From 8619829972a41469daa8edd890f1dcd0567a8a4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D1=80=D1=82=D1=91=D0=BC=20=D0=9F=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=BE=D0=B2=20=5BArtyom=20Pavlov=5D?= Date: Fri, 5 Sep 2025 17:31:19 +0300 Subject: [PATCH 1/2] Migrate to new dev macros --- Cargo.lock | 21 ++-- Cargo.toml | 6 ++ belt-ctr/tests/mod.rs | 13 ++- cbc/benches/aes128.rs | 7 +- cbc/tests/aes.rs | 26 ----- cbc/tests/aes_cavp.rs | 21 ++++ cbc/tests/iv_state.rs | 10 ++ cfb-mode/benches/aes128.rs | 7 +- cfb-mode/tests/aes.rs | 118 -------------------- cfb-mode/tests/aes_cavp.rs | 22 ++++ cfb-mode/tests/async_stream.rs | 95 ++++++++++++++++ cfb-mode/tests/belt.rs | 20 ++-- cfb-mode/tests/iv_state.rs | 10 ++ cfb8/benches/aes128.rs | 7 +- cfb8/tests/aes.rs | 56 ---------- cfb8/tests/aes_cavp.rs | 21 ++++ cfb8/tests/async_stream.rs | 31 ++++++ cfb8/tests/iv_state.rs | 10 ++ ctr/tests/ctr128/mod.rs | 25 +++-- ctr/tests/ctr32/be.rs | 173 +++++++++++++++-------------- ctr/tests/ctr32/le.rs | 191 ++++++++++++++++----------------- ige/benches/aes128.rs | 7 +- ige/tests/aes.rs | 24 ++--- ige/tests/iv_state.rs | 6 ++ ofb/benches/aes128.rs | 8 +- ofb/tests/aes.rs | 64 +++++------ ofb/tests/iv_state.rs | 13 +++ pcbc/benches/aes128.rs | 7 +- pcbc/tests/aes.rs | 22 ++-- pcbc/tests/iv_state.rs | 6 ++ 30 files changed, 527 insertions(+), 520 deletions(-) delete mode 100644 cbc/tests/aes.rs create mode 100644 cbc/tests/aes_cavp.rs create mode 100644 cbc/tests/iv_state.rs delete mode 100644 cfb-mode/tests/aes.rs create mode 100644 cfb-mode/tests/aes_cavp.rs create mode 100644 cfb-mode/tests/async_stream.rs create mode 100644 cfb-mode/tests/iv_state.rs delete mode 100644 cfb8/tests/aes.rs create mode 100644 cfb8/tests/aes_cavp.rs create mode 100644 cfb8/tests/async_stream.rs create mode 100644 cfb8/tests/iv_state.rs create mode 100644 ige/tests/iv_state.rs create mode 100644 ofb/tests/iv_state.rs create mode 100644 pcbc/tests/iv_state.rs diff --git a/Cargo.lock b/Cargo.lock index e706684..9b82082 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -34,8 +34,7 @@ dependencies = [ [[package]] name = "blobby" version = "0.4.0-pre.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a859067dcb257cb2ae028cb821399b55140b76fb8b2a360e052fe109019db43" +source = "git+https://github.com/RustCrypto/utils#303c9e8e8fd5e08de4719bd6614935bc68c63a55" [[package]] name = "block-buffer" @@ -86,15 +85,14 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" [[package]] name = "cipher" version = "0.5.0-rc.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e12a13eb01ded5d32ee9658d94f553a19e804204f2dc811df69ab4d9e0cb8c7" +source = "git+https://github.com/RustCrypto/traits?branch=cipher%2Fdev_block_tweak#88ca34c87d54258cd8c13fc32df4bd7a7fd5d063" dependencies = [ "blobby", "block-buffer", @@ -115,8 +113,7 @@ dependencies = [ [[package]] name = "crypto-common" version = "0.2.0-rc.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a8235645834fbc6832939736ce2f2d08192652269e11010a6240f61b908a1c6" +source = "git+https://github.com/RustCrypto/traits?branch=cipher%2Fdev_block_tweak#88ca34c87d54258cd8c13fc32df4bd7a7fd5d063" dependencies = [ "hybrid-array", ] @@ -189,9 +186,9 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.170" +version = "0.2.175" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "875b3680cb2f8f71bdcf9a30f38d48282f5d3c95cbf9b3fa57269bb5d5c06828" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" [[package]] name = "magma" @@ -222,9 +219,9 @@ dependencies = [ [[package]] name = "typenum" -version = "1.17.0" +version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" +checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f" [[package]] name = "zeroize" diff --git a/Cargo.toml b/Cargo.toml index db63e39..f4506bb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,3 +14,9 @@ members = [ [profile.dev] opt-level = 2 + +[patch.crates-io] +# https://github.com/RustCrypto/traits/pull/1998 +cipher = { git = "https://github.com/RustCrypto/traits", branch = "cipher/dev_block_tweak" } +# https://github.com/RustCrypto/utils/pull/1187 +blobby = { git = "https://github.com/RustCrypto/utils" } diff --git a/belt-ctr/tests/mod.rs b/belt-ctr/tests/mod.rs index 696b7c8..f4d50de 100644 --- a/belt-ctr/tests/mod.rs +++ b/belt-ctr/tests/mod.rs @@ -1,8 +1,7 @@ -// use belt_ctr::{BeltCtr, BeltCtrCore}; +//! Test vectors from the BelT standard (tables A.15 and A.16): +//! https://apmi.bsu.by/assets/files/std/belt-spec371.pdf +use belt_ctr::{BeltCtr, BeltCtrCore}; -// Test vectors from the BelT standard (tables A.15 and A.16): -// https://apmi.bsu.by/assets/files/std/belt-spec371.pdf -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// cipher::stream_cipher_test!(belt_ctr_core, "belt-ctr", BeltCtr); -// cipher::stream_cipher_seek_test!(belt_ctr_seek, BeltCtr); -// cipher::iv_state_test!(belt_ctr_iv_state, BeltCtrCore, apply_ks); +cipher::stream_cipher_test!(belt_ctr_core, "belt-ctr", BeltCtr); +cipher::stream_cipher_seek_test!(belt_ctr_seek, BeltCtr); +cipher::iv_state_test!(belt_ctr_iv_state, BeltCtrCore, apply_ks); diff --git a/cbc/benches/aes128.rs b/cbc/benches/aes128.rs index b478146..792c53d 100644 --- a/cbc/benches/aes128.rs +++ b/cbc/benches/aes128.rs @@ -1,16 +1,13 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::block_encryptor_bench!( - KeyIv: cbc::Encryptor, + KeyIv: cbc::Encryptor, cbc_aes128_encrypt_block, cbc_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: cbc::Decryptor, + KeyIv: cbc::Decryptor, cbc_aes128_decrypt_block, cbc_aes128_decrypt_blocks, ); diff --git a/cbc/tests/aes.rs b/cbc/tests/aes.rs deleted file mode 100644 index 8340af7..0000000 --- a/cbc/tests/aes.rs +++ /dev/null @@ -1,26 +0,0 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::*; -// use cbc::{Decryptor, Encryptor}; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// -// iv_state_test!(aes128_cbc_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes128_cbc_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes192_cbc_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes192_cbc_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes256_cbc_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes256_cbc_dec_iv_state, Decryptor, decrypt); -// -// // Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": -// // -// block_mode_enc_test!(aes128_cbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128_cbc_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes128enc_cbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128dec_cbc_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes192_cbc_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192_cbc_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes192enc_cbc_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192dec_cbc_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes256_cbc_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256_cbc_dec_test, "aes256", Decryptor); -// block_mode_enc_test!(aes256enc_cbc_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256dec_cbc_dec_test, "aes256", Decryptor); diff --git a/cbc/tests/aes_cavp.rs b/cbc/tests/aes_cavp.rs new file mode 100644 index 0000000..c6ab5ae --- /dev/null +++ b/cbc/tests/aes_cavp.rs @@ -0,0 +1,21 @@ +//! Test vectors from CAVP "AES Multiblock Message Test (MMT) Sample Vectors": +//! +use aes::*; +use cbc::{Decryptor, Encryptor}; +use cipher::block_mode_test; + +block_mode_test!(aes128_cbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192_cbc_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256_cbc_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128_cbc_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192_cbc_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256_cbc_dec, "aes256", Decryptor, decrypt); + +block_mode_test!(aes128enc_cbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192enc_cbc_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256enc_cbc_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128dec_cbc_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192dec_cbc_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256dec_cbc_dec, "aes256", Decryptor, decrypt); diff --git a/cbc/tests/iv_state.rs b/cbc/tests/iv_state.rs new file mode 100644 index 0000000..ccfe8bc --- /dev/null +++ b/cbc/tests/iv_state.rs @@ -0,0 +1,10 @@ +use aes::*; +use cbc::{Decryptor, Encryptor}; +use cipher::iv_state_test; + +iv_state_test!(aes128_cbc_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes128_cbc_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes192_cbc_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes192_cbc_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes256_cbc_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes256_cbc_dec_iv_state, Decryptor, decrypt); diff --git a/cfb-mode/benches/aes128.rs b/cfb-mode/benches/aes128.rs index 1d5c9df..6c53ab9 100644 --- a/cfb-mode/benches/aes128.rs +++ b/cfb-mode/benches/aes128.rs @@ -1,16 +1,13 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::block_encryptor_bench!( - KeyIv: cfb_mode::Encryptor, + KeyIv: cfb_mode::Encryptor, cfb_aes128_encrypt_block, cfb_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: cfb_mode::Decryptor, + KeyIv: cfb_mode::Decryptor, cfb_aes128_decrypt_block, cfb_aes128_decrypt_blocks, ); diff --git a/cfb-mode/tests/aes.rs b/cfb-mode/tests/aes.rs deleted file mode 100644 index f6db937..0000000 --- a/cfb-mode/tests/aes.rs +++ /dev/null @@ -1,118 +0,0 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::*; -// use cfb_mode::{BufDecryptor, BufEncryptor, Decryptor, Encryptor}; -// use cipher::{KeyInit, block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// -// iv_state_test!(aes128_cfb_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes128_cfb_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes192_cfb_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes192_cfb_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes256_cfb_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes256_cfb_dec_iv_state, Decryptor, decrypt); -// -// // Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": -// // -// block_mode_enc_test!(aes128_cfb_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128_cfb_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes128enc_cfb_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128enc_cfb_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes192_cfb_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192_cfb_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes192enc_cfb_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192dec_cfb_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes256_cfb_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256_cfb_dec_test, "aes256", Decryptor); -// block_mode_enc_test!(aes256enc_cfb_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256dec_cfb_dec_test, "aes256", Decryptor); -// -// /// Test methods from the `AsyncStreamCipher` trait. -// #[test] -// fn aes128_cfb_async_test() { -// use cipher::{AsyncStreamCipher, KeyIvInit}; -// -// type Enc = Encryptor; -// type Dec = Decryptor; -// -// let key = [42; 16]; -// let iv = [24; 16]; -// let mut pt = [0u8; 101]; -// for (i, b) in pt.iter_mut().enumerate() { -// *b = (i % 11) as u8; -// } -// let enc = Enc::new_from_slices(&key, &iv).unwrap(); -// let mut ct = pt; -// enc.encrypt(&mut ct); -// for i in 1..100 { -// let enc = Enc::new_from_slices(&key, &iv).unwrap(); -// let mut t = pt; -// let t = &mut t[..i]; -// enc.encrypt(t); -// assert_eq!(t, &ct[..i]); -// -// let dec = Dec::new_from_slices(&key, &iv).unwrap(); -// dec.decrypt(t); -// assert_eq!(t, &pt[..i]); -// } -// } -// -// #[test] -// fn aes128_cfb_buffered_test() { -// use cipher::{AsyncStreamCipher, KeyIvInit}; -// -// type Enc = Encryptor; -// -// type BufEnc = BufEncryptor; -// type BufDec = BufDecryptor; -// -// let key = [42; 16]; -// let iv = [24; 16]; -// let mut pt = [0u8; 101]; -// for (i, b) in pt.iter_mut().enumerate() { -// *b = (i % 11) as u8; -// } -// -// // unbuffered -// let enc = Enc::new_from_slices(&key, &iv).unwrap(); -// let mut ct = pt; -// enc.encrypt(&mut ct); -// -// // buffered -// for i in 1..100 { -// let mut buf_enc = BufEnc::new_from_slices(&key, &iv).unwrap(); -// let mut ct2 = pt; -// for chunk in ct2.chunks_mut(i) { -// buf_enc.encrypt(chunk); -// } -// assert_eq!(ct2, ct); -// -// let mut buf_dec = BufDec::new_from_slices(&key, &iv).unwrap(); -// for chunk in ct2.chunks_mut(i) { -// buf_dec.decrypt(chunk); -// } -// assert_eq!(ct2, pt); -// } -// -// // buffered with restore -// for i in 1..100 { -// let mut buf_enc = BufEnc::new_from_slices(&key, &iv).unwrap(); -// let mut ct2 = pt; -// for chunk in ct2.chunks_mut(i) { -// let (iv, pos) = buf_enc.get_state(); -// let cipher = Aes128::new_from_slice(&key).unwrap(); -// buf_enc = BufEnc::from_state(cipher, iv, pos); -// -// buf_enc.encrypt(chunk); -// } -// assert_eq!(ct2, ct); -// -// let mut buf_dec = BufDec::new_from_slices(&key, &iv).unwrap(); -// for chunk in ct2.chunks_mut(i) { -// let (iv, pos) = buf_dec.get_state(); -// let cipher = Aes128::new_from_slice(&key).unwrap(); -// buf_dec = BufDec::from_state(cipher, iv, pos); -// -// buf_dec.decrypt(chunk); -// } -// assert_eq!(ct2, pt); -// } -// } diff --git a/cfb-mode/tests/aes_cavp.rs b/cfb-mode/tests/aes_cavp.rs new file mode 100644 index 0000000..741d973 --- /dev/null +++ b/cfb-mode/tests/aes_cavp.rs @@ -0,0 +1,22 @@ +//! Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": +//! + +use aes::*; +use cfb_mode::{Decryptor, Encryptor}; +use cipher::block_mode_test; + +block_mode_test!(aes128_cfb_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192_cfb_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256_cfb_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128_cfb_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192_cfb_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256_cfb_dec, "aes256", Decryptor, decrypt); + +block_mode_test!(aes128enc_cfb_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192enc_cfb_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256enc_cfb_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128enc_cfb_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192dec_cfb_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256dec_cfb_dec, "aes256", Decryptor, decrypt); diff --git a/cfb-mode/tests/async_stream.rs b/cfb-mode/tests/async_stream.rs new file mode 100644 index 0000000..01e9a97 --- /dev/null +++ b/cfb-mode/tests/async_stream.rs @@ -0,0 +1,95 @@ +//! Tests for the `AsyncStreamCipher` trait methods +use aes::*; +use cfb_mode::{BufDecryptor, BufEncryptor, Decryptor, Encryptor}; +use cipher::KeyInit; + +#[test] +fn aes128_cfb_async_test() { + use cipher::{AsyncStreamCipher, KeyIvInit}; + + type Enc = Encryptor; + type Dec = Decryptor; + + let key = [42; 16]; + let iv = [24; 16]; + let mut pt = [0u8; 101]; + for (i, b) in pt.iter_mut().enumerate() { + *b = (i % 11) as u8; + } + let enc = Enc::new_from_slices(&key, &iv).unwrap(); + let mut ct = pt; + enc.encrypt(&mut ct); + for i in 1..100 { + let enc = Enc::new_from_slices(&key, &iv).unwrap(); + let mut t = pt; + let t = &mut t[..i]; + enc.encrypt(t); + assert_eq!(t, &ct[..i]); + + let dec = Dec::new_from_slices(&key, &iv).unwrap(); + dec.decrypt(t); + assert_eq!(t, &pt[..i]); + } +} + +#[test] +fn aes128_cfb_buffered_test() { + use cipher::{AsyncStreamCipher, KeyIvInit}; + + type Enc = Encryptor; + + type BufEnc = BufEncryptor; + type BufDec = BufDecryptor; + + let key = [42; 16]; + let iv = [24; 16]; + let mut pt = [0u8; 101]; + for (i, b) in pt.iter_mut().enumerate() { + *b = (i % 11) as u8; + } + + // unbuffered + let enc = Enc::new_from_slices(&key, &iv).unwrap(); + let mut ct = pt; + enc.encrypt(&mut ct); + + // buffered + for i in 1..100 { + let mut buf_enc = BufEnc::new_from_slices(&key, &iv).unwrap(); + let mut ct2 = pt; + for chunk in ct2.chunks_mut(i) { + buf_enc.encrypt(chunk); + } + assert_eq!(ct2, ct); + + let mut buf_dec = BufDec::new_from_slices(&key, &iv).unwrap(); + for chunk in ct2.chunks_mut(i) { + buf_dec.decrypt(chunk); + } + assert_eq!(ct2, pt); + } + + // buffered with restore + for i in 1..100 { + let mut buf_enc = BufEnc::new_from_slices(&key, &iv).unwrap(); + let mut ct2 = pt; + for chunk in ct2.chunks_mut(i) { + let (iv, pos) = buf_enc.get_state(); + let cipher = Aes128::new_from_slice(&key).unwrap(); + buf_enc = BufEnc::from_state(cipher, iv, pos); + + buf_enc.encrypt(chunk); + } + assert_eq!(ct2, ct); + + let mut buf_dec = BufDec::new_from_slices(&key, &iv).unwrap(); + for chunk in ct2.chunks_mut(i) { + let (iv, pos) = buf_dec.get_state(); + let cipher = Aes128::new_from_slice(&key).unwrap(); + buf_dec = BufDec::from_state(cipher, iv, pos); + + buf_dec.decrypt(chunk); + } + assert_eq!(ct2, pt); + } +} diff --git a/cfb-mode/tests/belt.rs b/cfb-mode/tests/belt.rs index 4fa5fb8..9a89cb8 100644 --- a/cfb-mode/tests/belt.rs +++ b/cfb-mode/tests/belt.rs @@ -1,12 +1,8 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use belt_block::BeltBlock; -// use cfb_mode::{Decryptor, Encryptor}; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// -// iv_state_test!(belt_cfb_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(belt_cfb_dec_iv_state, Decryptor, decrypt); -// -// // Test vectors from STB 34.101.31-2020 (tables А.13 and А.14): -// // -// block_mode_enc_test!(belt_cfb_enc_test, "belt", Encryptor); -// block_mode_dec_test!(belt_cfb_dec_test, "belt", Decryptor); +//! Test vectors from STB 34.101.31-2020 (tables А.13 and А.14): +//! +use belt_block::BeltBlock; +use cfb_mode::{Decryptor, Encryptor}; +use cipher::block_mode_test; + +block_mode_test!(belt_cfb_enc_test, "belt", Encryptor, encrypt); +block_mode_test!(belt_cfb_dec_test, "belt", Decryptor, decrypt); diff --git a/cfb-mode/tests/iv_state.rs b/cfb-mode/tests/iv_state.rs new file mode 100644 index 0000000..4732bd2 --- /dev/null +++ b/cfb-mode/tests/iv_state.rs @@ -0,0 +1,10 @@ +use aes::*; +use cfb_mode::{Decryptor, Encryptor}; +use cipher::iv_state_test; + +iv_state_test!(aes128_cfb_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes128_cfb_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes192_cfb_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes192_cfb_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes256_cfb_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes256_cfb_dec_iv_state, Decryptor, decrypt); diff --git a/cfb8/benches/aes128.rs b/cfb8/benches/aes128.rs index aa6dd6b..eff71ea 100644 --- a/cfb8/benches/aes128.rs +++ b/cfb8/benches/aes128.rs @@ -1,16 +1,13 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::block_encryptor_bench!( - KeyIv: cfb8::Encryptor, + KeyIv: cfb8::Encryptor, cfb8_aes128_encrypt_block, cfb8_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: cfb8::Decryptor, + KeyIv: cfb8::Decryptor, cfb8_aes128_decrypt_block, cfb8_aes128_decrypt_blocks, ); diff --git a/cfb8/tests/aes.rs b/cfb8/tests/aes.rs deleted file mode 100644 index b3e4e16..0000000 --- a/cfb8/tests/aes.rs +++ /dev/null @@ -1,56 +0,0 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::*; -// use cfb8::{Decryptor, Encryptor}; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// -// iv_state_test!(aes128_cfb8_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes128_cfb8_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes192_cfb8_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes192_cfb8_dec_iv_state, Decryptor, decrypt); -// iv_state_test!(aes256_cfb8_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes256_cfb8_dec_iv_state, Decryptor, decrypt); -// -// // Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": -// // -// block_mode_enc_test!(aes128_cfb8_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128_cfb8_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes128enc_cfb8_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128enc_cfb8_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes192_cfb8_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192_cfb8_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes192enc_cfb8_enc_test, "aes192", Encryptor); -// block_mode_dec_test!(aes192dec_cfb8_dec_test, "aes192", Decryptor); -// block_mode_enc_test!(aes256_cfb8_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256_cfb8_dec_test, "aes256", Decryptor); -// block_mode_enc_test!(aes256enc_cfb8_enc_test, "aes256", Encryptor); -// block_mode_dec_test!(aes256dec_cfb8_dec_test, "aes256", Decryptor); -// -// /// Test methods from the `AsyncStreamCipher` trait. -// #[test] -// fn aes128_cfb8_async_test() { -// use cipher::{AsyncStreamCipher, KeyIvInit}; -// -// type Enc = Encryptor; -// type Dec = Decryptor; -// -// let key = [42; 16]; -// let iv = [24; 16]; -// let mut pt = [0u8; 101]; -// for (i, b) in pt.iter_mut().enumerate() { -// *b = (i % 11) as u8; -// } -// let enc = Enc::new_from_slices(&key, &iv).unwrap(); -// let mut ct = pt; -// enc.encrypt(&mut ct); -// for i in 1..100 { -// let enc = Enc::new_from_slices(&key, &iv).unwrap(); -// let mut t = pt; -// let t = &mut t[..i]; -// enc.encrypt(t); -// assert_eq!(t, &ct[..i]); -// -// let dec = Dec::new_from_slices(&key, &iv).unwrap(); -// dec.decrypt(t); -// assert_eq!(t, &pt[..i]); -// } -// } diff --git a/cfb8/tests/aes_cavp.rs b/cfb8/tests/aes_cavp.rs new file mode 100644 index 0000000..18b2098 --- /dev/null +++ b/cfb8/tests/aes_cavp.rs @@ -0,0 +1,21 @@ +//! Test vectors from CAVP "AES Multiblock Message Test (MMT) Sample Vectors": +//! +use aes::*; +use cfb8::{Decryptor, Encryptor}; +use cipher::block_mode_test; + +block_mode_test!(aes128_cfb8_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192_cfb8_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256_cfb8_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128_cfb8_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192_cfb8_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256_cfb8_dec, "aes256", Decryptor, decrypt); + +block_mode_test!(aes128enc_cfb8_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes192enc_cfb8_enc, "aes192", Encryptor, encrypt); +block_mode_test!(aes256enc_cfb8_enc, "aes256", Encryptor, encrypt); + +block_mode_test!(aes128enc_cfb8_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes192dec_cfb8_dec, "aes192", Decryptor, decrypt); +block_mode_test!(aes256dec_cfb8_dec, "aes256", Decryptor, decrypt); diff --git a/cfb8/tests/async_stream.rs b/cfb8/tests/async_stream.rs new file mode 100644 index 0000000..db35c3e --- /dev/null +++ b/cfb8/tests/async_stream.rs @@ -0,0 +1,31 @@ +//! Tests for the [`AsyncStreamCipher`] methods. +use aes::*; +use cfb8::{Decryptor, Encryptor}; +use cipher::{AsyncStreamCipher, KeyIvInit}; + +#[test] +fn aes128_cfb8_async_test() { + type Enc = Encryptor; + type Dec = Decryptor; + + let key = [42; 16]; + let iv = [24; 16]; + let mut pt = [0u8; 101]; + for (i, b) in pt.iter_mut().enumerate() { + *b = (i % 11) as u8; + } + let enc = Enc::new_from_slices(&key, &iv).unwrap(); + let mut ct = pt; + enc.encrypt(&mut ct); + for i in 1..100 { + let enc = Enc::new_from_slices(&key, &iv).unwrap(); + let mut t = pt; + let t = &mut t[..i]; + enc.encrypt(t); + assert_eq!(t, &ct[..i]); + + let dec = Dec::new_from_slices(&key, &iv).unwrap(); + dec.decrypt(t); + assert_eq!(t, &pt[..i]); + } +} diff --git a/cfb8/tests/iv_state.rs b/cfb8/tests/iv_state.rs new file mode 100644 index 0000000..fdef674 --- /dev/null +++ b/cfb8/tests/iv_state.rs @@ -0,0 +1,10 @@ +use aes::*; +use cfb8::{Decryptor, Encryptor}; +use cipher::iv_state_test; + +iv_state_test!(aes128_cfb8_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes128_cfb8_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes192_cfb8_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes192_cfb8_dec_iv_state, Decryptor, decrypt); +iv_state_test!(aes256_cfb8_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes256_cfb8_dec_iv_state, Decryptor, decrypt); diff --git a/ctr/tests/ctr128/mod.rs b/ctr/tests/ctr128/mod.rs index 4b1f26b..8bc0a77 100644 --- a/ctr/tests/ctr128/mod.rs +++ b/ctr/tests/ctr128/mod.rs @@ -1,13 +1,12 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::{Aes128, Aes256}; -// use ctr::{Ctr128BE, CtrCore, flavors}; -// -// cipher::stream_cipher_test!(aes128_ctr_core, "aes128-ctr", Ctr128BE); -// cipher::stream_cipher_test!(aes256_ctr_core, "aes256-ctr", Ctr128BE); -// cipher::stream_cipher_seek_test!(aes128_ctr_seek, Ctr128BE); -// cipher::stream_cipher_seek_test!(aes256_ctr_seek, Ctr128BE); -// cipher::iv_state_test!( -// aes128_ctr_iv_state, -// CtrCore, -// apply_ks, -// ); +use aes::{Aes128, Aes256}; +use ctr::{Ctr128BE, CtrCore, flavors}; + +cipher::stream_cipher_test!(aes128_ctr_core, "aes128-ctr", Ctr128BE); +cipher::stream_cipher_test!(aes256_ctr_core, "aes256-ctr", Ctr128BE); +cipher::stream_cipher_seek_test!(aes128_ctr_seek, Ctr128BE); +cipher::stream_cipher_seek_test!(aes256_ctr_seek, Ctr128BE); +cipher::iv_state_test!( + aes128_ctr_iv_state, + CtrCore, + apply_ks, +); diff --git a/ctr/tests/ctr32/be.rs b/ctr/tests/ctr32/be.rs index 4dfd0a4..98b1302 100644 --- a/ctr/tests/ctr32/be.rs +++ b/ctr/tests/ctr32/be.rs @@ -1,87 +1,86 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// //! Counter Mode with a 32-bit big endian counter -// -// use cipher::{KeyIvInit, StreamCipher, StreamCipherSeek, StreamCipherSeekCore}; -// use hex_literal::hex; -// -// type Aes128Ctr = ctr::Ctr32BE; -// -// 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, -// apply_ks, -// ); +//! Counter Mode with a 32-bit big endian counter + +use cipher::{KeyIvInit, StreamCipher, StreamCipherSeek, StreamCipherSeekCore}; +use hex_literal::hex; + +type Aes128Ctr = ctr::Ctr32BE; + +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, + apply_ks, +); diff --git a/ctr/tests/ctr32/le.rs b/ctr/tests/ctr32/le.rs index b470444..a270dbd 100644 --- a/ctr/tests/ctr32/le.rs +++ b/ctr/tests/ctr32/le.rs @@ -1,96 +1,95 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// //! Counter Mode with a 32-bit little endian counter -// -// use cipher::{ -// KeyIvInit, StreamCipher, StreamCipherSeek, StreamCipherSeekCore, array::Array, consts::U16, -// }; -// use hex_literal::hex; -// -// type Aes128Ctr = ctr::Ctr32LE; -// -// 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]) -> Array { -// 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, -// apply_ks, -// ); +//! Counter Mode with a 32-bit little endian counter + +use cipher::{ + KeyIvInit, StreamCipher, StreamCipherSeek, StreamCipherSeekCore, array::Array, consts::U16, +}; +use hex_literal::hex; + +type Aes128Ctr = ctr::Ctr32LE; + +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]) -> Array { + 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, + apply_ks, +); diff --git a/ige/benches/aes128.rs b/ige/benches/aes128.rs index af67406..0c65622 100644 --- a/ige/benches/aes128.rs +++ b/ige/benches/aes128.rs @@ -1,16 +1,13 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::block_encryptor_bench!( - KeyIv: ige::Encryptor, + KeyIv: ige::Encryptor, ige_aes128_encrypt_block, ige_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: ige::Decryptor, + KeyIv: ige::Decryptor, ige_aes128_decrypt_block, ige_aes128_decrypt_blocks, ); diff --git a/ige/tests/aes.rs b/ige/tests/aes.rs index f725839..e0ff8f6 100644 --- a/ige/tests/aes.rs +++ b/ige/tests/aes.rs @@ -1,14 +1,10 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::{Aes128, Aes128Dec, Aes128Enc}; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// use ige::{Decryptor, Encryptor}; -// -// iv_state_test!(aes128_ige_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes128_ige_dec_iv_state, Decryptor, decrypt); -// -// // Test vectors from: -// // https://mgp25.com/blog/2015/06/21/AESIGE/#test-vectors -// block_mode_enc_test!(aes128_cbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128_cbc_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes128enc_cbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128dec_cbc_dec_test, "aes128", Decryptor); +//! Test vectors from: +//! +use aes::{Aes128, Aes128Dec, Aes128Enc}; +use cipher::block_mode_test; +use ige::{Decryptor, Encryptor}; + +block_mode_test!(aes128_cbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes128_cbc_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes128enc_cbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes128dec_cbc_dec, "aes128", Decryptor, decrypt); diff --git a/ige/tests/iv_state.rs b/ige/tests/iv_state.rs new file mode 100644 index 0000000..d11c1bf --- /dev/null +++ b/ige/tests/iv_state.rs @@ -0,0 +1,6 @@ +use aes::Aes128; +use cipher::iv_state_test; +use ige::{Decryptor, Encryptor}; + +iv_state_test!(aes128_ige_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes128_ige_dec_iv_state, Decryptor, decrypt); diff --git a/ofb/benches/aes128.rs b/ofb/benches/aes128.rs index d3f7c70..7eeec0e 100644 --- a/ofb/benches/aes128.rs +++ b/ofb/benches/aes128.rs @@ -1,8 +1,6 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::stream_cipher_bench!( ofb::Ofb; ofb_aes128_stream_bench1_16b 16; @@ -10,15 +8,13 @@ cipher::stream_cipher_bench!( ofb_aes128_stream_bench3_1kib 1024; ofb_aes128_stream_bench4_16kib 16384; ); - cipher::block_encryptor_bench!( - KeyIv: ofb::OfbCore, + KeyIv: ofb::OfbCore, ofb_aes128_encrypt_block, ofb_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: ofb::OfbCore, + KeyIv: ofb::OfbCore, ofb_aes128_decrypt_block, ofb_aes128_decrypt_blocks, ); diff --git a/ofb/tests/aes.rs b/ofb/tests/aes.rs index ee3aed3..f89f8b2 100644 --- a/ofb/tests/aes.rs +++ b/ofb/tests/aes.rs @@ -1,35 +1,29 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::*; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test, stream_cipher_test}; -// use ofb::{Ofb, OfbCore}; -// -// iv_state_test!(aes128_ofb_enc_iv_state, OfbCore, encrypt); -// iv_state_test!(aes128_ofb_dec_iv_state, OfbCore, decrypt); -// iv_state_test!(aes128_ofb_apply_ks_iv_state, OfbCore, apply_ks); -// iv_state_test!(aes192_ofb_enc_iv_state, OfbCore, encrypt); -// iv_state_test!(aes192_ofb_dec_iv_state, OfbCore, decrypt); -// iv_state_test!(aes192_ofb_apply_ks_iv_state, OfbCore, apply_ks); -// iv_state_test!(aes256_ofb_enc_iv_state, OfbCore, encrypt); -// iv_state_test!(aes256_ofb_dec_iv_state, OfbCore, decrypt); -// iv_state_test!(aes256_ofb_apply_ks_iv_state, OfbCore, apply_ks); -// -// // Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": -// // -// block_mode_enc_test!(aes128_ofb_enc_test, "aes128", OfbCore); -// block_mode_dec_test!(aes128_ofb_dec_test, "aes128", OfbCore); -// block_mode_enc_test!(aes128enc_ofb_enc_test, "aes128", OfbCore); -// block_mode_dec_test!(aes128dec_ofb_dec_test, "aes128", OfbCore); -// stream_cipher_test!(aes128_ofb_stream_test, "aes128", Ofb); -// stream_cipher_test!(aes128enc_ofb_stream_test, "aes128", Ofb); -// block_mode_enc_test!(aes192_ofb_enc_test, "aes192", OfbCore); -// block_mode_dec_test!(aes192_ofb_dec_test, "aes192", OfbCore); -// block_mode_enc_test!(aes192enc_ofb_enc_test, "aes192", OfbCore); -// block_mode_dec_test!(aes192dec_ofb_dec_test, "aes192", OfbCore); -// stream_cipher_test!(aes192_ofb_stream_test, "aes192", Ofb); -// stream_cipher_test!(aes192enc_ofb_stream_test, "aes192", Ofb); -// block_mode_enc_test!(aes256_ofb_enc_test, "aes256", OfbCore); -// block_mode_dec_test!(aes256_ofb_dec_test, "aes256", OfbCore); -// block_mode_enc_test!(aes256enc_ofb_enc_test, "aes256", OfbCore); -// block_mode_dec_test!(aes256dec_ofb_dec_test, "aes256", OfbCore); -// stream_cipher_test!(aes256_ofb_stream_test, "aes256", Ofb); -// stream_cipher_test!(aes256enc_ofb_stream_test, "aes256", Ofb); +//! Test vectors from CVAP "AES Multiblock Message Test (MMT) Sample Vectors": +//! +use aes::*; +use cipher::{block_mode_test, stream_cipher_test}; +use ofb::{Ofb, OfbCore}; + +block_mode_test!(aes128_ofb_enc, "aes128", OfbCore, encrypt); +block_mode_test!(aes192_ofb_enc, "aes192", OfbCore, encrypt); +block_mode_test!(aes256_ofb_enc, "aes256", OfbCore, encrypt); + +block_mode_test!(aes128_ofb_dec, "aes128", OfbCore, decrypt); +block_mode_test!(aes192_ofb_dec, "aes192", OfbCore, decrypt); +block_mode_test!(aes256_ofb_dec, "aes256", OfbCore, decrypt); + +block_mode_test!(aes128enc_ofb_enc, "aes128", OfbCore, encrypt); +block_mode_test!(aes192enc_ofb_enc, "aes192", OfbCore, encrypt); +block_mode_test!(aes256enc_ofb_enc, "aes256", OfbCore, encrypt); + +block_mode_test!(aes128enc_ofb_dec, "aes128", OfbCore, decrypt); +block_mode_test!(aes192enc_ofb_dec, "aes192", OfbCore, decrypt); +block_mode_test!(aes256enc_ofb_dec, "aes256", OfbCore, decrypt); + +stream_cipher_test!(aes128_ofb_stream_test, "aes128", Ofb); +stream_cipher_test!(aes192_ofb_stream_test, "aes192", Ofb); +stream_cipher_test!(aes256_ofb_stream_test, "aes256", Ofb); + +stream_cipher_test!(aes128enc_ofb_stream_test, "aes128", Ofb); +stream_cipher_test!(aes192enc_ofb_stream_test, "aes192", Ofb); +stream_cipher_test!(aes256enc_ofb_stream_test, "aes256", Ofb); diff --git a/ofb/tests/iv_state.rs b/ofb/tests/iv_state.rs new file mode 100644 index 0000000..23e8dc3 --- /dev/null +++ b/ofb/tests/iv_state.rs @@ -0,0 +1,13 @@ +use aes::*; +use cipher::iv_state_test; +use ofb::OfbCore; + +iv_state_test!(aes128_ofb_enc_iv_state, OfbCore, encrypt); +iv_state_test!(aes128_ofb_dec_iv_state, OfbCore, decrypt); +iv_state_test!(aes128_ofb_apply_ks_iv_state, OfbCore, apply_ks); +iv_state_test!(aes192_ofb_enc_iv_state, OfbCore, encrypt); +iv_state_test!(aes192_ofb_dec_iv_state, OfbCore, decrypt); +iv_state_test!(aes192_ofb_apply_ks_iv_state, OfbCore, apply_ks); +iv_state_test!(aes256_ofb_enc_iv_state, OfbCore, encrypt); +iv_state_test!(aes256_ofb_dec_iv_state, OfbCore, decrypt); +iv_state_test!(aes256_ofb_apply_ks_iv_state, OfbCore, apply_ks); diff --git a/pcbc/benches/aes128.rs b/pcbc/benches/aes128.rs index 5abeae5..dd7e5cc 100644 --- a/pcbc/benches/aes128.rs +++ b/pcbc/benches/aes128.rs @@ -1,16 +1,13 @@ #![feature(test)] extern crate test; -use aes::Aes128; - cipher::block_encryptor_bench!( - KeyIv: pcbc::Encryptor, + KeyIv: pcbc::Encryptor, pcbc_aes128_encrypt_block, pcbc_aes128_encrypt_blocks, ); - cipher::block_decryptor_bench!( - KeyIv: pcbc::Decryptor, + KeyIv: pcbc::Decryptor, pcbc_aes128_decrypt_block, pcbc_aes128_decrypt_blocks, ); diff --git a/pcbc/tests/aes.rs b/pcbc/tests/aes.rs index 754002d..1f7f361 100644 --- a/pcbc/tests/aes.rs +++ b/pcbc/tests/aes.rs @@ -1,13 +1,9 @@ -// TODO(tarcieri): update tests to support RustCrypto/traits#1916 -// use aes::{Aes128, Aes128Dec, Aes128Enc}; -// use cipher::{block_mode_dec_test, block_mode_enc_test, iv_state_test}; -// use pcbc::{Decryptor, Encryptor}; -// -// iv_state_test!(aes128_pcbc_enc_iv_state, Encryptor, encrypt); -// iv_state_test!(aes128_pcbc_dec_iv_state, Decryptor, decrypt); -// -// // The test vectors are generated using this implementation. -// block_mode_enc_test!(aes128_pcbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128_pcbc_dec_test, "aes128", Decryptor); -// block_mode_enc_test!(aes128enc_pcbc_enc_test, "aes128", Encryptor); -// block_mode_dec_test!(aes128dec_pcbc_dec_test, "aes128", Decryptor); +//! Test vectors generated using this crate. +use aes::{Aes128, Aes128Dec, Aes128Enc}; +use cipher::block_mode_test; +use pcbc::{Decryptor, Encryptor}; + +block_mode_test!(aes128_pcbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes128_pcbc_dec, "aes128", Decryptor, decrypt); +block_mode_test!(aes128enc_pcbc_enc, "aes128", Encryptor, encrypt); +block_mode_test!(aes128dec_pcbc_dec, "aes128", Decryptor, decrypt); diff --git a/pcbc/tests/iv_state.rs b/pcbc/tests/iv_state.rs new file mode 100644 index 0000000..c943515 --- /dev/null +++ b/pcbc/tests/iv_state.rs @@ -0,0 +1,6 @@ +use aes::Aes128; +use cipher::iv_state_test; +use pcbc::{Decryptor, Encryptor}; + +iv_state_test!(aes128_pcbc_enc_iv_state, Encryptor, encrypt); +iv_state_test!(aes128_pcbc_dec_iv_state, Decryptor, decrypt); From 6dc5fbe2c3d72997b7753bc6b930c2d1e0e14bc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D1=80=D1=82=D1=91=D0=BC=20=D0=9F=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=BE=D0=B2=20=5BArtyom=20Pavlov=5D?= Date: Fri, 5 Sep 2025 17:37:36 +0300 Subject: [PATCH 2/2] us cipher from the master branch --- Cargo.lock | 4 ++-- Cargo.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9b82082..5a6d436 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -92,7 +92,7 @@ checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" [[package]] name = "cipher" version = "0.5.0-rc.1" -source = "git+https://github.com/RustCrypto/traits?branch=cipher%2Fdev_block_tweak#88ca34c87d54258cd8c13fc32df4bd7a7fd5d063" +source = "git+https://github.com/RustCrypto/traits#e0b946691a9af9c875045c554317bcb9726ad370" dependencies = [ "blobby", "block-buffer", @@ -113,7 +113,7 @@ dependencies = [ [[package]] name = "crypto-common" version = "0.2.0-rc.4" -source = "git+https://github.com/RustCrypto/traits?branch=cipher%2Fdev_block_tweak#88ca34c87d54258cd8c13fc32df4bd7a7fd5d063" +source = "git+https://github.com/RustCrypto/traits#e0b946691a9af9c875045c554317bcb9726ad370" dependencies = [ "hybrid-array", ] diff --git a/Cargo.toml b/Cargo.toml index f4506bb..b2de64a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,6 @@ opt-level = 2 [patch.crates-io] # https://github.com/RustCrypto/traits/pull/1998 -cipher = { git = "https://github.com/RustCrypto/traits", branch = "cipher/dev_block_tweak" } +cipher = { git = "https://github.com/RustCrypto/traits" } # https://github.com/RustCrypto/utils/pull/1187 blobby = { git = "https://github.com/RustCrypto/utils" }