chore: debug pipeline

.github/workflows/kauma.yaml

@@ -66,5 +66,5 @@ jobs:
           docker tag ghcr.io/johndoe31415/labwork-docker:master labwork
       - name: Run labwork container
         run: |
-          docker run -v $PWD:/dut/ labwork /bin/bash -c '/dut/build && /dut/kauma ./test_json/kauma_tests.json'
+          docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls -la /dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma /dut/test_json/kauma_tests.json'
 

Cargo.toml

@@ -10,17 +10,9 @@ base64 = "0.22"
 openssl = "0.10"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-num = "0.4"
-rand = "0.8"
-threadpool = "1.8"
-num_cpus = "1.16.0"
 
 [source.crates-io]
 replace-with = "vendored-sources"
 
 [source.vendored-sources]
 directory = "vendor"
-
-[profile.profiling]
-inherits = "release"
-debug = true

kauma

@@ -1,4 +1,4 @@
 #!/bin/bash
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd $SCRIPT_DIR
-cargo run --release --locked --offline -- $@
+cargo run --release --locked --offline -- --verbose $@

src/main.rs

@@ -1,20 +1,18 @@
 use std::{
-    env::{self},
+    env::{self, args},
     fs,
 };
 
-// TESTING 2
-
 use anyhow::Result;
 
 fn main() -> Result<()> {
     let args: Vec<String> = env::args().collect();
-    let path_to_workload = &args[1];
+    let path_to_workload = &args[2];
 
     let json = fs::read_to_string(path_to_workload).unwrap();
     let workload = kauma::utils::parse::parse_json(json)?;
 
-    let response = kauma::tasks::task_distribute(&workload)?;
+    let response = kauma::tasks::task_distrubute(&workload)?;
     println!("{}", serde_json::to_string(&response)?);
 
     Ok(())

src/tasks/mod.rs

@@ -1,28 +1,12 @@
-use base64::prelude::*;
-
 use std::collections::HashMap;
 
 use crate::utils::parse::{Responses, Testcase, Testcases};
-use tasks01::{
+use tasks01::{block2poly::block2poly, gfmul::gfmul, poly2block::poly2block, sea128::sea128};
-    block2poly::block2poly,
-    gcm::{gcm_decrypt, gcm_encrypt},
-    gcm_crack::gcm_crack,
-    gfmul::gfmul_task,
-    pad_oracle::padding_oracle,
-    pfmath::{
-        gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_factor_ddf, gfpoly_factor_edf,
-        gfpoly_factor_sff, gfpoly_gcd, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod,
-        gfpoly_sort, gfpoly_sqrt,
-    },
-    poly2block::poly2block,
-    sea128::sea128,
-    xex::fde_xex,
-};
 
 use anyhow::{anyhow, Result};
 use serde_json::{json, Value};
 
-pub mod tasks01;
+mod tasks01;
 
 pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
     /*
@@ -35,7 +19,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
 
     match testcase.action.as_str() {
         "poly2block" => {
-            let result = BASE64_STANDARD.encode(poly2block(args)?);
+            let result = poly2block(args);
             let json = json!({"block" : result});
             Ok(json)
         }
@@ -51,139 +35,10 @@ pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
             Ok(json)
         }
         "gfmul" => {
-            let result = BASE64_STANDARD.encode(gfmul_task(args)?);
+            let result = gfmul(args)?;
             let json = json!({"product" : result});
             Ok(json)
         }
-        "xex" => {
-            let result = BASE64_STANDARD.encode(fde_xex(args)?);
-            let json = json!({"output" : result});
-
-            Ok(json)
-        }
-        "gcm_encrypt" => {
-            let (ciphertext, auth_tag, l_field, auth_key_h) = gcm_encrypt(args)?;
-            let out_ciph = BASE64_STANDARD.encode(&ciphertext);
-            let out_tag = BASE64_STANDARD.encode(&auth_tag);
-            let out_l = BASE64_STANDARD.encode(&l_field);
-            let out_h = BASE64_STANDARD.encode(&auth_key_h);
-
-            let json = json!({"ciphertext" : out_ciph, "tag" : out_tag, "L" : out_l, "H" : out_h});
-
-            Ok(json)
-        }
-        "gcm_decrypt" => {
-            let (plaintext, valid) = gcm_decrypt(args)?;
-            let out_plain = BASE64_STANDARD.encode(&plaintext);
-            let json = json!({ "authentic" : valid, "plaintext" : out_plain});
-
-            Ok(json)
-        }
-        "padding_oracle" => {
-            let plaintext = padding_oracle(args)?;
-            let out_plain = BASE64_STANDARD.encode(&plaintext);
-            let json = json!({"plaintext" : out_plain});
-
-            Ok(json)
-        }
-        "gfpoly_add" => {
-            let result = gfpoly_add(args)?;
-            let json = json!({"S" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_mul" => {
-            let result = gfpoly_mul(args)?;
-            let json = json!({"P" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_pow" => {
-            let result = gfpoly_pow(args)?;
-            let json = json!({"Z" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfdiv" => {
-            let result = gfdiv(args)?;
-            let out = result.to_b64();
-            let json = json!({"q" : out});
-
-            Ok(json)
-        }
-        "gfpoly_divmod" => {
-            let result = gfpoly_divmod(args)?;
-            let json = json!({"Q" : result.0.to_c_array(), "R" : result.1.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_powmod" => {
-            let result = gfpoly_powmod(args)?;
-            let json = json!({"Z" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_sort" => {
-            let sorted_array = gfpoly_sort(args)?;
-            let mut result: Vec<Vec<String>> = vec![];
-
-            for poly in sorted_array {
-                result.push(poly.to_c_array());
-            }
-
-            let json = json!({"sorted_polys" : json!(result)});
-
-            Ok(json)
-        }
-        "gfpoly_make_monic" => {
-            let result = gfpoly_make_monic(args)?;
-            let json = json!({"A*" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_sqrt" => {
-            let result = gfpoly_sqrt(args)?;
-            let json = json!({"S" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_diff" => {
-            let result = gfpoly_diff(args)?;
-            let json = json!({"F'" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_gcd" => {
-            let result = gfpoly_gcd(args)?;
-            let json = json!({"G" : result.to_c_array()});
-
-            Ok(json)
-        }
-        "gfpoly_factor_sff" => {
-            let result = gfpoly_factor_sff(args)?;
-            let json = json!({"factors" : result});
-
-            Ok(json)
-        }
-        "gfpoly_factor_ddf" => {
-            let result = gfpoly_factor_ddf(args)?;
-            let json = json!({"factors" : result});
-
-            Ok(json)
-        }
-        "gfpoly_factor_edf" => {
-            let result = gfpoly_factor_edf(args)?;
-            let json = json!({"factors" : result});
-
-            Ok(json)
-        }
-        "gcm_crack" => {
-            let result = gcm_crack(args)?;
-            let json = json!(result);
-
-            Ok(json)
-        }
-
         _ => Err(anyhow!(
             "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}",
             testcase,
@@ -192,60 +47,16 @@ pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
     }
 }
 
-fn task_distribute_mt(testcases: &Testcases) -> Result<Responses> {
+pub fn task_distrubute(testcases: &Testcases) -> Result<Responses> {
-    eprintln!("USING MULTITHREADED");
-    let mut responses: HashMap<String, Value> = HashMap::new();
-    let pool = threadpool::ThreadPool::default();
-    let (tx, rx) = std::sync::mpsc::channel();
-    for (key, testcase) in testcases.testcases.clone() {
-        let tx = tx.clone();
-        let testcase = testcase.clone();
-        pool.execute(move || {
-            tx.send((key, task_deploy(&testcase)))
-                .expect("could not send return value of thread to main thread")
-        });
-    }
-
-    for _ in 0..testcases.testcases.len() {
-        let result = match rx.recv_timeout(std::time::Duration::from_secs(60 * 5)) {
-            Ok(r) => r,
-            Err(e) => {
-                eprintln!("! Job timed out: {e}");
-                return Err(e.into());
-            }
-        };
-        match result.1 {
-            Ok(v) => {
-                let _ = responses.insert(result.0, v);
-            }
-            Err(e) => {
-                eprintln!("! failed to solve a challenge: {e:#}");
-                continue;
-            }
-        }
-    }
-
-    Ok(Responses { responses })
-}
-
-pub fn task_distribute_st(testcases: &Testcases) -> Result<Responses> {
-    //eprintln!("USING SINGLETHREADED");
     let mut responses: HashMap<String, Value> = HashMap::new();
 
     for (id, testcase) in &testcases.testcases {
         responses.insert(id.to_owned(), task_deploy(testcase).unwrap());
     }
 
-    Ok(Responses { responses })
+    Ok(Responses {
-}
+        responses: responses,
-
+    })
-pub fn task_distribute(testcases: &Testcases) -> Result<Responses> {
-    let cpus = num_cpus::get();
-    if cpus > 1 {
-        task_distribute_mt(testcases)
-    } else {
-        task_distribute_st(testcases)
-    }
 }
 
 #[cfg(test)]
@@ -256,7 +67,7 @@ mod tests {
 
     #[test]
     fn test_task_deploy() {
-        let json = fs::read_to_string("test_json/poly2block_example.json").unwrap();
+        let json = fs::read_to_string("src/test_json/poly2block_example.json").unwrap();
         let parsed = parse_json(json).unwrap();
         let testcase = parsed
             .testcases
@@ -272,13 +83,13 @@ mod tests {
 
     #[test]
     fn test_task_distribution() -> Result<()> {
-        let json = fs::read_to_string("test_json/poly2block_example.json").unwrap();
+        let json = fs::read_to_string("src/test_json/poly2block_example.json").unwrap();
         let parsed = parse_json(json).unwrap();
 
         let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}});
 
         assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -287,7 +98,7 @@ mod tests {
 
     #[test]
     fn test_task_sea128_task_full() -> Result<()> {
-        let json = fs::read_to_string("test_json/sea128.json").unwrap();
+        let json = fs::read_to_string("src/test_json/sea128.json").unwrap();
         let parsed = parse_json(json).unwrap();
 
         let expected = json!({
@@ -302,7 +113,7 @@ mod tests {
         });
 
         assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -311,125 +122,13 @@ mod tests {
 
     #[test]
     fn test_task_gfmul_full() -> Result<()> {
-        let json = fs::read_to_string("test_json/gfmul_test.json").unwrap();
+        let json = fs::read_to_string("src/test_json/gfmul_test.json").unwrap();
         let parsed = parse_json(json).unwrap();
 
         let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}});
 
         assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_xex_full() -> Result<()> {
-        let json = fs::read_to_string("test_json/xex_tests.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses": {
-        "0192d428-3913-762b-a702-d14828eae1f8": {"output": "mHAVhRCKPAPx0BcufG5BZ4+/CbneMV/gRvqK5rtLe0OJgpDU5iT7z2P0R7gEeRDO"},
-        "0192d428-3913-7168-a3bb-69c258c74dc1": {"output": "SGV5IHdpZSBrcmFzcyBkYXMgZnVua3Rpb25pZXJ0IGphIG9mZmVuYmFyIGVjaHQu"}
-        }});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_gcm_encrypt_aes_case() -> Result<()> {
-        let json = fs::read_to_string("test_json/gcm_encrypt.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : {
-        "ciphertext": "ET3RmvH/Hbuxba63EuPRrw==",
-        "tag": "Mp0APJb/ZIURRwQlMgNN/w==",
-        "L": "AAAAAAAAAEAAAAAAAAAAgA==",
-        "H": "Bu6ywbsUKlpmZXMQyuGAng=="
-        }}});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_gcm_encrypt_sea_case() -> Result<()> {
-        let json = fs::read_to_string("test_json/gcm_encrypt_sea.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : {
-        "ciphertext": "0cI/Wg4R3URfrVFZ0hw/vg==",
-        "tag": "ysDdzOSnqLH0MQ+Mkb23gw==",
-        "L": "AAAAAAAAAEAAAAAAAAAAgA==",
-        "H": "xhFcAUT66qWIpYz+Ch5ujw=="
-        }}});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_gcm_decrypt_aes_case() -> Result<()> {
-        let json = fs::read_to_string("test_json/gcm_decrypt_aes.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : {
-        "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==",
-        "authentic": true,
-        }}});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_gcm_decrypt_sea_case() -> Result<()> {
-        let json = fs::read_to_string("test_json/gcm_decrypt_sea.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : {
-        "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==",
-        "authentic": true,
-        }}});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
-            serde_json::to_value(expected).unwrap()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_task_gcm_gfpoly_add() -> Result<()> {
-        let json = fs::read_to_string("test_json/gcm_decrypt_sea.json").unwrap();
-        let parsed = parse_json(json).unwrap();
-
-        let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : {
-        "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==",
-        "authentic": true,
-        }}});
-
-        assert_eq!(
-            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 

src/tasks/tasks01/block2poly.rs

@@ -1,17 +1,15 @@
-use crate::utils::poly::block_2_polynomial;
+use crate::utils::poly::{b64_2_num, get_coefficients};
 use anyhow::Result;
-use base64::prelude::*;
 use serde_json::Value;
 
 pub fn block2poly(val: &Value) -> Result<Vec<u8>> {
     // Convert JSON data in to a u128
     // TODO: Transfer decoding into own function?
     let string: String = serde_json::from_value(val["block"].clone())?;
-    let block = BASE64_STANDARD.decode(string)?;
 
-    let semantic: String = serde_json::from_value(val["semantic"].clone())?;
+    let number = b64_2_num(&string)?;
 
-    let coefficients: Vec<u8> = block_2_polynomial(block, &semantic)?; //get_coefficients(number);
+    let coefficients: Vec<u8> = get_coefficients(number);
 
     Ok(coefficients)
 }
@@ -19,13 +17,14 @@ pub fn block2poly(val: &Value) -> Result<Vec<u8>> {
 #[cfg(test)]
 mod tests {
     use serde_json::json;
+    use std::str::FromStr;
 
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
     #[test]
     fn block2poly_task01() -> Result<()> {
-        let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "xex"});
+        let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA=="});
         let coefficients: Vec<u8> = vec![0, 9, 12, 127];
         assert_eq!(
             block2poly(&block)?,
@@ -36,18 +35,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[test]
-    fn block2poly_task02() -> Result<()> {
-        let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "gcm"});
-        let coefficients: Vec<u8> = vec![7, 11, 14, 120];
-        assert_eq!(
-            block2poly(&block)?,
-            coefficients,
-            "Coefficients were: {:?}",
-            block2poly(&block)?
-        );
-
-        Ok(())
-    }
 }

src/tasks/tasks01/gcm.rs

@@ -1,52 +0,0 @@
-use anyhow::{anyhow, Result};
-use base64::prelude::*;
-use serde_json::Value;
-
-use crate::utils::ciphers::{gcm_decrypt_aes, gcm_decrypt_sea, gcm_encrypt_aes, gcm_encrypt_sea};
-
-pub fn gcm_encrypt(args: &Value) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>)> {
-    let nonce_text: String = serde_json::from_value(args["nonce"].clone())?;
-    let nonce = BASE64_STANDARD.decode(nonce_text)?;
-
-    let key_text: String = serde_json::from_value(args["key"].clone())?;
-    let key = BASE64_STANDARD.decode(key_text)?;
-
-    let plaintext_text: String = serde_json::from_value(args["plaintext"].clone())?;
-    let plaintext = BASE64_STANDARD.decode(plaintext_text)?;
-
-    let ad_text: String = serde_json::from_value(args["ad"].clone())?;
-    let ad = BASE64_STANDARD.decode(ad_text)?;
-
-    let alg_text: String = serde_json::from_value(args["algorithm"].clone())?;
-
-    match alg_text.as_str() {
-        "aes128" => Ok(gcm_encrypt_aes(nonce, key, plaintext, ad)?),
-        "sea128" => Ok(gcm_encrypt_sea(nonce, key, plaintext, ad)?),
-        _ => Err(anyhow!("No compatible algorithm found")),
-    }
-}
-
-pub fn gcm_decrypt(args: &Value) -> Result<(Vec<u8>, bool)> {
-    let nonce_text: String = serde_json::from_value(args["nonce"].clone())?;
-    let nonce = BASE64_STANDARD.decode(nonce_text)?;
-
-    let key_text: String = serde_json::from_value(args["key"].clone())?;
-    let key = BASE64_STANDARD.decode(key_text)?;
-
-    let plaintext_text: String = serde_json::from_value(args["ciphertext"].clone())?;
-    let plaintext = BASE64_STANDARD.decode(plaintext_text)?;
-
-    let ad_text: String = serde_json::from_value(args["ad"].clone())?;
-    let ad = BASE64_STANDARD.decode(ad_text)?;
-
-    let tag_text: String = serde_json::from_value(args["tag"].clone())?;
-    let tag = BASE64_STANDARD.decode(tag_text)?;
-
-    let alg_text: String = serde_json::from_value(args["algorithm"].clone())?;
-
-    match alg_text.as_str() {
-        "aes128" => Ok(gcm_decrypt_aes(nonce, key, plaintext, ad, tag)?),
-        "sea128" => Ok(gcm_decrypt_sea(nonce, key, plaintext, ad, tag)?),
-        _ => Err(anyhow!("No compatible algorithm found")),
-    }
-}

src/tasks/tasks01/gcm_crack.rs

@@ -1,174 +0,0 @@
-
-use anyhow::{Ok, Result};
-use base64::{prelude::BASE64_STANDARD, Engine};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-use crate::utils::{
-    ciphers::ghash,
-    dff::ddf,
-    edf::edf,
-    field::FieldElement,
-    math::{reverse_bits_in_bytevec, xor_bytes},
-    poly::Polynomial,
-    sff::sff,
-};
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct CrackAnswer {
-    tag: String,
-    H: String,
-    mask: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct Message {
-    ciphertext: Vec<u8>,
-    ad: Vec<u8>,
-    tag: Vec<u8>,
-    l_field: Vec<u8>,
-}
-
-fn parse_message(val: &Value) -> Result<(Message, Polynomial)> {
-    let ciphertext_text: String = serde_json::from_value(val["ciphertext"].clone())?;
-    let mut ciphertext_bytes: Vec<u8> = BASE64_STANDARD.decode(ciphertext_text)?;
-    let mut c_len: Vec<u8> = ((ciphertext_bytes.len() * 8) as u64).to_be_bytes().to_vec();
-
-    if ciphertext_bytes.len() % 16 != 0 {
-        ciphertext_bytes.append(vec![0u8; 16 - (ciphertext_bytes.len() % 16)].as_mut());
-    }
-
-    let ciphertext_chunks: Vec<FieldElement> = ciphertext_bytes
-        .chunks(16)
-        .into_iter()
-        .map(|chunk| FieldElement::new(chunk.to_vec()))
-        .collect();
-
-    let ad_text: String = serde_json::from_value(val["associated_data"].clone())?;
-    let mut ad_bytes: Vec<u8> = BASE64_STANDARD.decode(ad_text)?;
-    let mut l_field: Vec<u8> = ((ad_bytes.len() * 8) as u64).to_be_bytes().to_vec();
-
-    if ad_bytes.len() % 16 != 0 || ad_bytes.is_empty() {
-        ad_bytes.append(vec![0u8; 16 - (ad_bytes.len() % 16)].as_mut());
-    }
-
-    let ad_chunks: Vec<FieldElement> = ad_bytes
-        .chunks(16)
-        .into_iter()
-        .map(|chunk| FieldElement::new(chunk.to_vec()))
-        .collect();
-
-    let tag_text: String = serde_json::from_value(val["tag"].clone()).unwrap_or("".to_string());
-    let tag_bytes: Vec<u8> = BASE64_STANDARD.decode(tag_text)?;
-    let tag_field: FieldElement = FieldElement::new(tag_bytes.clone());
-
-    l_field.append(c_len.as_mut());
-
-    // Combine all data
-    let mut combined: Vec<FieldElement> =
-        Vec::with_capacity(ad_chunks.len() + ciphertext_chunks.len() + 1);
-    combined.extend(ad_chunks);
-    combined.extend(ciphertext_chunks.clone());
-    combined.push(FieldElement::new(l_field.clone()));
-    combined.push(tag_field);
-
-    combined.reverse();
-
-    let h_poly: Polynomial = Polynomial::new(combined);
-
-    Ok((
-        Message {
-            ciphertext: ciphertext_bytes,
-            ad: ad_bytes,
-            tag: tag_bytes,
-            l_field,
-        },
-        h_poly,
-    ))
-}
-
-pub fn gcm_crack(args: &Value) -> Result<CrackAnswer> {
-    // Prepare first equation
-    let (m1_data, m1_h_poly) = parse_message(&args["m1"])?;
-
-    let (_, m2_h_poly) = parse_message(&args["m2"])?;
-
-    let (m3_data, _) = parse_message(&args["m3"])?;
-
-    let combine_poly = m1_h_poly + m2_h_poly;
-
-    let combine_sff = sff(combine_poly.monic());
-
-    let mut combine_ddf: Vec<(Polynomial, u128)> = vec![];
-    for (factor, _) in combine_sff {
-        combine_ddf.extend(ddf(factor));
-    }
-
-    let mut combine_edf: Vec<Polynomial> = vec![];
-    for (factor, degree) in combine_ddf {
-        if degree == 1 {
-            combine_edf.extend(edf(factor, degree as u32));
-        }
-    }
-
-    let mut m3_auth_tag: Vec<u8> = vec![];
-    let mut h_candidate: FieldElement = FieldElement::zero();
-    let mut eky0: Vec<u8> = vec![];
-    for candidate in combine_edf {
-        if candidate.degree() == 1 {
-            h_candidate = candidate.extract_component(0);
-            let m1_ghash = ghash(
-                reverse_bits_in_bytevec(h_candidate.to_vec()),
-                m1_data.ad.clone(),
-                m1_data.ciphertext.clone(),
-                m1_data.l_field.clone(),
-            )
-            .unwrap();
-
-            eky0 = xor_bytes(&m1_data.tag, m1_ghash).unwrap();
-            eprintln!("eky0: {:?}", BASE64_STANDARD.encode(eky0.clone()));
-
-            let m3_ghash = ghash(
-                reverse_bits_in_bytevec(h_candidate.to_vec()),
-                m3_data.ad.clone(),
-                m3_data.ciphertext.clone(),
-                m3_data.l_field.clone(),
-            )
-            .unwrap();
-
-            m3_auth_tag = xor_bytes(&eky0, m3_ghash).unwrap();
-            eprintln!(
-                "M3 auth tag: {:02X?}",
-                BASE64_STANDARD.encode(m3_auth_tag.clone())
-            );
-
-            if m3_auth_tag == m3_data.tag {
-                break;
-            } else {
-                eprintln!("H candidate not valid");
-            }
-        }
-    }
-
-    let (forgery_data, _) = parse_message(&args["forgery"])?;
-
-    let forgery_ghash = ghash(
-        reverse_bits_in_bytevec(h_candidate.to_vec()),
-        forgery_data.ad.clone(),
-        forgery_data.ciphertext.clone(),
-        forgery_data.l_field.clone(),
-    )
-    .unwrap();
-
-    let forgery_auth_tag = xor_bytes(&eky0, forgery_ghash).unwrap();
-
-    if eky0.is_empty() {
-        eky0 = vec![0; 16];
-    }
-
-    Ok(CrackAnswer {
-        tag: BASE64_STANDARD.encode(forgery_auth_tag),
-        H: h_candidate.to_b64(),
-        mask: BASE64_STANDARD.encode(eky0),
-    })
-}

src/tasks/tasks01/gfmul.rs

@@ -1,26 +1,59 @@
-use crate::utils::poly::gfmul;
-
 use anyhow::Result;
 use base64::prelude::*;
+//use num_bigint::{BigUint, ToBigUint};
 use serde_json::Value;
 
-pub fn gfmul_task(args: &Value) -> Result<Vec<u8>> {
+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> {
+    let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec());
+    red_poly_bytes.0.push(0x01);
+
     let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-    let poly_a = BASE64_STANDARD.decode(poly1_text)?;
+    let mut poly1: ByteArray = ByteArray(BASE64_STANDARD.decode(poly1_text)?);
+    poly1.0.push(0x00);
 
     let poly2_text: String = serde_json::from_value(args["b"].clone())?;
-    let poly_b = BASE64_STANDARD.decode(poly2_text)?;
+    let mut poly2: ByteArray = ByteArray(BASE64_STANDARD.decode(poly2_text)?);
+    poly2.0.push(0x00);
 
-    let semantic: String = serde_json::from_value(args["semantic"].clone())?;
+    let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
-    let result = gfmul(&poly_a, &poly_b, &semantic)?;
+    if poly2.LSB_is_one() {
+        result.xor_byte_arrays(&poly1);
+        poly2.right_shift();
+    } else {
+        poly2.right_shift();
+    }
 
-    Ok(result)
+    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();
+    }
+
+    result.0.remove(16);
+    let mut bytes: [u8; 16] = [0u8; 16];
+    bytes.copy_from_slice(&result.0);
+
+    Ok(BASE64_STANDARD.encode(bytes))
 }
 
 #[cfg(test)]
 mod tests {
     use serde_json::json;
+    use std::str::FromStr;
 
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
@@ -28,75 +61,7 @@ mod tests {
     #[test]
     fn gfmul_task01() -> Result<()> {
         let args: Value = json!({"a": "ARIAAAAAAAAAAAAAAAAAgA==", "b": "AgAAAAAAAAAAAAAAAAAAAA=="});
-
+        let result = gfmul(&args)?;
-        let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-        let poly_a = BASE64_STANDARD.decode(poly1_text)?;
-
-        let poly2_text: String = serde_json::from_value(args["b"].clone())?;
-        let poly_b = BASE64_STANDARD.decode(poly2_text)?;
-
-        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
-
-        assert_eq!(
-            result, "hSQAAAAAAAAAAAAAAAAAAA==",
-            "Failure. Calulated result was: {}",
-            result
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn gfmul_task02() -> Result<()> {
-        let args: Value = json!({"a": "AwEAAAAAAAAAAAAAAAAAgA==", "b": "gBAAAAAAAAAAAAAAAAAAAA=="});
-
-        let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-        let poly_a = BASE64_STANDARD.decode(poly1_text)?;
-
-        let poly2_text: String = serde_json::from_value(args["b"].clone())?;
-        let poly_b = BASE64_STANDARD.decode(poly2_text)?;
-
-        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
-
-        assert_eq!(
-            result, "QKgUAAAAAAAAAAAAAAAAAA==",
-            "Failure. Calulated result was: {}",
-            result
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn gfmul_task03() -> Result<()> {
-        let args: Value = json!({"a": "AwEAAAAAAAAAAAAAAAAAgA==", "b": "oBAAAAAAAAAAAAAAAAAAAA=="});
-
-        let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-        let poly_a = BASE64_STANDARD.decode(poly1_text)?;
-
-        let poly2_text: String = serde_json::from_value(args["b"].clone())?;
-        let poly_b = BASE64_STANDARD.decode(poly2_text)?;
-
-        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
-
-        assert_eq!(
-            result, "UIAUAAAAAAAAAAAAAAAAAA==",
-            "Failure. Calulated result was: {}",
-            result
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn gfmul_task04() -> Result<()> {
-        let args: Value = json!({"a": "ARIAAAAAAAAAAAAAAAAAgA==", "b": "AgAAAAAAAAAAAAAAAAAAAA=="});
-
-        let poly1_text: String = serde_json::from_value(args["a"].clone())?;
-        let poly_a = BASE64_STANDARD.decode(poly1_text)?;
-
-        let poly2_text: String = serde_json::from_value(args["b"].clone())?;
-        let poly_b = BASE64_STANDARD.decode(poly2_text)?;
-
-        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
-
         assert_eq!(
             result, "hSQAAAAAAAAAAAAAAAAAAA==",
             "Failure. Calulated result was: {}",

src/tasks/tasks01/mod.rs

@@ -1,9 +1,4 @@
 pub mod block2poly;
-pub mod gcm;
-pub mod gcm_crack;
 pub mod gfmul;
-pub mod pad_oracle;
-pub mod pfmath;
 pub mod poly2block;
 pub mod sea128;
-pub mod xex;

src/tasks/tasks01/pad_oracle.rs

@@ -1,148 +0,0 @@
-use anyhow::Result;
-use base64::prelude::*;
-use serde_json::Value;
-use std::io::prelude::*;
-use std::net::TcpStream;
-use std::usize;
-
-pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
-    let hostname: String = serde_json::from_value(args["hostname"].clone())?;
-
-    let port_val: Value = serde_json::from_value(args["port"].clone())?;
-    let port: u64 = port_val.as_u64().expect("Failure in parsing port number");
-
-    let iv_string: String = serde_json::from_value(args["iv"].clone())?;
-    let iv: Vec<u8> = BASE64_STANDARD.decode(iv_string)?;
-
-    let cipher_text: String = serde_json::from_value(args["ciphertext"].clone())?;
-    let ciphertext: Vec<u8> = BASE64_STANDARD.decode(cipher_text)?;
-
-    // Initialise tracker to adapt correct byte
-    let byte_counter = 15;
-    eprintln!("byte_counter is: {}", byte_counter);
-
-    let mut plaintext: Vec<u8> = vec![];
-    eprintln!("Ciphertext: {:002X?}", ciphertext);
-
-    let cipher_chunks: Vec<&[u8]> = ciphertext.chunks(16).rev().collect();
-    let mut chunk_counter = 0;
-
-    for chunk in &cipher_chunks {
-        let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?;
-        stream.set_nodelay(true).expect("Error on no delay");
-        stream.set_nonblocking(false)?;
-
-        // Track value sent to server
-        let mut attack_counter: Vec<u8> = vec![0; 16];
-
-        // Amount of q blocks to send to server.
-        // TODO:: May be increased via function
-        let q_block_count: u16 = 256;
-
-        //Send the first ciphertext chunk
-        stream.flush()?;
-        stream.write_all(&chunk)?;
-        stream.flush()?;
-
-        for i in (0..=15).rev() {
-            // Craft length message
-            // FIXME: Assignment is redundant for now
-            // TODO: Goal is to maybe add speed increase in the future
-            let l_msg: [u8; 2] = q_block_count.to_le_bytes();
-
-            // Generate attack blocks
-            //  TODO: Collect all and send in one
-            let mut payload: Vec<u8> = Vec::with_capacity(2 + 16 * 265);
-            payload.extend(l_msg.to_vec());
-            for _j in 0..q_block_count {
-                // Next byte
-                payload.extend(&attack_counter);
-                attack_counter[i as usize] += 1;
-            }
-
-            stream.write_all(&payload)?;
-            stream.flush()?;
-
-            // Read server response
-            let mut server_q_resp = [0u8; 256];
-            stream.read_exact(&mut server_q_resp)?;
-
-            // extract valid position
-            let valid_val = server_q_resp
-                .iter()
-                .position(|&r| r == 0x01)
-                .unwrap_or(0x00) as u8;
-            if valid_val == 0x00 {
-                eprintln!("No valid found in main loop");
-            }
-            // Craft next attack vector padding; 0x01, 0x02, ...
-            attack_counter[i as usize] = valid_val;
-
-            // Check for edgecase
-            if i == 15 {
-                let mut l_msg_check: Vec<u8> = vec![0x01, 0x00];
-                let mut check_q_block: Vec<u8> = vec![0; 16];
-                check_q_block[15] = attack_counter[15];
-                check_q_block[14] = !check_q_block[15];
-
-                l_msg_check.extend(check_q_block.as_slice());
-
-                stream.write_all(&l_msg_check)?;
-                let mut buf = [0u8; 0x01];
-                stream.read(&mut buf)?;
-                if buf == [0x01] {
-                } else {
-                    // Search for second hit
-                    let valid_val = 255
-                        - server_q_resp
-                            .iter()
-                            .rev()
-                            .position(|&r| r == 0x01)
-                            .unwrap_or(0x00) as u8;
-                    if valid_val == 0x00 {
-                        eprintln!("No valid found");
-                    }
-                    // Craft next attack vector padding; 0x01, 0x02, ...
-                    attack_counter[i as usize] = valid_val;
-                }
-            }
-
-            if chunk_counter + 1 < cipher_chunks.len() {
-                plaintext.push(
-                    cipher_chunks[chunk_counter + 1][i]
-                        ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1)),
-                );
-            } else {
-                plaintext.push(iv[i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1)));
-            }
-            let range = i;
-            for pos in range..=15 {
-                let intermediate = attack_counter[pos as usize] ^ (15 - i as u8 + 1);
-
-                attack_counter[pos as usize] = intermediate ^ ((15 - i as u8 + 1) + 1);
-            }
-
-            stream.flush()?;
-
-            // Write plaintext
-        }
-        chunk_counter += 1;
-        stream.flush()?;
-        drop(stream);
-    }
-
-    plaintext.reverse();
-
-    eprintln!("{:02X?}", BASE64_STANDARD.encode(&plaintext));
-    Ok(plaintext)
-} // the stream is closed here
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_connection() -> Result<()> {
-        Ok(())
-    }
-}

src/tasks/tasks01/pfmath.rs

@@ -1,282 +0,0 @@
-
-use anyhow::Result;
-use base64::{prelude::BASE64_STANDARD, Engine};
-use serde_json::Value;
-
-use crate::utils::{
-        self,
-        dff::ddf,
-        edf::edf,
-        field::FieldElement,
-        poly::{gcd, Polynomial},
-        sff::{sff, Factors},
-    };
-
-pub fn gfpoly_add(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let poly_b = Polynomial::from_c_array(&args["B"].clone());
-
-    let result = poly_a + poly_b;
-
-    Ok(result)
-}
-
-pub fn gfpoly_mul(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let poly_b = Polynomial::from_c_array(&args["B"].clone());
-
-    let result = poly_a * poly_b;
-
-    Ok(result)
-}
-
-pub fn gfpoly_pow(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let k: u128 = serde_json::from_value(args["k"].clone())?;
-
-    let result = poly_a.pow(k);
-
-    Ok(result)
-}
-
-pub fn gfdiv(args: &Value) -> Result<FieldElement> {
-    let f1_text: String = serde_json::from_value(args["a"].clone())?;
-    let f_a = FieldElement::new(BASE64_STANDARD.decode(f1_text)?);
-
-    let f2_text: String = serde_json::from_value(args["b"].clone())?;
-    let f_b = FieldElement::new(BASE64_STANDARD.decode(f2_text)?);
-
-    let result = f_a / f_b;
-
-    Ok(result)
-}
-
-pub fn gfpoly_divmod(args: &Value) -> Result<(Polynomial, Polynomial)> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let poly_b = Polynomial::from_c_array(&args["B"].clone());
-
-    let result = poly_a.div(&poly_b);
-
-    Ok(result)
-}
-
-pub fn gfpoly_powmod(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let poly_m = Polynomial::from_c_array(&args["M"].clone());
-
-    let k: u128 = serde_json::from_value(args["k"].clone())?;
-
-    let result = poly_a.pow_mod(k, poly_m);
-
-    Ok(result)
-}
-
-pub fn gfpoly_sort(args: &Value) -> Result<Vec<Polynomial>> {
-    let poly_arrays: Vec<Value> = serde_json::from_value(args["polys"].clone())?;
-    let mut polys: Vec<Polynomial> = vec![];
-
-    for array in poly_arrays {
-        polys.push(Polynomial::from_c_array(&array));
-    }
-
-    polys.sort();
-    //polys.sort();
-    Ok(polys)
-}
-
-pub fn gfpoly_make_monic(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-
-    let result = poly_a.monic();
-
-    Ok(result)
-}
-
-pub fn gfpoly_sqrt(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["Q"].clone());
-
-    let result = poly_a.sqrt();
-
-    Ok(result)
-}
-
-pub fn gfpoly_diff(args: &Value) -> Result<Polynomial> {
-    let poly_f = Polynomial::from_c_array(&args["F"].clone());
-
-    let result = poly_f.diff();
-
-    Ok(result)
-}
-
-pub fn gfpoly_gcd(args: &Value) -> Result<Polynomial> {
-    let poly_a = Polynomial::from_c_array(&args["A"].clone());
-    let poly_b = Polynomial::from_c_array(&args["B"].clone());
-
-    let result = gcd(&poly_a.monic(), &poly_b.monic());
-
-    Ok(result)
-}
-
-pub fn gfpoly_factor_sff(arsg: &Value) -> Result<Vec<Factors>> {
-    let poly_f = Polynomial::from_c_array(&arsg["F"].clone());
-
-    let mut factors = sff(poly_f);
-    factors.sort();
-    let mut result: Vec<Factors> = vec![];
-
-    for (factor, exponent) in factors {
-        result.push(Factors {
-            factor: factor.to_c_array(),
-            exponent,
-        });
-    }
-
-    Ok(result)
-}
-
-pub fn gfpoly_factor_ddf(arsg: &Value) -> Result<Vec<utils::dff::Factors>> {
-    let poly_f = Polynomial::from_c_array(&arsg["F"].clone());
-
-    let mut factors = ddf(poly_f);
-    factors.sort();
-    let mut result: Vec<utils::dff::Factors> = vec![];
-
-    for (factor, degree) in factors {
-        result.push(utils::dff::Factors {
-            factor: factor.to_c_array(),
-            degree: degree as u32,
-        });
-    }
-
-    Ok(result)
-}
-
-pub fn gfpoly_factor_edf(arsg: &Value) -> Result<Vec<Vec<String>>> {
-    let poly_f = Polynomial::from_c_array(&arsg["F"].clone());
-    let d: u32 = serde_json::from_value(arsg["d"].clone())?;
-
-    let mut factors = edf(poly_f, d);
-
-    factors.sort();
-
-    let mut result: Vec<Vec<String>> = vec![];
-
-    for factor in factors {
-        result.push(factor.to_c_array())
-    }
-
-    Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn test_poly_sorting() {
-        let json1 = json!(
-            {"polys": [
-            [
-                "NeverGonnaGiveYouUpAAA==",
-                "NeverGonnaLetYouDownAA==",
-                "NeverGonnaRunAroundAAA==",
-                "AndDesertYouAAAAAAAAAA=="
-            ],
-            [
-                "WereNoStrangersToLoveA==",
-                "YouKnowTheRulesAAAAAAA==",
-                "AndSoDoIAAAAAAAAAAAAAA=="
-            ],
-            [
-                "NeverGonnaMakeYouCryAA==",
-                "NeverGonnaSayGoodbyeAA==",
-                "NeverGonnaTellALieAAAA==",
-                "AndHurtYouAAAAAAAAAAAA=="
-            ]
-        ]});
-
-        let expected = json!([
-            [
-                "WereNoStrangersToLoveA==",
-                "YouKnowTheRulesAAAAAAA==",
-                "AndSoDoIAAAAAAAAAAAAAA=="
-            ],
-            [
-                "NeverGonnaMakeYouCryAA==",
-                "NeverGonnaSayGoodbyeAA==",
-                "NeverGonnaTellALieAAAA==",
-                "AndHurtYouAAAAAAAAAAAA=="
-            ],
-            [
-                "NeverGonnaGiveYouUpAAA==",
-                "NeverGonnaLetYouDownAA==",
-                "NeverGonnaRunAroundAAA==",
-                "AndDesertYouAAAAAAAAAA=="
-            ]
-        ]);
-
-        let sorted_array = gfpoly_sort(&json1).unwrap();
-        let mut result: Vec<Vec<String>> = vec![];
-        for poly in sorted_array {
-            result.push(poly.to_c_array());
-        }
-
-        assert_eq!(json!(result), expected);
-        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
-    }
-
-    #[test]
-    fn test_poly_sorting_02() {
-        let json1 = json!(
-            {"polys": [
-            [
-            "AQAAAAAAAAAAAAAAAAAAAA==",  // 0x01
-            "AgAAAAAAAAAAAAAAAAAAAA==",  // 0x02 
-            "AwAAAAAAAAAAAAAAAAAAAA=="   // 0x03
-            ],
-            [
-            "AQAAAAAAAAAAAAAAAAAAAA==",  // 0x01
-            "AgAAAAAAAAAAAAAAAAAAAA==",  // 0x02
-            "BAAAAAAAAAAAAAAAAAAAAA=="   // 0x04
-            ],
-            [
-            "AQAAAAAAAAAAAAAAAAAAAA==",  // 0x01
-            "AgAAAAAAAAAAAAAAAAAAAA=="   // 0x02
-            ],
-            [
-            "AQAAAAAAAAAAAAAAAAAAAA==",  // 0x01
-            "AwAAAAAAAAAAAAAAAAAAAA=="   // 0x03
-            ]
-        ],});
-
-        let expected = json!([
-            ["AQAAAAAAAAAAAAAAAAAAAA==", "AgAAAAAAAAAAAAAAAAAAAA=="],
-            ["AQAAAAAAAAAAAAAAAAAAAA==", "AwAAAAAAAAAAAAAAAAAAAA=="],
-            [
-                "AQAAAAAAAAAAAAAAAAAAAA==",
-                "AgAAAAAAAAAAAAAAAAAAAA==",
-                "BAAAAAAAAAAAAAAAAAAAAA=="
-            ],
-            [
-                "AQAAAAAAAAAAAAAAAAAAAA==",
-                "AgAAAAAAAAAAAAAAAAAAAA==",
-                "AwAAAAAAAAAAAAAAAAAAAA=="
-            ]
-        ]);
-
-        let sorted_array = gfpoly_sort(&json1).unwrap();
-        let mut result: Vec<Vec<String>> = vec![];
-        for poly in sorted_array {
-            result.push(poly.to_c_array());
-        }
-
-        assert_eq!(json!(result), expected);
-        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
-    }
-}

src/tasks/tasks01/poly2block.rs

@@ -1,8 +1,8 @@
-use crate::utils::poly::polynomial_2_block;
+use crate::utils::poly::{self};
-use anyhow::{Ok, Result};
+use base64::prelude::*;
 use serde_json::Value;
 
-pub fn poly2block(args: &Value) -> Result<Vec<u8>> {
+pub fn poly2block(args: &Value) -> String {
     let coefficients: Vec<u8> = args["coefficients"]
         .as_array()
         .unwrap()
@@ -10,9 +10,5 @@ pub fn poly2block(args: &Value) -> Result<Vec<u8>> {
         .map(|x| x.as_u64().unwrap() as u8)
         .collect();
 
-    let semantic: String = serde_json::from_value(args["semantic"].clone())?;
+    BASE64_STANDARD.encode(poly::coefficient_to_binary(coefficients).to_ne_bytes())
-
-    let result = polynomial_2_block(coefficients, &semantic).unwrap();
-
-    Ok(result)
 }

src/tasks/tasks01/sea128.rs

@@ -6,13 +6,19 @@ use crate::utils::ciphers::{sea_128_decrypt, sea_128_encrypt};
 
 pub fn sea128(args: &Value) -> Result<String> {
     let key_string: String = serde_json::from_value(args["key"].clone())?;
+    //let key: &[u8] = b64_2_num(key_string)?.to_ne_bytes();
     let key = BASE64_STANDARD.decode(key_string)?;
+    //eprintln!("{:?}", key);
     let input_string: String = serde_json::from_value(args["input"].clone())?;
+    //let plaintexts: &[u8] = &b64_2_num(plaintexts_string)?.to_ne_bytes();
     let input = BASE64_STANDARD.decode(input_string)?;
+    let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11;
 
     let mode: String = serde_json::from_value(args["mode"].clone())?;
     match mode.as_str() {
         "encrypt" => {
+            //eprintln!("{:?}", plaintexts);
+
             let output = BASE64_STANDARD.encode(sea_128_encrypt(&key, &input)?);
 
             Ok(output)
@@ -28,6 +34,7 @@ pub fn sea128(args: &Value) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
+    use std::fs;
 
     use anyhow::Result;
     use serde_json::json;

src/tasks/tasks01/xex.rs

@@ -1,27 +0,0 @@
-use anyhow::{anyhow, Result};
-use base64::prelude::*;
-use serde_json::Value;
-
-use crate::utils::ciphers::{xex_decrypt, xex_encrypt};
-
-pub fn fde_xex(args: &Value) -> Result<Vec<u8>> {
-    let key_string: String = serde_json::from_value(args["key"].clone())?;
-    let key: Vec<u8> = BASE64_STANDARD.decode(key_string)?;
-
-    let tweak_string: String = serde_json::from_value(args["tweak"].clone())?;
-    let tweak: Vec<u8> = BASE64_STANDARD.decode(tweak_string)?;
-
-    let input_string: String = serde_json::from_value(args["input"].clone())?;
-    let input: Vec<u8> = BASE64_STANDARD.decode(input_string)?;
-
-    let mode_string: String = serde_json::from_value(args["mode"].clone())?;
-
-    match mode_string.as_str() {
-        "encrypt" => Ok(xex_encrypt(key, &tweak, &input)?),
-        "decrypt" => Ok(xex_decrypt(key, &tweak, &input)?),
-        _ => Err(anyhow!(
-            "Failure: No compatible mode found. Data was: {:?}",
-            args
-        )),
-    }
-}

src/utils/ciphers.rs

@@ -1,12 +1,8 @@
-use crate::utils::{field::ByteArray, poly::gfmul};
 use anyhow::Result;
 use openssl::symm::{Cipher, Crypter, Mode};
 
 use super::math::xor_bytes;
 
-/// AES ENCRYPT
-/// Function to perform encryption with AES ECB mode
-/// Function does not use padding for blocks
 pub fn aes_128_encrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
     let mut encrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Encrypt, &key, None)?;
     encrypter.pad(false);
@@ -22,9 +18,6 @@ pub fn aes_128_encrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
     Ok(ciphertext)
 }
 
-/// AES DECRPYT
-/// Function to perform decryption with AES ECB mode
-/// Function does not use padding for blocks    
 pub fn aes_128_decrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
     let mut decrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Decrypt, key, None)?;
     decrypter.pad(false);
@@ -37,18 +30,13 @@ pub fn aes_128_decrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
 
     let mut bytes: [u8; 16] = [0u8; 16];
     bytes.copy_from_slice(&plaintext);
+    let number: u128 = <u128>::from_be_bytes(bytes);
 
     Ok(plaintext)
 }
 
-/// SEA ENCRYPT
-/// Function to perform sea encrption.
-/// At its core, the function ses the AES ENCRYPT, but then xors with a constant value of:
-/// 0xc0ffeec0ffeec0ffeec0ffeec0ffee11
 pub fn sea_128_encrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
-    // Constant value used for XOR
     let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11;
-
     let sea128_out = xor_bytes(
         &aes_128_encrypt(key, input)?,
         xor_val.to_be_bytes().to_vec(),
@@ -56,507 +44,16 @@ pub fn sea_128_encrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
     Ok(sea128_out)
 }
 
-/// SEA DECRYPT
-/// Function to perform sea decryption.
-/// At its core, the function ses the AES DECRYPT, but then xors with a constant value of:
-/// 0xc0ffeec0ffeec0ffeec0ffeec0ffee11
 pub fn sea_128_decrypt(key: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
-    // Constant value used for XOR
     let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11;
 
     let intermediate = xor_bytes(input, xor_val.to_be_bytes().to_vec())?;
     Ok(aes_128_decrypt(&key, &intermediate)?)
 }
 
-/// Function to perform xex encryption.
-/// The function performs the encryption for XEX on the basis of the SEA ENCRYPT.
-pub fn xex_encrypt(mut key: Vec<u8>, tweak: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
-    let key2: Vec<u8> = key.split_off(16);
-
-    let input_chunks: Vec<Vec<u8>> = input.chunks(16).map(|x| x.to_vec()).collect();
-
-    let mut output: Vec<u8> = vec![];
-    let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?);
-
-    for chunk in input_chunks {
-        let plaintext_intermediate = xor_bytes(&tweak_block.0, chunk)?;
-        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("xex");
-    }
-
-    Ok(output)
-}
-
-pub fn xex_decrypt(mut key: Vec<u8>, tweak: &Vec<u8>, input: &Vec<u8>) -> Result<Vec<u8>> {
-    let key2: Vec<u8> = key.split_off(16);
-    let input_chunks: Vec<Vec<u8>> = input.chunks(16).map(|x| x.to_vec()).collect();
-
-    let mut output: Vec<u8> = vec![];
-    let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?);
-
-    for chunk in input_chunks {
-        let cyphertext_intermediate = xor_bytes(&tweak_block.0, chunk)?;
-        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("xex");
-    }
-
-    Ok(output)
-}
-
-pub fn gcm_encrypt_aes(
-    mut nonce: Vec<u8>,
-    key: Vec<u8>,
-    plaintext: Vec<u8>,
-    ad: Vec<u8>,
-) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>)> {
-    let mut ciphertext: Vec<u8> = vec![];
-
-    let mut counter: u32 = 1;
-    nonce.append(counter.to_be_bytes().to_vec().as_mut());
-    //nonce.append(0u8.to_le_bytes().to_vec().as_mut());
-
-    let auth_tag_xor = aes_128_encrypt(&key, &nonce)?;
-
-    let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?;
-
-    let plaintext_chunks: Vec<Vec<u8>> = plaintext.chunks(16).map(|x| x.to_vec()).collect();
-
-    counter = 2;
-    for chunk in plaintext_chunks {
-        nonce.drain(12..);
-        nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-        let inter1 = aes_128_encrypt(&key, &nonce)?;
-
-        let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
-
-        ciphertext.append(inter2.as_mut());
-        counter += 1;
-    }
-
-    let mut l_field: Vec<u8> = ((ad.len() * 8) as u64).to_be_bytes().to_vec();
-    let mut c_len: Vec<u8> = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec();
-    l_field.append(c_len.as_mut());
-
-    let auth_tag = xor_bytes(
-        &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
-        auth_tag_xor,
-    )?;
-
-    Ok((ciphertext, auth_tag, l_field, auth_key_h))
-}
-
-pub fn gcm_decrypt_aes(
-    mut nonce: Vec<u8>,
-    key: Vec<u8>,
-    ciphertext: Vec<u8>,
-    ad: Vec<u8>,
-    tag: Vec<u8>,
-) -> Result<(Vec<u8>, bool)> {
-    let mut plaintext: Vec<u8> = vec![];
-
-    let mut counter: u32 = 1;
-    nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-    let auth_tag_xor = aes_128_encrypt(&key, &nonce)?;
-
-    let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?;
-
-    let ciphertext_chunks: Vec<Vec<u8>> = ciphertext.chunks(16).map(|x| x.to_vec()).collect();
-
-    counter = 2;
-    for chunk in ciphertext_chunks {
-        nonce.drain(12..);
-        nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-        let inter1 = aes_128_encrypt(&key, &nonce)?;
-
-        let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
-
-        plaintext.append(inter2.as_mut());
-        counter += 1;
-    }
-
-    let mut l_field: Vec<u8> = ((ad.len() * 8) as u64).to_be_bytes().to_vec();
-    let mut c_len: Vec<u8> = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec();
-    l_field.append(c_len.as_mut());
-
-    let auth_tag = xor_bytes(
-        &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
-        auth_tag_xor,
-    )?;
-
-    let valid = auth_tag == tag;
-
-    Ok((plaintext, valid))
-}
-
-pub fn gcm_encrypt_sea(
-    mut nonce: Vec<u8>,
-    key: Vec<u8>,
-    plaintext: Vec<u8>,
-    ad: Vec<u8>,
-) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>)> {
-    let mut ciphertext: Vec<u8> = vec![];
-
-    let mut counter: u32 = 1;
-    nonce.append(counter.to_be_bytes().to_vec().as_mut());
-    //nonce.append(0u8.to_le_bytes().to_vec().as_mut());
-
-    let auth_tag_xor = sea_128_encrypt(&key, &nonce)?;
-
-    let auth_key_h = sea_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?;
-
-    let plaintext_chunks: Vec<Vec<u8>> = plaintext.chunks(16).map(|x| x.to_vec()).collect();
-
-    counter = 2;
-    for chunk in plaintext_chunks {
-        nonce.drain(12..);
-        nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-        let inter1 = sea_128_encrypt(&key, &nonce)?;
-
-        let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
-
-        ciphertext.append(inter2.as_mut());
-        counter += 1;
-    }
-
-    let mut l_field: Vec<u8> = ((ad.len() * 8) as u64).to_be_bytes().to_vec();
-    let mut c_len: Vec<u8> = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec();
-    l_field.append(c_len.as_mut());
-
-    let auth_tag = xor_bytes(
-        &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
-        auth_tag_xor,
-    )?;
-
-    Ok((ciphertext, auth_tag, l_field, auth_key_h))
-}
-
-pub fn gcm_decrypt_sea(
-    mut nonce: Vec<u8>,
-    key: Vec<u8>,
-    ciphertext: Vec<u8>,
-    ad: Vec<u8>,
-    tag: Vec<u8>,
-) -> Result<(Vec<u8>, bool)> {
-    let mut plaintext: Vec<u8> = vec![];
-
-    let mut counter: u32 = 1;
-    nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-    let auth_tag_xor = sea_128_encrypt(&key, &nonce)?;
-
-    let auth_key_h = sea_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?;
-
-    let plaintext_chunks: Vec<Vec<u8>> = ciphertext.chunks(16).map(|x| x.to_vec()).collect();
-
-    counter = 2;
-    for chunk in plaintext_chunks {
-        nonce.drain(12..);
-        nonce.append(counter.to_be_bytes().to_vec().as_mut());
-
-        let inter1 = sea_128_encrypt(&key, &nonce)?;
-
-        let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
-
-        plaintext.append(inter2.as_mut());
-        counter += 1;
-    }
-
-    let mut l_field: Vec<u8> = ((ad.len() * 8) as u64).to_be_bytes().to_vec();
-    let mut c_len: Vec<u8> = ((plaintext.len() * 8) as u64).to_be_bytes().to_vec();
-    l_field.append(c_len.as_mut());
-
-    let auth_tag = xor_bytes(
-        &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
-        auth_tag_xor,
-    )?;
-
-    let valid = auth_tag == tag;
-
-    Ok((plaintext, valid))
-}
-
-pub fn ghash(
-    auth_key_h: Vec<u8>,
-    mut ad: Vec<u8>,
-    mut ciphertext: Vec<u8>,
-    l_field: Vec<u8>,
-) -> Result<Vec<u8>> {
-    let output: Vec<u8> = vec![0; 16];
-
-    if ad.len() % 16 != 0 || ad.is_empty() {
-        ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut());
-    }
-
-    if ciphertext.len() % 16 != 0 {
-        ciphertext.append(vec![0u8; 16 - (ciphertext.len() % 16)].as_mut());
-    }
-
-    let mut ad_chunks = ad.chunks(16);
-
-    let inter1 = xor_bytes(&output, ad_chunks.next().unwrap().to_vec())?;
-    let mut inter_loop = gfmul(&inter1, &auth_key_h, "gcm")?;
-
-    for chunk in ad_chunks {
-        let inter2 = xor_bytes(&inter_loop, chunk.to_vec())?;
-        inter_loop = gfmul(&inter2, &auth_key_h, "gcm")?;
-    }
-
-    let cipher_chunks = ciphertext.chunks(16);
-
-    for chunk in cipher_chunks {
-        let inter3 = xor_bytes(&inter_loop, chunk.to_vec())?;
-        inter_loop = gfmul(&inter3, &auth_key_h, "gcm")?;
-    }
-
-    let inter4 = xor_bytes(&inter_loop, l_field)?;
-    inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?;
-
-    Ok(inter_loop)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use base64::prelude::*;
-
-    #[test]
-    fn test_xex_encrypt() -> Result<()> {
-        let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?;
-        let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?;
-        let input = BASE64_STANDARD
-            .decode("/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW")?;
-
-        let output = BASE64_STANDARD.encode(xex_encrypt(key, &tweak, &input)?);
-
-        assert_eq!(
-            output,
-            "mHAVhRCKPAPx0BcufG5BZ4+/CbneMV/gRvqK5rtLe0OJgpDU5iT7z2P0R7gEeRDO"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_xex_decrypt() -> Result<()> {
-        let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?;
-        let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?;
-        let input = BASE64_STANDARD
-            .decode("lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a")?;
-
-        let output = BASE64_STANDARD.encode(xex_decrypt(key, &tweak, &input)?);
-
-        assert_eq!(
-            output,
-            "SGV5IHdpZSBrcmFzcyBkYXMgZnVua3Rpb25pZXJ0IGphIG9mZmVuYmFyIGVjaHQu"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_xex_encrypt_empty_case() -> Result<()> {
-        let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?;
-        let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?;
-        let input = BASE64_STANDARD.decode("")?;
-
-        let output = BASE64_STANDARD.encode(xex_encrypt(key, &tweak, &input)?);
-
-        assert_eq!(output, "");
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_gcm_encrypt_aes() -> Result<()> {
-        let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?;
-        let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?;
-        let plaintext = BASE64_STANDARD.decode("RGFzIGlzdCBlaW4gVGVzdA==")?;
-        let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?;
-
-        let (ciphertext, auth_tag, l_field, auth_key_h) =
-            gcm_encrypt_aes(nonce, key, plaintext, ad)?;
-
-        eprintln!(
-            "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}",
-            BASE64_STANDARD.encode(&ciphertext),
-            BASE64_STANDARD.encode(&auth_tag),
-            BASE64_STANDARD.encode(&l_field),
-            BASE64_STANDARD.encode(&auth_key_h)
-        );
-
-        assert_eq!(
-            BASE64_STANDARD.encode(ciphertext),
-            "ET3RmvH/Hbuxba63EuPRrw=="
-        );
-        assert_eq!(BASE64_STANDARD.encode(auth_tag), "Mp0APJb/ZIURRwQlMgNN/w==");
-        assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAEAAAAAAAAAAgA==");
-        assert_eq!(
-            BASE64_STANDARD.encode(auth_key_h),
-            "Bu6ywbsUKlpmZXMQyuGAng=="
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_gcm_encrypt_aes_long_ad() -> Result<()> {
-        let nonce = BASE64_STANDARD.decode("yv66vvrO263eyviI")?;
-        let key = BASE64_STANDARD.decode("/v/pkoZlcxxtao+UZzCDCA==")?;
-        let plaintext = BASE64_STANDARD.decode(
-            "2TEyJfiEBuWlWQnFr/UmmoanqVMVNPfaLkwwPYoxinIcPAyVlWgJUy/PDiRJprUlsWrt9aoN5le6Y3s5",
-        )?;
-        let ad = BASE64_STANDARD.decode("/u36zt6tvu/+7frO3q2+76ut2tI=")?;
-
-        let (ciphertext, auth_tag, l_field, auth_key_h) =
-            gcm_encrypt_aes(nonce, key, plaintext, ad)?;
-
-        eprintln!(
-            "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}",
-            BASE64_STANDARD.encode(&ciphertext),
-            BASE64_STANDARD.encode(&auth_tag),
-            BASE64_STANDARD.encode(&l_field),
-            BASE64_STANDARD.encode(&auth_key_h)
-        );
-
-        assert_eq!(
-            BASE64_STANDARD.encode(ciphertext),
-            "QoMewiF3dCRLciG3hNDUnOOqIS8sAqTgNcF+IymsoS4h1RSyVGaTHH2PalqshKoFG6MLOWoKrJc9WOCR"
-        );
-        assert_eq!(BASE64_STANDARD.encode(auth_tag), "W8lPvDIhpduU+ula5xIaRw==");
-        assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAKAAAAAAAAAB4A==");
-        assert_eq!(
-            BASE64_STANDARD.encode(auth_key_h),
-            "uDtTNwi/U10KpuUpgNU7eA=="
-        );
-
-        Ok(())
-    }
 /*
-        * TODO:Not sure if this case can really happen in our data
+* let mut bytes: [u8; 16] = [0u8; 16];
+    bytes.copy_from_slice(&ciphertext);
+    let number: u128 = <u128>::from_be_bytes(bytes);
 
-        #[test]
+* */
-        fn test_gcm_encrypt_aes_long_0000() -> Result<()> {
-            let nonce = BASE64_STANDARD.decode(
-                "kxMiXfiEBuVVkJxa/1Jpqmp6lThTT32h5MMD0qMYpyjDwMlRVoCVOfzw4kKaa1JUFq7b9aDealemN7Ob",
-            )?;
-            let key = BASE64_STANDARD.decode("/v/pkoZlcxxtao+UZzCDCP7/6ZKGZXMcbWqPlGcwgwg=")?;
-            let plaintext = BASE64_STANDARD.decode(
-                "2TEyJfiEBuWlWQnFr/UmmoanqVMVNPfaLkwwPYoxinIcPAyVlWgJUy/PDiRJprUlsWrt9aoN5le6Y3s5",
-            )?;
-            let ad = BASE64_STANDARD.decode("/u36zt6tvu/+7frO3q2+76ut2tI=")?;
-
-            let (ciphertext, auth_tag, l_field, auth_key_h) =
-                gcm_encrypt_aes(nonce, key, plaintext, ad)?;
-
-            eprintln!(
-                "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}",
-                BASE64_STANDARD.encode(&ciphertext),
-                BASE64_STANDARD.encode(&auth_tag),
-                BASE64_STANDARD.encode(&l_field),
-                BASE64_STANDARD.encode(&auth_key_h)
-            );
-
-            assert_eq!(
-                BASE64_STANDARD.encode(ciphertext),
-                "Wo3vLwyeU/H3XXhTZZ4qIO6ysiqv3mQZoFirT290a/QPwMO3gPJERS2j6/HF2CzeokGJlyAO+C5Ern4/"
-            );
-            assert_eq!(BASE64_STANDARD.encode(auth_tag), "pEqCZu4cjrDItdTPWunxmg==");
-            assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAKAAAAAAAAAB4A==");
-            assert_eq!(
-                BASE64_STANDARD.encode(auth_key_h),
-                "rL7yBXm0uOvOiJushzLa1w=="
-            );
-
-            Ok(())
-        }
-    */
-    #[test]
-    fn test_gcm_encrypt_sea() -> Result<()> {
-        let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?;
-        let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?;
-        let plaintext = BASE64_STANDARD.decode("RGFzIGlzdCBlaW4gVGVzdA==")?;
-        let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?;
-
-        let (ciphertext, auth_tag, l_field, auth_key_h) =
-            gcm_encrypt_sea(nonce, key, plaintext, ad)?;
-
-        eprintln!(
-            "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}",
-            BASE64_STANDARD.encode(&ciphertext),
-            BASE64_STANDARD.encode(&auth_tag),
-            BASE64_STANDARD.encode(&l_field),
-            BASE64_STANDARD.encode(&auth_key_h)
-        );
-
-        assert_eq!(
-            BASE64_STANDARD.encode(ciphertext),
-            "0cI/Wg4R3URfrVFZ0hw/vg=="
-        );
-        assert_eq!(BASE64_STANDARD.encode(auth_tag), "ysDdzOSnqLH0MQ+Mkb23gw==");
-        assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAEAAAAAAAAAAgA==");
-        assert_eq!(
-            BASE64_STANDARD.encode(auth_key_h),
-            "xhFcAUT66qWIpYz+Ch5ujw=="
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_gcm_decrypt_aes() -> Result<()> {
-        let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?;
-        let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?;
-        let ciphertext = BASE64_STANDARD.decode("ET3RmvH/Hbuxba63EuPRrw==")?;
-        let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?;
-        let tag = BASE64_STANDARD.decode("Mp0APJb/ZIURRwQlMgNN/w==")?;
-
-        let (plaintext, valid) = gcm_decrypt_aes(nonce, key, ciphertext, ad, tag)?;
-
-        eprintln!(
-            "Cipher: {:001X?} \n Valids: {:001X?}",
-            BASE64_STANDARD.encode(&plaintext),
-            &valid,
-        );
-
-        assert_eq!(
-            BASE64_STANDARD.encode(plaintext),
-            "RGFzIGlzdCBlaW4gVGVzdA=="
-        );
-        assert_eq!(valid, true);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_gcm_decrypt_sea() -> Result<()> {
-        let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?;
-        let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?;
-        let ciphertext = BASE64_STANDARD.decode("0cI/Wg4R3URfrVFZ0hw/vg==")?;
-        let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?;
-        let tag = BASE64_STANDARD.decode("ysDdzOSnqLH0MQ+Mkb23gw==")?;
-
-        let (plaintext, valid) = gcm_decrypt_sea(nonce, key, ciphertext, ad, tag)?;
-
-        eprintln!(
-            "Plaintext: {:001X?} \n Valid: {:001X?}",
-            BASE64_STANDARD.encode(&plaintext),
-            &valid,
-        );
-
-        assert_eq!(
-            BASE64_STANDARD.encode(plaintext),
-            "RGFzIGlzdCBlaW4gVGVzdA=="
-        );
-        assert_eq!(valid, true);
-
-        Ok(())
-    }
-}

src/utils/dff.rs

@@ -1,81 +0,0 @@
-use std::usize;
-
-use num::{pow::Pow, BigUint, FromPrimitive};
-use serde::{Deserialize, Serialize};
-
-use super::poly::{gcd, Polynomial};
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Factors {
-    pub factor: Vec<String>,
-    pub degree: u32,
-}
-
-pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> {
-    let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128);
-
-    let mut z: Vec<(Polynomial, u128)> = vec![];
-    let mut d: u128 = 1;
-    let mut f_star = f.clone();
-
-    let one_cmp = Polynomial::one();
-
-    while f_star.degree() as u128 >= (2 * d) {
-        let h = Polynomial::x().bpow_mod(q.clone().pow(d), &f_star.clone()) + Polynomial::x();
-
-        let g = gcd(&h, &f_star);
-        if g != one_cmp {
-            z.push((g.clone(), d));
-            f_star = f_star.div(&g).0;
-        }
-
-        d += 1;
-    }
-
-    if f_star != one_cmp {
-        z.push((f_star.clone(), f_star.degree() as u128));
-    } else if z.len() == 0 {
-        z.push((f.clone(), 1));
-    }
-
-    z
-}
-
-#[cfg(test)]
-mod tests {
-
-    use serde_json::json;
-
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
-    use super::*;
-
-    #[test]
-    fn test_dff_sheet() {
-        let json_f = json!([
-            "tpkgAAAAAAAAAAAAAAAAAA==",
-            "m6MQAAAAAAAAAAAAAAAAAA==",
-            "8roAAAAAAAAAAAAAAAAAAA==",
-            "3dUAAAAAAAAAAAAAAAAAAA==",
-            "FwAAAAAAAAAAAAAAAAAAAA==",
-            "/kAAAAAAAAAAAAAAAAAAAA==",
-            "a4AAAAAAAAAAAAAAAAAAAA==",
-            "gAAAAAAAAAAAAAAAAAAAAA=="
-        ]);
-        let poly_f = Polynomial::from_c_array(&json_f);
-
-        let mut factors = ddf(poly_f);
-        factors.sort();
-        let mut result: Vec<Factors> = vec![];
-
-        for (factor, degree) in factors {
-            result.push(Factors {
-                factor: factor.to_c_array(),
-                degree: degree as u32,
-            });
-        }
-
-        println!("Result: {:?}", result);
-        let _bit_indices: Vec<u8> = vec![0];
-        assert!(false)
-    }
-}

src/utils/edf.rs

@@ -1,86 +0,0 @@
-use num::{BigUint, FromPrimitive, One};
-use rand::Rng;
-
-use super::poly::{gcd, Polynomial};
-
-pub fn edf(f: Polynomial, d: u32) -> Vec<Polynomial> {
-    let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128);
-    let n: u32 = (f.degree() as u32) / (d);
-    let mut z: Vec<Polynomial> = vec![f.clone()];
-    let one_cmp = Polynomial::one();
-
-    while (z.len() as u32) < n {
-        let h = Polynomial::rand(&rand::thread_rng().gen_range(1..=f.degree()));
-
-        let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap();
-
-        let g = h.bpow_mod(exponent, &f) + Polynomial::one();
-
-        for i in (0..z.len()).rev() {
-            if z[i].degree() as u32 > d {
-                let j = gcd(&z[i], &g);
-                if j != one_cmp && j != z[i] {
-                    let intemediate = z[i].div(&j).0;
-                    z.remove(i);
-                    z.push(j.clone());
-                    z.push(intemediate);
-                }
-            }
-        }
-    }
-
-    z
-}
-
-#[cfg(test)]
-mod tests {
-
-    use serde_json::json;
-
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
-    use super::*;
-
-    #[test]
-    fn test_edf_sheet() {
-        let json_f = json!([
-            "mmAAAAAAAAAAAAAAAAAAAA==",
-            "AbAAAAAAAAAAAAAAAAAAAA==",
-            "zgAAAAAAAAAAAAAAAAAAAA==",
-            "FwAAAAAAAAAAAAAAAAAAAA==",
-            "AAAAAAAAAAAAAAAAAAAAAA==",
-            "wAAAAAAAAAAAAAAAAAAAAA==",
-            "gAAAAAAAAAAAAAAAAAAAAA=="
-        ]);
-        let d = 3;
-        let poly_f = Polynomial::from_c_array(&json_f);
-
-        let mut factors = edf(poly_f, d);
-        factors.sort();
-
-        let mut result: Vec<Vec<String>> = vec![];
-
-        for factor in factors {
-            result.push(factor.to_c_array())
-        }
-
-        println!("Result: {:?}", result);
-
-        assert_eq!(
-            result,
-            vec![
-                [
-                    "iwAAAAAAAAAAAAAAAAAAAA==",
-                    "CAAAAAAAAAAAAAAAAAAAAA==",
-                    "AAAAAAAAAAAAAAAAAAAAAA==",
-                    "gAAAAAAAAAAAAAAAAAAAAA=="
-                ],
-                [
-                    "kAAAAAAAAAAAAAAAAAAAAA==",
-                    "CAAAAAAAAAAAAAAAAAAAAA==",
-                    "wAAAAAAAAAAAAAAAAAAAAA==",
-                    "gAAAAAAAAAAAAAAAAAAAAA=="
-                ]
-            ]
-        )
-    }
-}

src/utils/field.rs

@@ -1,468 +0,0 @@
-use base64::prelude::*;
-use std::{u128, u8, usize};
-
-use std::{
-    cmp::Ordering,
-    ops::{Add, BitXor, Div, Mul},
-};
-
-use anyhow::{anyhow, Ok, Result};
-
-use super::{
-    math::{reverse_bits_in_bytevec, xor_bytes},
-    poly::gfmul,
-};
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub struct FieldElement {
-    field_element: Vec<u8>,
-}
-
-impl FieldElement {
-    pub const IRREDUCIBLE_POLYNOMIAL: [u8; 17] = [
-        0x87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x01,
-    ];
-
-    pub fn rand() -> Self {
-        let rand_field: [u8; 16] = rand::random();
-        FieldElement::new_no_convert(rand_field.to_vec())
-    }
-
-    pub fn zero() -> Self {
-        FieldElement::new_no_convert(vec![0; 16])
-    }
-
-    pub fn one() -> Self {
-        FieldElement::new_no_convert(vec![0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-    }
-
-    pub fn to_vec(&self) -> Vec<u8> {
-        self.field_element.clone()
-    }
-
-    pub fn new(field_element: Vec<u8>) -> Self {
-        Self {
-            field_element: reverse_bits_in_bytevec(field_element),
-        }
-    }
-
-    pub fn new_no_convert(field_element: Vec<u8>) -> Self {
-        Self { field_element }
-    }
-
-    pub fn mul(&self, poly_a: Vec<u8>, poly_b: Vec<u8>) -> Result<Vec<u8>> {
-        gfmul(&poly_a, &poly_b, "gcm")
-    }
-
-    pub fn to_b64(&self) -> String {
-        BASE64_STANDARD.encode(reverse_bits_in_bytevec(self.field_element.to_owned()))
-    }
-
-    pub fn pow(mut self, mut exponent: u128) -> FieldElement {
-        let mut result: FieldElement = FieldElement::one();
-
-        if exponent == 1 {
-            return self;
-        }
-
-        if exponent == 0 {
-            let result = FieldElement::one();
-
-            return result;
-        }
-
-        while exponent > 0 {
-            if exponent & 1 == 1 {
-                let temp = &self * &result;
-
-                result = temp
-            }
-            let temp_square = &self * &self;
-
-            self = temp_square;
-            exponent >>= 1;
-        }
-
-        result
-    }
-
-    pub fn inv(mut self) -> Self {
-        const INVERSER_START: u128 = 0xfffffffffffffffffffffffffffffffe;
-
-        let mut inverser = INVERSER_START;
-        let mut inverse: Vec<u8> = vec![0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-        while inverser > 0 {
-            if inverser & 1 == 1 {
-                inverse = gfmul(&self.field_element, &inverse, "xex").unwrap();
-            }
-            inverser >>= 1;
-            self.field_element = gfmul(&self.field_element, &self.field_element, "xex")
-                .expect("Error in sqrmul sqr");
-        }
-        FieldElement::new_no_convert(inverse)
-    }
-
-    pub fn is_zero(&self) -> bool {
-        self.field_element.iter().all(|&x| x == 0x00)
-    }
-
-    pub fn reverse_bits(&self) -> Self {
-        FieldElement::new_no_convert(reverse_bits_in_bytevec(self.field_element.clone()))
-    }
-}
-
-impl Mul for FieldElement {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        FieldElement::new_no_convert(
-            gfmul(&self.field_element, &rhs.field_element, "xex")
-                .expect("Error during multiplication"),
-        )
-    }
-}
-
-impl Mul for &FieldElement {
-    type Output = FieldElement;
-
-    fn mul(self, rhs: &FieldElement) -> FieldElement {
-        FieldElement::new_no_convert(
-            gfmul(&self.field_element, &rhs.field_element, "xex")
-                .expect("Error during multiplication"),
-        )
-    }
-}
-
-impl Add for FieldElement {
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        FieldElement::new_no_convert(
-            xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"),
-        )
-    }
-}
-
-impl Add for &FieldElement {
-    type Output = FieldElement;
-    fn add(self, rhs: Self) -> Self::Output {
-        FieldElement::new_no_convert(
-            xor_bytes(&self.field_element, rhs.field_element.clone()).expect("Error in poly add"),
-        )
-    }
-}
-
-impl AsRef<[u8]> for FieldElement {
-    fn as_ref(&self) -> &[u8] {
-        &self.field_element.as_ref()
-    }
-}
-
-impl Clone for FieldElement {
-    fn clone(&self) -> Self {
-        FieldElement {
-            field_element: self.field_element.clone(),
-        }
-    }
-}
-
-impl BitXor for FieldElement {
-    type Output = Self;
-    fn bitxor(self, rhs: Self) -> Self::Output {
-        let result: Vec<u8> = self
-            .field_element
-            .iter()
-            .zip(rhs.field_element.iter())
-            .map(|(&x1, &x2)| x1 ^ x2)
-            .collect();
-        FieldElement::new_no_convert(result)
-    }
-}
-
-impl Div for FieldElement {
-    type Output = Self;
-    fn div(self, rhs: Self) -> Self::Output {
-        let inverse = rhs.inv();
-        self * inverse
-    }
-}
-
-impl Div for &FieldElement {
-    type Output = FieldElement;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        self.clone() * rhs.clone().inv()
-    }
-}
-
-impl PartialOrd for FieldElement {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        for (byte_a, byte_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) {
-            if byte_a > byte_b {
-                return Some(Ordering::Greater);
-            } else if byte_a < byte_b {
-                return Some(Ordering::Less);
-            } else {
-                continue;
-            }
-        }
-        Some(Ordering::Equal)
-    }
-}
-
-impl PartialEq for FieldElement {
-    fn eq(&self, other: &Self) -> bool {
-        self.field_element == other.field_element
-    }
-}
-
-impl Eq for FieldElement {
-    // add code here
-}
-
-impl Ord for FieldElement {
-    fn cmp(&self, other: &Self) -> Ordering {
-        for (byte_a, byte_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) {
-            if byte_a > byte_b {
-                return Ordering::Greater;
-            } else if byte_a < byte_b {
-                return Ordering::Less;
-            } else {
-                continue;
-            }
-        }
-        Ordering::Equal
-    }
-}
-
-#[derive(Debug)]
-pub struct ByteArray(pub Vec<u8>);
-
-impl ByteArray {
-    pub fn left_shift(&mut self, semantic: &str) -> Result<u8> {
-        match semantic {
-            "xex" => {
-                let mut carry = 0u8;
-                for byte in self.0.iter_mut() {
-                    let new_carry = *byte >> 7;
-                    *byte = (*byte << 1) | carry;
-                    carry = new_carry;
-                }
-                Ok(carry)
-            }
-            "gcm" => {
-                let mut carry = 0u8;
-                for byte in self.0.iter_mut() {
-                    let new_carry = *byte & 1;
-                    *byte = (*byte >> 1) | (carry << 7);
-                    carry = new_carry;
-                }
-                Ok(carry)
-            }
-            _ => Err(anyhow!("Failure in lsh. No compatible action found")),
-        }
-    }
-
-    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, &alpha_poly, "xex").unwrap();
-            }
-            "gcm" => {
-                let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
-                    .decode("AgAAAAAAAAAAAAAAAAAAAA==")
-                    .expect("Decode failed");
-                self.0 = gfmul(&self.0, &alpha_poly, "gcm").unwrap();
-            }
-            _ => {}
-        }
-    }
-
-    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")),
-        }
-    }
-
-    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 msb_is_one(&self) -> bool {
-        (self.0.last().unwrap() & 1) == 1
-    }
-
-    pub fn is_empty(&self) -> bool {
-        for i in self.0.iter() {
-            if *i != 0 {
-                return false;
-            }
-        }
-        true
-    }
-
-    pub fn reverse_bits_in_bytevec(&mut self) {
-        self.0 = self.0.iter_mut().map(|byte| byte.reverse_bits()).collect();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[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("xex").unwrap();
-
-        assert_eq!(byte_array.0, shifted_array.0);
-    }
-
-    #[test]
-    fn test_byte_array_shift2() {
-        let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
-        let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]);
-        byte_array.left_shift("xex").unwrap();
-
-        assert_eq!(
-            byte_array.0, shifted_array.0,
-            "Failure: Shifted array was: {:?}",
-            byte_array.0
-        );
-    }
-
-    #[test]
-    fn test_byte_array_shift1_gcm() {
-        let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
-        let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]);
-        byte_array.left_shift("gcm").unwrap();
-
-        assert_eq!(
-            byte_array.0, shifted_array.0,
-            "Failure: Shifted array was: {:02X?}",
-            byte_array.0
-        );
-    }
-
-    #[test]
-    fn test_byte_array_shift1_right_gcm() {
-        let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]);
-        let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]);
-        byte_array.right_shift("gcm").unwrap();
-
-        assert_eq!(
-            byte_array.0, shifted_array.0,
-            "Failure: Shifted array was: {:02X?}",
-            byte_array.0
-        );
-    }
-
-    #[test]
-    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("xex").unwrap();
-
-        assert_eq!(
-            byte_array.0, shifted_array.0,
-            "Failure: Shifted array was: {:?}",
-            byte_array.0
-        );
-    }
-
-    #[test]
-    fn test_lsb_one() {
-        let byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]);
-        assert!(!byte_array.LSB_is_one());
-
-        let byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]);
-        assert!(!byte_array2.LSB_is_one());
-
-        let byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]);
-        assert!(byte_array3.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]);
-    }
-
-    #[test]
-    fn test_field_add_01() {
-        let element1: FieldElement =
-            FieldElement::new(BASE64_STANDARD.decode("NeverGonnaGiveYouUpAAA==").unwrap());
-        let element2: FieldElement =
-            FieldElement::new(BASE64_STANDARD.decode("KryptoanalyseAAAAAAAAA==").unwrap());
-        let sum = element2 + element1;
-
-        assert_eq!(sum.to_b64(), "H1d3GuyA9/0OxeYouUpAAA==");
-    }
-
-    #[test]
-    fn test_field_add_02() {
-        let element1: FieldElement =
-            FieldElement::new(BASE64_STANDARD.decode("NeverGonnaLetYouDownAA==").unwrap());
-        let element2: FieldElement =
-            FieldElement::new(BASE64_STANDARD.decode("DHBWMannheimAAAAAAAAAA==").unwrap());
-        let sum = element2 + element1;
-
-        assert_eq!(sum.to_b64(), "OZuIncPAGEp4tYouDownAA==");
-    }
-
-    #[test]
-    fn test_field_div_01() {
-        let element1 =
-            FieldElement::new(BASE64_STANDARD.decode("JAAAAAAAAAAAAAAAAAAAAA==").unwrap());
-
-        let element2 =
-            FieldElement::new(BASE64_STANDARD.decode("wAAAAAAAAAAAAAAAAAAAAA==").unwrap());
-
-        let result = element1 / element2;
-
-        assert_eq!(result.to_b64(), "OAAAAAAAAAAAAAAAAAAAAA==");
-    }
-}

