fixed cargo clippy and added README.md content

Author: truthixify

Cargo.lock

@@ -16,6 +16,7 @@ name = "md6"
 
 [dependencies]
 digest = "=0.11.0-pre.9"
+hex = "0.4.3"
 
 [dev-dependencies]
 digest = { version = "=0.11.0-pre.9", features = ["dev"] }

md6/Cargo.toml

@@ -0,0 +1,81 @@
+# RustCrypto: MD6
+
+Pure Rust implementation of the MD6 hash function.
+
+## Example
+
+### Fixed output size
+
+```rust
+use md6::{Md6_256, Digest};
+use hex_literal::hex;
+
+// create a Blake2b512 object
+let mut hasher = Md6_256::new();
+
+// write input message
+hasher.update(b"hello world");
+
+// read hash digest and consume hasher
+let hash = hasher.finalize();
+assert_eq!(hash.to_vec(), hex!(
+    "9ae602639631cc2c60adaa7a952aae8756141f31a7e6a9b76adc1de121db2230"
+));
+```
+
+Also, see the [examples section] in the RustCrypto/hashes readme.
+
+### Variable output size
+
+This implementation supports run and compile time variable sizes.
+
+Output size set at run time:
+```rust
+use md6::Md6Var;
+use blake2::digest::{Update, VariableOutput};
+use hex_literal::hex;
+
+let mut hasher = Md6Var::new(12).unwrap();
+hasher.update(b"hello rust");
+let mut buf = [0u8; 12];
+hasher.finalize_variable(&mut buf).unwrap();
+assert_eq!(buf, hex!("9c5b8d9744898ec981bcc573"));
+```
+
+Output size set at compile time:
+```rust
+use md6::{Md6, Digest, digest::consts::U20};
+use hex_literal::hex;
+
+type Md6_160 = Md6<U20>;
+
+let mut hasher = Md6_160::new();
+hasher.update(b"my_input");
+let res = hasher.finalize();
+assert_eq!(res, hex!("576d736a93a555a1c868973cfdd2d21838a26623"));
+```
+
+## Minimum Supported Rust Version
+
+Rust **1.81** or higher.
+
+Minimum supported Rust version can be changed in the future, but it will be
+done with a minor version bump.
+
+## SemVer Policy
+
+- All on-by-default features of this library are covered by SemVer
+- MSRV is considered exempt from SemVer as noted above
+
+## License
+
+The crate is licensed under either of:
+
+* [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
+* [MIT license](http://opensource.org/licenses/MIT)
+
+## Contributing
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.

md6/README.md

@@ -145,7 +145,7 @@ pub fn compress(c: &mut [Md6Word], n: &mut [Md6Word], r: usize, a: &mut [Md6Word
     c.copy_from_slice(&a[((r - 1) * C + N)..((r - 1) * C + N + C)]); // output into c
 }
 
-fn make_control_word(
+pub fn make_control_word(
     r: usize,
     l: usize,
     z: usize,
@@ -170,15 +170,9 @@ pub fn pack(
     n: &mut [Md6Word],
     q: &[Md6Word],
     k: [Md6Word; K],
-    ell: usize,
-    i: Md6Word,
-    r: usize,
-    l: usize,
-    z: usize,
-    p: usize,
-    keylen: usize,
-    d: usize,
     b: [Md6Word; 64],
+    u: Md6NodeID,
+    v: Md6ControlWord,
 ) {
     let mut ni = 0;
 
@@ -188,46 +182,13 @@ pub fn pack(
     n[ni..ni + K].copy_from_slice(&k[..K]); // k: key in words  15--22
     ni += K;
 
-    let u = make_node_id(ell, i); // u: unique node ID in 23
+    // u: unique node ID in 23
     n[ni] = u;
     ni += U;
 
-    let v = make_control_word(r, l, z, p, keylen, d); // v: control word in 24
+    // v: control word in 24
     n[ni] = v;
     ni += V;
 
     n[ni..ni + B].copy_from_slice(&b[..B]); // b: data words     25--88
 }
-
-pub fn standard_compress(
-    c: &mut [Md6Word],
-    q: &[Md6Word],
-    k: [Md6Word; K],
-    ell: usize,
-    i: Md6Word,
-    r: usize,
-    l: usize,
-    z: usize,
-    p: usize,
-    keylen: usize,
-    d: usize,
-    b: [Md6Word; 64],
-) {
-    let mut n = [0; MD6_N];
-    let mut a = [0; 5000];
-
-    // check that the input values are sensible
-    assert!(!c.is_empty());
-    assert!(!q.is_empty());
-    assert!(!b.is_empty());
-    assert!(r <= MD6_MAX_R);
-    assert!(l <= 255);
-    assert!(ell <= 255);
-    assert!(p <= B * W);
-    assert!(d <= C * W / 2);
-    assert!(!k.is_empty());
-
-    pack(&mut n, q, k, ell, i, r, l, z, p, keylen, d, b); // pack input data into N
-
-    compress(c, &mut n, r, &mut a); // compress
-}

md6/src/compress.rs

@@ -24,6 +24,8 @@ use crate::md6::Md6VarCore;
 pub type Md6Var = RtVariableCoreWrapper<Md6VarCore>;
 /// Core hash function for Md6 generic over output size
 pub type Md6Core<OutSize> = CtVariableCoreWrapper<Md6VarCore, OutSize>;
+/// Md6 generic over output size.
+pub type Md6<OutSize> = CoreWrapper<Md6Core<OutSize>>;
 /// Md6 with 64-bit output
 pub type Md6_64 = CoreWrapper<Md6Core<U8>>;
 /// Md6 with 128-bit output

md6/src/lib.rs

@@ -245,7 +245,7 @@ impl SerializableState for Md6VarCore {
 
         let mut k = [0u64; K];
         for word in &mut k {
-            *word = read_u64(&serialized_state, &mut offset);
+            *word = read_u64(serialized_state, &mut offset);
         }
 
         let mut b = [[0u64; B]; MD6_MAX_STACK_HEIGHT];
@@ -298,7 +298,7 @@ impl Md6VarCore {
         if key.is_some() {
             assert!(keylen <= K * (W / 8), "bad keylen");
         }
-        assert!(!(d < 1 || d > 512 || d > W * C / 2), "bad hashlen");
+        assert!((1..=512).contains(&d), "bad hashlen");
 
         let (k, keylen) = match key {
             Some(key) if keylen > 0 => {
@@ -354,6 +354,36 @@ impl Md6VarCore {
         }
     }
 
+    pub fn standard_compress(
+        &self,
+        c: &mut [Md6Word],
+        q: &[Md6Word],
+        ell: usize,
+        p: usize,
+        z: usize,
+    ) {
+        let mut n = [0; MD6_N];
+        let mut a = [0; 5000];
+
+        // check that the input values are sensible
+        assert!(!c.is_empty());
+        assert!(!q.is_empty());
+        assert!(!self.b.is_empty());
+        assert!(self.r <= MD6_MAX_R);
+        assert!(self.l <= 255);
+        assert!(ell <= 255);
+        assert!(p <= B * W);
+        assert!(self.d <= C * W / 2);
+        assert!(!self.k.is_empty());
+
+        let u = make_node_id(ell, self.i_for_level[ell]);
+        let v = make_control_word(self.r, self.l, z, p, self.keylen, self.d);
+
+        pack(&mut n, q, self.k, self.b[ell], u, v); // pack input data into N
+
+        compress(c, &mut n, self.r, &mut a); // compress
+    }
+
     #[inline]
     fn compress_block(&mut self, c: &mut [u64], ell: usize, z: usize) {
         // check that input values are sensible
@@ -365,20 +395,7 @@ impl Md6VarCore {
         let p = B * W - self.bits[ell]; // number of padding bits
         let q = get_round_constants(W); // Q constant
 
-        standard_compress(
-            c,
-            q,
-            self.k,
-            ell,
-            self.i_for_level[ell],
-            self.r,
-            self.l,
-            z,
-            p,
-            self.keylen,
-            self.d,
-            self.b[ell],
-        );
+        self.standard_compress(c, q, ell, p, z);
 
         self.bits[ell] = 0; // clear bits used count this level
         self.i_for_level[ell] += 1; // increment i for this level
@@ -466,15 +483,15 @@ impl Md6VarCore {
         // Number of bytes (full or partial) in src
         let srcbytes = (srclen + 7) / 8;
 
-        for i in 0..srcbytes {
+        for (i, item) in src.iter().enumerate().take(srcbytes) {
             if i != srcbytes - 1 {
                 // Not the last byte
                 accum = (accum << 8) ^ src[i] as u16;
                 accumlen += 8;
             } else {
                 // Last byte
                 let newbits = if srclen % 8 == 0 { 8 } else { srclen % 8 };
-                accum = (accum << newbits) ^ ((src[i] as u16) >> (8 - newbits));
+                accum = (accum << newbits) ^ ((*item as u16) >> (8 - newbits));
                 accumlen += newbits;
             }