add block-level API, remove the dirty traits, reorganize code

Author: newpavlov

Cargo.lock

@@ -14,11 +14,13 @@ categories = ["cryptography", "no-std"]
 [dependencies]
 generic-array = "0.14"
 blobby = { version = "0.2", optional = true }
+block-buffer = { version = "0.9", optional = true }
 
 [features]
 alloc = []
 std = ["alloc"]
 dev = ["blobby"]
+core-api = ["block-buffer"]
 
 [package.metadata.docs.rs]
 all-features = true

digest/Cargo.toml

@@ -0,0 +1,138 @@
+use crate::{ExtendableOutput, FixedOutput, Reset, Update, XofReader};
+use block_buffer::BlockBuffer;
+use generic_array::{ArrayLength, GenericArray};
+
+/// Trait for updating hasher state with input data divided into blocks.
+pub trait UpdateCore {
+    /// Block size.
+    type BlockSize: ArrayLength<u8>;
+
+    /// Update the hasher state using the provided data.
+    fn update_blocks(&mut self, blocks: &[GenericArray<u8, Self::BlockSize>]);
+}
+
+/// Trait for fixed-output digest implementations to use to retrieve the
+/// hash output.
+///
+/// Usage of this trait in user code is discouraged. Instead use core algorithm
+/// wrapped by [`crate::CoreWrapper`], which implements the [`FixedOutput`]
+/// trait.
+pub trait FixedOutputCore: crate::UpdateCore {
+    /// Digest output size.
+    type OutputSize: ArrayLength<u8>;
+
+    /// Retrieve result into provided buffer using remaining data stored
+    /// in the block buffer and leave hasher in a dirty state.
+    ///
+    /// This method is expected to only be called once unless [`Reset::reset`]
+    /// is called, after which point it can be called again and reset again
+    /// (and so on).
+    fn finalize_fixed_core(
+        &mut self,
+        buffer: &mut block_buffer::BlockBuffer<Self::BlockSize>,
+        out: &mut GenericArray<u8, Self::OutputSize>,
+    );
+}
+
+/// Trait for extendable-output function (XOF) core implementations to use to
+/// retrieve the hash output.
+///
+/// Usage of this trait in user code is discouraged. Instead use core algorithm
+/// wrapped by [`crate::CoreWrapper`], which implements the
+/// [`ExtendableOutput`] trait.
+#[cfg(feature = "core-api")]
+pub trait ExtendableOutputCore: crate::UpdateCore {
+    /// XOF reader.
+    type Reader: XofReader;
+
+    /// Retrieve XOF reader using remaining data stored in the block buffer
+    /// and leave hasher in a dirty state.
+    ///
+    /// This method is expected to only be called once unless [`Reset::reset`]
+    /// is called, after which point it can be called again and reset again
+    /// (and so on).
+    fn finalize_xof_core(
+        &mut self,
+        buffer: &mut block_buffer::BlockBuffer<Self::BlockSize>,
+    ) -> Self::Reader;
+}
+
+/// Wrapper around core trait implementations.
+///
+/// It handles data buffering and implements the mid-level traits.
+#[derive(Clone, Default)]
+pub struct CoreWrapper<D: UpdateCore> {
+    core: D,
+    buffer: BlockBuffer<D::BlockSize>,
+}
+
+impl<D: Reset + UpdateCore> Reset for CoreWrapper<D> {
+    #[inline]
+    fn reset(&mut self) {
+        self.core.reset();
+        self.buffer.reset();
+    }
+}
+
+impl<D: UpdateCore> Update for CoreWrapper<D> {
+    #[inline]
+    fn update(&mut self, input: &[u8]) {
+        let Self { core, buffer } = self;
+        buffer.input_blocks(input, |blocks| core.update_blocks(blocks));
+    }
+}
+
+impl<D: FixedOutputCore + Reset> FixedOutput for CoreWrapper<D> {
+    type OutputSize = D::OutputSize;
+
+    #[inline]
+    fn finalize_into(self, out: &mut GenericArray<u8, Self::OutputSize>) {
+        let Self {
+            mut core,
+            mut buffer,
+        } = self;
+        core.finalize_fixed_core(&mut buffer, out);
+    }
+
+    #[inline]
+    fn finalize_into_reset(&mut self, out: &mut GenericArray<u8, Self::OutputSize>) {
+        let Self { core, buffer } = self;
+        core.finalize_fixed_core(buffer, out);
+        self.reset();
+    }
+}
+
+impl<D: ExtendableOutputCore + Reset> ExtendableOutput for CoreWrapper<D> {
+    type Reader = D::Reader;
+
+    #[inline]
+    fn finalize_xof(self) -> Self::Reader {
+        let Self {
+            mut core,
+            mut buffer,
+        } = self;
+        core.finalize_xof_core(&mut buffer)
+    }
+
+    #[inline]
+    fn finalize_xof_reset(&mut self) -> Self::Reader {
+        let Self { core, buffer } = self;
+        let reader = core.finalize_xof_core(buffer);
+        self.reset();
+        reader
+    }
+}
+
+#[cfg(feature = "std")]
+impl<D: UpdateCore> std::io::Write for CoreWrapper<D> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        Update::update(self, buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}

