diff --git a/Cargo.toml b/Cargo.toml
index e127c7e..0d58d2b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,9 +10,17 @@ 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
diff --git a/src/main.rs b/src/main.rs
index 5816ecb..0bb3127 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,10 @@
 use std::{
-    env::{self, args},
+    env::{self},
     fs,
 };
 
+// TESTING 2
+
 use anyhow::Result;
 
 fn main() -> Result<()> {
@@ -12,7 +14,7 @@ fn main() -> Result<()> {
     let json = fs::read_to_string(path_to_workload).unwrap();
     let workload = kauma::utils::parse::parse_json(json)?;
 
-    let response = kauma::tasks::task_distrubute(&workload)?;
+    let response = kauma::tasks::task_distribute(&workload)?;
     println!("{}", serde_json::to_string(&response)?);
 
     Ok(())
diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs
index 0fa72d6..8a8b782 100644
--- a/src/tasks/mod.rs
+++ b/src/tasks/mod.rs
@@ -1,19 +1,22 @@
 use base64::prelude::*;
 
-use std::{collections::HashMap, env::args};
+use std::collections::HashMap;
 
-use crate::utils::{
-    ciphers::gcm_encrypt_aes,
-    parse::{Responses, Testcase, Testcases},
-};
+use crate::utils::parse::{Responses, Testcase, Testcases};
 use tasks01::{
     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::{self, fde_xex},
+    xex::fde_xex,
 };
 
 use anyhow::{anyhow, Result};
@@ -83,6 +86,104 @@ pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
 
             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,
@@ -91,16 +192,60 @@ pub fn task_deploy(testcase: &Testcase) -> Result<Value> {
     }
 }
 
-pub fn task_distrubute(testcases: &Testcases) -> Result<Responses> {
+fn task_distribute_mt(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: responses,
-    })
+    Ok(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)]
@@ -133,7 +278,7 @@ mod tests {
         let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -157,7 +302,7 @@ mod tests {
         });
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -172,7 +317,7 @@ mod tests {
         let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -190,7 +335,7 @@ mod tests {
         }});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -210,7 +355,7 @@ mod tests {
         }}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -230,7 +375,7 @@ mod tests {
         }}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -248,7 +393,7 @@ mod tests {
         }}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            serde_json::to_value(task_distribute(&parsed)?).unwrap(),
             serde_json::to_value(expected).unwrap()
         );
 
@@ -266,7 +411,25 @@ mod tests {
         }}});
 
         assert_eq!(
-            serde_json::to_value(task_distrubute(&parsed)?).unwrap(),
+            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()
         );
 
diff --git a/src/tasks/tasks01/block2poly.rs b/src/tasks/tasks01/block2poly.rs
index dbdaf66..3377bf6 100644
--- a/src/tasks/tasks01/block2poly.rs
+++ b/src/tasks/tasks01/block2poly.rs
@@ -1,4 +1,4 @@
-use crate::utils::poly::{b64_2_num, block_2_polynomial, get_coefficients};
+use crate::utils::poly::block_2_polynomial;
 use anyhow::Result;
 use base64::prelude::*;
 use serde_json::Value;
@@ -19,7 +19,6 @@ 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::*;
diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs
new file mode 100644
index 0000000..09ccb2c
--- /dev/null
+++ b/src/tasks/tasks01/gcm_crack.rs
@@ -0,0 +1,174 @@
+
+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),
+    })
+}
diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs
index 01731f6..8bca55f 100644
--- a/src/tasks/tasks01/gfmul.rs
+++ b/src/tasks/tasks01/gfmul.rs
@@ -1,7 +1,4 @@
-use crate::utils::{
-    field::ByteArray,
-    poly::{b64_2_num, coefficient_to_binary, gfmul},
-};
+use crate::utils::poly::gfmul;
 
 use anyhow::Result;
 use base64::prelude::*;
@@ -16,7 +13,7 @@ pub fn gfmul_task(args: &Value) -> Result<Vec<u8>> {
 
     let semantic: String = serde_json::from_value(args["semantic"].clone())?;
 
-    let result = gfmul(poly_a, poly_b, &semantic)?;
+    let result = gfmul(&poly_a, &poly_b, &semantic)?;
 
     Ok(result)
 }
