Fix clippy and rustfmt errors in kmac submission

Author: hoxxep

kmac/benches/mod.rs

@@ -1,9 +1,9 @@
 #![feature(test)]
 extern crate test;
 
+use core::hint::black_box;
 use kmac::{KeyInit, Kmac128, Kmac256, Mac};
 use test::Bencher;
-use core::hint::black_box;
 
 #[macro_export]
 macro_rules! bench_full {
@@ -58,4 +58,4 @@ digest::bench_update!(
     kmac256_update_100 100;
     kmac256_update_1000 1000;
     kmac256_update_10000 10000;
-);
+);

kmac/src/encoding.rs

@@ -3,8 +3,7 @@
 #[inline(always)]
 pub(crate) fn num_encoding_size(num: u64) -> usize {
     let bits = 64 - (num | 1).leading_zeros() as usize;
-    let len = (bits + 7) / 8;
-    len
+    bits.div_ceil(8)
 }
 
 #[inline(always)]
@@ -55,7 +54,13 @@ mod tests {
         ];
 
         for &(num, expected_size) in &test_cases {
-            assert_eq!(num_encoding_size(num), expected_size, "num_encoding_size({}) should return {}", num, expected_size);
+            assert_eq!(
+                num_encoding_size(num),
+                expected_size,
+                "num_encoding_size({}) should return {}",
+                num,
+                expected_size
+            );
         }
     }
 
@@ -88,9 +93,10 @@ mod tests {
 
         for i in 0..usize::BITS {
             let x: usize = 1 << i;
-            let mut want = std::vec::Vec::from_iter(x.to_be_bytes().iter().copied().skip_while(|&v| v == 0));
+            let mut want =
+                std::vec::Vec::from_iter(x.to_be_bytes().iter().copied().skip_while(|&v| v == 0));
             want.push(want.len() as u8);
             assert_eq!(right_encode(x as u64, &mut buf), want, "#{x}");
         }
     }
-}
+}

kmac/src/kmac.rs

@@ -1,9 +1,12 @@
+use crate::encoding::{left_encode, right_encode};
+use crate::traits::{CShake, EagerHash};
 use core::fmt;
-use digest::block_api::{AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, Eager, ExtendableOutputCore, FixedOutputCore, UpdateCore, XofReaderCore};
+use digest::block_api::{
+    AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, Eager, ExtendableOutputCore,
+    FixedOutputCore, UpdateCore, XofReaderCore,
+};
 use digest::crypto_common::KeySizeUser;
 use digest::{InvalidLength, Key, KeyInit, MacMarker, Output, OutputSizeUser};
-use crate::encoding::{left_encode, right_encode};
-use crate::traits::{CShake, EagerHash};
 
 pub struct KmacCore<D: EagerHash> {
     digest: D::Core,
@@ -45,27 +48,22 @@ impl<D: EagerHash> KmacCore<D> {
         // bytepad, left_encode(w)
         buffer.digest_blocks(
             left_encode(D::block_size() as u64, &mut encode_buffer),
-            |blocks| digest.update_blocks(blocks)
+            |blocks| digest.update_blocks(blocks),
         );
 
         // encode_string(K), left_encode(len(K)) -- length is in bits
         buffer.digest_blocks(
             left_encode(8 * key.len() as u64, &mut encode_buffer),
-            |blocks| digest.update_blocks(blocks)
+            |blocks| digest.update_blocks(blocks),
         );
 
         // encode_string(K) copy K into blocks
-        buffer.digest_blocks(
-            &key,
-            |blocks| digest.update_blocks(blocks)
-        );
+        buffer.digest_blocks(key, |blocks| digest.update_blocks(blocks));
 
         // bytepad, pad the key to the block size
         digest.update_blocks(&[buffer.pad_with_zeros()]);
 
-        Self {
-            digest,
-        }
+        Self { digest }
     }
 }
 
