migrate k12

Author: newpavlov

Cargo.lock

@@ -13,11 +13,12 @@ categories = ["cryptography", "no-std"]
 description = "Implementation of the KangarooTwelve family of extendable-output functions"
 
 [dependencies]
-digest = "0.11"
+digest = { version = "0.11", default-features = false }
 keccak = { version = "0.2", features = ["parallel"] }
+sponge-cursor = "0.1"
 
 [dev-dependencies]
-digest = { version = "0.11", features = ["alloc", "dev"] }
+digest = { version = "0.11", default-features = false, features = ["alloc", "dev"] }
 hex-literal = "1"
 
 [features]

k12/Cargo.toml

@@ -1,7 +1,7 @@
 use core::fmt;
 use digest::{
     CollisionResistance, ExtendableOutput, ExtendableOutputReset, HashMarker, Reset, Update,
-    block_buffer::BlockSizes,
+    array::ArraySize,
     common::{AlgorithmName, BlockSizeUser},
     consts::{U16, U32, U136, U168},
 };
@@ -10,12 +10,12 @@ use crate::{Kt, KtReader, utils::length_encode};
 
 /// Customized KangarooTwelve hasher generic over rate with borrrowed customization string.
 #[derive(Clone)]
-pub struct CustomRefKt<'a, Rate: BlockSizes> {
+pub struct CustomRefKt<'a, Rate: ArraySize> {
     customization: &'a [u8],
     inner: Kt<Rate>,
 }
 
-impl<'a, Rate: BlockSizes> CustomRefKt<'a, Rate> {
+impl<'a, Rate: ArraySize> CustomRefKt<'a, Rate> {
     /// Create new customized KangarooTwelve hasher with borrrowed customization string.
     ///
     /// Note that this is an inherent method and `CustomRefKt` does not implement
@@ -29,56 +29,56 @@ impl<'a, Rate: BlockSizes> CustomRefKt<'a, Rate> {
     }
 }
 
-impl<Rate: BlockSizes> Default for CustomRefKt<'static, Rate> {
+impl<Rate: ArraySize> Default for CustomRefKt<'static, Rate> {
     #[inline]
     fn default() -> Self {
         Self::new_customized(&[])
     }
 }
 
-impl<Rate: BlockSizes> fmt::Debug for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> fmt::Debug for CustomRefKt<'_, Rate> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         write!(f, "CustomKt{} {{ ... }}", 4 * (200 - Rate::USIZE))
     }
 }
 
-impl<Rate: BlockSizes> AlgorithmName for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> AlgorithmName for CustomRefKt<'_, Rate> {
     #[inline]
     fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Kt::<Rate>::write_alg_name(f)
     }
 }
 
-impl<Rate: BlockSizes> HashMarker for CustomRefKt<'_, Rate> {}
+impl<Rate: ArraySize> HashMarker for CustomRefKt<'_, Rate> {}
 
-impl<Rate: BlockSizes> BlockSizeUser for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> BlockSizeUser for CustomRefKt<'_, Rate> {
     type BlockSize = Rate;
 }
 
-impl<Rate: BlockSizes> Update for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> Update for CustomRefKt<'_, Rate> {
     #[inline]
     fn update(&mut self, data: &[u8]) {
         self.inner.update(data);
     }
 }
 
-impl<Rate: BlockSizes> Reset for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> Reset for CustomRefKt<'_, Rate> {
     #[inline]
     fn reset(&mut self) {
         self.inner.reset();
     }
 }
 
-impl<Rate: BlockSizes> CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> CustomRefKt<'_, Rate> {
     fn absorb_customization(&mut self) {
         self.inner.update(self.customization);
         let len = u64::try_from(self.customization.len()).expect("length always fits into `u64`");
         length_encode(len, |enc_len| self.inner.update(enc_len));
     }
 }
 
-impl<Rate: BlockSizes> ExtendableOutput for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> ExtendableOutput for CustomRefKt<'_, Rate> {
     type Reader = KtReader<Rate>;
 
     #[inline]
@@ -88,7 +88,7 @@ impl<Rate: BlockSizes> ExtendableOutput for CustomRefKt<'_, Rate> {
     }
 }
 