@@ -24,7 +21,6 @@ pub fn gfmul_task(args: &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::*;
@@ -39,7 +35,7 @@ mod tests {
         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")?);
+        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
 
         assert_eq!(
             result, "hSQAAAAAAAAAAAAAAAAAAA==",
@@ -59,7 +55,7 @@ mod tests {
         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")?);
+        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
 
         assert_eq!(
             result, "QKgUAAAAAAAAAAAAAAAAAA==",
@@ -79,7 +75,7 @@ mod tests {
         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")?);
+        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
 
         assert_eq!(
             result, "UIAUAAAAAAAAAAAAAAAAAA==",
@@ -99,27 +95,7 @@ mod tests {
         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_task01_gcm() -> Result<()> {
-        let args: Value = json!({"a": "AAAAAAAAAAAAAAAQBAAAAA==", "b": "IAAAAAAAAACAAAAAAAAAAA=="});
-
-        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, "gcm")?);
+        let result = BASE64_STANDARD.encode(gfmul(&poly_a, &poly_b, "xex")?);
 
         assert_eq!(
             result, "hSQAAAAAAAAAAAAAAAAAAA==",
diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs
index 479fe47..64d24da 100644
--- a/src/tasks/tasks01/mod.rs
+++ b/src/tasks/tasks01/mod.rs
@@ -1,7 +1,9 @@
 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;
diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs
index 1a0c144..234babf 100644
--- a/src/tasks/tasks01/pad_oracle.rs
+++ b/src/tasks/tasks01/pad_oracle.rs
@@ -3,8 +3,7 @@ use base64::prelude::*;
 use serde_json::Value;
 use std::io::prelude::*;
 use std::net::TcpStream;
-use std::time::{Duration, Instant};
-use std::{thread, usize};
+use std::usize;
 
 pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
     let hostname: String = serde_json::from_value(args["hostname"].clone())?;
@@ -29,9 +28,8 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
     let mut chunk_counter = 0;
 
     for chunk in &cipher_chunks {
-        let start = Instant::now();
-
-        let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port))?;
+        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
@@ -42,7 +40,6 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
         let q_block_count: u16 = 256;
 
         //Send the first ciphertext chunk
-        //eprintln!("Sending Ciphertext chunk: {:002X?}", chunk);
         stream.flush()?;
         stream.write_all(&chunk)?;
         stream.flush()?;
@@ -52,23 +49,16 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
             // 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();
-            //eprintln!("Sending l_msg: {:02X?}", l_msg);
-            //stream.write_all(&l_msg)?;
-            //stream.flush()?;
-            //eprintln!("L_msg sent");
 
             // Generate attack blocks
             //  TODO: Collect all and send in one
-            let mut payload: Vec<u8> = l_msg.to_vec();
-            for j in 0..q_block_count {
+            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
-                //eprintln!("Sending attack block: {:02X?}", attack_counter);
-
-                //thread::sleep(Duration::from_millis(1000));
                 payload.extend(&attack_counter);
                 attack_counter[i as usize] += 1;
             }
-            //eprintln!("Time for qblocks: {:?}", start.elapsed());
 
             stream.write_all(&payload)?;
             stream.flush()?;
@@ -76,70 +66,57 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
             // Read server response
             let mut server_q_resp = [0u8; 256];
             stream.read_exact(&mut server_q_resp)?;
-            //eprintln!("{:02X?}", buf);
 
             // extract valid position
             let valid_val = server_q_resp
                 .iter()
                 .position(|&r| r == 0x01)
-                .expect("No valid found in main loop") as u8;
-            //eprintln!("Valid value found: {:02X?}", valid_val);
+                .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];
 
-                stream.write_all(&[0x01, 0x00])?;
-                stream.write_all(&check_q_block)?;
+                l_msg_check.extend(check_q_block.as_slice());
+
+                stream.write_all(&l_msg_check)?;
                 let mut buf = [0u8; 0x01];
                 stream.read(&mut buf)?;
-                eprintln!("Buffer from pad check: {:02X?}", buf);
                 if buf == [0x01] {
-                    eprintln!("Valid padding");
                 } else {
-                    eprintln!("Invalid padding");
                     // Search for second hit
-                    let valid_val = (255
+                    let valid_val = 255
                         - server_q_resp
                             .iter()
                             .rev()
                             .position(|&r| r == 0x01)
-                            .expect("No valid found") as u8);
-                    eprintln!("Valid value found: {:02X?}", valid_val);
+                            .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() {
-                //eprintln!("XOR Next Ciph block");
                 plaintext.push(
                     cipher_chunks[chunk_counter + 1][i]
                         ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1)),
                 );
             } else {
-                //seprintln!("XOR IV");
-
                 plaintext.push(iv[i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1)));
             }
-            //eprintln!("Attack counter after set: {:02X?}", attack_counter);
-            for pos in i..=15 {
-                //eprintln!("i is: {:02X?}", i);
-                //eprintln!("i + 1 is: {:02X?}", ((16 - i) as u8).to_le());
-                /*
-                eprintln!(
-                    "attack_counter[pos as usize]: {:02X?}",
-                    attack_counter[pos as usize]
-                );
-                eprintln!(
-                    "attack_counter[pos as usize] ^ 0x02 {:02X?}",
-                    attack_counter[pos 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);
@@ -148,13 +125,10 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
             stream.flush()?;
 
             // Write plaintext
-            //eprintln!("{:02X?}", plaintext);
         }
         chunk_counter += 1;
         stream.flush()?;
-        // break;
         drop(stream);
-        eprintln!("Time rest of calc: {:?}", start.elapsed());
     }
 
     plaintext.reverse();
@@ -166,7 +140,6 @@ pub fn padding_oracle(args: &Value) -> Result<Vec<u8>> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use serde_json::json;
 
     #[test]
     fn test_connection() -> Result<()> {
diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs
new file mode 100644
index 0000000..6830e1a
--- /dev/null
+++ b/src/tasks/tasks01/pfmath.rs
@@ -0,0 +1,282 @@
+
+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==");
+    }
+}
diff --git a/src/tasks/tasks01/poly2block.rs b/src/tasks/tasks01/poly2block.rs
index 293d1c3..7557981 100644
--- a/src/tasks/tasks01/poly2block.rs
+++ b/src/tasks/tasks01/poly2block.rs
@@ -1,6 +1,5 @@
-use crate::utils::poly::{self, polynomial_2_block};
+use crate::utils::poly::polynomial_2_block;
 use anyhow::{Ok, Result};
-use base64::prelude::*;
 use serde_json::Value;
 
 pub fn poly2block(args: &Value) -> Result<Vec<u8>> {
diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs
index 3f5c40d..2a6a7e2 100644
--- a/src/tasks/tasks01/sea128.rs
+++ b/src/tasks/tasks01/sea128.rs
@@ -6,19 +6,13 @@ 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)
@@ -34,7 +28,6 @@ pub fn sea128(args: &Value) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
-    use std::fs;
 
     use anyhow::Result;
     use serde_json::json;
diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs
index 917a1c7..0b558af 100644
--- a/src/utils/ciphers.rs
+++ b/src/utils/ciphers.rs
@@ -1,8 +1,5 @@
-use std::{io::BufRead, process::Output};
-
-use crate::utils::{field::ByteArray, math::reverse_bits_in_bytevec, poly::gfmul};
+use crate::utils::{field::ByteArray, poly::gfmul};
 use anyhow::Result;
-use base64::prelude::*;
 use openssl::symm::{Cipher, Crypter, Mode};
 
 use super::math::xor_bytes;
@@ -40,7 +37,6 @@ 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)
 }
@@ -122,10 +118,8 @@ pub fn gcm_encrypt_aes(
     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());
-    eprintln!("{:001X?}", nonce);
 
     let auth_tag_xor = aes_128_encrypt(&key, &nonce)?;
-    eprintln!("Y0 {:001X?}", auth_tag_xor);
 
     let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?;
 
@@ -136,8 +130,6 @@ pub fn gcm_encrypt_aes(
         nonce.drain(12..);
         nonce.append(counter.to_be_bytes().to_vec().as_mut());
 
-        eprintln!("{:001X?}", nonce);
-
         let inter1 = aes_128_encrypt(&key, &nonce)?;
 
         let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
@@ -154,7 +146,6 @@ pub fn gcm_encrypt_aes(
         &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
         auth_tag_xor,
     )?;
-    eprintln!("aes auth tag: {:001X?}", &auth_tag);
 
     Ok((ciphertext, auth_tag, l_field, auth_key_h))
 }
@@ -170,8 +161,6 @@ pub fn gcm_decrypt_aes(
 
     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());
-    eprintln!("{:001X?}", nonce);
 
     let auth_tag_xor = aes_128_encrypt(&key, &nonce)?;
 
@@ -184,8 +173,6 @@ pub fn gcm_decrypt_aes(
         nonce.drain(12..);
         nonce.append(counter.to_be_bytes().to_vec().as_mut());
 
-        eprintln!("{:001X?}", nonce);
-
         let inter1 = aes_128_encrypt(&key, &nonce)?;
 
         let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
@@ -204,7 +191,6 @@ pub fn gcm_decrypt_aes(
     )?;
 
     let valid = auth_tag == tag;
-    eprintln!("aes auth tag: {:001X?}", auth_tag);
 
     Ok((plaintext, valid))
 }
@@ -220,7 +206,6 @@ pub fn gcm_encrypt_sea(
     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());
-    eprintln!("{:001X?}", nonce);
 
     let auth_tag_xor = sea_128_encrypt(&key, &nonce)?;
 
@@ -233,8 +218,6 @@ pub fn gcm_encrypt_sea(
         nonce.drain(12..);
         nonce.append(counter.to_be_bytes().to_vec().as_mut());
 
-        eprintln!("{:001X?}", nonce);
-
         let inter1 = sea_128_encrypt(&key, &nonce)?;
 
         let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
@@ -266,8 +249,6 @@ pub fn gcm_decrypt_sea(
 
     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());
-    eprintln!("Nonce 1: {:001X?}", nonce);
 
     let auth_tag_xor = sea_128_encrypt(&key, &nonce)?;
 
@@ -275,17 +256,11 @@ pub fn gcm_decrypt_sea(
 
     let plaintext_chunks: Vec<Vec<u8>> = ciphertext.chunks(16).map(|x| x.to_vec()).collect();
 
-    eprintln!("{:?}", plaintext_chunks);
-
     counter = 2;
     for chunk in plaintext_chunks {
-        eprintln!("Inside loop");
-
         nonce.drain(12..);
         nonce.append(counter.to_be_bytes().to_vec().as_mut());
 
-        eprintln!("Nonce 2: {:001X?}", nonce);
-
         let inter1 = sea_128_encrypt(&key, &nonce)?;
 
         let mut inter2 = xor_bytes(&inter1, chunk.clone())?;
@@ -298,15 +273,11 @@ pub fn gcm_decrypt_sea(
     let mut c_len: Vec<u8> = ((plaintext.len() * 8) as u64).to_be_bytes().to_vec();
     l_field.append(c_len.as_mut());
 
-    eprintln!("Ciphertext: {}", BASE64_STANDARD.encode(&ciphertext));
-
     let auth_tag = xor_bytes(
         &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?,
         auth_tag_xor,
     )?;
 
-    eprintln!("sea dec auth tag: {}", BASE64_STANDARD.encode(&auth_tag));
-
     let valid = auth_tag == tag;
 
     Ok((plaintext, valid))
@@ -320,10 +291,6 @@ pub fn ghash(
 ) -> Result<Vec<u8>> {
     let output: Vec<u8> = vec![0; 16];
 
-    eprintln!("{:?}", ad.len() as u8);
-    eprintln!("{:?}", (ad.len() % 16) as u8);
-    eprintln!("{:001X?}", ad);
-
     if ad.len() % 16 != 0 || ad.is_empty() {
         ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut());
     }
@@ -332,46 +299,29 @@ pub fn ghash(
         ciphertext.append(vec![0u8; 16 - (ciphertext.len() % 16)].as_mut());
     }
 
-    eprintln!("{:001X?}", ad);
-    eprintln!("{:001X?}", ciphertext);
-
     let mut ad_chunks = ad.chunks(16);
 
-    eprintln!("Ad chunks before first next {:001X?}", ad_chunks);
-
     let inter1 = xor_bytes(&output, ad_chunks.next().unwrap().to_vec())?;
-    let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?;
-    eprintln!("Ad chunks after first next {:001X?}", ad_chunks);
+    let mut inter_loop = gfmul(&inter1, &auth_key_h, "gcm")?;
 
     for chunk in ad_chunks {
-        eprintln!("Inside ad chunk loop");
-        eprintln!("Ad chunk in loop {:001X?}", chunk);
         let inter2 = xor_bytes(&inter_loop, chunk.to_vec())?;
-        inter_loop = gfmul(inter2, auth_key_h.clone(), "gcm")?;
+        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.clone(), "gcm")?;
+        inter_loop = gfmul(&inter3, &auth_key_h, "gcm")?;
     }
 
     let inter4 = xor_bytes(&inter_loop, l_field)?;
-    inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?;
-
-    eprintln!("GHASH auth tag: {:001X?}", inter_loop);
+    inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?;
 
     Ok(inter_loop)
 }
 
-/*
-* let mut bytes: [u8; 16] = [0u8; 16];
-    bytes.copy_from_slice(&ciphertext);
-    let number: u128 = <u128>::from_be_bytes(bytes);
-
-* */
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/utils/dff.rs b/src/utils/dff.rs
new file mode 100644
index 0000000..21dde69
--- /dev/null
+++ b/src/utils/dff.rs
@@ -0,0 +1,81 @@
+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)
+    }
+}
diff --git a/src/utils/edf.rs b/src/utils/edf.rs
new file mode 100644
index 0000000..dfb59cf
--- /dev/null
+++ b/src/utils/edf.rs
@@ -0,0 +1,86 @@
+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=="
+                ]
+            ]
+        )
+    }
+}
diff --git a/src/utils/field.rs b/src/utils/field.rs
index 5645b04..739b466 100644
--- a/src/utils/field.rs
+++ b/src/utils/field.rs
@@ -1,7 +1,239 @@
-use anyhow::{anyhow, Ok, Result};
-use base64::Engine;
+use base64::prelude::*;
+use std::{u128, u8, usize};
 
-use super::poly::gfmul;
+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>);
@@ -37,13 +269,13 @@ impl ByteArray {
                 let alpha_poly: Vec<u8> = base64::prelude::BASE64_STANDARD
                     .decode("AgAAAAAAAAAAAAAAAAAAAA==")
                     .expect("Decode failed");
-                self.0 = gfmul(self.0.clone(), alpha_poly, "xex").unwrap();
+                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.clone(), alpha_poly, "gcm").unwrap();
+                self.0 = gfmul(&self.0, &alpha_poly, "gcm").unwrap();
             }
             _ => {}
         }
@@ -105,13 +337,12 @@ impl ByteArray {
 #[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("xex");
+        byte_array.left_shift("xex").unwrap();
 
         assert_eq!(byte_array.0, shifted_array.0);
     }
