fix(sdk): Upload encrypted media with application/octet-stream mime type

This is apparently the right way to do it, both because some HS expect only this mimetype and also so we don't leak the mime type of the encrypted media.

Author: jmartinesp

crates/matrix-sdk/src/encryption/futures.rs

@@ -31,21 +31,14 @@ use crate::{config::RequestConfig, Client, Media, Result, TransmissionProgress};
 #[allow(missing_debug_implementations)]
 pub struct UploadEncryptedFile<'a, R: ?Sized> {
     client: &'a Client,
-    content_type: &'a mime::Mime,
     reader: &'a mut R,
     send_progress: SharedObservable<TransmissionProgress>,
     request_config: Option<RequestConfig>,
 }
 
 impl<'a, R: ?Sized> UploadEncryptedFile<'a, R> {
-    pub(crate) fn new(client: &'a Client, content_type: &'a mime::Mime, reader: &'a mut R) -> Self {
-        Self {
-            client,
-            content_type,
-            reader,
-            send_progress: Default::default(),
-            request_config: None,
-        }
+    pub(crate) fn new(client: &'a Client, reader: &'a mut R) -> Self {
+        Self { client, reader, send_progress: Default::default(), request_config: None }
     }
 
     /// Replace the default `SharedObservable` used for tracking upload
@@ -87,7 +80,7 @@ where
     boxed_into_future!(extra_bounds: 'a);
 
     fn into_future(self) -> Self::IntoFuture {
-        let Self { client, content_type, reader, send_progress, request_config } = self;
+        let Self { client, reader, send_progress, request_config } = self;
         Box::pin(async move {
             let mut encryptor = matrix_sdk_base::crypto::AttachmentEncryptor::new(reader);
 
@@ -101,7 +94,7 @@ where
 
             let response = client
                 .media()
-                .upload(content_type, buf, request_config)
+                .upload(&mime::APPLICATION_OCTET_STREAM, buf, request_config)
                 .with_send_progress_observable(send_progress)
                 .await?;
 

crates/matrix-sdk/src/encryption/mod.rs

@@ -435,24 +435,22 @@ impl Client {
     /// # let client = Client::new(homeserver).await?;
     /// # let room = client.get_room(&room_id!("!test:example.com")).unwrap();
     /// let mut reader = std::io::Cursor::new(b"Hello, world!");
-    /// let encrypted_file = client.upload_encrypted_file(&mime::TEXT_PLAIN, &mut reader).await?;
+    /// let encrypted_file = client.upload_encrypted_file(&mut reader).await?;
     ///
     /// room.send(CustomEventContent { encrypted_file }).await?;
     /// # anyhow::Ok(()) };
     /// ```
     pub fn upload_encrypted_file<'a, R: Read + ?Sized + 'a>(
         &'a self,
-        content_type: &'a mime::Mime,
         reader: &'a mut R,
     ) -> UploadEncryptedFile<'a, R> {
-        UploadEncryptedFile::new(self, content_type, reader)
+        UploadEncryptedFile::new(self, reader)
     }
 
     /// Encrypt and upload the file and thumbnails, and return the source
     /// information.
     pub(crate) async fn upload_encrypted_media_and_thumbnail(
         &self,
-        content_type: &mime::Mime,
         data: &[u8],
         thumbnail: Option<Thumbnail>,
         send_progress: SharedObservable<TransmissionProgress>,
@@ -461,7 +459,7 @@ impl Client {
 
         let upload_attachment = async {
             let mut cursor = Cursor::new(data);
-            self.upload_encrypted_file(content_type, &mut cursor)
+            self.upload_encrypted_file(&mut cursor)
                 .with_send_progress_observable(send_progress)
                 .await
         };
@@ -482,11 +480,11 @@ impl Client {
             return Ok(None);
         };
 
-        let (data, content_type, thumbnail_info) = thumbnail.into_parts();
+        let (data, _, thumbnail_info) = thumbnail.into_parts();
         let mut cursor = Cursor::new(data);
 
         let file = self
-            .upload_encrypted_file(&content_type, &mut cursor)
+            .upload_encrypted_file(&mut cursor)
             .with_send_progress_observable(send_progress)
             .await?;
 

crates/matrix-sdk/src/room/mod.rs

@@ -2101,7 +2101,7 @@ impl Room {
         #[cfg(feature = "e2e-encryption")]
         let (media_source, thumbnail) = if self.latest_encryption_state().await?.is_encrypted() {
             self.client
-                .upload_encrypted_media_and_thumbnail(content_type, &data, thumbnail, send_progress)
+                .upload_encrypted_media_and_thumbnail(&data, thumbnail, send_progress)
                 .await?
         } else {
             self.client

crates/matrix-sdk/src/room/shared_room_history.rs

@@ -53,8 +53,7 @@ pub async fn share_room_history(room: &Room, user_id: OwnedUserId) -> Result<()>
 
     // 2. Upload to the server as an encrypted file
     let json = serde_json::to_vec(&bundle)?;
-    let upload =
-        client.upload_encrypted_file(&mime::APPLICATION_JSON, &mut (json.as_slice())).await?;
+    let upload = client.upload_encrypted_file(&mut (json.as_slice())).await?;
 
     info!(
         media_url = ?upload.url,

crates/matrix-sdk/src/send_queue/mod.rs

@@ -705,12 +705,6 @@ impl RoomSendQueue {
                 trace!(%relates_to, "uploading media related to event");
 
                 let fut = async move {
-                    let mime = Mime::from_str(&content_type).map_err(|_| {
-                        crate::Error::SendQueueWedgeError(Box::new(
-                            QueueWedgeError::InvalidMimeType { mime_type: content_type.clone() },
-                        ))
-                    })?;
-
                     let data = room
                         .client()
                         .event_cache_store()
@@ -722,13 +716,19 @@ impl RoomSendQueue {
                             QueueWedgeError::MissingMediaContent,
                         )))?;
 
+                    let mime = Mime::from_str(&content_type).map_err(|_| {
+                        crate::Error::SendQueueWedgeError(Box::new(
+                            QueueWedgeError::InvalidMimeType { mime_type: content_type.clone() },
+                        ))
+                    })?;
+
                     #[cfg(feature = "e2e-encryption")]
                     let media_source = if room.latest_encryption_state().await?.is_encrypted() {
                         trace!("upload will be encrypted (encrypted room)");
                         let mut cursor = std::io::Cursor::new(data);
                         let encrypted_file = room
                             .client()
-                            .upload_encrypted_file(&mime, &mut cursor)
+                            .upload_encrypted_file(&mut cursor)
                             .with_request_config(RequestConfig::short_retry())
                             .await?;
                         MediaSource::Encrypted(Box::new(encrypted_file))

crates/matrix-sdk/tests/integration/room/attachment/mod.rs

@@ -58,6 +58,42 @@ async fn test_room_attachment_send() {
     assert_eq!(expected_event_id, response.event_id);
 }
 
+#[cfg(feature = "e2e-encryption")]
+#[async_test]
+async fn test_room_attachment_send_in_encrypted_room_has_binary_mime_type() {
+    let mock = MatrixMockServer::new().await;
+
+    let expected_event_id = event_id!("$h29iv0s8:example.com");
+
+    mock.mock_room_send().ok(expected_event_id).mock_once().mount().await;
+
+    mock.mock_upload()
+        .expect_mime_type("application/octet-stream")
+        .ok(mxc_uri!("mxc://example.com/AQwafuaFswefuhsfAFAgsw"))
+        .up_to_n_times(2)
+        .mount()
+        .await;
+
+    // Needed for the message to be sent in an encrypted room
+    mock.mock_get_members().ok(Vec::new()).mock_once().mount().await;
+
+    let client = mock.client_builder().build().await;
+    let room = mock.sync_joined_room(&client, &DEFAULT_TEST_ROOM_ID).await;
+    mock.mock_room_state_encryption().encrypted().mount().await;
+
+    let response = room
+        .send_attachment(
+            "image",
+            &mime::IMAGE_JPEG,
+            b"Hello world".to_vec(),
+            AttachmentConfig::new(),
+        )
+        .await
+        .expect("Failed to send attachment");
+
+    assert_eq!(expected_event_id, response.event_id);
+}
+
 #[async_test]
 async fn test_room_attachment_send_info() {
     let mock = MatrixMockServer::new().await;