@@ -95,7 +93,7 @@ impl<D: EagerHash> KmacCore<D> {
         // right_encode(L), where L = output length in bits
         buffer.digest_blocks(
             right_encode(8 * out.len() as u64, &mut [0u8; 9]),
-            |blocks| self.update_blocks(blocks)
+            |blocks| self.update_blocks(blocks),
         );
 
         let mut reader = self.digest.finalize_xof_core(buffer);
@@ -126,10 +124,9 @@ impl<D: EagerHash> ExtendableOutputCore for KmacCore<D> {
     #[inline(always)]
     fn finalize_xof_core(&mut self, buffer: &mut Buffer<Self>) -> Self::ReaderCore {
         // right_encode(0), as L = 0 for extendable output
-        buffer.digest_blocks(
-            right_encode(0, &mut [0u8; 9]),
-            |blocks| self.update_blocks(blocks)
-        );
+        buffer.digest_blocks(right_encode(0, &mut [0u8; 9]), |blocks| {
+            self.update_blocks(blocks)
+        });
         self.digest.finalize_xof_core(buffer)
     }
 }

kmac/src/lib.rs

@@ -10,14 +10,14 @@
 #![forbid(unsafe_code)]
 #![warn(missing_docs)]
 
+mod encoding;
 mod kmac;
 mod traits;
-mod encoding;
 
 use crate::kmac::KmacCore;
 use digest::block_api::{Block, BlockSizeUser, Buffer, ExtendableOutputCore, XofReaderCore};
 use digest::block_buffer::ReadBuffer;
-use digest::consts::{U136, U168, U32, U64};
+use digest::consts::{U32, U64, U136, U168};
 pub use digest::{self, ExtendableOutput, KeyInit, Mac, XofReader};
 use digest::{InvalidLength, OutputSizeUser};
 use sha3::block_api::Sha3ReaderCore;
@@ -213,12 +213,18 @@ mod tests {
         mac.update(b"input message");
         let result = mac.finalize();
         let code_bytes = result.into_bytes();
-        let expected = hex!("
+        let expected = hex!(
+            "
             c39a8f614f8821443599440df5402787
             0f67e4c47919061584f14a616f3efcf5
-        ");
-        assert_eq!(code_bytes[..], expected[..], "Expected hex output is {}", hex::encode(&code_bytes));
-
+        "
+        );
+        assert_eq!(
+            code_bytes[..],
+            expected[..],
+            "Expected hex output is {}",
+            hex::encode(&code_bytes)
+        );
 
         let mut mac = Kmac128::new_from_slice(b"key material").unwrap();
         mac.update(b"input message");
@@ -232,11 +238,18 @@ mod tests {
         let mut output = [0u8; 32];
         mac.finalize_into(&mut output);
 
-        let expected = hex!("
+        let expected = hex!(
+            "
             85fb77da3a35e4c4b0057c3151e6cc54
             ee401ffe65ec2f0239f439be8896f7b6
-        ");
-        assert_eq!(output[..], expected[..], "Expected hex output is {}", hex::encode(&output));
+        "
+        );
+        assert_eq!(
+            output[..],
+            expected[..],
+            "Expected hex output is {}",
+            hex::encode(&output)
+        );
     }
 
     #[test]
@@ -248,10 +261,17 @@ mod tests {
         let mut output = [0u8; 32];
         reader.read(&mut output);
 
-        let expected = hex!("
+        let expected = hex!(
+            "
             b675b75668eab0706ab05650f34fa1b6
             24051a9a42b5e42cfe9970e8f903d45b
-        ");
-        assert_eq!(output[..], expected[..], "Expected hex output is {}", hex::encode(&output));
+        "
+        );
+        assert_eq!(
+            output[..],
+            expected[..],
+            "Expected hex output is {}",
+            hex::encode(&output)
+        );
     }
-}
+}

kmac/src/traits.rs

@@ -1,5 +1,7 @@
-use digest::block_api::{BlockSizeUser, BufferKindUser, CoreProxy, Eager, ExtendableOutputCore, UpdateCore};
 use digest::HashMarker;
+use digest::block_api::{
+    BlockSizeUser, BufferKindUser, CoreProxy, Eager, ExtendableOutputCore, UpdateCore,
+};
 
 const FUNCTION_NAME: &[u8] = b"KMAC";
 
@@ -23,26 +25,26 @@ impl CShake for sha3::block_api::CShake256Core {
 pub trait EagerHash: BlockSizeUser {
     /// Block-level core type of the hash.
     type Core: HashMarker
-    + CShake
-    + UpdateCore
-    + ExtendableOutputCore
-    + BlockSizeUser<BlockSize = <Self as BlockSizeUser>::BlockSize>
-    + BufferKindUser<BufferKind = Eager>
-    + Default
-    + Clone;
+        + CShake
+        + UpdateCore
+        + ExtendableOutputCore
+        + BlockSizeUser<BlockSize = <Self as BlockSizeUser>::BlockSize>
+        + BufferKindUser<BufferKind = Eager>
+        + Default
+        + Clone;
 }
 
 impl<T> EagerHash for T
 where
     T: CoreProxy + BlockSizeUser,
     <T as CoreProxy>::Core: HashMarker
-    + CShake
-    + UpdateCore
-    + ExtendableOutputCore
-    + BlockSizeUser<BlockSize = <Self as BlockSizeUser>::BlockSize>
-    + BufferKindUser<BufferKind = Eager>
-    + Default
-    + Clone,
+        + CShake
+        + UpdateCore
+        + ExtendableOutputCore
+        + BlockSizeUser<BlockSize = <Self as BlockSizeUser>::BlockSize>
+        + BufferKindUser<BufferKind = Eager>
+        + Default
+        + Clone,
 {
     type Core = T::Core;
 }