Migrate tests to the new blobby format

belt-mac/tests/mod.rs

@@ -1,6 +1,7 @@
-//! Test vectors.
+//! Test vectors from STB 34.101.31-2020:
+//! <https://apmi.bsu.by/assets/files/std/belt-spec371.pdf>
 
-//use belt_mac::BeltMac;
+use belt_mac::BeltMac;
+use digest::dev::reset_mac_test;
 
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// digest::new_resettable_mac_test!(belt_mac_stb, "belt-mac", BeltMac, "left");
+digest::new_mac_test!(belt_mac_stb, BeltMac, reset_mac_test, trunc_left);

cmac/tests/cavp_large.rs

@@ -1,15 +1,15 @@
 //! Tests from CAVP (excluding all 64 KiB vectors for AES-128 except the first one):
 //! <https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/CAVP-TESTING-BLOCK-CIPHER-MODES>
+//!
+//! Test vectors in this file use 64 KiB of data, so they are excluded from published packages.
 
-// use aes::Aes128;
-// use cmac::Cmac;
+use aes::Aes128;
+use cmac::Cmac;
+use digest::dev::reset_mac_test;
 
-//
-// Test vectors in this file use 64 KiB of data, so they are excluded from published packages.
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// digest::new_resettable_mac_test!(
-//     cmac_aes128_cavp,
-//     "cavp_aes128_large",
-//     Cmac<Aes128>,
-//     trunc_left
-// );
+digest::new_mac_test!(
+    cmac_aes128_cavp_large,
+    Cmac<Aes128>,
+    reset_mac_test,
+    trunc_left,
+);

cmac/tests/mod.rs

@@ -1,37 +1,33 @@
 //! Test vectors.
 
-// use aes::{Aes128, Aes192, Aes256};
-// use cmac::Cmac;
-// use des::{TdesEde2, TdesEde3};
-// use digest::new_resettable_mac_test;
-// use kuznyechik::Kuznyechik;
-// use magma::Magma;
+use aes::{Aes128, Aes192, Aes256};
+use cmac::Cmac;
+use des::{TdesEde2, TdesEde3};
+use digest::{dev::reset_mac_test, new_mac_test};
+use kuznyechik::Kuznyechik;
+use magma::Magma;
 
 // Tests from NIST SP 800-38B:
 // https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// new_resettable_mac_test!(cmac_aes128_nist, "aes128", Cmac<Aes128>);
-// new_resettable_mac_test!(cmac_aes192_nist, "aes192", Cmac<Aes192>);
-// new_resettable_mac_test!(cmac_aes256_nist, "aes256", Cmac<Aes256>);
+new_mac_test!(cmac_aes128_nist, Cmac<Aes128>, reset_mac_test);
+new_mac_test!(cmac_aes192_nist, Cmac<Aes192>, reset_mac_test);
+new_mac_test!(cmac_aes256_nist, Cmac<Aes256>, reset_mac_test);
 
 // Tests from CAVP (excluding all 64 KiB vectors for AES-128 except the first one):
 // https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/CAVP-TESTING-BLOCK-CIPHER-MODES
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// new_resettable_mac_test!(cmac_aes128_cavp, "cavp_aes128", Cmac<Aes128>, trunc_left);
-// new_resettable_mac_test!(cmac_aes192_cavp, "cavp_aes192", Cmac<Aes192>, trunc_left);
-// new_resettable_mac_test!(cmac_aes256_cavp, "cavp_aes256", Cmac<Aes256>, trunc_left);
-// new_resettable_mac_test!(cmac_tdes2_cavp, "cavp_tdes2", Cmac<TdesEde2>, trunc_left);
-// new_resettable_mac_test!(cmac_tdes3_cavp, "cavp_tdes3", Cmac<TdesEde3>, trunc_left);
+new_mac_test!(cmac_aes128_cavp, Cmac<Aes128>, reset_mac_test, trunc_left);
+new_mac_test!(cmac_aes192_cavp, Cmac<Aes192>, reset_mac_test, trunc_left);
+new_mac_test!(cmac_aes256_cavp, Cmac<Aes256>, reset_mac_test, trunc_left);
+new_mac_test!(cmac_tdes2_cavp, Cmac<TdesEde2>, reset_mac_test, trunc_left);
+new_mac_test!(cmac_tdes3_cavp, Cmac<TdesEde3>, reset_mac_test, trunc_left);
 
 // Tests from Project Wycheproof:
 // https://github.com/google/wycheproof
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// new_resettable_mac_test!(cmac_aes128_wycheproof, "wycheproof-aes128", Cmac<Aes128>);
-// new_resettable_mac_test!(cmac_aes192_wycheproof, "wycheproof-aes192", Cmac<Aes192>);
-// new_resettable_mac_test!(cmac_aes256_wycheproof, "wycheproof-aes256", Cmac<Aes256>);
+new_mac_test!(cmac_aes128_wycheproof, Cmac<Aes128>, reset_mac_test);
+new_mac_test!(cmac_aes192_wycheproof, Cmac<Aes192>, reset_mac_test);
+new_mac_test!(cmac_aes256_wycheproof, Cmac<Aes256>, reset_mac_test);
 
 // Test from GOST R 34.13-2015:
 // https://tc26.ru/standard/gost/GOST_R_3413-2015.pdf
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// new_resettable_mac_test!(cmac_kuznyechik_gost, "kuznyechik", Cmac<Kuznyechik>);
-// new_resettable_mac_test!(cmac_magma_gost, "magma", Cmac<Magma>);
+new_mac_test!(cmac_kuznyechik_gost, Cmac<Kuznyechik>, reset_mac_test);
+new_mac_test!(cmac_magma_gost, Cmac<Magma>, reset_mac_test);

