diff --git a/crates/abcrypt/benches/argon2_context.rs b/crates/abcrypt/benches/argon2_context.rs index 1cf8dfe1..ce65a553 100644 --- a/crates/abcrypt/benches/argon2_context.rs +++ b/crates/abcrypt/benches/argon2_context.rs @@ -10,7 +10,7 @@ use abcrypt::Argon2; use test::Bencher; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); #[bench] fn params(b: &mut Bencher) { diff --git a/crates/abcrypt/benches/decrypt.rs b/crates/abcrypt/benches/decrypt.rs index a3f96197..81dbdd42 100644 --- a/crates/abcrypt/benches/decrypt.rs +++ b/crates/abcrypt/benches/decrypt.rs @@ -11,7 +11,7 @@ use test::Bencher; const PASSPHRASE: &str = "passphrase"; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); #[bench] fn decrypt(b: &mut Bencher) { diff --git a/crates/abcrypt/benches/params.rs b/crates/abcrypt/benches/params.rs index ef140bda..9e1c7fc3 100644 --- a/crates/abcrypt/benches/params.rs +++ b/crates/abcrypt/benches/params.rs @@ -10,7 +10,7 @@ use abcrypt::Params; use test::Bencher; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); #[bench] fn params(b: &mut Bencher) { diff --git a/crates/abcrypt/src/argon2_context.rs b/crates/abcrypt/src/argon2_context.rs index e9e5bf66..e41a5183 100644 --- a/crates/abcrypt/src/argon2_context.rs +++ b/crates/abcrypt/src/argon2_context.rs @@ -35,7 +35,7 @@ impl Argon2 { /// ``` /// # use abcrypt::Argon2; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// assert!(Argon2::new(ciphertext).is_ok()); /// ``` @@ -57,7 +57,7 @@ impl Argon2 { /// ``` /// # use abcrypt::{argon2::Algorithm, Argon2}; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// let argon2 = Argon2::new(ciphertext).unwrap(); /// assert_eq!(argon2.variant(), Algorithm::Argon2id); @@ -75,7 +75,7 @@ impl Argon2 { /// ``` /// # use abcrypt::{argon2::Version, Argon2}; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// let argon2 = Argon2::new(ciphertext).unwrap(); /// assert_eq!(argon2.version(), Version::V0x13); diff --git a/crates/abcrypt/src/decrypt.rs b/crates/abcrypt/src/decrypt.rs index 698abecd..fba3c3df 100644 --- a/crates/abcrypt/src/decrypt.rs +++ b/crates/abcrypt/src/decrypt.rs @@ -43,7 +43,7 @@ impl<'c> Decryptor<'c> { /// ``` /// # use abcrypt::Decryptor; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// let passphrase = "passphrase"; /// /// let cipher = Decryptor::new(&ciphertext, passphrase).unwrap(); @@ -109,7 +109,7 @@ impl<'c> Decryptor<'c> { /// # use abcrypt::Decryptor; /// # /// let data = b"Hello, world!\n"; - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// let passphrase = "passphrase"; /// /// let cipher = Decryptor::new(&ciphertext, passphrase).unwrap(); @@ -147,7 +147,7 @@ impl<'c> Decryptor<'c> { /// # use abcrypt::Decryptor; /// # /// let data = b"Hello, world!\n"; - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// let passphrase = "passphrase"; /// /// let cipher = Decryptor::new(&ciphertext, passphrase).unwrap(); @@ -169,7 +169,7 @@ impl<'c> Decryptor<'c> { /// ``` /// # use abcrypt::Decryptor; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// let passphrase = "passphrase"; /// /// let cipher = Decryptor::new(&ciphertext, passphrase).unwrap(); @@ -206,7 +206,7 @@ impl<'c> Decryptor<'c> { /// /// ``` /// let data = b"Hello, world!\n"; -/// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); +/// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// let passphrase = "passphrase"; /// /// let plaintext = abcrypt::decrypt(ciphertext, passphrase).unwrap(); diff --git a/crates/abcrypt/src/params.rs b/crates/abcrypt/src/params.rs index c1557af6..80e0cd64 100644 --- a/crates/abcrypt/src/params.rs +++ b/crates/abcrypt/src/params.rs @@ -36,7 +36,7 @@ impl Params { /// ``` /// # use abcrypt::Params; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// assert!(Params::new(ciphertext).is_ok()); /// ``` @@ -56,7 +56,7 @@ impl Params { /// ``` /// # use abcrypt::Params; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// let params = Params::new(ciphertext).unwrap(); /// assert_eq!(params.memory_cost(), 32); @@ -74,7 +74,7 @@ impl Params { /// ``` /// # use abcrypt::Params; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// let params = Params::new(ciphertext).unwrap(); /// assert_eq!(params.time_cost(), 3); @@ -92,7 +92,7 @@ impl Params { /// ``` /// # use abcrypt::Params; /// # - /// let ciphertext = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + /// let ciphertext = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); /// /// let params = Params::new(ciphertext).unwrap(); /// assert_eq!(params.parallelism(), 4); diff --git a/crates/abcrypt/tests/argon2_context.rs b/crates/abcrypt/tests/argon2_context.rs index 08cc9c78..afa25cff 100644 --- a/crates/abcrypt/tests/argon2_context.rs +++ b/crates/abcrypt/tests/argon2_context.rs @@ -8,7 +8,7 @@ use abcrypt::{ }; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/argon2id/v0x13/data.txt.abcrypt"); #[test] fn success() { @@ -18,12 +18,58 @@ fn success() { #[test] fn variant() { - let argon2 = Argon2::new(TEST_DATA_ENC).unwrap(); - assert_eq!(argon2.variant(), Algorithm::Argon2id); + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + } + { + let argon2 = + Argon2::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + } + { + let argon2 = Argon2::new(TEST_DATA_ENC).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + } } #[test] fn version() { - let argon2 = Argon2::new(TEST_DATA_ENC).unwrap(); - assert_eq!(argon2.version(), Version::V0x13); + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.version(), Version::V0x10); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.version(), Version::V0x13); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.version(), Version::V0x10); + } + { + let argon2 = Argon2::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.version(), Version::V0x13); + } + { + let argon2 = + Argon2::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(argon2.version(), Version::V0x10); + } + { + let argon2 = Argon2::new(TEST_DATA_ENC).unwrap(); + assert_eq!(argon2.version(), Version::V0x13); + } } diff --git a/crates/abcrypt/tests/data/v1/argon2d/v0x10/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2d/v0x10/data.txt.abcrypt new file mode 100644 index 00000000..c34dca4a Binary files /dev/null and b/crates/abcrypt/tests/data/v1/argon2d/v0x10/data.txt.abcrypt differ diff --git a/crates/abcrypt/tests/data/v1/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2d/v0x10/data.txt.abcrypt.license similarity index 100% rename from crates/abcrypt/tests/data/v1/data.txt.abcrypt.license rename to crates/abcrypt/tests/data/v1/argon2d/v0x10/data.txt.abcrypt.license diff --git a/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt new file mode 100644 index 00000000..7839ca69 Binary files /dev/null and b/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt differ diff --git a/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt.license new file mode 100644 index 00000000..df26b1a7 --- /dev/null +++ b/crates/abcrypt/tests/data/v1/argon2d/v0x13/data.txt.abcrypt.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: 2024 Shun Sakai + +SPDX-License-Identifier: Apache-2.0 OR MIT diff --git a/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt new file mode 100644 index 00000000..3c470deb Binary files /dev/null and b/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt differ diff --git a/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt.license new file mode 100644 index 00000000..df26b1a7 --- /dev/null +++ b/crates/abcrypt/tests/data/v1/argon2i/v0x10/data.txt.abcrypt.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: 2024 Shun Sakai + +SPDX-License-Identifier: Apache-2.0 OR MIT diff --git a/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt new file mode 100644 index 00000000..d8938583 Binary files /dev/null and b/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt differ diff --git a/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt.license new file mode 100644 index 00000000..df26b1a7 --- /dev/null +++ b/crates/abcrypt/tests/data/v1/argon2i/v0x13/data.txt.abcrypt.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: 2024 Shun Sakai + +SPDX-License-Identifier: Apache-2.0 OR MIT diff --git a/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt new file mode 100644 index 00000000..e44a4bd3 Binary files /dev/null and b/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt differ diff --git a/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt.license new file mode 100644 index 00000000..df26b1a7 --- /dev/null +++ b/crates/abcrypt/tests/data/v1/argon2id/v0x10/data.txt.abcrypt.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: 2024 Shun Sakai + +SPDX-License-Identifier: Apache-2.0 OR MIT diff --git a/crates/abcrypt/tests/data/v1/data.txt.abcrypt b/crates/abcrypt/tests/data/v1/argon2id/v0x13/data.txt.abcrypt similarity index 100% rename from crates/abcrypt/tests/data/v1/data.txt.abcrypt rename to crates/abcrypt/tests/data/v1/argon2id/v0x13/data.txt.abcrypt diff --git a/crates/abcrypt/tests/data/v1/argon2id/v0x13/data.txt.abcrypt.license b/crates/abcrypt/tests/data/v1/argon2id/v0x13/data.txt.abcrypt.license new file mode 100644 index 00000000..df26b1a7 --- /dev/null +++ b/crates/abcrypt/tests/data/v1/argon2id/v0x13/data.txt.abcrypt.license @@ -0,0 +1,3 @@ +SPDX-FileCopyrightText: 2024 Shun Sakai + +SPDX-License-Identifier: Apache-2.0 OR MIT diff --git a/crates/abcrypt/tests/decrypt.rs b/crates/abcrypt/tests/decrypt.rs index 38371f36..e6e5187e 100644 --- a/crates/abcrypt/tests/decrypt.rs +++ b/crates/abcrypt/tests/decrypt.rs @@ -9,14 +9,71 @@ use abcrypt::{ const PASSPHRASE: &str = "passphrase"; const TEST_DATA: &[u8] = include_bytes!("data/data.txt"); // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/argon2id/v0x13/data.txt.abcrypt"); #[test] fn success() { - let cipher = Decryptor::new(&TEST_DATA_ENC, PASSPHRASE).unwrap(); - let mut buf = [u8::default(); TEST_DATA.len()]; - cipher.decrypt(&mut buf).unwrap(); - assert_eq!(buf, TEST_DATA); + #[cfg(feature = "alloc")] + { + let cipher = Decryptor::new( + &include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Decryptor::new( + &include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt"), + PASSPHRASE, + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Decryptor::new( + &include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Decryptor::new( + &include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt"), + PASSPHRASE, + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Decryptor::new( + &include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let cipher = Decryptor::new(&TEST_DATA_ENC, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } } #[cfg(feature = "alloc")] diff --git a/crates/abcrypt/tests/encrypt.rs b/crates/abcrypt/tests/encrypt.rs index 9427d391..45935b4c 100644 --- a/crates/abcrypt/tests/encrypt.rs +++ b/crates/abcrypt/tests/encrypt.rs @@ -59,31 +59,173 @@ fn success_with_params() { #[test] fn success_with_context() { - let cipher = Encryptor::with_context( - &TEST_DATA, - PASSPHRASE, - Algorithm::Argon2i, - Version::V0x10, - Params::new(32, 3, 4, None).unwrap(), - ) - .unwrap(); - let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; - cipher.encrypt(&mut buf); - assert_ne!(buf, TEST_DATA); + #[cfg(feature = "alloc")] + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2d, + Version::V0x10, + Params::new(47104, 1, 1, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); - let argon2 = Argon2::new(buf).unwrap(); - assert_eq!(argon2.variant(), Algorithm::Argon2i); - assert_eq!(argon2.version(), Version::V0x10); + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x10); - let params = abcrypt::Params::new(buf).unwrap(); - assert_eq!(params.memory_cost(), 32); - assert_eq!(params.time_cost(), 3); - assert_eq!(params.parallelism(), 4); + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 47104); + assert_eq!(params.time_cost(), 1); + assert_eq!(params.parallelism(), 1); - let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); - let mut buf = [u8::default(); TEST_DATA.len()]; - cipher.decrypt(&mut buf).unwrap(); - assert_eq!(buf, TEST_DATA); + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2d, + Version::V0x13, + Params::new(19456, 2, 1, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); + + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 19456); + assert_eq!(params.time_cost(), 2); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2i, + Version::V0x10, + Params::new(12288, 3, 1, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); + + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 12288); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2i, + Version::V0x13, + Params::new(9216, 4, 1, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); + + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 9216); + assert_eq!(params.time_cost(), 4); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + #[cfg(feature = "alloc")] + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2id, + Version::V0x10, + Params::new(7168, 5, 1, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); + + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 7168); + assert_eq!(params.time_cost(), 5); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let cipher = Encryptor::with_context( + &TEST_DATA, + PASSPHRASE, + Algorithm::Argon2id, + Version::V0x13, + Params::new(32, 3, 4, None).unwrap(), + ) + .unwrap(); + let mut buf = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + cipher.encrypt(&mut buf); + assert_ne!(buf, TEST_DATA); + + let argon2 = Argon2::new(buf).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(buf).unwrap(); + assert_eq!(params.memory_cost(), 32); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 4); + + let cipher = Decryptor::new(&buf, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } } #[cfg(feature = "alloc")] @@ -351,28 +493,160 @@ fn success_convenience_function_with_params() { #[cfg(feature = "alloc")] #[test] fn success_convenience_function_with_context() { - let ciphertext = abcrypt::encrypt_with_context( - TEST_DATA, - PASSPHRASE, - Algorithm::Argon2i, - Version::V0x10, - Params::new(32, 3, 4, None).unwrap(), - ) - .unwrap(); - assert_ne!(ciphertext, TEST_DATA); - assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2d, + Version::V0x10, + Params::new(47104, 1, 1, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); - let argon2 = Argon2::new(&ciphertext).unwrap(); - assert_eq!(argon2.variant(), Algorithm::Argon2i); - assert_eq!(argon2.version(), Version::V0x10); + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x10); - let params = abcrypt::Params::new(&ciphertext).unwrap(); - assert_eq!(params.memory_cost(), 32); - assert_eq!(params.time_cost(), 3); - assert_eq!(params.parallelism(), 4); + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 47104); + assert_eq!(params.time_cost(), 1); + assert_eq!(params.parallelism(), 1); - let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); - let mut buf = [u8::default(); TEST_DATA.len()]; - cipher.decrypt(&mut buf).unwrap(); - assert_eq!(buf, TEST_DATA); + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2d, + Version::V0x13, + Params::new(19456, 2, 1, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 19456); + assert_eq!(params.time_cost(), 2); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2i, + Version::V0x10, + Params::new(12288, 3, 1, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 12288); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2i, + Version::V0x13, + Params::new(9216, 4, 1, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 9216); + assert_eq!(params.time_cost(), 4); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2id, + Version::V0x10, + Params::new(7168, 5, 1, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 7168); + assert_eq!(params.time_cost(), 5); + assert_eq!(params.parallelism(), 1); + + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } + { + let ciphertext = abcrypt::encrypt_with_context( + TEST_DATA, + PASSPHRASE, + Algorithm::Argon2id, + Version::V0x13, + Params::new(32, 3, 4, None).unwrap(), + ) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!(ciphertext.len(), TEST_DATA.len() + HEADER_SIZE + TAG_SIZE); + + let argon2 = Argon2::new(&ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(&ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 32); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 4); + + let cipher = Decryptor::new(&ciphertext, PASSPHRASE).unwrap(); + let mut buf = [u8::default(); TEST_DATA.len()]; + cipher.decrypt(&mut buf).unwrap(); + assert_eq!(buf, TEST_DATA); + } } diff --git a/crates/abcrypt/tests/params.rs b/crates/abcrypt/tests/params.rs index 7cd2cb0d..a34caf4b 100644 --- a/crates/abcrypt/tests/params.rs +++ b/crates/abcrypt/tests/params.rs @@ -5,7 +5,7 @@ use abcrypt::Params; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/argon2id/v0x13/data.txt.abcrypt"); #[test] fn success() { @@ -15,20 +15,89 @@ fn success() { #[test] fn memory_cost() { - let params = Params::new(TEST_DATA_ENC).unwrap(); - assert_eq!(params.memory_cost(), 32); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.memory_cost(), 47104); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.memory_cost(), 19456); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.memory_cost(), 12288); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.memory_cost(), 9216); + } + { + let params = + Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.memory_cost(), 7168); + } + { + let params = Params::new(TEST_DATA_ENC).unwrap(); + assert_eq!(params.memory_cost(), 32); + } } #[test] fn time_cost() { - let params = Params::new(TEST_DATA_ENC).unwrap(); - assert_eq!(params.time_cost(), 3); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.time_cost(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.time_cost(), 2); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.time_cost(), 3); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.time_cost(), 4); + } + { + let params = + Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.time_cost(), 5); + } + { + let params = Params::new(TEST_DATA_ENC).unwrap(); + assert_eq!(params.time_cost(), 3); + } } #[test] fn parallelism() { - let params = Params::new(TEST_DATA_ENC).unwrap(); - assert_eq!(params.parallelism(), 4); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")).unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = + Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")).unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(TEST_DATA_ENC).unwrap(); + assert_eq!(params.parallelism(), 4); + } } #[cfg(feature = "serde")] diff --git a/crates/capi/src/decrypt.rs b/crates/capi/src/decrypt.rs index 74b9cee5..e1b5d0df 100644 --- a/crates/capi/src/decrypt.rs +++ b/crates/capi/src/decrypt.rs @@ -81,26 +81,128 @@ mod tests { const PASSPHRASE: &str = "passphrase"; const TEST_DATA: &[u8] = include_bytes!("../tests/data/data.txt"); // Generated using `abcrypt` crate version 0.4.0. - const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); #[test] fn success() { - let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); - let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); - let mut plaintext = [u8::default(); TEST_DATA.len()]; - assert_ne!(plaintext, TEST_DATA); - let code = unsafe { - abcrypt_decrypt( - NonNull::new(ciphertext.as_mut_ptr()), - ciphertext.len(), - NonNull::new(passphrase.as_mut_ptr()), - passphrase.len(), - NonNull::new(plaintext.as_mut_ptr()), - plaintext.len(), - ) - }; - assert_eq!(code, ErrorCode::Ok); - assert_eq!(plaintext, TEST_DATA); + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x10/data.txt.abcrypt"); + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x13/data.txt.abcrypt"); + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x10/data.txt.abcrypt"); + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x13/data.txt.abcrypt"); + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2id/v0x10/data.txt.abcrypt"); + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut ciphertext: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } } #[test] diff --git a/crates/capi/src/encrypt.rs b/crates/capi/src/encrypt.rs index 868c8020..3207c7c2 100644 --- a/crates/capi/src/encrypt.rs +++ b/crates/capi/src/encrypt.rs @@ -315,50 +315,282 @@ mod tests { #[test] fn success_with_context() { - let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); - let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); - let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; - let code = unsafe { - abcrypt_encrypt_with_context( - NonNull::new(plaintext.as_mut_ptr()), - plaintext.len(), - NonNull::new(passphrase.as_mut_ptr()), - passphrase.len(), - NonNull::new(ciphertext.as_mut_ptr()), - ciphertext.len(), - 1, - 0x10, - 32, - 3, - 4, - ) - }; - assert_eq!(code, ErrorCode::Ok); - assert_ne!(ciphertext, TEST_DATA); + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 0, + 0x10, + 47104, + 1, + 1, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); - let argon2 = Argon2::new(ciphertext).unwrap(); - assert_eq!(argon2.variant(), Algorithm::Argon2i); - assert_eq!(argon2.version(), Version::V0x10); + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x10); - let params = abcrypt::Params::new(ciphertext).unwrap(); - assert_eq!(params.memory_cost(), 32); - assert_eq!(params.time_cost(), 3); - assert_eq!(params.parallelism(), 4); + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 47104); + assert_eq!(params.time_cost(), 1); + assert_eq!(params.parallelism(), 1); - let mut plaintext = [u8::default(); TEST_DATA.len()]; - assert_ne!(plaintext, TEST_DATA); - let code = unsafe { - abcrypt_decrypt( - NonNull::new(ciphertext.as_mut_ptr()), - ciphertext.len(), - NonNull::new(passphrase.as_mut_ptr()), - passphrase.len(), - NonNull::new(plaintext.as_mut_ptr()), - plaintext.len(), - ) - }; - assert_eq!(code, ErrorCode::Ok); - assert_eq!(plaintext, TEST_DATA); + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 0, + 0x13, + 19456, + 2, + 1, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); + + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2d); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 19456); + assert_eq!(params.time_cost(), 2); + assert_eq!(params.parallelism(), 1); + + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 1, + 0x10, + 12288, + 3, + 1, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); + + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 12288); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 1); + + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 1, + 0x13, + 9216, + 4, + 1, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); + + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2i); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 9216); + assert_eq!(params.time_cost(), 4); + assert_eq!(params.parallelism(), 1); + + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 2, + 0x10, + 7168, + 5, + 1, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); + + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x10); + + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 7168); + assert_eq!(params.time_cost(), 5); + assert_eq!(params.parallelism(), 1); + + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } + { + let mut plaintext: [u8; TEST_DATA.len()] = TEST_DATA.try_into().unwrap(); + let mut passphrase: [u8; PASSPHRASE.len()] = PASSPHRASE.as_bytes().try_into().unwrap(); + let mut ciphertext = [u8::default(); TEST_DATA.len() + HEADER_SIZE + TAG_SIZE]; + let code = unsafe { + abcrypt_encrypt_with_context( + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + 2, + 0x13, + 32, + 3, + 4, + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_ne!(ciphertext, TEST_DATA); + + let argon2 = Argon2::new(ciphertext).unwrap(); + assert_eq!(argon2.variant(), Algorithm::Argon2id); + assert_eq!(argon2.version(), Version::V0x13); + + let params = abcrypt::Params::new(ciphertext).unwrap(); + assert_eq!(params.memory_cost(), 32); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 4); + + let mut plaintext = [u8::default(); TEST_DATA.len()]; + assert_ne!(plaintext, TEST_DATA); + let code = unsafe { + abcrypt_decrypt( + NonNull::new(ciphertext.as_mut_ptr()), + ciphertext.len(), + NonNull::new(passphrase.as_mut_ptr()), + passphrase.len(), + NonNull::new(plaintext.as_mut_ptr()), + plaintext.len(), + ) + }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(plaintext, TEST_DATA); + } } #[test] diff --git a/crates/capi/src/params.rs b/crates/capi/src/params.rs index ecee4b3e..337171e2 100644 --- a/crates/capi/src/params.rs +++ b/crates/capi/src/params.rs @@ -237,7 +237,7 @@ mod tests { use super::*; // Generated using `abcrypt` crate version 0.4.0. - const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/data.txt.abcrypt"); + const TEST_DATA_ENC: &[u8] = include_bytes!("../tests/data/v1/argon2id/v0x13/data.txt.abcrypt"); #[test] fn success() { @@ -251,34 +251,205 @@ mod tests { #[test] fn memory_cost() { - let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); - let params = abcrypt_params_new(); - let code = - unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; - assert_eq!(code, ErrorCode::Ok); - assert_eq!(abcrypt_params_memory_cost(params), 32); - unsafe { abcrypt_params_free(params) }; + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 47104); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 19456); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 12288); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 9216); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2id/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 7168); + unsafe { abcrypt_params_free(params) }; + } + { + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_memory_cost(params), 32); + unsafe { abcrypt_params_free(params) }; + } } #[test] fn time_cost() { - let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); - let params = abcrypt_params_new(); - let code = - unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; - assert_eq!(code, ErrorCode::Ok); - assert_eq!(abcrypt_params_time_cost(params), 3); - unsafe { abcrypt_params_free(params) }; + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 2); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 3); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 4); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2id/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 5); + unsafe { abcrypt_params_free(params) }; + } + { + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_time_cost(params), 3); + unsafe { abcrypt_params_free(params) }; + } } #[test] fn parallelism() { - let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); - let params = abcrypt_params_new(); - let code = - unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; - assert_eq!(code, ErrorCode::Ok); - assert_eq!(abcrypt_params_parallelism(params), 4); - unsafe { abcrypt_params_free(params) }; + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2d/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2i/v0x13/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + const TEST_DATA_ENC: &[u8] = + include_bytes!("../tests/data/v1/argon2id/v0x10/data.txt.abcrypt"); + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 1); + unsafe { abcrypt_params_free(params) }; + } + { + let mut data: [u8; TEST_DATA_ENC.len()] = TEST_DATA_ENC.try_into().unwrap(); + let params = abcrypt_params_new(); + let code = + unsafe { abcrypt_params_read(NonNull::new(data.as_mut_ptr()), data.len(), params) }; + assert_eq!(code, ErrorCode::Ok); + assert_eq!(abcrypt_params_parallelism(params), 4); + unsafe { abcrypt_params_free(params) }; + } } } diff --git a/crates/cli/tests/argon2.rs b/crates/cli/tests/argon2.rs index a214011e..d45d3696 100644 --- a/crates/cli/tests/argon2.rs +++ b/crates/cli/tests/argon2.rs @@ -10,7 +10,42 @@ use predicates::prelude::predicate; fn basic_argon2() { utils::command::command() .arg("argon2") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2d/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::contains("Type: Argon2d")) + .stderr(predicate::str::contains("Version: 0x10")); + utils::command::command() + .arg("argon2") + .arg("data/v1/argon2d/v0x13/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::contains("Type: Argon2d")) + .stderr(predicate::str::contains("Version: 0x13")); + utils::command::command() + .arg("argon2") + .arg("data/v1/argon2i/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::contains("Type: Argon2i")) + .stderr(predicate::str::contains("Version: 0x10")); + utils::command::command() + .arg("argon2") + .arg("data/v1/argon2i/v0x13/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::contains("Type: Argon2i")) + .stderr(predicate::str::contains("Version: 0x13")); + utils::command::command() + .arg("argon2") + .arg("data/v1/argon2id/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::contains("Type: Argon2id")) + .stderr(predicate::str::contains("Version: 0x10")); + utils::command::command() + .arg("argon2") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .assert() .success() .stderr(predicate::str::contains("Type: Argon2id")) diff --git a/crates/cli/tests/decrypt.rs b/crates/cli/tests/decrypt.rs index b41f42ca..ab2d068c 100644 --- a/crates/cli/tests/decrypt.rs +++ b/crates/cli/tests/decrypt.rs @@ -11,7 +11,47 @@ fn basic_decrypt() { utils::command::command() .arg("decrypt") .arg("--passphrase-from-stdin") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2d/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("data/v1/argon2d/v0x13/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("data/v1/argon2i/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("data/v1/argon2i/v0x13/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("data/v1/argon2id/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .write_stdin("passphrase") .assert() .success() @@ -63,7 +103,7 @@ fn decrypt_if_output_is_directory() { .arg("-o") .arg("data/dummy") .arg("--passphrase-from-stdin") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .write_stdin("passphrase") .assert() .failure() @@ -113,7 +153,7 @@ fn decrypt_if_passphrase_is_incorrect() { utils::command::command() .arg("decrypt") .arg("--passphrase-from-stdin") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .write_stdin("password") .assert() .failure() @@ -145,7 +185,67 @@ fn decrypt_verbose() { .arg("decrypt") .arg("--passphrase-from-stdin") .arg("-v") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2d/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")) + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 47104; timeCost = 1; parallelism = 1;", + )); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("-v") + .arg("data/v1/argon2d/v0x13/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")) + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 19456; timeCost = 2; parallelism = 1;", + )); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("-v") + .arg("data/v1/argon2i/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")) + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 12288; timeCost = 3; parallelism = 1;", + )); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("-v") + .arg("data/v1/argon2i/v0x13/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")) + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 9216; timeCost = 4; parallelism = 1;", + )); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("-v") + .arg("data/v1/argon2id/v0x10/data.txt.abcrypt") + .write_stdin("passphrase") + .assert() + .success() + .stdout(predicate::eq("Hello, world!\n")) + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 7168; timeCost = 5; parallelism = 1;", + )); + utils::command::command() + .arg("decrypt") + .arg("--passphrase-from-stdin") + .arg("-v") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .write_stdin("passphrase") .assert() .success() diff --git a/crates/cli/tests/information.rs b/crates/cli/tests/information.rs index 8861953f..1c008166 100644 --- a/crates/cli/tests/information.rs +++ b/crates/cli/tests/information.rs @@ -10,7 +10,47 @@ use predicates::prelude::predicate; fn basic_information() { utils::command::command() .arg("information") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2d/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 47104; timeCost = 1; parallelism = 1;", + )); + utils::command::command() + .arg("information") + .arg("data/v1/argon2d/v0x13/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 19456; timeCost = 2; parallelism = 1;", + )); + utils::command::command() + .arg("information") + .arg("data/v1/argon2i/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 12288; timeCost = 3; parallelism = 1;", + )); + utils::command::command() + .arg("information") + .arg("data/v1/argon2i/v0x13/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 9216; timeCost = 4; parallelism = 1;", + )); + utils::command::command() + .arg("information") + .arg("data/v1/argon2id/v0x10/data.txt.abcrypt") + .assert() + .success() + .stderr(predicate::str::starts_with( + "Parameters used: memoryCost = 7168; timeCost = 5; parallelism = 1;", + )); + utils::command::command() + .arg("information") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .assert() .success() .stderr(predicate::str::starts_with( @@ -60,7 +100,7 @@ fn information_command_without_default_feature() { utils::command::command() .arg("information") .arg("-j") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .assert() .failure() .code(2) @@ -73,7 +113,7 @@ fn information_as_json() { utils::command::command() .arg("information") .arg("-j") - .arg("data/v1/data.txt.abcrypt") + .arg("data/v1/argon2id/v0x13/data.txt.abcrypt") .assert() .success() .stdout(predicate::eq(concat!( diff --git a/crates/python/tests/test_decrypt.py b/crates/python/tests/test_decrypt.py index 3707ec76..e69ee71f 100644 --- a/crates/python/tests/test_decrypt.py +++ b/crates/python/tests/test_decrypt.py @@ -12,11 +12,53 @@ TEST_DIR: Final[Path] = Path(__file__).resolve().parent TEST_DATA: Final[bytes] = Path(TEST_DIR / "data/data.txt").read_bytes() TEST_DATA_ENC: Final[bytes] = Path( - TEST_DIR / "data/v1/data.txt.abcrypt" + TEST_DIR / "data/v1/argon2id/v0x13/data.txt.abcrypt" ).read_bytes() -def test_success() -> None: +def test_success_from_argon2d_and_v0x10() -> None: + plaintext = abcrypt_py.decrypt( + Path(TEST_DIR / "data/v1/argon2d/v0x10/data.txt.abcrypt").read_bytes(), + PASSPHRASE, + ) + assert plaintext == TEST_DATA + + +def test_success_from_argon2d_and_v0x13() -> None: + plaintext = abcrypt_py.decrypt( + Path(TEST_DIR / "data/v1/argon2d/v0x13/data.txt.abcrypt").read_bytes(), + PASSPHRASE, + ) + assert plaintext == TEST_DATA + + +def test_success_from_argon2i_and_v0x10() -> None: + plaintext = abcrypt_py.decrypt( + Path(TEST_DIR / "data/v1/argon2i/v0x10/data.txt.abcrypt").read_bytes(), + PASSPHRASE, + ) + assert plaintext == TEST_DATA + + +def test_success_from_argon2i_and_v0x13() -> None: + plaintext = abcrypt_py.decrypt( + Path(TEST_DIR / "data/v1/argon2i/v0x13/data.txt.abcrypt").read_bytes(), + PASSPHRASE, + ) + assert plaintext == TEST_DATA + + +def test_success_from_argon2id_and_v0x10() -> None: + plaintext = abcrypt_py.decrypt( + Path( + TEST_DIR / "data/v1/argon2id/v0x10/data.txt.abcrypt" + ).read_bytes(), + PASSPHRASE, + ) + assert plaintext == TEST_DATA + + +def test_success_from_argon2id_and_v0x13() -> None: plaintext = abcrypt_py.decrypt(TEST_DATA_ENC, PASSPHRASE) assert plaintext == TEST_DATA diff --git a/crates/python/tests/test_encrypt.py b/crates/python/tests/test_encrypt.py index f6993a86..1e1e02bc 100644 --- a/crates/python/tests/test_encrypt.py +++ b/crates/python/tests/test_encrypt.py @@ -52,9 +52,114 @@ def test_success_with_params() -> None: assert plaintext == TEST_DATA -def test_success_with_context() -> None: +def test_success_with_context_to_argon2d_and_v0x10() -> None: ciphertext = abcrypt_py.encrypt_with_context( - TEST_DATA, PASSPHRASE, 1, 0x10, 32, 3, 4 + TEST_DATA, PASSPHRASE, 0, 0x10, 47104, 1, 1 + ) + assert ciphertext != TEST_DATA + assert ( + len(ciphertext) + == len(TEST_DATA) + + abcrypt_py.Format.HEADER_SIZE + + abcrypt_py.Format.TAG_SIZE + ) + + params = abcrypt_py.Params(ciphertext) + assert params.memory_cost == 47104 + assert params.time_cost == 1 + assert params.parallelism == 1 + + plaintext = abcrypt_py.decrypt(ciphertext, PASSPHRASE) + assert plaintext == TEST_DATA + + +def test_success_with_context_to_argon2d_and_v0x13() -> None: + ciphertext = abcrypt_py.encrypt_with_context( + TEST_DATA, PASSPHRASE, 0, 0x13, 19456, 2, 1 + ) + assert ciphertext != TEST_DATA + assert ( + len(ciphertext) + == len(TEST_DATA) + + abcrypt_py.Format.HEADER_SIZE + + abcrypt_py.Format.TAG_SIZE + ) + + params = abcrypt_py.Params(ciphertext) + assert params.memory_cost == 19456 + assert params.time_cost == 2 + assert params.parallelism == 1 + + plaintext = abcrypt_py.decrypt(ciphertext, PASSPHRASE) + assert plaintext == TEST_DATA + + +def test_success_with_context_to_argon2i_and_v0x10() -> None: + ciphertext = abcrypt_py.encrypt_with_context( + TEST_DATA, PASSPHRASE, 1, 0x10, 12288, 3, 1 + ) + assert ciphertext != TEST_DATA + assert ( + len(ciphertext) + == len(TEST_DATA) + + abcrypt_py.Format.HEADER_SIZE + + abcrypt_py.Format.TAG_SIZE + ) + + params = abcrypt_py.Params(ciphertext) + assert params.memory_cost == 12288 + assert params.time_cost == 3 + assert params.parallelism == 1 + + plaintext = abcrypt_py.decrypt(ciphertext, PASSPHRASE) + assert plaintext == TEST_DATA + + +def test_success_with_context_to_argon2i_and_v0x13() -> None: + ciphertext = abcrypt_py.encrypt_with_context( + TEST_DATA, PASSPHRASE, 1, 0x13, 9216, 4, 1 + ) + assert ciphertext != TEST_DATA + assert ( + len(ciphertext) + == len(TEST_DATA) + + abcrypt_py.Format.HEADER_SIZE + + abcrypt_py.Format.TAG_SIZE + ) + + params = abcrypt_py.Params(ciphertext) + assert params.memory_cost == 9216 + assert params.time_cost == 4 + assert params.parallelism == 1 + + plaintext = abcrypt_py.decrypt(ciphertext, PASSPHRASE) + assert plaintext == TEST_DATA + + +def test_success_with_context_to_argon2id_and_v0x10() -> None: + ciphertext = abcrypt_py.encrypt_with_context( + TEST_DATA, PASSPHRASE, 2, 0x10, 7168, 5, 1 + ) + assert ciphertext != TEST_DATA + assert ( + len(ciphertext) + == len(TEST_DATA) + + abcrypt_py.Format.HEADER_SIZE + + abcrypt_py.Format.TAG_SIZE + ) + + params = abcrypt_py.Params(ciphertext) + assert params.memory_cost == 7168 + assert params.time_cost == 5 + assert params.parallelism == 1 + + plaintext = abcrypt_py.decrypt(ciphertext, PASSPHRASE) + assert plaintext == TEST_DATA + + +def test_success_with_context_to_argon2id_and_v0x13() -> None: + ciphertext = abcrypt_py.encrypt_with_context( + TEST_DATA, PASSPHRASE, 2, 0x13, 32, 3, 4 ) assert ciphertext != TEST_DATA assert ( diff --git a/crates/python/tests/test_params.py b/crates/python/tests/test_params.py index e9202c74..2ab59c47 100644 --- a/crates/python/tests/test_params.py +++ b/crates/python/tests/test_params.py @@ -9,7 +9,7 @@ TEST_DIR: Final[Path] = Path(__file__).resolve().parent TEST_DATA_ENC: Final[bytes] = Path( - TEST_DIR / "data/v1/data.txt.abcrypt" + TEST_DIR / "data/v1/argon2id/v0x13/data.txt.abcrypt" ).read_bytes() @@ -17,16 +17,121 @@ def test_success() -> None: abcrypt_py.Params(TEST_DATA_ENC) -def test_memory_cost() -> None: +def test_memory_cost_from_argon2d_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.memory_cost == 47104 + + +def test_memory_cost_from_argon2d_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.memory_cost == 19456 + + +def test_memory_cost_from_argon2i_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.memory_cost == 12288 + + +def test_memory_cost_from_argon2i_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.memory_cost == 9216 + + +def test_memory_cost_from_argon2id_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2id/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.memory_cost == 7168 + + +def test_memory_cost_from_argon2id_and_v0x13() -> None: params = abcrypt_py.Params(TEST_DATA_ENC) assert params.memory_cost == 32 -def test_time_cost() -> None: +def test_time_cost_from_argon2d_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.time_cost == 1 + + +def test_time_cost_from_argon2d_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.time_cost == 2 + + +def test_time_cost_from_argon2i_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.time_cost == 3 + + +def test_time_cost_from_argon2i_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.time_cost == 4 + + +def test_time_cost_from_argon2id_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2id/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.time_cost == 5 + + +def test_time_cost_from_argon2id_and_v0x13() -> None: params = abcrypt_py.Params(TEST_DATA_ENC) assert params.time_cost == 3 -def test_parallelism() -> None: +def test_parallelism_from_argon2d_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.parallelism == 1 + + +def test_parallelism_from_argon2d_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2d/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.parallelism == 1 + + +def test_parallelism_from_argon2i_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.parallelism == 1 + + +def test_parallelism_from_argon2i_and_v0x13() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2i/v0x13/data.txt.abcrypt").read_bytes() + ) + assert params.parallelism == 1 + + +def test_parallelism_from_argon2id_and_v0x10() -> None: + params = abcrypt_py.Params( + Path(TEST_DIR / "data/v1/argon2id/v0x10/data.txt.abcrypt").read_bytes() + ) + assert params.parallelism == 1 + + +def test_parallelism_from_argon2id_and_v0x13() -> None: params = abcrypt_py.Params(TEST_DATA_ENC) assert params.parallelism == 4 diff --git a/crates/wasm/tests/decrypt.rs b/crates/wasm/tests/decrypt.rs index 948613ae..c3b222a6 100644 --- a/crates/wasm/tests/decrypt.rs +++ b/crates/wasm/tests/decrypt.rs @@ -8,14 +8,61 @@ use wasm_bindgen_test::wasm_bindgen_test; const PASSPHRASE: &[u8] = b"passphrase"; const TEST_DATA: &[u8] = include_bytes!("data/data.txt"); // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/argon2id/v0x13/data.txt.abcrypt"); #[wasm_bindgen_test] fn success() { - let plaintext = abcrypt_wasm::decrypt(TEST_DATA_ENC, PASSPHRASE) + { + let plaintext = abcrypt_wasm::decrypt( + include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let plaintext = abcrypt_wasm::decrypt( + include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt"), + PASSPHRASE, + ) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let plaintext = abcrypt_wasm::decrypt( + include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let plaintext = abcrypt_wasm::decrypt( + include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt"), + PASSPHRASE, + ) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let plaintext = abcrypt_wasm::decrypt( + include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt"), + PASSPHRASE, + ) .map_err(JsValue::from) .unwrap(); - assert_eq!(plaintext, TEST_DATA); + assert_eq!(plaintext, TEST_DATA); + } + { + let plaintext = abcrypt_wasm::decrypt(TEST_DATA_ENC, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } } #[wasm_bindgen_test] diff --git a/crates/wasm/tests/encrypt.rs b/crates/wasm/tests/encrypt.rs index c0407986..4e33da95 100644 --- a/crates/wasm/tests/encrypt.rs +++ b/crates/wasm/tests/encrypt.rs @@ -55,24 +55,132 @@ fn success_with_params() { #[wasm_bindgen_test] fn success_with_context() { - let ciphertext = abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 1, 0x10, 32, 3, 4) - .map_err(JsValue::from) - .unwrap(); - assert_ne!(ciphertext, TEST_DATA); - assert_eq!( - ciphertext.len(), - TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() - ); + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 0, 0x10, 47104, 1, 1) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); - let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); - assert_eq!(params.memory_cost(), 32); - assert_eq!(params.time_cost(), 3); - assert_eq!(params.parallelism(), 4); + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 47104); + assert_eq!(params.time_cost(), 1); + assert_eq!(params.parallelism(), 1); - let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) - .map_err(JsValue::from) - .unwrap(); - assert_eq!(plaintext, TEST_DATA); + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 0, 0x13, 19456, 2, 1) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); + + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 19456); + assert_eq!(params.time_cost(), 2); + assert_eq!(params.parallelism(), 1); + + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 1, 0x10, 12288, 3, 1) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); + + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 12288); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 1); + + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 1, 0x13, 9216, 4, 1) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); + + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 9216); + assert_eq!(params.time_cost(), 4); + assert_eq!(params.parallelism(), 1); + + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 2, 0x10, 7168, 5, 1) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); + + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 7168); + assert_eq!(params.time_cost(), 5); + assert_eq!(params.parallelism(), 1); + + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } + { + let ciphertext = + abcrypt_wasm::encrypt_with_context(TEST_DATA, PASSPHRASE, 2, 0x10, 32, 3, 4) + .map_err(JsValue::from) + .unwrap(); + assert_ne!(ciphertext, TEST_DATA); + assert_eq!( + ciphertext.len(), + TEST_DATA.len() + abcrypt_wasm::header_size() + abcrypt_wasm::tag_size() + ); + + let params = Params::new(&ciphertext).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 32); + assert_eq!(params.time_cost(), 3); + assert_eq!(params.parallelism(), 4); + + let plaintext = abcrypt_wasm::decrypt(&ciphertext, PASSPHRASE) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(plaintext, TEST_DATA); + } } #[wasm_bindgen_test] diff --git a/crates/wasm/tests/params.rs b/crates/wasm/tests/params.rs index 56d3a327..f51f7669 100644 --- a/crates/wasm/tests/params.rs +++ b/crates/wasm/tests/params.rs @@ -7,7 +7,7 @@ use wasm_bindgen::JsValue; use wasm_bindgen_test::wasm_bindgen_test; // Generated using `abcrypt` crate version 0.4.0. -const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/data.txt.abcrypt"); +const TEST_DATA_ENC: &[u8] = include_bytes!("data/v1/argon2id/v0x13/data.txt.abcrypt"); #[wasm_bindgen_test] fn success() { @@ -17,18 +17,114 @@ fn success() { #[wasm_bindgen_test] fn memory_cost() { - let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); - assert_eq!(params.memory_cost(), 32); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.memory_cost(), 47104); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.memory_cost(), 19456); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.memory_cost(), 12288); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.memory_cost(), 9216); + } + { + let params = Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.memory_cost(), 7168); + } + { + let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); + assert_eq!(params.memory_cost(), 32); + } } #[wasm_bindgen_test] fn time_cost() { - let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); - assert_eq!(params.time_cost(), 3); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.time_cost(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.time_cost(), 2); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.time_cost(), 3); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.time_cost(), 4); + } + { + let params = Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.time_cost(), 5); + } + { + let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); + assert_eq!(params.time_cost(), 3); + } } #[wasm_bindgen_test] fn parallelism() { - let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); - assert_eq!(params.parallelism(), 4); + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2d/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2i/v0x13/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(include_bytes!("data/v1/argon2id/v0x10/data.txt.abcrypt")) + .map_err(JsValue::from) + .unwrap(); + assert_eq!(params.parallelism(), 1); + } + { + let params = Params::new(TEST_DATA_ENC).map_err(JsValue::from).unwrap(); + assert_eq!(params.parallelism(), 4); + } }