Cargo.lock

@@ -8,6 +8,12 @@ version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37bf3594c4c988a53154954629820791dde498571819ae4ca50ca811e060cc95"
 
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -62,6 +68,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "base64",
+ "num-bigint",
  "openssl",
  "serde",
  "serde_json",
@@ -79,6 +86,34 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.20.2"

Cargo.toml

@@ -7,6 +7,7 @@ rust = "1.75"
 [dependencies]
 anyhow = "1.0.90"
 base64 = "0.22.1"
+num-bigint = "0.4.6"
 openssl = "0.10.68"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0"

src/tasks/tasks01/gfmul.rs

@@ -1,20 +1,38 @@
 use anyhow::Result;
 use base64::prelude::*;
+//use num_bigint::{BigUint, ToBigUint};
 use serde_json::Value;
 
-use crate::utils::poly::{b64_2_num, coefficient_to_binary};
+use crate::utils::{
+    math::ByteArray,
+    poly::{b64_2_num, coefficient_to_binary},
+};
+
+pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000;
 
 pub fn gfmul(args: &Value) -> Result<String> {
     eprintln!("{args}");
     // Generate reduction polynomial
-    let reduction_polynomial_coeffs: Vec<u8> = vec![7, 2, 1, 0];
+    let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec());
-    let red_poly_num: u128 = 340282366920938463463374607431768211591; //coefficient_to_binary(reduction_polynomial_coeffs);
+    eprintln!("Before push  {:01X?}", red_poly_bytes);
-                                                                      //eprintln!("{:?}", serde_json::from_value(args["a"].clone())?);
+    red_poly_bytes.0.push(0x01);
+    //red_poly_bytes.0.reverse();
+    eprintln!("After push  {:01X?}", red_poly_bytes);
+    //let red_poly_num = ; //coefficient_to_binary(reduction_polynomial_coeffs);
+    //eprintln!("{:?}", serde_json::from_value(args["a"].clone())?);
 
-    let mut poly1: u128 = b64_2_num(&serde_json::from_value(args["a"].clone())?)?;
+    let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-    let poly2: u128 = b64_2_num(&serde_json::from_value(args["b"].clone())?)?;
+    let mut poly1: ByteArray = ByteArray(BASE64_STANDARD.decode(poly1_text)?);
-    eprintln!("poly1 is: {}", poly1);
+    poly1.0.push(0x00);
-    eprintln!("poly2 is: {}", poly2);
+    //poly1.0.reverse();
+
+    let poly2_text: String = serde_json::from_value(args["b"].clone())?;
+    let mut poly2: ByteArray = ByteArray(BASE64_STANDARD.decode(poly2_text)?);
+    poly2.0.push(0x00);
+    //poly2.0.reverse();
+
+    eprintln!("poly1 is: {:01X?}", poly1);
+    eprintln!("poly2 is: {:01X?}", poly2);
 
     /* Begin of magic algorithm
      *  poly1 = a = X = V ???
@@ -22,26 +40,51 @@ pub fn gfmul(args: &Value) -> Result<String> {
      *  result = Z
      */
 
