chore(deps): bump digest pin

digest doesn't provide `std` feature anymore

Author: baloo

Cargo.lock

@@ -11,3 +11,15 @@ members = [
 
 [profile.dev]
 opt-level = 2
+
+[patch.crates-io]
+# https://github.com/RustCrypto/traits/pull/1844
+crypto-common = { git = "https://github.com/baloo/traits.git", branch = "baloo/digest/newtype-bufferkinduser" }
+cipher        = { git = "https://github.com/baloo/traits.git", branch = "baloo/digest/newtype-bufferkinduser" }
+digest        = { git = "https://github.com/baloo/traits.git", branch = "baloo/digest/newtype-bufferkinduser" }
+
+streebog = { git = "https://github.com/RustCrypto/hashes.git", branch = "newtype" }
+md-5     = { git = "https://github.com/RustCrypto/hashes.git", branch = "newtype" }
+sha1     = { git = "https://github.com/RustCrypto/hashes.git", branch = "newtype" }
+sha2     = { git = "https://github.com/RustCrypto/hashes.git", branch = "newtype" }
+

Cargo.toml

@@ -22,7 +22,6 @@ digest = { version = "=0.11.0-pre.10", features = ["dev"] }
 hex-literal = "1"
 
 [features]
-std = ["digest/std"]
 zeroize = ["cipher/zeroize"]
 
 [package.metadata.docs.rs]

belt-mac/Cargo.toml

@@ -23,7 +23,6 @@ aes = "0.9.0-pre.3"
 des = "0.9.0-pre.3"
 
 [features]
-std = ["digest/std"]
 zeroize = ["cipher/zeroize"]
 
 [package.metadata.docs.rs]

cbc-mac/Cargo.toml

@@ -28,7 +28,6 @@ kuznyechik = "0.9.0-pre.3"
 magma = "0.10.0-pre.3"
 
 [features]
-std = ["digest/std"]
 zeroize = ["cipher/zeroize"]
 
 [package.metadata.docs.rs]

cmac/Cargo.toml

@@ -24,7 +24,7 @@ streebog = { version = "=0.11.0-pre.5", default-features = false }
 hex-literal = "1"
 
 [features]
-std = ["digest/std"]
+std = []
 reset = [] # Enable ability to reset HMAC instances
 
 [package.metadata.docs.rs]

hmac/Cargo.toml

@@ -103,7 +103,7 @@ use digest::{
 mod optim;
 mod simple;
 
-pub use optim::{EagerHash, Hmac, HmacCore};
+pub use optim::{EagerHash, Hmac};
 pub use simple::SimpleHmac;
 
 const IPAD: u8 = 0x36;

hmac/src/lib.rs

@@ -1,50 +1,35 @@
 use super::{IPAD, OPAD, get_der_key};
-use core::{fmt, slice};
+use core::fmt;
 use digest::{
-    HashMarker, InvalidLength, KeyInit, MacMarker, Output,
+    FixedOutput, HashMarker, InvalidLength, KeyInit, MacMarker, Output, Update,
     block_buffer::Eager,
-    core_api::{
-        AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, CoreWrapper, FixedOutputCore,
-        OutputSizeUser, UpdateCore,
-    },
+    core_api::{AlgorithmName, BlockSizeUser, BufferKindUser, OutputSizeUser},
     crypto_common::{Key, KeySizeUser},
 };
 
-/// Generic HMAC instance.
-pub type Hmac<D> = CoreWrapper<HmacCore<D>>;
+///// Generic HMAC instance.
+//pub type Hmac<D> = CoreWrapper<HmacCore<D>>;
 
 /// Trait implemented by eager hashes which expose their block-level core.
-pub trait EagerHash {
-    /// Block-level core type of the hash.
-    type Core: HashMarker
-        + UpdateCore
-        + FixedOutputCore
-        + BufferKindUser<BufferKind = Eager>
-        + Default
-        + Clone;
+pub trait EagerHash:
+    HashMarker + Update + FixedOutput + BufferKindUser<BufferKind = Eager> + Default + Clone
+{
 }
 
-impl<C> EagerHash for CoreWrapper<C>
-where
-    C: HashMarker
-        + UpdateCore
-        + FixedOutputCore
-        + BufferKindUser<BufferKind = Eager>
-        + Default
-        + Clone,
+impl<D> EagerHash for D where
+    D: HashMarker + Update + FixedOutput + BufferKindUser<BufferKind = Eager> + Default + Clone
 {
-    type Core = C;
 }
 
 /// Generic core HMAC instance, which operates over blocks.
-pub struct HmacCore<D: EagerHash> {
-    digest: D::Core,
-    opad_digest: D::Core,
+pub struct Hmac<D: EagerHash> {
+    digest: D,
+    opad_digest: D,
     #[cfg(feature = "reset")]
-    ipad_digest: D::Core,
+    ipad_digest: D,
 }
 
-impl<D: EagerHash> Clone for HmacCore<D> {
+impl<D: EagerHash> Clone for Hmac<D> {
     fn clone(&self) -> Self {
         Self {
             digest: self.digest.clone(),
@@ -55,45 +40,45 @@ impl<D: EagerHash> Clone for HmacCore<D> {
     }
 }
 
-impl<D: EagerHash> MacMarker for HmacCore<D> {}
+impl<D: EagerHash> MacMarker for Hmac<D> {}
 
-impl<D: EagerHash> BufferKindUser for HmacCore<D> {
+impl<D: EagerHash> BufferKindUser for Hmac<D> {
     type BufferKind = Eager;
 }
 
-impl<D: EagerHash> KeySizeUser for HmacCore<D> {
-    type KeySize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
+impl<D: EagerHash> KeySizeUser for Hmac<D> {
+    type KeySize = <D as BlockSizeUser>::BlockSize;
 }
 
-impl<D: EagerHash> BlockSizeUser for HmacCore<D> {
-    type BlockSize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
+impl<D: EagerHash> BlockSizeUser for Hmac<D> {
+    type BlockSize = <D as BlockSizeUser>::BlockSize;
 }
 
-impl<D: EagerHash> OutputSizeUser for HmacCore<D> {
-    type OutputSize = <<D as EagerHash>::Core as OutputSizeUser>::OutputSize;
+impl<D: EagerHash> OutputSizeUser for Hmac<D> {
+    type OutputSize = <D as OutputSizeUser>::OutputSize;
 }
 
-impl<D: EagerHash> KeyInit for HmacCore<D> {
+impl<D: EagerHash> KeyInit for Hmac<D> {
     #[inline(always)]
     fn new(key: &Key<Self>) -> Self {
         Self::new_from_slice(key.as_slice()).unwrap()
     }
 
     #[inline(always)]
     fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> {
-        let mut buf = get_der_key::<CoreWrapper<D::Core>>(key);
+        let mut buf = get_der_key::<D>(key);
         for b in buf.iter_mut() {
             *b ^= IPAD;
         }
-        let mut digest = D::Core::default();
-        digest.update_blocks(slice::from_ref(&buf));
+        let mut digest = D::default();
+        digest.update(buf.as_slice());
 
         for b in buf.iter_mut() {
             *b ^= IPAD ^ OPAD;
         }
 
-        let mut opad_digest = D::Core::default();
-        opad_digest.update_blocks(slice::from_ref(&buf));
+        let mut opad_digest = D::default();
+        opad_digest.update(buf.as_slice());
 
         Ok(Self {
             #[cfg(feature = "reset")]
@@ -104,57 +89,67 @@ impl<D: EagerHash> KeyInit for HmacCore<D> {
     }
 }
 
-impl<D: EagerHash> UpdateCore for HmacCore<D> {
+impl<D: EagerHash> Update for Hmac<D> {
     #[inline(always)]
-    fn update_blocks(&mut self, blocks: &[Block<Self>]) {
-        self.digest.update_blocks(blocks);
+    fn update(&mut self, data: &[u8]) {
+        self.digest.update(data);
     }
 }
 
-impl<D: EagerHash> FixedOutputCore for HmacCore<D> {
+impl<D: EagerHash> FixedOutput for Hmac<D> {
     #[inline(always)]
-    fn finalize_fixed_core(&mut self, buffer: &mut Buffer<Self>, out: &mut Output<Self>) {
-        let mut hash = Output::<D::Core>::default();
-        self.digest.finalize_fixed_core(buffer, &mut hash);
-        // finalize_fixed_core should reset the buffer as well, but
-        // to be extra safe we reset it explicitly again.
-        buffer.reset();
-        #[cfg(not(feature = "reset"))]
-        let h = &mut self.opad_digest;
-        #[cfg(feature = "reset")]
-        let mut h = self.opad_digest.clone();
-        buffer.digest_blocks(&hash, |b| h.update_blocks(b));
-        h.finalize_fixed_core(buffer, out);
+    fn finalize_into(self, out: &mut Output<Self>) {
+        let mut hash = Output::<D>::default();
+
+        let Self {
+            digest,
+            mut opad_digest,
+            ..
+        } = self;
+        digest.finalize_into(&mut hash);
+
+        opad_digest.update(&hash);
+        opad_digest.finalize_into(out);
     }
 }
 
 #[cfg(feature = "reset")]
 #[cfg_attr(docsrs, doc(cfg(feature = "reset")))]
-impl<D: EagerHash> digest::Reset for HmacCore<D> {
+impl<D: EagerHash> digest::Reset for Hmac<D> {
     #[inline(always)]
     fn reset(&mut self) {
         self.digest = self.ipad_digest.clone();
     }
 }
 
-impl<D: EagerHash> AlgorithmName for HmacCore<D>
+#[cfg(feature = "reset")]
+#[cfg_attr(docsrs, doc(cfg(feature = "reset")))]
+impl<D: EagerHash> digest::FixedOutputReset for Hmac<D> {
+    #[inline(always)]
+    fn finalize_into_reset(&mut self, out: &mut Output<Self>) {
+        self.clone().finalize_into(out);
+        <Self as digest::Reset>::reset(self);
+    }
+}
+
+impl<D: EagerHash> AlgorithmName for Hmac<D>
 where
-    D::Core: AlgorithmName,
+    D: AlgorithmName,
 {
     fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("Hmac<")?;
-        <D::Core as AlgorithmName>::write_alg_name(f)?;
+        <D as AlgorithmName>::write_alg_name(f)?;
         f.write_str(">")
     }
 }
 
-impl<D: EagerHash> fmt::Debug for HmacCore<D>
+impl<D: EagerHash> fmt::Debug for Hmac<D>
 where
-    D::Core: AlgorithmName,
+    D: AlgorithmName,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("HmacCore<")?;
-        <D::Core as AlgorithmName>::write_alg_name(f)?;
+        f.write_str("Hmac<")?;
+        <D as AlgorithmName>::write_alg_name(f)?;
         f.write_str("> { ... }")
     }
 }

hmac/src/optim.rs

@@ -2,7 +2,7 @@
 use digest::new_mac_test as test;
 #[cfg(feature = "reset")]
 use digest::new_resettable_mac_test as test;
-use hmac::{Hmac, HmacCore, SimpleHmac};
+use hmac::{Hmac, /* HmacCore,*/ SimpleHmac};
 use sha1::Sha1;
 use sha2::{Sha224, Sha256, Sha384, Sha512};
 use streebog::{Streebog256, Streebog512};
@@ -12,7 +12,7 @@ fn test_debug_impls() {
     fn needs_debug<T: std::fmt::Debug>() {}
 
     needs_debug::<Hmac<Sha256>>();
-    needs_debug::<HmacCore<Sha256>>();
+    //needs_debug::<HmacCore<Sha256>>();
     needs_debug::<SimpleHmac<Sha256>>();
 }
 

hmac/tests/mod.rs

@@ -22,7 +22,7 @@ aes = "0.9.0-pre.3"
 digest = { version = "=0.11.0-pre.10", features = ["dev"] }
 
 [features]
-std = ["digest/std"]
+std = []
 zeroize = ["cipher/zeroize"]
 
 [package.metadata.docs.rs]