chore: checkpoint before Python removal

vendor/ctr/tests/ctr128/mod.rs

@@ -0,0 +1,12 @@
+use aes::{Aes128, Aes256};
+use ctr::{flavors, Ctr128BE, CtrCore};
+
+cipher::stream_cipher_test!(aes128_ctr_core, "aes128-ctr", Ctr128BE<Aes128>);
+cipher::stream_cipher_test!(aes256_ctr_core, "aes256-ctr", Ctr128BE<Aes256>);
+cipher::stream_cipher_seek_test!(aes128_ctr_seek, Ctr128BE<Aes128>);
+cipher::stream_cipher_seek_test!(aes256_ctr_seek, Ctr128BE<Aes256>);
+cipher::iv_state_test!(
+    aes128_ctr_iv_state,
+    CtrCore<Aes128, flavors::Ctr128BE>,
+    apply_ks,
+);

vendor/ctr/tests/ctr32/be.rs

@@ -0,0 +1,86 @@
+//! Counter Mode with a 32-bit big endian counter
+
+use cipher::{KeyIvInit, StreamCipher, StreamCipherSeek, StreamCipherSeekCore};
+use hex_literal::hex;
+
+type Aes128Ctr = ctr::Ctr32BE<aes::Aes128>;
+
+const KEY: &[u8; 16] = &hex!("000102030405060708090A0B0C0D0E0F");
+const NONCE1: &[u8; 16] = &hex!("11111111111111111111111111111111");
+const NONCE2: &[u8; 16] = &hex!("222222222222222222222222FFFFFFFE");
+
+#[test]
+fn counter_incr() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), NONCE1.into());
+    assert_eq!(ctr.get_core().get_block_pos(), 0);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    assert_eq!(ctr.get_core().get_block_pos(), 4);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "35D14E6D3E3A279CF01E343E34E7DED36EEADB04F42E2251AB4377F257856DBA"
+            "0AB37657B9C2AA09762E518FC9395D5304E96C34CCD2F0A95CDE7321852D90C0"
+        )[..]
+    );
+}
+
+#[test]
+fn counter_seek() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), NONCE1.into());
+    ctr.seek(16);
+    assert_eq!(ctr.get_core().get_block_pos(), 1);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    assert_eq!(ctr.get_core().get_block_pos(), 5);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "6EEADB04F42E2251AB4377F257856DBA0AB37657B9C2AA09762E518FC9395D53"
+            "04E96C34CCD2F0A95CDE7321852D90C0F7441EAB3811A03FDBD162AEC402F5AA"
+        )[..]
+    );
+}
+
+#[test]
+fn keystream_xor() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), NONCE1.into());
+    let mut buffer = [1u8; 64];
+
+    ctr.apply_keystream(&mut buffer);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "34D04F6C3F3B269DF11F353F35E6DFD26FEBDA05F52F2350AA4276F356846CBB"
+            "0BB27756B8C3AB08772F508EC8385C5205E86D35CDD3F1A85DDF7220842C91C1"
+        )[..]
+    );
+}
+
+#[test]
+fn counter_wrap() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), NONCE2.into());
+    assert_eq!(ctr.get_core().get_block_pos(), 0);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    assert_eq!(ctr.get_core().get_block_pos(), 4);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "58FC849D1CF53C54C63E1B1D15CB3C8AAA335F72135585E9FF943F4DAC77CB63"
+            "BD1AE8716BE69C3B4D886B222B9B4E1E67548EF896A96E2746D8CA6476D8B183"
+        )[..]
+    );
+}
+
+cipher::iv_state_test!(
+    iv_state,
+    ctr::CtrCore<aes::Aes128, ctr::flavors::Ctr32BE>,
+    apply_ks,
+);

vendor/ctr/tests/ctr32/le.rs