hmac/tests/mod.rs

@@ -1,59 +1,82 @@
 //! Test vectors.
 
-macro_rules! test {
-    ($mod_name:ident, $test_name:expr, $hash:ty $(, $t:ident)?) => {
-        mod $mod_name {
-            // TODO(tarcieri): update tests to support RustCrypto/traits#1916
-            // digest::new_mac_test!(hmac, $test_name, hmac::Hmac<$hash> $(, $t)?);
-            // digest::new_mac_test!(simple_hmac, $test_name, hmac::SimpleHmac<$hash> $(, $t)?);
-            // digest::new_resettable_mac_test!(
-            //     hmac_reset,
-            //     $test_name,
-            //     hmac::HmacReset<$hash>
-            //     $(, $t)?
-            // );
-            // digest::new_resettable_mac_test!(
-            //     simple_reset_hmac,
-            //     $test_name,
-            //     hmac::SimpleHmacReset<$hash>
-            //     $(, $t)?
-            // );
+macro_rules! new_test {
+    ($name:ident, $digest:ty $(,)?) => {
+        new_test!($name, $digest, digest::dev::MacTruncSide::None);
+    };
+    ($name:ident, $digest:ty, trunc_left $(,)?) => {
+        new_test!($name, $digest, digest::dev::MacTruncSide::Left);
+    };
+    ($name:ident, $digest:ty, $trunc:expr $(,)?) => {
+        #[test]
+        fn $name() {
+            use digest::dev::{MacTestVector, mac_test, reset_mac_test};
+
+            digest::dev::blobby::parse_into_structs!(
+                include_bytes!(concat!("data/", stringify!($name), ".blb"));
+                static TEST_VECTORS: &[MacTestVector { key, input, tag }];
+            );
+
+            type Hmac = hmac::Hmac<$digest>;
+            type HmacReset = hmac::HmacReset<$digest>;
+            type SimpleHmac = hmac::SimpleHmac<$digest>;
+            type SimpleHmacReset = hmac::SimpleHmacReset<$digest>;
+
+            for (i, tv) in TEST_VECTORS.iter().enumerate() {
+                if let Err(reason) = mac_test::<Hmac>(tv, $trunc) {
+                    panic!(
+                        "\n\
+                        Failed `Hmac` test #{i}\n\
+                        reason:\t{reason:?}\n\
+                        test vector:\t{tv:?}\n"
+                    );
+                }
+                if let Err(reason) = reset_mac_test::<HmacReset>(tv, $trunc) {
+                    panic!(
+                        "\n\
+                        Failed `HmacReset` test #{i}\n\
+                        reason:\t{reason:?}\n\
+                        test vector:\t{tv:?}\n"
+                    );
+                }
+                if let Err(reason) = mac_test::<SimpleHmac>(tv, $trunc) {
+                    panic!(
+                        "\n\
+                        Failed `SimpleHmac` test #{i}\n\
+                        reason:\t{reason:?}\n\
+                        test vector:\t{tv:?}\n"
+                    );
+                }
+                if let Err(reason) = reset_mac_test::<SimpleHmacReset>(tv, $trunc) {
+                    panic!(
+                        "\n\
+                        Failed `SimpleHmacReset` test #{i}\n\
+                        reason:\t{reason:?}\n\
+                        test vector:\t{tv:?}\n"
+                    );
+                }
+            }
         }
     };
 }
 
-// Test vectors from RFC 2104, plus wiki test
-test!(md5_rfc2104, "md5", md5::Md5);
+// Test vectors from RFC 2104, plus Wikipedia test
+new_test!(hmac_md5_rfc2104, md5::Md5);
 
 // Test vectors from RFC 4231
-test!(sha224_rfc4231, "sha224", sha2::Sha224);
-test!(sha256_rfc4231, "sha256", sha2::Sha256);
-test!(sha384_rfc4231, "sha384", sha2::Sha384);
-test!(sha512_rfc4231, "sha512", sha2::Sha512);
+new_test!(hmac_sha224_rfc4231, sha2::Sha224);
+new_test!(hmac_sha256_rfc4231, sha2::Sha256);
+new_test!(hmac_sha384_rfc4231, sha2::Sha384);
+new_test!(hmac_sha512_rfc4231, sha2::Sha512);
 
 // Test vectors from R 50.1.113-2016:
 // https://tc26.ru/standard/rs/Р%2050.1.113-2016.pdf
-test!(treebog256, "streebog256", streebog::Streebog256);
-test!(streebog512, "streebog512", streebog::Streebog512);
+new_test!(hmac_streebog256_gost, streebog::Streebog256);
+new_test!(hmac_streebog512_gost, streebog::Streebog512);
 
 // Tests from Project Wycheproof:
 // https://github.com/google/wycheproof
-test!(sha1_wycheproof, "wycheproof-sha1", sha1::Sha1, trunc_left);
-test!(
-    sha256_wycheproof,
-    "wycheproof-sha256",
-    sha2::Sha256,
-    trunc_left
-);
-test!(
-    sha384_wycheproof,
-    "wycheproof-sha384",
-    sha2::Sha384,
-    trunc_left
-);
-test!(
-    sha512_wycheproof,
-    "wycheproof-sha512",
-    sha2::Sha512,
-    trunc_left
-);
+new_test!(hmac_sha1_wycheproof, sha1::Sha1, trunc_left);
+new_test!(hmac_sha256_wycheproof, sha2::Sha256, trunc_left);
+new_test!(hmac_sha384_wycheproof, sha2::Sha384, trunc_left);
+new_test!(hmac_sha512_wycheproof, sha2::Sha512, trunc_left);

pmac/tests/mod.rs

@@ -1,11 +1,9 @@
-//! Test vectors.
+//! Test vectors from: <http://web.cs.ucdavis.edu/~rogaway/ocb/pmac-test.htm>
 
-// use aes::{Aes128, Aes192, Aes256};
-// use digest::new_resettable_mac_test;
-// use pmac::Pmac;
+use aes::{Aes128, Aes192, Aes256};
+use digest::{dev::reset_mac_test, new_mac_test};
+use pmac::Pmac;
 
-// Test vectors from: http://web.cs.ucdavis.edu/~rogaway/ocb/pmac-test.htm
-// TODO(tarcieri): update tests to support RustCrypto/traits#1916
-// new_resettable_mac_test!(pmac_aes128, "aes128", Pmac<Aes128>);
-// new_resettable_mac_test!(pmac_aes192, "aes192", Pmac<Aes192>);
-// new_resettable_mac_test!(pmac_aes256, "aes256", Pmac<Aes256>);
+new_mac_test!(pmac_aes128, Pmac<Aes128>, reset_mac_test);
+new_mac_test!(pmac_aes192, Pmac<Aes192>, reset_mac_test);
+new_mac_test!(pmac_aes256, Pmac<Aes256>, reset_mac_test);