test: re-enable large file roundtrip tests and kdbx4 tests

sseemayer · sseemayer · commit 7d75de4c9143 · 2025-09-20T22:28:48.000+02:00
diff --git a/src/db/types/mod.rs b/src/db/types/mod.rs
@@ -112,6 +112,10 @@ impl Database {
         self.group_mut(recyclebin_id)
     }
 
+    pub fn num_attachments(&self) -> usize {
+        self.attachments.len()
+    }
+
     pub fn num_entries(&self) -> usize {
         self.entries.len()
     }
diff --git a/src/format/kdbx4/mod.rs b/src/format/kdbx4/mod.rs
@@ -58,186 +58,181 @@ struct KDBX4InnerHeader {
     inner_random_stream_key: Vec<u8>,
 }
 
-//#[cfg(feature = "save_kdbx4")]
-//#[cfg(test)]
-//mod kdbx4_tests {
-//    use super::*;
-//
-//    use crate::format::kdbx4::dump::dump_kdbx4;
-//    use crate::{
-//        config::{CompressionConfig, DatabaseConfig, InnerCipherConfig, KdfConfig, OuterCipherConfig},
-//        db::{Database, Entry, Group, HeaderAttachment, NodeRef, Value},
-//        format::KDBX4_CURRENT_MINOR_VERSION,
-//        key::DatabaseKey,
-//    };
-//
-//    #[cfg(feature = "challenge_response")]
-//    #[test]
-//    fn test_with_challenge_response() {
-//        let mut db = Database::new(DatabaseConfig::default());
-//
-//        let mut root_group = Group::new("Root");
-//        root_group.add_child(Entry::new());
-//        root_group.add_child(Entry::new());
-//        root_group.add_child(Entry::new());
-//        db.root = root_group;
-//
-//        let mut password_bytes: Vec<u8> = vec![];
-//        let mut password: String = "".to_string();
-//        password_bytes.resize(40, 0);
-//        getrandom::fill(&mut password_bytes).unwrap();
-//        for random_char in password_bytes {
-//            password += &std::char::from_u32(random_char as u32).unwrap().to_string();
-//        }
-//
-//        let db_key = DatabaseKey::new()
-//            .with_password(&password)
-//            .with_challenge_response_key(crate::key::ChallengeResponseKey::LocalChallenge(
-//                "0102030405060708090a0b0c0d0e0f1011121314".to_string(),
-//            ));
-//
-//        let mut encrypted_db = Vec::new();
-//        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
-//
-//        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
-//
-//        assert_eq!(decrypted_db.root.children.len(), 3);
-//    }
-//
-//    fn test_with_config(config: DatabaseConfig) {
-//        let mut db = Database::new(config);
-//
-//        let mut root_group = Group::new("Root");
-//
-//        let mut entry_with_password = Entry::new();
-//        entry_with_password
-//            .fields
-//            .insert("Title".to_string(), Value::Unprotected("Demo Entry".into()));
-//
-//        entry_with_password
-//            .fields
-//            .insert("Password".to_string(), Value::Protected("secret".into()));
-//
-//        root_group.add_child(entry_with_password);
-//        root_group.add_child(Entry::new());
-//        root_group.add_child(Entry::new());
-//        db.root = root_group;
-//
-//        let mut password_bytes: Vec<u8> = vec![];
-//        let mut password: String = "".to_string();
-//        password_bytes.resize(40, 0);
-//        getrandom::fill(&mut password_bytes).unwrap();
-//        for random_char in password_bytes {
-//            password += &std::char::from_u32(random_char as u32).unwrap().to_string();
-//        }
-//
-//        let db_key = DatabaseKey::new().with_password(&password);
-//
-//        let mut encrypted_db = Vec::new();
-//        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
-//
-//        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
-//
-//        assert_eq!(decrypted_db.root.children.len(), 3);
-//
-//        if let Some(NodeRef::Entry(e)) = decrypted_db.root.get(&["Demo Entry"]) {
-//            assert_eq!(e.get_password(), Some("secret"));
-//        } else {
-//            panic!("Could not get NodeRef")
-//        }
-//    }
-//
-//    #[test]
-//    pub fn test_config_matrix() {
-//        let outer_cipher_configs = [
-//            OuterCipherConfig::AES256,
-//            OuterCipherConfig::Twofish,
-//            OuterCipherConfig::ChaCha20,
-//        ];
-//
-//        let compression_configs = [CompressionConfig::None, CompressionConfig::GZip];
-//
-//        let inner_cipher_configs = [
-//            InnerCipherConfig::Plain,
-//            InnerCipherConfig::Salsa20,
-//            InnerCipherConfig::ChaCha20,
-//        ];
-//
-//        let kdf_configs = [
-//            KdfConfig::Aes { rounds: 10 },
-//            KdfConfig::Argon2 {
-//                iterations: 10,
-//                memory: 65536,
-//                parallelism: 2,
-//                version: argon2::Version::Version13,
-//            },
-//            KdfConfig::Argon2id {
-//                iterations: 10,
-//                memory: 65536,
-//                parallelism: 2,
-//                version: argon2::Version::Version13,
-//            },
-//        ];
-//
-//        for outer_cipher_config in &outer_cipher_configs {
-//            for compression_config in &compression_configs {
-//                for inner_cipher_config in &inner_cipher_configs {
-//                    for kdf_config in &kdf_configs {
-//                        let config = DatabaseConfig {
-//                            version: DatabaseVersion::KDB4(KDBX4_CURRENT_MINOR_VERSION),
-//                            outer_cipher_config: outer_cipher_config.clone(),
-//                            compression_config: compression_config.clone(),
-//                            inner_cipher_config: inner_cipher_config.clone(),
-//                            kdf_config: kdf_config.clone(),
-//                            public_custom_data: Default::default(),
-//                        };
-//
-//                        println!("Testing with config: {config:?}");
-//
-//                        test_with_config(config);
-//                    }
-//                }
-//            }
-//        }
-//    }
-//
-//    #[test]
-//    pub fn header_attachments() {
-//        let mut root_group = Group::new("Root");
-//        root_group.add_child(Entry::new());
-//
-//        let mut db = Database::new(DatabaseConfig::default());
-//
-//        db.header_attachments = vec![
-//            HeaderAttachment {
-//                flags: 1,
-//                content: vec![0x01, 0x02, 0x03, 0x04],
-//            },
-//            HeaderAttachment {
-//                flags: 2,
-//                content: vec![0x04, 0x03, 0x02, 0x01],
-//            },
-//        ];
-//
-//        let mut entry = Entry::new();
-//        entry
-//            .fields
-//            .insert("Title".to_string(), Value::Unprotected("Demo entry".to_string()));
-//
-//        db.root.add_child(entry);
-//
-//        let db_key = DatabaseKey::new().with_password("test");
-//
-//        let mut encrypted_db = Vec::new();
-//        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
-//
-//        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
-//
-//        assert_eq!(decrypted_db.root.children.len(), 1);
-//
-//        let header_attachments = &decrypted_db.header_attachments;
-//        assert_eq!(header_attachments.len(), 2);
-//        assert_eq!(header_attachments[0].flags, 1);
-//        assert_eq!(header_attachments[0].content, [0x01, 0x02, 0x03, 0x04]);
-//    }
-//}
+#[cfg(feature = "save_kdbx4")]
+#[cfg(test)]
+mod kdbx4_tests {
+    use super::*;
+
+    use crate::db::fields;
+    use crate::format::kdbx4::dump::dump_kdbx4;
+    use crate::{
+        config::{CompressionConfig, DatabaseConfig, InnerCipherConfig, KdfConfig, OuterCipherConfig},
+        db::{Database, Entry, Group, Value},
+        format::KDBX4_CURRENT_MINOR_VERSION,
+        key::DatabaseKey,
+    };
+
+    #[cfg(feature = "challenge_response")]
+    #[test]
+    fn test_with_challenge_response() {
+        let mut db = Database::new();
+
+        let mut root = db.root_mut();
+        root.add_entry();
+        root.add_entry();
+        root.add_entry();
+
+        let mut password_bytes: Vec<u8> = vec![];
+        let mut password: String = "".to_string();
+        password_bytes.resize(40, 0);
+        getrandom::fill(&mut password_bytes).unwrap();
+        for random_char in password_bytes {
+            password += &std::char::from_u32(random_char as u32).unwrap().to_string();
+        }
+
+        let db_key = DatabaseKey::new()
+            .with_password(&password)
+            .with_challenge_response_key(crate::key::ChallengeResponseKey::LocalChallenge(
+                "0102030405060708090a0b0c0d0e0f1011121314".to_string(),
+            ));
+
+        let mut encrypted_db = Vec::new();
+        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
+
+        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
+
+        assert_eq!(decrypted_db.num_entries(), 3);
+    }
+
+    fn test_with_config(config: DatabaseConfig) {
+        let mut db = Database::new();
+        db.config = config;
+
+        let mut root = db.root_mut();
+
+        let mut entry_with_password = root.add_entry();
+        entry_with_password.set_unprotected(fields::TITLE, "Demo Entry");
+        entry_with_password.set_protected(fields::PASSWORD, "secret");
+
+        root.add_entry();
+        root.add_entry();
+
+        let mut password_bytes: Vec<u8> = vec![];
+        let mut password: String = "".to_string();
+        password_bytes.resize(40, 0);
+        getrandom::fill(&mut password_bytes).unwrap();
+        for random_char in password_bytes {
+            password += &std::char::from_u32(random_char as u32).unwrap().to_string();
+        }
+
+        let db_key = DatabaseKey::new().with_password(&password);
+
+        let mut encrypted_db = Vec::new();
+        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
+
+        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
+
+        assert_eq!(decrypted_db.num_entries(), 3);
+
+        let decrypted_root = decrypted_db.root();
+        let the_entry = decrypted_root
+            .entry_by_name("Demo Entry")
+            .expect("Could not find entry");
+
+        assert_eq!(the_entry.get_str(fields::PASSWORD), Some("secret"));
+    }
+
+    #[test]
+    pub fn test_config_matrix() {
+        let outer_cipher_configs = [
+            OuterCipherConfig::AES256,
+            OuterCipherConfig::Twofish,
+            OuterCipherConfig::ChaCha20,
+        ];
+
+        let compression_configs = [CompressionConfig::None, CompressionConfig::GZip];
+
+        let inner_cipher_configs = [
+            InnerCipherConfig::Plain,
+            InnerCipherConfig::Salsa20,
+            InnerCipherConfig::ChaCha20,
+        ];
+
+        let kdf_configs = [
+            KdfConfig::Aes { rounds: 10 },
+            KdfConfig::Argon2 {
+                iterations: 10,
+                memory: 65536,
+                parallelism: 2,
+                version: argon2::Version::Version13,
+            },
+            KdfConfig::Argon2id {
+                iterations: 10,
+                memory: 65536,
+                parallelism: 2,
+                version: argon2::Version::Version13,
+            },
+        ];
+
+        for outer_cipher_config in &outer_cipher_configs {
+            for compression_config in &compression_configs {
+                for inner_cipher_config in &inner_cipher_configs {
+                    for kdf_config in &kdf_configs {
+                        let config = DatabaseConfig {
+                            version: DatabaseVersion::KDB4(KDBX4_CURRENT_MINOR_VERSION),
+                            outer_cipher_config: outer_cipher_config.clone(),
+                            compression_config: compression_config.clone(),
+                            inner_cipher_config: inner_cipher_config.clone(),
+                            kdf_config: kdf_config.clone(),
+                            public_custom_data: Default::default(),
+                        };
+
+                        println!("Testing with config: {config:?}");
+
+                        test_with_config(config);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    pub fn header_attachments() {
+        let mut db = Database::new();
+
+        let mut root = db.root_mut();
+
+        let mut entry = root.add_entry();
+        entry.set_unprotected(fields::TITLE, "Demo entry");
+        entry.set_protected(fields::PASSWORD, "secret");
+
+        let mut attachment1 = entry.add_attachment();
+        attachment1.name = "hello.txt".to_string();
+        attachment1.set_data(b"Hello, World!".to_vec());
+
+        let mut attachment2 = entry.add_attachment();
+        attachment2.name = "image.png".to_string();
+        attachment2.set_data(vec![0x89, 0x50, 0x4E, 0x47]);
+
+        let db_key = DatabaseKey::new().with_password("test");
+
+        let mut encrypted_db = Vec::new();
+        dump_kdbx4(&db, &db_key, &mut encrypted_db).unwrap();
+
+        let decrypted_db = parse_kdbx4(&encrypted_db, &db_key).unwrap();
+
+        assert_eq!(decrypted_db.num_entries(), 1);
+        assert_eq!(decrypted_db.num_attachments(), 2);
+
+        let decrypted_root = decrypted_db.root();
+        let the_entry = decrypted_root
+            .entry_by_name("Demo entry")
+            .expect("Could not find entry");
+
+        the_entry.attachments().for_each(|a| match a.name.as_str() {
+            "hello.txt" => assert_eq!(a.data(), &b"Hello, World!"[..]),
+            "image.png" => assert_eq!(a.data(), &[0x89, 0x50, 0x4E, 0x47][..]),
+            _ => panic!("Unexpected attachment name"),
+        });
+    }
+}
diff --git a/tests/file_read_tests.rs b/tests/file_read_tests.rs
@@ -1,10 +1,7 @@
 mod file_read_tests {
 
     use anyhow::Result;
-    use keepass::{
-        db::{Database, GroupId},
-        DatabaseKey,
-    };
+    use keepass::{db::Database, DatabaseKey};
     use uuid::uuid;
 
     use std::{fs::File, path::Path};
diff --git a/tests/large_database_roundtrip_tests.rs b/tests/large_database_roundtrip_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,10 @@ impl Database {`
`112`	`112`	`self.group_mut(recyclebin_id)`
`113`	`113`	`}`
`114`	`114`
	`115`	`+ pub fn num_attachments(&self) -> usize {`
	`116`	`+ self.attachments.len()`
	`117`	`+ }`
	`118`	`+`
`115`	`119`	`pub fn num_entries(&self) -> usize {`
`116`	`120`	`self.entries.len()`
`117`	`121`	`}`