@@ -120,7 +351,7 @@ mod tests {
     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");
+        byte_array.left_shift("xex").unwrap();
 
         assert_eq!(
             byte_array.0, shifted_array.0,
@@ -133,7 +364,7 @@ mod tests {
     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");
+        byte_array.left_shift("gcm").unwrap();
 
         assert_eq!(
             byte_array.0, shifted_array.0,
@@ -146,7 +377,7 @@ mod tests {
     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");
+        byte_array.right_shift("gcm").unwrap();
 
         assert_eq!(
             byte_array.0, shifted_array.0,
@@ -159,7 +390,7 @@ mod tests {
     fn test_byte_array_shift_right() {
         let mut byte_array: ByteArray = ByteArray(vec![0x02]);
         let shifted_array: ByteArray = ByteArray(vec![0x01]);
-        byte_array.right_shift("xex");
+        byte_array.right_shift("xex").unwrap();
 
         assert_eq!(
             byte_array.0, shifted_array.0,
@@ -199,4 +430,39 @@ mod tests {
 
         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==");
+    }
 }
diff --git a/src/utils/math.rs b/src/utils/math.rs
index cf87e0c..c1809e2 100644
--- a/src/utils/math.rs
+++ b/src/utils/math.rs
@@ -1,7 +1,5 @@
-use anyhow::{anyhow, Ok, Result};
-use base64::Engine;
+use anyhow::{Ok, Result};
 
-use super::poly::gfmul;
 
 pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
     for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) {
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 298415b..35fb781 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -1,6 +1,9 @@
 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;
diff --git a/src/utils/parse.rs b/src/utils/parse.rs
index 5cc1781..4b71b29 100644
--- a/src/utils/parse.rs
+++ b/src/utils/parse.rs
@@ -8,13 +8,13 @@ pub struct Testcases {
     pub testcases: HashMap<String, Testcase>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Testcase {
     pub action: String,
     pub arguments: Value,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Responses {
     pub responses: HashMap<String, Value>,
 }
@@ -28,8 +28,6 @@ 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::*;
 
diff --git a/src/utils/poly.rs b/src/utils/poly.rs
index 78889c8..6a61853 100644
--- a/src/utils/poly.rs
+++ b/src/utils/poly.rs
@@ -1,28 +1,567 @@
 use crate::utils::field::ByteArray;
-use anyhow::{anyhow, Result};
 use base64::prelude::*;
-use serde_json::Value;
+
+use num::traits::FromBytes;
+use num::{BigUint, One, Zero};
+
 use std::{str::FromStr, u128, u8, usize};
 
-use super::{field, math::reverse_bits_in_bytevec};
+use std::{
+    cmp::Ordering,
+    ops::{Add, Mul},
+};
+
+use anyhow::{anyhow, Ok, Result};
+use serde_json::Value;
+
+use super::field::FieldElement;
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct Polynomial {
+    polynomial: Vec<FieldElement>,
+}
+
+impl Polynomial {
+    pub const fn new(polynomial: Vec<FieldElement>) -> Self {
+        Self { polynomial }
+    }
+
+    pub fn degree(&self) -> usize {
+        self.polynomial.len() - 1
+    }
+
+    pub fn empty() -> Polynomial {
+        Polynomial::new(vec![])
+    }
+
+    pub fn one() -> Self {
+        Polynomial::new(vec![FieldElement::one()])
+    }
+
+    pub fn x() -> Self {
+        Polynomial::new(vec![
+            FieldElement::new(vec![0; 16]),
+            FieldElement::new(polynomial_2_block(vec![0], "xex").unwrap()),
+        ])
+    }
+
+    pub fn rand(rng_cap: &usize) -> Self {
+        let mut rand_poly: Vec<FieldElement> = Vec::with_capacity(rng_cap.to_owned());
+        for _i in 0..rng_cap.to_owned() {
+            rand_poly.push(FieldElement::rand());
+        }
+
+        Polynomial::new(rand_poly)
+    }
+
+    pub fn zero() -> Self {
+        Polynomial::new(vec![FieldElement::zero()])
+    }
+
+    pub fn from_c_array(array: &Value) -> Self {
+        let mut polynomial: Vec<FieldElement> = vec![];
+        let c_array: Vec<String> = array
+            .as_array()
+            .expect("Input is not an array")
+            .iter()
+            .map(|x| {
+                x.as_str()
+                    .expect("Array element is not a string")
+                    .to_string()
+            })
+            .collect();
+
+        for coefficient in c_array {
+            polynomial.push(FieldElement::new(
+                BASE64_STANDARD
+                    .decode(coefficient)
+                    .expect("Error on poly decode:"),
+            ));
+        }
+        Self { polynomial }
+    }
+
+    pub fn to_c_array(self) -> Vec<String> {
+        let mut output: Vec<String> = vec![];
+        for coeff in self.polynomial {
+            output.push(coeff.to_b64());
+        }
+
+        output
+    }
+
+    pub fn pow(mut self, mut exponent: u128) -> Polynomial {
+        let mut result: Polynomial = Polynomial::new(vec![FieldElement::new(
+            polynomial_2_block(vec![0], "gcm").unwrap(),
+        )]);
+
+        if exponent == 1 {
+            return self;
+        }
+
+        if exponent == 0 {
+            let result = Polynomial::new(vec![FieldElement::new(
+                polynomial_2_block(vec![0], "gcm").unwrap(),
+            )]);
+
+            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;
+        }
+
+        while !result.polynomial.is_empty()
+            && result
+                .polynomial
+                .last()
+                .unwrap()
+                .as_ref()
+                .iter()
+                .all(|&x| x == 0)
+        {
+            result.polynomial.pop();
+        }
+
+        if result.is_empty() {
+            result = Polynomial::zero();
+        }
+
+        result
+    }
+
+    pub fn bpow_mod(mut self, mut exponent: BigUint, modulus: &Polynomial) -> Polynomial {
+        let mut result: Polynomial = Polynomial::new(vec![FieldElement::new(
+            polynomial_2_block(vec![0], "gcm").unwrap(),
+        )]);
+
+        if exponent == BigUint::one() {
+            return self.div(&modulus).1;
+        }
+
+        if exponent == BigUint::zero() {
+            let result = Polynomial::new(vec![FieldElement::new(
+                polynomial_2_block(vec![0], "gcm").unwrap(),
+            )]);
+
+            return result;
+        }
+
+        while &exponent > &BigUint::zero() {
+            if &exponent & BigUint::one() == BigUint::one() {
+                let temp = &self * &result;
+                result = temp.div(&modulus).1;
+            }
+            let temp_square = &self * &self;
+            self = temp_square.div(&modulus).1;
+            exponent >>= 1;
+        }
+
+        while !result.polynomial.is_empty()
+            && result
+                .polynomial
+                .last()
+                .unwrap()
+                .as_ref()
+                .iter()
+                .all(|&x| x == 0)
+        {
+            result.polynomial.pop();
+        }
+
+        if result.is_empty() {
+            result = Polynomial::zero();
+        }
+
+        result
+    }
+    pub fn pow_mod(mut self, mut exponent: u128, modulus: Polynomial) -> Polynomial {
+        let mut result: Polynomial = Polynomial::new(vec![FieldElement::new(
+            polynomial_2_block(vec![0], "gcm").unwrap(),
+        )]);
+
+        if exponent == 1 {
+            return self.div(&modulus).1;
+        }
+
+        if exponent == 0 {
+            let result = Polynomial::new(vec![FieldElement::one()]);
+
+            return result;
+        }
+
+        while exponent > 0 {
+            if exponent & 1 == 1 {
+                let temp = &self * &result;
+                result = temp.div(&modulus).1;
+            }
+            let temp_square = &self * &self;
+            self = temp_square.div(&modulus).1;
+            exponent >>= 1;
+        }
+
+        while !result.polynomial.is_empty()
+            && result
+                .polynomial
+                .last()
+                .unwrap()
+                .as_ref()
+                .iter()
+                .all(|&x| x == 0)
+        {
+            result.polynomial.pop();
+        }
+
+        if result.is_empty() {
+            result = Polynomial::zero();
+        }
+
+        result
+    }
+
+    pub fn div(&self, rhs: &Self) -> (Self, Self) {
+        if self.polynomial.len() < rhs.polynomial.len() {
+            return (Polynomial::new(vec![FieldElement::zero()]), self.clone());
+        }
+
+        let mut remainder = self.clone();
+        let divisor = rhs;
+        let dividend_deg = remainder.polynomial.len() - 1;
+        let divisor_deg = divisor.polynomial.len() - 1;
+
+        if dividend_deg < divisor_deg {
+            return (Polynomial::new(vec![FieldElement::zero()]), remainder);
+        }
+
+        let mut quotient_coeffs = vec![FieldElement::zero(); dividend_deg - divisor_deg + 1];
+
+        while remainder.polynomial.len() >= divisor.polynomial.len() {
+            let deg_diff = remainder.polynomial.len() - divisor.polynomial.len();
+            let leading_dividend = remainder.polynomial.last().unwrap();
+            let leading_divisor = divisor.polynomial.last().unwrap();
+            let quot_coeff = leading_dividend / leading_divisor;
+            quotient_coeffs[deg_diff] = quot_coeff.clone();
+
+            let mut pos;
+            for (i, divisor_coeff) in divisor.polynomial.iter().enumerate() {
+                pos = deg_diff + i;
+                let a: &FieldElement = &remainder.polynomial[pos];
+                let c: &FieldElement = &quot_coeff;
+                remainder.polynomial[pos] = a + &(divisor_coeff * c);
+            }
+
+            while !remainder.polynomial.is_empty() && remainder.polynomial.last().unwrap().is_zero()
+            {
+                remainder.polynomial.pop();
+            }
+        }
+
+        if remainder.is_empty() {
+            remainder = Polynomial::zero();
+        }
+
+        (Polynomial::new(quotient_coeffs), remainder)
+    }
+
+    fn is_zero(&self) -> bool {
+        for field_element in &self.polynomial {
+            if !field_element.is_zero() {
+                return false;
+            }
+        }
+        true
+    }
+
+    pub fn monic(mut self) -> Self {
+        let divident = self.polynomial.last().unwrap().clone();
+
+        for fieldelement in &mut self.polynomial.iter_mut() {
+            *fieldelement = fieldelement.clone() / divident.clone();
+        }
+
+        while !self.polynomial.is_empty()
+            && self
+                .polynomial
+                .last()
+                .unwrap()
+                .as_ref()
+                .iter()
+                .all(|&x| x == 0)
+        {
+            self.polynomial.pop();
+        }
+
+        if self.is_empty() {
+            self = Polynomial::new(vec![FieldElement::new(vec![0; 16])]);
+        }
+        self
+    }
+
+    pub fn sqrt(self) -> Self {
+        let mut result = vec![];
+
+        for (position, element) in self.polynomial.iter().enumerate() {
+            if position % 2 == 0 {
+                result.push(element.clone().pow(2u128.pow(127)));
+            }
+        }
+
+        Polynomial::new(result)
+    }
+
+    pub fn diff(mut self) -> Self {
+        // Pop first element
+        // Check if the polynomial is 1 or less. In this case, output would be [] without check
+        // Output should be [0; 16] however
+        if self.polynomial.len() > 1 {
+            self.polynomial.remove(0);
+        } else {
+            return Polynomial::new(vec![FieldElement::new(vec![0; 16])]);
+        }
+
+        for (position, element) in self.polynomial.iter_mut().enumerate() {
+            // Set all uneven degrees to 0, as they were the even degrees before
+            // As we are in GF128, this means they become 0 after mul with even number
+            if position % 2 == 1 {
+                *element = FieldElement::new(vec![0; 16]);
+            }
+        }
+
+        while !self.polynomial.is_empty()
+            && self
+                .polynomial
+                .last()
+                .unwrap()
+                .as_ref()
+                .iter()
+                .all(|&x| x == 0)
+        {
+            self.polynomial.pop();
+        }
+
+        if self.is_empty() {
+            self = Polynomial::new(vec![FieldElement::new(vec![0; 16])]);
+        }
+
+        self
+    }
+
+    pub fn extract_component(&self, i: u32) -> FieldElement {
+        self.polynomial[i as usize].clone()
+    }
+}
+
+impl Clone for Polynomial {
+    fn clone(&self) -> Self {
+        Polynomial {
+            polynomial: self.polynomial.clone(),
+        }
+    }
+}
+
+impl Mul for Polynomial {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        if self.is_zero() || rhs.is_zero() {
+            return Polynomial::zero();
+        }
+        let mut polynomial: Vec<FieldElement> =
+            vec![FieldElement::zero(); self.polynomial.len() + rhs.polynomial.len() - 1];
+        for i in 0..self.polynomial.len() {
+            for j in 0..rhs.polynomial.len() {
+                polynomial[i + j] = &polynomial[i + j]
+                    + &(self.polynomial.get(i).unwrap() * rhs.polynomial.get(j).unwrap());
+            }
+        }
+        Polynomial::new(polynomial)
+    }
+}
+
+impl Mul for &Polynomial {
+    type Output = Polynomial;
+    fn mul(self, rhs: Self) -> Self::Output {
+        if self.is_zero() || rhs.is_zero() {
+            return Polynomial::zero();
+        }
+        let mut polynomial: Vec<FieldElement> =
+            vec![FieldElement::zero(); self.polynomial.len() + rhs.polynomial.len() - 1];
+        for i in 0..self.polynomial.len() {
+            for j in 0..rhs.polynomial.len() {
+                polynomial[i + j] = &polynomial[i + j]
+                    + &(self.polynomial.get(i).unwrap() * rhs.polynomial.get(j).unwrap());
+            }
+        }
+        Polynomial::new(polynomial)
+    }
+}
+
+impl Add for Polynomial {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        let mut polynomial: Vec<FieldElement>;
+
+        if self.polynomial.len() > rhs.polynomial.len() {
+            polynomial = self.polynomial.clone();
+            for i in 0..rhs.polynomial.len() {
+                polynomial[i] = polynomial[i].clone() + rhs.polynomial[i].clone();
+            }
+        } else {
+            polynomial = rhs.polynomial.clone();
+            for i in 0..self.polynomial.len() {
+                polynomial[i] = polynomial[i].clone() + self.polynomial[i].clone();
+            }
+        }
+
+        while !polynomial.is_empty() && polynomial.last().unwrap().as_ref().iter().all(|&x| x == 0)
+        {
+            polynomial.pop();
+        }
+
+        if polynomial.is_empty() {
+            return Polynomial::new(vec![FieldElement::zero()]);
+        }
+
+        Polynomial::new(polynomial)
+    }
+}
+
+trait IsEmpty {
+    fn is_empty(&self) -> bool;
+}
+
+impl IsEmpty for Polynomial {
+    fn is_empty(&self) -> bool {
+        self.polynomial.is_empty()
+    }
+}
+impl AsRef<[FieldElement]> for Polynomial {
+    fn as_ref(&self) -> &[FieldElement] {
+        &self.polynomial
+    }
+}
+
+impl PartialEq for Polynomial {
+    fn eq(&self, other: &Self) -> bool {
+        if self.polynomial.len() != other.polynomial.len() {
+            return false;
+        }
+        // Compare each coefficient
+        self.polynomial
+            .iter()
+            .zip(other.polynomial.iter())
+            .all(|(a, b)| a == b)
+    }
+}
+
+impl PartialOrd for Polynomial {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match other.polynomial.len().cmp(&self.polynomial.len()) {
+            Ordering::Equal => {
+                for (field_a, field_b) in
+                    self.as_ref().iter().rev().zip(other.as_ref().iter().rev())
+                {
+                    match field_a
+                        //.reverse_bits()
+                        .partial_cmp(&field_b)
+                        .unwrap()
+                    {
+                        Ordering::Equal => continue,
+                        other => return Some(other),
+                    }
+                }
+                Some(Ordering::Equal)
+            }
+            other => Some(other.reverse()),
+        }
+    }
+}
+
+impl Eq for Polynomial {}
+
+impl Ord for Polynomial {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match other.polynomial.len().cmp(&self.polynomial.len()) {
+            Ordering::Equal => {
+                for (field_a, field_b) in
+                    self.as_ref().iter().rev().zip(other.as_ref().iter().rev())
+                {
+                    match field_a
+                        //.reverse_bits()
+                        .cmp(&field_b)
+                    {
+                        Ordering::Equal => continue,
+                        other => return other,
+                    }
+                }
+                Ordering::Equal
+            }
+            other => other.reverse(),
+        }
+    }
+}
+
+pub fn gcd(a: &Polynomial, b: &Polynomial) -> Polynomial {
+    if a.is_zero() {
+        return b.clone();
+    }
+    if b.is_zero() {
+        return a.clone();
+    }
+
+    if a.degree() > b.degree() {
+        return gcd(b, a);
+    }
+
+    let (_, remainder) = b.div(a);
+
+    if remainder.is_zero() {
+        return a.clone().monic();
+    }
+
+    gcd(&remainder, a)
+}
+
+pub fn non_monic_gcd(a: &Polynomial, b: &Polynomial) -> Polynomial {
+    if a.is_zero() {
+        return b.clone();
+    }
+
+    let b = b.div(&a).1;
+    return non_monic_gcd(&b, a);
+}
+
+pub fn sort_polynomial_array(mut polys: Vec<Polynomial>) -> Result<Vec<Polynomial>> {
+    // Algorithm to sort polynomials
+    // First sorting round
+    // Sorting by degree of polynomial
+    polys.sort();
+
+    Ok(polys)
+}
+
 pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000;
 
-pub fn gfmul(poly_a: Vec<u8>, poly_b: Vec<u8>, semantic: &str) -> Result<Vec<u8>> {
-    let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec());
-    red_poly_bytes.0.push(0x01);
+pub fn gfmul(poly_a: &Vec<u8>, poly_b: &Vec<u8>, semantic: &str) -> Result<Vec<u8>> {
+    let red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec());
 
-    let mut poly1: ByteArray = ByteArray(poly_a);
-    poly1.0.push(0x00);
+    let mut poly1: ByteArray = ByteArray(poly_a.to_vec());
 
-    let mut poly2: ByteArray = ByteArray(poly_b);
-    poly2.0.push(0x00);
+    let mut poly2: ByteArray = ByteArray(poly_b.to_vec());
 
     if semantic == "gcm" {
         poly1.reverse_bits_in_bytevec();
         poly2.reverse_bits_in_bytevec();
     }
 
-    let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
 
     if poly2.LSB_is_one() {
         result.xor_byte_arrays(&poly1);
@@ -30,9 +569,9 @@ pub fn gfmul(poly_a: Vec<u8>, poly_b: Vec<u8>, semantic: &str) -> Result<Vec<u8>
     poly2.right_shift("xex")?;
 
     while !poly2.is_empty() {
-        poly1.left_shift("xex")?;
+        let carry = poly1.left_shift("xex")?;
 
-        if poly1.msb_is_one() {
+        if carry == 1 {
             poly1.xor_byte_arrays(&red_poly_bytes);
         }
 
@@ -43,7 +582,7 @@ pub fn gfmul(poly_a: Vec<u8>, poly_b: Vec<u8>, semantic: &str) -> Result<Vec<u8>
         poly2.right_shift("xex")?;
     }
 
-    result.0.remove(16);
+    //result.0.remove(16);
 
     if semantic == "gcm" {
         result.reverse_bits_in_bytevec();
@@ -64,8 +603,6 @@ pub fn convert_gcm_to_xex(gcm_poly: Vec<u8>) -> Result<Vec<u8>> {
 pub fn get_alpha_rep(num: u128) -> String {
     let powers: Vec<u8> = get_coefficients(num);
 
-    //println!("{:?}", powers);
-
     let mut alpha_rep = String::new();
 
     if powers.len() == 1 {
@@ -92,7 +629,6 @@ pub fn b64_2_num(string: &String) -> Result<u128> {
 pub fn get_coefficients(num: u128) -> Vec<u8> {
     let mut powers: Vec<u8> = vec![];
     for shift in 0..128 {
-        //println!("{:?}", ((num >> shift) & 1));
         if ((num >> shift) & 1) == 1 {
             powers.push(shift);
         }
@@ -172,7 +708,7 @@ pub fn coefficients_to_byte_arr_xex(coeffs: Vec<u8>) -> Vec<u8> {
     let mut byte_array: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
     for coeff in coeffs {
         let block_num = coeff / 8;
-        byte_array[usize::from(block_num)] |= (1 << (coeff % 7));
+        byte_array[usize::from(block_num)] |= 1 << (coeff % 7);
     }
 
     byte_array
@@ -189,31 +725,12 @@ pub fn coefficient_to_binary(coefficients: Vec<u8>) -> u128 {
 
 #[cfg(test)]
 mod tests {
-    use crate::utils::poly::b64_2_num;
+    use crate::utils::poly::{b64_2_num, gcd};
     use anyhow::Result;
+    use serde_json::json;
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
-    /*
-    * TODO: Consider removing
-    #[test]
-    fn coefficients_to_byte_arr_xex_test1() {
-        let coefficients: Vec<u8> = vec![0];
-        let byte_array = vec![
-            01, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
-        ];
-        assert_eq!(coefficients_to_byte_arr_xex(coefficients), byte_array)
-    }
-
-    #[test]
-    fn coefficients_to_byte_arr_xex_test2() {
-        let coefficients: Vec<u8> = vec![127, 12, 9, 0];
-        let byte_array = vec![
-            01, 12, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 80,
-        ];
-        assert_eq!(coefficients_to_byte_arr_xex(coefficients), byte_array)
-    }
-    */
     #[test]
     fn byte_indices_0x01() {
         let byte: u8 = 0x01;
@@ -238,7 +755,7 @@ mod tests {
     #[test]
     fn coeff_to_binary() {
         let coefficients: Vec<u8> = vec![12, 127, 9, 0];
-        let b64: &str = "ARIAAAAAAAAAAAAAAAAAgA==";
+        let _b64: &str = "ARIAAAAAAAAAAAAAAAAAgA==";
         let calculated_num: u128 = coefficient_to_binary(coefficients);
         assert_eq!(
             BASE64_STANDARD.encode(calculated_num.to_ne_bytes()),
@@ -258,4 +775,588 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_field_add_03() {
+        let json1 = json!([
+            "NeverGonnaGiveYouUpAAA==",
+            "NeverGonnaLetYouDownAA==",
+            "NeverGonnaRunAroundAAA==",
+            "AndDesertYouAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(
+            sum.to_c_array(),
+            vec![
+                "H1d3GuyA9/0OxeYouUpAAA==",
+                "OZuIncPAGEp4tYouDownAA==",
+                "NeverGonnaRunAroundAAA==",
+                "AndDesertYouAAAAAAAAAA=="
+            ]
+        );
+    }
+
+    #[test]
+    fn test_field_add_multiple_zeros() {
+        let json1 = json!([
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA==", "AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA==",]);
+    }
+
+    #[test]
+    fn test_field_add_same_element() {
+        let json1 = json!(["NeverGonnaGiveYouUpAAA=="]);
+        let json2 = json!(["NeverGonnaGiveYouUpAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA==",]);
+    }
+
+    #[test]
+    fn test_field_add_zero() {
+        let json1 = json!([
+            "NeverGonnaGiveYouUpAAA==",
+            "NeverGonnaLetYouDownAA==",
+            "NeverGonnaRunAroundAAA==",
+            "AndDesertYouAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(
+            sum.to_c_array(),
+            vec![
+                "NeverGonnaGiveYouUpAAA==",
+                "NeverGonnaLetYouDownAA==",
+                "NeverGonnaRunAroundAAA==",
+                "AndDesertYouAAAAAAAAAA=="
+            ]
+        );
+    }
+
+    #[test]
+    fn test_field_add_zero_to_zero() {
+        let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(sum.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
+    }
+
+    #[test]
+    fn test_field_add_short_to_long() {
+        let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let json2 = json!([
+            "NeverGonnaGiveYouUpAAA==",
+            "NeverGonnaLetYouDownAA==",
+            "NeverGonnaRunAroundAAA==",
+            "AndDesertYouAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let sum = element2 + element1;
+
+        assert_eq!(
+            sum.to_c_array(),
+            vec![
+                "NeverGonnaGiveYouUpAAA==",
+                "NeverGonnaLetYouDownAA==",
+                "NeverGonnaRunAroundAAA==",
+                "AndDesertYouAAAAAAAAAA=="
+            ]
+        );
+    }
+
+    #[test]
+    fn test_field_mul_01() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        //eprintln!("{:?}", element1);
+
+        let result = element1 * element2;
+
+        assert_eq!(
+            result.to_c_array(),
+            vec![
+                "MoAAAAAAAAAAAAAAAAAAAA==",
+                "sUgAAAAAAAAAAAAAAAAAAA==",
+                "MbQAAAAAAAAAAAAAAAAAAA==",
+                "AAhAAAAAAAAAAAAAAAAAAA=="
+            ]
+        );
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_poly_mul_with_zero() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        //eprintln!("{:?}", element1);
+
+        let result = element1 * element2;
+
+        assert_eq!(result.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_poly_pow_01() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.pow(3);
+
+        assert_eq!(
+            result.to_c_array(),
+            vec![
+                "AkkAAAAAAAAAAAAAAAAAAA==",
+                "DDAAAAAAAAAAAAAAAAAAAA==",
+                "LQIIAAAAAAAAAAAAAAAAAA==",
+                "8AAAAAAAAAAAAAAAAAAAAA==",
+                "ACgCQAAAAAAAAAAAAAAAAA==",
+                "AAAMAAAAAAAAAAAAAAAAAA==",
+                "AAAAAgAAAAAAAAAAAAAAAA=="
+            ]
+        );
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_poly_pow_with_zero() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.pow(0);
+
+        assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_pow_mod_01() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.pow(3);
+
+        assert_eq!(
+            result.to_c_array(),
+            vec![
+                "AkkAAAAAAAAAAAAAAAAAAA==",
+                "DDAAAAAAAAAAAAAAAAAAAA==",
+                "LQIIAAAAAAAAAAAAAAAAAA==",
+                "8AAAAAAAAAAAAAAAAAAAAA==",
+                "ACgCQAAAAAAAAAAAAAAAAA==",
+                "AAAMAAAAAAAAAAAAAAAAAA==",
+                "AAAAAgAAAAAAAAAAAAAAAA=="
+            ]
+        );
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_pow_mod_with_zero() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.pow(0);
+
+        assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_poly_div_01() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        //eprintln!("{:?}", element1);
+
+        println!("Beginning the new division");
+        let (result, remainder) = element1.div(&element2);
+
+        assert_eq!(
+            result.to_c_array(),
+            vec!["nAIAgCAIAgCAIAgCAIAgCg==", "m85znOc5znOc5znOc5znOQ=="]
+        );
+        assert_eq!(remainder.to_c_array(), vec!["lQNA0DQNA0DQNA0DQNA0Dg=="]);
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_poly_div_larger_div() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        //eprintln!("{:?}", element1);
+
+        println!("Beginning the new division");
+        let (result, remainder) = element2.div(&element1);
+
+        assert_eq!(result.to_c_array(), vec!["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        assert_eq!(
+            remainder.to_c_array(),
+            vec!["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]
+        );
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_poly_div_eqdeg() {
+        let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "wAAAAAAAAAAAAAAAAAAAAA==",]);
+        let json2 = json!(["0AAAAAAAAAAAAAAAAAAAAA==", "IQAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let (result, remainder) = element2.div(&element1);
+
+        eprintln!("{:02X?}", (&result, &remainder));
+
+        assert!(!result.is_zero());
+        assert!(!remainder.is_zero());
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_poly_div_eqdeg_02() {
+        let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "wAAAAAAAAAAAAAAAAAAAAA==",]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let element2: Polynomial = Polynomial::from_c_array(&json2);
+
+        let (result, remainder) = element2.div(&element1);
+
+        eprintln!("{:02X?}", (&result, &remainder));
+
+        assert!(!result.is_zero());
+        assert!(!remainder.is_zero());
+        //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA==");
+    }
+
+    #[test]
+    fn test_field_poly_powmod_01() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let modulus: Polynomial = Polynomial::from_c_array(&json2);
+
+        let result = element1.pow_mod(1000, modulus);
+
+        eprintln!("Result is: {:02X?}", result);
+        assert_eq!(result.to_c_array(), vec!["oNXl5P8xq2WpUTP92u25zg=="]);
+    }
+
+    #[test]
+    fn test_field_poly_powmod_k1() {
+        let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let modulus: Polynomial = Polynomial::from_c_array(&json2);
+
+        let result = element1.pow_mod(1, modulus);
+
+        eprintln!("Result is: {:02X?}", result);
+        assert_eq!(result.to_c_array(), vec!["JAAAAAAAAAAAAAAAAAAAAA=="]);
+    }
+
+    #[test]
+    fn test_field_poly_powmod_k0_special() {
+        let json1 = json!(["NeverGonnaGiveYouUpAAA=="]);
+        let json2 = json!(["NeverGonnaGiveYouUpAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let modulus: Polynomial = Polynomial::from_c_array(&json2);
+
+        let result = element1.pow_mod(0, modulus);
+
+        eprintln!("Result is: {:02X?}", result);
+
+        assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
+    }
+
+    #[test]
+    fn test_field_poly_powmod_k0() {
+        let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let modulus: Polynomial = Polynomial::from_c_array(&json2);
+
+        let result = element1.pow_mod(0, modulus);
+
+        eprintln!("Result is: {:02X?}", result);
+        assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]);
+    }
+
+    #[test]
+    fn test_field_pow_mod_10mill() {
+        let json1 = json!([
+            "JAAAAAAAAAAAAAAAAAAAAA==",
+            "wAAAAAAAAAAAAAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let json2 = json!(["KryptoanalyseAAAAAAAAA==", "DHBWMannheimAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        let modulus: Polynomial = Polynomial::from_c_array(&json2);
+
+        let result = element1.pow_mod(10000000, modulus);
+
+        assert!(!result.is_zero())
+    }
+
+    #[test]
+    fn test_poly_monic() {
+        let json1 = json!([
+            "NeverGonnaGiveYouUpAAA==",
+            "NeverGonnaLetYouDownAA==",
+            "NeverGonnaRunAroundAAA==",
+            "AndDesertYouAAAAAAAAAA=="
+        ]);
+        let expected = json!([
+            "edY47onJ4MtCENDTHG/sZw==",
+            "oaXjCKnceBIxSavZ9eFT8w==",
+            "1Ial5rAJGOucIdUe3zh5bw==",
+            "gAAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.monic();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_monic_poly_zero() {
+        let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.monic();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_monic_poly_multiple_zero() {
+        let json1 = json!([
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.monic();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_poly_sqrt() {
+        let json1 = json!([
+            "5TxUxLHO1lHE/rSFquKIAg==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "0DEUJYdHlmd4X7nzzIdcCA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "PKUa1+JHTxHE8y3LbuKIIA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "Ds96KiAKKoigKoiKiiKAiA=="
+        ]);
+        let expected = json!([
+            "NeverGonnaGiveYouUpAAA==",
+            "NeverGonnaLetYouDownAA==",
+            "NeverGonnaRunAroundAAA==",
+            "AndDesertYouAAAAAAAAAA=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        eprintln!("Starting poly sqrt");
+
+        let result = element1.sqrt();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_diff() {
+        let json1 = json!([
+            "IJustWannaTellYouAAAAA==",
+            "HowImFeelingAAAAAAAAAA==",
+            "GottaMakeYouAAAAAAAAAA==",
+            "UnderstaaaaaaaaaaaaanQ=="
+        ]);
+        let expected = json!([
+            "HowImFeelingAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "UnderstaaaaaaaaaaaaanQ=="
+        ]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        eprintln!("Starting poly sqrt");
+
+        let result = element1.diff();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_diff_len1() {
+        let json1 = json!(["IJustWannaTellYouAAAAA==",]);
+        let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA==",]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+        eprintln!("Starting poly sqrt");
+
+        let result = element1.diff();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_diff_multi_zero() {
+        let json1 = json!([
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+            "AAAAAAAAAAAAAAAAAAAAAA==",
+        ]);
+        let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA==",]);
+        let element1: Polynomial = Polynomial::from_c_array(&json1);
+
+        let result = element1.diff();
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_gcd() {
+        let a = json!([
+            "DNWpXnnY24XecPa7a8vrEA==",
+            "I8uYpCbsiPaVvUznuv1IcA==",
+            "wsbiU432ARWuO93He3vbvA==",
+            "zp0g3o8iNz7Y+8oUxw1vJw==",
+            "J0GekE3uendpN6WUAuJ4AA==",
+            "wACd0e6u1ii4AAAAAAAAAA==",
+            "ACAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let b = json!([
+            "I20VjJmlSnRSe88gaDiLRQ==",
+            "0Cw5HxJm/pfybJoQDf7/4w==",
+            "8ByrMMf+vVj5r3YXUNCJ1g==",
+            "rEU/f2UZRXqmZ6V7EPKfBA==",
+            "LfdALhvCrdhhGZWl9l9DSg==",
+            "KSUKhN0n6/DZmHPozd1prw==",
+            "DQrRkuA9Zx279wAAAAAAAA==",
+            "AhCEAAAAAAAAAAAAAAAAAA=="
+        ]);
+        let expected = json!([
+            "NeverGonnaMakeYouCryAA==",
+            "NeverGonnaSayGoodbyeAA==",
+            "NeverGonnaTellALieAAAA==",
+            "AndHurtYouAAAAAAAAAAAA==",
+            "gAAAAAAAAAAAAAAAAAAAAA=="
+        ]);
+
+        let a: Polynomial = Polynomial::from_c_array(&a);
+        let b: Polynomial = Polynomial::from_c_array(&b);
+
+        let result = gcd(&a.monic(), &b.monic());
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_gcd_zero() {
+        let a = json!(["AAAAAAAAAAAAAAAAAAAAAA==",]);
+        let b = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+        let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]);
+
+        let a: Polynomial = Polynomial::from_c_array(&a);
+        let b: Polynomial = Polynomial::from_c_array(&b);
+
+        let result = gcd(&a.monic(), &b.monic());
+
+        assert_eq!(json!(result.to_c_array()), expected);
+    }
+
+    #[test]
+    fn test_poly_gcd_stress() {
+        eprintln!("{:?}", Polynomial::one());
+
+        let poly1 = Polynomial::rand(&(500 as usize));
+        let poly2 = Polynomial::rand(&(500 as usize));
+
+        let result = gcd(&poly1.monic(), &poly2.monic());
+
+        eprintln!("{:02X?}", result.to_c_array());
+        assert!(true);
+    }
 }
diff --git a/src/utils/sff.rs b/src/utils/sff.rs
new file mode 100644
index 0000000..de2bef6
--- /dev/null
+++ b/src/utils/sff.rs
@@ -0,0 +1,92 @@
+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)
+    }
+}
diff --git a/test_json/padding_long.json b/test_json/padding_long.json
new file mode 100644
index 0000000..3b37422
--- /dev/null
+++ b/test_json/padding_long.json
@@ -0,0 +1,1203 @@
+{
+  "testcases": {
+  "2397d270-6a7d-48e8-8a7b-e464bcb00063": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "vm7Urlq3BHFPy34hxIn9yJJ4xKnmJYnkD02uUgznoIw8K+2HxtJLItkOcdXbIk2ADNXgjc3aQiTeCnTX2CJMng=="
+      }
+    }
+  
+,
+  "44c19d5d-2149-400d-ab96-0764c440acac": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "SlelDIsQJ+qLVsVJaAQpyo/kaNAZ54eJrXOYaYqFuvf8SrED9lst6Iv/CdW0ydh76fy8Cf1TJO6M+wzXt8nZZQ=="
+      }
+    }
+  
+,
+  "4a3ecbcb-a8ed-4c46-b63b-09f8fae33371": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "uWkaarF8CoHqIqWtNv5FkIebZ/e4v6QVvH09z2Ew8XehLpc6BgiAB5r3KXtJMuwdJjuaMA0AiQGd8yx5SjLtAw=="
+      }
+    }
+  
+,
+  "ed63e4c3-db96-4d3e-b2b8-91fb78dc970f": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "y1wFLXHmhe2rHDgpeAISDU4kv6cJf77367yods6RxUT/bUuOr5N3u+APaRvZE5PRZrZGhKSbfr3nC2wZ2hOSzw=="
+      }
+    }
+  
+,
+  "5a9de26e-5ad3-42e8-9523-cb5ad069a1db": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "xBVHDKq5LsWkoTaEti6ltXLiBvZAN/LvHWv1N/mFBH8TGZyt84nYHHw0r0cyCrAEC4WRp/iB0Rp7MKpFMQqxGg=="
+      }
+    }
+  
+,
+  "e2fcaa72-d396-4ba9-885d-8c8449e48645": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "F8rc8G3tvt1lUfB664zqmawpXoxzM08hgpyjQnbE7MwW7M3noC9s8ez65PW3s6uYKbDA7asnZffr/uH3tLOqhg=="
+      }
+    }
+  
+,
+  "541dc95b-080c-47a1-8c6f-86063c960ac4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "0aDij+0vWLj+PfQJhqiLSBynGHhk+IvXw3mfT2YHQsCaRegAHHuWFT16VrHIncQtORnlChdznxM6flOzy53FMw=="
+      }
+    }
+  
+,
+  "0314b333-aaed-4c48-9418-411233140585": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "HFeCxKmP42XhzuY8w0sMamhazEymf3b7EDzP0iskU4FKBKZAzc8tF5fv8YWWqiIZrxqrSsbHJBGQ6/SHlaojBw=="
+      }
+    }
+  
+,
+  "b20e9178-af52-4112-8183-50c0112d0275": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Z15CHkQ1iOkOwdZ/+TvmAMSS3UITjxaJ5N230T0bKql58C0KLiPqx3TlcKoC281Y6bUgACUr48Fz4XWoAdvMRg=="
+      }
+    }
+  
+,
+  "7ee6d7e7-d4fa-4398-a615-6801555c6406": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "w516YKGlRGANdg+30RBCyGKPnGmv7o/uv567VzbBsNz76Dcv1TZxGlq8rcH9vek5W486Jd4+eBxduKjD/r3oJw=="
+      }
+    }
+  
+,
+  "f590c5e7-52b8-4c5b-916e-ee0d3cd4a867": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "bB5OrSvRcitV8Q6k5IYhxZGHwK7tL6n4pO8mO9qY+lEn8PWUKjN29bVJhqlp6r4nnfr4niE7f/OyTYOrauq/OQ=="
+      }
+    }
+  
+,
+  "382599d8-e079-4dea-a0e2-84349b0836a2": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Vet2VvnayHeF5OF+FrBBMRZz5FXg+ziTPAWcW4ICYrEl8E8dlGN8Cj7UyUMTgMsXs8FCF59rdQw50MxBEIDKCQ=="
+      }
+    }
+  
+,
+  "c9581cf4-b380-4f19-820b-924a108fdfab": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "/N7OSIyd0rJe+WI2BIgn/C+X9EZ+iGAfgE0CHepbkFSjyf49Dxd4JUMkcj26ggucl+3zNwQfcSNEIHc/uYIKgg=="
+      }
+    }
+  
+,
+  "eecd178c-5d86-47c4-830e-1bf5aed430f9": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "ZQj80wGTXZiBwtoMbC3eRK0awvIdRhcUEzln9qEoWKilGytMXS9a6NlOA6IOxDG4IaQmRlYnU+7eSgagDcQwpg=="
+      }
+    }
+  
+,
+  "4c1501ab-7cae-4567-a576-c359c1e7695e": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "AaG6i5IwVVr9ycYDaTYIw8AcBYEZkSIaqQE7ttR4hqlSfp8Wr1zKV+q965Za3r3o0HGSHKRUw1Htue6UWd689g=="
+      }
+    }
+  
+,
+  "807bdda6-26ef-4e97-b6e9-bf27539187fe": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "fbPGRKxBPpXkqWfQltwOhpXqoWxz3La9rlyf8M3ppfg45jwlWydWlXGHfuXHfq7Rr10xL1AvX5N2g3vnxH6vzw=="
+      }
+    }
+  
+,
+  "829d1b66-700c-458d-8116-b76890e97537": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "r8KymEWRwDRyOj0GB5Pt3swuAJ+Cdi7+DxGSY62R6qOCcg2OnGDEkmvDHTlrSv6qeDoAhJdozZRsxxg7aEr/tA=="
+      }
+    }
+  
+,
+  "caa6a14d-6fe3-427d-a445-c6b15cf8b25c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "ZTq4Us+pnWzcBFfsNTncXNVR8iVoV2epE1xeP15cJEQDW0erZpZSTJdafN8LnLVc15ZKoW2eW0qQXnndCJy0Qg=="
+      }
+    }
+  
+,
+  "df9ae9f0-51ab-4613-b3c2-56e6f2de74b6": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "D5X0/aOPzv/YnaevH3A0zrrt/MPG68P9+o16Vs9R+Yr0dKbVdx0oCZraoQe9u5iSLvKr33wVIQ+d3qQFvruZjA=="
+      }
+    }
+  
+,
+  "c591b3d2-05b5-4792-a502-da4641461533": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "y2IUs+cKPmUpeY9hdDDSTGatuvZVthvWqmdC5/unBWr5OKFFXuI+9BIv9pRIctmY5iusT1XqN/IVK/OWS3LYhg=="
+      }
+    }
+  
+,
+  "3f5c5abc-81e6-4540-873a-ea5498df297c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "yDfhetbRPSBFlGvLotAsnD4E4knnUcppjw/gREIy9YHeNOmqoRu3LDsQbRUw6tQHm6XkoKoTvio8FGgXM+rVGQ=="
+      }
+    }
+  
+,
+  "5b6c1490-a77d-4a2a-9976-9d4635cf195c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "NabDKqpsyhbP+wPVnpDYakbwpyn/z/rJWra2XDUBHRRCkreZR2nODjwKQY47X3i7or66k0xhxwg7DkSMOF95pQ=="
+      }
+    }
+  
+,
+  "852c775a-0bff-42e4-87f4-3991b58eb1dd": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "RCm+XJz0gMd0OCVhrvACw+lpNkiOJEiT0EbZt/cMgToNjqsRM95ncabJZnqKmqiuzOamGzjWbnehzWN4iZqpsA=="
+      }
+    }
+  
+,
+  "a5a86d99-4bfc-42b4-9d8a-07f1a6f6cbba": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "UZRcMpvxPxszgcIYtp9vGbL/f9EQ0AVRaHw5WF3C8EEjo7J68BHKNeoKVA16F/FduyG/cPsZwzPtDlEPeRfwQw=="
+      }
+    }
+  
+,
+  "cb260f8a-508f-428b-a135-00d8b0348832": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "ICiC/LcF4LhQSKrAi7w/HzTef5YyDwE6sjNe+XZeoH/OkclPUsj3mo/xoJuGOSfzBUDERVnA/pyI9aWZhTkm7Q=="
+      }
+    }
+  
+,
+  "e8aa9530-60ae-4c5a-9e0b-93dbfd0d6660": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "5kE3TUL4Lq2jKNgNlVYxqKZ1nM5x2yCx09yrNs9f8fWjBzdEENHczF5uHZ3uKIfoxgU6ThvZ1cpZahif7SiG9g=="
+      }
+    }
+  
+,
+  "7c5067be-0e0e-4b07-bac6-ffdd8652db55": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "6piHQ3VtWEvfOa/zf4VWJS6PH+QWlb7+aZDwyJlcfDIDalbg9+G9WT9YJhcrYix9XV9b6vzptF84XCMVKGItYw=="
+      }
+    }
+  
+,
+  "6ffc6d43-0346-4a7c-a525-c93842ff2074": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "UzXj9SuFBZTpiEEqzw/DVgv1sLzN5ncacQbfK5DbUg91sKz12uzQoBvUTeXIG2qOTbmh/9Hk2aYc0EjnyxtrkA=="
+      }
+    }
+  
+,
+  "b7567d39-e6a8-4259-a292-8e6790df08b1": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "lNc3wjie7beF0ZLOfhzX6Tzosr+02y9idqgrv48u3Yyd0okKnK7AmLQEHAiQe0qGK5WEAJemyZ6zABkKk3tLmA=="
+      }
+    }
+  
+,
+  "c34d7d89-a620-432b-aa98-8f1074c826ba": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Cg0XaEGegQNznReu8KeQ+NDEArv5nZbYfui2Nny8omXeHofazD2jgDnq0ui8uov9V56K0Mc1qoY+7tfqv7qK4w=="
+      }
+    }
+  
+,
+  "6b823c15-919b-4525-95b6-a64eff1a671b": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "1u2ethWeOGIavEEWsbgSqkUth+0cmPFgN4pYvT67oyxvWk1vGEv28vvDjy1OmPMIB95AZRND//T8x4ovTZjyFg=="
+      }
+    }
+  
+,
+  "72145942-656a-40ff-b981-79b0224ae80b": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "qIv/gRp4qoNhw6d2pZK2NhI3+rXboQ7CUQ7vmFsL8AA67qvcb1OrOxj1Z63cEvmBAfSm1mRboj0f8WKv3xL4nw=="
+      }
+    }
+  
+,
+  "8ade9aa1-7cea-4d1f-ae32-dfa72c3fa322": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Hn97+gE6oeY1h4W7xN/olVE7koHA/PILlbJk8Vh56c9V/SSSZVRneIUmrl1Z/82JUfQpmG5cbn6CIqtfWv/Mlw=="
+      }
+    }
+  
+,
+  "7e894b2e-d5a0-4590-bc3d-e93672dd9261": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "ttx3yJh+GDifmTwxjCqcv8zUZoi4ExKzogq2ilOTK3ab1agUmk/pRxrMKH1s0Nya0IGlHpFH4EEdyC1/b9DdhA=="
+      }
+    }
+  
+,
+  "d1ce21a1-6295-4729-a9f0-e39cc4aa4f40": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "BqB4yVG2NY2fmvaAGYc6otIgW32JKOaHv86vD8Zz+MNZPz0sR7PR+qsD15vKkE6SxGIwJky72PysB9KZyZBPjA=="
+      }
+    }
+  
+,
+  "f4d6f056-650c-4b6f-ae51-6f44918968c2": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Ga9utTnt8SCSBV4l2sDJ6n0SLkx6ajuFI5MZU/V4LGl4QYMCuOIeYxPqpLsYaBl+1LqOCLPqF2UU7qG5G2gYYA=="
+      }
+    }
+  
+,
+  "55dc70a5-e5b4-4ada-bab0-0e0f51cdd6e0": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "g+E+xh8lT3kNEC5nC3wEmgaV47JEa0cxVj2XzTLZimbNNhmWAT9Enhe5T5463QOvHqYUnAo3TZgQvUqcOd0CsQ=="
+      }
+    }
+  
+,
+  "db3533ad-300b-4067-a394-4b4506d7e740": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "cMbGvtBs3pEcfs2wmgTfEGwzpuvN+03DVCUXRnuhjXdUhoPSqu/+6nF+7W42f7C/jzCO2KHn9+x2euhsNX+xoQ=="
+      }
+    }
+  
+,
+  "7ba96858-7e5d-4d76-9151-4c24a89f141a": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "S12Mc1V7Q7hPAWPk3JKrOPPWwoJNrhvVQDhQLFMPDUxtrduMRXbAosYcp9zbHK/Zp6zWhk5+yaTBGKLe2Byuxw=="
+      }
+    }
+  
+,
+  "45650223-8b12-43ec-8ba4-5739d7f8e1b7": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "bq0ehniEAiH6yNKeyvCNGmwl6ifyJiWm/Jh3+pgSqJ+oiJ2+GASK20JCQWuOAVXeNSGQtBMMg91FRkRpjQFUwA=="
+      }
+    }
+  
+,
+  "25535889-3ce4-4315-a60c-d17cade233b6": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "G1JIQcHRZeL5vhZOEHk3R+lnnfJKtmW0ehGKo7NNaf3p+muo6B4NSR1ev2z+3BapaUZmouMWBE8aWrpu/dwXtw=="
+      }
+    }
+  
+,
+  "6e48220f-0dbb-4a70-88d5-3843d92beb22": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "03u4zIxW/dc3n+TPZ46nohJwrGUnEr8Kw4pqfc7ewJKmBrMk/AGP35zI7JT96wQZ25e+LvcJhtmbzOmW/usFBw=="
+      }
+    }
+  
+,
+  "c064be77-b978-45e1-8872-12d810f51c7c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "CUlnUH1Oykz+tVfAx08vx4n1KTfkGix9J7EcHO/UQ/wtRs/qdhLCgGM3QL86K0vAemvC4H0ay4ZkM0W9OStK3g=="
+      }
+    }
+  
+,
+  "daa98c74-3bb6-482b-8515-35130b328a37": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "CujN9/8yzR8n7JjQ6lcWa5FbAjSqYPwnd1htDi7nstjGVQJMD5tSlz8t6FbH73b/WzoPRgSTW5E4Ke1UxO934Q=="
+      }
+    }
+  
+,
+  "faf4fdad-f71e-45e1-8cd9-35ab5c83a94e": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "koNoZ0F+7UP8XGmmGvzqsMxEibKLRKer8j0/HP6N3HaOJ4N7eeyn6sRCNuBC8Q9HCriOcXLkruzDRjPiQfEOWQ=="
+      }
+    }
+  
+,
+  "539aed2a-be20-4837-9571-bf72cbbce7c1": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "P5BRSYQQwC+e3Wr6a0iZmCDOWrwD0Oqbl2nd3CpjCkjQ6rKAPSuusYc8yGVnCQHeo6a/ijYjp7eAOM1nZAkAwA=="
+      }
+    }
+  
+,
+  "5b97b7c1-2ea6-4324-8208-fc8b60421a71": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "GThxMuyHpeSFMuO2E9x6ZLJxY3bqqbSjEFPONgHRbcNIC9qbORFkJhJdzL5SbW7nPLbXkTIZbSAVWcm8UW1v+Q=="
+      }
+    }
+  
+,
+  "a457cfe1-4972-48c1-9ffd-f6cd58259cb4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "RWZSt4GByw8blm0TPnNJQWx8Z5M7jahfmCuSrXcNdFu+t4kcyeuUSTNGpQsZIQy4iX2EFsLjnU80QqAJGiENpg=="
+      }
+    }
+  
+,
+  "fde675ab-8ceb-461d-b917-752ad5e10683": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "UYnLQHhdhWXjImgi9vj6EECVlol0EFzLojOdD5P0zml4llbHYtxaS2EntJwb31SUsQtbzWnUU01mI7GeGN9Vig=="
+      }
+    }
+  
+,
+  "13f792e3-5f90-4f1a-9f2c-d9ad7546e965": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "iUaOYIKxDD3m1gnBcDqxENggOM8Ct0GZbxgzCcr8+d4SZGsTNTBegtltYyLNIveNqEpmGT44V4TeaWYgziL2kw=="
+      }
+    }
+  
+,
+  "1363c336-61c3-44f2-b034-a7df4f51cac0": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "+8NreDMpSmce1BS0CwlWTe6Fbvh2wGhl7pY5YjfPQ3Y1cCjYYdLGKeadiQMs2UhUzpcl0mrazy/hmYwBL9lJSg=="
+      }
+    }
+  
+,
+  "dacfb5cd-794e-447a-a73f-5727a4be381b": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "aHZaILzJqHrpeagmBOELoHIk4WkMx3Tt+vQ3IQcG48H7Y2GH24+YL6Hnm+24w7nkt8tsjdCHkSmm457vu8O4+g=="
+      }
+    }
+  
+,
+  "8f57a6b7-ae39-4701-82c9-b6b93797e501": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "6sLGtM2rLi1YBtcoHVAhirDLpbl50CNCCKRmxsxLVxJS78+dGozdAsF7zt74sWEJ2ILClxGE1ATGf8vc+7FgFw=="
+      }
+    }
+  
+,
+  "ed4852b2-ae49-471b-aa43-5ca40520f5fb": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "p77RUg7oMOEAmQmWetO3INtX9T4UJCeqNmdILmufV6pCqTmQ7V6oIijdSRrelvw7viU0muZWoSQv2UwY3Zb9JQ=="
+      }
+    }
+  
+,
+  "384ac609-7112-4c25-a1e9-8f470b2998c9": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "VrDXpBoOuWJ2zoJlcmBmj3E1CXm3bOj3Xw6yMZymH0JocA0RqBmHtHaei5tNJlwdYmsAG6MRjrJxmo6ZTiZdAw=="
+      }
+    }
+  
+,
+  "22542b77-5761-427f-b0c0-e04feec5f1b4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "1iA+cp1BATVWLvJQC8WbYowiGLpvQnmkiNVHy+j+fbid2fwlplsq1Xz3aIB8kLWCdPPxL61TI9N7822Cf5C0nA=="
+      }
+    }
+  
+,
+  "fd978de7-ad93-4f4c-b0fc-53a0cd82aa6c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "f5M4Cljp9wYiFtLeeY0xullO97md6wc25/IeM//u4luv+xRfwV8uOlTesdGEMsG2KaoZVcpXJzxT2rTThzLAqA=="
+      }
+    }
+  
+,
+  "2cb54cb5-4c3b-49f8-9fd8-5612e062a794": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "h7MAdEyFyMeQkeaST+JzXT9LLoMr1oN0sSbHh99bHv47amSZ0wnob1drT3DRMWcV0X9pk9gB4WlQb0py0jFmCw=="
+      }
+    }
+  
+,
+  "6fa0219c-5b86-44a3-8906-d23b947a2bc4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "bYC+gQ/FQgTshymtgqKI18BdFGqHddn1kGktLkYnL+Y9aLzwk1X9c45tEiuUdRfkkYqx+phd9HWJaRcpl3UW+g=="
+      }
+    }
+  
+,
+  "413f61b6-4830-4537-aa37-4d7a9217e83e": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "o/ttuaXRBEYcrqRvrO4Rx5iX076H7spBRJGLbYn8o/aUEAAdIPF1V0HPtAooYAfTb2UNFyv5fFFGy7EIK2AGzQ=="
+      }
+    }
+  
+,
+  "c23d0451-e97e-4cb1-89bd-1d0f8c161b84": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "h8Kwck8yxXgGHIRiQpfMeHqaEBEgaZAx8+sEYA2XU4Fe0Ustok2D/8FqtfN6UC86uMVGJ6lFivnGbrDxeVAuJA=="
+      }
+    }
+  
+,
+  "14db3036-ad5b-43b1-b0cd-63c7d275c901": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "n3f2r/oc/F5cRt/KtLRs5oRi92ixYVyq1q4c90K0Eg+jJnb2x4i4JcjAhQxhKtsq5TZ7/MyAsSPPxIAOYiraNA=="
+      }
+    }
+  
+,
+  "495b74a6-84d7-4704-9f2d-d4d02e3b2deb": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "VUDL46a2gYXIzruEzCwoILc8eA4rx0oGDB0rEyR0vj504Pj5RD0RYA474ZH+/lwAkhj18081GGYJP+ST/f5dHg=="
+      }
+    }
+  
+,
+  "09111522-0191-49c1-baee-9e7452ade6d6": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "R7x6DtdfjxMKn7umK1YP6Ih1tmRfXG7Ea7r9/897ELESJQzZTbVgRxHtDIBif3StsvMB00a9aUEW6QmCYX91sw=="
+      }
+    }
+  
+,
+  "04e31e23-bf5b-488d-98ea-0916ea054a57": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "vTpRyVKVxIlBH+SVp/+dGaLnicvNd3OnlzEbYoPv1Y++pZCSjStzPHeAOmOexYut5IidmIYjejpwhD9hncWKsw=="
+      }
+    }
+  
+,
+  "db4e4f3e-af56-4e80-915e-2833e1720152": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "qNJ6UWDZtHbuLU8XJ63XoZx0732T6dXl27+uRiEaUCbKKfW28dBao9fWUxxgNNInpzz4vPrYU6XQ0lYeYzTTOQ=="
+      }
+    }
+  
+,
+  "4c27df40-e586-4454-96fd-bbd38d9c254d": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "3R9meuHw44Q4I7gPKLb9yj/KiixEw50lPXL0Ccad28idMKbspSBcP9msU5G6NW1B7Zir5q4oVTneqFaTuTVsXw=="
+      }
+    }
+  
+,
+  "4bc30fc8-6515-4da4-b9ec-d3659e26977e": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "5cN2IR5Ml/JXaD6GXjdOhWaZj86JypxJgD2Dx82DOd0NfGmgS8tdplA+iOk2qvIVWjRkqkDDVKBXOo3rNarzCw=="
+      }
+    }
+  
+,
+  "30857906-6323-484f-a42e-2a9383a878a5": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "0DQEb9ILeloWef9d4Blr6fmxTBwrW6jkDfBXsrCAHV02UEkMuGFKlq9v6aMZK9EFR11EBrNpQ5Coa+yhGivQGw=="
+      }
+    }
+  
+,
+  "a483d63f-115b-4e15-a8a4-9d6f69c30534": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "HyGdkwKolhIEXPXWdjJ8mWUL1Rlwuvfx8DJss5NM2cNqWLDOF+e0pU5iBF9NgoRGWom9xBzvvaNJZgFdToKFWA=="
+      }
+    }
+  
+,
+  "9c7f225f-0fa8-45aa-8fba-995cc0880827": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "vqwFkwWUqcrca9kLD4GfMQ8Kdi1E3FV5Ar2p9+XrN9FE7R/UUjtcyOFVKDZJrZHa6+wS3lkzVc7mUS00Sq2QxA=="
+      }
+    }
+  
+,
+  "3c531189-5fa2-46fd-a913-c5da0bd26e5b": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "XUNMJYgLjnoUh+RaP7fFjslFehaIteonz5eMQFXeU0BQ48MWYAlOsN1q/0QpxdsNrbnOHGsBR7babvpGKsXaEw=="
+      }
+    }
+  
+,
+  "8fcf110e-7b2f-4bef-bdca-cb3e4e852309": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "gQHsqB57y8oIWZvnO1IXhtV70YGLTgihQ/l338iqqw0eO+oRuOBupNwr9ePqdy+lxFTnG7PoZ6LbL/Dh6Xcuuw=="
+      }
+    }
+  
+,
+  "8369fe41-f1c8-45ac-9823-2eb4d6644e0b": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "KF/IEz9b9JC0H7WmymmXZ6qADb0+wmFvZsB87y4rwqMvmnkcvTJhjgm0WVeFJDJk3gV0FrY6aIgOsFxVhiQzeg=="
+      }
+    }
+  
+,
+  "aac997d9-c874-41ff-b9cb-70c3c966b1d4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Tq2DLoykYhAPmjf8Y+G8ADsFvtanTCJHq9bV0iKDM86RwdEvT3m3MYoxQwi6Zm8/CJTcJURxvjeNNUYKuWZuIQ=="
+      }
+    }
+  
+,
+  "571a4cec-707c-49ec-96ad-d1035d212087": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "cd6JdgsmhX4QyBWhRmEFbvnfDLwuoCmgtwTDHtsGVEAnt5Yj/w1pszvu05Djlp33BwebKfQFYLU86taS4Jac6Q=="
+      }
+    }
+  
+,
+  "af25e252-7418-4fa1-a9f4-acde2d55c989": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "yHYApE1BDfVL6EgbDLjXK1mA+godz5Ho1eeCLEGpocxGdlWluJGilib6X8tTL3teKA5Yr7OZq5Ah/lrJUC96QA=="
+      }
+    }
+  
+,
+  "4cb90117-6313-4deb-9ac5-19f81f0fa0d7": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "hYVhDlhDSfGOZrdm/cfQs5+pwgsX6KVssfh3sIHXL59i8PoGk/fxIwyJd8/TL5Gymh73DJj/+CULjXLN0C+QrA=="
+      }
+    }
+  
+,
+  "4a7da8a2-3ed9-4c69-bbc0-84c12d8dda26": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "uOBBTKX9bc9P729W0L6FnlD9JN4gDCPAP5xVN9TrvjJCo+u7J5lNo87BJIxiRxI+vazmsSyRRKXJxSGOYUcTIA=="
+      }
+    }
+  
+,
+  "dc4e9268-1faf-4e59-9bd0-632f98fc54b1": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "/ryLcAF/i4K0Q908nNTVn5ORHINBk3BVcAWfZY04WD0C8X8DpeO0tiUWTzq6zfHCC39yCa7rvbAiEko4uc3w3A=="
+      }
+    }
+  
+,
+  "02b0b683-f7c8-47c6-9d4c-b368ad41c6ac": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "Dh5oC6q/jnBkFSi/pqoD7v+zOm/QZVLGtBkkaBe2yf4FQ+F68esNu4FxJhDK8gjqpnfscPrjBL2GdSMSyfIJ9A=="
+      }
+    }
+  
+,
+  "4acf39d6-d489-45c7-bfcd-6d2e15a634dd": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "c1BvpQp0fAz4FFC7NCEja9iP4oDJb5ihj8ZfG8NZkMNpMfs1cX/6jKv8fRi6ua2SlRX2P3p384qs+HgaubmsjA=="
+      }
+    }
+  
+,
+  "99ed3f0a-2e2f-4779-8afa-cd85b9c4fd0e": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "aTlxJX03/IMHzxK4ox6l7Vx9Y8sFYb63JC0JulVWxaePM/1+zGz47sIBI4gjLz7+qgvwdMdk8ejFBSaKIC8/4A=="
+      }
+    }
+  
+,
+  "073e7165-34c5-4378-b782-571f8f1a68e3": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "vpRYbgOlxfsXgI5E14rtbHOGmA1am/gNNPuJcEI7qHXyeVegrfZeRXKDpPVbZfZEFJpaqqb+V0N1h6H3WGX3Wg=="
+      }
+    }
+  
+,
+  "de43e72c-2c95-43e6-8c2e-357ca7538390": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "bUqEnu51k6UorPZh3coyIpFotnyqQ0NMVJblugfhUYXOsKexkxTkohMDywuHVusDjsiqu5gc7aQUB84JhFbqHQ=="
+      }
+    }
+  
+,
+  "a0d4e7f3-eb77-4a0d-9a20-b2415038b0c7": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "aTDl1UOaGhyfAM/oMIUXOlEsZdQ91ByWbNMZ7DMbx1poVBMWBmkRdAEC8W6W6UkvtY4eHA1hGHIGBvRslelIMQ=="
+      }
+    }
+  
+,
+  "691e973a-3598-45f4-93b1-74348a423bd4": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "dsBQl0VypyGciDcGbFZEsSO9xWarGMwHTlXk+0qgWYQ61Jo931Dy3aLUAWjhq8BUtYOXN9RY+9ul0ARq4qvBSg=="
+      }
+    }
+  
+,
+  "5cbb74c3-b71e-4482-9324-d3ec31944ae1": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "cnWbIbq2LFSyEuVA7CvtaNdEvOGbJtyuArna4Co+d0mSsAWfKPhOk+yEFLsa4bbdSjUIlSPwR5XrgBG5GeG3ww=="
+      }
+    }
+  
+,
+  "5ba9b9a7-b347-4942-8c77-0697328cb6a0": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "q1Aqo8bOgalL5OUeLMOlUFBm1XO9wr+V9uBSS4XZ2aY6SBt3kS1diUGjewx5zYOjqhIWfZolVI9Gp34Oes2CvQ=="
+      }
+    }
+  
+,
+  "6c42e851-cb6f-4c1d-8c17-9bdc8e0e6de7": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "UTmqk0zLVPAXxObZ3mtdE8c0bmys8uC/F9tbOCec474T3Yo2WbWrVBakp4awM3F+Vv+HPFK9olIRoKKEszNwYA=="
+      }
+    }
+  
+,
+  "5c18d55f-a0fd-46a5-a1ac-93a810646e32": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "v8ADatzqlIjOhap07uLTuntszynDas18n19UEI4GyDTqdjjkgJNlvjKuk98yqHIyQtA17oubbLg1qpbdMahzLA=="
+      }
+    }
+  
+,
+  "6b1b291e-8def-4c0f-83e0-6291d4ab240c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "G/CjHOiAwXTQ3xcS6Db/X7Xqw84UGA26YEcmGfRCWUVcBXe9hwi7ppwcOQeVBlcOJNJ6t4wAsqCbGDwFlgZWEA=="
+      }
+    }
+  
+,
+  "364012fc-464f-438e-ba9f-e63c203887f6": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "uqMG21goTh4x+ZDjcPOKwkbiTUIGSNtLLr9Gr36jFCwS7wwRJGoYNYBg2VNCyyDHEDkBGy9iETOHZNxRQcsh2Q=="
+      }
+    }
+  
+,
+  "f0656f9e-f46a-4839-a370-f62229cfb725": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "cIM41ydOUh6wTFj8wuCFP21NbrtApWsrbpnZYIcLF0jpzkC6/TruFNsPGawOavVvqYZNsPYy5xLcCxyuDWr0cQ=="
+      }
+    }
+  
+,
+  "0c465f36-3609-49ed-97a0-f3f466074014": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "+4M26CAsDZSQGPgauO26O9hRmL8swl4YNW6kqfifk6bHsAb3ti8NpIduNp0ql9FWFBwL/b0nBKKAajOfKZfQSA=="
+      }
+    }
+  
+,
+  "f487be27-8e21-4c99-a0e8-24ccbf91df0c": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "r1Vg5MBZTWUlTSmBZbsZiNxnDA9p9ikQs1ZOeW/JsLetmmVTYjaxcvMU+GPUTnS6k8xoWWk+uHT0EP1h1051pA=="
+      }
+    }
+  
+,
+  "2d8899bf-6130-4211-8df6-331d6d102c76": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "+6/kIzx1obQkV1F0ZeCeif4wxrYER3KUepAbgbakQ69SrXWZaSVrzdMpdNSiy9WRsdV4k2ItYsvULXHWocvUjw=="
+      }
+    }
+  
+,
+  "a321a245-030a-481d-b348-3cc27aecc4a8": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "EMQYQ3iCqrqlYlukmHOuLdBzf9NxziuNRsLjpC494kJMllEtotoFr4Zn7t4pWviK4xRcJ6nSDKmBY+vcKlr5lA=="
+      }
+    }
+  
+,
+  "b378f388-943e-440d-81f5-e15f76f4e68a": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "QFXeShopbJ7B+GS3dv4XJ9tYjJCnJNOl1etTxY9dG/Lhuozib7f27uQBsSCQxCPUEJyB6GS//+jjBbQik8Qiyg=="
+      }
+    }
+  
+,
+  "16d21da6-76af-42bf-a395-4699f8c3fd4f": 
+    {
+      "action": "padding_oracle",
+      "arguments": {
+        "hostname": "localhost",
+        "port": 1337,
+        "iv": "AAAAAAAAAAAAAAAAAAAAAA==",
+        "ciphertext": "WMoU8g20SWQ8N1wBAq9gfa0EhfUnPTS34bY783m/2NFvXHiikuIUx//qRepcHOmdzSF1qJnqHcH47kDoXxzogw=="
+      }
+    }
+  
+}
+}
diff --git a/test_json/pfmath_tests.json b/test_json/pfmath_tests.json
new file mode 100644
index 0000000..b9cc6e0
--- /dev/null
+++ b/test_json/pfmath_tests.json
@@ -0,0 +1,98 @@
+{
+  "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=="
+      }
+    }
+  }
+}
diff --git a/test_json/poly_algs.json b/test_json/poly_algs.json
new file mode 100644
index 0000000..b4a687e
--- /dev/null
+++ b/test_json/poly_algs.json
@@ -0,0 +1,29 @@
+{
+  "testcases": {
+    "b856d760-023d-4b00-bad2-15d2b6da22fe": {
+
+"action": "gfpoly_sort",
+"arguments": {
+"polys": [
+[
+"NeverGonnaGiveYouUpAAA==",
+"NeverGonnaLetYouDownAA==",
+"NeverGonnaRunAroundAAA==",
+"AndDesertYouAAAAAAAAAA=="
+],
+[
+"WereNoStrangersToLoveA==",
+"YouKnowTheRulesAAAAAAA==",
+"AndSoDoIAAAAAAAAAAAAAA=="
+],
+[
+"NeverGonnaMakeYouCryAA==",
+"NeverGonnaSayGoodbyeAA==",
+"NeverGonnaTellALieAAAA==",
+"AndHurtYouAAAAAAAAAAAA=="
+]
+]
+}
+}
+  }
+}
diff --git a/test_json/sandbox.json b/test_json/sandbox.json
new file mode 100644
index 0000000..e3f5e1f
--- /dev/null
+++ b/test_json/sandbox.json
@@ -0,0 +1,29 @@
+{
+    "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": ""
+                }
+            }
+        }
+    }
+}