From bc9f59a120073a91e7271b4b8f2075bbe371906c Mon Sep 17 00:00:00 2001 From: Sean McGrail <549813+skmcgrail@users.noreply.github.com> Date: Fri, 16 Aug 2024 12:28:23 +0000 Subject: [PATCH] KDF in Counter Mode and One-Step KDF API (#482) * KDF in Counter Mode and One-Step KDF API * Feedback * Latest feedback * cargo fmt --- aws-lc-rs/src/agreement/ephemeral.rs | 91 ++- aws-lc-rs/src/digest.rs | 2 +- aws-lc-rs/src/unstable.rs | 1 + aws-lc-rs/src/unstable/kdf.rs | 459 +++++++++++++++ aws-lc-rs/src/unstable/kdf/kbkdf.rs | 176 ++++++ aws-lc-rs/src/unstable/kdf/sskdf.rs | 339 +++++++++++ aws-lc-rs/tests/data/kbkdf_counter.txt | 599 +++++++++++++++++++ aws-lc-rs/tests/data/sskdf.txt | 770 +++++++++++++++++++++++++ aws-lc-rs/tests/kdf_test.rs | 166 ++++++ 9 files changed, 2552 insertions(+), 51 deletions(-) create mode 100644 aws-lc-rs/src/unstable/kdf.rs create mode 100644 aws-lc-rs/src/unstable/kdf/kbkdf.rs create mode 100644 aws-lc-rs/src/unstable/kdf/sskdf.rs create mode 100644 aws-lc-rs/tests/data/kbkdf_counter.txt create mode 100644 aws-lc-rs/tests/data/sskdf.txt create mode 100644 aws-lc-rs/tests/kdf_test.rs diff --git a/aws-lc-rs/src/agreement/ephemeral.rs b/aws-lc-rs/src/agreement/ephemeral.rs index 0e001e36584..f15b0370594 100644 --- a/aws-lc-rs/src/agreement/ephemeral.rs +++ b/aws-lc-rs/src/agreement/ephemeral.rs @@ -362,59 +362,50 @@ mod tests { let peer_public = agreement::UnparsedPublicKey::new(alg, test_case.consume_bytes("PeerQ")); - match test_case.consume_optional_string("Error") { - None => { - let my_private_bytes = test_case.consume_bytes("D"); - let my_private = { - let rng = test::rand::FixedSliceRandom { - bytes: &my_private_bytes, - }; - agreement::EphemeralPrivateKey::generate_for_test(alg, &rng)? + if test_case.consume_optional_string("Error").is_none() { + let my_private_bytes = test_case.consume_bytes("D"); + let my_private = { + let rng = test::rand::FixedSliceRandom { + bytes: &my_private_bytes, }; - let my_public = test_case.consume_bytes("MyQ"); - let output = test_case.consume_bytes("Output"); - - assert_eq!(my_private.algorithm(), alg); - - let computed_public = my_private.compute_public_key().unwrap(); - assert_eq!(computed_public.as_ref(), &my_public[..]); - - assert_eq!(my_private.algorithm(), alg); - - let result = agreement::agree_ephemeral( - my_private, - &peer_public, - (), - |key_material| { - assert_eq!(key_material, &output[..]); - Ok(()) - }, - ); - assert_eq!( - result, - Ok(()), - "Failed on private key: {:?}", - test::to_hex(my_private_bytes) - ); - } - - Some(_) => { - fn kdf_not_called(_: &[u8]) -> Result<(), ()> { - panic!( - "The KDF was called during ECDH when the peer's \ + agreement::EphemeralPrivateKey::generate_for_test(alg, &rng)? + }; + let my_public = test_case.consume_bytes("MyQ"); + let output = test_case.consume_bytes("Output"); + + assert_eq!(my_private.algorithm(), alg); + + let computed_public = my_private.compute_public_key().unwrap(); + assert_eq!(computed_public.as_ref(), &my_public[..]); + + assert_eq!(my_private.algorithm(), alg); + + let result = + agreement::agree_ephemeral(my_private, &peer_public, (), |key_material| { + assert_eq!(key_material, &output[..]); + Ok(()) + }); + assert_eq!( + result, + Ok(()), + "Failed on private key: {:?}", + test::to_hex(my_private_bytes) + ); + } else { + fn kdf_not_called(_: &[u8]) -> Result<(), ()> { + panic!( + "The KDF was called during ECDH when the peer's \ public key is invalid." - ); - } - let dummy_private_key = - agreement::EphemeralPrivateKey::generate(alg, &rng)?; - assert!(agreement::agree_ephemeral( - dummy_private_key, - &peer_public, - (), - kdf_not_called - ) - .is_err()); + ); } + let dummy_private_key = agreement::EphemeralPrivateKey::generate(alg, &rng)?; + assert!(agreement::agree_ephemeral( + dummy_private_key, + &peer_public, + (), + kdf_not_called + ) + .is_err()); } Ok(()) diff --git a/aws-lc-rs/src/digest.rs b/aws-lc-rs/src/digest.rs index aa930e00a8e..f3c5c22d688 100644 --- a/aws-lc-rs/src/digest.rs +++ b/aws-lc-rs/src/digest.rs @@ -304,7 +304,7 @@ impl Algorithm { } } -#[derive(Debug, Eq, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum AlgorithmID { SHA1, SHA224, diff --git a/aws-lc-rs/src/unstable.rs b/aws-lc-rs/src/unstable.rs index 46b6daedf97..313a7557480 100644 --- a/aws-lc-rs/src/unstable.rs +++ b/aws-lc-rs/src/unstable.rs @@ -9,4 +9,5 @@ //! Features contained within this module, or child modules are subject to changes, relocation, //! or removal across minor releases, and thus are not subject to semantic versioning policies. +pub mod kdf; pub mod kem; diff --git a/aws-lc-rs/src/unstable/kdf.rs b/aws-lc-rs/src/unstable/kdf.rs new file mode 100644 index 00000000000..b3a07d85b35 --- /dev/null +++ b/aws-lc-rs/src/unstable/kdf.rs @@ -0,0 +1,459 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR ISC + +//! # Key-based Key Derivation Function (KBKDF) in Counter Mode +//! +//! [`kbkdf_ctr_hmac`] provides an implementation of KDF in Counter Mode using HMAC PRF specified in +//! [NIST SP 800-108r1-upd1](https://doi.org/10.6028/NIST.SP.800-108r1-upd1) section 4.1. Further details +//! regarding the implementation can be found on the accompanying function documentation. +//! +//! Key-based key derivation functions are used to derive additional keys from an existing cryptographic key. +//! +//! ## Example: Usage with HMAC-SHA256 PRF +//! +//! ```rust +//! # use std::error::Error; +//! # +//! # fn main() -> Result<(), Box> { +//! # #[cfg(feature = "fips")] +//! # return Ok(()); +//! use aws_lc_rs::{ +//! error::Unspecified, +//! unstable::kdf::{ +//! get_kbkdf_ctr_hmac_algorithm, kbkdf_ctr_hmac, KbkdfCtrHmacAlgorithm, +//! KbkdfCtrHmacAlgorithmId, +//! }, +//! }; +//! +//! const OUTPUT_KEY_LEN: usize = 16; +//! +//! let key: &[u8] = &[ +//! 0x01, 0x85, 0xfb, 0x76, 0x61, 0xf6, 0xdd, 0x40, 0x8d, 0x98, 0x2f, 0x81, 0x0f, 0xcd, 0x50, +//! 0x04, +//! ]; +//! +//! let info: &[u8] = &[ +//! 0xc3, 0xf1, 0x71, 0x2a, 0x82, 0x61, 0x36, 0x43, 0xe0, 0xf7, 0x63, 0xa7, 0xa0, 0xa3, 0x15, +//! 0x88, 0xb6, 0xae, 0xd9, 0x50, 0x56, 0xdf, 0xc5, 0x12, 0x55, 0x0c, 0xf2, 0xd0, 0x0d, 0x68, +//! 0xa3, 0x2d, +//! ]; +//! +//! let mut output_key = [0u8; OUTPUT_KEY_LEN]; +//! +//! let kbkdf_ctr_hmac_sha256: &KbkdfCtrHmacAlgorithm = +//! get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256).ok_or(Unspecified)?; +//! +//! kbkdf_ctr_hmac(kbkdf_ctr_hmac_sha256, key, info, &mut output_key)?; +//! +//! assert_eq!( +//! output_key, +//! [ +//! 0xc6, 0x3f, 0x74, 0x7b, 0x67, 0xbe, 0x71, 0xf5, 0x7b, 0xa4, 0x56, 0x21, 0x17, 0xdd, +//! 0x29, 0x4 +//! ] +//! ); +//! +//! # Ok(()) +//! # } +//! ``` +//! +//! ## Example: Usage with HMAC-SHA256 PRF using NIST FixedInfo Construction +//! +//! ```rust +//! # use std::error::Error; +//! # fn main() -> Result<(), Box> { +//! # #[cfg(feature = "fips")] +//! # return Ok(()); +//! use aws_lc_rs::{ +//! error::Unspecified, +//! unstable::kdf::{ +//! get_kbkdf_ctr_hmac_algorithm, kbkdf_ctr_hmac, KbkdfCtrHmacAlgorithm, +//! KbkdfCtrHmacAlgorithmId, +//! }, +//! }; +//! +//! const OUTPUT_KEY_LEN: usize = 16; +//! +//! let key: &[u8] = &[ +//! 0x01, 0x85, 0xfb, 0x76, 0x61, 0xf6, 0xdd, 0x40, 0x8d, 0x98, 0x2f, 0x81, 0x0f, 0xcd, 0x50, +//! 0x04, +//! ]; +//! +//! let label: &[u8] = b"KBKDF HMAC Counter Label"; +//! let context: &[u8] = b"KBKDF HMAC Counter Context"; +//! +//! let output_len_bits_be: [u8; 4] = { +//! // Multiply `output_len` by eight to convert from bytes to bits +//! // Convert value to a 32-bit big-endian representation +//! let len: u32 = (OUTPUT_KEY_LEN * 8).try_into()?; +//! len.to_be_bytes() +//! }; +//! +//! // FixedInfo String: Label || 0x00 || Context || [L] +//! let mut info = Vec::::new(); +//! info.extend_from_slice(label); +//! info.push(0x0); +//! info.extend_from_slice(context); +//! info.extend_from_slice(&output_len_bits_be); +//! +//! let mut output_key = [0u8; OUTPUT_KEY_LEN]; +//! +//! let kbkdf_ctr_hmac_sha256: &KbkdfCtrHmacAlgorithm = +//! get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256).ok_or(Unspecified)?; +//! +//! kbkdf_ctr_hmac(kbkdf_ctr_hmac_sha256, key, &info, &mut output_key)?; +//! +//! assert_eq!( +//! output_key, +//! [ +//! 0xcd, 0xe0, 0x92, 0xc8, 0xfe, 0x96, 0x21, 0x51, 0x88, 0xd4, 0x3d, 0xe4, 0x6c, 0xf6, +//! 0x37, 0xcb +//! ] +//! ); +//! +//! # Ok(()) +//! # } +//! ``` +//! # Single-step Key Derivation Function (SSKDF) +//! +//! [`sskdf_digest`] and [`sskd_hmac`] provided implementations of a one-step key derivation function defined in +//! section 4 of [NIST SP 800-56Cr2](https://doi.org/10.6028/NIST.SP.800-56Cr2). +//! +//! These functions are used to derive keying material from a shared secret during a key establishment scheme. +//! +//! ## SSKDF using digest +//! +//! ```rust +//! # use std::error::Error; +//! # fn main() -> Result<(), Box> { +//! # #[cfg(feature = "fips")] +//! # return Ok(()); +//! use aws_lc_rs::{ +//! error::Unspecified, +//! unstable::kdf::{ +//! get_sskdf_digest_algorithm, sskdf_digest, SskdfDigestAlgorithm, SskdfDigestAlgorithmId, +//! }, +//! }; +//! +//! const OUTPUT_KEY_LEN: usize = 16; +//! +//! let shared_secret: &[u8] = &[ +//! 0x59, 0x09, 0x6b, 0x7b, 0xb7, 0x2b, 0x94, 0xc5, 0x55, 0x5c, 0x36, 0xc9, 0x76, 0x8f, 0xd8, +//! 0xe4, 0xed, 0x8f, 0x39, 0x5e, 0x78, 0x48, 0x5e, 0xb9, 0xf9, 0xdd, 0x43, 0x65, 0x55, 0x00, +//! 0xed, 0x7a, +//! ]; +//! +//! let info: &[u8] = &[ +//! 0x9b, 0xca, 0xd7, 0xe8, 0xee, 0xf7, 0xb2, 0x1a, 0x98, 0xff, 0x18, 0x60, 0x5c, 0x68, 0x16, +//! 0xbd, +//! ]; +//! +//! let mut output_key = [0u8; OUTPUT_KEY_LEN]; +//! +//! let sskdf_digest_sha256: &SskdfDigestAlgorithm = +//! get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha256).ok_or(Unspecified)?; +//! +//! sskdf_digest(sskdf_digest_sha256, shared_secret, info, &mut output_key)?; +//! +//! assert_eq!( +//! output_key, +//! [ +//! 0x21, 0x79, 0x35, 0x6c, 0xdc, 0x30, 0x1, 0xe6, 0x3f, 0x91, 0xb3, 0xc8, 0x10, 0x7, 0xba, +//! 0x31 +//! ] +//! ); +//! # Ok(()) +//! # } +//! ``` +//! +//! ## SSKDF using HMAC +//! +//! ```rust +//! # use std::error::Error; +//! # fn main() -> Result<(), Box> { +//! # #[cfg(feature = "fips")] +//! # return Ok(()); +//! use aws_lc_rs::{ +//! error::Unspecified, +//! unstable::kdf::{ +//! get_sskdf_hmac_algorithm, sskdf_hmac, SskdfHmacAlgorithm, SskdfHmacAlgorithmId, +//! }, +//! }; +//! +//! const OUTPUT_KEY_LEN: usize = 16; +//! +//! let shared_secret: &[u8] = &[ +//! 0x59, 0x09, 0x6b, 0x7b, 0xb7, 0x2b, 0x94, 0xc5, 0x55, 0x5c, 0x36, 0xc9, 0x76, 0x8f, 0xd8, +//! 0xe4, 0xed, 0x8f, 0x39, 0x5e, 0x78, 0x48, 0x5e, 0xb9, 0xf9, 0xdd, 0x43, 0x65, 0x55, 0x00, +//! 0xed, 0x7a, +//! ]; +//! +//! let info: &[u8] = &[ +//! 0x9b, 0xca, 0xd7, 0xe8, 0xee, 0xf7, 0xb2, 0x1a, 0x98, 0xff, 0x18, 0x60, 0x5c, 0x68, 0x16, +//! 0xbd, +//! ]; +//! +//! let salt: &[u8] = &[ +//! 0x2b, 0xc5, 0xf1, 0x6c, 0x48, 0x34, 0x72, 0xd8, 0xda, 0x53, 0xf6, 0xc3, 0x0f, 0x0a, 0xf4, +//! 0x02, +//! ]; +//! +//! let mut output_key = [0u8; OUTPUT_KEY_LEN]; +//! +//! let sskdf_hmac_sha256: &SskdfHmacAlgorithm = +//! get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha256).ok_or(Unspecified)?; +//! +//! sskdf_hmac( +//! sskdf_hmac_sha256, +//! shared_secret, +//! info, +//! salt, +//! &mut output_key, +//! )?; +//! +//! assert_eq!( +//! output_key, +//! [ +//! 0x4c, 0x36, 0x80, 0x2d, 0xf5, 0xd8, 0xd6, 0x1b, 0xd5, 0xc2, 0x4, 0x7e, 0x5, 0x5a, 0x6d, +//! 0xcb +//! ] +//! ); +//! # Ok(()) +//! # } +//! ``` + +mod kbkdf; +mod sskdf; + +pub use kbkdf::{ + get_kbkdf_ctr_hmac_algorithm, kbkdf_ctr_hmac, KbkdfCtrHmacAlgorithm, KbkdfCtrHmacAlgorithmId, +}; + +pub use sskdf::{ + get_sskdf_digest_algorithm, get_sskdf_hmac_algorithm, sskdf_digest, sskdf_hmac, + SskdfDigestAlgorithm, SskdfDigestAlgorithmId, SskdfHmacAlgorithm, SskdfHmacAlgorithmId, +}; + +#[cfg(test)] +mod tests { + #[cfg(not(feature = "fips"))] + mod notfips { + use crate::unstable::kdf::{ + get_kbkdf_ctr_hmac_algorithm, get_sskdf_digest_algorithm, get_sskdf_hmac_algorithm, + kbkdf, kbkdf_ctr_hmac, sskdf::SskdfHmacAlgorithmId, sskdf_digest, sskdf_hmac, + KbkdfCtrHmacAlgorithmId, SskdfDigestAlgorithmId, + }; + + #[test] + fn zero_length_output() { + let mut output = vec![0u8; 0]; + assert!(sskdf_hmac( + get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha256) + .expect("algorithm supported"), + &[0u8; 16], + &[], + &[], + &mut output + ) + .is_err()); + assert!(sskdf_digest( + get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha256) + .expect("algorithm supported"), + &[0u8; 16], + &[], + &mut output + ) + .is_err()); + assert!(kbkdf_ctr_hmac( + get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256) + .expect("algorithm supported"), + &[0u8; 16], + &[], + &mut output + ) + .is_err()); + } + + #[test] + fn zero_length_secret() { + let mut output = vec![0u8; 16]; + assert!(sskdf_hmac( + get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha256) + .expect("algorithm supported"), + &[], + &[], + &[], + &mut output + ) + .is_err()); + assert!(sskdf_digest( + get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha256) + .expect("algorithm supported"), + &[], + &[], + &mut output + ) + .is_err()); + assert!(kbkdf_ctr_hmac( + get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256) + .expect("algorithm supported"), + &[], + &[], + &mut output + ) + .is_err()); + } + + #[test] + fn sskdf_digest_test() { + for id in [ + SskdfDigestAlgorithmId::Sha224, + SskdfDigestAlgorithmId::Sha256, + SskdfDigestAlgorithmId::Sha384, + SskdfDigestAlgorithmId::Sha512, + ] { + let alg = get_sskdf_digest_algorithm(id).expect("supported"); + assert_eq!(id, alg.id()); + assert_eq!(format!("{id:?}"), format!("{alg:?}")); + assert_eq!(format!("{id:?}"), format!("{:?}", alg.id())); + let mut output = vec![0u8; 32]; + sskdf_digest(alg, &[1u8; 32], &[2u8; 32], &mut output).expect("success"); + } + } + + #[test] + fn sskdf_hmac_test() { + for id in [ + SskdfHmacAlgorithmId::Sha224, + SskdfHmacAlgorithmId::Sha256, + SskdfHmacAlgorithmId::Sha384, + SskdfHmacAlgorithmId::Sha512, + ] { + let alg = get_sskdf_hmac_algorithm(id).expect("supported"); + assert_eq!(id, alg.id()); + assert_eq!(format!("{id:?}"), format!("{alg:?}")); + assert_eq!(format!("{id:?}"), format!("{:?}", alg.id())); + let mut output = vec![0u8; 32]; + sskdf_hmac(alg, &[1u8; 32], &[2u8; 32], &[3u8; 32], &mut output).expect("success"); + } + } + + #[test] + fn kbkdf_ctr_hmac_test() { + for id in [ + KbkdfCtrHmacAlgorithmId::Sha224, + KbkdfCtrHmacAlgorithmId::Sha256, + KbkdfCtrHmacAlgorithmId::Sha384, + KbkdfCtrHmacAlgorithmId::Sha512, + ] { + let alg = get_kbkdf_ctr_hmac_algorithm(id).expect("supported"); + assert_eq!(id, alg.id()); + assert_eq!(format!("{id:?}"), format!("{alg:?}")); + assert_eq!(format!("{id:?}"), format!("{:?}", alg.id())); + let mut output = vec![0u8; 32]; + kbkdf_ctr_hmac(alg, &[1u8; 32], &[2u8; 32], &mut output).expect("success"); + } + } + + #[test] + fn algorithm_equality() { + let alg1 = get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256).unwrap(); + let alg2 = get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha256).unwrap(); + assert_eq!(alg1, alg2); + let alg2 = get_kbkdf_ctr_hmac_algorithm(KbkdfCtrHmacAlgorithmId::Sha512).unwrap(); + assert_ne!(alg1, alg2); + + let alg1 = get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha256).unwrap(); + let alg2 = get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha256).unwrap(); + assert_eq!(alg1, alg2); + let alg2 = get_sskdf_digest_algorithm(SskdfDigestAlgorithmId::Sha512).unwrap(); + assert_ne!(alg1, alg2); + + let alg1 = get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha256).unwrap(); + let alg2 = get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha256).unwrap(); + assert_eq!(alg1, alg2); + let alg2 = get_sskdf_hmac_algorithm(SskdfHmacAlgorithmId::Sha512).unwrap(); + assert_ne!(alg1, alg2); + } + } + + #[cfg(feature = "fips")] + mod fips { + use crate::unstable::kdf::{ + get_kbkdf_ctr_hmac_algorithm, get_sskdf_digest_algorithm, get_sskdf_hmac_algorithm, + KbkdfCtrHmacAlgorithmId, SskdfDigestAlgorithmId, SskdfHmacAlgorithmId, + }; + + macro_rules! assert_get_unsupported_algorithm { + ($name:ident, $getter:path, $alg:expr) => { + #[test] + fn $name() { + assert_eq!(None, $getter($alg)); + } + }; + } + + assert_get_unsupported_algorithm!( + get_sskdf_hmac_algorithm_hmac_sha224, + get_sskdf_hmac_algorithm, + SskdfHmacAlgorithmId::Sha224 + ); + assert_get_unsupported_algorithm!( + get_sskdf_hmac_algorithm_hmac_sha256, + get_sskdf_hmac_algorithm, + SskdfHmacAlgorithmId::Sha256 + ); + assert_get_unsupported_algorithm!( + get_sskdf_hmac_algorithm_hmac_sha384, + get_sskdf_hmac_algorithm, + SskdfHmacAlgorithmId::Sha384 + ); + assert_get_unsupported_algorithm!( + get_sskdf_hmac_algorithm_hmac_sha512, + get_sskdf_hmac_algorithm, + SskdfHmacAlgorithmId::Sha512 + ); + + assert_get_unsupported_algorithm!( + get_sskdf_digest_algorithm_sha224, + get_sskdf_digest_algorithm, + SskdfDigestAlgorithmId::Sha224 + ); + assert_get_unsupported_algorithm!( + get_sskdf_digest_algorithm_sha256, + get_sskdf_digest_algorithm, + SskdfDigestAlgorithmId::Sha256 + ); + assert_get_unsupported_algorithm!( + get_sskdf_digest_algorithm_sha384, + get_sskdf_digest_algorithm, + SskdfDigestAlgorithmId::Sha384 + ); + assert_get_unsupported_algorithm!( + get_sskdf_digest_algorithm_sha512, + get_sskdf_digest_algorithm, + SskdfDigestAlgorithmId::Sha512 + ); + + assert_get_unsupported_algorithm!( + get_kbkdf_ctr_hmac_algorithm_sha224, + get_kbkdf_ctr_hmac_algorithm, + KbkdfCtrHmacAlgorithmId::Sha224 + ); + assert_get_unsupported_algorithm!( + get_kbkdf_ctr_hmac_algorithm_sha256, + get_kbkdf_ctr_hmac_algorithm, + KbkdfCtrHmacAlgorithmId::Sha256 + ); + assert_get_unsupported_algorithm!( + get_kbkdf_ctr_hmac_algorithm_sha384, + get_kbkdf_ctr_hmac_algorithm, + KbkdfCtrHmacAlgorithmId::Sha384 + ); + assert_get_unsupported_algorithm!( + get_kbkdf_ctr_hmac_algorithm_sha512, + get_kbkdf_ctr_hmac_algorithm, + KbkdfCtrHmacAlgorithmId::Sha512 + ); + } +} diff --git a/aws-lc-rs/src/unstable/kdf/kbkdf.rs b/aws-lc-rs/src/unstable/kdf/kbkdf.rs new file mode 100644 index 00000000000..5b901195def --- /dev/null +++ b/aws-lc-rs/src/unstable/kdf/kbkdf.rs @@ -0,0 +1,176 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR ISC + +#![allow(clippy::module_name_repetitions)] + +#[cfg(not(feature = "fips"))] +use aws_lc::KBKDF_ctr_hmac; + +use aws_lc::EVP_MD; +#[cfg(feature = "fips")] +use stubs::KBKDF_ctr_hmac; + +#[cfg(feature = "fips")] +mod stubs { + #[allow(non_snake_case)] + pub(super) unsafe fn KBKDF_ctr_hmac( + _out_key: *mut u8, + _out_len: usize, + _digest: *const aws_lc::EVP_MD, + _secret: *const u8, + _secret_len: usize, + _info: *const u8, + _info_len: usize, + ) -> std::os::raw::c_int { + 0 + } +} + +use crate::{ + digest::{match_digest_type, AlgorithmID}, + error::Unspecified, + ptr::ConstPointer, +}; + +/// KBKDF in Counter Mode with HMAC-SHA224 +#[allow(dead_code)] +const KBKDF_CTR_HMAC_SHA224: KbkdfCtrHmacAlgorithm = KbkdfCtrHmacAlgorithm { + id: KbkdfCtrHmacAlgorithmId::Sha224, +}; + +/// KBKDF in Counter Mode with HMAC-SHA256 +#[allow(dead_code)] +const KBKDF_CTR_HMAC_SHA256: KbkdfCtrHmacAlgorithm = KbkdfCtrHmacAlgorithm { + id: KbkdfCtrHmacAlgorithmId::Sha256, +}; + +/// KBKDF in Counter Mode with HMAC-SHA384 +#[allow(dead_code)] +const KBKDF_CTR_HMAC_SHA384: KbkdfCtrHmacAlgorithm = KbkdfCtrHmacAlgorithm { + id: KbkdfCtrHmacAlgorithmId::Sha384, +}; + +/// KBKDF in Counter Mode with HMAC-SHA512 +#[allow(dead_code)] +const KBKDF_CTR_HMAC_SHA512: KbkdfCtrHmacAlgorithm = KbkdfCtrHmacAlgorithm { + id: KbkdfCtrHmacAlgorithmId::Sha512, +}; + +/// Retrieve an unstable [`KbkdfCtrHmacAlgorithm`] using the [`KbkdfCtrHmacAlgorithmId`] specified by `id`. +/// May return [`None`] if the algorithm is not usable with the configured crate feature set (i.e. `fips`). +#[must_use] +pub const fn get_kbkdf_ctr_hmac_algorithm( + id: KbkdfCtrHmacAlgorithmId, +) -> Option<&'static KbkdfCtrHmacAlgorithm> { + #[cfg(feature = "fips")] + { + let _ = id; + None + } + #[cfg(not(feature = "fips"))] + { + Some(match id { + KbkdfCtrHmacAlgorithmId::Sha224 => &KBKDF_CTR_HMAC_SHA224, + KbkdfCtrHmacAlgorithmId::Sha256 => &KBKDF_CTR_HMAC_SHA256, + KbkdfCtrHmacAlgorithmId::Sha384 => &KBKDF_CTR_HMAC_SHA384, + KbkdfCtrHmacAlgorithmId::Sha512 => &KBKDF_CTR_HMAC_SHA512, + }) + } +} + +/// KBKDF in Counter Mode with HMAC Algorithm +pub struct KbkdfCtrHmacAlgorithm { + id: KbkdfCtrHmacAlgorithmId, +} + +impl KbkdfCtrHmacAlgorithm { + /// Returns the KBKDF Counter HMAC Algorithm Identifier + #[must_use] + pub fn id(&self) -> KbkdfCtrHmacAlgorithmId { + self.id + } + + #[must_use] + fn get_evp_md(&self) -> ConstPointer { + match_digest_type(match self.id { + KbkdfCtrHmacAlgorithmId::Sha224 => &AlgorithmID::SHA224, + KbkdfCtrHmacAlgorithmId::Sha256 => &AlgorithmID::SHA256, + KbkdfCtrHmacAlgorithmId::Sha384 => &AlgorithmID::SHA384, + KbkdfCtrHmacAlgorithmId::Sha512 => &AlgorithmID::SHA512, + }) + } +} + +impl PartialEq for KbkdfCtrHmacAlgorithm { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl Eq for KbkdfCtrHmacAlgorithm {} + +impl core::fmt::Debug for KbkdfCtrHmacAlgorithm { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::Debug::fmt(&self.id, f) + } +} + +/// Key-based Derivation Function Algorithm Identifier +#[non_exhaustive] +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum KbkdfCtrHmacAlgorithmId { + /// KBKDF in Counter Mode with HMAC-SHA224 + Sha224, + + /// KBKDF in Counter Mode with HMAC-SHA256 + Sha256, + + /// KBKDF in Counter Mode with HMAC-SHA384 + Sha384, + + /// KBKDF in Counter Mode with HMAC-SHA512 + Sha512, +} + +/// # Key-based Key Derivation Function (KBKDF) in Counter Mode with HMAC PRF +/// +/// ## Input Validation and Defaults +/// * `output.len() > 0 and `secret.len() > 0` +/// * `output.len() <= usize::MAX - DIGEST_LENGTH` +/// * The requested `output.len()` would result in overflowing the counter. +/// +/// ## Implementation Notes +/// +/// This implementation adheres to the algorithm specified in Section 4.1 of the +/// NIST Special Publication 800-108 Revision 1 Update 1 published on August +/// 2022. Using HMAC as the PRF function. In this implementation: +/// * The counter is 32-bits and is represented in big-endian format +/// * The counter is placed before the fixed info string +/// +/// Specification available at +/// +/// # Errors +/// `Unspecified` is returned if input validation fails or an unexpected error occurs. +pub fn kbkdf_ctr_hmac( + algorithm: &'static KbkdfCtrHmacAlgorithm, + secret: &[u8], + info: &[u8], + output: &mut [u8], +) -> Result<(), Unspecified> { + let evp_md = algorithm.get_evp_md(); + let out_len = output.len(); + if 1 != unsafe { + KBKDF_ctr_hmac( + output.as_mut_ptr(), + out_len, + *evp_md, + secret.as_ptr(), + secret.len(), + info.as_ptr(), + info.len(), + ) + } { + return Err(Unspecified); + } + Ok(()) +} diff --git a/aws-lc-rs/src/unstable/kdf/sskdf.rs b/aws-lc-rs/src/unstable/kdf/sskdf.rs new file mode 100644 index 00000000000..9d26a891fcd --- /dev/null +++ b/aws-lc-rs/src/unstable/kdf/sskdf.rs @@ -0,0 +1,339 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR ISC + +#![allow(clippy::module_name_repetitions)] + +use aws_lc::EVP_MD; +#[cfg(not(feature = "fips"))] +use aws_lc::{SSKDF_digest, SSKDF_hmac}; + +#[cfg(feature = "fips")] +use stubs::{SSKDF_digest, SSKDF_hmac}; + +use crate::{ + digest::{match_digest_type, AlgorithmID}, + error::Unspecified, + ptr::ConstPointer, +}; + +#[cfg(feature = "fips")] +mod stubs { + #[allow(non_snake_case)] + pub(super) unsafe fn SSKDF_digest( + _out_key: *mut u8, + _out_len: usize, + _digest: *const aws_lc::EVP_MD, + _secret: *const u8, + _secret_len: usize, + _info: *const u8, + _info_len: usize, + ) -> std::os::raw::c_int { + 0 + } + + #[allow(clippy::too_many_arguments, non_snake_case)] + pub(super) unsafe fn SSKDF_hmac( + _out_key: *mut u8, + _out_len: usize, + _digest: *const aws_lc::EVP_MD, + _secret: *const u8, + _secret_len: usize, + _info: *const u8, + _info_len: usize, + _salt: *const u8, + _salt_len: usize, + ) -> std::os::raw::c_int { + 0 + } +} + +/// SSKDF with HMAC-SHA224 +#[allow(dead_code)] +const SSKDF_HMAC_SHA224: SskdfHmacAlgorithm = SskdfHmacAlgorithm { + id: SskdfHmacAlgorithmId::Sha224, +}; + +/// SSKDF with HMAC-SHA256 +#[allow(dead_code)] +const SSKDF_HMAC_SHA256: SskdfHmacAlgorithm = SskdfHmacAlgorithm { + id: SskdfHmacAlgorithmId::Sha256, +}; + +/// SSKDF with HMAC-SHA384 +#[allow(dead_code)] +const SSKDF_HMAC_SHA384: SskdfHmacAlgorithm = SskdfHmacAlgorithm { + id: SskdfHmacAlgorithmId::Sha384, +}; + +/// SSKDF with HMAC-SHA512 +#[allow(dead_code)] +const SSKDF_HMAC_SHA512: SskdfHmacAlgorithm = SskdfHmacAlgorithm { + id: SskdfHmacAlgorithmId::Sha512, +}; + +/// SSKDF with SHA224 +#[allow(dead_code)] +const SSKDF_DIGEST_SHA224: SskdfDigestAlgorithm = SskdfDigestAlgorithm { + id: SskdfDigestAlgorithmId::Sha224, +}; + +/// SSKDF with SHA256 +#[allow(dead_code)] +const SSKDF_DIGEST_SHA256: SskdfDigestAlgorithm = SskdfDigestAlgorithm { + id: SskdfDigestAlgorithmId::Sha256, +}; + +/// SSKDF with SHA384 +#[allow(dead_code)] +const SSKDF_DIGEST_SHA384: SskdfDigestAlgorithm = SskdfDigestAlgorithm { + id: SskdfDigestAlgorithmId::Sha384, +}; + +/// SSKDF with SHA512 +#[allow(dead_code)] +const SSKDF_DIGEST_SHA512: SskdfDigestAlgorithm = SskdfDigestAlgorithm { + id: SskdfDigestAlgorithmId::Sha512, +}; + +/// Retrieve an unstable [`SskdfHmacAlgorithm`] using the [`SskdfHmacAlgorithmId`] specified by `id`. +/// May return [`None`] if the algorithm is not usable with the configured crate feature set (i.e. `fips`). +#[must_use] +pub const fn get_sskdf_hmac_algorithm( + id: SskdfHmacAlgorithmId, +) -> Option<&'static SskdfHmacAlgorithm> { + #[cfg(feature = "fips")] + { + let _ = id; + None + } + #[cfg(not(feature = "fips"))] + { + match id { + SskdfHmacAlgorithmId::Sha224 => Some(&SSKDF_HMAC_SHA224), + SskdfHmacAlgorithmId::Sha256 => Some(&SSKDF_HMAC_SHA256), + SskdfHmacAlgorithmId::Sha384 => Some(&SSKDF_HMAC_SHA384), + SskdfHmacAlgorithmId::Sha512 => Some(&SSKDF_HMAC_SHA512), + } + } +} + +/// Retrieve an unstable [`SskdfDigestAlgorithm`] using the [`SskdfDigestAlgorithmId`] specified by `id`. +/// May return [`None`] if the algorithm is not usable with the configured crate feature set (i.e. `fips`). +#[must_use] +pub const fn get_sskdf_digest_algorithm( + id: SskdfDigestAlgorithmId, +) -> Option<&'static SskdfDigestAlgorithm> { + #[cfg(feature = "fips")] + { + let _ = id; + None + } + #[cfg(not(feature = "fips"))] + { + match id { + SskdfDigestAlgorithmId::Sha224 => Some(&SSKDF_DIGEST_SHA224), + SskdfDigestAlgorithmId::Sha256 => Some(&SSKDF_DIGEST_SHA256), + SskdfDigestAlgorithmId::Sha384 => Some(&SSKDF_DIGEST_SHA384), + SskdfDigestAlgorithmId::Sha512 => Some(&SSKDF_DIGEST_SHA512), + } + } +} + +/// SSKDF algorithm using HMAC +pub struct SskdfHmacAlgorithm { + id: SskdfHmacAlgorithmId, +} + +impl SskdfHmacAlgorithm { + /// Returns the SSKDF HMAC Algorithm Identifier + #[must_use] + pub fn id(&self) -> SskdfHmacAlgorithmId { + self.id + } + + #[must_use] + fn get_evp_md(&self) -> ConstPointer { + match_digest_type(match self.id { + SskdfHmacAlgorithmId::Sha224 => &AlgorithmID::SHA224, + SskdfHmacAlgorithmId::Sha256 => &AlgorithmID::SHA256, + SskdfHmacAlgorithmId::Sha384 => &AlgorithmID::SHA384, + SskdfHmacAlgorithmId::Sha512 => &AlgorithmID::SHA512, + }) + } +} + +impl PartialEq for SskdfHmacAlgorithm { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl Eq for SskdfHmacAlgorithm {} + +impl core::fmt::Debug for SskdfHmacAlgorithm { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::Debug::fmt(&self.id, f) + } +} + +/// SSKDF algorithm using digest +pub struct SskdfDigestAlgorithm { + id: SskdfDigestAlgorithmId, +} + +impl SskdfDigestAlgorithm { + /// Returns the SSKDF Algorithm Identifier + #[must_use] + pub fn id(&self) -> SskdfDigestAlgorithmId { + self.id + } + + #[must_use] + fn get_evp_md(&self) -> ConstPointer { + match_digest_type(match self.id { + SskdfDigestAlgorithmId::Sha224 => &AlgorithmID::SHA224, + SskdfDigestAlgorithmId::Sha256 => &AlgorithmID::SHA256, + SskdfDigestAlgorithmId::Sha384 => &AlgorithmID::SHA384, + SskdfDigestAlgorithmId::Sha512 => &AlgorithmID::SHA512, + }) + } +} + +impl PartialEq for SskdfDigestAlgorithm { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl Eq for SskdfDigestAlgorithm {} + +impl core::fmt::Debug for SskdfDigestAlgorithm { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::Debug::fmt(&self.id, f) + } +} + +/// Single-step (One-step) Key Derivation Function Digest Algorithm Identifier +#[non_exhaustive] +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum SskdfDigestAlgorithmId { + /// SSKDF with SHA224 + Sha224, + + /// SSKDF with SHA256 + Sha256, + + /// SSKDF with SHA384 + Sha384, + + /// SSKDF with SHA512 + Sha512, +} + +/// Single-step (One-step) Key Derivation Function HMAC Algorithm Identifier +#[non_exhaustive] +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum SskdfHmacAlgorithmId { + /// SSKDF with HMAC-SHA224 + Sha224, + + /// SSKDF with HMAC-SHA256 + Sha256, + + /// SSKDF with HMAC-SHA384 + Sha384, + + /// SSKDF with HMAC-SHA512 + Sha512, +} + +/// # Single-step Key Derivation Function using HMAC +/// +/// This algorithm may be referred to as "Single-Step KDF" or "NIST Concatenation KDF" by other +/// implementors. +/// +/// ## Input Validation and Defaults +/// * `output.len()`, `secret.len()`, `info.len()` each must be <= 2^30. +/// * The default salt, an all zero byte string with length equal to the digest block length, is used +/// if `salt.len() == 0`. +/// * `output.len() > 0 and `secret.len() > 0` +/// +/// ## Implementation Notes +/// +/// This implementation adheres to the algorithm specified in Section 4 of the +/// NIST Special Publication 800-56C Revision 2 published on August 2020. +/// Using Option 2 for the auxiliary function H. +/// +/// Specification is available at +/// +/// # Errors +/// `Unspecified` is returned if input validation fails or an unexpected error occurs. +pub fn sskdf_hmac( + algorithm: &'static SskdfHmacAlgorithm, + secret: &[u8], + info: &[u8], + salt: &[u8], + output: &mut [u8], +) -> Result<(), Unspecified> { + let evp_md = algorithm.get_evp_md(); + let out_len = output.len(); + if 1 != unsafe { + SSKDF_hmac( + output.as_mut_ptr(), + out_len, + *evp_md, + secret.as_ptr(), + secret.len(), + info.as_ptr(), + info.len(), + salt.as_ptr(), + salt.len(), + ) + } { + return Err(Unspecified); + } + Ok(()) +} + +/// # Single-step Key Derivation Function using digest +/// +/// This algorithm may be referred to as "Single-Step KDF" or "NIST Concatenation KDF" by other +/// implementors. +/// +/// ## Input Validation and Defaults +/// * `output.len()`, `secret.len()`, `info.len()` each must be <= 2^30. +/// * `output.len() > 0 and `secret.len() > 0` +/// +/// ## Implementation Notes +/// +/// This implementation adheres to the algorithm specified in Section 4 of the +/// NIST Special Publication 800-56C Revision 2 published on August 2020. +/// Using Option 1 for the auxiliary function H. +/// +/// Specification is available at +/// +/// # Errors +/// `Unspecified` is returned if input validation fails or an unexpected error occurs. +pub fn sskdf_digest( + algorithm: &'static SskdfDigestAlgorithm, + secret: &[u8], + info: &[u8], + output: &mut [u8], +) -> Result<(), Unspecified> { + let evp_md = algorithm.get_evp_md(); + let out_len = output.len(); + if 1 != unsafe { + SSKDF_digest( + output.as_mut_ptr(), + out_len, + *evp_md, + secret.as_ptr(), + secret.len(), + info.as_ptr(), + info.len(), + ) + } { + return Err(Unspecified); + } + Ok(()) +} diff --git a/aws-lc-rs/tests/data/kbkdf_counter.txt b/aws-lc-rs/tests/data/kbkdf_counter.txt new file mode 100644 index 00000000000..97022e8846b --- /dev/null +++ b/aws-lc-rs/tests/data/kbkdf_counter.txt @@ -0,0 +1,599 @@ +HASH = SHA-256 +SECRET = DD1D91B7D90B2BD3138533CE92B272FBF8A369316AEFE242E659CC0AE238AFE0 +INFO = 01322B96B30ACD197979444E468E1C5C6859BF1B1CF951B7E725303E237E46B864A145FAB25E517B08F8683D0315BB2911D80A0E8ABA17F3B413FAAC +EXPECT = 10621342BFB0FD40046C0E29F2CFDBF0 + +HASH = SHA-256 +SECRET = 32C4003872A146194023EAC1BDA74DDF2B66977DAD8A554B974CA2A62F7E4F43 +INFO = 33D8CF6D0C759FB622D867EA8CF1285DE4020AF81CC287ADDF38CC2DA4643E6DB3B215AD3E33BFC47877C3620E336887C3C9AD4A1C6C0476B0F90A33 +EXPECT = F593AF0E1A492A7B904A2662897FA1C1 + +HASH = SHA-256 +SECRET = 3C87E9CC98579B2749FF92C8B823A2AD6B367AC26622E7B5B80A2CE6F450E361 +INFO = 777D66A24C2D3CC3299CA0718F4F6DCD1161ECBEF6EB3C71F0BC145B4E765A6EECE807A74CA7A698D55B2EB0D30D8D3E5CD71FD2A02B5608274C95C3 +EXPECT = EA6425F03803F2F06C42D8BA11CE4EE9 + +HASH = SHA-256 +SECRET = DE1F4ABFE78C4DD6F02331C057EFA939AE2DB1F1E7E7C650E07537D259B1EA72 +INFO = 4C1F00198D76F3630D3260F56D94F52507394F4A98CDC2937D4ABAA76EBB3FD409A8769DF074DC002917EF818A4852CF004F0225EFC4663211A08C5D +EXPECT = 74182AE81EE88C6A1634FF4991BEB9EE + +HASH = SHA-256 +SECRET = 8C299BEEAEA05F445D59F5C354DBD0C8B4CD009F197A35369FB3B8612B75026B +INFO = 1A73FCE114CB427DFAA6A699AB2751BF7136FA03D238DA492D9A036143148334294D0BDBE4852C8FF37706BB27D722DDF909BC8BEF91AC72E1841CAD +EXPECT = 16614F3E848515CBE526FD2B1B5A0BC3 + +HASH = SHA-256 +SECRET = FA1F4C6CA4268480527B37CC1635B69D4A07118F720C60BD13CEDC867DFC2754 +INFO = 464516D6F8BB6589928849B984BEA6DC3A45A3E3CBE9B27A95E94801C718901764D78910E72E5FE69860E76E8F2BBBA9298676E8A86B3D63563B45A2 +EXPECT = 67507B8FBC813D2387F69BC4D3BDA44A + +HASH = SHA-256 +SECRET = AB12CA4709CA38350CAF5602EEE5218EC950353D19E65DE9EFC4DC2D19FE3017 +INFO = A8DA5B25E4F292C149C88F9203C5370822193CDAC135FBCD6B03F42300B8C372F68520DD3B525C79AA25F250B786E6DE7F5D73B5FB46C987671C7F76 +EXPECT = A7F44187D4EBE759B9A37E484A844E2B + +HASH = SHA-256 +SECRET = 12A9C4B3921B4EC2754E1CF093A38A98702ACF0B8EB30F4BF654B8E3A10D3990 +INFO = C5170E6E67CCEFEBE8415EE2FB6429DF37D6C2EE8FBDD6B970C3A98D486E8718C2202F7FC09FE438D53DFDAEEB0874EF0FD7B4DFA209CC9C5C512BAA +EXPECT = 9D1A3121760B17EA787E0F64C90BF109 + +HASH = SHA-256 +SECRET = 218B0F76980954CC381F2646636907E702078F7902A1894952966547ACE91B19 +INFO = 16CB8BEDB363B4795153A105C6049291F1978E7B2AAB01AB64E29C9BB562418CF3AB4F1EE6111D5ED2E58EBE3AD9665588E0E4D9DEAE8524B5B79ED8 +EXPECT = 80175FD5C9CA252C52BDCB5302DE3DB1 + +HASH = SHA-256 +SECRET = 3433F2C53824D6EEBE11E11EB656DA9740C5A342F5769DF7FE17C4C4801132CA +INFO = 07E3F8FF03E6AF5AAD503CACB1DB119D3178BBD3E2377888D6F5E6B7BF7B8F7C563A88AA8A778848F4DC01B29CAF85A3B2307E3CDFE3DE1E7043DDEF +EXPECT = AE81916CD3641C59897512649B657252 + +HASH = SHA-256 +SECRET = E204D6D466AAD507FFAF6D6DAB0A5B26152C9E21E764370464E360C8FBC765C6 +INFO = 7B03B98D9F94B899E591F3EF264B71B193FBA7043C7E953CDE23BC5384BC1A6293580115FAE3495FD845DADBD02BD6455CF48D0F62B33E62364A3A80 +EXPECT = 770DFAB6A6A4A4BEE0257FF335213F78D8287B4FD537D5C1FFFA956910E7C779 + +HASH = SHA-256 +SECRET = AEEECA60F689A441B13B0CBCD441D82DF0CF87DAC236290DECE8931DF8D70317 +INFO = 588EC041E5733B7031212C5538EFE4F6AAFA4CDA8B925D261F5A2688F007B3AC240EE12991E77B8CB8538678615966164A81872BD1CFCBFB39A4F450 +EXPECT = 3E81D6113CEE3C529ECEDFF89A6999CE25B618C15EE1D19D45CB376A1C8E2374 + +HASH = SHA-256 +SECRET = 95C8F76E11367EB55526A2B393AE906583D1CBDD47962146F506CC7CAC12F464 +INFO = CAD60E904B9E9C8BFEB4A81A7F67D3BDDCC05E64255870403770F3533AE6DD634CEAA56C53E688BD137AE6018935F34B9FB084EA48E4C688F6BBB388 +EXPECT = CAFA5CA03F5FBE2A242004ABCBD3DE1059C7407B1EE579255124AF189BE0B556 + +HASH = SHA-256 +SECRET = 4D05391FD6FB1E292E78AB9619B1B72A7D63EE59D7435DD71897B9FF7EE7AE70 +INFO = F078E6F9B7F82D64554FA6B604C808F19B1F6AD6727DB7AA6F1C86694E104B5256C8B4039919646481D7EA2452C72C17A3E8D7D3916285460AA5EB81 +EXPECT = 6B16E8F53B831AA5E86BF97A5C4FA37D089BC172DA5A1E7F662DD4A595339AB7 + +HASH = SHA-256 +SECRET = 0F68A82FF1671634CC9136C564A9E02A767621DD74A1BF5C24129B808214B752 +INFO = 648599809C2C4E7C6A5E6C449F0031EBF55C3661A895B44DB0572EE88083B1F4B12602AA55FC1DF150A65A6D6EEDA0AA79A434A1039B91B5A58FC7F1 +EXPECT = E297640F7768485D4A6E7CFE245F8BFA84700D99762692EA1A425CCC0275E8F5 + +HASH = SHA-256 +SECRET = 43EEF6D824FD820405626AB9B6D79F1FD04E126AB8E17729E3AFC7CB5AF794F8 +INFO = 5E269B5A7BDEDCC3E875E2725693A257FC60011AF7DCD68A3358507FE29B0659CA66951DAA05A15032033650BC58A27840F8FBE9F4088B9030738F68 +EXPECT = F0A339ECBCAE6ADD1AFB27DA3BA40A1320C6427A58AFB9DC366B219B7EB29ECF + +HASH = SHA-256 +SECRET = E5F31D98A13F2390B354DBA08E1E85116F99A56C2E8761D386958A0D0A888A29 +INFO = 02113F45151B63F374CFCDB1BEDE41CEF2226A42B6C02C9F090F9F3DB39D4E98A8258C42E27224279CD45C2501CA45A008D8F38915E5B45B8B995F5B +EXPECT = 98E7A023092A3064050902C8B90C749D72005626E0296E1DFB28C10E450B2DD3 + +HASH = SHA-256 +SECRET = E6CFA4864D31FE09960FFF968AC62F03B6F63B5A221CC95C3A1058B4B60FE9BC +INFO = 4670A7C2C8F5643B75EA4CEED87E253E58FFAA87472299160D35240753F3164C0820374B1F4BEDB2DC34692C8B7E06C7951EE73F1645B10E3F272D17 +EXPECT = 4F208E7306B076BF06133F439A6617A3D650253CF87775C3D6D7FEDE32139F4F + +HASH = SHA-256 +SECRET = 2F180B1A10445D3D29683B3FACB856807689C6DE54C760F6050C3329A4A1DE4E +INFO = 4D48CA49A279A79BF9B3A9E346C3AF74926FAB6AD881027DEE6A6F40DCF67ADD04EFEC4D86DF31BBFC190D43E3A7AEEA9BABCEBAEAD3B07B69DD3D6E +EXPECT = 7765D245FDF143B6CA4359A2503AD1D8EA8CAA7DA8D556B1FE8E25C44C70DBE1 + +HASH = SHA-256 +SECRET = 2EB0A49FD3199A57264F746B1C8ACBC76F7CE51223F72134590FBBEB3176264B +INFO = 980A908ED38B6E699DF3F44E651F0AD3A9D209D3867C495E52673855D09E4F1A58FB477067C400CACCA9AB9260E205C4556905F2727925561280639C +EXPECT = 06D5ADC2D5C517BF40406CC6BB56553B222F70ABF2BB505584000E88628BAF17 + +HASH = SHA-256 +SECRET = DC60338D884EECB72975C603C27B360605011756C697C4FC388F5176EF81EFB1 +INFO = 44D7AA08FEBA26093C14979C122C2437C3117B63B78841CD10A4BC5ED55C56586AD8986D55307DCA1D198EDCFFBC516A8FBE6152AA428CDD800C062D +EXPECT = 29AC07DCCF1F28D506CD623E6E3FC2FA255BD60B + +HASH = SHA-256 +SECRET = 7A7ECEE4F04C1F5453F29B8C65BEE909F673C44F65E8F9CC18C31C32E9BCFC5A +INFO = 0E2B53DD63008E0663962A25DA9CD55FC2EA377148783DA229FF7E3BD6142A43C854B6B5D06D87B535936F1EDC7CD067E8DBBA220A1F9A5932B32A64 +EXPECT = 96FB8EF9380AC9DE2711EF5A83249E608DC7BFFC + +HASH = SHA-256 +SECRET = DE71295DC50AC76EB5579410869E918B7BE757AFA606C509BE4378BD98EDA686 +INFO = 33CA974F8A1A065B75090C34C948449910495611E28ECC62CED29E5B3AE76217E139267041BA40BE235DE130438C1B14AA833296EB8E4BABE2101010 +EXPECT = 385D60538090A45A2B2544275905C4C16E9F23E2 + +HASH = SHA-256 +SECRET = 389DE0B914661C8AC9AAF11D261F6261BAF4652886CF20D2B13DF67BE2E3B185 +INFO = 92B3D47EA042591DB5B531907E09A45A60A9C5C5FE0251806B7805B641C5B3EBCDE14D6CB542B4CB242B04F5A9B60B2C66D1A24C66141FE0B818E93C +EXPECT = B12A4E200180D20DA404B44C952639A955DD83D0 + +HASH = SHA-256 +SECRET = 311AF73874E13A8ACAD981490113934065B3BD5D448E2BB8DFA68B70C69D7D45 +INFO = EA20FC9D32CDDC78DCBCA2EAD6C5C66744DA85D95B643D3FFAB2D0E2D5677DD3A27313153B019CFCD33B3E305ED66404042B2DB0E3DE2267CB557FD8 +EXPECT = C6E86D1043333FB690AD23274A908204D6BCBBAC + +HASH = SHA-256 +SECRET = 756F9980CBEFEA398350B886CA4C1B2910708B5B8154A0EC4B9648AC77B9D7DC +INFO = 3F09AA15D2FA769C6E8A3380BC55844827BA3EA64CCF177BEB4BFBD5142B3963BF696803A89974AA7D5AF0192CD525A83B71CD8EE7B0BC92F07B9515 +EXPECT = E3BC62B38A7B3C7E7FCB9EF007AA4AD6A9BB519C + +HASH = SHA-256 +SECRET = AE815BFE220407BCE6638F20AEFA109B63C7382E91D7BB8B010ED7C6D8D3757D +INFO = A221F1A3623ECA5F6385B57E7AFE67D134011C6058E3977DF977BDF0C7AB0E14B6D5C059F39948982912B047D00103DC4836E59B7A470222DBAE72CA +EXPECT = ED5E876D76227D0A7F1ACF5CA08C812995303FB2 + +HASH = SHA-256 +SECRET = D5110C808A951C5FE36AA4852FBDE7E0BC372A2C69A35ACFC890CC9FF78E40FB +INFO = F45187072A7D78FE91282F5825DAEB256A28A818C70A285262B080CD3EE2EC785125B27E4026AC9688A5EAE657DB578CD207956249F04A064870D677 +EXPECT = 0E7DE25FC559969C08D973AB40795DF74E51965D + +HASH = SHA-256 +SECRET = 4AA25A61F8B31F061E0FC1D541DEB20E097663CC57054E1F9A347989D8172D62 +INFO = E473FE5877FA137C50BEADC2295187F1B66E35C80B7864BF01C1C620FC09893991500E9A93851AE122170911562BF6EE3C75D5DDEADED27814623D2C +EXPECT = E235FF72D9C0A64A80CD86FDB26F1CD8740E2704 + +HASH = SHA-256 +SECRET = 26B29556106C06A85C6950AAF20B5E08A523E80E198A725B69E23FE93BD2E16D +INFO = BD973F9BC6FF0226B2ACC682E0084B8C67B285EA9B8B838938D18F96DE84521FE47D560337115F8232D765166751F1B7026E608D25EC6504346D106D +EXPECT = E23B197D4D5FD8081CA54DD86A1D459CCA7C69B0 + +HASH = SHA-256 +SECRET = C4BEDBDDB66493E7C7259A3BBBC25F8C7E0CA7FE284D92D431D9CD99A0D214AC +INFO = 1C69C54766791E315C2CC5C47ECD3FFAB87D0D273DD920E70955814C220EACACE6A5946542DA3DFE24FF626B4897898CAFB7DB83BDFF3C14FA46FD4B +EXPECT = 1DA47638D6C9C4D04D74D4640BBD42AB814D9E8CC22F4326695239F96B0693F12D0DD1152CF44430 + +HASH = SHA-256 +SECRET = 22256CA571D5C896DB80A8758FF81CF8631D2BC38C7E76F3BAFB0C2AF540A356 +INFO = 9DD2DCD97B926251B50C6111D988E2951B02ACCC143702C88920CF36848F7C731756AB0537CB26E22725F11DE069E5335802B0CB56C158DD75014791 +EXPECT = A11AA3B1A93D2CE117550866C28D6974CF626719385B8868101A71A5D2AA793BC23C3CFDEBE52EC9 + +HASH = SHA-256 +SECRET = 8066E057E73296158ED5479848317AD5E64EE8FB2E54D4EF85B7792F57F6F887 +INFO = 16DA06E7360E4C27419B5F697E4C8548925CE55B53AD9E5E85B94C7F8E57AD142A1A0A0384337B1ADF6410EDCECEA921152B94D6B23A192CE6F602D7 +EXPECT = 6EBEF64B358050EDC3C841F52188C5E442CB69630FEC0BE5114816AF616A333F0AAC5153E9265AA6 + +HASH = SHA-256 +SECRET = 56F06CC0BC392AB108696C7DF71495B5A5CD3638E0A92045AF7CBD3076F6DD18 +INFO = 4FCAE8F32B08B8FB746121A2DB2BC99FBB24B9FF11C60A1DC91F14AD9A60C6BAFE4ADB4DC160E9901EEEEB212A147EE0A7E76D4AEFA427F66A205C86 +EXPECT = CCDA8231FA5C0702BA282A8F18A0C1DEC6BAEF308625FB8F504410522C3F3B6D647C177054317A07 + +HASH = SHA-256 +SECRET = 617F1B6810C551AA5C21878B00656351466069D41ADC7FEE1CED3F2F3432435C +INFO = 2113F7005C580B77060990C2A3F9E8C8825F0D7E93A3F69F208EBB5B97C488DABD0DE7C7F00E08B4515DB2C02E1824F96E71C9A21A18079C4B649D81 +EXPECT = 0325B1C85F3D25AD5EBC2E7B380CFEDE6B3C8ADA1AF0D0D5BCD9D2B34C29083115168B8AEF54C584 + +HASH = SHA-256 +SECRET = 659EDB9A0DF51A3867D4AA01F74F60B7B151B01A3437C2F774FD37B6881A9CA4 +INFO = 3FB60870A5813BADFD7AF948C3C924BEC05C92D540140BF28F2546825C5FBD40F1571493A178467FDA9793F2F7EED45B40EF68E0107B8D74C0CF32E4 +EXPECT = 5C12C7B6EC38F516F72E76689C3106EE00EE8C2F50862CBF7FCB74BF8798EB761A33838788E276A3 + +HASH = SHA-256 +SECRET = 5703C556E3A53B8D2BF3C5CA773D0C6ED2C1B66A84E6680475A8286941B246B3 +INFO = 119E37D64B5AD702CA59F7952E5822CDAFB723C0F92CD70338A17E24D3AF6267AF792B189A01A8A3353ACD7A85B4D63BF7E4B22F73D7992E8E4E7389 +EXPECT = E302C1C1E5C8F688A7580997399433FBAAE499400B8A48901D808839C1EB49DFDF6324145F1EF01E + +HASH = SHA-256 +SECRET = 9A6E83B91BD999737E577E449142DAE05968E774B223C1185DC574DA785C93CC +INFO = 4B5845C6737202632B2946C3579D9D4582B475DFA373945B0ABC68C8F0DAA36520179439086C6809AA182094453BC0BFFEF0DC2888B96295FCD6E442 +EXPECT = E90E3ED902A8EB1FC67823AF534A2B48466BF2C5877DAD0AADC7D6FF741D8F437B2E6D0031846960 + +HASH = SHA-256 +SECRET = 9BEBF465003A85BC25ED340C6095D963885504D3CF0266AF252EFFD22AD32D6F +INFO = 17506DB459DCA14840917DAD23264303AB1C83E35018A72258099D20D4F8AB85C5227404B23AED6AE108BD1282E50A00D160E534264770A11B4FCC75 +EXPECT = 1A32EA308AA6DC6F1B7C77F1D9AAE40672FCAE22438BBB0528E280073B31797886B6A80036A00E19 + +HASH = SHA-256 +SECRET = 1D9209183E557D3AAC7E2AB53D26EC659DF2A745FE56A53818EF5853A42CE194 +INFO = C01A431A32833930A22ABEE5C6EA34DB459316DEF3B241529ECE7E39E2069A1E6B942946132EEBC9679801D2CEFEF4BBB6A1B84EF853325B7BC498FD +EXPECT = DABCFFA16A7589DEEE6C768AAF01E0813DE909005526DA54700083EF068F854D49941279689A1726 + +HASH = SHA-384 +SECRET = 216ED044769C4C3908188ECE61601AF8819C30F501D12995DF608E06F5E0E607AB54F542EE2DA41906DFDB4971F20F9D +INFO = 638E9506A2C7BE69EA346B84629A010C0E225B7548F508162C89F29C1DDBFD70472C2B58E7DC8AA6A5B06602F1C8ED4948CDA79C62708218E26AC0E2 +EXPECT = D4B144BB40C7CABED13963D7D4318E72 + +HASH = SHA-384 +SECRET = 912141F04E2BCF79FE4BAFE46F44DC9082CA39DCF964D9409C486139787467EAC87095A8F2E2561C19D418EE6F3D836B +INFO = CBA728C3CB42F62B9FDE6598C8628E0F88F7639FD605B39D81296A0749F27C8B75830686DEAB949DE1BBD0062E46524B1F30746C1CBA02508FB4C29F +EXPECT = 158B313C6D28B03B288AE2154EAB2140 + +HASH = SHA-384 +SECRET = 43C80426677180BC073D093A809436E16D56082647CE17948765D560B6CCF0442129EB55341370768197BADC754B095D +INFO = FD71974C9F2D40C04D62B73AEDB6A380AB65E84712E7C7DC3C109AE30311F3EDE77C7ECE413DD5769FD74CBCCB020C92F7B87C376205FF9490B689C3 +EXPECT = E241E2C538FD0293DE1D5F6E7CD56C7C + +HASH = SHA-384 +SECRET = 06F29A5D684A2EEB623532484A691AD85040D987248DC82C51D9B0B7E7BE51847E9076E26FA7D33BE6856207FE4CE035 +INFO = 56FAFFD4911601C217725FD816FE0C1A1FBD8F1553F20D8101422FC72058CAB9C2E63A6266A726075CC31EDC0A327FA4449B5EC981A86D9141932AB9 +EXPECT = A2DF03F0212038CB83BA468E9E05A502 + +HASH = SHA-384 +SECRET = FCF5DB9AB3214FD36D9FB4247AB2A6F58862F1387917E585FA656FE0A19847B3C111FBEE5A868092F224C79658EBDB52 +INFO = C792FC8B32A86C94212B5C845FC78A9A66D94EF98378E4D800B369F543F0A077FDE0B6B109EFB4C6BACFA1502249DDC1E39C7C56DFBE3B285D8E1970 +EXPECT = B75B0C95AE60EACF7ED7B6A216C0A395 + +HASH = SHA-384 +SECRET = 4179A34CAC89DE053CC0E1557D41BA96C2AEA4E35A0D304DFE2D4591DFD5DEEDCE94FFC7BA6ABA8B17DCDA0E9CF8C420 +INFO = 3BFAB95F22FC446E0E3682EE197F34DB085FF24088FB6A26299878A309EAE112EE32BF4882E218AD0A618B3062D685707E1261C15D62D14C5CE958D0 +EXPECT = 49A25905C12EF9FECE58C0A2861078C6 + +HASH = SHA-384 +SECRET = 816E498680E5CC39B8264709B508AF653A50B927FCBDCEFF2EBE62BA3A25B79950268D3114AC49168C57C419FD77DC50 +INFO = 40486CB22CACDDDE870B727DE81E11667EF92CB4F920CE7F2F80A0EF29ADD016142CE2694E866E1D631B5C1C13BA1E3FD0DDC9A16447C20186FAC13B +EXPECT = 79A867C0333D346F0DF8EA2C6D4CB14B + +HASH = SHA-384 +SECRET = 6CFC570A4ADCEBCCB8651C6DB504E765364079EF34315C783546605AC48CC2AA933C6F10E824ACC3C7338A09C01E1A30 +INFO = D5F8EE6DE37E3D1A54C370BC2A80C88749A546857C60C6EE6DF22F4F166BE188BD2999870FA5FCC1D7CC455828F3446E6A450A14A667E715D3C16622 +EXPECT = 7CF844677F8970285AD148E9904AB137 + +HASH = SHA-384 +SECRET = D6D454975EDF1598FC5532C5C3D9FA0ECD357EA587B0601C90C7515729A84BE28C0C9313A6EC757B8C2AF5C17E994675 +INFO = 5C3EDF4D856931D83F8939BE9A245EF34638F406DEE47AAE5162A71F0F68C46C95CEDE46FA452A83D0691E7D06DA9AB200FD5FB2F7C5F28C8A122C41 +EXPECT = 0B14055CFB841A465259B80DC3E87D90 + +HASH = SHA-384 +SECRET = D62569C3669F1012C966F54AC5AC121D8A89871582347B13B208DEFD50CD3BC4908C9896257B10345BEC2D40DF2B6C5D +INFO = 918C0244A3A7870E3AE4F8C07628BB754A0F6F8A52137D549C7E9E17103B42A029688857185E608470953F787CC97A7ED75E7A3609EED2F3B1A20E39 +EXPECT = 2DC4524AECCB5A21ACF1F0B13053F5A5 + +HASH = SHA-384 +SECRET = 8FCA201473433F2DC8F6AE51E48DE1A5654CE687E711D2D65F0DC5DA6FEE9A6A3DB9D8535D3E4455AB53D35850C88272 +INFO = 195BD88AA2D4211912334FE2FD9BD24522F7D9FB08E04747609BC34F2538089A9D28BBC70B2E1336C3643753CEC6E5CD3F246CAA915E3C3A6B94D3B6 +EXPECT = F51AC86B0F462388D189ED0197EF99C2FF3A65816D8442E5EA304397B98DD11F + +HASH = SHA-384 +SECRET = 96C45DCE79A02D2BFC2A10A8E744C974812E6A9B83474CE53743FCB334B87D826F411BAD836DE017790CFE07087F8B02 +INFO = 80698CD988E02B1BBB0D02C1BB2BDAF544FFDB3527EDE621D2F2F5EAB4A4964EF530378E94AE9AB7484D1EEF854832D5BB204A8BFF21651A9E3CE758 +EXPECT = 8EF1E0FC26D3997F985AB5567066391C0D8CED54F1CDABCE57B5ACCABE21EF78 + +HASH = SHA-384 +SECRET = 822C764A1B117085C10F0E689814D2BFBD9B43287F1A8C75D795A9831A286184C8586F3577B6E5BBCE1637925E04FC47 +INFO = AF346110B941B11D2189316C9FC2B9F4213775A5D7368D35412678A28FCD03B07F0549666EFDF30C80F0AB5563720A56EF616A13BB8F7780036FC08E +EXPECT = E0AE235CB82380527BE76934A69622396D90E7BFA7E2D295E4375BCEE0D1B101 + +HASH = SHA-384 +SECRET = 340E212D758E83CC5B89E4B56A86EE8C9631AE4E4BBAEC15AC095EA4407BC7B634AD630DD0BE85A91C08A8C7E1E1030B +INFO = 3CD5561AD12FADFCE408E04180AFCEE38B83156B9E4BE0779C4F0DB9E26BFE5CCD43E15921977CD26B1DB8288B80089EB7D1BBD7F59E1011B3E18B51 +EXPECT = 05FA577B7081210E7C9DE69DB03D7C2026CF4469A90BFA29F1C2C10818D463E0 + +HASH = SHA-384 +SECRET = BEB7DBDE7E0A8ACCA2F3EBF8C37A1E9C318E447B9592F93FC9021E690888391A354810B9673E1E2400F05060D3AAB851 +INFO = 560BE29C62ECA33855BD1CC70ADFAF4E7EABA4FE55075D466E91467AC4F4B9BEB678E1B2C961511AB12AFA28D34A11CD2EE2B151609BC851036D1845 +EXPECT = 63F96D3339E355487091287012D8D46280387567AFB67517AC616D340FA36466 + +HASH = SHA-384 +SECRET = A360F0B516FC35A76D1D4A9EC6A08E856B8EFA9310411398BF1AC69F28539300BC2256D76388E504C1F60C8B60E60698 +INFO = 0206FAF5C9AC40EAACA9A1D16AC71F19E2DE844DB2E73E4FB7E34567E221D5ACBC6931412745DCB0B05E119284D21C4BB3F9A939271750F68784FD9D +EXPECT = 88ECEE742A071F9D24720520E8BDBFE140CE57E7FE2B686966871EED0A6165EB + +HASH = SHA-384 +SECRET = DC875B2F393C1D40C241261B0918790601C8B908608448F766E6E8AECFA5E4927E7574AF4030047D98B11468108288E3 +INFO = C63AE3B995AFEE4AC3154BF9EFC6BB10E537736AB5BC427F3C376BE8FB81AA5E0764A4B0165EAAB0A519ECFF45E6F6C769EA664BDD6935C94D8ACEC2 +EXPECT = 473DC6A980D6E2465BFA3D02E7E5341B9CEA5E09F27767A5C58F7DB60B5F744B + +HASH = SHA-384 +SECRET = 49DB7631A3507F02D6B9048E26AFCE48B05E91B50FEC3B7CCF2E8BDE9AA9D79C0B6673F814D8CE39795E79239CBC3967 +INFO = C9083A35299B25141CDC60B4CC7C24263693F15E7AF1A8C6D121D798FE0B9948A83338DC2CBDC75876EFC83FD3398CA0DF223B105B0F13EC2033BAD4 +EXPECT = B350425347979C6F1C100DB1F6DE919100FF713765C1DEA146C62A69896235A6 + +HASH = SHA-384 +SECRET = E2168AB072C12DA471FC024FCBC52778E9BD68F44762B9D8BAAB746DB9C14FFE7181F71C2EE6488130832830FD0BD5F0 +INFO = 59569454B2F5424A914A2D166DA8EE127B0EC5AB4788B115C1D9966A5297181C64549073229A32E5DE40C94A8F9EFE71A0C968F6330482876E37BEDD +EXPECT = 16CB6BC93D9A001460B83259BC9A4344D4B4CB422C6102565DC5B190DE1C5673 + +HASH = SHA-384 +SECRET = 00A12D3CE4FF75A6E30F41F3557C826AF1326B6302F4CE887BAD3D3317A548C8C03A057284DCC38D8BC690BD4A565F47 +INFO = 24C5C0B2C810DFA08E35D7FEEBB8C78E0CD726C92ECD42D9171013738CA2531A947F523C37F64CDB04305BD969D1D6F9ECD46405D28280F968500BA7 +EXPECT = AEF3D57C8DA7D9582C5D1C62D6B64896DA9B1B0E4012A44CDC3DCF4B70AD6C66 + +HASH = SHA-384 +SECRET = BC3157B8932E88D1B1CF8E4622137010A242D3527B1D23D6D9C0DB9CC9EDFC20E5135DE823977BF4DEFAFAE44D6CDAB6 +INFO = B42A8E43CC2D4E5C69EE5E4F6B19FF6B8071D26BAB4DFE45650B92B1F47652D25162D4B61441D8448C54918AE568AE2FB53091C624DBFFFACEE51D88 +EXPECT = 91314BDF542162031643247D6507838EABA50F1A + +HASH = SHA-384 +SECRET = 23D5F3F34C9FE733E808949F4011BA3171376E3BEE807EC5B28496BF4EB51D85AA37C42E1ED93CFFBAB96C6DCA3AFB3B +INFO = 6EC7B6BBD81A312FF787DC6AF7C7C7B9CDBB7D0C19D808536BC0990BD7E79E232BBC1433CA567CBCC4DAF79E8D7224C30124A639852587E2715AE62E +EXPECT = C3C3579CD70AF7F8C184C580224F27F7664C9FD3 + +HASH = SHA-384 +SECRET = 0000D9B7EC6FBEFDF256FD68220B5205AC65A2001145118C50BA6B657032198B8B7CE3B2F7068A780DC17C22459AF2B7 +INFO = D857541C62B85756DC73DE7DC2D86F5D5E8B28338BB0A945B5C4FD7C81F71961B9705D3D153B19195D003B74212068ED10F96C53438653087A0152CF +EXPECT = 793EF113F96397AB0031EAA0FAA777C107E7D03C + +HASH = SHA-384 +SECRET = 4F3D744D3E449E0627BF4498743828F86E638F60620A7ED4A7C9B5B073691C9EC94728C58822E827F0F6CCF86DBC1CAE +INFO = 301FEEB25E6CA8503ECD821F1D3787AEBFB3D0EC518BB31174F5209B2AC1F28ED3E698736BAD10A18E3CBDB5DC27BBD12D058B36DB0892F9CFD08300 +EXPECT = 85EF9505B230565ECCF2A64AB3DE53E5A91C7B51 + +HASH = SHA-384 +SECRET = 6AF3E1659EE7CAF1D10AD9135C9757350F69886CCAB1BA4FDE50C4614B319E2B20ECC7636C5F6BBAE71CD35565A4A2C8 +INFO = 79BAC447F12FBE96C197963B91B939AC3DBF4541BEDEBB22C5677F54B377A0CC3B55A2BF4033D422401A149E74A81615472D0D4F8E4F0CE54384D844 +EXPECT = 28ABEC20D6F092D09E32360986359303753CEDBE + +HASH = SHA-384 +SECRET = 0299D1F064352D5A83FB61E1E050980F65B4B440819D2C1C29B6AD5BDFB2C00347DA993CC9EC00FCC4BD01C03FED9B65 +INFO = 6F9EE5CB3852EEC2AC3F095C25C20363D0F7F4770899BF99187E2A830C6571AFF821CEB7E80B6C744F8C5E7BC0B2B8196FB540002B8DB7BC60913998 +EXPECT = 293E0FD3E4D06EFE9EE1BA7D8BAB1D36BD7509C1 + +HASH = SHA-384 +SECRET = 1EDC7FE9AD33A7F6F12F350C128E2893EC1BE59C0A77FA5896F2E276BF9EB19CE5B1C1CC2FF25F9391DA304D26037BE3 +INFO = FE3483540341174FADD6BFA9F96473EABD964AD588AE1460739DEB3BF512475C6D57E017DC46E1115733DD81FA6A5DAA9C1F9D23C0AFBBB36958CDAC +EXPECT = 3C192347CE7313E9E54291C37C412CF90AF58A65 + +HASH = SHA-384 +SECRET = 27A9A514E63943E9B90CAD1291FB2A3054C85B4A745CC3CF31BDC1C8935D153FB495E7BA4AB641B7C9E3B5A7C497B1CA +INFO = C5AF66CE6C03FB7FD88017B38149A32C8C9DCAB96665EFAD28DEB71B61EE75887E1324800B01B13FDD5DB00B8BB4BE50CC2EAEEA43CF26E77DE6DCB3 +EXPECT = 886DB74207DE3B034F3E70CF9B47324D57DF5185 + +HASH = SHA-384 +SECRET = E358BB04A5AAED97939AE415AB3FFE9D2AB14C86C3C3F72B285BFDFB7C1440F80D75CCF28D2C64D503426F552CB4FDBA +INFO = 6B93ADD9163F5E14DF0160B0EE0402B3542F920FB12CBA71C2C7988877BE46BE951113DABF48AFF27E8C9B214CBF293B8A966D2EA7FF515B6BDAA8E1 +EXPECT = 48BC1BC135D5CE4AC04B11E7C50CDBBF84C44ED7 + +HASH = SHA-384 +SECRET = 6E3AB74222CAA37F732DE378992BA75C37B1C14B3F5A2C2BB42C270D6F213EEBAD3C3524A4B354F753BCE5ED7CA865DB +INFO = 79D39097B19BC6172ADB445CF9418979B943825228307F2F3AA8A591E0331C77BA01AEDCA2C094390C04694DAC907BE1ED20C124C0C1E5B278F63A3C +EXPECT = 629354FADAFB077D7344F524B82B7D14A5CEAB22 + +HASH = SHA-384 +SECRET = 582F968A54B8797B9EA8C655B42E397ADB73D773B1984B1E1C429CD597B8015D2F91D59E4136A9D523BF6491A4733C7A +INFO = E6D3C193EFF34E34F8B7B00E66565AEB01F63206BB27E27AA281592AFC06AE1EC5B7EB97A39684CE773D7C3528F2667C1F5D428406E78CE4CF39F652 +EXPECT = 691726C111E5030B5F9657069107861ECC18BC5835A814C3D2E5092C901CB1FB6C1A7CD3EB0BE2A7 + +HASH = SHA-384 +SECRET = BDA32EBF6B8D6C21B4078C05582CCAC57D0E09D598ED51CA808BBAE4315FF3082086E772A50F828BA3A8A47089604C1F +INFO = 723A6AA3E2093F2B3A377E4D716CFADEF784EB38D10302A8BC88294FFAB02E8AB43E6C83A70489DC91A4040E1C04F711A9ADF601D49A2AD07835C668 +EXPECT = 92EBA10440A0F28ECA40C765CC08031BFBAEC5FA2A2D3FA19069CB3D5DD08E01702CD5EE16328D0F + +HASH = SHA-384 +SECRET = BC8D610533E7FD81F3F6AC2F93876BE259E88C6F234ABD0880762D12CD7D2134F252BECC395CC48B88EB645D722514C7 +INFO = 29A5EA0DC26206268095791A2C0B1819079C88F85DD0259BC8EA74D6BF504FFC21C6CD5F92F74A02283DE4E33945393E64CA4B0F691885E4F2762E27 +EXPECT = 6E3A1B6233D8E08A1CFE49C9F9E8605FA366F61080C5F1A750B22113168D36001DAAC6D7BB8C99D4 + +HASH = SHA-384 +SECRET = D6BE75028F7BD73620667EA50C4A674471854B677FF0B63026460C3000D11B5210029F2979B3EEAA613812983E7D7693 +INFO = 5C2CE248C0A73A29A6E8E7B3FDBBAF0198D636E6D9D6A547685C27134D80411D122F96311434798CB19B3D446F52D7D1D74BF3EE3FD1FEA2A3B526CE +EXPECT = E67C995DA49F4ED0F6EFC09F839C795E8447E17790F9805AA8A93A4DB9A03970C280E9159A64FEC3 + +HASH = SHA-384 +SECRET = F7678CC0B7AEC5F4BDE487F30A5A88C988FD24C463B9E46B3B2AE4C765CA79C48ABE691CF93B6B435B2BDFF2A3D491F2 +INFO = B04C945BF149F2F6D17438958D1A725C3A8AB46CAA15A05E809524B9D1777EFB48E7D6BAAF5D3EFBF30B69B326935E59411207B913F38988E06ABE5D +EXPECT = 65E303ADE8D5ED5559C40E6312B10EE4F2F4DDEE166127547FF1A14CC0318CDC61D1D0C3D6542AD9 + +HASH = SHA-384 +SECRET = D5D78EEBD12F82F398235CA72AF4277DB475A80DA843F36E1ED95A661E1E610A2C7DCC433E60029C6689980961F3590F +INFO = 094C5D7C7457C51C877A0BEA03FBC44165C10635A4E64B8556C8ECF20914E621EF34224496489D76F67B2639608820ADA74137916BFB315BD50872ED +EXPECT = A16E9EC1BE1AE3B40AA906C8E18E9A7697CC34124B7B04957CE149BC39BDF27016F5839E21EA7976 + +HASH = SHA-384 +SECRET = 58F1A4C16CB332631B217A8E1B5CCA843665064CC61C9E82AE4180D574DEF4E2A3AB9403036E3915D95044997F1BAB81 +INFO = C77A0BC9543841DC062C8ABB804978A3AF7192244AAC4F73A821750BA38D486D5A2B4F8D927F830772C4E5208E91C37F82B7C658D240E14E20D58CEE +EXPECT = B2D075292489BBD177F72E5E800618D04A30F9B6E0A8D1FCCB438AE6F646A33E0C47D3625AB87B6C + +HASH = SHA-384 +SECRET = AAB0E07E2845CE1664057AA15A1D50C35CE85591C5E0D8D3AA7E8C5A58B0BF56C270957F3728C9745A4BC696F87CA0F1 +INFO = 3C115BFFC26D419182433BD43570FB3F6F2FFE37855A5546DBC542990FEF1E332C3A070743BA31E984CA18CC94E33F4F2C744F6B70234A7BA80D7E4A +EXPECT = 001CDA059179ACD067BC9129017D24E8B99A2D6604E14714F720358BF7F43CBB6A4AAD4623267E72 + +HASH = SHA-384 +SECRET = 0C5620F34AA7029F655A9EB9B051F13251D65BDF99D390B8F67898EB2216EC10BACB29358B895529DB64FBFC942FD0FF +INFO = 6D8B8CDF7B699C0205C6FEB4AC1839D3C436CF962F8575EE67FF20D69103C4AA93BB369D360980181E38C44215065C99A066946733EDE23185183617 +EXPECT = 2857C7B4221A02B6717A1C67B1EEB64DCDA8162284FAAE88466414B317E45457B5AAEF5B5089722F + +HASH = SHA-384 +SECRET = B57DC52354AFEE11EDB4C9052A528344348B2C6B6C39F32133ED3BB72035A4AB55D6648C1529EF7A9170FEC9EF26A81E +INFO = 17E641909DEDFEE4968BB95D7F770E4557CA347A46614CB371423F0D91DF3B58B536ED54531FD2A2EB0B8B2A1634C23C88FAD9706C45DB4411A23B89 +EXPECT = 5949ACF9635A77297928C1E155D43A4E4BCA61B1369A5EF50530888550BA270E26BE4A421CDF80B7 + +HASH = SHA-512 +SECRET = DD5DBD45593EE2AC139748E7645B450F223D2FF297B73FD71CBCEBE71D41653C950B88500DE5322D99EF18DFDD30428294C4B3094F4C954334E593BD982EC614 +INFO = B50B0C963C6B3034B8CF19CD3F5C4EBE4F4985AF0C03E575DB62E6FDF1ECFE4F28B95D7CE16DF85843246E1557CE95BB26CC9A21974BBD2EB69E8355 +EXPECT = E5993BF9BD2AA1C45746042E12598155 + +HASH = SHA-512 +SECRET = 6024BDC82440473BAF798653BCB846F8503D73B6EDF5CEBC116374538B6256AC8A8AD5FA8C7FAD7B3F089933B9C7326D6B80572635C9F5F6B38643971D075B9F +INFO = 1472A96BC81881767F6154B2BB79F4DA8578D447AC495D7EDE31454834BE3D643034B2E16034BA877A846E6E6E22B284B6D894395F33B4BEA5F1CD7B +EXPECT = ACBD761E976576B189696D26E745A680 + +HASH = SHA-512 +SECRET = 6C7D94622A2D1C4394768A39CC340C6887E06C4A88D57AA7822F0F2B3FAC0192E851F7DD39CBEFE6CCD70992E27EDEA4729B215CA2DACB05373A411600233CCA +INFO = 52D1EE8B4C0AEC771E236E86928B4E943CEC53401848B8A353FB2DC0C74D9CFF74E8086EF5542E3F210209FF614D1FD3177B5DF4DBF89978D1ABDBAA +EXPECT = F3048AEAE11B116A234659D40711267D + +HASH = SHA-512 +SECRET = E0630545EBDC440F373D194FC6C4629A62AEF028DB52A3FADCD32DA24C2FF79106D349AFD8500D6B4FFBFE2A9D59803FB90F25B60FD029C3B67C21DC070D852F +INFO = 1821CB3B1CDE82BEB76E55CAC866E3BBF7EB541E0AA66C3DFBE509EA7870670745ACD5451D775464AED2D66E5CC4360C6B7B75B35A3820CEC217A086 +EXPECT = 90FBFA27119450ACC8E6D74B03B05558 + +HASH = SHA-512 +SECRET = 7B3088F0FE86A0C71CC02660E3AB04D3789500AB9551DD59F030847DDA0E14DDA8D6A2051379D0F591269C3DFF303CBFA08424F421913B3BF9C3C076012AD8FC +INFO = 8524FD3E73EB9476513E31005D29DFE6927D877B74734EDD8C2B886FFD3F053000D28344EE9FD9340B448C29FB1725657B314DB93C639F98D756CD9D +EXPECT = 5122A61ADD589993111739F4643EE406 + +HASH = SHA-512 +SECRET = F4EE35D1575D273CE42A66D6A6E521E87FAD64BF81C99F5773B60C0A9FE2D4D97C52E6E0C1775B4EF7E41E92A1BD32EABF3FBADB93F6A0B3E7324B7DA043D6C9 +INFO = 92364F044E0D64A8FB4C53CB1B73A665AAF66FFC9DDF4152AE9DA35B470256B00B50234E26C3149F1C380DD93E75ACCACCD167E1D60A8A06D31BB2E8 +EXPECT = E2B4CB180AB6730BB0C16178B20548B6 + +HASH = SHA-512 +SECRET = DB3DB876166713A7052A9954F2D37EF35E446368CF84CE5C315B4F59AC00D0D9EB22B119D040BAB5F25F224A24D94901015A2223856203DAD2260164ECE61935 +INFO = 77D5AFC143648A249B17AF10D688188A780542DB7F2E3D4265D16E4FC94CDAB158C5AFB9C70AF2D1668A008AAD4ADA64A9DBFA97B439002E4BD3DBF6 +EXPECT = B01C96BAF28CA5841CB6E4E0CAE30D59 + +HASH = SHA-512 +SECRET = 7C977B74CDF87721A37C6F5E9D7C91D1E11744514D51A68D12D1837D26B79611E86A05A4685DBEE8EB0B30962B19B96F373F5ABE92FF0235A4AE7C35380794A5 +INFO = 8DA372E4D534416D9C4FECF9D22DC576F889BC6F27453CA75458CCD8F88A8600BA03D4D19480D2EF899DC72DF0732FCEE8ED997FEA4F2D526BEC44F3 +EXPECT = B22DB6AC3A88AA1AA093C0FE55E2639F + +HASH = SHA-512 +SECRET = 6E6ED01FF12D3251396BF56062B1B3C79B55B4373C0331B14AA593A3EE005B5F068F0EFC56026FC72D66F2744DD1F168F247912F9B26EBC59463B96BD9F1A1A1 +INFO = 5ECA796BEF031B87521ED0904BF1D855589749B0183E993D99F741619B62644FA686A4C90F7F1E6ED5344EB75880724C09B751617C31FA5549828A25 +EXPECT = B03B235F5AF9719F35F215C2F94A76A5 + +HASH = SHA-512 +SECRET = F4CD4F279A128C74E5EB821472098204ED96ED61EAC9281BCD53FDE6890A2CBB1CDB97E0E343FC8588B932CD701AF88F0A7AF723D5C0850E3E01E47612FCEC83 +INFO = EF470DFCD57359F558354F845FC8CA3A1A67419A6D0F6DD698C78F9A57E820C3D8786F3C589F9693B8F3FB3E123A482386C1C0CFE26BC5322E90FD4B +EXPECT = FAA720299513B73DE2B54896D9A06BCC + +HASH = SHA-512 +SECRET = 5BE2BF7F5E2527E15FE65CDE4507D98BA55457006867DE9E4F36645BCFF4CA38754F92898B1C5544718102593B8C26D45D1FCEAEA27D97EDE9DE8B9EBFE88093 +INFO = 004B13C1F628CB7A00D9498937BF437B71FE196CC916C47D298FA296C6B86188073543BBC66B7535EB17B5CF43C37944B6CA1225298A9E563413E5BB +EXPECT = CEE0C11BE2D8110B808F738523E718447D785878BBB783FB081A055160590072 + +HASH = SHA-512 +SECRET = B0B5599C29CCE7644372B278A3275F3E0723739F42BC03FC9A4ACA09D9CECF9AFDC30393DD1CF7499236239608A258F5C48E66B663F6521049A482B63D468A33 +INFO = F00101F38E5D6098CFEA4C7C8490EB5505390000478A645E6621B1F711105BDB4820DC0C783BF980C062899B70875E17CC9116F2FA588A942405BBD6 +EXPECT = 768796179CA511B841717887810F870FA3C12641C95ECDCEA8590D730EA43B8E + +HASH = SHA-512 +SECRET = 52BEC703DEC94B80ED2F8449C752EE4B8B8B1B80E55B6B0E1E9DB1770DADFBB2631DF554D1BA41BBBD0E587369AC81B40BA6D941FB62DBA78A76B554EB03C643 +INFO = 9F51256B1896925866F22053348EF6E8A52EC580B1F32BEB2574AFD23A5460C30E8C811D0E7A2887BD5CC0653EC8D68DCCA43F71A8DF1F0193205B75 +EXPECT = B19AC7D4EFDE7C62191EA76530D30DFA5510CC74BAFACAEA5CBE2CED467FA1A5 + +HASH = SHA-512 +SECRET = 8C472849C12153D5A47360EED0438689D056C08496D285A179297A93DFF50070FD3C2C2D88F1C4A25B77C1A5EFB47BB8F881C89F24D464BC23C4F200291D6251 +INFO = F2D317F020B212066EF7C869C9C56699C1D4DFDB74CF679B97D718E701E442B117A6D1162BF825EF491FA628EB249A1CE28018B8A5BD0B1B296E4D92 +EXPECT = FF82B4D0FC9E17C0539FA2FE66F2E1A07B7B593A1342CD0B48162FDA68B7D80A + +HASH = SHA-512 +SECRET = 104280C86C79879E96CF15DE96412492FFF5D4DBFC677F7D384C09A4BCEE160FA3C972969D12F9B1542D570BAAEBBD801F632E172A8A00477EDC06F938EAE198 +INFO = ADF1F167939087D71FE8D9DDD2C903C542775129DAB2EDC2446CB394A808BA49CF4710EA10CB72A4EFE8F1A32C03D14660F10B0AA9255BD0EE865C10 +EXPECT = 5CED814230D7F07DA116D7930B4DB6B18B391BB869D15196677BD1D17F2F8C7C + +HASH = SHA-512 +SECRET = DA48986B8C84D0F6B2D6BA9F2C02A53ED8F173B238DD8F3020E15EAE425871CFF148F15BB0BA17C2AE00F44B2C14725A7B130505469BC0706B699E2D901AD16B +INFO = 08528600237B6D049268B7BF3E2FCD9373A6B2F6732EC89437EF8E134FB947C3F37F254C7041D3F06F789953BACED415E9D1DC400FB0025BE180425B +EXPECT = 50EB29E9CD5CA7730FA565870B23A40DB75B5E051B35850C98FC9613A251BDCB + +HASH = SHA-512 +SECRET = 195E31B3DB4630A9E66CDE347716F50227F8A81C397A72E30D27AAC27F8B9F2F2B453E68FABC9D209D443D952263DB0C341C866D966EB4DB8F8ACF8EAFE7A227 +INFO = 2B281526345351D797BE0A7DBC517BB9C9C220B5194CEC3847F6FAC4AB1030867D1851CB8D46561DB605506567DC2F39DDDBF471E4A7D51B23745592 +EXPECT = AEFF884DCBDC002A5F7A877A34F73B42ABAD2089D4E39B721EB370B3D87627F4 + +HASH = SHA-512 +SECRET = 7A1F12A3FAD7E0D3E244FC7BD3F0917E47BC76C60285DED739DDF9462C160CDFCCA887866D6DAEFBF12E7410FB1B50AD6C8B21B6E56877F47E8B14A0AC9F936D +INFO = 77097024C944E349F0CA2A579CF51353F50664DDB4BBBDBBE01DFDE80595DAA5D043D9DB9651FB821CC9ACD72FA91B2EE93E23EFB39409711F3915D0 +EXPECT = D2191B6AACC7668038D762C0CD5915BF68E490671EC4032C20297A64026FE042 + +HASH = SHA-512 +SECRET = 7A41DFE8D0C9AC924A2ACCD615AD3C0BC0D7E124FED6B2B7E05B9F8E6ADE0678E98D45766F9697CD187BC10321195FA1BB84B55BF94BB112D73C6ABB857F40A1 +INFO = E47AA81AF8D1074C8F7FBCB589727EC225163D076D4E8CEFC827C78EBA7B42D5E70377D7033DFDF5EDD93F605DD9B25D75548518E405563D1D4BF313 +EXPECT = 5DBF1D3DC128E67F2452ABA858B7ECFB87EFBE66B714541C0D4C009C2B92D7F9 + +HASH = SHA-512 +SECRET = B27BE323EE094400FC9DACAEEE0365E0C0C52811A6081551DD46DD86302C6396FCE80BB60E306C9785BEA1270356A1C2B4DB7634D5C04891E85417FB72CDFAB2 +INFO = 6EEDEA4C7C2AD22289C4E66A96E7A7A1CAE7D340FAE412A6E77697C2081A27560A9F0CB0E412297F99103A233A7998650590C5A7E2861738BED7C9FD +EXPECT = D0656230B86E4DC3EA2BDB8D62B452262462EED61229D1E2B92758B57C54C434 + +HASH = SHA-512 +SECRET = 9DD03864A31AA4156CA7A12000F541680CE0A5F4775EEF1088AC13368200B447A78D0BF14416A1D583C54B0F11200FF4A8983DD775CE9C0302D262483E300AE6 +INFO = 037369F142D669FCA9E87E9F37AE8F2C8D506B753FDFE8A3B72F75CAC1C50FA1F8620883B8DCB8DCC67ADCC95E70AA624ADB9FE1B2CB396692B0D2E8 +EXPECT = 96E8D1BC01DC95C0BF42C3C38FC54C090373CED4 + +HASH = SHA-512 +SECRET = 6AC19B36AF7D0E5C65F58DDA2FF76C68567CD8AC16FF2463FC3C8654DE45A05E39C75D83758351753D2E143629AB9075738B037A1EF41F7EFD70F1E700F7F67B +INFO = 4BA9F9E8E33B40F4390333F597AB565B27A841D5FAC930F67101E65973F071AC6BA3941C9D22F40CA44E91657A629B7F56980E0ECCAECB943B16EE27 +EXPECT = 3E43B70633884480DDD93D6F20BA512B55590B68 + +HASH = SHA-512 +SECRET = 2ECE7BC9EB5249F5179F2528A062D0DC30496604BB76F26E160D3633140FC6EDAC717EB5402D0FCE56B76B7CFB0AAF47B6AFC410FE06EFB049FA28953D7E4942 +INFO = 1EE1EFE3AE248819C5B33DEB7869C3540CD8ABB7DD522C5F0AB71618159CD0D23DD805F14EE27E012240CFF85F57C72F88D5EF6E2196EEDE8CF7B786 +EXPECT = 2DF4FA52D2858700085570901F5F857314E1E02D + +HASH = SHA-512 +SECRET = 283E37FE181516DE2BFB14E6291EDB91DBDE4A7B1475352ACC47EFDF244A2BA2E639D9B028C02DFEBF51DD2D37C4DA64AA89E6A64916D58F1C80B25CC080A950 +INFO = 578CFE1A70F52F7E456A22F1485BA23830E3DCB05700ED2812CADC181D448F1119FECD8FCB49667309CF0E316470590ED93BAF567F469DEF5DAFC3B1 +EXPECT = 24719CB6F6B10E2EB586A0E167F5683DF2113771 + +HASH = SHA-512 +SECRET = 4A66D41EBCB184C3148A0DEBD67AF5C8ECE3E6A1C13C413789796A99A1ED24ADA2F5107C91159306FE8F68C245499FBFD8F85009A100C8535D22DC71DF09F74F +INFO = 40EAF429F7DEE6F5C91F2351BA51E53CF6F7F836398DBCC33381B4EA4046A5F2CD545C932E58027A1E724FCF8552CC79ABBCEDED385A524648C1DAE4 +EXPECT = 8F1BDCB99AF0FC510AD4825EFDD750D3CAB7846F + +HASH = SHA-512 +SECRET = 95A53B3F953AB90D4F85E7E8437325BE1A0235A89311FA1C7405C3C0BC61F14EF6E7CAD32165AEEA2AD718BEF144D66302E989E2F1A323E512780D28B6DA74AC +INFO = 37495216C113EFD2CCAEF3583A87B067D65C165DBACEA9E04EE34411EAA6616FCE5348ABBD121186F29E071C467B60D9291CA2EB664EBC2A7EE50EAB +EXPECT = 71A5B1EAB411AFBA65081D4D0471D532BF0EC65F + +HASH = SHA-512 +SECRET = FC3EF290A89B79E95DE83326B34242778FD2D542457365E2719D328FA5581401EBFE6E2655DA070AA3E26B363B595E1AF7BABD17075DBEF1775CF6157D3C716B +INFO = 592E1984BDFB4BF18DE83A6B19CDB63F27B10985E7CA520B71EC392CE09E1D2DA14C632553574B876752B9D572ECF41BC5AFD057BE99D8019E19F7E8 +EXPECT = 083CD3B0B564EE7C5E927F32D10190749715B21C + +HASH = SHA-512 +SECRET = 388B8C9BB988E762EDE3CC072BD88BA7294785AFB0D6506C2357A5E23331A51E968F7BF50576EF9E64B69B4F48D6E509639CE9693E3F2094FA33B97963E1CC6E +INFO = 5B8FE0C658C0FD7698234C477860531221A7F48617E4405D5C8E8D3550F105B78469A449CC2B855D4A5357C1C612234B2AE2B820F07487B094AC7C3F +EXPECT = 735102B59B09D06D3E6C9494433CB03F5B8CA383 + +HASH = SHA-512 +SECRET = F1E39D9D0984641F24702F8B37FBF9A8FAFBD17FC23569E940C31384CDA58C0274B167B1AFC9FF44473D20D6A23C922502E31B3DAD13274B22024FF4EAED668E +INFO = C880707804A76450019632C32F037F97FF2CE7FB1541A9ADBC092D96122CDE19D5FE81CD12A60F491C5877B601E4ECBE0FBAEB67B446C4BB2A9ED60E +EXPECT = 5440C3450AC332D0A8F5C724647962AC82F659E1 + +HASH = SHA-512 +SECRET = 9E0A79B1D6C672D3235464CB2BE6A36D02C982387DEF7E2FE32A5D2BE7343FDC038AF48FB941972FACC8E33D6286E142852DC4CF2667A3C97DD557BC6FC66E98 +INFO = CD356D14E32BF958C17711D26A30412088A2E214E600E692ED4966212565EA891C807E1E0BDEC0A9DBC71F502F09975FCE910C7723DB4DF380E7FFB2 +EXPECT = F46693300BC3BF106D6A8566481FB12B45EE1F95 + +HASH = SHA-512 +SECRET = A9F4A2C5AF839867F5DB5A1E520AB3CCA72A166CA60DE512FD7FE7E64CF94F92CF1D8B636175F293E003275E021018C3F0EDE495997A505EC9A2AFEB0495BE57 +INFO = 8E9DB3335779DB688BCFE096668D9C3BC64E193E3529C430E68D09D56C837DD6C0F94678F121A68EE1FEEA4735DA85A49D34A5290AA39F7B40DE435F +EXPECT = 6DB880DAAC98B078EE389A2164252DED61322D661E2B49247EA921E544675D8F17AF2BF66DD40D81 + +HASH = SHA-512 +SECRET = 244356BE9B327964732EB4A7C09B04B420712396EB57F72BC94924066C687E878E798E0A033A1EE1A4D8CDC2DA0443ECD77401D0460CD906EAAB02656C1EDC98 +INFO = D806E2DF8C85D3BAF5D67E9C97B746EE6BBB1BC10DCDF6C7A6075C311CF34752ACBE60E68F23C7F890B5EA7300A1AD32178254885246F0493987A6E8 +EXPECT = F0B5BC749EB300CA217CA82FDFFED89B1BF2C8AFC2B36EE2B48695E5085B893A6DAAD5474F74EF0F + +HASH = SHA-512 +SECRET = F5567A2DD9236A99200C4BD5390743E2560BAB4B196E3C732B01ABF900C7649CAB5B957DA6AE8FD025605147B36572C19F103670B16F6BB57C138754479AD45D +INFO = A8CCD4BD36FB0ED0765E9662F1028D600BD650E4C2CDDDF94B27EE881120AAF74B727B02F0036B46162062E39ED43FA85687A58D177AF6F566811889 +EXPECT = 2E55B73D126DB0F92810266C92E4DC7A7F2D32CBED9EB4EDAB519E5CC9138C642FD4B229780C17BF + +HASH = SHA-512 +SECRET = 46A65F2E432FE2AAB26DE24D1B9D39B44DA270230F17844D44E249565A125F87A070B4B2EEAC0B3A6C54ACFC49DDC6360F59FE0E330E0605C61E85C5C27FE756 +INFO = B06A23E05945F96A293DE59DC3DB5972CA1FA00B4647AC38F753790335D5DAEB2FFE09CF8924AC4E80B275EA4DBEC53B9E2AAF90DF0E6FD82AD69F7C +EXPECT = 04BBC4F93FB5C3589690798BF793C10BB726F87A4A2DE93B8FDF6BE8015ABE156577119C5637AE71 + +HASH = SHA-512 +SECRET = 8D371552164BCEE60771E876CE546C4B0277B978E0963E2312666FED5FAAF340A55E00644CB36474464A4C2775F480D88E2D3B41F31E0706209EB8E51595B92E +INFO = F570212DB2D3F314AFAE51F83875E4DA7DBC13073ECE83A6727E011DD0F748F569714B59F44930067B8962B83289B441BA65B0E2237AADA36800F955 +EXPECT = 9565B54259FC5C61A7F7448E6BDFBE48191C2DD6CA61CE35EAF3717FFBFE1C467B3DE080FAEEB8B4 + +HASH = SHA-512 +SECRET = 07F8E73D47DE5F0EE2CCF871C702A92A1FD15A4DE130611E46A4247A0497465B3FB5D785C01ED1CF061C73FE1F55DFE0111EC735D376BB39AC6CF83D7A2371C4 +INFO = C13AADC44D9C3A209B9081B19BE6556C9FE7B491E0B8D98B18AC82C6B4DC3E8EE23B82DB2BABC27F055979511895E296B6D9F7DDA35A0E265FB3C645 +EXPECT = 9E222EBCD27C7CA72179121C6C60FB0DAAE910620CA7B01A8D0154D48DA9C7D7AA9A5667375FF518 + +HASH = SHA-512 +SECRET = 5F00B6755ED8C9D3EA8CECDD8C17CA3AFEDD25871D1C50B302C1FC864D04147382313E6A701D9B6CC3DE791FA65A782BC0D74097361B12A5B45408F1172DFEA5 +INFO = 5669569B911167E8F9C6B1A83FDE57B6DB4171AEB7657AA94D87D542BD9D4E89F69C89E0FB4B3D3502702327FBFE653AF60A7FE1AB600E2620D765A6 +EXPECT = D937822EF92073CFCDB5D8DB801A3875E45FE34D316F40EE57140E1153E4D28251D0A05A9F49EA66 + +HASH = SHA-512 +SECRET = BE755AB76FFD8F2EB3F246E036BCC06DF39E83A471F468C29EA8BCEFF47D28222637C1CACF2FDBD233545CC888474A7B2131CCC735225027C517C48420D10ACC +INFO = 4E39D12BB306F5D1E1859484215048CE6FF0033B3199CF1732D0088C4187D49884FE30571243B2A643BC56D4986DDA958ED5C279BF7A9BE2E37567E3 +EXPECT = 302E5F81107D186C054173BC705E11A648A5DCEB8435510C3CDC80C9984CB9C9C362840D44265E7E + +HASH = SHA-512 +SECRET = 2C94C4873FAF4DE3E93152B49428C92C865DC58E1E336FFB9AA50523DB6311DB34D5A731164073D7958506501CDB4DCE05B845198E6FEFE63DB87837C2434850 +INFO = 27FE559B6D92995338283A776159856285474B74302DEDCB3E7FE191490EAB7F580212CFEA6F6013388E3DB28443F454280572B90F0DC2207FDCC0EF +EXPECT = 42885AC518C97BDA290B548B597B7F04B20BC34A0A6D9DFC89A446D9F23A1CCCC37608FEECA7A4C3 + +HASH = SHA-512 +SECRET = 0FF2C279653A7B954AFB0096C2B16E591FA32EEF39EDD8141C6513D6DC6C0863AF0E94BFD57B17817CD1038F37639CF8D63871AEF46EE81947526BC5454C13F2 +INFO = 16EE1DAEF6A0316AA0467646C521FA30165FE336B249600F1E565D287B97018033E2BAD45D76C6685D77339B27EBDD9CCE1B34C1E4619A97774D94E7 +EXPECT = BC0E3CB2B78BD9D6E2EC544672ADBE44398FDBA7EF332F1C4235C104CA32EC00FB47D47209E15197 diff --git a/aws-lc-rs/tests/data/sskdf.txt b/aws-lc-rs/tests/data/sskdf.txt new file mode 100644 index 00000000000..142b0f03b93 --- /dev/null +++ b/aws-lc-rs/tests/data/sskdf.txt @@ -0,0 +1,770 @@ +HASH = SHA-256 +VARIANT = DIGEST +SECRET = a4801c1ca39cc74b7df5c127593e3482f4c4e4e945753076 +INFO = 4341565369649a34a5c3879740e3907add7ba1b2c3d4e5658aaff1cc4bd0aa8e7a215ad1f61873ce67cd7b83225010 +EXPECT = 13229b870d7e49795f34 + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 008392d899edd742510212be86e6ba5eede4f354b034b2f4df0e6f5a0003f3b334aebbd3 +INFO = 434156536964808e2f1e4b8a68301e33483b423d0a9b6d15a1b2c3d4e5f3c9e8598a950b971c402d0d65a290845fde +EXPECT = 2041f42703fd9ff370373fef399009cd + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 0189e7c2133207b3f37741fd596d532bfd37a62b2f6577678f42e0643300a3f20c1f4bed +INFO = 434156536964cc2ac48877251aef42fd21686b0aa425a838a1b2c3d4e5da4e1b22f244bdf689861da265954b433e14 +EXPECT = 247b5fb8977bf202b9c6fc81e07c7deb + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 07ce5c270ad7d39b0d4c594eb66620fbfc424ee8464c6c12cff08307d34f74082b7a9f54 +INFO = 434156536964bd813bb05390d7bbd94ff0b3687c157ca53da1b2c3d4e5a42c7a0c533d316edcd318fbac3a9f754f5e +EXPECT = fab546ee7a66c58e0a0501ce63e0731f + +HASH = SHA-384 +VARIANT = DIGEST +SECRET = 016995ef4b250d677dc674577427a0603b5d2185ee66e88c2f450c47727cfafa5707c5b74f9d6a2403f571094eaa7ee54bb251de +INFO = 434156536964ac9a3236f3d2a4cda1ada36079b3275556220286c036169ebda8a1b2c3d4e575408962a5a3c8afeb92 +EXPECT = 86a4a396d8819edfab9784f668b997fe9a1da99f6f08c5b1 + +HASH = SHA-384 +VARIANT = DIGEST +SECRET = 00c12d6863ff167766e1ee061eb53109f281d5ffb0593939fb37281354110cffa0f73f2f3761524f86d047e57f8e3fa04f7ba9ea +INFO = 43415653696495b4b25586d6a8a0653ea547ce23d757ee125ff89f889e9cd4c0a1b2c3d4e50ebd18fdde3f0429c876 +EXPECT = 3ca777a800ff751ecfc610b08ce3506aab4541cba38b1cb8 + +HASH = SHA-384 +VARIANT = DIGEST +SECRET = 012060eb88ab29fa77688ab0ea23fcd21af79456598b82f5212e7e0b835fecca08c6a6fd5d49a264cc6d66f93bf8a436c1fadd60 +INFO = 43415653696433a0c05720cd9ae757b38a71e9abd634e90fbd842bf15b1d4c0da1b2c3d4e54e7d6c1bc80533e7452d +EXPECT = 241e45e9cbe075abe0a0aed94834d97f704d4a62da1889ec + +HASH = SHA-384 +VARIANT = DIGEST +SECRET = 01b11eb41c758b28cb326d78e33ffcacd5ace2ab395281f791fd4f7a80649fd47d4d091bb9cc1c725a4c32715165291b5f522a1a +INFO = 4341565369647cdaff4407f99eae33795b0aaf968c20b0071dfe9fe0e3f80eb7a1b2c3d4e5457a0daef12445a665f0 +EXPECT = c0f969c63e99d1798f0a52907b6e42c952611940618733c1 + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 017812834e28c2930b612b15de106b241948a823291480cfe2c7515530aff60cd8eee86f6100769a889bbfda985d6fb60e12104c +INFO = 4341565369644e1d7bb30359f9dfcf4a622e809a87bf0c78ac5775eb8b54ef66a1b2c3d4e54f288cc26c3a5c84d344 +EXPECT = 61b86d9bf5783c89e9a30b4e30d2c0096544c74d1677820f + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 0184c49404209f6c0af846444fb5705da3875c8a84b6f43004e9e6fae6d2faaaef26d0853fe191624b74de855955807077cd1e6a +INFO = 43415653696426abad2b9558fc7450a4e2a9416330626c17ad5a7667ba7e64cca1b2c3d4e5b49c2962094b5387f0d1 +EXPECT = 76ee4f052b5862138b91de6b57b9f9ab74f8263ef72948eb + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 016774c65fb07b9d3d737d027ae5409999b1a3965c8f9d4b470c50be201e75f9ee6cc6cfe3863d0e683971b92512cfb64b816e24 +INFO = 434156536964fa87a7dda67d13f0aded76ef7a62bf5b9ffa25e024691a7e1f40a1b2c3d4e5902e4f6e3f344a95c3f8 +EXPECT = 51cad9a349609ad538704ab813d82401a23f2c1c7d429912 + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 0058d0c565a00f423efb4ccc321acddf7b2e24ba9e259c5ac43845e97b1117a8b89a30b02f9421e31c60ebeac22c6b42b95d4a56 +INFO = 434156536964f5c1165e63acf905b51ac0bcaf116b51737b49a3f6cb1063b1e3a1b2c3d4e5e150d4c3b125bf032b47 +EXPECT = 7abf9a0654a90c18b0d423bb20c3c4d6374c8dfd06446848 + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 005f8c03ac2d9313e2cc5b30dcc9133cbf8c53671af5e80032bb36b9279cc41c8742f859b3c64097ef1ba62a1c4b6d02d9ec1a6e +INFO = 4341565369641253e69cd9f2692f10c4d09c1be8d1967445c4e4596ffa61c2cea1b2c3d4e5f776d55088934bc8d5d2 +EXPECT = 00059c8673b4d3e269147e91591385d5636e793cc36690ae + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 81f3d2ad1f70fd67a374547d59506a04d545f4e869f00fa0 +INFO = 434156536964e63969525e54d806789d7121a1b2c3d4e581597a0e979d5c99a79b1789b41ae57fef5b916f85a1e449 +EXPECT = 94a283be5d007b1729f8a7ed1a9bf0361435131c4477e750959bd64426c1fa16df07f848e1ba90d8d3196424de928cdb8a5eda08ef03a5ca907b07faa0d4ac096a9dc7c5fa1f931336f864fdd9038b2dda14ca933c722657c90dd1c82c3a99af48fdb599a975498f023424c5a6cfe010dd800e42c55de57a5d75a6cd54e299b9 + +HASH = SHA-384 +VARIANT = DIGEST +SECRET = 81f3d2ad1f70fd67a374547d59506a04d545f4e869f00fa0 +INFO = 434156536964e63969525e54d806789d7121a1b2c3d4e581597a0e979d5c99a79b1789b41ae57fef5b916f85a1e449 +EXPECT = 98989fa5f8de3098dfa089a454c24586f75f5bdc1e860d6088f42d9cc129bb462ae243b7922a6c276891bee5ca79b0744b7ef4cb419db1e4ab80d67c873cb62912cb6cef80f17198e02ff590af59faf17e3128b80879606fa346f14930597005d2be607b08b4361a403a28f18f5bc485a8c53921fbe8adcb35e64d4dc9227a5e + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 81f3d2ad1f70fd67a374547d59506a04d545f4e869f00fa0 +INFO = 434156536964e63969525e54d806789d7121a1b2c3d4e581597a0e979d5c99a79b1789b41ae57fef5b916f85a1e449 +EXPECT = 8501c55696448de9e6b452cd56b022cba6826e8d4fd3d1f75346ef4698169b2642ffedad53e948ab42b923f54083244879b735e5e478139cb500fa7972d79f6c4cfdbc243f34b37bede60315c7e92500fee77cdd1c6eff97ff6a181d39dfe01350ad1702eb37441256bca3d0ddeb6043daebafc821afa2bae9a5457515ddee56 + +# Tests that follow were sourced from https://github.com/patrickfav/singlestep-kdf + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 4d7920736563726574 +INFO = 00000000000000000000000000000000 +EXPECT = 5f225b4801843ed861b95f5b0a3afd78473498f0b5cb6d7769e67458e057da8c0311 + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 616e6f74686572206f6e65 +INFO = 9014bf55dc1e03babb5ca1c1323a1e5b +EXPECT = 4f0a3cf7d52987ccd470d4a8f9d41da9bc6dcf4945c1e522c04fd0c070c397ddb7f4 + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 65306334326336353234373139 +INFO = dbebe4f7dde938229f26651e011f7bbd +EXPECT = d9151c3f36f6980951d84cca75ade71b + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = cf80cf80cf80cf80cf80cf80cf80cf80 +INFO = 676c65eb966200b04a2bb870d7ed20ce +EXPECT = c5bb681f1a04713ee7be14e0190676773b0ff63561892fac030b18cca38955369cfc32cdd956ef6e2e4301deb61d049a4d82e57a434168bc5ae084e0df15c0a0d8232d7a791088446b66e612753d36649e70a234a360b611baa07e4a6a7c660db2a1b56acba42d6d3d83b3ce51c787c544bb14b1c94b780fab5c0f966efd80f4a71cd4f267f816a3bb1ec8ceddcd810d1665742c8f68767cd9d7f87ad97792edc6896b6518 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 4d7920736563726574 +INFO = 00000000000000000000000000000000 +EXPECT = eba887dca269a550a3882f06f3b1c30058751bc4ec5375e5435e525aeca9782e6311 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 616e6f74686572206f6e65 +INFO = 9014bf55dc1e03babb5ca1c1323a1e5b +SALT = ebf4c1e001f26879afc76c7a45ac9541 +EXPECT = 8a6484427e5231642a83e7a01fd410040dda5bf3b3d34ec626a8603ac1a5e2e38f02 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 65306334326336353234373139 +INFO = dbebe4f7dde938229f26651e011f7bbd +EXPECT = cceb4536d8431c4d91a5c6f061955aac + +HASH = SHA-256 +VARIANT = HMAC +SECRET = cf80cf80cf80cf80cf80cf80cf80cf80 +INFO = 676c65eb966200b04a2bb870d7ed20ce +SALT = 1aab1829c8b7ed941b3dc8359dd1f402 +EXPECT = 2933b1a656efd556c421533e4fab685c4a9c32f15099a357a73a59c6acebb01b9685631d6208992413c2397c58e8020e588cc16f1f1b470a411ab65d6a0503e3728be789e54e313d49bd1edd606757db6c605ed1e346dd6841afd895379ba09dde046a19dce0a8d49b3ed5671d448e141da5f6bcf3aa5313affd8a14784c424b6d5087aa038ab13db398abbd50dfd39d1134dbe88e308373861d7acf1d79b740f717193d5b + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 4d7920736563726574 +INFO = 00000000000000000000000000000000 +EXPECT = 8930b01ea45ed7c97c31b5d98a84c48c198c3e5db28241ba9c8417ff1986b53bb4f0 + +# Test Vector from https://github.com/openssl/openssl/blob/9fcf57b45985336b04579dd317d0dc990a9c062b/test/evp_kdf_test.c#L901 +HASH = SHA-224 +VARIANT = DIGEST +SECRET = 6dbdc23f045488e4062757b06b9ebae183fc5a5946d80db93fec6f62ec07e3727f0126aed12ce4b262f47d48d54287f81d474c7c3b1850e9 +INFO = a1b2c3d4e54341565369643c832e9849dcdba71e9a3139e606e095de3c264a66e98a165854cd07989b1ee0ec3f8dbe +EXPECT = a462de16a89de8466ef5460b47b8 + +# Translated Vectors below from https://github.com/openssl/openssl/blob/9fcf57b45985336b04579dd317d0dc990a9c062b/test/recipes/30-test_evp_data/evpkdf_ss.txt +HASH = SHA-256 +VARIANT = DIGEST +SECRET = afc4e154498d4770aa8365f6903dc83b +INFO = 662af20379b29d5ef813e655 +EXPECT = f0b80d6ae4c1e19e2105a37024e35dc6 + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 108cf63318555c787fa578731dd4f037 +INFO = 53191b1dd3f94d83084d61d6 +EXPECT = 0ad475c1826da3007637970c8b92b993 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 6ee6c00d70a6cd14bd5a4e8fcfec8386 +SALT = 532f5131e0a2fecc722f87e5aa2062cb +INFO = 861aa2886798231259bd0314 +EXPECT = 13479e9a91dd20fdd757d68ffe8869fb + +HASH = SHA-256 +VARIANT = HMAC +SECRET = cb09b565de1ac27a50289b3704b93afd +SALT = d504c1c41a499481ce88695d18ae2e8f +INFO = 5ed3768c2c7835943a789324 +EXPECT = f081c0255b0cae16edc6ce1d6c9d12bc + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 98f50345fd970639a1b7935f501e1d7c +SALT = 3691939461247e9f74382ae4ef629b17 +INFO = 6ddbdb1314663152c3ccc192 +EXPECT = 56f42183ed3e287298dbbecf143f51ac + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a72b0076221727eca4d3ef8f4d88ac96 +SALT = 397dc6807de2c1d5ba52e03c4e6c7a19 +INFO = 12379bd7873a7dbabe894ac8 +EXPECT = 26c0f937e8ca337a859b6c092fe22b9a + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0b09bf8ebe1e85a049174c521e35be64 +SALT = 313d29bbeaa5ac9e52278f7619d29d93 +INFO = e2ac98de1486959bfc6363c0 +EXPECT = 4bfdf78782a45e2a5858edb851c5783c + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e907ad4fe811ee047af77e0c4418226a +SALT = 5000ef57104ca2e86a5fec5883ea4ea8 +INFO = c4ee443920f2b7542eee2a24 +EXPECT = 06bfbd9571462c920a5a1b589c765383 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 608dae15fe8b906d2dc649815bdee148 +SALT = 742cc5a02a24d09c66fd9da0d0c571f6 +INFO = ba60ff781e2756cba07f6524 +EXPECT = 7f7f9e5d8f89a8edd10289f1d690f629 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = eb39e8dc7c40b906216108e2592bb6cd +SALT = af9f612da575c1afc8c4afff4ced34e1 +INFO = 84b7f0628df0cb22baaa279a +EXPECT = 5202576c69c6276daedf4916de250d19 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 4bac0c1a963b8cf6933beb2ad191a31e +SALT = debd24d71a1a7ae77f7e3aa24d939635 +INFO = 9e51c8593cec92c89e82439a +EXPECT = ecb9889f9004f80716b56c44910f160c + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 8aa41e3c8076ea01ca6789dd18709a68 +SALT = 7c9dacc409cde7b05efdae07bd9973db +INFO = 52651f0f2e858bbfbacb2533 +EXPECT = b8683c9a982e0826d659a1ab77a603d7 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d3 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d8 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d89102 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be0 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f2 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c504 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a1 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca6 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd99 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995de + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c710 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca9091 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab6 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe19 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c95 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d4 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d45849 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 02b40d33e3f685aeae677ac344eeaf77 +SALT = 0ad52c9357c85e4781296a36ca72039c +INFO = c67c389580128f18f6cf8592 +EXPECT = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d45849133d + +HASH = SHA-256 +VARIANT = HMAC +SECRET = f4e1 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = 3f661ec46fcc1e110b88f33ee7dbc308 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 253554e5 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = 73ccb357554ca44967d507518262e38d + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e10d0e0bc95b +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = c4f1cf190980b6777bb35107654b25f9 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 451f7f2c23c51326 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = ddb2d7475d00cc65bff6904b4f0b54ba + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0f27277ee800d6cc5425 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = 1100a6049ae9d8be01ab3829754cecc2 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 20438ff1f26390dbc3a1a6d0 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = 5180382f740444ada597197f98e73e1e + +HASH = SHA-256 +VARIANT = HMAC +SECRET = b74a149a161546f8c20b06ac4ed4 +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = 44f676e85c1b1a8bbc3d319218631ca3 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 8aa7df46b8cb3fe47228494f4e116b2c +SALT = 3638271ccd68a25dc24ecddd39ef3f89 +INFO = 348a37a27ef1282f5f020dcc +EXPECT = ebb24413855a0a3249960d0de0f4750d + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = d851 +EXPECT = 5dbe10ead8f81a81a29072eca4501658 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = b04da03c +EXPECT = 0a08d7616dcbec25a36f1936b82992ca + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = f9e8b47eade3 +EXPECT = 84a29697445179b662d85dbc59bf8042 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = 5b141bfa54fcf824 +EXPECT = be7660c840644cec84d67d95ba7ebf2d + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = 736e7ddb856f0ba14744 +EXPECT = e3010b1fbcb02fd8baa8449ac71d0c62 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = c54320ff6e7d1a3b0b3aea00 +EXPECT = df0ac84982999cda676e4cbf707c42f0 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = 37ab143e1b4ab61d0294ea8afbc7 +EXPECT = 93eec7f4dda18b7e710dbbd7570ebd13 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a678236b6ac82077b23f73a510c1d0e2 +SALT = 46ee4f36a4167a09cde5a33b130c6e1c +INFO = c3146575d2c60981511e700902fc2ac1 +EXPECT = e9125f77d699faa53d5bc48f3fc2f7d0 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = 1ae1 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = ddf7eedcd997eca3943d4519aaf414f4 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = 3bda13b6 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = ec783ca20501df3cacac5ab4adbc6427 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = c792f52e5876 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = 9303a2562e6f8c418e3fcc081b94bdcf + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = a9b7a64840d52633 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = aab6b0dc19bae0dd7fa02391ac3d6ef1 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = 8f62a3ec15cdf9b3522f +INFO = 97ed3540c7466ab27395fe79 +EXPECT = 1516d5ed7f46474d250408b0864647cf + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = 55ed67cbdc98ed8e45214704 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = 38bf96a3d737a84dc10a835d340b6866 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = e4946aff3b2ab891b311234c77bc +INFO = 97ed3540c7466ab27395fe79 +EXPECT = 3ddd870471ff028a63c5f1bacc7e5b5c + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0031558fddb96e3db2e0496026302055 +SALT = 91e8378de5348cea41f84c41e8546e34 +INFO = 97ed3540c7466ab27395fe79 +EXPECT = bf1eb0eab488b2393ad6a1c2eb804381 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 4ce16564db9615f75d46c6a9837af7ca +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = 0a102289b16cbf4b + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 2578fe1116e27e3a5e8e935e892e12eb +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = dd5773998893ad5a93f9819c8e798aab + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e9dd8bd75f29661e61703346bbf2df47 +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = 32136643daa64aaac0e2886364f157ba923d7b36ada761eb + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e4640d3752cf48186a8ad2d7d4a81210 +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = 6379d59efbe02576663af5efaccb9d063f596a22c8e1fed12cde7cdd7f327e88 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 3bd9a074a219d62273c3f639659a3ecd +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = cc45eb2ab80272c1e082b4f167ee4e086f12af3fbd0c812dda5568fea702928999cde3899cffc8a8 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 2147c0fb1c7587b22fa44ce3bf3d8f5b +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = 4e3a8827fcdb214686b35bfcc497ca69dccb78d3464aa4af0704ec0fba03c7bb10b9a4e31e27b1b2379a32e46935309c + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 2c2438b6321fed7a9eac200b91b3ac30 +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = b402fda16e1c2719263be82158972c9080a7bafcbe0a3a6ede3504a3d5c8c0c0e00fe7e5f6bb3afdfa4d661b8fbe4bd7b950cfe0b2443bbd + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 0ffa4c40a822f6e3d86053aefe738eac +SALT = 6199187690823def2037e0632577c6b1 +EXPECT = 0486d589aa71a603c09120fb76eeab3293eee2dc36a91b23eb954d6703ade8a7b660d920c5a6f7bf3898d0e81fbad3a680b74b33680e0cc6a16aa616d078b256 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a801d997ed539ae9aa05d17871eb7fab +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 1a5efa3aca87c1f4 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e9624e112f9e90e7bf8a749cf37d920c +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = ee93ca3986cc43516ae4e29fd7a90ef1 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = a92acdee54a84a4564d4782d47801ec0 +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 3116b87eaffaa0cc48a72e6c1574df335d706f7c860b44e9 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = e60d902e63b1a2bf5dab733cadb47b10 +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 3fde6c078dd6dc65aacf62beafa39398d2b3d7cfb4b0ee4807bfc98a15330eef + +HASH = SHA-256 +VARIANT = HMAC +SECRET = d3b747a1d1584a0fc5aefcd4dd8ef9c3 +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 2c4363597d42f9f8736e8050b4a6dd033d7ddac6f7211c4810ef74aff01f101d885767d7ae6f1d7f + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 119559a2c0a8888e9c95b9989a460d97 +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 97922585f69adf484930cf22b8378c797694438502fa47e2f19f0fee97ca11451f3bc81a20c1d74964c63ab2d5df1985 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = 807f375266988df5d0ae878efac424fa +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = ba78ef8ab720fc583bb64581917634fca230876cc344e46b44fe61f3bdab556ee753743b78db4b16c0fcd8f987aebad15d0b7b13a10f6819 + +HASH = SHA-256 +VARIANT = HMAC +SECRET = f7906f870b256753b5bc3ef408e47e9b +INFO = 03697296e42a6fdbdb24b3ec +EXPECT = 96bee2ae234f98c285aa970bd54c2e2891febf734bad58a91dc7a97490b6b05fe539f2156ae3acd2e661eced0d59084fda340cd1ba3daa7ca2a550d7b1c19462 + +HASH = SHA-512 +VARIANT = HMAC +SECRET = 73b6e2ede34aae5680e2289e611ffc3a +SALT = 28df8439747d5a9b502e0838ca6999b2 +INFO = 232941631fc04dd82f727a51 +EXPECT = b0d36cd7d6b23b48ca6f89901bb784ec + +HASH = SHA-512 +VARIANT = HMAC +SECRET = abb7d7554c0de41cada5826a1f79d76f +INFO = a80b9061879365b1669c87a8 +EXPECT = 71e29fff69198eca92f5180bcb281fbdaf409ec7c99ca704b1f56e782d3c4db10cb4158e6634d793a46c13bffb6bdb71a01101936ea9b20f7dbe302558b1356c + +HASH = SHA-256 +VARIANT = DIGEST +SECRET = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +INFO = 307e300a06082b06010502030602a01f041d301ba0071b0553552e5345a110300ea003020101a10730051b036c6861a12904273025a0071b0553552e5345a11a3018a003020101a111300f1b066b72627467741b0553552e5345a22404223020a003020112a10c040aaaaaaaaaaaaaaaaaaaaaa20b0409bbbbbbbbbbbbbbbbbb +EXPECT = 77ef4e48c420ae3fec75109d7981697eed5d295c90c62564f7bfd101fa9bc1d5 + +HASH = SHA-512 +VARIANT = DIGEST +SECRET = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +INFO = 307e300a06082b06010502030603a01f041d301ba0071b0553552e5345a110300ea003020101a10730051b036c6861a12904273025a0071b0553552e5345a11a3018a003020101a111300f1b066b72627467741b0553552e5345a22404223020a003020110a10c040aaaaaaaaaaaaaaaaaaaaaa20b0409bbbbbbbbbbbbbbbbbb +EXPECT = d3c78b78d75313e9a926f75dfb012363fa17fa01db diff --git a/aws-lc-rs/tests/kdf_test.rs b/aws-lc-rs/tests/kdf_test.rs new file mode 100644 index 00000000000..1b32f1e99a6 --- /dev/null +++ b/aws-lc-rs/tests/kdf_test.rs @@ -0,0 +1,166 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR ISC + +#![cfg(all(feature = "unstable", not(feature = "fips")))] + +use std::error::Error; + +use aws_lc_rs::{ + test, test_file, + unstable::kdf::{ + get_kbkdf_ctr_hmac_algorithm, get_sskdf_digest_algorithm, get_sskdf_hmac_algorithm, + kbkdf_ctr_hmac, sskdf_digest, sskdf_hmac, KbkdfCtrHmacAlgorithm, KbkdfCtrHmacAlgorithmId, + SskdfDigestAlgorithm, SskdfDigestAlgorithmId, SskdfHmacAlgorithm, SskdfHmacAlgorithmId, + }, +}; + +#[derive(Clone, Copy)] +enum SskdfVariant { + Digest, + Hmac, +} + +impl TryFrom for SskdfVariant { + type Error = Box; + + fn try_from(value: String) -> Result { + match value.as_str() { + "DIGEST" => Ok(SskdfVariant::Digest), + "HMAC" => Ok(SskdfVariant::Hmac), + _ => Err(format!("unsupported sskdf variant: {value:?}").into()), + } + } +} + +#[derive(Clone, Copy)] +enum Hash { + Sha224, + Sha256, + Sha384, + Sha512, +} + +impl TryFrom for Hash { + type Error = Box; + + fn try_from(value: String) -> Result { + match value.as_str() { + "SHA-224" => Ok(Hash::Sha224), + "SHA-256" => Ok(Hash::Sha256), + "SHA-384" => Ok(Hash::Sha384), + "SHA-512" => Ok(Hash::Sha512), + _ => Err(format!("unsupported hash: {value:?}").into()), + } + } +} + +impl From for &'static SskdfHmacAlgorithm { + fn from(value: Hash) -> Self { + get_sskdf_hmac_algorithm(match value { + Hash::Sha224 => SskdfHmacAlgorithmId::Sha224, + Hash::Sha256 => SskdfHmacAlgorithmId::Sha256, + Hash::Sha384 => SskdfHmacAlgorithmId::Sha384, + Hash::Sha512 => SskdfHmacAlgorithmId::Sha512, + }) + .expect("hash supported") + } +} + +impl From for &'static SskdfDigestAlgorithm { + fn from(value: Hash) -> Self { + get_sskdf_digest_algorithm(match value { + Hash::Sha224 => SskdfDigestAlgorithmId::Sha224, + Hash::Sha256 => SskdfDigestAlgorithmId::Sha256, + Hash::Sha384 => SskdfDigestAlgorithmId::Sha384, + Hash::Sha512 => SskdfDigestAlgorithmId::Sha512, + }) + .expect("hash supported") + } +} + +impl From for &'static KbkdfCtrHmacAlgorithm { + fn from(value: Hash) -> Self { + get_kbkdf_ctr_hmac_algorithm(match value { + Hash::Sha224 => KbkdfCtrHmacAlgorithmId::Sha224, + Hash::Sha256 => KbkdfCtrHmacAlgorithmId::Sha256, + Hash::Sha384 => KbkdfCtrHmacAlgorithmId::Sha384, + Hash::Sha512 => KbkdfCtrHmacAlgorithmId::Sha512, + }) + .expect("hash supported") + } +} + +#[test] +fn sskdf() { + test::run(test_file!("data/sskdf.txt"), |_section, tc| { + const EMPTY_SLICE: &[u8] = &[]; + + let hash: Hash = tc.consume_string("HASH").try_into().unwrap(); + let variant: SskdfVariant = tc.consume_string("VARIANT").try_into().unwrap(); + + let secret = tc.consume_bytes("SECRET"); + let info = tc.consume_optional_bytes("INFO"); + let salt = tc.consume_optional_bytes("SALT"); + let expect = tc.consume_bytes("EXPECT"); + + let info = if let Some(v) = &info { + v.as_slice() + } else { + EMPTY_SLICE + }; + + let salt = if let Some(v) = &salt { + v.as_slice() + } else { + EMPTY_SLICE + }; + + match variant { + SskdfVariant::Digest => { + assert_sskdf_digest(hash.into(), &secret, info, &expect); + } + SskdfVariant::Hmac => assert_sskdf_hmac(hash.into(), &secret, info, salt, &expect), + } + + Ok(()) + }); +} + +fn assert_sskdf_digest( + algorithm: &'static SskdfDigestAlgorithm, + secret: &[u8], + info: &[u8], + expect: &[u8], +) { + let mut output = vec![0u8; expect.len()]; + sskdf_digest(algorithm, secret, info, output.as_mut_slice()).unwrap(); + assert_eq!(expect, output.as_slice()); +} + +fn assert_sskdf_hmac( + algorithm: &'static SskdfHmacAlgorithm, + secret: &[u8], + info: &[u8], + salt: &[u8], + expect: &[u8], +) { + let mut output = vec![0u8; expect.len()]; + sskdf_hmac(algorithm, secret, info, salt, output.as_mut_slice()).unwrap(); + assert_eq!(expect, output.as_slice()); +} + +#[test] +fn hkdf_ctr_hmac() { + test::run(test_file!("data/kbkdf_counter.txt"), |_section, tc| { + let hash: Hash = tc.consume_string("HASH").try_into().unwrap(); + let secret = tc.consume_bytes("SECRET"); + let info = tc.consume_bytes("INFO"); + let expect = tc.consume_bytes("EXPECT"); + + let mut output = vec![0u8; expect.len()]; + kbkdf_ctr_hmac(hash.into(), &secret, &info, output.as_mut_slice()).unwrap(); + assert_eq!(expect, output.as_slice()); + + Ok(()) + }); +}