digest: add buffering macros

digest/README.md

@@ -64,25 +64,6 @@ let hash = Sha256::digest(b"my message");
 println!("Result: {:x}", hash);
 ```
 
-### Hashing `Read`-able objects
-
-If you want to hash data from [`Read`][3] trait (e.g. from file) you can rely on
-implementation of [`Write`][4] trait (requires enabled-by-default `std` feature):
-
-```rust
-use sha2::{Sha256, Digest};
-use std::{fs, io};
-
-let mut file = fs::File::open(&path)?;
-let mut hasher = Sha256::new();
-let n = io::copy(&mut file, &mut hasher)?;
-let hash = hasher.finalize();
-
-println!("Path: {}", path);
-println!("Bytes processed: {}", n);
-println!("Hash value: {:x}", hash);
-```
-
 ### Generic code
 
 You can write generic code over `Digest` (or other traits from `digest` crate)

digest/src/buffer_macros.rs

@@ -0,0 +1,4 @@
+mod fixed;
+mod variable_ct;
+mod variable_rt;
+mod xof;

digest/src/buffer_macros/fixed.rs

@@ -0,0 +1,330 @@
+/// Creates a buffered wrapper around block-level "core" type which implements fixed output size traits.
+#[macro_export]
+macro_rules! buffer_fixed {
+    (
+        $(#[$attr:meta])*
+        $v:vis struct $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        impl: $($trait_name:ident)*;
+    ) => {
+        $(#[$attr])*
+        $v struct $name$(<$gp: $bound>)? {
+            core: $core_ty,
+            buffer: $crate::core_api::Buffer<$core_ty>,
+        }
+
+        $crate::buffer_fixed!(
+            impl_inner: $name$(<$gp: $bound>)?($core_ty);
+            $($trait_name)*;
+        );
+    };
+
+    (
+        $(#[$attr:meta])*
+        $v:vis struct $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        oid: $oid:literal;
+        impl: $($trait_name:ident)*;
+    ) => {
+        $crate::buffer_fixed!(
+            $(#[$attr])*
+            $v struct $name$(<$gp: $bound>)?($core_ty);
+            impl: $($trait_name)*;
+        );
+
+        #[cfg(feature = "oid")]
+        impl$(<$gp: $bound>)? $crate::const_oid::AssociatedOid for $name$(<$gp>)? {
+            const OID: $crate::const_oid::ObjectIdentifier =
+                $crate::const_oid::ObjectIdentifier::new_unwrap($oid);
+        }
+    };
+
+    // Terminates `impl_inner` sequences.
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty); ;
+    ) => {};
+
+    // Implements the set of traits common for fixed output hashes:
+    // `Default`, `Clone`, `HashMarker`, `Reset`, `FixedOutputReset`, `SerializableState`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        FixedHashTraits $($trait_name:ident)*;
+    ) => {
+        $crate::buffer_fixed!(
+            impl_inner: $name$(<$gp: $bound>)?($core_ty);
+            BaseFixedTraits Default Clone HashMarker Reset FixedOutputReset SerializableState $($trait_name)*;
+        );
+    };
+
+    // Implements basic fixed traits:
+    // `Debug`, `AlgorithmName`, `BlockSizeUser`, `OutputSizeUser`,
+    // `CoreProxy`, `Update`, and `FixedOutput`.
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        BaseFixedTraits $($trait_name:ident)*;
+    ) => {
+        $crate::buffer_fixed!(
+            impl_inner: $name$(<$gp: $bound>)?($core_ty);
+            Debug AlgorithmName BlockSizeUser OutputSizeUser CoreProxy Update FixedOutput $($trait_name)*;
+        );
+    };
+
+    // Implements `Debug`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        Debug $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? core::fmt::Debug for $name$(<$gp>)? {
+            #[inline]
+            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                f.write_str(concat!(stringify!($name), " { ... }"))
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `AlgorithmName`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        AlgorithmName $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::crypto_common::AlgorithmName for $name$(<$gp>)? {
+            #[inline]
+            fn write_alg_name(f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+                <$core_ty as $crate::crypto_common::AlgorithmName>::write_alg_name(f)
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `BlockSizeUser`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        BlockSizeUser $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::core_api::BlockSizeUser for $name$(<$gp>)? {
+            type BlockSize = <$core_ty as $crate::crypto_common::BlockSizeUser>::BlockSize;
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `OutputSizeUser`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        OutputSizeUser $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::OutputSizeUser for $name$(<$gp>)? {
+            type OutputSize = <$core_ty as $crate::core_api::OutputSizeUser>::OutputSize;
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `CoreProxy`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        CoreProxy $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::core_api::CoreProxy for $name$(<$gp>)? {
+            type Core = $core_ty;
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `Update`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        Update $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::Update for $name$(<$gp>)? {
+            #[inline]
+            fn update(&mut self, data: &[u8]) {
+                let Self { core, buffer } = self;
+                buffer.digest_blocks(data, |blocks| {
+                    $crate::core_api::UpdateCore::update_blocks(core, blocks)
+                });
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `FixedOutput`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        FixedOutput $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::FixedOutput for $name$(<$gp>)? {
+            #[inline]
+            fn finalize_into(mut self, out: &mut $crate::Output<Self>) {
+                let Self { core, buffer } = &mut self;
+                $crate::core_api::FixedOutputCore::finalize_fixed_core(core, buffer, out);
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `Default`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        Default $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? Default for $name$(<$gp>)? {
+            #[inline]
+            fn default() -> Self {
+                Self {
+                    core: Default::default(),
+                    buffer: Default::default(),
+                }
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `CustomizedInit`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        CustomizedInit $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::CustomizedInit for $name$(<$gp>)? {
+            #[inline]
+            fn new_customized(customization: &[u8]) -> Self {
+                Self {
+                    core: $crate::CustomizedInit::new_customized(customization),
+                    buffer: Default::default(),
+                }
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `Clone`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        Clone $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? Clone for $name$(<$gp>)? {
+            #[inline]
+            fn clone(&self) -> Self {
+                Self {
+                    core: Clone::clone(&self.core),
+                    buffer: Clone::clone(&self.buffer),
+                }
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `HashMarker` and asserts that `$core_ty` implements it
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        HashMarker $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::HashMarker for $name$(<$gp>)? {}
+
+        // Verify that `$core_ty` implements `HashMarker`
+        const _: () = {
+            fn check$(<$gp: $bound>)?(v: &$core_ty) {
+                v as &dyn $crate::HashMarker;
+            }
+        };
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `Reset`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        Reset $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::Reset for $name$(<$gp>)? {
+            #[inline]
+            fn reset(&mut self) {
+                $crate::Reset::reset(&mut self.core);
+                self.buffer.reset();
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `FixedOutputReset`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        FixedOutputReset $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::FixedOutputReset for $name$(<$gp>)? {
+            #[inline]
+            fn finalize_into_reset(&mut self, out: &mut $crate::Output<Self>) {
+                let Self { core, buffer } = self;
+                $crate::core_api::FixedOutputCore::finalize_fixed_core(core, buffer, out);
+                $crate::Reset::reset(self);
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    };
+
+    // Implements `SerializableState`
+    (
+        impl_inner: $name:ident$(<$gp:ident: $bound:ident>)?($core_ty:ty);
+        SerializableState $($trait_name:ident)*;
+    ) => {
+        impl$(<$gp: $bound>)? $crate::crypto_common::hazmat::SerializableState for $name$(<$gp>)? {
+            type SerializedStateSize = $crate::typenum::Sum<
+                <$core_ty as $crate::crypto_common::hazmat::SerializableState>::SerializedStateSize,
+                $crate::typenum::Add1<
+                    <$core_ty as $crate::core_api::BlockSizeUser>::BlockSize
+                >
+            >;
+
+            #[inline]
+            fn serialize(&self) -> $crate::crypto_common::hazmat::SerializedState<Self> {
+                use $crate::{
+                    array::Array,
+                    consts::U1,
+                    block_buffer::BlockBuffer,
+                    crypto_common::hazmat::SerializableState,
+                };
+
+                let serialized_core = self.core.serialize();
+                let pos = u8::try_from(self.buffer.get_pos()).unwrap();
+                let serialized_pos: Array<u8, U1> = Array([pos]);
+                let serialized_data = self.buffer.clone().pad_with_zeros();
+
+                serialized_core
+                    .concat(serialized_pos)
+                    .concat(serialized_data)
+            }
+
+            #[inline]
+            fn deserialize(
+                serialized_state: &$crate::crypto_common::hazmat::SerializedState<Self>,
+            ) -> Result<Self, $crate::crypto_common::hazmat::DeserializeStateError> {
+                use $crate::{
+                    block_buffer::BlockBuffer,
+                    consts::U1,
+                    crypto_common::hazmat::{SerializableState, DeserializeStateError},
+                };
+
+                let (serialized_core, remaining_buffer) = serialized_state
+                    .split_ref::<<$core_ty as SerializableState>::SerializedStateSize>();
+                let (serialized_pos, serialized_data) = remaining_buffer.split_ref::<U1>();
+
+                Ok(Self {
+                    core: <$core_ty as SerializableState>::deserialize(serialized_core)?,
+                    buffer: BlockBuffer::try_new(&serialized_data[..serialized_pos[0].into()])
+                        .map_err(|_| DeserializeStateError)?,
+                })
+            }
+        }
+
+        $crate::buffer_fixed!(impl_inner: $name$(<$gp: $bound>)?($core_ty); $($trait_name)*;);
+    }
+}