Rust wrapper: add blake2_digest module

Author: holtrop-wolfssl

wrapper/rust/wolfssl-wolfcrypt/src/blake2_digest.rs

@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2006-2026 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+/*!
+RustCrypto `digest` trait implementations for the wolfCrypt BLAKE2 hash
+types.
+
+Because BLAKE2b and BLAKE2s have variable digest sizes, this module exposes
+typed wrappers that pin the digest size of an underlying [`crate::blake2`]
+instance to a specific value, matching the typed aliases provided by the
+RustCrypto `blake2` crate (`Blake2b512`, `Blake2b256`, `Blake2s256`, etc.).
+
+Each typed wrapper implements the traits from the `digest` crate
+(`HashMarker`, `OutputSizeUser`, `BlockSizeUser`, `Update`, `Reset`,
+`FixedOutput`, and `FixedOutputReset`). With these implementations the
+`digest::Digest` trait becomes available via its blanket implementation,
+allowing these hashers to be used anywhere a RustCrypto `Digest` is
+accepted.
+
+Any failure returned by the underlying wolfCrypt call in a trait method
+will result in a panic, matching the infallible signatures required by the
+RustCrypto traits.
+*/
+
+use digest::consts::{U16, U24, U32, U48, U64, U128};
+
+macro_rules! impl_blake2_digest {
+    (
+        $(#[$attr:meta])*
+        $name:ident,
+        wc_ty = $wc_ty:path,
+        digest_size = $digest_size:literal,
+        out = $out_size:ty,
+        block = $block_size:ty
+    ) => {
+        $(#[$attr])*
+        pub struct $name {
+            blake2: $wc_ty,
+        }
+
+        $(#[$attr])*
+        impl Default for $name {
+            fn default() -> Self {
+                Self {
+                    blake2: <$wc_ty>::new($digest_size)
+                        .expect("wolfCrypt BLAKE2 init failed"),
+                }
+            }
+        }
+
+        $(#[$attr])*
+        impl digest::HashMarker for $name {}
+
+        $(#[$attr])*
+        impl digest::OutputSizeUser for $name {
+            type OutputSize = $out_size;
+        }
+
+        $(#[$attr])*
+        impl digest::block_api::BlockSizeUser for $name {
+            type BlockSize = $block_size;
+        }
+
+        $(#[$attr])*
+        impl digest::Update for $name {
+            fn update(&mut self, data: &[u8]) {
+                <$wc_ty>::update(&mut self.blake2, data)
+                    .expect("wolfCrypt BLAKE2 update failed");
+            }
+        }
+
+        $(#[$attr])*
+        impl digest::Reset for $name {
+            fn reset(&mut self) {
+                self.blake2 = <$wc_ty>::new($digest_size)
+                    .expect("wolfCrypt BLAKE2 init failed");
+            }
+        }
+
+        $(#[$attr])*
+        impl digest::FixedOutput for $name {
+            fn finalize_into(mut self, out: &mut digest::Output<Self>) {
+                <$wc_ty>::finalize(&mut self.blake2, out.as_mut_slice())
+                    .expect("wolfCrypt BLAKE2 finalize failed");
+            }
+        }
+
+        $(#[$attr])*
+        impl digest::FixedOutputReset for $name {
+            fn finalize_into_reset(&mut self, out: &mut digest::Output<Self>) {
+                <$wc_ty>::finalize(&mut self.blake2, out.as_mut_slice())
+                    .expect("wolfCrypt BLAKE2 finalize failed");
+                self.blake2 = <$wc_ty>::new($digest_size)
+                    .expect("wolfCrypt BLAKE2 init failed");
+            }
+        }
+    };
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2b)]
+    Blake2b256,
+    wc_ty = crate::blake2::BLAKE2b,
+    digest_size = 32,
+    out = U32,
+    block = U128
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2b)]
+    Blake2b384,
+    wc_ty = crate::blake2::BLAKE2b,
+    digest_size = 48,
+    out = U48,
+    block = U128
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2b)]
+    Blake2b512,
+    wc_ty = crate::blake2::BLAKE2b,
+    digest_size = 64,
+    out = U64,
+    block = U128
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2s)]
+    Blake2s128,
+    wc_ty = crate::blake2::BLAKE2s,
+    digest_size = 16,
+    out = U16,
+    block = U64
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2s)]
+    Blake2s192,
+    wc_ty = crate::blake2::BLAKE2s,
+    digest_size = 24,
+    out = U24,
+    block = U64
+}
+
+impl_blake2_digest! {
+    #[cfg(blake2s)]
+    Blake2s256,
+    wc_ty = crate::blake2::BLAKE2s,
+    digest_size = 32,
+    out = U32,
+    block = U64
+}

wrapper/rust/wolfssl-wolfcrypt/src/lib.rs

