test: [#261]: do not allow uploading two torrents with the same canonical infohash

If you upload a torrent, the infohash migth change if the `info`
dictionary contains custom fields. The Index removes non-standard custom
fields, and that generates a new infohash for the torrent.

If you upload a second torrent which is different from a previous one
only in the custom fields, the same canonical infohash will be
generated, so the torrent will be rejected as duplicated. The new
original infohash will be stored in the database.

Author: josecelano

tests/common/contexts/torrent/file.rs

@@ -8,21 +8,21 @@ use serde::Deserialize;
 use which::which;
 
 /// Attributes parsed from a torrent file.
-#[derive(Deserialize, Clone)]
+#[derive(Deserialize, Clone, Debug)]
 pub struct TorrentFileInfo {
     pub name: String,
     pub comment: Option<String>,
-    pub creation_date: u64,
-    pub created_by: String,
+    pub creation_date: Option<u64>,
+    pub created_by: Option<String>,
     pub source: Option<String>,
     pub info_hash: String,
     pub torrent_size: u64,
     pub content_size: u64,
     pub private: bool,
     pub tracker: Option<String>,
-    pub announce_list: Vec<Vec<String>>,
+    pub announce_list: Option<Vec<Vec<String>>>,
     pub update_url: Option<String>,
-    pub dht_nodes: Vec<String>,
+    pub dht_nodes: Option<Vec<String>>,
     pub piece_size: u64,
     pub piece_count: u64,
     pub file_count: u64,

tests/common/contexts/torrent/fixtures.rs

@@ -2,7 +2,11 @@ use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
+use serde::{Deserialize, Serialize};
+use serde_bytes::ByteBuf;
 use tempfile::{tempdir, TempDir};
+use torrust_index_backend::services::hasher::sha1;
+use torrust_index_backend::utils::hex::into_bytes;
 use uuid::Uuid;
 
 use super::file::{create_torrent, parse_torrent, TorrentFileInfo};
@@ -94,6 +98,45 @@ impl TestTorrent {
         }
     }
 
+    pub fn with_custom_info_dict_field(id: Uuid, file_contents: &str, custom: &str) -> Self {
+        let temp_dir = temp_dir();
+
+        let torrents_dir_path = temp_dir.path().to_owned();
+
+        // Create the torrent in memory
+        let torrent = TestTorrentWithCustomInfoField::with_contents(id, file_contents, custom);
+
+        // Bencode the torrent
+        let torrent_data = TestTorrentWithCustomInfoField::encode(&torrent).unwrap();
+
+        // Torrent temporary file path
+        let filename = format!("file-{id}.txt.torrent");
+        let torrent_path = torrents_dir_path.join(filename.clone());
+
+        // Write the torrent file to the temporary file
+        let mut file = File::create(torrent_path.clone()).unwrap();
+        file.write_all(&torrent_data).unwrap();
+
+        // Load torrent binary file
+        let torrent_file = BinaryFile::from_file_at_path(&torrent_path);
+
+        // Load torrent file metadata
+        let torrent_info = parse_torrent(&torrent_path);
+
+        let torrent_to_index = TorrentIndexInfo {
+            title: format!("title-{id}"),
+            description: format!("description-{id}"),
+            category: software_predefined_category_name(),
+            torrent_file,
+            name: filename,
+        };
+
+        TestTorrent {
+            file_info: torrent_info,
+            index_info: torrent_to_index,
+        }
+    }
+
     pub fn info_hash(&self) -> InfoHash {
         self.file_info.info_hash.clone()
     }
@@ -128,3 +171,65 @@ pub fn random_txt_file(dir: &Path, id: &Uuid) -> String {
 pub fn temp_dir() -> TempDir {
     tempdir().unwrap()
 }
+
+/// A minimal torrent file with a custom field in the info dict.
+///
+/// ```json
+/// {
+///     "info": {
+///        "length": 602515,
+///        "name": "mandelbrot_set_01",
+///        "piece length": 32768,
+///        "pieces": "<hex>8A 88 32 BE ED 05 5F AA C4 AF 4A 90 4B 9A BF 0D EC 83 42 1C 73 39 05 B8 D6 20 2C 1B D1 8A 53 28 1F B5 D4 23 0A 23 C8 DB AC C4 E6 6B 16 12 08 C7 A4 AD 64 45 70 ED 91 0D F1 38 E7 DF 0C 1A D0 C9 23 27 7C D1 F9 D4 E5 A1 5F F5 E5 A0 E4 9E FB B1 43 F5 4B AD 0E D4 9D CB 49 F7 E6 7B BA 30 5F AF F9 88 56 FB 45 9A B4 95 92 3E 2C 7F DA A6 D3 82 E7 63 A3 BB 4B 28 F3 57 C7 CB 7D 8C 06 E3 46 AB D7 E8 8E 8A 8C 9F C7 E6 C5 C5 64 82 ED 47 BB 2A F1 B7 3F A5 3C 5B 9C AF 43 EC 2A E1 08 68 9A 49 C8 BF 1B 07 AD BE E9 2D 7E BE 9C 18 7F 4C A1 97 0E 54 3A 18 94 0E 60 8D 5C 69 0E 41 46 0D 3C 9A 37 F6 81 62 4F 95 C0 73 92 CA 9A D5 A9 89 AC 8B 85 12 53 0B FB E2 96 26 3E 26 A6 5B 70 53 48 65 F3 6C 27 0F 6B BD 1C EE EB 1A 9D 5F 77 A8 D8 AF D8 14 82 4A E0 B4 62 BC F1 A5 F5 F2 C7 60 F8 38 C8 5B 0B A9 07 DD 86 FA C0 7B F0 26 D7 D1 9A 42 C3 1F 9F B9 59 83 10 62 41 E9 06 3C 6D A1 19 75 01 57 25 9E B7 FE DF 91 04 D4 51 4B 6D 44 02 8D 31 8E 84 26 95 0F 30 31 F0 2C 16 39 BD 53 1D CF D3 5E 3E 41 A9 1E 14 3F 73 24 AC 5E 9E FC 4D C5 70 45 0F 45 8B 9B 52 E6 D0 26 47 8F 43 08 9E 2A 7C C5 92 D5 86 36 FE 48 E9 B8 86 84 92 23 49 5B EE C4 31 B2 1D 10 75 8E 4C 07 84 8F</hex>",
+///        "custom": "custom03"
+///     }
+/// }
+/// ```
+///
+/// Changing the value of the `custom` field will change the info-hash of the torrent.
+#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+pub struct TestTorrentWithCustomInfoField {
+    pub info: InfoDictWithCustomField,
+}
+
+/// A minimal torrent info dict with a custom field.
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+pub struct InfoDictWithCustomField {
+    #[serde(default)]
+    pub length: i64,
+    #[serde(default)]
+    pub name: String,
+    #[serde(rename = "piece length")]
+    pub piece_length: i64,
+    #[serde(default)]
+    pub pieces: ByteBuf,
+    #[serde(default)]
+    pub custom: String,
+}
+
+impl TestTorrentWithCustomInfoField {
+    pub fn with_contents(id: Uuid, file_contents: &str, custom: &str) -> Self {
+        let sha1_of_file_contents = sha1(file_contents);
+        let pieces = into_bytes(&sha1_of_file_contents).expect("sha1 of test torrent contents cannot be converted to bytes");
+
+        Self {
+            info: InfoDictWithCustomField {
+                length: i64::try_from(file_contents.len()).expect("file contents size in bytes cannot exceed i64::MAX"),
+                name: format!("file-{id}.txt"),
+                piece_length: 16384,
+                pieces: ByteBuf::from(pieces),
+                custom: custom.to_owned(),
+            },
+        }
+    }
+
+    pub fn encode(torrent: &Self) -> Result<Vec<u8>, serde_bencode::Error> {
+        match serde_bencode::to_bytes(torrent) {
+            Ok(bencode_bytes) => Ok(bencode_bytes),
+            Err(e) => {
+                eprintln!("{e:?}");
+                Err(e)
+            }
+        }
+    }
+}

tests/e2e/web/api/v1/contexts/torrent/contract.rs

@@ -293,10 +293,11 @@ mod for_authenticated_users {
 
     use torrust_index_backend::utils::parse_torrent::decode_torrent;
     use torrust_index_backend::web::api;
+    use uuid::Uuid;
 
     use crate::common::asserts::assert_json_error_response;
     use crate::common::client::Client;
-    use crate::common::contexts::torrent::fixtures::random_torrent;
+    use crate::common::contexts::torrent::fixtures::{random_torrent, TestTorrent};
     use crate::common::contexts::torrent::forms::UploadTorrentMultipartForm;
     use crate::common::contexts::torrent::responses::UploadedTorrentResponse;
     use crate::e2e::environment::TestEnv;
@@ -410,6 +411,38 @@ mod for_authenticated_users {
         assert_eq!(response.status, 400);
     }
 
+    #[tokio::test]
+    async fn it_should_not_allow_uploading_a_torrent_whose_canonical_info_hash_already_exists() {
+        let mut env = TestEnv::new();
+        env.start(api::Version::V1).await;
+
+        if !env.provides_a_tracker() {
+            println!("test skipped. It requires a tracker to be running.");
+            return;
+        }
+
+        let uploader = new_logged_in_user(&env).await;
+        let client = Client::authenticated(&env.server_socket_addr().unwrap(), &uploader.token);
+
+        let id1 = Uuid::new_v4();
+
+        // Upload the first torrent
+        let first_torrent = TestTorrent::with_custom_info_dict_field(id1, "data", "custom 01");
+        let first_torrent_title = first_torrent.index_info.title.clone();
+        let form: UploadTorrentMultipartForm = first_torrent.index_info.into();
+        let _response = client.upload_torrent(form.into()).await;
+
+        // Upload the second torrent with the same canonical info-hash as the first one.
+        // We need to change the title otherwise the torrent will be rejected
+        // because of the duplicate title.
+        let mut torrent_with_the_same_canonical_info_hash = TestTorrent::with_custom_info_dict_field(id1, "data", "custom 02");
+        torrent_with_the_same_canonical_info_hash.index_info.title = format!("{first_torrent_title}-clone");
+        let form: UploadTorrentMultipartForm = torrent_with_the_same_canonical_info_hash.index_info.into();
+        let response = client.upload_torrent(form.into()).await;
+
+        assert_eq!(response.status, 400);
+    }
+
     #[tokio::test]
     async fn it_should_allow_authenticated_users_to_download_a_torrent_with_a_personal_announce_url() {
         let mut env = TestEnv::new();