feature(client-lib): compute cardano database message verify tampered files

Author: Clément Turmel

mithril-client/src/cardano_database_client/proving.rs

@@ -32,34 +32,40 @@ pub struct VerifiedDigests {
     pub merkle_tree: MKTree<MKTreeStoreInMemory>,
 }
 
+/// Represents the immutable files that were not verified during the digest verification process.
 #[derive(PartialEq, Debug)]
-pub(crate) struct InvalidImmutableFiles {
+pub(crate) struct ImmutableFilesNotVerified {
+    /// List of immutable files that were tampered (i.e. their digest does not match the verified digest)
     pub tampered_files: Vec<ImmutableFileName>,
+    /// List of immutable files that could not be verified (i.e., not present in the digests)
     pub non_verifiable_files: Vec<ImmutableFileName>,
 }
 
 impl VerifiedDigests {
-    pub(crate) fn list_tampered_immutable_files(
+    pub(crate) fn list_immutable_files_not_verified(
         &self,
-        computed_digests: &BTreeMap<ImmutableFileName, HexEncodedDigest>,
-    ) -> MithrilResult<InvalidImmutableFiles> {
+        computed_digests: &BTreeMap<ImmutableFile, HexEncodedDigest>,
+    ) -> ImmutableFilesNotVerified {
         let mut tampered_files = vec![];
         let mut non_verifiable_files = vec![];
 
-        computed_digests.iter().for_each(|(immutable_file_name, digest)| {
-            if let Some(verified_digest) = self.digests.get(immutable_file_name) {
-                if verified_digest != digest {
-                    tampered_files.push(immutable_file_name.clone());
+        for (immutable_file, digest) in computed_digests.iter() {
+            let immutable_file_name_to_verify = immutable_file.filename.clone();
+            match self.digests.get(&immutable_file_name_to_verify) {
+                Some(verified_digest) if verified_digest != digest => {
+                    tampered_files.push(immutable_file_name_to_verify);
                 }
-            } else {
-                non_verifiable_files.push(immutable_file_name.clone());
+                None => {
+                    non_verifiable_files.push(immutable_file_name_to_verify);
+                }
+                _ => {}
             }
-        });
+        }
 
-        Ok(InvalidImmutableFiles {
+        ImmutableFilesNotVerified {
             tampered_files,
             non_verifiable_files,
-        })
+        }
     }
 }
 
@@ -97,7 +103,7 @@ impl InternalArtifactProver {
         Ok(())
     }
 
-    ///Download digests and verify its authenticity against the certificate.
+    /// Download digests and verify its authenticity against the certificate.
     pub async fn download_and_verify_digests(
         &self,
         certificate: &CertificateMessage,
@@ -242,15 +248,23 @@ mod tests {
 
     use super::*;
 
-    mod list_tampered_immutable_files {
+    mod list_immutable_files_not_verified {
 
         use super::*;
 
+        fn fake_immutable(filename: &str) -> ImmutableFile {
+            ImmutableFile {
+                path: PathBuf::from("whatever"),
+                number: 1,
+                filename: filename.to_string(),
+            }
+        }
+
         #[test]
         fn should_return_empty_list_when_no_tampered_files() {
             let digests_to_verify = BTreeMap::from([
-                ("00001.chunk".to_string(), "digest-1".to_string()),
-                ("00002.chunk".to_string(), "digest-2".to_string()),
+                (fake_immutable("00001.chunk"), "digest-1".to_string()),
+                (fake_immutable("00002.chunk"), "digest-2".to_string()),
             ]);
 
             let verified_digests = VerifiedDigests {
@@ -261,13 +275,12 @@ mod tests {
                 merkle_tree: MKTree::new(&["whatever"]).unwrap(),
             };
 
-            let invalid_files = verified_digests
-                .list_tampered_immutable_files(&digests_to_verify)
-                .unwrap();
+            let invalid_files =
+                verified_digests.list_immutable_files_not_verified(&digests_to_verify);
 
             assert_eq!(
                 invalid_files,
-                InvalidImmutableFiles {
+                ImmutableFilesNotVerified {
                     tampered_files: vec![],
                     non_verifiable_files: vec![],
                 }
@@ -277,8 +290,8 @@ mod tests {
         #[test]
         fn should_return_list_with_tampered_files() {
             let digests_to_verify = BTreeMap::from([
-                ("00001.chunk".to_string(), "digest-1".to_string()),
-                ("00002.chunk".to_string(), "digest-2".to_string()),
+                (fake_immutable("00001.chunk"), "digest-1".to_string()),
+                (fake_immutable("00002.chunk"), "digest-2".to_string()),
             ]);
 
             let verified_digests = VerifiedDigests {
@@ -289,13 +302,12 @@ mod tests {
                 merkle_tree: MKTree::new(&["whatever"]).unwrap(),
             };
 
-            let invalid_files = verified_digests
-                .list_tampered_immutable_files(&digests_to_verify)
-                .unwrap();
+            let invalid_files =
+                verified_digests.list_immutable_files_not_verified(&digests_to_verify);
 
             assert_eq!(
                 invalid_files,
-                InvalidImmutableFiles {
+                ImmutableFilesNotVerified {
                     tampered_files: vec!["00002.chunk".to_string()],
                     non_verifiable_files: vec![],
                 }
@@ -305,22 +317,24 @@ mod tests {
         #[test]
         fn should_return_list_with_non_verifiable() {
             let digests_to_verify = BTreeMap::from([
-                ("00001.chunk".to_string(), "digest-1".to_string()),
-                ("00002.not.verifiable".to_string(), "digest-2".to_string()),
+                (fake_immutable("00001.chunk"), "digest-1".to_string()),
+                (
+                    fake_immutable("00002.not.verifiable"),
+                    "digest-2".to_string(),
+                ),
             ]);
 
             let verified_digests = VerifiedDigests {
                 digests: BTreeMap::from([("00001.chunk".to_string(), "digest-1".to_string())]),
                 merkle_tree: MKTree::new(&["whatever"]).unwrap(),
             };
 
-            let invalid_files = verified_digests
-                .list_tampered_immutable_files(&digests_to_verify)
-                .unwrap();
+            let invalid_files =
+                verified_digests.list_immutable_files_not_verified(&digests_to_verify);
 
             assert_eq!(
                 invalid_files,
-                InvalidImmutableFiles {
+                ImmutableFilesNotVerified {
                     tampered_files: vec![],
                     non_verifiable_files: vec!["00002.not.verifiable".to_string()],
                 }