diff --git a/Cargo.toml b/Cargo.toml index 0d58d2b..e127c7e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,17 +10,9 @@ base64 = "0.22" openssl = "0.10" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" -num = "0.4" -rand = "0.8" -threadpool = "1.8" -num_cpus = "1.16.0" [source.crates-io] replace-with = "vendored-sources" [source.vendored-sources] directory = "vendor" - -[profile.profiling] -inherits = "release" -debug = true diff --git a/src/main.rs b/src/main.rs index 0bb3127..5816ecb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,10 +1,8 @@ use std::{ - env::{self}, + env::{self, args}, fs, }; -// TESTING 2 - use anyhow::Result; fn main() -> Result<()> { @@ -14,7 +12,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_distribute(&workload)?; + let response = kauma::tasks::task_distrubute(&workload)?; println!("{}", serde_json::to_string(&response)?); Ok(()) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 8a8b782..0fa72d6 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -1,22 +1,19 @@ use base64::prelude::*; -use std::collections::HashMap; +use std::{collections::HashMap, env::args}; -use crate::utils::parse::{Responses, Testcase, Testcases}; +use crate::utils::{ + ciphers::gcm_encrypt_aes, + 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::fde_xex, + xex::{self, fde_xex}, }; use anyhow::{anyhow, Result}; @@ -86,104 +83,6 @@ pub fn task_deploy(testcase: &Testcase) -> Result { 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![]; - - for poly in sorted_array { - result.push(poly.to_c_array()); - } - - let json = json!({"sorted_polys" : json!(result)}); - - Ok(json) - } - "gfpoly_make_monic" => { - let result = gfpoly_make_monic(args)?; - let json = json!({"A*" : result.to_c_array()}); - - Ok(json) - } - "gfpoly_sqrt" => { - let result = gfpoly_sqrt(args)?; - let json = json!({"S" : result.to_c_array()}); - - Ok(json) - } - "gfpoly_diff" => { - let result = gfpoly_diff(args)?; - let json = json!({"F'" : result.to_c_array()}); - - Ok(json) - } - "gfpoly_gcd" => { - let result = gfpoly_gcd(args)?; - let json = json!({"G" : result.to_c_array()}); - - Ok(json) - } - "gfpoly_factor_sff" => { - let result = gfpoly_factor_sff(args)?; - let json = json!({"factors" : result}); - - Ok(json) - } - "gfpoly_factor_ddf" => { - let result = gfpoly_factor_ddf(args)?; - let json = json!({"factors" : result}); - - Ok(json) - } - "gfpoly_factor_edf" => { - let result = gfpoly_factor_edf(args)?; - let json = json!({"factors" : result}); - - Ok(json) - } - "gcm_crack" => { - let result = gcm_crack(args)?; - let json = json!(result); - - Ok(json) - } - _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, @@ -192,60 +91,16 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } } -fn task_distribute_mt(testcases: &Testcases) -> Result { - eprintln!("USING MULTITHREADED"); - let mut responses: HashMap = 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 { - //eprintln!("USING SINGLETHREADED"); +pub fn task_distrubute(testcases: &Testcases) -> Result { let mut responses: HashMap = HashMap::new(); for (id, testcase) in &testcases.testcases { responses.insert(id.to_owned(), task_deploy(testcase).unwrap()); } - Ok(Responses { responses }) -} - -pub fn task_distribute(testcases: &Testcases) -> Result { - let cpus = num_cpus::get(); - if cpus > 1 { - task_distribute_mt(testcases) - } else { - task_distribute_st(testcases) - } + Ok(Responses { + responses: responses, + }) } #[cfg(test)] @@ -278,7 +133,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -302,7 +157,7 @@ mod tests { }); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -317,7 +172,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -335,7 +190,7 @@ mod tests { }}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -355,7 +210,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -375,7 +230,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -393,7 +248,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -411,25 +266,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), - serde_json::to_value(expected).unwrap() - ); - - Ok(()) - } - - #[test] - fn test_task_gcm_gfpoly_add() -> Result<()> { - let json = fs::read_to_string("test_json/gcm_decrypt_sea.json").unwrap(); - let parsed = parse_json(json).unwrap(); - - let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : { - "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==", - "authentic": true, - }}}); - - assert_eq!( - serde_json::to_value(task_distribute(&parsed)?).unwrap(), + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); diff --git a/src/tasks/tasks01/block2poly.rs b/src/tasks/tasks01/block2poly.rs index 3377bf6..dbdaf66 100644 --- a/src/tasks/tasks01/block2poly.rs +++ b/src/tasks/tasks01/block2poly.rs @@ -1,4 +1,4 @@ -use crate::utils::poly::block_2_polynomial; +use crate::utils::poly::{b64_2_num, block_2_polynomial, get_coefficients}; use anyhow::Result; use base64::prelude::*; use serde_json::Value; @@ -19,6 +19,7 @@ pub fn block2poly(val: &Value) -> Result> { #[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 deleted file mode 100644 index 09ccb2c..0000000 --- a/src/tasks/tasks01/gcm_crack.rs +++ /dev/null @@ -1,174 +0,0 @@ - -use anyhow::{Ok, Result}; -use base64::{prelude::BASE64_STANDARD, Engine}; -use serde::{Deserialize, Serialize}; -use serde_json::Value; - -use crate::utils::{ - ciphers::ghash, - dff::ddf, - edf::edf, - field::FieldElement, - math::{reverse_bits_in_bytevec, xor_bytes}, - poly::Polynomial, - sff::sff, -}; - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct CrackAnswer { - tag: String, - H: String, - mask: String, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -struct Message { - ciphertext: Vec, - ad: Vec, - tag: Vec, - l_field: Vec, -} - -fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { - let ciphertext_text: String = serde_json::from_value(val["ciphertext"].clone())?; - let mut ciphertext_bytes: Vec = BASE64_STANDARD.decode(ciphertext_text)?; - let mut c_len: Vec = ((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 = 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 = BASE64_STANDARD.decode(ad_text)?; - let mut l_field: Vec = ((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 = 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 = 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 = - 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 { - // 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 = vec![]; - for (factor, degree) in combine_ddf { - if degree == 1 { - combine_edf.extend(edf(factor, degree as u32)); - } - } - - let mut m3_auth_tag: Vec = vec![]; - let mut h_candidate: FieldElement = FieldElement::zero(); - let mut eky0: Vec = 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 8bca55f..01731f6 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -1,4 +1,7 @@ -use crate::utils::poly::gfmul; +use crate::utils::{ + field::ByteArray, + poly::{b64_2_num, coefficient_to_binary, gfmul}, +}; use anyhow::Result; use base64::prelude::*; @@ -13,7 +16,7 @@ pub fn gfmul_task(args: &Value) -> Result> { 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) } @@ -21,6 +24,7 @@ pub fn gfmul_task(args: &Value) -> Result> { #[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::*; @@ -35,7 +39,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==", @@ -55,7 +59,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==", @@ -75,7 +79,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==", @@ -95,7 +99,27 @@ 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==", + "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")?); assert_eq!( result, "hSQAAAAAAAAAAAAAAAAAAA==", diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs index 64d24da..479fe47 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -1,9 +1,7 @@ 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 234babf..1a0c144 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -3,7 +3,8 @@ use base64::prelude::*; use serde_json::Value; use std::io::prelude::*; use std::net::TcpStream; -use std::usize; +use std::time::{Duration, Instant}; +use std::{thread, usize}; pub fn padding_oracle(args: &Value) -> Result> { let hostname: String = serde_json::from_value(args["hostname"].clone())?; @@ -28,8 +29,9 @@ pub fn padding_oracle(args: &Value) -> Result> { let mut chunk_counter = 0; for chunk in &cipher_chunks { - let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?; - stream.set_nodelay(true).expect("Error on no delay"); + let start = Instant::now(); + + let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port))?; stream.set_nonblocking(false)?; // Track value sent to server @@ -40,6 +42,7 @@ pub fn padding_oracle(args: &Value) -> Result> { 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()?; @@ -49,16 +52,23 @@ pub fn padding_oracle(args: &Value) -> Result> { // 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 = Vec::with_capacity(2 + 16 * 265); - payload.extend(l_msg.to_vec()); - for _j in 0..q_block_count { + let mut payload: Vec = 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()?; @@ -66,57 +76,70 @@ pub fn padding_oracle(args: &Value) -> Result> { // 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) - .unwrap_or(0x00) as u8; - if valid_val == 0x00 { - eprintln!("No valid found in main loop"); - } + .expect("No valid found in main loop") as u8; + //eprintln!("Valid value found: {:02X?}", valid_val); // 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 = vec![0x01, 0x00]; let mut check_q_block: Vec = vec![0; 16]; check_q_block[15] = attack_counter[15]; check_q_block[14] = !check_q_block[15]; - l_msg_check.extend(check_q_block.as_slice()); - - stream.write_all(&l_msg_check)?; + stream.write_all(&[0x01, 0x00])?; + stream.write_all(&check_q_block)?; 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) - .unwrap_or(0x00) as u8; - if valid_val == 0x00 { - eprintln!("No valid found"); - } + .expect("No valid found") as u8); + eprintln!("Valid value found: {:02X?}", valid_val); // 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))); } - let range = i; - for pos in range..=15 { + //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 intermediate = attack_counter[pos as usize] ^ (15 - i as u8 + 1); attack_counter[pos as usize] = intermediate ^ ((15 - i as u8 + 1) + 1); @@ -125,10 +148,13 @@ pub fn padding_oracle(args: &Value) -> Result> { stream.flush()?; // Write plaintext + //eprintln!("{:02X?}", plaintext); } chunk_counter += 1; stream.flush()?; + // break; drop(stream); + eprintln!("Time rest of calc: {:?}", start.elapsed()); } plaintext.reverse(); @@ -140,6 +166,7 @@ pub fn padding_oracle(args: &Value) -> Result> { #[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 deleted file mode 100644 index 6830e1a..0000000 --- a/src/tasks/tasks01/pfmath.rs +++ /dev/null @@ -1,282 +0,0 @@ - -use anyhow::Result; -use base64::{prelude::BASE64_STANDARD, Engine}; -use serde_json::Value; - -use crate::utils::{ - self, - dff::ddf, - edf::edf, - field::FieldElement, - poly::{gcd, Polynomial}, - sff::{sff, Factors}, - }; - -pub fn gfpoly_add(args: &Value) -> Result { - 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 { - 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 { - 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 { - 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 { - 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> { - let poly_arrays: Vec = serde_json::from_value(args["polys"].clone())?; - let mut polys: Vec = 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 { - let poly_a = Polynomial::from_c_array(&args["A"].clone()); - - let result = poly_a.monic(); - - Ok(result) -} - -pub fn gfpoly_sqrt(args: &Value) -> Result { - let poly_a = Polynomial::from_c_array(&args["Q"].clone()); - - let result = poly_a.sqrt(); - - Ok(result) -} - -pub fn gfpoly_diff(args: &Value) -> Result { - let poly_f = Polynomial::from_c_array(&args["F"].clone()); - - let result = poly_f.diff(); - - Ok(result) -} - -pub fn gfpoly_gcd(args: &Value) -> Result { - 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> { - let poly_f = Polynomial::from_c_array(&arsg["F"].clone()); - - let mut factors = sff(poly_f); - factors.sort(); - let mut result: Vec = 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> { - let poly_f = Polynomial::from_c_array(&arsg["F"].clone()); - - let mut factors = ddf(poly_f); - factors.sort(); - let mut result: Vec = 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>> { - 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![]; - - 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![]; - 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![]; - 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 7557981..293d1c3 100644 --- a/src/tasks/tasks01/poly2block.rs +++ b/src/tasks/tasks01/poly2block.rs @@ -1,5 +1,6 @@ -use crate::utils::poly::polynomial_2_block; +use crate::utils::poly::{self, polynomial_2_block}; use anyhow::{Ok, Result}; +use base64::prelude::*; use serde_json::Value; pub fn poly2block(args: &Value) -> Result> { diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index 2a6a7e2..3f5c40d 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -6,13 +6,19 @@ use crate::utils::ciphers::{sea_128_decrypt, sea_128_encrypt}; pub fn sea128(args: &Value) -> Result { let key_string: String = serde_json::from_value(args["key"].clone())?; + //let key: &[u8] = b64_2_num(key_string)?.to_ne_bytes(); let key = BASE64_STANDARD.decode(key_string)?; + //eprintln!("{:?}", key); let input_string: String = serde_json::from_value(args["input"].clone())?; + //let plaintexts: &[u8] = &b64_2_num(plaintexts_string)?.to_ne_bytes(); let input = BASE64_STANDARD.decode(input_string)?; + let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11; let mode: String = serde_json::from_value(args["mode"].clone())?; match mode.as_str() { "encrypt" => { + //eprintln!("{:?}", plaintexts); + let output = BASE64_STANDARD.encode(sea_128_encrypt(&key, &input)?); Ok(output) @@ -28,6 +34,7 @@ pub fn sea128(args: &Value) -> Result { #[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 0b558af..917a1c7 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,5 +1,8 @@ -use crate::utils::{field::ByteArray, poly::gfmul}; +use std::{io::BufRead, process::Output}; + +use crate::utils::{field::ByteArray, math::reverse_bits_in_bytevec, poly::gfmul}; use anyhow::Result; +use base64::prelude::*; use openssl::symm::{Cipher, Crypter, Mode}; use super::math::xor_bytes; @@ -37,6 +40,7 @@ pub fn aes_128_decrypt(key: &Vec, input: &Vec) -> Result> { let mut bytes: [u8; 16] = [0u8; 16]; bytes.copy_from_slice(&plaintext); + let number: u128 = ::from_be_bytes(bytes); Ok(plaintext) } @@ -118,8 +122,10 @@ 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())?; @@ -130,6 +136,8 @@ 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())?; @@ -146,6 +154,7 @@ 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)) } @@ -161,6 +170,8 @@ 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)?; @@ -173,6 +184,8 @@ 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())?; @@ -191,6 +204,7 @@ pub fn gcm_decrypt_aes( )?; let valid = auth_tag == tag; + eprintln!("aes auth tag: {:001X?}", auth_tag); Ok((plaintext, valid)) } @@ -206,6 +220,7 @@ 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)?; @@ -218,6 +233,8 @@ 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())?; @@ -249,6 +266,8 @@ 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)?; @@ -256,11 +275,17 @@ pub fn gcm_decrypt_sea( let plaintext_chunks: Vec> = 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())?; @@ -273,11 +298,15 @@ pub fn gcm_decrypt_sea( let mut c_len: Vec = ((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)) @@ -291,6 +320,10 @@ pub fn ghash( ) -> Result> { let output: Vec = 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()); } @@ -299,29 +332,46 @@ 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, "gcm")?; + let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?; + eprintln!("Ad chunks after first next {:001X?}", ad_chunks); 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, "gcm")?; + inter_loop = gfmul(inter2, auth_key_h.clone(), "gcm")?; } let cipher_chunks = ciphertext.chunks(16); for chunk in cipher_chunks { let inter3 = xor_bytes(&inter_loop, chunk.to_vec())?; - inter_loop = gfmul(&inter3, &auth_key_h, "gcm")?; + inter_loop = gfmul(inter3, auth_key_h.clone(), "gcm")?; } let inter4 = xor_bytes(&inter_loop, l_field)?; - inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?; + inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?; + + eprintln!("GHASH auth tag: {:001X?}", inter_loop); Ok(inter_loop) } +/* +* let mut bytes: [u8; 16] = [0u8; 16]; + bytes.copy_from_slice(&ciphertext); + let number: u128 = ::from_be_bytes(bytes); + +* */ + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/dff.rs b/src/utils/dff.rs deleted file mode 100644 index 21dde69..0000000 --- a/src/utils/dff.rs +++ /dev/null @@ -1,81 +0,0 @@ -use std::usize; - -use num::{pow::Pow, BigUint, FromPrimitive}; -use serde::{Deserialize, Serialize}; - -use super::poly::{gcd, Polynomial}; - -#[derive(Debug, Serialize, Deserialize)] -pub struct Factors { - pub factor: Vec, - 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 = 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 = vec![0]; - assert!(false) - } -} diff --git a/src/utils/edf.rs b/src/utils/edf.rs deleted file mode 100644 index dfb59cf..0000000 --- a/src/utils/edf.rs +++ /dev/null @@ -1,86 +0,0 @@ -use num::{BigUint, FromPrimitive, One}; -use rand::Rng; - -use super::poly::{gcd, Polynomial}; - -pub fn edf(f: Polynomial, d: u32) -> Vec { - let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128); - let n: u32 = (f.degree() as u32) / (d); - let mut z: Vec = 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![]; - - 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 739b466..5645b04 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,239 +1,7 @@ -use base64::prelude::*; -use std::{u128, u8, usize}; - -use std::{ - cmp::Ordering, - ops::{Add, BitXor, Div, Mul}, -}; - use anyhow::{anyhow, Ok, Result}; +use base64::Engine; -use super::{ - math::{reverse_bits_in_bytevec, xor_bytes}, - poly::gfmul, -}; - -#[derive(Debug, serde::Serialize, serde::Deserialize)] -pub struct FieldElement { - field_element: Vec, -} - -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 { - self.field_element.clone() - } - - pub fn new(field_element: Vec) -> Self { - Self { - field_element: reverse_bits_in_bytevec(field_element), - } - } - - pub fn new_no_convert(field_element: Vec) -> Self { - Self { field_element } - } - - pub fn mul(&self, poly_a: Vec, poly_b: Vec) -> Result> { - 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 = 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 = 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 { - 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 - } -} +use super::poly::gfmul; #[derive(Debug)] pub struct ByteArray(pub Vec); @@ -269,13 +37,13 @@ impl ByteArray { let alpha_poly: Vec = base64::prelude::BASE64_STANDARD .decode("AgAAAAAAAAAAAAAAAAAAAA==") .expect("Decode failed"); - self.0 = gfmul(&self.0, &alpha_poly, "xex").unwrap(); + self.0 = gfmul(self.0.clone(), alpha_poly, "xex").unwrap(); } "gcm" => { let alpha_poly: Vec = base64::prelude::BASE64_STANDARD .decode("AgAAAAAAAAAAAAAAAAAAAA==") .expect("Decode failed"); - self.0 = gfmul(&self.0, &alpha_poly, "gcm").unwrap(); + self.0 = gfmul(self.0.clone(), alpha_poly, "gcm").unwrap(); } _ => {} } @@ -337,12 +105,13 @@ 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").unwrap(); + byte_array.left_shift("xex"); assert_eq!(byte_array.0, shifted_array.0); } @@ -351,7 +120,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").unwrap(); + byte_array.left_shift("xex"); assert_eq!( byte_array.0, shifted_array.0, @@ -364,7 +133,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").unwrap(); + byte_array.left_shift("gcm"); assert_eq!( byte_array.0, shifted_array.0, @@ -377,7 +146,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").unwrap(); + byte_array.right_shift("gcm"); assert_eq!( byte_array.0, shifted_array.0, @@ -390,7 +159,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").unwrap(); + byte_array.right_shift("xex"); assert_eq!( byte_array.0, shifted_array.0, @@ -430,39 +199,4 @@ 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 c1809e2..cf87e0c 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -1,5 +1,7 @@ -use anyhow::{Ok, Result}; +use anyhow::{anyhow, Ok, Result}; +use base64::Engine; +use super::poly::gfmul; pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) { diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 35fb781..298415b 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,9 +1,6 @@ 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 4b71b29..5cc1781 100644 --- a/src/utils/parse.rs +++ b/src/utils/parse.rs @@ -8,13 +8,13 @@ pub struct Testcases { pub testcases: HashMap, } -#[derive(Debug, Serialize, Deserialize, Clone)] +#[derive(Debug, Serialize, Deserialize)] pub struct Testcase { pub action: String, pub arguments: Value, } -#[derive(Debug, Serialize, Deserialize, Clone)] +#[derive(Debug, Serialize, Deserialize)] pub struct Responses { pub responses: HashMap, } @@ -28,6 +28,8 @@ pub fn parse_json(json: String) -> Result { 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 6a61853..78889c8 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,567 +1,28 @@ use crate::utils::field::ByteArray; +use anyhow::{anyhow, Result}; use base64::prelude::*; - -use num::traits::FromBytes; -use num::{BigUint, One, Zero}; - +use serde_json::Value; use std::{str::FromStr, u128, u8, usize}; -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, -} - -impl Polynomial { - pub const fn new(polynomial: Vec) -> 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 = 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 = vec![]; - let c_array: Vec = 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 { - let mut output: Vec = 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 = "_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 = - 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 = - 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; - - 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 { - 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) -> Result> { - // Algorithm to sort polynomials - // First sorting round - // Sorting by degree of polynomial - polys.sort(); - - Ok(polys) -} - +use super::{field, math::reverse_bits_in_bytevec}; pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; -pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result> { - let red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); +pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result> { + let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); + red_poly_bytes.0.push(0x01); - let mut poly1: ByteArray = ByteArray(poly_a.to_vec()); + let mut poly1: ByteArray = ByteArray(poly_a); + poly1.0.push(0x00); - let mut poly2: ByteArray = ByteArray(poly_b.to_vec()); + let mut poly2: ByteArray = ByteArray(poly_b); + poly2.0.push(0x00); 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]); + let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); if poly2.LSB_is_one() { result.xor_byte_arrays(&poly1); @@ -569,9 +30,9 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result) -> Result> { pub fn get_alpha_rep(num: u128) -> String { let powers: Vec = get_coefficients(num); + //println!("{:?}", powers); + let mut alpha_rep = String::new(); if powers.len() == 1 { @@ -629,6 +92,7 @@ pub fn b64_2_num(string: &String) -> Result { pub fn get_coefficients(num: u128) -> Vec { let mut powers: Vec = vec![]; for shift in 0..128 { + //println!("{:?}", ((num >> shift) & 1)); if ((num >> shift) & 1) == 1 { powers.push(shift); } @@ -708,7 +172,7 @@ pub fn coefficients_to_byte_arr_xex(coeffs: Vec) -> Vec { let mut byte_array: Vec = 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 @@ -725,12 +189,31 @@ pub fn coefficient_to_binary(coefficients: Vec) -> u128 { #[cfg(test)] mod tests { - use crate::utils::poly::{b64_2_num, gcd}; + use crate::utils::poly::b64_2_num; 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 = 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 = 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; @@ -755,7 +238,7 @@ mod tests { #[test] fn coeff_to_binary() { let coefficients: Vec = 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()), @@ -775,588 +258,4 @@ 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 deleted file mode 100644 index de2bef6..0000000 --- a/src/utils/sff.rs +++ /dev/null @@ -1,92 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::{ - field::FieldElement, - poly::{gcd, polynomial_2_block}, -}; - -use super::poly::Polynomial; - -#[derive(Debug, Serialize, Deserialize)] -pub struct Factors { - pub factor: Vec, - 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 = vec![]; - - for (factor, exponent) in factors { - result.push(Factors { - factor: factor.to_c_array(), - exponent, - }); - } - - println!("{:?}", result); - let _bit_indices: Vec = vec![0]; - assert!(false) - } -} diff --git a/test_json/padding_long.json b/test_json/padding_long.json deleted file mode 100644 index 3b37422..0000000 --- a/test_json/padding_long.json +++ /dev/null @@ -1,1203 +0,0 @@ -{ - "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 deleted file mode 100644 index b9cc6e0..0000000 --- a/test_json/pfmath_tests.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "testcases": { - "gfpoly_add": { - "action": "gfpoly_add", - "arguments": { - "A": [ - "NeverGonnaGiveYouUpAAA==", - "NeverGonnaLetYouDownAA==", - "NeverGonnaRunAroundAAA==", - "AndDesertYouAAAAAAAAAA==" - ], - "B": [ - "KryptoanalyseAAAAAAAAA==", - "DHBWMannheimAAAAAAAAAA==" - ] - } - }, - "gfpoly_mul": { - "action": "gfpoly_mul", - "arguments": { - "A": [ - "JAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "B": [ - "0AAAAAAAAAAAAAAAAAAAAA==", - "IQAAAAAAAAAAAAAAAAAAAA==" - ] - } - }, - "gfpoly_mul_10": { - "action": "gfpoly_mul", - "arguments": { - "A": [ - "JAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "B": [ - "AAAAAAAAAAAAAAAAAAAAAA==" - ] - } - }, - "gfpoly_mul_01": { - "action": "gfpoly_mul", - "arguments": { - "A": [ - "AAAAAAAAAAAAAAAAAAAAAA==" - ], - "B": [ - "0AAAAAAAAAAAAAAAAAAAAA==", - "IQAAAAAAAAAAAAAAAAAAAA==" - ] - } - }, - "gfpoly_pow": { - "action": "gfpoly_pow", - "arguments": { - "A": [ - "JAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "k": 3 - } - }, - "gfpoly_pow_k0": { - "action": "gfpoly_pow", - "arguments": { - "A": [ - "JAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "k": 0 - } - }, - "gfpoly_pow_k1": { - "action": "gfpoly_pow", - "arguments": { - "A": [ - "JAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "k": 1 - } - }, - "gfdiv": { - "action": "gfdiv", - "arguments": { - "a": "JAAAAAAAAAAAAAAAAAAAAA==", - "b": "wAAAAAAAAAAAAAAAAAAAAA==" - } - } - } -} diff --git a/test_json/poly_algs.json b/test_json/poly_algs.json deleted file mode 100644 index b4a687e..0000000 --- a/test_json/poly_algs.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "testcases": { - "b856d760-023d-4b00-bad2-15d2b6da22fe": { - -"action": "gfpoly_sort", -"arguments": { -"polys": [ -[ -"NeverGonnaGiveYouUpAAA==", -"NeverGonnaLetYouDownAA==", -"NeverGonnaRunAroundAAA==", -"AndDesertYouAAAAAAAAAA==" -], -[ -"WereNoStrangersToLoveA==", -"YouKnowTheRulesAAAAAAA==", -"AndSoDoIAAAAAAAAAAAAAA==" -], -[ -"NeverGonnaMakeYouCryAA==", -"NeverGonnaSayGoodbyeAA==", -"NeverGonnaTellALieAAAA==", -"AndHurtYouAAAAAAAAAAAA==" -] -] -} -} - } -} diff --git a/test_json/sandbox.json b/test_json/sandbox.json deleted file mode 100644 index e3f5e1f..0000000 --- a/test_json/sandbox.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "testcases": { - "gcm_crack1": { - "action": "gcm_crack", - "arguments": { - "nonce": "4gF+BtR3ku/PUQci", - "m1": { - "ciphertext": "CGOkZDnJEt24aVV8mqQq+P4pouVDWhAYj0SN5MDAgg==", - "associated_data": "TmFjaHJpY2h0IDE=", - "tag": "GC9neV3aZLnmznTIWqCC4A==" - }, - "m2": { - "ciphertext": "FnWyLSTfRrO8Y1MuhLIs6A==", - "associated_data": "", - "tag": "gb2ph1vzwU85/FsUg51t3Q==" - }, - "m3": { - "ciphertext": "CGOkZDnJEt25aV58iaMt6O8+8chKVh0Eg1XFxA==", - "associated_data": "TmFjaHJpY2h0IDM=", - "tag": "+/aDjsAzTseDLuM4jt5Q6Q==" - }, - "forgery": { - "ciphertext": "AXe/ZQ==", - "associated_data": "" - } - } - } - } -}