tweak code

Author: newpavlov

sponge-cursor/src/lib.rs

@@ -107,7 +107,7 @@ impl<const RATE: usize> SpongeCursor<RATE> {
                 head
             };
 
-            utils::xor_into_state::<N, RATE>(state, pos, head);
+            utils::absorb_partial::<N, RATE>(state, pos, head);
 
             if is_partial {
                 self.pos = u8::try_from(pos + head.len()).expect("the sum is smaller than Rate");
@@ -121,19 +121,13 @@ impl<const RATE: usize> SpongeCursor<RATE> {
         let tail = blocks.remainder();
 
         for block in blocks {
-            let chunks = block.chunks_exact(size_of::<u64>());
-            assert!(chunks.remainder().is_empty());
-
-            for (dst, chunk) in state.iter_mut().zip(chunks) {
-                let chunk = chunk.try_into().expect("chunk has correct length");
-                *dst ^= u64::from_le_bytes(chunk);
-            }
-
+            let block: &[u8; RATE] = block.try_into().expect("block has correct size");
+            utils::absorb_full(state, block);
             sponge(state);
         }
 
         if !tail.is_empty() {
-            utils::xor_into_state::<N, RATE>(state, 0, tail);
+            utils::absorb_partial::<N, RATE>(state, 0, tail);
         }
 
         self.pos = u8::try_from(tail.len()).expect("tail.len() is smaller than RATE");
@@ -171,6 +165,7 @@ impl<const RATE: usize> SpongeCursor<RATE> {
         );
     }
 
+    #[inline(always)]
     fn squeeze_inner_u64_le<const N: usize>(
         &mut self,
         state: &mut [u64; N],

sponge-cursor/src/utils.rs

@@ -1,5 +1,29 @@
+//! Utility functions.
+//!
+//! Note that support of big-endian targets is somewhat sub-optimal since we prioritized
+//! simplicity of the implementation.
+
+#[inline(always)]
+pub(crate) fn absorb_full<const N: usize, const RATE: usize>(
+    state: &mut [u64; N],
+    block: &[u8; RATE],
+) {
+    const {
+        assert!(size_of::<[u8; RATE]>() <= size_of::<[u64; N]>());
+        assert!(RATE % size_of::<u64>() == 0);
+    };
+
+    let chunks = block.chunks_exact(size_of::<u64>());
+    assert!(chunks.remainder().is_empty());
+
+    for (dst, chunk) in state.iter_mut().zip(chunks) {
+        let chunk = chunk.try_into().expect("chunk has correct length");
+        *dst ^= u64::from_le_bytes(chunk);
+    }
+}
+
 #[inline(always)]
-pub(crate) fn xor_into_state<const N: usize, const RATE: usize>(
+pub(crate) fn absorb_partial<const N: usize, const RATE: usize>(
     state: &mut [u64; N],
     offset: usize,
     data: &[u8],
@@ -61,22 +85,20 @@ pub(crate) fn squeeze_read_partial<const N: usize, const RATE: usize>(
         assert!(RATE % size_of::<u64>() == 0);
     };
 
-    let (sub_state, mut buf);
-    if cfg!(target_endian = "little") {
+    let mut buf = [0u8; RATE];
+
+    let sub_state: &[u8; RATE] = if cfg!(target_endian = "little") {
         // SAFETY: casting of `&[u64; N]` into `&[u8; M]` is safe if
         // `size_of::<[u8; M]>() <= size_of::<[u64; N]>())`
-        sub_state = unsafe { &*(state.as_ptr().cast::<[u8; RATE]>()) };
+        unsafe { &*(state.as_ptr().cast::<[u8; RATE]>()) }
     } else {
-        buf = [0u8; RATE];
-
         let mut chunks = buf.chunks_exact_mut(size_of::<u64>());
         for (src, dst) in state.iter().zip(&mut chunks) {
             dst.copy_from_slice(&src.to_le_bytes());
         }
         assert!(chunks.into_remainder().is_empty());
-
-        sub_state = &buf;
-    }
+        &buf
+    };
 
     let src = &sub_state[offset..][..dst.len()];
     dst.copy_from_slice(src);
@@ -112,22 +134,20 @@ pub(crate) fn squeeze_xor_partial<const N: usize, const RATE: usize>(
         assert!(RATE % size_of::<u64>() == 0);
     };
 
-    let (sub_state, mut buf);
-    if cfg!(target_endian = "little") {
+    let mut buf = [0u8; RATE];
+
+    let sub_state: &[u8; RATE] = if cfg!(target_endian = "little") {
         // SAFETY: casting of `&[u64; N]` into `&[u8; M]` is safe if
         // `size_of::<[u8; M]>() <= size_of::<[u64; N]>())`
-        sub_state = unsafe { &*(state.as_ptr().cast::<[u8; RATE]>()) };
+        unsafe { &*(state.as_ptr().cast::<[u8; RATE]>()) }
     } else {
-        buf = [0u8; RATE];
-
         let mut chunks = buf.chunks_exact_mut(size_of::<u64>());
         for (src, dst) in state.iter().zip(&mut chunks) {
             dst.copy_from_slice(&src.to_le_bytes());
         }
         assert!(chunks.into_remainder().is_empty());
-
-        sub_state = &buf;
-    }
+        &buf
+    };
 
     let src = &sub_state[offset..][..dst.len()];
     for i in 0..dst.len() {