Use chunks_exact

As of Rust 1.31 we have access to `chunks_exact` and `chunks_exact_mut`,
according to the docs these methods can be often be better optimised by
the compiler than the non-`_exact` methods.

Author: tcharding

src/ripemd160.rs

@@ -53,7 +53,7 @@ impl crate::HashEngine for HashEngine {
     #[cfg(not(fuzzing))]
     fn midstate(&self) -> [u8; 20] {
         let mut ret = [0; 20];
-        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_mut(4)) {
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
             ret_bytes.copy_from_slice(&(*val).to_le_bytes());
         }
         ret
@@ -269,7 +269,7 @@ impl HashEngine {
         debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
 
         let mut w = [0u32; 16];
-        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks(4)) {
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
             *w_val = u32::from_le_bytes(buff_bytes.try_into().expect("4 byte slice"))
         }
 

src/sha1.rs

@@ -48,7 +48,7 @@ impl crate::HashEngine for HashEngine {
     #[cfg(not(fuzzing))]
     fn midstate(&self) -> [u8; 20] {
         let mut ret = [0; 20];
-        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_mut(4)) {
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
             ret_bytes.copy_from_slice(&val.to_be_bytes())
         }
         ret
@@ -157,7 +157,7 @@ impl HashEngine {
         debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
 
         let mut w = [0u32; 80];
-        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks(4)) {
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
             *w_val = u32::from_be_bytes(buff_bytes.try_into().expect("4 bytes slice"))
         }
         for i in 16..80 {

src/sha256.rs

@@ -48,7 +48,7 @@ impl crate::HashEngine for HashEngine {
     #[cfg(not(fuzzing))]
     fn midstate(&self) -> Midstate {
         let mut ret = [0; 32];
-        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_mut(4)) {
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
             ret_bytes.copy_from_slice(&val.to_be_bytes());
         }
         Midstate(ret)
@@ -259,7 +259,7 @@ impl HashEngine {
         assert!(length % BLOCK_SIZE == 0, "length is no multiple of the block size");
 
         let mut ret = [0; 8];
-        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate[..].chunks(4)) {
+        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate[..].chunks_exact(4)) {
             *ret_val = u32::from_be_bytes(midstate_bytes.try_into().expect("4 byte slice"));
         }
 
@@ -275,7 +275,7 @@ impl HashEngine {
         debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
 
         let mut w = [0u32; 16];
-        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks(4)) {
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
             *w_val = u32::from_be_bytes(buff_bytes.try_into().expect("4 byte slice"));
         }
 

src/sha512.rs

@@ -56,7 +56,7 @@ impl crate::HashEngine for HashEngine {
     #[cfg(not(fuzzing))]
     fn midstate(&self) -> [u8; 64] {
         let mut ret = [0; 64];
-        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_mut(8)) {
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(8)) {
             ret_bytes.copy_from_slice(&val.to_be_bytes());
         }
         ret
@@ -237,7 +237,7 @@ impl HashEngine {
         debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
 
         let mut w = [0u64; 16];
-        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks(8)) {
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(8)) {
             *w_val = u64::from_be_bytes(buff_bytes.try_into().expect("8 byte slice"));
         }