@@ -45,6 +45,8 @@ pub(crate) unsafe fn zeroize_raw<T>(val: &mut T) {
 
 pub mod aes;
 pub mod blake2;
+#[cfg(all(any(blake2b, blake2s), feature = "digest"))]
+pub mod blake2_digest;
 #[cfg(all(any(blake2b, blake2s), feature = "mac"))]
 pub mod blake2_mac;
 pub mod chacha20_poly1305;

wrapper/rust/wolfssl-wolfcrypt/tests/test_blake2_digest.rs

@@ -0,0 +1,126 @@
+#![cfg(all(any(blake2b, blake2s), feature = "digest"))]
+
+use digest::{Digest, FixedOutputReset};
+use digest::block_api::BlockSizeUser;
+
+mod common;
+
+fn check_digest<D: Digest + BlockSizeUser + FixedOutputReset + Default>(
+    input: &[u8],
+    expected: &[u8],
+    expected_block_size: usize,
+) {
+    assert_eq!(<D as Digest>::output_size(), expected.len());
+    assert_eq!(<D as BlockSizeUser>::block_size(), expected_block_size);
+
+    /* One-shot digest via associated function. */
+    let out = D::digest(input);
+    assert_eq!(out.as_slice(), expected);
+
+    /* Streaming via Digest::update and finalize. */
+    let mut hasher = D::new();
+    Digest::update(&mut hasher, input);
+    let out = hasher.finalize();
+    assert_eq!(out.as_slice(), expected);
+
+    /* Split update via Default + Update + FixedOutputReset::finalize_reset. */
+    let mut hasher = D::default();
+    if input.len() >= 2 {
+        let mid = input.len() / 2;
+        Digest::update(&mut hasher, &input[..mid]);
+        Digest::update(&mut hasher, &input[mid..]);
+    } else {
+        Digest::update(&mut hasher, input);
+    }
+    let out = hasher.finalize_reset();
+    assert_eq!(out.as_slice(), expected);
+
+    /* After reset, the same hasher should produce the same result. */
+    Digest::update(&mut hasher, input);
+    let out = hasher.finalize();
+    assert_eq!(out.as_slice(), expected);
+}
+
+#[test]
+#[cfg(blake2b)]
+fn test_digest_blake2b_512() {
+    use wolfssl_wolfcrypt::blake2_digest::Blake2b512;
+    common::setup();
+    check_digest::<Blake2b512>(
+        b"abc",
+        b"\xBA\x80\xA5\x3F\x98\x1C\x4D\x0D\x6A\x27\x97\xB6\x9F\x12\xF6\xE9\x4C\x21\x2F\x14\x68\x5A\xC4\xB7\x4B\x12\xBB\x6F\xDB\xFF\xA2\xD1\x7D\x87\xC5\x39\x2A\xAB\x79\x2D\xC2\x52\xD5\xDE\x45\x33\xCC\x95\x18\xD3\x8A\xA8\xDB\xF1\x92\x5A\xB9\x23\x86\xED\xD4\x00\x99\x23",
+        128,
+    );
+}
+
+#[test]
+#[cfg(blake2b)]
+fn test_digest_blake2b_384() {
+    use wolfssl_wolfcrypt::blake2::BLAKE2b;
+    use wolfssl_wolfcrypt::blake2_digest::Blake2b384;
+    common::setup();
+
+    let mut reference = BLAKE2b::new(48).expect("Error with new()");
+    reference.update(b"abc").expect("Error with update()");
+    let mut expected = [0u8; 48];
+    reference.finalize(&mut expected).expect("Error with finalize()");
+
+    check_digest::<Blake2b384>(b"abc", &expected, 128);
+}
+
+#[test]
+#[cfg(blake2b)]
+fn test_digest_blake2b_256() {
+    use wolfssl_wolfcrypt::blake2::BLAKE2b;
+    use wolfssl_wolfcrypt::blake2_digest::Blake2b256;
+    common::setup();
+
+    let mut reference = BLAKE2b::new(32).expect("Error with new()");
+    reference.update(b"abc").expect("Error with update()");
+    let mut expected = [0u8; 32];
+    reference.finalize(&mut expected).expect("Error with finalize()");
+
+    check_digest::<Blake2b256>(b"abc", &expected, 128);
+}
+
+#[test]
+#[cfg(blake2s)]
+fn test_digest_blake2s_256() {
+    use wolfssl_wolfcrypt::blake2_digest::Blake2s256;
+    common::setup();
+    check_digest::<Blake2s256>(
+        b"abc",
+        b"\x50\x8C\x5E\x8C\x32\x7C\x14\xE2\xE1\xA7\x2B\xA3\x4E\xEB\x45\x2F\x37\x45\x8B\x20\x9E\xD6\x3A\x29\x4D\x99\x9B\x4C\x86\x67\x59\x82",
+        64,
+    );
+}
+
+#[test]
+#[cfg(blake2s)]
+fn test_digest_blake2s_192() {
+    use wolfssl_wolfcrypt::blake2::BLAKE2s;
+    use wolfssl_wolfcrypt::blake2_digest::Blake2s192;
+    common::setup();
+
+    let mut reference = BLAKE2s::new(24).expect("Error with new()");
+    reference.update(b"abc").expect("Error with update()");
+    let mut expected = [0u8; 24];
+    reference.finalize(&mut expected).expect("Error with finalize()");
+
+    check_digest::<Blake2s192>(b"abc", &expected, 64);
+}
+
+#[test]
+#[cfg(blake2s)]
+fn test_digest_blake2s_128() {
+    use wolfssl_wolfcrypt::blake2::BLAKE2s;
+    use wolfssl_wolfcrypt::blake2_digest::Blake2s128;
+    common::setup();
+
+    let mut reference = BLAKE2s::new(16).expect("Error with new()");
+    reference.update(b"abc").expect("Error with update()");
+    let mut expected = [0u8; 16];
+    reference.finalize(&mut expected).expect("Error with finalize()");
+
+    check_digest::<Blake2s128>(b"abc", &expected, 64);
+}