feat: download BLAKE2X test vectors at test time

Author: huitseeker

blake2/Cargo.toml

@@ -25,6 +25,7 @@ rand = "0.8"
 paste = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+ureq = "2"
 
 [features]
 default = ["alloc"]

blake2/src/macros.rs

@@ -485,10 +485,6 @@ macro_rules! blake2x_impl {
         $vardoc:expr, $base_core:path,
     ) => {
         /// Blake2X XOF core implementation.
-        ///
-        /// Implements the Blake2X extended output function which builds on top of Blake2b/Blake2s
-        /// to provide variable-length output. The XOF length parameter is incorporated into the
-        /// root hash computation to ensure different output lengths produce different results.
         #[derive(Clone)]
         pub struct $core_name {
             /// The root hasher for this variant of Blake2X.
@@ -500,69 +496,53 @@ macro_rules! blake2x_impl {
         impl $core_name {
             /// Create new core with specified output length.
             pub fn new(xof_len: $xof_len_type) -> Self {
-                // Root hasher construction is delegated to new_blake2x_root_hasher for deduplication and correctness.
-                $core_name {
-                    root_hasher: Self::new_blake2x_root_hasher(xof_len),
+                Self {
+                    root_hasher: Self::new_root_hasher(xof_len),
                     xof_len,
                 }
             }
 
             /// Create new core with specified output length and a key.
             pub fn new_with_key(key: &[u8], xof_len: $xof_len_type) -> Self {
-                $core_name {
-                    root_hasher: Self::new_blake2x_root_hasher_with_key(key, xof_len),
+                Self {
+                    root_hasher: Self::new_keyed_root_hasher(key, xof_len),
                     xof_len,
                 }
             }
 
-            /// Apply XOF length parameter adjustments to a Blake2 hasher state.
-            ///
-            /// The Blake2X specification requires the total output length (xof_len) to be
-            /// incorporated into the parameter block of the root hash computation. This ensures
-            /// that Blake2X(M, L1) and Blake2X(M, L2) produce different outputs when L1 ≠ L2.
-            ///
-            /// This helper function encapsulates the word-size specific logic for both
-            /// Blake2b (64-bit) and Blake2s (32-bit) variants.
-            fn xof_parameter_adjustment(hasher: &mut $base_core, xof_len: $xof_len_type) {
+            /// Apply XOF length parameter to the hasher state.
+            fn apply_xof_param(hasher: &mut $base_core, xof_len: $xof_len_type) {
                 let xof_param_vec = if core::mem::size_of::<$word>() == 8 {
                     // Blake2b: xof_length is a u32 in the high 32-bits of parameter word p[1]
                     let xof_param_val = ((xof_len as u64) << 32) as $word;
-                    $vec::new(0 as $word, xof_param_val, 0 as $word, 0 as $word)
-
+                    $vec::new(0, xof_param_val, 0, 0)
                 } else {
-                    // Blake2s: xof_digest_length is a u32 in parameter word p[3].
-                    // We start with a standard Blake2s parameter block and then
-                    // XOR in the xof_len to modify the h state corresponding to p[3].
-                    let xof_param_val = xof_len as $word;
-                    // The parameter p[3] is the 4th element of the first SIMD vector.
-                    $vec::new(0, 0, 0, xof_param_val)
+                    // Blake2s: xof_digest_length is a u32 in parameter word p[3]
+                    $vec::new(0, 0, 0, xof_len as $word)
                 };
                 hasher.h[0] = hasher.h[0] ^ xof_param_vec;
                 #[cfg(feature = "reset")]
                 { hasher.h0[0] = hasher.h0[0] ^ xof_param_vec; }
             }
 
-            /// Create Blake2 hasher specifically for Blake2X root hash computation.
-            fn new_blake2x_root_hasher(xof_len: $xof_len_type) -> $base_core {
+            /// Create Blake2 hasher for Blake2X root hash computation.
+            fn new_root_hasher(xof_len: $xof_len_type) -> $base_core {
                 let mut hasher = <$base_core>::new_with_params(&[], &[], 0, $hash_size);
-                Self::xof_parameter_adjustment(&mut hasher, xof_len);
+                Self::apply_xof_param(&mut hasher, xof_len);
                 hasher
             }
 
             /// Create Blake2 hasher for a keyed Blake2X root hash.
-            ///
-            /// This is similar to new_blake2x_root_hasher but includes the key length
-            /// in the parameter block for proper keyed hashing support.
-            fn new_blake2x_root_hasher_with_key(key: &[u8], xof_len: $xof_len_type) -> $base_core {
+            fn new_keyed_root_hasher(key: &[u8], xof_len: $xof_len_type) -> $base_core {
                 let mut hasher = <$base_core>::new_with_params(&[], &[], key.len(), $hash_size);
-                Self::xof_parameter_adjustment(&mut hasher, xof_len);
+                Self::apply_xof_param(&mut hasher, xof_len);
                 hasher
             }
         }
 
         impl Default for $core_name {
             fn default() -> Self {
-                Self::new(<$xof_len_type>::MAX) // Unknown size by default
+                Self::new(<$xof_len_type>::MAX)
             }
         }
 
@@ -587,10 +567,8 @@ macro_rules! blake2x_impl {
             type ReaderCore = $reader_name;
 
             fn finalize_xof_core(&mut self, buffer: &mut Buffer<Self>) -> Self::ReaderCore {
-                // Finalize the root hash H0
                 let mut root_output = Output::<$base_core>::default();
                 self.root_hasher.finalize_variable_core(buffer, &mut root_output);
-
                 $reader_name::new(root_output.into(), self.xof_len)
             }
         }
@@ -628,10 +606,8 @@ macro_rules! blake2x_impl {
                 serialized_state: &digest::crypto_common::hazmat::SerializedState<Self>,
             ) -> Result<Self, digest::crypto_common::hazmat::DeserializeStateError> {
                 let len_bytes = core::mem::size_of::<$xof_len_type>();
-                let mut xof_len_bytes = [0u8; 8]; // Max size for either u16 or u32
-                xof_len_bytes[..len_bytes].copy_from_slice(&serialized_state[..len_bytes]);
                 let xof_len = <$xof_len_type>::from_le_bytes(
-                    xof_len_bytes[..len_bytes].try_into().unwrap()
+                    serialized_state[..len_bytes].try_into().unwrap()
                 );
                 Ok(Self::new(xof_len))
             }
@@ -642,7 +618,6 @@ macro_rules! blake2x_impl {
         pub struct $reader_name {
             root_hash: [u8; $hash_size],
             node_offset: u32,
-            position: usize,
             remaining: $xof_len_type,
             total_xof_len: $xof_len_type,
         }
@@ -652,25 +627,13 @@ macro_rules! blake2x_impl {
                 Self {
                     root_hash,
                     node_offset: 0,
-                    position: 0,
                     remaining: xof_len,
                     total_xof_len: xof_len,
                 }
             }
-        }
-
-        impl BlockSizeUser for $reader_name {
-            type BlockSize = $reader_block_size;
-        }
 
-
-        impl $reader_name {
             /// Build expansion node parameter array for Blake2X.
-            ///
-            /// Creates a unified parameter word array that encodes the expansion node
-            /// parameters according to the Blake2X specification. This handles the
-            /// word-size differences between Blake2b and Blake2s variants.
-            fn build_expansion_node_params(
+            fn build_node_params(
                 node_offset: u32,
                 output_size: usize,
                 total_xof_len: $xof_len_type
@@ -679,115 +642,77 @@ macro_rules! blake2x_impl {
 
                 if core::mem::size_of::<$word>() == 4 {
                     // Blake2s (32-bit words)
-                    // p[0]: digest_len | key_len (0) | fanout (0) | depth (0)
                     p[0] = output_size as $word;
-                    // p[1]: leaf_length (should be hash_size for Blake2Xs per specification)
                     p[1] = $hash_size as $word;
-                    // p[2]: node_offset (the block counter)
                     p[2] = node_offset as $word;
-                    // p[3]: xof_len(u16) | node_depth(u8, 0) << 16 | inner_len(u8, hash_size) << 24
-                    let xof_len = total_xof_len as $word;
-                    let node_depth = 0 as $word;
-                    let inner_len = $hash_size as $word;
-                    p[3] = xof_len | (node_depth << 16) | (inner_len << 24);
+                    // xof_len(u16) | node_depth(u8, 0) << 16 | inner_len(u8, hash_size) << 24
+                    p[3] = (total_xof_len as $word) | (($hash_size as $word) << 24);
                 } else {
                     // Blake2b (64-bit words)
-
-                    // p[0]: Contains bytes 0-7 with digest_length, key_length, fanout, depth, leaf_length
-                    let digest_length = output_size as u64;
-                    let key_length = 0u64; // No key for expansion nodes
-                    let fanout = 0u64; // Unlimited fanout
-                    let depth = 0u64; // Unlimited depth
-                    let leaf_length = ($hash_size as u64) << 32;
-                    p[0] = (digest_length | (key_length << 8) | (fanout << 16) | (depth << 24) | leaf_length) as $word;
-
-                    // p[1]: Contains bytes 8-15 with node_offset (with XOF length in upper 32 bits)
-                    // For Blake2b expansion nodes, we include the XOF length in the upper bits
-                    let node_offset_full = ((total_xof_len as u64) << 32) + (node_offset as u64);
-                    p[1] = node_offset_full as $word;
-
-                    // p[2]: Contains bytes 16-23 with node_depth, inner_length
-                    let node_depth = 0u64; // Leaf level
-                    let inner_length = ($hash_size as u64) << 8;
-                    p[2] = (node_depth | inner_length) as $word;
-
-                    // p[3..7]: All zeros (already initialized)
+                    // p[0]: digest_length | key_length(0) << 8 | fanout(0) << 16 | depth(0) << 24 | leaf_length << 32
+                    p[0] = (output_size as u64 | (($hash_size as u64) << 32)) as $word;
+                    // p[1]: node_offset with XOF length in upper 32 bits
+                    p[1] = (((total_xof_len as u64) << 32) | (node_offset as u64)) as $word;
+                    // p[2]: node_depth(0) | inner_length << 8
+                    p[2] = (($hash_size as u64) << 8) as $word;
                 }
 
                 p
             }
 
             /// Create hasher with expansion node parameter state.
-            ///
-            /// Initializes a Blake2 hasher with the given parameter array by XORing
-            /// the initialization vector with the parameter block.
             fn create_hasher_with_params(p: &[$word; 8]) -> $base_core {
-                // Initialize state h = IV ^ p
-                let h = [
+                let mut node = <$base_core>::new_with_params(&[], &[], 0, $hash_size);
+                node.h = [
                     $vec::new($IV[0], $IV[1], $IV[2], $IV[3]) ^ $vec::new(p[0], p[1], p[2], p[3]),
                     $vec::new($IV[4], $IV[5], $IV[6], $IV[7]) ^ $vec::new(p[4], p[5], p[6], p[7]),
                 ];
-
-                // Create hasher with expansion node parameters
-                let mut node = <$base_core>::new_with_params(&[], &[], 0, $hash_size);
-                node.h = h;
                 #[cfg(feature = "reset")]
-                { node.h0 = h; }
-
+                { node.h0 = node.h; }
                 node
             }
 
             /// Blake2X expansion node function.
-            ///
-            /// Implements B2(node_offset, output_size, H0) from the Blake2X specification.
-            /// Each expansion node computes Blake2(H0) with specific tree parameters that
-            /// encode the node offset and output size.
-            fn expand_node(h0: &[u8; $hash_size], node_offset: u32, output_size: usize, total_xof_len: $xof_len_type) -> [u8; $hash_size] {
-                // Build expansion node parameter array
-                let p = Self::build_expansion_node_params(node_offset, output_size, total_xof_len);
-
-                // Create the node hasher with the parameter state
+            fn expand_node(
+                &self,
+                node_offset: u32,
+                output_size: usize
+            ) -> [u8; $hash_size] {
+                let p = Self::build_node_params(node_offset, output_size, self.total_xof_len);
                 let mut node_hasher = Self::create_hasher_with_params(&p);
 
-                // The hashing logic is now unified for both Blake2b and Blake2s
+                // Hash the root hash as a single block
                 let mut buffer = LazyBuffer::default();
-                buffer.digest_blocks(h0, |blocks| {
+                buffer.digest_blocks(&self.root_hash, |blocks| {
                     node_hasher.update_blocks(blocks);
                 });
 
-                // Finalize and return
-                let mut output = [0u8; $hash_size];
                 let mut var_output = Output::<$base_core>::default();
                 node_hasher.finalize_variable_core(&mut buffer, &mut var_output);
+
+                let mut output = [0u8; $hash_size];
                 output[..output_size].copy_from_slice(&var_output[..output_size]);
                 output
             }
         }
 
+        impl BlockSizeUser for $reader_name {
+            type BlockSize = $reader_block_size;
+        }
+
         impl XofReaderCore for $reader_name {
             fn read_block(&mut self) -> Block<Self> {
                 let mut block = Block::<Self>::default();
 
                 if self.remaining == 0 {
-                    return block; // Return zeros if no more output needed
+                    return block;
                 }
 
-                // Determine output size for this block
-                let output_size = if self.remaining >= $hash_size as $xof_len_type {
-                    $hash_size
-                } else {
-                    self.remaining as usize
-                };
-
-                // Blake2x expansion: Hash H0 with specific tree parameters for this node
-                let node_output = Self::expand_node(&self.root_hash, self.node_offset, output_size, self.total_xof_len);
-
-                // Copy output to block
+                let output_size = core::cmp::min(self.remaining as usize, $hash_size);
+                let node_output = self.expand_node(self.node_offset, output_size);
                 block[..output_size].copy_from_slice(&node_output[..output_size]);
 
-                // Update state
                 self.node_offset += 1;
-                self.position += output_size;
                 self.remaining -= output_size as $xof_len_type;
 
                 block
@@ -800,7 +725,6 @@ macro_rules! blake2x_impl {
             }
         }
 
-
         // Use buffer_xof macro to create the wrapper types
         digest::buffer_xof!(
             #[doc=$vardoc]