From 2fac7447e02aa0f532ebcacbfffc71565b691aea Mon Sep 17 00:00:00 2001 From: Jack O'Connor Date: Fri, 27 Dec 2019 16:20:38 -0600 Subject: [PATCH] make derive_key take a key of any length The previous version of this API called for a key of exactly 256 bits. That's good for optimal performance, but it would mean losing the use-with-other-algorithms property for applications whose input keys are a different size. There's no way for an abstraction over the previous version to provide reliable domain separation for the "extract" step. --- b3sum/src/main.rs | 9 ++-- b3sum/tests/test.rs | 11 ++--- reference_impl/reference_impl.rs | 18 +++++--- src/lib.rs | 72 +++++++++++++++++--------------- src/test.rs | 20 +++++---- test_vectors/src/lib.rs | 40 ++++++++++++------ test_vectors/test_vectors.json | 44 +++++++++---------- 7 files changed, 123 insertions(+), 91 deletions(-) diff --git a/b3sum/src/main.rs b/b3sum/src/main.rs index e2e430071..3fc074c25 100644 --- a/b3sum/src/main.rs +++ b/b3sum/src/main.rs @@ -34,8 +34,9 @@ fn clap_parse_argv() -> clap::ArgMatches<'static> { Arg::with_name(DERIVE_KEY_ARG) .long(DERIVE_KEY_ARG) .conflicts_with(KEYED_ARG) - .requires(FILE_ARG) - .help("Uses the KDF mode, with the 32-byte key read from stdin"), + .takes_value(true) + .value_name("CONTEXT") + .help("Uses the key derivation mode, with the input as key material"), ) .arg( Arg::with_name(NO_NAMES_ARG) @@ -160,8 +161,8 @@ fn main() -> Result<()> { .context("Failed to parse length.")?; let base_hasher = if args.is_present(KEYED_ARG) { blake3::Hasher::new_keyed(&read_key_from_stdin()?) - } else if args.is_present(DERIVE_KEY_ARG) { - blake3::Hasher::new_derive_key(&read_key_from_stdin()?) + } else if let Some(context) = args.value_of(DERIVE_KEY_ARG) { + blake3::Hasher::new_derive_key(context) } else { blake3::Hasher::new() }; diff --git a/b3sum/tests/test.rs b/b3sum/tests/test.rs index a74a1f13d..8f2e623ea 100644 --- a/b3sum/tests/test.rs +++ b/b3sum/tests/test.rs @@ -72,13 +72,14 @@ fn test_keyed() { #[test] fn test_derive_key() { - let key = [99; blake3::KEY_LEN]; + let context = "BLAKE3 2019-12-28 10:28:41 example context"; let f = tempfile::NamedTempFile::new().unwrap(); - f.as_file().write_all(b"context").unwrap(); + f.as_file().write_all(b"key material").unwrap(); f.as_file().flush().unwrap(); - let expected = hex::encode(blake3::derive_key(&key, b"context")); - let output = cmd!(b3sum_exe(), "--derive-key", "--no-names", f.path()) - .stdin_bytes(&key[..]) + let mut derive_key_out = [0; blake3::OUT_LEN]; + blake3::derive_key(context, b"key material", &mut derive_key_out); + let expected = hex::encode(&derive_key_out); + let output = cmd!(b3sum_exe(), "--derive-key", context, "--no-names", f.path()) .read() .unwrap(); assert_eq!(&*expected, &*output); diff --git a/reference_impl/reference_impl.rs b/reference_impl/reference_impl.rs index bb8b51146..d97256e0f 100644 --- a/reference_impl/reference_impl.rs +++ b/reference_impl/reference_impl.rs @@ -12,7 +12,8 @@ const CHUNK_END: u32 = 1 << 1; const PARENT: u32 = 1 << 2; const ROOT: u32 = 1 << 3; const KEYED_HASH: u32 = 1 << 4; -const DERIVE_KEY: u32 = 1 << 5; +const DERIVE_KEY_CONTEXT: u32 = 1 << 5; +const DERIVE_KEY_MATERIAL: u32 = 1 << 6; const IV: [u32; 8] = [ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19, @@ -272,11 +273,16 @@ impl Hasher { Self::new_internal(key_words, KEYED_HASH) } - /// Construct a new `Hasher` for the key derivation function. - pub fn new_derive_key(key: &[u8; KEY_LEN]) -> Self { - let mut key_words = [0; 8]; - words_from_litte_endian_bytes(key, &mut key_words); - Self::new_internal(key_words, DERIVE_KEY) + /// Construct a new `Hasher` for the key derivation function. The context + /// string should be hardcoded, globally unique, and application-specific. + pub fn new_derive_key(context: &str) -> Self { + let mut context_hasher = Hasher::new_internal(IV, DERIVE_KEY_CONTEXT); + context_hasher.update(context.as_bytes()); + let mut context_key = [0; KEY_LEN]; + context_hasher.finalize(&mut context_key); + let mut context_key_words = [0; 8]; + words_from_litte_endian_bytes(&context_key, &mut context_key_words); + Self::new_internal(context_key_words, DERIVE_KEY_MATERIAL) } fn push_stack(&mut self, cv: [u32; 8]) { diff --git a/src/lib.rs b/src/lib.rs index ddffeacfc..e19fbc319 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -105,7 +105,8 @@ const CHUNK_END: u8 = 1 << 1; const PARENT: u8 = 1 << 2; const ROOT: u8 = 1 << 3; const KEYED_HASH: u8 = 1 << 4; -const DERIVE_KEY: u8 = 1 << 5; +const DERIVE_KEY_CONTEXT: u8 = 1 << 5; +const DERIVE_KEY_MATERIAL: u8 = 1 << 6; fn counter_low(counter: u64) -> u32 { counter as u32 @@ -663,29 +664,32 @@ pub fn keyed_hash(key: &[u8; KEY_LEN], input: &[u8]) -> Hash { /// The key derivation function. /// -/// Given a 32-byte (256-bit) cryptographic key and a context string, this -/// function returns a 32-byte derived subkey. Key derivation is important when -/// you want to use the same key in multiple algorithms or use cases. Deriving -/// a separate subkey for each use case protects you from bad interactions -/// between algorithms. (For example, one algorithm might publish some value -/// that another algorithm considers secret.) Derived keys also mitigate the -/// damage from one part of your application accidentally leaking its key. +/// Given cryptographic key material of any length and a context string of any +/// length, this function outputs a derived subkey of any length. **The context +/// string should be hardcoded, globally unique, and application-specific.** A +/// good default format for such strings is `"[application] [commit timestamp] +/// [purpose]"`, e.g., `"example.com 2019-12-25 16:18:03 session tokens v1"`. /// -/// The context string should be globally unique, application-specific, and -/// hardcoded. A good default format for such strings is `"[application] -/// [commit timestamp] [purpose]"`, e.g., `"example.com 2019-12-25 16:18:03 -/// session tokens v1"`. +/// Key derivation is important when you want to use the same key in multiple +/// algorithms or use cases. Using the same key with different cryptographic +/// algorithms is generally forbidden, and deriving a separate subkey for each +/// use case protects you from bad interactions. Derived keys also mitigate the +/// damage from one part of your application accidentally leaking its key. /// -/// If your input key is some size other than 32 bytes, you can convert it to -/// 32 bytes using [`hash`]. This is similar to the "extract" stage in the -/// "extract-then-expand" paradigm of HKDF. +/// As a rare exception to that general rule, however, it is possible to use +/// `derive_key` with key material that you are already using with another +/// algorithm. You might need to do this if you're adding features to an +/// existing application, which does not yet use key derivation internally. +/// However, you still must not share key material with algorithms that forbid +/// key reuse entirely, like a one-time pad. /// -/// [`hash`]: fn.hash.html -pub fn derive_key(key: &[u8; KEY_LEN], context: &[u8]) -> [u8; OUT_LEN] { - let key_words = platform::words_from_le_bytes_32(key); - hash_all_at_once(context, &key_words, DERIVE_KEY) - .root_hash() - .into() +/// [`Hasher::new_derive_key`]: struct.Hasher.html#method.new_derive_key +/// [`Hasher::finalize_xof`]: struct.Hasher.html#method.finalize_xof +pub fn derive_key(context: &str, key_material: &[u8], output: &mut [u8]) { + let context_key = hash_all_at_once(context.as_bytes(), IV, DERIVE_KEY_CONTEXT).root_hash(); + let context_key_words = platform::words_from_le_bytes_32(context_key.as_bytes()); + let inner_output = hash_all_at_once(key_material, &context_key_words, DERIVE_KEY_MATERIAL); + OutputReader::new(inner_output).fill(output); } fn parent_node_output( @@ -741,16 +745,14 @@ impl Hasher { } /// Construct a new `Hasher` for the key derivation function. See - /// [`derive_key`]. - /// - /// Note that the input to [`derive_key`] should be a hardcoded context - /// string. Most callers that don't need extended output should prefer the - /// standalone function for that reason. + /// [`derive_key`]. The context string should be hardcoded, globally + /// unique, and application-specific. /// /// [`derive_key`]: fn.derive_key.html - pub fn new_derive_key(key: &[u8; KEY_LEN]) -> Self { - let key_words = platform::words_from_le_bytes_32(key); - Self::new_internal(&key_words, DERIVE_KEY) + pub fn new_derive_key(context: &str) -> Self { + let context_key = hash_all_at_once(context.as_bytes(), IV, DERIVE_KEY_CONTEXT).root_hash(); + let context_key_words = platform::words_from_le_bytes_32(context_key.as_bytes()); + Self::new_internal(&context_key_words, DERIVE_KEY_MATERIAL) } // See comment in push_cv. @@ -990,10 +992,7 @@ impl Hasher { /// /// [`OutputReader`]: struct.OutputReader.html pub fn finalize_xof(&self) -> OutputReader { - OutputReader { - inner: self.final_output(), - position_within_block: 0, - } + OutputReader::new(self.final_output()) } } @@ -1030,6 +1029,13 @@ pub struct OutputReader { } impl OutputReader { + fn new(inner: Output) -> Self { + Self { + inner, + position_within_block: 0, + } + } + /// Fill a buffer with output bytes and advance the position of the /// `OutputReader`. This is equivalent to [`Read::read`], except that it /// doesn't return a `Result`. Both methods always fill the entire buffer. diff --git a/src/test.rs b/src/test.rs index af0bd1c0a..0ac6cb6b5 100644 --- a/src/test.rs +++ b/src/test.rs @@ -115,7 +115,7 @@ pub fn test_hash_many_fn( &TEST_KEY_WORDS, counter, IncrementCounter::Yes, - crate::DERIVE_KEY, + crate::KEYED_HASH, crate::CHUNK_START, crate::CHUNK_END, &mut portable_chunks_out, @@ -128,7 +128,7 @@ pub fn test_hash_many_fn( &TEST_KEY_WORDS, counter, IncrementCounter::Yes, - crate::DERIVE_KEY, + crate::KEYED_HASH, crate::CHUNK_START, crate::CHUNK_END, &mut test_chunks_out, @@ -154,7 +154,7 @@ pub fn test_hash_many_fn( &TEST_KEY_WORDS, 0, IncrementCounter::No, - crate::DERIVE_KEY | crate::PARENT, + crate::KEYED_HASH | crate::PARENT, 0, 0, &mut portable_parents_out, @@ -167,7 +167,7 @@ pub fn test_hash_many_fn( &TEST_KEY_WORDS, 0, IncrementCounter::No, - crate::DERIVE_KEY | crate::PARENT, + crate::KEYED_HASH | crate::PARENT, 0, 0, &mut test_parents_out, @@ -298,17 +298,19 @@ fn test_compare_reference_impl() { // derive_key { - let mut reference_hasher = reference_impl::Hasher::new_derive_key(&TEST_KEY); + let context = "BLAKE3 2019-12-27 16:13:59 example context"; + let mut reference_hasher = reference_impl::Hasher::new_derive_key(context); reference_hasher.update(input); let mut expected_out = [0; OUT]; reference_hasher.finalize(&mut expected_out); - let test_out = crate::derive_key(&TEST_KEY, input); - assert_eq!(&test_out, array_ref!(expected_out, 0, 32)); - let mut hasher = crate::Hasher::new_derive_key(&TEST_KEY); + let mut test_out = [0; OUT]; + crate::derive_key(context, input, &mut test_out); + assert_eq!(&test_out[..], &expected_out[..]); + let mut hasher = crate::Hasher::new_derive_key(context); hasher.update(input); assert_eq!(&hasher.finalize(), array_ref!(expected_out, 0, 32)); - assert_eq!(&hasher.finalize(), &test_out); + assert_eq!(&hasher.finalize(), array_ref!(test_out, 0, 32)); let mut extended = [0; OUT]; hasher.finalize_xof().fill(&mut extended); assert_eq!(&extended[..], &expected_out[..]); diff --git a/test_vectors/src/lib.rs b/test_vectors/src/lib.rs index 2c06477fd..77786b0da 100644 --- a/test_vectors/src/lib.rs +++ b/test_vectors/src/lib.rs @@ -29,7 +29,21 @@ pub const TEST_CASES: &[usize] = &[ 31 * CHUNK_LEN, // 16 + 8 + 4 + 2 + 1 ]; -pub const TEST_KEY: &[u8; blake3::KEY_LEN] = b"whats the Elvish word for friend"; +pub const TEST_CONTEXT: &str = "BLAKE3 2019-12-27 16:29:52 test vectors context"; + +const COMMENT: &str = r#" +Each test is an input length and three outputs, one for each of the hash, +keyed_hash, and derive_key modes. The input in each case is filled with a +251-byte-long repeating pattern: 0, 1, 2, ..., 249, 250, 0, 1, ... The key used +with keyed_hash is the 32-byte ASCII string given in the 'key' field below. For +derive_key, the test input is used as the input key, and the context string is +'BLAKE3 2019-12-27 16:29:52 example context'. (As good practice for following +the security requirements of derive_key, test runners should make that context +string a hardcoded constant, and we do not provided it in machine-readable +form.) Outputs are encoded as hexadecimal. Each case is an extended output, and +implementations should also check that the first 32 bytes match their +default-length output. +"#; // Paint the input with a repeating byte pattern. We use a cycle length of 251, // because that's the largets prime number less than 256. This makes it @@ -57,6 +71,8 @@ pub struct Case { } pub fn generate_json() -> String { + const TEST_KEY: &[u8; blake3::KEY_LEN] = b"whats the Elvish word for friend"; + let mut cases = Vec::new(); for &input_len in TEST_CASES { let mut input = vec![0; input_len]; @@ -75,7 +91,7 @@ pub fn generate_json() -> String { .fill(&mut keyed_hash_out); let mut derive_key_out = [0; OUTPUT_LEN]; - blake3::Hasher::new_derive_key(TEST_KEY) + blake3::Hasher::new_derive_key(TEST_CONTEXT) .update(&input) .finalize_xof() .fill(&mut derive_key_out); @@ -89,10 +105,11 @@ pub fn generate_json() -> String { } let mut json = serde_json::to_string_pretty(&Cases { - _comment: "Each test is an input length and three outputs, one for each of the hash, keyed_hash, and derive_key modes. The input in each case is filled with a 251-byte-long repeating pattern: 0, 1, 2, ..., 249, 250, 0, 1, ... The key used with keyed_hash and derive_key is the 32-byte ASCII string given below. Outputs are encoded as hexadecimal. Each case is an extended output, and implementations should also check that the first 32 bytes match their default-length output.".to_string(), + _comment: COMMENT.trim().replace("\n", " "), key: std::str::from_utf8(TEST_KEY).unwrap().to_string(), cases, - }).unwrap(); + }) + .unwrap(); // Add a trailing newline. json.push('\n'); @@ -134,7 +151,7 @@ mod tests { assert_eq!(expected_keyed_hash, &out[..]); let mut out = vec![0; expected_derive_key.len()]; - let mut hasher = reference_impl::Hasher::new_derive_key(key); + let mut hasher = reference_impl::Hasher::new_derive_key(TEST_CONTEXT); hasher.update(input); hasher.finalize(&mut out); assert_eq!(expected_derive_key, &out[..]); @@ -164,7 +181,7 @@ mod tests { assert_eq!(expected_keyed_hash, &out[..]); let mut out = vec![0; expected_derive_key.len()]; - let mut hasher = reference_impl::Hasher::new_derive_key(key); + let mut hasher = reference_impl::Hasher::new_derive_key(TEST_CONTEXT); for &b in input { hasher.update(&[b]); } @@ -194,7 +211,7 @@ mod tests { assert_eq!(&expected_keyed_hash[..32], hasher.finalize().as_bytes()); let mut out = vec![0; expected_derive_key.len()]; - let mut hasher = blake3::Hasher::new_derive_key(key); + let mut hasher = blake3::Hasher::new_derive_key(TEST_CONTEXT); hasher.update(input); hasher.finalize_xof().fill(&mut out); assert_eq!(expected_derive_key, &out[..]); @@ -227,7 +244,7 @@ mod tests { assert_eq!(&expected_keyed_hash[..32], hasher.finalize().as_bytes()); let mut out = vec![0; expected_derive_key.len()]; - let mut hasher = blake3::Hasher::new_derive_key(key); + let mut hasher = blake3::Hasher::new_derive_key(TEST_CONTEXT); for &b in input { hasher.update(&[b]); } @@ -248,10 +265,9 @@ mod tests { &expected_keyed_hash[..32], &blake3::keyed_hash(key, input).as_bytes()[..], ); - assert_eq!( - &expected_derive_key[..32], - &blake3::derive_key(key, input)[..], - ); + let mut derive_key_out = vec![0; expected_derive_key.len()]; + blake3::derive_key(TEST_CONTEXT, input, &mut derive_key_out); + assert_eq!(expected_derive_key, &derive_key_out[..],); } #[test] diff --git a/test_vectors/test_vectors.json b/test_vectors/test_vectors.json index d7ba4ecb4..4b6ce2dea 100644 --- a/test_vectors/test_vectors.json +++ b/test_vectors/test_vectors.json @@ -1,132 +1,132 @@ { - "_comment": "Each test is an input length and three outputs, one for each of the hash, keyed_hash, and derive_key modes. The input in each case is filled with a 251-byte-long repeating pattern: 0, 1, 2, ..., 249, 250, 0, 1, ... The key used with keyed_hash and derive_key is the 32-byte ASCII string given below. Outputs are encoded as hexadecimal. Each case is an extended output, and implementations should also check that the first 32 bytes match their default-length output.", + "_comment": "Each test is an input length and three outputs, one for each of the hash, keyed_hash, and derive_key modes. The input in each case is filled with a 251-byte-long repeating pattern: 0, 1, 2, ..., 249, 250, 0, 1, ... The key used with keyed_hash is the 32-byte ASCII string given in the 'key' field below. For derive_key, the test input is used as the input key, and the context string is 'BLAKE3 2019-12-27 16:29:52 example context'. (As good practice for following the security requirements of derive_key, test runners should make that context string a hardcoded constant, and we do not provided it in machine-readable form.) Outputs are encoded as hexadecimal. Each case is an extended output, and implementations should also check that the first 32 bytes match their default-length output.", "key": "whats the Elvish word for friend", "cases": [ { "input_len": 0, "hash": "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262e00f03e7b69af26b7faaf09fcd333050338ddfe085b8cc869ca98b206c08243a26f5487789e8f660afe6c99ef9e0c52b92e7393024a80459cf91f476f9ffdbda7001c22e159b402631f277ca96f2defdf1078282314e763699a31c5363165421cce14d", "keyed_hash": "92b2b75604ed3c761f9d6f62392c8a9227ad0ea3f09573e783f1498a4ed60d26b18171a2f22a4b94822c701f107153dba24918c4bae4d2945c20ece13387627d3b73cbf97b797d5e59948c7ef788f54372df45e45e4293c7dc18c1d41144a9758be58960856be1eabbe22c2653190de560ca3b2ac4aa692a9210694254c371e851bc8f", - "derive_key": "0f42e871bf9115e065cb0f67325b0ffad401cdf2f40b71148b98aae90a932e3f00ee95d66f5a73943a666f9a367b22ef258edd60fa146867e1ee2a449c9de4d7edae320241aaaed9b763df20298bfd6ffba6887917b5c0d0a155c4065160dba02f28edebb1dff1a7a36739204682c6df43ce0f3dd33c9d93dcc032ac8f48442992645b" + "derive_key": "38b6ca03a5d7cdce36340d871c2a75a9e5238fb5ffb50d38d004c8f57b024781a6bd4091d4c71c812d7a2cedce497fbb9b12e2295bdb4e4b718baf07628a905fef58abde0d134f7f246f33f38c79a00be2372648ad3e078a9b59571e24d4534df9b402f2290f3513d9c96e1ea5ce72dfe185de12e07480670c8b43bb557c7d92f6e660" }, { "input_len": 1, "hash": "2d3adedff11b61f14c886e35afa036736dcd87a74d27b5c1510225d0f592e213c3a6cb8bf623e20cdb535f8d1a5ffb86342d9c0b64aca3bce1d31f60adfa137b358ad4d79f97b47c3d5e79f179df87a3b9776ef8325f8329886ba42f07fb138bb502f4081cbcec3195c5871e6c23e2cc97d3c69a613eba131e5f1351f3f1da786545e5", "keyed_hash": "6d7878dfff2f485635d39013278ae14f1454b8c0a3a2d34bc1ab38228a80c95b6568c0490609413006fbd428eb3fd14e7756d90f73a4725fad147f7bf70fd61c4e0cf7074885e92b0e3f125978b4154986d4fb202a3f331a3fb6cf349a3a70e49990f98fe4289761c8602c4e6ab1138d31d3b62218078b2f3ba9a88e1d08d0dd4cea11", - "derive_key": "b6b2fdb9a45d8251f811db7af9478d4d886db22e6ea282b9c27a45f20107902a4ce1e4c58a35bf64eccd3f3d8421b101538a9ea2304ca8f4586e07c9704d683c8212a3281e68d01e8a2531412f3e42e29ff041d966d3c6426db9d87a983e0b1c2565b570b7413b8d09ebffd6bcf974d9a326ba55d3524659dcf782ebec11bfedba6486" + "derive_key": "d47b96d469adb5569625dc996601a81dbbcad83eefce2b6c072a8b6514a1932486fe8d78ea01159ebc047a83f06d2268919d782b6110bd62e14eeeacd83ae52904565c0a3abd426696f8ea8e0763eb5d2420a002da4333bd7a2d00224b31e0451101cd1baf02071162e925348fbdf863d738b9f3d1d7b26c7fb91ab4235cd5c3927a45" }, { "input_len": 1023, "hash": "9c93cdcb05286dc72e0c998c3055b0fa44cb2fa05a284bc597a4e216dfecf23b89e4ec3126046332385bc0f30bf83a80b37292c8376f6d2060a3ae721b96b22c71d4b3a1069e5e4aff53ba5c5c45bd8d007062bcc75084ec6befcb6e725c6d198652e6d97eaaa2b7c4c577ebf49a07c9b3b8d4d08a0f4038b7c4545936e95559916c5d", "keyed_hash": "682ff353dcb9322468d991f26d9268d3af0e82acf9b13b278e3f74393742e9ecd996c6e6d6f5a5e63b16ca6aec851ba9c9690115443109f8a6b131c518d657386a74d209756031884e716da99decd2c0d0defd35af60c3895f69cdee6e7d6ad1b26d8c7ec4ff1f3400834c52ade9678ca3d8317e3315daf79d85a64365211daf777e95", - "derive_key": "2256b460666a52b426cae83c406eb91e5569e8821d488e0e1c8ae639a6e95f334620d3f7da0371baaf1d427cdd445c331ba85f3f5cd818de819c63f7b9b762baca6695ff69ea817faa05bc1138b10cad75424a107e90c3589a02c36b24c5c0f5b42f6ee84f112dc053aa7e5dff7bd07c89dbd0b80f3affca80828aa3f2983f5dad65b8" + "derive_key": "0fa2580fa785d32e78cbdae63326618edc81774b888fd5d93702decc83fec2d8b5197e58ab83d81c202da40c9cc72eba2b44029429d773137aec50f8f10978685d2a9e6470844dcdac3fc20f178bf2375fbdbc0fb4dc6ecedee7671413236316976ffa26d10a584384bdab79ee0ad1b728c859673557c76a0d34248c3bd175249a41cf" }, { "input_len": 1024, "hash": "b4342a9e49dceeb14dee0dcaefe92ac2fdd0cc37d880df8dce450bdb2daed817b00342c7db27ffbcfcf46eaecab2a7460d60c6812437ce101286c51df816934b3fbe2d8ee6a6db61556552fdd0992b906fd3f91f5eefe39abbba06d6dc9f3a02c8e4f8805443344016de267647a2806890f17b43e80a11d9d8e41e505e7dc10da250af", "keyed_hash": "71c777f92b6609192ccacba3f3672a44659b472b08a9972dc3e1d01ab83c54a71f050eae60ca5a295e393eba6e4f0358b5a053c131f39a9ef496411ecdeab76e43b5003c3ac968c83b0a5e791cab5fb390c5fc83164c1b450c2ef250a57361f06b41d1501111fc5b01eb8fb9c5efc2371547f0dca60dd80e0f00b4f8687f0150c18cf0", - "derive_key": "763c5d853f488fada8ea4a3931f82584a9b90d90947d4cd6d288389b808d7d1f91e27a68e35502df3f4e56d4c4e018dfbc14225be81bdd4277804ade7e00fa3414091cb7a8f3c86b0016b493ca1ee7594c31c4be1cea149e800e2e8261495ba6b49612af5e5d9d444dba37d118dbf138e78621ca5d1d9c16015cb0b92b54d50766cdc7" + "derive_key": "63d82c2be58515ecdc23663f6351029cf63d3cbe447604d69eff2af20ad1aa1fc99fad1e371f00bcadfc50e93012c816227a411caa5fb857b935efd93adec613ee6f66cefc762b272653828b2f83ccfa186df7a0203ef3af9ccc6673c873534b160f4b1b60a373a095397def476596f12d751dffd77420e525e28863425608846257f1" }, { "input_len": 1025, "hash": "016ec9e10c1dbae0ba41f75462379b0f94719c544d024eb7bb5ce76d4bb522259e0df61c24ac2ca8092a1340b8c9ca0975d4d35205403ecacb62285b4b00f139e99dadf514d64b4165d0f3fc1c290763371d2d8cdf10123cde3a3f0b341094aa15b893f16a42ddb0eb4d4b32821aee0b52b9e70b721714f917cd47334d995aa1624bea", "keyed_hash": "a3c4908e3580319031ac309266f4fdfb37f157116b60df6b0006ab055cf2a0c6c16c51d4169d72d170610d3414bdbad9e94c18c79a47c6b4dfca10510c3216b6b554c3c6390fed862d20155db21863d21ac03965c698a4c5f91cc75ea289a912c65e57373fde28d84d60f778c7f834230bc3324be2d4f1a527f3793aff84fd764114c5", - "derive_key": "42f3adf310f965449ec13d7f1505c9dd4c7fd48cccd04eccb983785f0c9ecd7535cfaeacfaace1afaafb5b9037e44efac33b3f1203230590f28f7949b87638f7315d8082aa1115ec093e09941d7d0d7d94a03021f0bbcbf48f5f3bbb8151d92dcc77a7d0d0fc10652caa55bc54e7d83c372e9fc5b2c6b8b4decf88b492908834f743db" + "derive_key": "dab19462c9f5f8a2790a6297f518eb708528d2eb0bbddfeda5dcfb17b46144fa78649a6830cb67acb9bdabac5aba2815cb65682057a1d769d9aad682ac4d37d2fef6b83f6354942ade8b79125d1bec214519c2df9aaadb29aab1c8e7d12bb979ca454a8f828e6770c7432dd05ba273b74cf008e30c003b5747628e55fe9084b2f341a8" }, { "input_len": 2048, "hash": "c35f5b29380287b01c9b7c805a948a43e818aa409f2527601a9ce0ce9f10d50833964400fe36ac38994ea663326841a7f3fde074a19e355772776557e0e7e8a768d03c18c4f0704c49dd58a1de01cb202f228aff76c4bc29a0fb5528c67a84fb5dee5b599f5f84726e5892311009984d720413d91eabd66b3ef7aca60fccfbe22a6e7f", "keyed_hash": "1d527087c25ab15fd3f624036a39cb621b2383bd8dcb2597db4b23e5af39808119cf6005cfabb0625dc5247e69a0f8d703b564cd7952cce1a6e6eebebe056abfc045618db7f2c92a635cbe477dec98fc0816ec7d5a16f94cd6219cdcb3ebb3c7403500e089225f67d2281248bb6404f87b14112bcbd109f28ce42ab85bff8a68cab9bf", - "derive_key": "9b33156a08406f1bd1d1d6b3a02a979761b7b42554ca97ec7b9d8beebba91e16d80e5cedccc414047a317fa3c6e6d90915e155630caa4c4d0b75913732f23adbc629d25b4711a743690b43071c1610c90450368dec4c3c94806299d53c43e95933490f1fed26955570fd8cc37c9d120f82870e21387c6a7712ae32a24e475a61baa4a7" + "derive_key": "96d23334001e61d3902b20a703ea203fb6045e7f74b1d17a0de7500ff328d00a19ef432f4dfdfc979ecd2585beab6f7a70d769163ae3e6b21d11fe7b4072b1505711ba041b690278f4bf7f1cb95325b410a118948f89b6100cda455965ccedf9af7dc1bb2fa606107ebe1d7486909608e97fd21a51e7412ec1970e9eda29fea87846e5" }, { "input_len": 2049, "hash": "050250e2f40977b9439b90d81c5d0a8306c4d81cb0f2dc41f856aa5415950ac082e35eaaabd579c8b32a79b6ffa5e0d63fbbdeafcc887438760fe0fbd3a7dbf679f9b287da1b3d2ae5645ae7deda633f581beb255ba41b097f6f890946d55c770bb48f628a727492de73230e365b330af3e786878592c0a54ccf1d9040ef627f120cf5", "keyed_hash": "0ab87b84668045b57b7ad2311175b039ab7078e7b82c263d6f2595fe7215006b1a1ccad2d7afe150f4bd238d9fca73331d26749268ba0c54366fd7aca3d071277185824a2b2678141eb82d59394a27d3db522a9b40cc1364ac189a78f4c91122a67900838cd572d6a4f6531ad4497ce9e4505fdb59b444ed91e670de4116e66ff89ff7", - "derive_key": "14970357d73b88688221bfa7b2871fb0e644738efe3b7aa695c185a95dfc3381ebed05ad4d5f73963cca9840a985a00b3af3fcd61541902e0d9e1420bda0dfad226c98f2b036d0993d48fcc027ea1055bda4d48775e7b10245a96821cb6206f6ce1b9d10ad08a0fd5bdc0f1f11ef7d47b4b200565abaa0d69bdb6e316495612246fdb8" + "derive_key": "d5007bdb7a37c34a7b116b994828ded0a86766d80cba5852fc57e6293ae07fa77b7272dcb05d3ac48f05a556302f549da106a913839477d44bc50cb0def239a09ed8e4d06ddc2a5925971a86846b1a2247d3eaf8852036a99c55a676eb5670e9bcce9188b6d11a5831b236c2f32a0bcf728bac5117545838d49ce0238b33fa6c648b58" }, { "input_len": 3072, "hash": "f4ee67a9c3c1d72129216ad7d59ea92d2573a1cf4149f09d394efc1bb3da11ebdeab0a745a4a75bec19edc1592fb110fc3b6e15601959d1f4fa3cca2751a2c9dad9a28a818a51a3d8eb117fdbb0c761023657cd04657a4c442b9e929059f89efda17d99d2eafbae767cd4dd2193027d7deb5e8374c9ed117a9a78b5d3f4db8d9703453", "keyed_hash": "1376b94975b3d3531b00f2b1d402eae8f62f0a5240eb41eb81876f9bdb06250cb1e1830fde5d967fd79c247b42f53c00826db7f621f0dc8cb4fede40973025737b987281b6a5bac8dbfafa68e33475940c0e55191a31e0e4e8985a279cf311a6bc6ff4f7a15d63c195e0195790114d8033a91527097d4023aad7e7758b6c630e717651", - "derive_key": "14b84998443e84d23c306d317b9a501f58aad6c83b2b634ee0b821e0e5b1cb62358b136523aad7650d97d5db3ddea17975367b121ec251ff9888abb6f0b664caf77e164febd8954e2d4dd3656aa211fbece28c330d139981655a58e9d8736c0671638aeef667af8b62c3ce7e85ae948ac8f9870176a7fc2ed0744b6ae555425711a86e" + "derive_key": "1a75aa433cf0434f38bc4e644c1bdbed8c96b2f74dc30ddef0a217202f2a3e915f0b680c4bd456732d69b676950b4c74c7c67b46781d729c0bc43824d4ce83c1906ab1fdd6a48fb66f463c94799aeaa8e1828e57a926cf00c9fc1f37dcbeabce6b17c55bfea0710121ccda2b7ea52c9e89c68d1caf17fa31e2eccb3db8aea83c122032" }, { "input_len": 3073, "hash": "b88af2464b231dc122dcf87d20430a78a4027be457eaee96e7fc0f56fc870c304c39b27c29f265a117bea9031af40d63a60014ba35ea970bbeb1874175e07ea64f34f00b47dcce8914e3bab4fd2776f2c1898df2413c46d16d99a66007d3de7ff461e0efe1a58be47d2aed35e099524a67bc25a7585509f73ad858148c649159b786a0", "keyed_hash": "3a5f83ddce3de57a5928fdc80f899263acbe100d30ab958cd41c2520e64454727466cf3fc0929991b23d224a087aa49f974e53c0b5a77ba8586a7dd3a25a52fb4c4d8b57ab361589f2077fcbbaafcf4d96b3b19e88f0eceb377f357d1e691c7d416f786dbcd478706f726365fc6d035da3c6849635b905bd022ebed1b6c19d835bfc51", - "derive_key": "87ffbf5cbb3107cdc147fe6dbf25dad1b42cdb5c294cdf7d962e7a67aecb246d6ba70aaf678b03ccf2513da9333dd1226bbae39dd20c1fea418ba6b1ea55f1a8018ad029d31cad2f64132218efa5372554941cd13e9f3b9af7c67cabb5309d1eae57811a29ea98a4c1c50c80698819fa5a39bba042c6855dc31b6e83bd688c8aab9a87" + "derive_key": "65514539d21e845995102409bcc1d1384e0b5ef528b5f72fddd55f52da337fa20404d0a153bd9b0f21ab5e3e69fc4bbb1f8dc02615e9ce0cc14d6f8c27f6e69a226d4573b579c7487bcd340785f64a59beb27736c4a71aa92388f098518a42bd058f2d74d297d67f5395f8c0bf3e9e77114ea814d86a60e1895a57a2d6bcc8c9eff7a9" }, { "input_len": 4096, "hash": "56068fe2417d482caddf41981d3821706c4fb55a9cc1eb7bc7f70f81323fb2b5d31581421f19697bd513b5527ca701ed4f0519568932c1d0e514a1daa976ce159f032fd7d4afc6b52756c0049cc0c5f6fbbaa27295c60d7be229d69c84046b7afcc5dfd76824f3e58aac78e0fd109ad1e09acdf10afb8f2d6b8a0c7974643971d01614", "keyed_hash": "b9e6c35b491aff9a80dcfa9706fa163dc114ff6120d329b421b2adf9e8bd4abf8b8c8ab3f0fc827c302069e2c9900ed3548365b2b67e0ee19cd78b9f1737f7876e09c036fc776d62ae0aaf2a1784fb8825df9f1550d8d907d733cb479ea218468cda2ce25ba17835ec3bff8e7f6cff65ac856da18df30b5091a278fb5a789606df8ff8", - "derive_key": "a5780a5c3f8be52f12d97baa2cb0fa7f863f580dea0e35f8e30dbe496eec9a0641fc4902c66678c0db4433aca0426321ed95b1d06dd19c39a12baf821df5ac1f3304c0f5b169fd5cd3f06ba8acf3286737d1c2e9209b005d209a1cfc60713e4eaeafa0e21de4455f60d5db438c124edfbb7f93a14119214f0b2ecd1e836a15e0f43c90" + "derive_key": "8628132ebe74e431f3303d515bc4a90b7d519c4d5d24aeb08d19dcbfbfb3ade86c36358a0e7013ed08008990d91d40169821a2c49c047d68560b6bb7e063b05971d6a45aadd2f397e8514a7f29ad79cffc4af406551e4a75a9c26cd58ea0f6c690c20064e243867abf768d2fb361a431008361abef9e3bd920349f6509de340a5e5dfe" }, { "input_len": 4097, "hash": "05cd1eb97346a2dfa22cfe210a4b13c03ccf947ed0f26a8fe279f78d2b442509242d4f69b7f23a607e74a4d67b69ab3ac5ac2f3cacc576dad666776fefad878b2934d137e569f7d794f5636b1731b874f48b12e887edadacacbcc715dc5c9522994e0fffbf699586dde80f2e80c6c0aafaf15cc4ea2f6dfea12d7e6759e1dc24a1a31d", "keyed_hash": "3456202ab8bf4d8ea1694b9756659bc3a85255670304d3c67eb451888221c93780a9fe5e7e092fe78bcf716b4423a97a8c03b56aca1fe038c100684762f1ce9c7620a56abfba69f979e14d0ddeade8f4ebbaa0a6307d0e8fe518f2a70cb0a23c5b0a8a8523e1d0b9fa74296640176f8f592e461a3151f2601524c011a634079efab019", - "derive_key": "47022f8bc16d4655853000b2c3ff13c5c153694314a450ad9f18d61d996296b029e1e0da445f5bf8a4e5b2e32364f8cf676c0533dae0412afa69f127f71bf74f233e4a2d56de3fcbd39b04e9c1fee26758b1cff5608962d6593704fec9cbf9087fb17890f81245f742c8a50275df7fd1bd54a75b28a3ae40785d28b8113161e20f07f9" + "derive_key": "45f89725444620851c9c80711a64d10feff6adeb0795f2a3e1fc6077223191b0aeae1578cf91e2807d174b8bb1bbfe6aa63422d554d0f957f8b57d188d853747f3c1e73d35a546206836ac530794a3860bd8f4b3b31c2dc685e343c5831d98c37aafe64c89ca954914da3a5f179016e46d680eb1257cdf3449cb58f3899a46ecae1496" }, { "input_len": 5120, "hash": "10e426fca9481e052ae4e4861b83ae5153b683962d81480cb69afbc611c6c2ac716ce4fcd4c44456450220d29494ba65dd77c9efb450048283ac982d59aeec935a73f16d4a92642a9d61e7a0e448ed95e35b5834b8cfa8bb36f09f3bf1812cb5ebea77d0e7fea35fd5f8530b28eca28577e77486595a0bf83b6d0b1835d4655d1ec199", "keyed_hash": "50c1881a1e247bcd482b1254ae8f77a9d953fcef15e12cc26334d158f0079146351e29a26ca6c9e268ce2f32c1b0443b92d0458465d8611c94e47d477aaad3ccde6ab4ef21b99fbfa0e87bd2c6d05400e871725609e7f4b8a22cd570132483639ea364382c7643c1b08911cbec29322a82f1957414537125c5c20975bbbe3abe0d9ad8", - "derive_key": "5249571928c0009ee6dcffa8b8b9ff952490e85d8abd3f0459ecac3613dbce83a718eb430d121695a919011f0edecdcaec78fcda5201c4377c94d18d2bb5dc37528370ef616c31cf285c3bf9e2de1a6c8dea79f62061c7604f1b736a47559c664e8fdc3b2ff3af03b86693c55b5ea2362a99a3c59704df9c68e17fcc81a0a774e80c95" + "derive_key": "04866c7d7629e41233e432668514ce1e681eac4a591b23a70e9819c0eff5dc73b72a3b10b99c5103635017ec954f82a4682ff9e167ccc21d20713617238a09ec015774dfefb30f7aaf7eaaf14cb9ad5aa45a974f4eb93de2e26dcbcacca3599ec2e461df9b67f34588b197d48f7fd3d6088d33ea6676b8890a0a4e9cfd6e37cb77de34" }, { "input_len": 5121, "hash": "2e80caea9b43674ae1770f26a1c5d1fc9fae62348ded8725b6ee447e361cca3876b8f44d9be09fd25dddea5c319eb718202122bb97add2fa3a262fe0322ac0213464cf9f7c754ae5e0c7fd697bd58537ceb6592a1cc2572deabeeadf859743b5c57dd3b3c4e92fa97fede8c13d05017c29d310e6e5168dc94a6ee2a6b470f391606027", "keyed_hash": "2f4ed41ef09baf4698f34cdf3638c0b9af1c7c20ce6bbc15c4ba589158d63e3ee2d5d873a0508fc51c1c3fb587a0aeeada084c9303ed5e21d1c89edf50a54bdb92591fbdacbd8bf070f61f0d4b2ef0979b14051b7ad6ceb3150605b4e9b8a78a5339de5f6723ee53664f45e6fadc435a380d50b7662a2a344394c7fb483bcaea81751d", - "derive_key": "818bb413621498d4d3d6b9835d80dee994538ddad7857d0b29b4ce39a02e324c281715cbfae95f2d6ac54123dba02b2028bdfac984a279ba6917ce1f961e1a46c47e61fa370c85eb0b7932eef03e06174fef2f67f3d67104d6fca65b3dabdca3e1c3175775f438abe670d81a035fdb5fe77bf197584656a43228948c8bd7ea2c78e330" + "derive_key": "13cda085527d4ff766c27a1311ccc0a928a6799b2aa6ffbb14f282bbb33d5fe6bbdfdf46466c3799904497503a07eea886df32db74dce84a0c0f73e3ca086a2913670ae5199b17344bbbd0e73419c09f148b493b1e82430f182b5fcd782d194b8033e5000967cfb826e0cdb91a7a723513b61c81accfff2e9dd46f1d49e697cc536e28" }, { "input_len": 6144, "hash": "1f2a63135b07210fca1f6b5dc8dc982328981a427d67c2b3b09ae9b0280ad6842b57f174f315d306e5b3743bfc5b6f66e13fa8ef10aa371e228c34fd9e19a2b467f4a4cbc6160050b6288615e391ae8027441ec90b12db1d7961b2d51c66acb881444f91181371153100f1dd615b82e0f8f11bf6f7635dd96132ff25e15588ef52b2db", "keyed_hash": "8459fab047883448b07406ba3a2e5fe8651ff5c2b41e8451ba6c24a77c3a54254c043ae924f1620250f3f900b9b9b55013a634a77b18187c20b40a5d292c2fc324fdd5a719b63300067f5d914c6791737400dccf9924320e324be9f1af6956535aac86df8a5f56b42b97c0e31e6e9edc18ed1e44300ca33f4c6f4544cbd44373ac8ea1", - "derive_key": "b4cf2d3b0f2273acbf1dfcf0c1a7d74b13a95b9669c2f276cd31ebd7fedd0bc768e5baff5e019dd221a58dbc96099ee33bbcec5152915d20b82af6a30853719176d0be6014f97d7abe16c2d6f94be4a3b07b52aa6a0bef1b76fb02c916c6607463f6b199af2085e0b8bbeb3a602ff40d86c902f922f8671e9b4278a4514e903e903f65" + "derive_key": "8da60e09960016e0cc92c86f9a9a3a575e40d7a1f5b9c0442017657f73e715506c06c4e4b5750b08187f8701a16c7f9ab5024b55f1c9f9ae0e2add639fa284a51b9b50a2f66c7d7c94797371eb8f85e9356a8cadbcd3b9605be0cc6a8b26d9ac2519d18b46f509e8d6cbeed12c9b8732aeaad8f9f66dc61e97fcc68f5e007073ce7b49" }, { "input_len": 6145, "hash": "23a825db8dee7749a2ec23924f602209a0fddca6ec469fbccd28c28d3267ba862ff53154fe87bb22ca6a8413390d3c68e7fa970b0ff928c0540c64afa8f85706ee5de39fef4f116328d7caa3115e987b97058a52af568f095e5a3a5e7ea4cd28fbea9a23fa9af797f94a9a8dc160b777ef40d765148ccc710ef262377d3c09a7ecae8b", "keyed_hash": "13619b046067dfe8febcfbed54d843f9f62fd0c1e19a5f97264fb94dffefcecbf894eaaec77a91909dd0ebb9443ba58bbc203604a0142768ed9799166bfa2b70daa052dda42c52735e48fc87b074930b568b57fa190c899408e94eecaba8a2c2dda0d70e1b10a71189e15146919d81e8694cc0de9a437463588f1372e9b04a2288288f", - "derive_key": "147a2420fdbba21e63feba2456e956be30516f3eaf287ef4aa68446d83972f80c7b60407b4caa6695e035050638b33b01350772dd4e17719b16124cf7c90e64e2d6288c2d56a7dd65d924b4f43a9f95d15871658dd4d4ddcc4d71a587b93b1766de9cb360023d694881ff7c45cba9f2b8b82dfb0a2850f4ad8c26775086c95505b2511" + "derive_key": "8183a9f240a310ae7da7a6d894189766e13a73d8692c67fe5e63a46b87665acce1f8cf8f0ce2bce459faefa66d6ac5945b0edfd86d18981636e98af8777c3310a9a25fa9ae0631caf35400526fa1143de1cbe881ef8c813cc762477e2aa5544a898a877b3e095f0a2b3819c15f761e6d7236294aba2f653d9b6d51cf8b2296468215cb" }, { "input_len": 7168, "hash": "73aff5e142aba955db9a11bc4bf5e875be2d27720f13aee122816262a821ccb3bc7cecd468884bff8aa86d760248984be22e4a6a72bfb2f4f2d945fe94e62a597f97bb969b53fd54bc089033ff04aa4b4a974874c8e49c0b58367aae97ff87329e1ba8bf3a740e115574eab72960e02b82a93ad1b2bc4dd40850b7614f3198f9d5f514", "keyed_hash": "2277e49eff7f0e353bb647985e25adead0607e10b01a3af0e4e83efc9e04ba95ed6995304e472646b297b3917f8682b7f1802e2f9b07fa24a86da90620ac2de930489463481c36b1efe122509d39dcd3cb3610e960da46e462a840f43df9afb1be5e0512b972bc58a7d773f1830ec79b124554dc2d5c9f9f95400b264475e8cc522603", - "derive_key": "802b65135ec5390020ddb9032f231bb2fd4bbbafb1cded2bc16d09e1bac490591bca6b8e761f2548ac56dcf47d1be689382b72cb0bf3902ff2a3cc7fb091bd5778b574c5b802233983723bc4a16a4eaaa9db6659873de839f9785a4e2bfe0f1179ae8c2054adabe2cd22a8e24d93998e792a73775618394b302898f5c113aa3045ec16" + "derive_key": "398653ac16edf8f6956b22a3934c797fa23f9f50e020b12bcfb6d6d63906c36438fa783c43735d481261390cdf196556faf5177e233886fa5372d4b568ed9037dcd0867aa7265668695c1fa7de3109c127ad1b746ccd1652424d8c02e424477073591119fe7af8d70988b5343ad2150594ba7c3f4be618cd86325b25b492663f1d17b0" }, { "input_len": 7169, "hash": "2ebec7780331a3794aff5e6b10ff3e8f12bde652796d74503214869c89c9e9ea680df2f90a252c723abbeff8ff8cbacfdcd20bb0a8de6917aaae0fb1bdc639eed856df1778a9b8359c2d412ec82bdf759028606fe1d00894449bdd043f3860eb0f309515d576fc111502e5247e1ec7bb589a1459291410fd4b4a8806ac55d843bea017", "keyed_hash": "897802df709fc320f73dc4cec70823c1209850ce4f8bc6a94f82cb33ee3abfee9d9ad6fa577390151cb106ee3f56a6d6416500ab0604fcc8c1b827bba8416508964fc0b68a7308df1bb2ee6499d7bdef2892ac4d6dc5c02755fcfff72e4341d95c085e9906928661a427b69d087c4469f62888395348fd54f2aa0bc4dc032691e780e0", - "derive_key": "87beb52a6089a58f97e896340b4a4f42c183dcd325f18120933dd779988f1a5154013290c315892353841868ff7fa35a4702ce427ae90be5963794e92b88ff3304a52b3e9826a898accb69e0ca09ea9a8f2fc87356e9aa19ad738fb46a04cae0abcbff10b7cf4eaca0f874f330f3fa2dd81c52e368782af9d3f00fb2aeaaf320b3b3bb" + "derive_key": "95fa359220bd5f4641e5ba9aa6b80145bb6de9901fda57446df60eadf018cf4c0b2b366d5d4358c60a063f802cd894a10e37fd82555a514cf438c11cb87c20886d212888ea47a01e9eadda63e03b94ac128ae7cec27dd62d4661532deae520f1cdf13d0b06b785287add95c6e051dc09a4dc1f89b182bbec8b4b0043cb95e9e6c614c7" }, { "input_len": 8192, "hash": "97fa001fbec31ce77600fef5d53b074f2c9f35ba1843f03fcdff567a8204159083023093a92e61c9ae6156b42b31eae6bbdeef422b35151cdb50d410aa65bf41936efee65850ddaf0c8daeb0b158498d77bf0341cff689c152a9eb421b1a4453f2c777d1671626c95decce350b3d32900303406944c82ab50d5b3258f627ab1468cee9", "keyed_hash": "459b6e7c3b67dbc2ded5ee7edf0c423a43b79f7f11445fece829e484876ebc304a50e5e3008c584f45dd0c448d6bddf09f6a88289852fae087bdf3531b20ffbcb3fc80ff03d39b03c0799a9c3face24161cab1622eac41c2536cc6f967b36c9d39fef5eb7a30cf24b0594d4bdf21f2532854593ea16c00da88dcab97cd106e75ad7c1d", - "derive_key": "ae4136573e28893f6b1637821415009223ae197ef5ed229ff15980c0519b39c225321ac9fb1ddd18decd9121b8fcd03f44aa4c9b6512eec25c1db075900b3818c6d7bf930fafaf50189fcc5dc4d2aef9c72427a747f3a8fbf13011ae46d4f3b1222b7b52bbed523ba0a41c83660969ea83374694ee6fa209ff1f312d06dd43e683cc72" + "derive_key": "eb84e9f33a2bb87fe3403d6817a6bb2a9f4c2742aab2fe6adc021b4a5628adc3957b496f7020c69903ae8b73b530e7283c7769fb53562291d9ce2c4053d4bc7987c282bdc5008d3452819f8f0a4abf7f9806c17b14cea10eaa5ae9d0f7c219585160287c955eb2414d2ec6efed67466e87a3f644a241dbdc0e0ba32b8feb823e728d9a" }, { "input_len": 8193, "hash": "5130f9d488e0397a5b33aaf5dc07dcff5791a363f6c8a3c1212773f106debc5e8abe5659a570881a84088cde123c8cd9452d445518198375bfda9dfd3a17de5150576777dcb23f25ef62870bd17350ddc2e545ca21c5ccb5c415994fc933a48fe30bfb7cbad580bb83ed971710eddd03918dcb3321d6d43086666d43ac40838ac84d49", "keyed_hash": "9f1468dd575f4d04617377620f3f0ee8f6f0e28b2e1adbbf00ddcc7763f64e4ea2e24637b0587facb504bed148971183ccae1ea94272c430868df99954fc8e875396832527ae09da201a4526abbaa92a6dd0d24958e8397137ab1a4c5064fb23fe4647512138288020bc9362212a9e8efda0aee1912cdcc8d166c8583958e8229af890", - "derive_key": "a9d29e855ff49e38e7a513790117488bc482e00f7b3372452f6b04b465a601c2350e55f8c913814aba733cbb3b8088574243f209e93ea167584df60888795bcc912fc5908bbbe5871c108900c7b68515a8ffbabb1f2c66e0336aea6d613e7081691fcab803e3ce0222c6b9036e56f0b7e415c8742dc203a2ab422ad61ff6f3426107bd" + "derive_key": "a278e50d4cebb843e97c4cbf62a870587464c965ef01af3a878357ad46861511704a5572d0daefba90ed7e665e1a9cf97a52716d0c9075d22590e5e98fb089f7df4071dae90ff685ad27a6c3b4e9345afd0680d7c2cb6001b5f29e85138f0726639aa52d3a6b116d752adc5afb67b29092e2b38ee3d463949b3bfb98813bc9cc1fab21" }, { "input_len": 16384, "hash": "f91f20dfad46cb08c3196ca0060f0b5c3840445030f0184ffa2ebbc4cf6c46e63dfdf6f6cd998aac06c43860322d75f050cd385862a826eb5e83552feddb5a7685a1d66463ee6a0aec4da1574d9a11d086bbc566c4fcd1b0a2f5a58ce29d663912ee1f9be6a63d5c93c1796103fc8a09f6cfea3d8cbd0835e045f7d5440bc9552dff96", "keyed_hash": "8b666ddf0a92535ee4056d663641b9528c9f5506bdb84498bd57a27a50ab770fe1a4a77a0998d88ce17080ee110b0104f3fb65c6498d9aafea4e9d710fd9f2ff8644342a42e1c31e777a3a74537a8dd5d3ae5dc690184a47a50f0df13d2ad26101f747a3646e489cda3eb939a37f21e7c42928369278d50ece2ea39c9763cc6e7bef98", - "derive_key": "f4061899074349ef06f61ceaa653086c6377924df70aaf3d03c68c9652462aa1adf740fdd86435bd1b789bb9c2e61b4a14bcfd3eb795a1feb141d4aac18031afb02d80599c597706c9151e5b59730914bbdb0e803d53c0c5359fdaf168072fa192c814fc97bc6850010facc5709735aa56df37362146fc27d696ef619f48468f53ddb3" + "derive_key": "e5aff1a86333a0ba8a51ad3e11b8154f8050869a2ef3e5e3b572e33b7549e4e36a2317cac5e7e521b0c90895d772d108dd8e1eea81730ea60cad608fb317eb34d9df00a4b9ffbaaa06b4b316d4ce3bd20d60f152bfb3cd029f517078fc61e0998f109fe937bfb23c9a2709a1615c0c8113b404fcf9b225f307807091389fc2048bbb52" }, { "input_len": 31744, "hash": "58a4d5c7cb22a2ea1a0e78cfcb79104d4b3e8bfd8fa384c995f42519bc2546d949d85b50f85673969fd1ccc0dad15e29249dc2be51eb9886ee637462f0c97834f6b777776cd3beaa578618e945323d2452f0ba654a999550ce487d7583a3e92e785d07641be903624a5882f44ac4e4a3b94b04b7fda352b4211793c830abf62ae0dd6e", "keyed_hash": "3de3905be6e33bf796994a710c10b07447ace37c29d65437d32c51dd5396074e0fe56076eeaf3509791f0dc24370cebc0aabcc048de03dfd11b3173963ccbb0f71c2456aba58ce1437a08834590020966307cc67437750df3b8df0bfc393f37629b13754309831d6533653847079e3031c2766bf3b15377f7021d05c65bbca76bdac65", - "derive_key": "d604f1a0e759ce81d762b870b2ca8a3d65ffa8ca9e00d265e03ea39f3acb4a9a70df332e3b9fd01d987c87279e6162b4da2f6cfd9a3e5c2ba5a99ff5bea10cddcc49969fcd2da18937664e724a2b90eb56b624452de8a152ce9dd4b430e2159c89ed9d47774779c831457c4ae45b9ea58fa15ca10ce9e0177ff1d0f1940ddb7b5c545d" + "derive_key": "f8a392cbe1db5e4deeab88285ddca8d8123c65ffadf27d4eb6dbabd9bc2d586d6f28886e3bab709cfd79d6d345da0bb06b17e45d16efa34ce853024994ed7153dc65653ea060619f1614b4fe1763d869c0e4b5e29343aaa86ed82d097150cc6e0ac9a646bcaf51c5a1c7162b941b64c5978dd394d455236c45c75185b1926946426b95" } ] }