refactor: externalise gfmul to make it more accessible and semantic support

src/utils/ciphers.rs

@@ -83,7 +83,7 @@ pub fn xex_encrypt(mut key: Vec<u8>, tweak: &Vec<u8>, input: &Vec<u8>) -> Result
         let cypher_block_intermediate = sea_128_encrypt(&key, &plaintext_intermediate)?;
         let mut cypher_block = xor_bytes(&tweak_block.0, cypher_block_intermediate)?;
         output.append(cypher_block.as_mut());
-        tweak_block.left_shift_reduce();
+        tweak_block.left_shift_reduce("xex");
     }
 
     Ok(output)
@@ -116,7 +116,7 @@ pub fn xex_decrypt(mut key: Vec<u8>, tweak: &Vec<u8>, input: &Vec<u8>) -> Result
         let plaintext_block_intermediate = sea_128_decrypt(&key, &cyphertext_intermediate)?;
         let mut cypher_block = xor_bytes(&tweak_block.0, plaintext_block_intermediate)?;
         output.append(cypher_block.as_mut());
-        tweak_block.left_shift_reduce();
+        tweak_block.left_shift_reduce("xex");
     }
 
     Ok(output)

src/utils/math.rs

@@ -1,7 +1,7 @@
-use anyhow::{Ok, Result};
+use anyhow::{anyhow, Ok, Result};
 use base64::Engine;
 
-use crate::tasks::tasks01::gfmul::gfmul;
+use super::poly::gfmul;
 
 pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
     for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) {
@@ -25,21 +25,46 @@ impl ByteArray {
         carry
     }
 
-    pub fn left_shift_reduce(&mut self) {
-        let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
-            .decode("AgAAAAAAAAAAAAAAAAAAAA==")
-            .expect("Decode failed");
-        self.0 = gfmul(self.0.clone(), alpha_poly).unwrap();
+    pub fn left_shift_reduce(&mut self, semantic: &str) {
+        match semantic {
+            "xex" => {
+                let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
+                    .decode("AgAAAAAAAAAAAAAAAAAAAA==")
+                    .expect("Decode failed");
+                self.0 = gfmul(self.0.clone(), alpha_poly, "xex").unwrap();
+            }
+            "gcm" => {
+                let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
+                    .decode("AgAAAAAAAAAAAAAAAAAAAA==")
+                    .expect("Decode failed");
+                self.0 = gfmul(self.0.clone(), alpha_poly, "gcm").unwrap();
+            }
+            _ => {}
+        }
     }
 
-    pub fn right_shift(&mut self) -> u8 {
-        let mut carry = 0u8;
-        for byte in self.0.iter_mut().rev() {
-            let new_carry = *byte & 1;
-            *byte = (*byte >> 1) | (carry << 7);
-            carry = new_carry;
+    pub fn right_shift(&mut self, semantic: &str) -> Result<u8> {
+        match semantic {
+            "xex" => {
+                let mut carry = 0u8;
+                for byte in self.0.iter_mut().rev() {
+                    let new_carry = *byte & 1;
+                    *byte = (*byte >> 1) | (carry << 7);
+                    carry = new_carry;
+                }
+                Ok(carry)
+            }
+            "gcm" => {
+                let mut carry = 0u8;
+                for byte in self.0.iter_mut().rev() {
+                    let new_carry = *byte & 1;
+                    *byte = (*byte << 1) | carry;
+                    carry = new_carry;
+                }
+                Ok(carry)
+            }
+            _ => Err(anyhow!("Failure in rsh. No valid semantic found")),
         }
-        carry
     }
 
     pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) {
@@ -94,7 +119,7 @@ mod tests {
     fn test_byte_array_shift_right() {
         let mut byte_array: ByteArray = ByteArray(vec![0x02]);
         let shifted_array: ByteArray = ByteArray(vec![0x01]);
-        byte_array.right_shift();
+        byte_array.right_shift("xex");
 
         assert_eq!(
             byte_array.0, shifted_array.0,

src/utils/poly.rs

@@ -1,7 +1,45 @@
+use crate::utils::math::ByteArray;
 use anyhow::Result;
 use base64::prelude::*;
-
+use serde_json::Value;
 use std::{str::FromStr, u128, u8, usize};
+pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000;
+
+pub fn gfmul(poly_a: Vec<u8>, poly_b: Vec<u8>, semantic: &str) -> Result<Vec<u8>> {
+    let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec());
+    red_poly_bytes.0.push(0x01);
+
+    let mut poly1: ByteArray = ByteArray(poly_a);
+    poly1.0.push(0x00);
+
+    let mut poly2: ByteArray = ByteArray(poly_b);
+    poly2.0.push(0x00);
+
+    let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+    if poly2.LSB_is_one() {
+        result.xor_byte_arrays(&poly1);
+        poly2.right_shift(semantic);
+    } else {
+        poly2.right_shift(semantic);
+    }
+
+    while !poly2.is_empty() {
+        if poly2.LSB_is_one() {
+            poly1.left_shift();
+            poly1.xor_byte_arrays(&red_poly_bytes);
+            result.xor_byte_arrays(&poly1);
+        } else {
+            poly1.left_shift();
+            poly1.xor_byte_arrays(&red_poly_bytes);
+        }
+        poly2.right_shift(semantic);
+    }
+
+    result.0.remove(16);
+
+    Ok(result.0)
+}
 
 pub fn get_alpha_rep(num: u128) -> String {
     let powers: Vec<u8> = get_coefficients(num);