digest/src/core_api.rs

@@ -2,7 +2,7 @@
 
 pub use blobby;
 
-use super::{ExtendableOutput, Reset, Update, VariableOutput, XofReader};
+use super::{ExtendableOutput, Reset, Update, XofReader};
 use core::fmt::Debug;
 
 /// Define test
@@ -165,56 +165,6 @@ where
     None
 }
 
-/// Variable-output digest test
-pub fn variable_test<D>(input: &[u8], output: &[u8]) -> Option<&'static str>
-where
-    D: Update + VariableOutput + Reset + Debug + Clone,
-{
-    let mut hasher = D::new(output.len()).unwrap();
-    let mut buf = [0u8; 128];
-    let buf = &mut buf[..output.len()];
-    // Test that it works when accepting the message all at once
-    hasher.update(input);
-    let mut hasher2 = hasher.clone();
-    hasher.finalize_variable(|res| buf.copy_from_slice(res));
-    if buf != output {
-        return Some("whole message");
-    }
-
-    // Test if reset works correctly
-    hasher2.reset();
-    hasher2.update(input);
-    hasher2.finalize_variable(|res| buf.copy_from_slice(res));
-    if buf != output {
-        return Some("whole message after reset");
-    }
-
-    // Test that it works when accepting the message in pieces
-    let mut hasher = D::new(output.len()).unwrap();
-    let len = input.len();
-    let mut left = len;
-    while left > 0 {
-        let take = (left + 1) / 2;
-        hasher.update(&input[len - left..take + len - left]);
-        left -= take;
-    }
-    hasher.finalize_variable(|res| buf.copy_from_slice(res));
-    if buf != output {
-        return Some("message in pieces");
-    }
-
-    // Test processing byte-by-byte
-    let mut hasher = D::new(output.len()).unwrap();
-    for chunk in input.chunks(1) {
-        hasher.update(chunk)
-    }
-    hasher.finalize_variable(|res| buf.copy_from_slice(res));
-    if buf != output {
-        return Some("message byte-by-byte");
-    }
-    None
-}
-
 /// Define benchmark
 #[macro_export]
 #[cfg_attr(docsrs, doc(cfg(feature = "dev")))]

digest/src/dev.rs

@@ -52,39 +52,48 @@ pub trait Digest {
 impl<D: Update + FixedOutput + Reset + Clone + Default> Digest for D {
     type OutputSize = <Self as FixedOutput>::OutputSize;
 
+    #[inline]
     fn new() -> Self {
         Self::default()
     }
 
+    #[inline]
     fn update(&mut self, data: impl AsRef<[u8]>) {
-        Update::update(self, data);
+        Update::update(self, data.as_ref());
     }
 
-    fn chain(self, data: impl AsRef<[u8]>) -> Self
+    #[inline]
+    fn chain(mut self, data: impl AsRef<[u8]>) -> Self
     where
         Self: Sized,
     {
-        Update::chain(self, data)
+        Update::update(&mut self, data.as_ref());
+        self
     }
 
+    #[inline]
     fn finalize(self) -> Output<Self> {
         self.finalize_fixed()
     }
 
+    #[inline]
     fn finalize_reset(&mut self) -> Output<Self> {
         let res = self.clone().finalize_fixed();
         self.reset();
         res
     }
 
+    #[inline]
     fn reset(&mut self) {
-        <Self as Reset>::reset(self)
+        Reset::reset(self)
     }
 
+    #[inline]
     fn output_size() -> usize {
         Self::OutputSize::to_usize()
     }
 
+    #[inline]
     fn digest(data: &[u8]) -> Output<Self> {
         let mut hasher = Self::default();
         Update::update(&mut hasher, data);

digest/src/digest.rs

@@ -35,9 +35,7 @@ impl<D: Update + FixedOutput + Reset + Clone + 'static> DynDigest for D {
     }
 
     fn finalize_reset(&mut self) -> Box<[u8]> {
-        let res = self.finalize_fixed_reset().to_vec().into_boxed_slice();
-        Reset::reset(self);
-        res
+        self.finalize_fixed_reset().to_vec().into_boxed_slice()
     }
 
     fn finalize(self: Box<Self>) -> Box<[u8]> {