@@ -0,0 +1,96 @@
+//! Counter Mode with a 32-bit little endian counter
+
+use cipher::{
+    consts::U16, generic_array::GenericArray, KeyIvInit, StreamCipher, StreamCipherSeek,
+    StreamCipherSeekCore,
+};
+use hex_literal::hex;
+
+type Aes128Ctr = ctr::Ctr32LE<aes::Aes128>;
+
+const KEY: &[u8; 16] = &hex!("000102030405060708090A0B0C0D0E0F");
+const NONCE1: &[u8; 16] = &hex!("11111111111111111111111111111111");
+const NONCE2: &[u8; 16] = &hex!("FEFFFFFF222222222222222222222222");
+
+/// Compute nonce as used by AES-GCM-SIV
+fn nonce(bytes: &[u8; 16]) -> GenericArray<u8, U16> {
+    let mut n = *bytes;
+    n[15] |= 0x80;
+    n.into()
+}
+
+#[test]
+fn counter_incr() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), &nonce(NONCE1));
+    assert_eq!(ctr.get_core().get_block_pos(), 0);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    // assert_eq!(ctr.current_ctr(), 4);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "2A0680B210CAD45E886D7EF6DAB357C9F18B39AFF6930FDB2D9FCE34261FF699"
+            "EB96774669D24B560C9AD028C5C39C4580775A82065256B4787DC91C6942B700"
+        )[..]
+    );
+}
+
+#[test]
+fn counter_seek() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), &nonce(NONCE1));
+    ctr.seek(16);
+    assert_eq!(ctr.get_core().get_block_pos(), 1);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    assert_eq!(ctr.get_core().get_block_pos(), 5);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "F18B39AFF6930FDB2D9FCE34261FF699EB96774669D24B560C9AD028C5C39C45"
+            "80775A82065256B4787DC91C6942B7001564DDA1B07DCED9201AB71BAF06905B"
+        )[..]
+    );
+}
+
+#[test]
+fn keystream_xor() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), &nonce(NONCE1));
+    let mut buffer = [1u8; 64];
+
+    ctr.apply_keystream(&mut buffer);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "2B0781B311CBD55F896C7FF7DBB256C8F08A38AEF7920EDA2C9ECF35271EF798"
+            "EA97764768D34A570D9BD129C4C29D4481765B83075357B5797CC81D6843B601"
+        )[..]
+    );
+}
+
+#[test]
+fn counter_wrap() {
+    let mut ctr = Aes128Ctr::new(KEY.into(), &nonce(NONCE2));
+    assert_eq!(ctr.get_core().get_block_pos(), 0);
+
+    let mut buffer = [0u8; 64];
+    ctr.apply_keystream(&mut buffer);
+
+    assert_eq!(ctr.get_core().get_block_pos(), 4);
+    assert_eq!(
+        &buffer[..],
+        &hex!(
+            "A1E649D8B382293DC28375C42443BB6A226BAADC9E9CCA8214F56E07A4024E06"
+            "6355A0DA2E08FB00112FFA38C26189EE55DD5B0B130ED87096FE01B59A665A60"
+        )[..]
+    );
+}
+
+cipher::iv_state_test!(
+    iv_state,
+    ctr::CtrCore<aes::Aes128, ctr::flavors::Ctr32LE>,
+    apply_ks,
+);

vendor/ctr/tests/ctr32/mod.rs

@@ -0,0 +1,9 @@
+//! Counter Mode with a 32-bit counter.
+//!
+//! NOTE: AES-128-CTR test vectors used by these tests were generated by first
+//! integration testing the implementation in the contexts of AES-GCM and
+//! AES-GCM-SIV, with the former tested against the NIST CAVS vectors, and the
+//! latter against the RFC8452 test vectors.
+
+mod be;
+mod le;

vendor/ctr/tests/gost/mod.rs

@@ -0,0 +1,55 @@
+use cipher::{KeyIvInit, StreamCipher};
+use hex_literal::hex;
+
+type MagmaCtr = ctr::Ctr32BE<magma::Magma>;
+type KuznyechikCtr = ctr::Ctr64BE<kuznyechik::Kuznyechik>;
+
+/// Test vectors from GOST R 34.13-2015 (Section A.1.2)
+#[test]
+fn kuznyechik() {
+    let key = hex!(
+        "8899aabbccddeeff0011223344556677"
+        "fedcba98765432100123456789abcdef"
+    );
+    let nonce = hex!("1234567890abcef00000000000000000");
+    let mut pt = hex!(
+        "1122334455667700ffeeddccbbaa9988"
+        "00112233445566778899aabbcceeff0a"
+        "112233445566778899aabbcceeff0a00"
+        "2233445566778899aabbcceeff0a0011"
+    );
+    let ct = hex!(
+        "f195d8bec10ed1dbd57b5fa240bda1b8"
+        "85eee733f6a13e5df33ce4b33c45dee4"
+        "a5eae88be6356ed3d5e877f13564a3a5"
+        "cb91fab1f20cbab6d1c6d15820bdba73"
+    );
+    let mut cipher = KuznyechikCtr::new(&key.into(), &nonce.into());
+    cipher.apply_keystream(&mut pt);
+    assert_eq!(pt[..], ct[..]);
+}
+
+/// Test vectors from GOST R 34.13-2015 (Section A.2.2)
+#[test]
+fn magma() {
+    let key = hex!(
+        "ffeeddccbbaa99887766554433221100"
+        "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
+    );
+    let nonce = hex!("1234567800000000");
+    let mut pt = hex!(
+        "92def06b3c130a59"
+        "db54c704f8189d20"
+        "4a98fb2e67a8024c"
+        "8912409b17b57e41"
+    );
+    let ct = hex!(
+        "4e98110c97b7b93c"
+        "3e250d93d6e85d69"
+        "136d868807b2dbef"
+        "568eb680ab52a12d"
+    );
+    let mut cipher = MagmaCtr::new(&key.into(), &nonce.into());
+    cipher.apply_keystream(&mut pt);
+    assert_eq!(pt[..], ct[..]);
+}

vendor/ctr/tests/mod.rs

@@ -0,0 +1,5 @@
+//! Counter Mode Tests
+
+mod ctr128;
+mod ctr32;
+mod gost;