-impl<Rate: BlockSizes> ExtendableOutputReset for CustomRefKt<'_, Rate> {
+impl<Rate: ArraySize> ExtendableOutputReset for CustomRefKt<'_, Rate> {
     #[inline]
     fn finalize_xof_reset(&mut self) -> Self::Reader {
         self.absorb_customization();
@@ -100,7 +100,7 @@ impl<Rate: BlockSizes> ExtendableOutputReset for CustomRefKt<'_, Rate> {
 
 // `inner` is zeroized by `Drop` and `customization` can not be zeroized
 #[cfg(feature = "zeroize")]
-impl<Rate: BlockSizes> digest::zeroize::ZeroizeOnDrop for CustomRefKt<'_, Rate> {}
+impl<Rate: ArraySize> digest::zeroize::ZeroizeOnDrop for CustomRefKt<'_, Rate> {}
 
 /// Customized KT128 hasher with borrowed customization string.
 pub type CustomRefKt128<'a> = CustomRefKt<'a, U168>;

k12/src/custom/borrow.rs

@@ -5,7 +5,7 @@ use core::fmt;
 use digest::{
     CollisionResistance, CustomizedInit, ExtendableOutput, ExtendableOutputReset, HashMarker,
     Reset, Update,
-    block_buffer::BlockSizes,
+    array::ArraySize,
     common::{AlgorithmName, BlockSizeUser},
     consts::{U16, U32, U136, U168},
 };
@@ -14,12 +14,12 @@ use crate::{Kt, KtReader, utils::length_encode};
 
 /// Customized KangarooTwelve hasher generic over rate with owned customization string.
 #[derive(Clone)]
-pub struct CustomKt<Rate: BlockSizes> {
+pub struct CustomKt<Rate: ArraySize> {
     customization: Vec<u8>,
     inner: Kt<Rate>,
 }
 
-impl<Rate: BlockSizes> CustomizedInit for CustomKt<Rate> {
+impl<Rate: ArraySize> CustomizedInit for CustomKt<Rate> {
     #[inline]
     fn new_customized(customization: &[u8]) -> Self {
         let len = u64::try_from(customization.len()).expect("length should always fit into `u64`");
@@ -37,48 +37,48 @@ impl<Rate: BlockSizes> CustomizedInit for CustomKt<Rate> {
     }
 }
 
-impl<Rate: BlockSizes> Default for CustomKt<Rate> {
+impl<Rate: ArraySize> Default for CustomKt<Rate> {
     #[inline]
     fn default() -> Self {
         Self::new_customized(&[])
     }
 }
 
-impl<Rate: BlockSizes> fmt::Debug for CustomKt<Rate> {
+impl<Rate: ArraySize> fmt::Debug for CustomKt<Rate> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         write!(f, "CustomKt{} {{ ... }}", 4 * (200 - Rate::USIZE))
     }
 }
 
-impl<Rate: BlockSizes> AlgorithmName for CustomKt<Rate> {
+impl<Rate: ArraySize> AlgorithmName for CustomKt<Rate> {
     #[inline]
     fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Kt::<Rate>::write_alg_name(f)
     }
 }
 
-impl<Rate: BlockSizes> HashMarker for CustomKt<Rate> {}
+impl<Rate: ArraySize> HashMarker for CustomKt<Rate> {}
 
-impl<Rate: BlockSizes> BlockSizeUser for CustomKt<Rate> {
+impl<Rate: ArraySize> BlockSizeUser for CustomKt<Rate> {
     type BlockSize = Rate;
 }
 
-impl<Rate: BlockSizes> Update for CustomKt<Rate> {
+impl<Rate: ArraySize> Update for CustomKt<Rate> {
     #[inline]
     fn update(&mut self, data: &[u8]) {
         self.inner.update(data);
     }
 }
 
-impl<Rate: BlockSizes> Reset for CustomKt<Rate> {
+impl<Rate: ArraySize> Reset for CustomKt<Rate> {
     #[inline]
     fn reset(&mut self) {
         self.inner.reset();
     }
 }
 
-impl<Rate: BlockSizes> ExtendableOutput for CustomKt<Rate> {
+impl<Rate: ArraySize> ExtendableOutput for CustomKt<Rate> {
     type Reader = KtReader<Rate>;
 
     #[inline]
@@ -88,7 +88,7 @@ impl<Rate: BlockSizes> ExtendableOutput for CustomKt<Rate> {
     }
 }
 
-impl<Rate: BlockSizes> ExtendableOutputReset for CustomKt<Rate> {
+impl<Rate: ArraySize> ExtendableOutputReset for CustomKt<Rate> {
     #[inline]
     fn finalize_xof_reset(&mut self) -> Self::Reader {
         self.inner.update(&self.customization);
@@ -98,7 +98,7 @@ impl<Rate: BlockSizes> ExtendableOutputReset for CustomKt<Rate> {
     }
 }
 
-impl<Rate: BlockSizes> Drop for CustomKt<Rate> {
+impl<Rate: ArraySize> Drop for CustomKt<Rate> {
     #[inline]
     fn drop(&mut self) {
         #[cfg(feature = "zeroize")]
@@ -111,7 +111,7 @@ impl<Rate: BlockSizes> Drop for CustomKt<Rate> {
 }
 
 #[cfg(feature = "zeroize")]
-impl<Rate: BlockSizes> digest::zeroize::ZeroizeOnDrop for CustomKt<Rate> {}
+impl<Rate: ArraySize> digest::zeroize::ZeroizeOnDrop for CustomKt<Rate> {}
 
 /// Customized KT128 hasher with owned customization string.
 pub type CustomKt128 = CustomKt<U168>;