src/utils/math.rs

@@ -1,6 +1,5 @@
 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()) {
         *byte2 ^= byte1;
@@ -9,8 +8,120 @@ pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
     Ok(vec2)
 }
 
-pub fn reverse_bits_in_bytevec(mut vec: Vec<u8>) -> Vec<u8> {
+#[derive(Debug)]
-    vec = vec.iter_mut().map(|byte| byte.reverse_bits()).collect();
+pub struct ByteArray(pub Vec<u8>);
 
-    vec
+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![0xFF, 0x00]);
+        let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]);
+        byte_array.left_shift();
+
+        assert_eq!(
+            byte_array.0, shifted_array.0,
+            "Failure: Shifted array was: {:?}",
+            byte_array.0
+        );
+    }
+
+    #[test]
+    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();
+
+        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![0x02, 0xFF]);
+        assert!(!byte_array2.LSB_is_one());
+
+        let mut byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]);
+        assert!(byte_array3.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/mod.rs

@@ -1,9 +1,4 @@
 pub mod ciphers;
-pub mod dff;
-pub mod edf;
-pub mod field;
 pub mod math;
-pub mod net;
 pub mod parse;
 pub mod poly;
-pub mod sff;

src/utils/net.rs

@@ -1 +0,0 @@
-

src/utils/parse.rs

@@ -8,13 +8,13 @@ pub struct Testcases {
     pub testcases: HashMap<String, Testcase>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Testcase {
     pub action: String,
     pub arguments: Value,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Responses {
     pub responses: HashMap<String, Value>,
 }
@@ -28,12 +28,14 @@ pub fn parse_json(json: String) -> Result<Testcases> {
 mod tests {
     use std::fs;
 
+    use serde_json::json;
+
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
     #[test]
     fn test_json_parsing() {
-        let json = fs::read_to_string("test_json/parse_example.json").unwrap();
+        let json = fs::read_to_string("src/test_json/parse_example.json").unwrap();
         let parsed = parse_json(json).unwrap();
 
         /*

src/utils/sff.rs

@@ -1,92 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::{
-    field::FieldElement,
-    poly::{gcd, polynomial_2_block},
-};
-
-use super::poly::Polynomial;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Factors {
-    pub factor: Vec<String>,
-    pub exponent: u128,
-}
-
-pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u128)> {
-    let mut c = gcd(&f, &f.clone().diff());
-    f = f.div(&c).0;
-    let mut z: Vec<(Polynomial, u128)> = vec![];
-    let mut e: u128 = 1;
-
-    let one_element = Polynomial::new(vec![FieldElement::new(
-        polynomial_2_block(vec![0], "gcm").unwrap(),
-    )]);
-
-    while f != one_element {
-        let y = gcd(&f, &c);
-        if f != y {
-            z.push(((f.div(&y).0), e));
-        }
-
-        f = y.clone();
-        c = c.div(&y).0;
-        e += 1;
-    }
-
-    if c != one_element {
-        let r = sff(c.sqrt());
-        for (f_star, e_star) in r {
-            z.push((f_star, 2 * e_star));
-        }
-    }
-
-    z
-}
-
-#[cfg(test)]
-mod tests {
-
-    use serde_json::json;
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
-    use super::*;
-
-    #[test]
-    fn byte_indices_0x01() {
-        let json_f = json!([
-            "vL77UwAAAAAAAAAAAAAAAA==",
-            "mEHchYAAAAAAAAAAAAAAAA==",
-            "9WJa0MAAAAAAAAAAAAAAAA==",
-            "akHfwWAAAAAAAAAAAAAAAA==",
-            "E12o/QAAAAAAAAAAAAAAAA==",
-            "vKJ/FgAAAAAAAAAAAAAAAA==",
-            "yctWwAAAAAAAAAAAAAAAAA==",
-            "c1BXYAAAAAAAAAAAAAAAAA==",
-            "o0AtAAAAAAAAAAAAAAAAAA==",
-            "AbP2AAAAAAAAAAAAAAAAAA==",
-            "k2YAAAAAAAAAAAAAAAAAAA==",
-            "vBYAAAAAAAAAAAAAAAAAAA==",
-            "dSAAAAAAAAAAAAAAAAAAAA==",
-            "69gAAAAAAAAAAAAAAAAAAA==",
-            "VkAAAAAAAAAAAAAAAAAAAA==",
-            "a4AAAAAAAAAAAAAAAAAAAA==",
-            "gAAAAAAAAAAAAAAAAAAAAA=="
-        ]);
-        let poly_f = Polynomial::from_c_array(&json_f);
-
-        let mut factors = sff(poly_f);
-        factors.sort();
-        let mut result: Vec<Factors> = vec![];
-
-        for (factor, exponent) in factors {
-            result.push(Factors {
-                factor: factor.to_c_array(),
-                exponent,
-            });
-        }
-
-        println!("{:?}", result);
-        let _bit_indices: Vec<u8> = vec![0];
-        assert!(false)
-    }
-}

test_json/gcm_decrypt_aes.json

@@ -1,14 +0,0 @@
-{
-  "testcases": {
-    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
-      "action": "gcm_decrypt",
-"arguments": {
-"algorithm": "aes128",
-"nonce": "4gF+BtR3ku/PUQci",
-"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==",
-"ciphertext": "ET3RmvH/Hbuxba63EuPRrw==",
-"ad": "QUQtRGF0ZW4=",
-"tag": "Mp0APJb/ZIURRwQlMgNN/w=="
-}    }
-  }
-}

test_json/gcm_decrypt_sea.json

@@ -1,14 +0,0 @@
-{
-  "testcases": {
-    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
-      "action": "gcm_decrypt",
-"arguments": {
-"algorithm": "sea128",
-"nonce": "4gF+BtR3ku/PUQci",
-"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==",
-"ciphertext": "0cI/Wg4R3URfrVFZ0hw/vg==",
-"ad": "QUQtRGF0ZW4=",
-"tag": "ysDdzOSnqLH0MQ+Mkb23gw=="
-}    }
-  }
-}

test_json/gcm_encrypt.json

@@ -1,14 +0,0 @@
-{
-  "testcases": {
-    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
-      "action": "gcm_encrypt",
-      "arguments": {
-        "algorithm": "aes128",
-        "nonce": "4gF+BtR3ku/PUQci",
-        "key": "Xjq/GkpTSWoe3ZH0F+tjrQ==",
-        "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==",
-        "ad": "QUQtRGF0ZW4="
-      }
-    }
-  }
-}

test_json/gcm_encrypt_sea.json

@@ -1,14 +0,0 @@
-{
-  "testcases": {
-    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
-      "action": "gcm_encrypt",
-      "arguments": {
-"algorithm": "sea128",
-"nonce": "4gF+BtR3ku/PUQci",
-"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==",
-"plaintext": "RGFzIGlzdCBlaW4gVGVzdA==",
-"ad": "QUQtRGF0ZW4="
-}
-    }
-  }
-}

test_json/kauma_tests.json

@@ -42,32 +42,7 @@
           0
         ]
       }
-    },
-    "0192d428-3913-762b-a702-d14828eae1f8": {
-      "action": "xex",
-      "arguments": {
-        "mode": "encrypt",
-        "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=",
-        "tweak": "6VXORr+YYHrd2nVe0OlA+Q==",
-        "input": "/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW"
-      }
-    },
-    "0192d428-3913-7168-a3bb-69c258c74dc1": {
-      "action": "xex",
-      "arguments": {
-        "mode": "decrypt",
-        "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=",
-        "tweak": "6VXORr+YYHrd2nVe0OlA+Q==",
-        "input": "lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a"
-      }
-    },
-    "0192d428-3913-78b5-9b35-3171c1c85484": {
-      "action": "gfmul",
-      "arguments": {
-        "semantic": "xex",
-        "a": "ARIAAAAAAAAAAAAAAAAAgA==",
-        "b": "AgAAAAAAAAAAAAAAAAAAAA=="
-      }
     }
   }
+  
 }

test_json/pfmath_tests.json

@@ -1,98 +0,0 @@
-{
-  "testcases": {
-    "gfpoly_add": {
-      "action": "gfpoly_add",
-      "arguments": {
-        "A": [
-          "NeverGonnaGiveYouUpAAA==",
-          "NeverGonnaLetYouDownAA==",
-          "NeverGonnaRunAroundAAA==",
-          "AndDesertYouAAAAAAAAAA=="
-        ],
-        "B": [
-          "KryptoanalyseAAAAAAAAA==",
-          "DHBWMannheimAAAAAAAAAA=="
-        ]
-      }
-    },
-    "gfpoly_mul": {
-      "action": "gfpoly_mul",
-      "arguments": {
-        "A": [
-          "JAAAAAAAAAAAAAAAAAAAAA==",
-          "wAAAAAAAAAAAAAAAAAAAAA==",
-          "ACAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "B": [
-          "0AAAAAAAAAAAAAAAAAAAAA==",
-          "IQAAAAAAAAAAAAAAAAAAAA=="
-        ]
-      }
-    },
-    "gfpoly_mul_10": {
-      "action": "gfpoly_mul",
-      "arguments": {
-        "A": [
-          "JAAAAAAAAAAAAAAAAAAAAA==",
-          "wAAAAAAAAAAAAAAAAAAAAA==",
-          "ACAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "B": [
-          "AAAAAAAAAAAAAAAAAAAAAA=="
-        ]
-      }
-    },
-    "gfpoly_mul_01": {
-      "action": "gfpoly_mul",
-      "arguments": {
-        "A": [
-          "AAAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "B": [
-          "0AAAAAAAAAAAAAAAAAAAAA==",
-          "IQAAAAAAAAAAAAAAAAAAAA=="
-        ]
-      }
-    },
-    "gfpoly_pow": {
-      "action": "gfpoly_pow",
-      "arguments": {
-        "A": [
-          "JAAAAAAAAAAAAAAAAAAAAA==",
-          "wAAAAAAAAAAAAAAAAAAAAA==",
-          "ACAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "k": 3
-      }
-    },
-    "gfpoly_pow_k0": {
-      "action": "gfpoly_pow",
-      "arguments": {
-        "A": [
-          "JAAAAAAAAAAAAAAAAAAAAA==",
-          "wAAAAAAAAAAAAAAAAAAAAA==",
-          "ACAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "k": 0
-      }
-    },
-    "gfpoly_pow_k1": {
-      "action": "gfpoly_pow",
-      "arguments": {
-        "A": [
-          "JAAAAAAAAAAAAAAAAAAAAA==",
-          "wAAAAAAAAAAAAAAAAAAAAA==",
-          "ACAAAAAAAAAAAAAAAAAAAA=="
-        ],
-        "k": 1
-      }
-    },
-    "gfdiv": {
-      "action": "gfdiv",
-      "arguments": {
-        "a": "JAAAAAAAAAAAAAAAAAAAAA==",
-        "b": "wAAAAAAAAAAAAAAAAAAAAA=="
-      }
-    }
-  }
-}

test_json/poly_algs.json

@@ -1,29 +0,0 @@
-{
-  "testcases": {
-    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
-
-"action": "gfpoly_sort",
-"arguments": {
-"polys": [
-[
-"NeverGonnaGiveYouUpAAA==",
-"NeverGonnaLetYouDownAA==",
-"NeverGonnaRunAroundAAA==",
-"AndDesertYouAAAAAAAAAA=="
-],
-[
-"WereNoStrangersToLoveA==",
-"YouKnowTheRulesAAAAAAA==",
-"AndSoDoIAAAAAAAAAAAAAA=="
-],
-[
-"NeverGonnaMakeYouCryAA==",
-"NeverGonnaSayGoodbyeAA==",
-"NeverGonnaTellALieAAAA==",
-"AndHurtYouAAAAAAAAAAAA=="
-]
-]
-}
-}
-  }
-}

test_json/sandbox.json

@@ -1,29 +0,0 @@
-{
-    "testcases": {
-        "gcm_crack1": {
-            "action": "gcm_crack",
-            "arguments": {
-                "nonce": "4gF+BtR3ku/PUQci",
-                "m1": {
-                    "ciphertext": "CGOkZDnJEt24aVV8mqQq+P4pouVDWhAYj0SN5MDAgg==",
-                    "associated_data": "TmFjaHJpY2h0IDE=",
-                    "tag": "GC9neV3aZLnmznTIWqCC4A=="
-                },
-                "m2": {
-                    "ciphertext": "FnWyLSTfRrO8Y1MuhLIs6A==",
-                    "associated_data": "",
-                    "tag": "gb2ph1vzwU85/FsUg51t3Q=="
-                },
-                "m3": {
-                    "ciphertext": "CGOkZDnJEt25aV58iaMt6O8+8chKVh0Eg1XFxA==",
-                    "associated_data": "TmFjaHJpY2h0IDM=",
-                    "tag": "+/aDjsAzTseDLuM4jt5Q6Q=="
-                },
-                "forgery": {
-                    "ciphertext": "AXe/ZQ==",
-                    "associated_data": ""
-                }
-            }
-        }
-    }
-}

test_json/xex_tests.json

@@ -1,22 +0,0 @@
-{
-  "testcases": {
-    "0192d428-3913-762b-a702-d14828eae1f8": {
-      "action": "xex",
-      "arguments": {
-        "mode": "encrypt",
-        "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=",
-        "tweak": "6VXORr+YYHrd2nVe0OlA+Q==",
-        "input": "/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW"
-      }
-    },
-    "0192d428-3913-7168-a3bb-69c258c74dc1": {
-      "action": "xex",
-      "arguments": {
-        "mode": "decrypt",
-        "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=",
-        "tweak": "6VXORr+YYHrd2nVe0OlA+Q==",
-        "input": "lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a"
-      }
-    }
-  }
-}