Improve the performance of the pure rust implementations

Author: jedisct1

benches/benchmark.rs

@@ -3,9 +3,7 @@ use aegis::aegis128x2::Aegis128X2;
 use aegis::aegis128x4::Aegis128X4;
 use aegis::aegis256::Aegis256;
 
-#[cfg(not(feature = "pure-rust"))]
 use aegis::aegis256x2::Aegis256X2;
-#[cfg(not(feature = "pure-rust"))]
 use aegis::aegis256x4::Aegis256X4;
 
 #[cfg(not(feature = "pure-rust"))]
@@ -100,15 +98,13 @@ fn test_aegis256(m: &mut [u8]) {
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(feature = "pure-rust"))]
 fn test_aegis256x2(m: &mut [u8]) {
     let key = [0u8; 32];
     let nonce = [0u8; 32];
     let state = Aegis256X2::<16>::new(&nonce, &key);
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(feature = "pure-rust"))]
 fn test_aegis256x4(m: &mut [u8]) {
     let key = [0u8; 32];
     let nonce = [0u8; 32];
@@ -238,20 +234,17 @@ fn main() {
         res.throughput_bits(m.len() as _)
     );
 
-    #[cfg(not(feature = "pure-rust"))]
-    {
-        let res = bench.run(options, || test_aegis256x2(&mut m));
-        println!(
-            "aegis256x2          : {}",
-            res.throughput_bits(m.len() as _)
-        );
+    let res = bench.run(options, || test_aegis256x2(&mut m));
+    println!(
+        "aegis256x2          : {}",
+        res.throughput_bits(m.len() as _)
+    );
 
-        let res = bench.run(options, || test_aegis256x4(&mut m));
-        println!(
-            "aegis256x4          : {}",
-            res.throughput_bits(m.len() as _)
-        );
-    }
+    let res = bench.run(options, || test_aegis256x4(&mut m));
+    println!(
+        "aegis256x4          : {}",
+        res.throughput_bits(m.len() as _)
+    );
 
     let res = bench.run(options, || test_aegis256(&mut m));
     println!(

src/pure_rust/aegis128l.rs

@@ -14,19 +14,21 @@ struct State {
 }
 
 impl State {
+    #[inline(always)]
     fn update(&mut self, d1: AesBlock, d2: AesBlock) {
         let blocks = &mut self.blocks;
         let tmp = blocks[7];
-        let mut i = 7;
-        while i > 0 {
-            blocks[i] = blocks[i - 1].round(blocks[i]);
-            i -= 1;
-        }
-        blocks[0] = tmp.round(blocks[0]);
-        blocks[0] = blocks[0].xor(d1);
-        blocks[4] = blocks[4].xor(d2);
+        blocks[7] = blocks[6].round(blocks[7]);
+        blocks[6] = blocks[5].round(blocks[6]);
+        blocks[5] = blocks[4].round(blocks[5]);
+        blocks[4] = blocks[3].round(blocks[4]).xor(d2);
+        blocks[3] = blocks[2].round(blocks[3]);
+        blocks[2] = blocks[1].round(blocks[2]);
+        blocks[1] = blocks[0].round(blocks[1]);
+        blocks[0] = tmp.round(blocks[0]).xor(d1);
     }
 
+    #[inline(always)]
     pub fn new(key: &Key, nonce: &Nonce) -> Self {
         let c0 = AesBlock::from_bytes(&[
             0x00, 0x01, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9,
@@ -62,6 +64,7 @@ impl State {
         self.update(msg0, msg1);
     }
 
+    #[inline(always)]
     fn enc(&mut self, dst: &mut [u8; 32], src: &[u8; 32]) {
         let blocks = &self.blocks;
         let z0 = blocks[6].xor(blocks[1]).xor(blocks[2].and(blocks[3]));
@@ -75,6 +78,7 @@ impl State {
         self.update(msg0, msg1);
     }
 
+    #[inline(always)]
     fn dec(&mut self, dst: &mut [u8; 32], src: &[u8; 32]) {
         let blocks = &self.blocks;
         let z0 = blocks[6].xor(blocks[1]).xor(blocks[2].and(blocks[3]));
@@ -86,6 +90,7 @@ impl State {
         self.update(msg0, msg1);
     }
 
+    #[inline(always)]
     fn dec_partial(&mut self, dst: &mut [u8; 32], src: &[u8]) {
         let len = src.len();
         let mut src_padded = [0u8; 32];
@@ -106,6 +111,7 @@ impl State {
         self.update(msg0, msg1);
     }
 
+    #[inline(always)]
     fn mac<const TAG_BYTES: usize>(&mut self, adlen: usize, mlen: usize) -> Tag<TAG_BYTES> {
         let tmp = {
             let blocks = &self.blocks;