-    let mut result: u128 = 0;
+    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 >> 1) & 1) == 1 {
+    if poly2.LSB_is_one() {
-        eprintln!("ALHIGLIWhlighliwfhlihliawfhliawfhli");
+        result.xor_byte_arrays(&poly1);
-        result ^= poly1;
     }
 
-    for i in 2..128 {
+    while !poly2.is_empty() {
-        if ((poly2 >> i) & 1) == 1 {
+        if !poly2.LSB_is_one() {
-            poly1 = (poly1 << 1) ^ red_poly_num;
+            poly1.left_shift();
-            result ^= poly1;
+            poly1.xor_byte_arrays(&red_poly_bytes);
+            eprintln!("Poly1 after reduction: {:01X?}", poly1);
+            result.xor_byte_arrays(&poly1);
+            eprintln!(
+                "LSB was one; \n 
+                    poly1 is {:01X?}; \n
+                    poly2 is {:01X?}; \n
+                    result is: {:01X?}",
+                poly1.0, poly2.0, result.0
+            )
         } else {
-            poly1 = (poly1 << 1) ^ red_poly_num;
+            poly1.left_shift();
+            poly1.xor_byte_arrays(&red_poly_bytes);
+            eprintln!(
+                "LSB was 0; \n
+                    poly1 is {:01X?}; \n
+                    poly2 is {:01X?}; \n
+                    result is: {:01X?}",
+                poly1.0, poly2.0, result.0
+            )
         }
+        poly2.right_shift();
     }
+    //result.xor_byte_arrays(&red_poly_bytes);
+    //result.xor_byte_arrays(&red_poly_bytes);
+    eprintln!("Result after last red {:01X?}", &result.0);
 
-    poly1 = (poly1 << 1) ^ red_poly_num;
+    eprintln!(
-    result ^= poly1;
+        "Should be: {:01X?}",
+        ByteArray(BASE64_STANDARD.decode("hSQAAAAAAAAAAAAAAAAAAA==")?)
+    );
+    result.0.remove(16);
+    let mut bytes: [u8; 16] = [0u8; 16];
+    bytes.copy_from_slice(&result.0);
 
-    Ok(BASE64_STANDARD.encode(result.to_ne_bytes()))
+    Ok(BASE64_STANDARD.encode(bytes))
 }
 
 #[cfg(test)]

src/utils/math.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{Ok, Result};
 
 pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
     for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) {
@@ -7,3 +7,105 @@ pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
 
     Ok(vec2)
 }
+
+#[derive(Debug)]
+pub struct ByteArray(pub Vec<u8>);
+
+impl ByteArray {
+    pub fn left_shift(&mut self) -> u8 {
+        let mut carry = 0u8;
+        for byte in self.0.iter_mut() {
+            let new_carry = *byte >> 7;
+            *byte = (*byte << 1) | carry;
+            carry = new_carry;
+        }
+        carry
+    }
+
+    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;
+        }
+        carry
+    }
+
+    pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) {
+        self.0
+            .iter_mut()
+            .zip(vec2.0.iter())
+            .for_each(|(x1, x2)| *x1 ^= *x2);
+    }
+
+    pub fn LSB_is_one(&self) -> bool {
+        (self.0.first().unwrap() & 1) == 1
+    }
+
+    pub fn is_empty(&self) -> bool {
+        for i in self.0.iter() {
+            if *i != 0 {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_byte_array_shift1() {
+        let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x01]);
+        let shifted_array: ByteArray = ByteArray(vec![0x00, 0x02]);
+        byte_array.left_shift();
+
+        assert_eq!(byte_array.0, shifted_array.0);
+    }
+
+    #[test]
+    fn test_byte_array_shift2() {
+        let mut byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]);
+        let shifted_array: ByteArray = ByteArray(vec![0x01, 0xFE]);
+        byte_array.left_shift();
+
+        assert_eq!(
+            byte_array.0, shifted_array.0,
+            "Failure: Shifted array was: {:?}",
+            byte_array.0
+        );
+    }
+
+    #[test]
+    fn test_lsb_one() {
+        let mut byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]);
+        assert!(byte_array.LSB_is_one());
+
+        let mut byte_array2: ByteArray = ByteArray(vec![0x00, 0x02]);
+        assert!(!byte_array2.LSB_is_one());
+    }
+
+    #[test]
+    fn test_byte_xor() {
+        let mut byte_array: ByteArray = ByteArray(vec![0x25, 0x25]);
+        let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]);
+
+        byte_array.xor_byte_arrays(&byte_array2);
+
+        assert_eq!(byte_array.0, vec![0x70, 0x70]);
+    }
+
+    #[test]
+    fn test_byte_xor2() {
+        let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x00]);
+        let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]);
+
+        byte_array.xor_byte_arrays(&byte_array2);
+
+        assert_eq!(byte_array.0, vec![0x55, 0x55]);
+    }
+}

src/utils/poly.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use base64::prelude::*;
 
-use std::{str::FromStr, u128, u8};
+use std::{str::FromStr, u128, u8, usize};
 
 pub fn get_alpha_rep(num: u128) -> String {
     let powers: Vec<u8> = get_coefficients(num);
@@ -55,6 +55,16 @@ pub fn get_bit_indices_from_byte(byte: u8) -> Vec<u8> {
     coefficients
 }
 
+pub fn coefficients_to_byte_arr_xex(coeffs: Vec<u8>) -> Vec<u8> {
+    let mut byte_array: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    for coeff in coeffs {
+        let block_num = coeff / 8;
+        byte_array[usize::from(block_num)] |= (1 << (coeff % 7));
+    }
+
+    byte_array
+}
+
 pub fn coefficient_to_binary(coefficients: Vec<u8>) -> u128 {
     let mut binary_number: u128 = 0;
     for coeff in coefficients {
@@ -71,6 +81,24 @@ mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
+    #[test]
+    fn coefficients_to_byte_arr_xex_test1() {
+        let coefficients: Vec<u8> = vec![0];
+        let byte_array = vec![
+            01, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
+        ];
+        assert_eq!(coefficients_to_byte_arr_xex(coefficients), byte_array)
+    }
+
+    #[test]
+    fn coefficients_to_byte_arr_xex_test2() {
+        let coefficients: Vec<u8> = vec![127, 12, 9, 0];
+        let byte_array = vec![
+            01, 12, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 80,
+        ];
+        assert_eq!(coefficients_to_byte_arr_xex(coefficients), byte_array)
+    }
+
     #[test]
     fn byte_indices_0x01() {
         let byte: u8 = 0x01;