From becb9539268b9bb487d26756259aa04ab9f7421d Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Wed, 23 Oct 2024 10:46:11 +0200 Subject: [PATCH 001/105] WIP: feat: starting work on xex --- src/utils/ciphers.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index d82be86..bfa999e 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,3 +1,5 @@ +use std::io::BufRead; + use anyhow::Result; use openssl::symm::{Cipher, Crypter, Mode}; @@ -51,6 +53,14 @@ pub fn sea_128_decrypt(key: &Vec, input: &Vec) -> Result> { Ok(aes_128_decrypt(&key, &intermediate)?) } +pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result> { + let key_parts: Vec = key.split_off(128); + let key1 = key_parts[0]; + let key2 = key_parts[1]; + + todo!(); +} + /* * let mut bytes: [u8; 16] = [0u8; 16]; bytes.copy_from_slice(&ciphertext); From 34b7dbae2c664ce644aaf03733e78ee8fed77caf Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 16:55:22 +0100 Subject: [PATCH 002/105] chore: debug pipeline --- .github/workflows/kauma.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index f094270..aeea71b 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls && pwd && ls ./test_json/kauma_tests.json && /dut/build && /dut/kauma ./test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls ; pwd ; ls ./test_json/kauma_tests.json ; /dut/build && /dut/kauma ./test_json/kauma_tests.json' From 64615426492415f32475b9c320355a046081b6c7 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 16:58:05 +0100 Subject: [PATCH 003/105] chore: debug pipeline --- .github/workflows/kauma.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index aeea71b..eae69ca 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls ; pwd ; ls ./test_json/kauma_tests.json ; /dut/build && /dut/kauma ./test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls ; pwd ; ls ./test_json/kauma_tests.json ; /dut/build && /dut/kauma ./dut/test_json/kauma_tests.json' From 02c054f9a6e780a7dbe52d9349aeb0f194a80432 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 17:04:33 +0100 Subject: [PATCH 004/105] chore: debug pipeline --- .github/workflows/kauma.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index eae69ca..21447d5 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls ; pwd ; ls ./test_json/kauma_tests.json ; /dut/build && /dut/kauma ./dut/test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls ./dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma ./dut/test_json/kauma_tests.json' From 20617bb158ba4838698de9b01c211dede9f5ca7e Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 17:06:34 +0100 Subject: [PATCH 005/105] chore: debug pipeline --- .github/workflows/kauma.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index 21447d5..8421b92 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls ./dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma ./dut/test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls ./dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma /dut/test_json/kauma_tests.json' From 0b38a4703cf6f3c96531114c6f75daf0bbf47806 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 17:09:26 +0100 Subject: [PATCH 006/105] chore: debug pipeline --- .github/workflows/kauma.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index 8421b92..9b338bf 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls ./dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma /dut/test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c 'pwd ; ls ; echo "ls dut" ; ls /dut ; ls -la /dut/test_json/kauma_tests.json ; /dut/build && /dut/kauma /dut/test_json/kauma_tests.json' From b21e60985f65116e79a27ff4999c3e68098ced51 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 17:20:50 +0100 Subject: [PATCH 007/105] chore: debug pipeline --- src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index 5816ecb..ca8d9d2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,7 +7,7 @@ use anyhow::Result; fn main() -> Result<()> { let args: Vec = env::args().collect(); - let path_to_workload = &args[1]; + let path_to_workload = &args[2]; let json = fs::read_to_string(path_to_workload).unwrap(); let workload = kauma::utils::parse::parse_json(json)?; From 5c1c0f6c5ead7a33675500c5a743dd52a090e7c4 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 27 Oct 2024 22:32:14 +0100 Subject: [PATCH 008/105] refactor: Refactor gfmul function to enable use in XEX --- .github/workflows/kauma.yaml | 2 +- kauma | 2 +- src/tasks/tasks01/gfmul.rs | 18 ++++++++++++------ src/tasks/tasks01/mod.rs | 1 + src/utils/parse.rs | 2 +- 5 files changed, 16 insertions(+), 9 deletions(-) diff --git a/.github/workflows/kauma.yaml b/.github/workflows/kauma.yaml index f094270..97f49b6 100644 --- a/.github/workflows/kauma.yaml +++ b/.github/workflows/kauma.yaml @@ -66,5 +66,5 @@ jobs: docker tag ghcr.io/johndoe31415/labwork-docker:master labwork - name: Run labwork container run: | - docker run -v $PWD:/dut/ labwork /bin/bash -c 'ls && pwd && ls ./test_json/kauma_tests.json && /dut/build && /dut/kauma ./test_json/kauma_tests.json' + docker run -v $PWD:/dut/ labwork /bin/bash -c '/dut/build && /dut/kauma ./test_json/kauma_tests.json' diff --git a/kauma b/kauma index b2752c5..b9f9b40 100755 --- a/kauma +++ b/kauma @@ -1,4 +1,4 @@ #!/bin/bash SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) cd $SCRIPT_DIR -cargo run --release --locked --offline -- --verbose $@ +cargo run --release --locked --offline -- $@ diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 0543d8f..91ce8a2 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -10,16 +10,14 @@ use crate::utils::{ pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; -pub fn gfmul(args: &Value) -> Result { +pub fn gfmul(poly_a: Vec, poly_b: Vec) -> Result { let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); red_poly_bytes.0.push(0x01); - let poly1_text: String = serde_json::from_value(args["a"].clone())?; - let mut poly1: ByteArray = ByteArray(BASE64_STANDARD.decode(poly1_text)?); + let mut poly1: ByteArray = ByteArray(poly_a); poly1.0.push(0x00); - let poly2_text: String = serde_json::from_value(args["b"].clone())?; - let mut poly2: ByteArray = ByteArray(BASE64_STANDARD.decode(poly2_text)?); + let mut poly2: ByteArray = ByteArray(poly_b); poly2.0.push(0x00); let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); @@ -61,7 +59,15 @@ mod tests { #[test] fn gfmul_task01() -> Result<()> { let args: Value = json!({"a": "ARIAAAAAAAAAAAAAAAAAgA==", "b": "AgAAAAAAAAAAAAAAAAAAAA=="}); - let result = gfmul(&args)?; + + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; + + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; + + let result = gfmul(poly_a, poly_b)?; + assert_eq!( result, "hSQAAAAAAAAAAAAAAAAAAA==", "Failure. Calulated result was: {}", diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs index 9b90b1d..97ea4d7 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -2,3 +2,4 @@ pub mod block2poly; pub mod gfmul; pub mod poly2block; pub mod sea128; +pub mod xex; diff --git a/src/utils/parse.rs b/src/utils/parse.rs index 2ab1915..5cc1781 100644 --- a/src/utils/parse.rs +++ b/src/utils/parse.rs @@ -35,7 +35,7 @@ mod tests { #[test] fn test_json_parsing() { - let json = fs::read_to_string("src/test_json/parse_example.json").unwrap(); + let json = fs::read_to_string("test_json/parse_example.json").unwrap(); let parsed = parse_json(json).unwrap(); /* From c34557ea29a39f64d47e123c1a90f058e21ecd6c Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Mon, 28 Oct 2024 00:35:39 +0100 Subject: [PATCH 009/105] feat: both XEX enc/dec are working in atomic tests --- src/tasks/mod.rs | 20 +++++-- src/tasks/tasks01/gfmul.rs | 8 +-- src/tasks/tasks01/sea128.rs | 2 +- src/tasks/tasks01/xex.rs | 0 src/utils/ciphers.rs | 116 ++++++++++++++++++++++++++++++++++-- src/utils/math.rs | 10 ++++ 6 files changed, 140 insertions(+), 16 deletions(-) create mode 100644 src/tasks/tasks01/xex.rs diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 05d8e85..ad5c83c 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -1,3 +1,5 @@ +use base64::prelude::*; + use std::collections::HashMap; use crate::utils::parse::{Responses, Testcase, Testcases}; @@ -6,7 +8,7 @@ use tasks01::{block2poly::block2poly, gfmul::gfmul, poly2block::poly2block, sea1 use anyhow::{anyhow, Result}; use serde_json::{json, Value}; -mod tasks01; +pub mod tasks01; pub fn task_deploy(testcase: &Testcase) -> Result { /* @@ -35,7 +37,13 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } "gfmul" => { - let result = gfmul(args)?; + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; + + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; + + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b)?); let json = json!({"product" : result}); Ok(json) } @@ -67,7 +75,7 @@ mod tests { #[test] fn test_task_deploy() { - let json = fs::read_to_string("src/test_json/poly2block_example.json").unwrap(); + let json = fs::read_to_string("test_json/poly2block_example.json").unwrap(); let parsed = parse_json(json).unwrap(); let testcase = parsed .testcases @@ -83,7 +91,7 @@ mod tests { #[test] fn test_task_distribution() -> Result<()> { - let json = fs::read_to_string("src/test_json/poly2block_example.json").unwrap(); + let json = fs::read_to_string("test_json/poly2block_example.json").unwrap(); let parsed = parse_json(json).unwrap(); let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}}); @@ -98,7 +106,7 @@ mod tests { #[test] fn test_task_sea128_task_full() -> Result<()> { - let json = fs::read_to_string("src/test_json/sea128.json").unwrap(); + let json = fs::read_to_string("test_json/sea128.json").unwrap(); let parsed = parse_json(json).unwrap(); let expected = json!({ @@ -122,7 +130,7 @@ mod tests { #[test] fn test_task_gfmul_full() -> Result<()> { - let json = fs::read_to_string("src/test_json/gfmul_test.json").unwrap(); + let json = fs::read_to_string("test_json/gfmul_test.json").unwrap(); let parsed = parse_json(json).unwrap(); let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}}); diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 91ce8a2..44a032e 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -10,7 +10,7 @@ use crate::utils::{ pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; -pub fn gfmul(poly_a: Vec, poly_b: Vec) -> Result { +pub fn gfmul(poly_a: Vec, poly_b: Vec) -> Result> { let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); red_poly_bytes.0.push(0x01); @@ -42,10 +42,8 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec) -> Result { } result.0.remove(16); - let mut bytes: [u8; 16] = [0u8; 16]; - bytes.copy_from_slice(&result.0); - Ok(BASE64_STANDARD.encode(bytes)) + Ok(result.0) } #[cfg(test)] @@ -66,7 +64,7 @@ mod tests { let poly2_text: String = serde_json::from_value(args["b"].clone())?; let poly_b = BASE64_STANDARD.decode(poly2_text)?; - let result = gfmul(poly_a, poly_b)?; + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b)?); assert_eq!( result, "hSQAAAAAAAAAAAAAAAAAAA==", diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index 3f5c40d..cd5a87d 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -24,7 +24,7 @@ pub fn sea128(args: &Value) -> Result { Ok(output) } "decrypt" => { - let output = BASE64_STANDARD.encode(sea_128_decrypt(&key, &input)?); + let output = BASE64_STANDARD.encode(sea_128_decrypt(&key.into(), &input)?); Ok(output) } diff --git a/src/tasks/tasks01/xex.rs b/src/tasks/tasks01/xex.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index bfa999e..6b38c1a 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -3,6 +3,8 @@ use std::io::BufRead; use anyhow::Result; use openssl::symm::{Cipher, Crypter, Mode}; +use crate::utils::math::ByteArray; + use super::math::xor_bytes; pub fn aes_128_encrypt(key: &Vec, input: &Vec) -> Result> { @@ -54,11 +56,77 @@ pub fn sea_128_decrypt(key: &Vec, input: &Vec) -> Result> { } pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result> { - let key_parts: Vec = key.split_off(128); - let key1 = key_parts[0]; - let key2 = key_parts[1]; + let key2: Vec = key.split_off(16); + //let key1: ByteArray = ByteArray(vec![key_parts[0]]); + //let key2: ByteArray = ByteArray(vec![key_parts[1]]); - todo!(); + let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); + + let mut output: Vec = vec![]; + assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); + + dbg!("input_chunks: {:001X?}", &input_chunks); + + for chunk in input_chunks { + eprintln!("chunk: {:001X?}", &chunk); + let plaintext_intermediate = xor_bytes(&tweak_block.0, chunk)?; + eprintln!("key: {:001X?}", &key); + eprintln!("key2: {:001X?}", &key2); + eprintln!("plain: {:001X?}", &plaintext_intermediate); + eprintln!("tweak_block: {:001X?}", &tweak_block.0); + + assert!( + plaintext_intermediate.len() % 16 == 0, + "Failure: plaintext_intermediate len was {}", + plaintext_intermediate.len() + ); + assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + let cypher_block_intermediate = sea_128_encrypt(&key, &plaintext_intermediate)?; + let mut cypher_block = xor_bytes(&tweak_block.0, cypher_block_intermediate)?; + output.append(cypher_block.as_mut()); + tweak_block.left_shift_reduce(); + } + + Ok(output) +} + +pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result> { + let key2: Vec = key.split_off(16); + //let key1: ByteArray = ByteArray(vec![key_parts[0]]); + //let key2: ByteArray = ByteArray(vec![key_parts[1]]); + + let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); + + let mut output: Vec = vec![]; + assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); + + for chunk in input_chunks { + eprintln!("chunk: {:001X?}", &chunk); + let cyphertext_intermediate = xor_bytes(&tweak_block.0, chunk)?; + eprintln!("key: {:001X?}", &key); + eprintln!("key2: {:001X?}", &key2); + eprintln!("plain: {:001X?}", &cyphertext_intermediate); + eprintln!("tweak_block: {:001X?}", &tweak_block.0); + + assert!( + cyphertext_intermediate.len() % 16 == 0, + "Failure: plaintext_intermediate len was {}", + cyphertext_intermediate.len() + ); + assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + let plaintext_block_intermediate = sea_128_decrypt(&key, &cyphertext_intermediate)?; + let mut cypher_block = xor_bytes(&tweak_block.0, plaintext_block_intermediate)?; + output.append(cypher_block.as_mut()); + tweak_block.left_shift_reduce(); + } + + Ok(output) } /* @@ -67,3 +135,43 @@ pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result let number: u128 = ::from_be_bytes(bytes); * */ + +#[cfg(test)] +mod tests { + use super::*; + use base64::prelude::*; + + #[test] + fn test_xex_encrypt() -> Result<()> { + let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?; + let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?; + let input = BASE64_STANDARD + .decode("/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW")?; + + let output = BASE64_STANDARD.encode(xex_encrypt(key, &tweak, &input)?); + + assert_eq!( + output, + "mHAVhRCKPAPx0BcufG5BZ4+/CbneMV/gRvqK5rtLe0OJgpDU5iT7z2P0R7gEeRDO" + ); + + Ok(()) + } + + #[test] + fn test_xex_decrypt() -> Result<()> { + let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?; + let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?; + let input = BASE64_STANDARD + .decode("lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a")?; + + let output = BASE64_STANDARD.encode(xex_decrypt(key, &tweak, &input)?); + + assert_eq!( + output, + "SGV5IHdpZSBrcmFzcyBkYXMgZnVua3Rpb25pZXJ0IGphIG9mZmVuYmFyIGVjaHQu" + ); + + Ok(()) + } +} diff --git a/src/utils/math.rs b/src/utils/math.rs index 5fff14a..82b2c61 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -1,4 +1,7 @@ use anyhow::{Ok, Result}; +use base64::Engine; + +use crate::tasks::tasks01::gfmul::gfmul; pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) { @@ -22,6 +25,13 @@ impl ByteArray { carry } + pub fn left_shift_reduce(&mut self) { + let alpha_poly: Vec = base64::prelude::BASE64_STANDARD + .decode("AgAAAAAAAAAAAAAAAAAAAA==") + .expect("Decode failed"); + self.0 = gfmul(self.0.clone(), alpha_poly).unwrap(); + } + pub fn right_shift(&mut self) -> u8 { let mut carry = 0u8; for byte in self.0.iter_mut().rev() { From 31050ea696417836d8e1b1c3420f94027118ed42 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Mon, 28 Oct 2024 18:41:15 +0100 Subject: [PATCH 010/105] feat: finalise XEX runner and testing --- src/tasks/mod.rs | 32 +++++++++++++++- src/tasks/tasks01/sea128.rs | 2 +- src/tasks/tasks01/xex.rs | 27 ++++++++++++++ src/utils/ciphers.rs | 39 ++++++++------------ test_json/kauma_tests.json | 73 +++++++++++++++++++++++++------------ test_json/xex_tests.json | 22 +++++++++++ 6 files changed, 146 insertions(+), 49 deletions(-) create mode 100644 test_json/xex_tests.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index ad5c83c..13f27d8 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -3,7 +3,13 @@ use base64::prelude::*; use std::collections::HashMap; use crate::utils::parse::{Responses, Testcase, Testcases}; -use tasks01::{block2poly::block2poly, gfmul::gfmul, poly2block::poly2block, sea128::sea128}; +use tasks01::{ + block2poly::block2poly, + gfmul::gfmul, + poly2block::poly2block, + sea128::sea128, + xex::{self, fde_xex}, +}; use anyhow::{anyhow, Result}; use serde_json::{json, Value}; @@ -47,6 +53,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { let json = json!({"product" : result}); Ok(json) } + "xex" => { + let result = BASE64_STANDARD.encode(fde_xex(args)?); + let json = json!({"output" : result}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, @@ -142,4 +154,22 @@ mod tests { Ok(()) } + + #[test] + fn test_task_xex_full() -> Result<()> { + let json = fs::read_to_string("test_json/xex_tests.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ "responses": { + "0192d428-3913-762b-a702-d14828eae1f8": {"output": "mHAVhRCKPAPx0BcufG5BZ4+/CbneMV/gRvqK5rtLe0OJgpDU5iT7z2P0R7gEeRDO"}, + "0192d428-3913-7168-a3bb-69c258c74dc1": {"output": "SGV5IHdpZSBrcmFzcyBkYXMgZnVua3Rpb25pZXJ0IGphIG9mZmVuYmFyIGVjaHQu"} + }}); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } } diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index cd5a87d..3f5c40d 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -24,7 +24,7 @@ pub fn sea128(args: &Value) -> Result { Ok(output) } "decrypt" => { - let output = BASE64_STANDARD.encode(sea_128_decrypt(&key.into(), &input)?); + let output = BASE64_STANDARD.encode(sea_128_decrypt(&key, &input)?); Ok(output) } diff --git a/src/tasks/tasks01/xex.rs b/src/tasks/tasks01/xex.rs index e69de29..68b61da 100644 --- a/src/tasks/tasks01/xex.rs +++ b/src/tasks/tasks01/xex.rs @@ -0,0 +1,27 @@ +use anyhow::{anyhow, Result}; +use base64::prelude::*; +use serde_json::Value; + +use crate::utils::ciphers::{xex_decrypt, xex_encrypt}; + +pub fn fde_xex(args: &Value) -> Result> { + let key_string: String = serde_json::from_value(args["key"].clone())?; + let key: Vec = BASE64_STANDARD.decode(key_string)?; + + let tweak_string: String = serde_json::from_value(args["tweak"].clone())?; + let tweak: Vec = BASE64_STANDARD.decode(tweak_string)?; + + let input_string: String = serde_json::from_value(args["input"].clone())?; + let input: Vec = BASE64_STANDARD.decode(input_string)?; + + let mode_string: String = serde_json::from_value(args["mode"].clone())?; + + match mode_string.as_str() { + "encrypt" => Ok(xex_encrypt(key, &tweak, &input)?), + "decrypt" => Ok(xex_decrypt(key, &tweak, &input)?), + _ => Err(anyhow!( + "Failure: No compatible mode found. Data was: {:?}", + args + )), + } +} diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 6b38c1a..ec1b467 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -63,27 +63,23 @@ pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); let mut output: Vec = vec![]; - assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); - dbg!("input_chunks: {:001X?}", &input_chunks); + //dbg!("input_chunks: {:001X?}", &input_chunks); for chunk in input_chunks { - eprintln!("chunk: {:001X?}", &chunk); let plaintext_intermediate = xor_bytes(&tweak_block.0, chunk)?; - eprintln!("key: {:001X?}", &key); - eprintln!("key2: {:001X?}", &key2); - eprintln!("plain: {:001X?}", &plaintext_intermediate); - eprintln!("tweak_block: {:001X?}", &tweak_block.0); - - assert!( - plaintext_intermediate.len() % 16 == 0, - "Failure: plaintext_intermediate len was {}", - plaintext_intermediate.len() - ); - assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + /* + assert!( + plaintext_intermediate.len() % 16 == 0, + "Failure: plaintext_intermediate len was {}", + plaintext_intermediate.len() + ); + */ + //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let cypher_block_intermediate = sea_128_encrypt(&key, &plaintext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, cypher_block_intermediate)?; output.append(cypher_block.as_mut()); @@ -101,18 +97,14 @@ pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); let mut output: Vec = vec![]; - assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); + //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); for chunk in input_chunks { - eprintln!("chunk: {:001X?}", &chunk); let cyphertext_intermediate = xor_bytes(&tweak_block.0, chunk)?; - eprintln!("key: {:001X?}", &key); - eprintln!("key2: {:001X?}", &key2); - eprintln!("plain: {:001X?}", &cyphertext_intermediate); - eprintln!("tweak_block: {:001X?}", &tweak_block.0); + /* assert!( cyphertext_intermediate.len() % 16 == 0, "Failure: plaintext_intermediate len was {}", @@ -120,6 +112,7 @@ pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result ); assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); + */ let plaintext_block_intermediate = sea_128_decrypt(&key, &cyphertext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, plaintext_block_intermediate)?; output.append(cypher_block.as_mut()); diff --git a/test_json/kauma_tests.json b/test_json/kauma_tests.json index 26f47f0..ccc994a 100644 --- a/test_json/kauma_tests.json +++ b/test_json/kauma_tests.json @@ -1,29 +1,29 @@ { "testcases": { "254eaee7-05fd-4e0d-8292-9b658a852245": { - "action": "gfmul", - "arguments": { - "semantic": "xex", - "a": "ARIAAAAAAAAAAAAAAAAAgA==", - "b": "AgAAAAAAAAAAAAAAAAAAAA==" - } - }, - "b8f6d760-023d-4b00-bad2-15d2b6da22fe": { - "action": "sea128", - "arguments": { - "mode": "encrypt", - "key": "istDASeincoolerKEYrofg==", - "input": "yv66vvrO263eyviIiDNEVQ==" - } - }, - "254eaee7-05fd-4e0d-8292-9b658b852245": { - "action": "sea128", - "arguments": { - "mode": "decrypt", - "key": "istDASeincoolerKEYrofg==", - "input": "D5FDo3iVBoBN9gVi9/MSKQ==" - } - }, + "action": "gfmul", + "arguments": { + "semantic": "xex", + "a": "ARIAAAAAAAAAAAAAAAAAgA==", + "b": "AgAAAAAAAAAAAAAAAAAAAA==" + } + }, + "b8f6d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "sea128", + "arguments": { + "mode": "encrypt", + "key": "istDASeincoolerKEYrofg==", + "input": "yv66vvrO263eyviIiDNEVQ==" + } + }, + "254eaee7-05fd-4e0d-8292-9b658b852245": { + "action": "sea128", + "arguments": { + "mode": "decrypt", + "key": "istDASeincoolerKEYrofg==", + "input": "D5FDo3iVBoBN9gVi9/MSKQ==" + } + }, "b856d760-023d-4b00-bad2-15d2b6da22fe": { "action": "block2poly", "arguments": { @@ -42,7 +42,32 @@ 0 ] } + }, + "0192d428-3913-762b-a702-d14828eae1f8": { + "action": "xex", + "arguments": { + "mode": "encrypt", + "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=", + "tweak": "6VXORr+YYHrd2nVe0OlA+Q==", + "input": "/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW" + } + }, + "0192d428-3913-7168-a3bb-69c258c74dc1": { + "action": "xex", + "arguments": { + "mode": "decrypt", + "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=", + "tweak": "6VXORr+YYHrd2nVe0OlA+Q==", + "input": "lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a" + } + }, + "0192d428-3913-78b5-9b35-3171c1c85484": { + "action": "gfmul", + "arguments": { + "semantic": "xex", + "a": "ARIAAAAAAAAAAAAAAAAAgA==", + "b": "AgAAAAAAAAAAAAAAAAAAAA==" + } } } - } diff --git a/test_json/xex_tests.json b/test_json/xex_tests.json new file mode 100644 index 0000000..d8673a4 --- /dev/null +++ b/test_json/xex_tests.json @@ -0,0 +1,22 @@ +{ + "testcases": { + "0192d428-3913-762b-a702-d14828eae1f8": { + "action": "xex", + "arguments": { + "mode": "encrypt", + "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=", + "tweak": "6VXORr+YYHrd2nVe0OlA+Q==", + "input": "/aOg4jMocLkBLkDLgkHYtFKc2L9jjyd2WXSSyxXQikpMY9ZRnsJE76e9dW9olZIW" + } + }, + "0192d428-3913-7168-a3bb-69c258c74dc1": { + "action": "xex", + "arguments": { + "mode": "decrypt", + "key": "B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=", + "tweak": "6VXORr+YYHrd2nVe0OlA+Q==", + "input": "lr/ItaYGFXCtHhdPndE65yg7u/GIdM9wscABiiFOUH2Sbyc2UFMlIRSMnZrYCW1a" + } + } + } +} From f4c49a913779ff17265e180e52018be78a8b3bfd Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Tue, 29 Oct 2024 13:53:10 +0100 Subject: [PATCH 011/105] refactor: externalise gfmul to make it more accessible and semantic support --- src/tasks/mod.rs | 10 ++----- src/tasks/tasks01/gfmul.rs | 51 +++++++++-------------------------- src/utils/ciphers.rs | 4 +-- src/utils/math.rs | 55 +++++++++++++++++++++++++++----------- src/utils/poly.rs | 40 ++++++++++++++++++++++++++- 5 files changed, 96 insertions(+), 64 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 13f27d8..0e0f3c3 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -5,7 +5,7 @@ use std::collections::HashMap; use crate::utils::parse::{Responses, Testcase, Testcases}; use tasks01::{ block2poly::block2poly, - gfmul::gfmul, + gfmul::gfmul_task, poly2block::poly2block, sea128::sea128, xex::{self, fde_xex}, @@ -43,13 +43,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } "gfmul" => { - 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)?); + let result = BASE64_STANDARD.encode(gfmul_task(args)?); let json = json!({"product" : result}); Ok(json) } diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 44a032e..58e5afb 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -1,49 +1,24 @@ -use anyhow::Result; -use base64::prelude::*; -//use num_bigint::{BigUint, ToBigUint}; -use serde_json::Value; - use crate::utils::{ math::ByteArray, - poly::{b64_2_num, coefficient_to_binary}, + poly::{b64_2_num, coefficient_to_binary, gfmul}, }; -pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; +use anyhow::Result; +use base64::prelude::*; +use serde_json::Value; -pub fn gfmul(poly_a: Vec, poly_b: Vec) -> Result> { - let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); - red_poly_bytes.0.push(0x01); +pub fn gfmul_task(args: &Value) -> Result> { + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; - let mut poly1: ByteArray = ByteArray(poly_a); - poly1.0.push(0x00); + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; - let mut poly2: ByteArray = ByteArray(poly_b); - poly2.0.push(0x00); + let semantic: String = serde_json::from_value(args["semantic"].clone())?; - let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + let result = gfmul(poly_a, poly_b, &semantic)?; - if poly2.LSB_is_one() { - result.xor_byte_arrays(&poly1); - poly2.right_shift(); - } else { - poly2.right_shift(); - } - - while !poly2.is_empty() { - if poly2.LSB_is_one() { - poly1.left_shift(); - poly1.xor_byte_arrays(&red_poly_bytes); - result.xor_byte_arrays(&poly1); - } else { - poly1.left_shift(); - poly1.xor_byte_arrays(&red_poly_bytes); - } - poly2.right_shift(); - } - - result.0.remove(16); - - Ok(result.0) + Ok(result) } #[cfg(test)] @@ -64,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)?); + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b, "xex")?); assert_eq!( result, "hSQAAAAAAAAAAAAAAAAAAA==", diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index ec1b467..6ffa52a 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -83,7 +83,7 @@ pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result let cypher_block_intermediate = sea_128_encrypt(&key, &plaintext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, cypher_block_intermediate)?; output.append(cypher_block.as_mut()); - tweak_block.left_shift_reduce(); + tweak_block.left_shift_reduce("xex"); } Ok(output) @@ -116,7 +116,7 @@ pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result let plaintext_block_intermediate = sea_128_decrypt(&key, &cyphertext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, plaintext_block_intermediate)?; output.append(cypher_block.as_mut()); - tweak_block.left_shift_reduce(); + tweak_block.left_shift_reduce("xex"); } Ok(output) diff --git a/src/utils/math.rs b/src/utils/math.rs index 82b2c61..5fb6a35 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -1,7 +1,7 @@ -use anyhow::{Ok, Result}; +use anyhow::{anyhow, Ok, Result}; use base64::Engine; -use crate::tasks::tasks01::gfmul::gfmul; +use super::poly::gfmul; pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) { @@ -25,21 +25,46 @@ impl ByteArray { carry } - pub fn left_shift_reduce(&mut self) { - let alpha_poly: Vec = base64::prelude::BASE64_STANDARD - .decode("AgAAAAAAAAAAAAAAAAAAAA==") - .expect("Decode failed"); - self.0 = gfmul(self.0.clone(), alpha_poly).unwrap(); + pub fn left_shift_reduce(&mut self, semantic: &str) { + match semantic { + "xex" => { + let alpha_poly: Vec = base64::prelude::BASE64_STANDARD + .decode("AgAAAAAAAAAAAAAAAAAAAA==") + .expect("Decode failed"); + 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.clone(), alpha_poly, "gcm").unwrap(); + } + _ => {} + } } - pub fn right_shift(&mut self) -> u8 { - let mut carry = 0u8; - for byte in self.0.iter_mut().rev() { - let new_carry = *byte & 1; - *byte = (*byte >> 1) | (carry << 7); - carry = new_carry; + pub fn right_shift(&mut self, semantic: &str) -> Result { + match semantic { + "xex" => { + let mut carry = 0u8; + for byte in self.0.iter_mut().rev() { + let new_carry = *byte & 1; + *byte = (*byte >> 1) | (carry << 7); + carry = new_carry; + } + Ok(carry) + } + "gcm" => { + let mut carry = 0u8; + for byte in self.0.iter_mut().rev() { + let new_carry = *byte & 1; + *byte = (*byte << 1) | carry; + carry = new_carry; + } + Ok(carry) + } + _ => Err(anyhow!("Failure in rsh. No valid semantic found")), } - carry } pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) { @@ -94,7 +119,7 @@ mod tests { fn test_byte_array_shift_right() { let mut byte_array: ByteArray = ByteArray(vec![0x02]); let shifted_array: ByteArray = ByteArray(vec![0x01]); - byte_array.right_shift(); + byte_array.right_shift("xex"); assert_eq!( byte_array.0, shifted_array.0, diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 3c14e76..74233ed 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,7 +1,45 @@ +use crate::utils::math::ByteArray; use anyhow::Result; use base64::prelude::*; - +use serde_json::Value; use std::{str::FromStr, u128, u8, usize}; +pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; + +pub fn gfmul(poly_a: Vec, 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); + poly1.0.push(0x00); + + let mut poly2: ByteArray = ByteArray(poly_b); + poly2.0.push(0x00); + + let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + + if poly2.LSB_is_one() { + result.xor_byte_arrays(&poly1); + poly2.right_shift(semantic); + } else { + poly2.right_shift(semantic); + } + + while !poly2.is_empty() { + if poly2.LSB_is_one() { + poly1.left_shift(); + poly1.xor_byte_arrays(&red_poly_bytes); + result.xor_byte_arrays(&poly1); + } else { + poly1.left_shift(); + poly1.xor_byte_arrays(&red_poly_bytes); + } + poly2.right_shift(semantic); + } + + result.0.remove(16); + + Ok(result.0) +} pub fn get_alpha_rep(num: u128) -> String { let powers: Vec = get_coefficients(num); From ccf0b03ec0a7a040f18a6aacc6f6b59a33485e5c Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Tue, 29 Oct 2024 14:50:55 +0100 Subject: [PATCH 012/105] feat: add more shifting capabilities for gfmul --- src/utils/math.rs | 64 ++++++++++++++++++++++++++++++++++++++--------- src/utils/poly.rs | 10 ++++---- 2 files changed, 57 insertions(+), 17 deletions(-) diff --git a/src/utils/math.rs b/src/utils/math.rs index 5fb6a35..f0308ba 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -15,14 +15,28 @@ pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { pub struct ByteArray(pub Vec); impl ByteArray { - pub fn left_shift(&mut self) -> u8 { - let mut carry = 0u8; - for byte in self.0.iter_mut() { - let new_carry = *byte >> 7; - *byte = (*byte << 1) | carry; - carry = new_carry; + pub fn left_shift(&mut self, semantic: &str) -> Result { + match semantic { + "xex" => { + let mut carry = 0u8; + for byte in self.0.iter_mut() { + let new_carry = *byte >> 7; + *byte = (*byte << 1) | carry; + carry = new_carry; + } + Ok(carry) + } + "gcm" => { + let mut carry = 0u8; + for byte in self.0.iter_mut() { + let new_carry = *byte & 1; + *byte = (*byte >> 1) | (carry << 7); + carry = new_carry; + } + Ok(carry) + } + _ => Err(anyhow!("Failure in lsh. No compatible action found")), } - carry } pub fn left_shift_reduce(&mut self, semantic: &str) { @@ -97,7 +111,7 @@ mod tests { 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(); + byte_array.left_shift("xex"); assert_eq!(byte_array.0, shifted_array.0); } @@ -106,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(); + byte_array.left_shift("xex"); assert_eq!( byte_array.0, shifted_array.0, @@ -115,6 +129,32 @@ mod tests { ); } + #[test] + fn test_byte_array_shift1_gcm() { + let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); + let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]); + byte_array.left_shift("gcm"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:02X?}", + byte_array.0 + ); + } + + #[test] + fn test_byte_array_shift1_right_gcm() { + let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); + let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]); + byte_array.right_shift("gcm"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:02X?}", + byte_array.0 + ); + } + #[test] fn test_byte_array_shift_right() { let mut byte_array: ByteArray = ByteArray(vec![0x02]); @@ -130,13 +170,13 @@ mod tests { #[test] fn test_lsb_one() { - let mut byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]); + let byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]); assert!(!byte_array.LSB_is_one()); - let mut byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]); + let byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]); assert!(!byte_array2.LSB_is_one()); - let mut byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]); + let byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]); assert!(byte_array3.LSB_is_one()); } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 74233ed..5b6fb9a 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -19,21 +19,21 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result if poly2.LSB_is_one() { result.xor_byte_arrays(&poly1); - poly2.right_shift(semantic); + poly2.right_shift(semantic)?; } else { - poly2.right_shift(semantic); + poly2.right_shift(semantic)?; } while !poly2.is_empty() { if poly2.LSB_is_one() { - poly1.left_shift(); + poly1.left_shift(semantic)?; poly1.xor_byte_arrays(&red_poly_bytes); result.xor_byte_arrays(&poly1); } else { - poly1.left_shift(); + poly1.left_shift(semantic)?; poly1.xor_byte_arrays(&red_poly_bytes); } - poly2.right_shift(semantic); + poly2.right_shift(semantic)?; } result.0.remove(16); From 6d808aef548ab629c63f652ae5535131cdadc338 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Tue, 29 Oct 2024 20:22:02 +0100 Subject: [PATCH 013/105] chore: debug official ci --- src/main.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main.rs b/src/main.rs index 5816ecb..59e561b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,6 +3,8 @@ use std::{ fs, }; +// TESTING + use anyhow::Result; fn main() -> Result<()> { From 2e22bd5789de7d27cf38c04793ac270bd037f5a7 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Wed, 30 Oct 2024 17:57:24 +0100 Subject: [PATCH 014/105] refactor: fix broken gfmil algo --- src/tasks/tasks01/gfmul.rs | 60 ++++++++++++++++++++++++++++++++++++++ src/utils/math.rs | 4 +++ src/utils/poly.rs | 18 ++++++------ 3 files changed, 73 insertions(+), 9 deletions(-) diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 58e5afb..0ca5480 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -48,4 +48,64 @@ mod tests { ); Ok(()) } + + #[test] + fn gfmul_task02() -> Result<()> { + let args: Value = json!({"a": "AwEAAAAAAAAAAAAAAAAAgA==", "b": "gBAAAAAAAAAAAAAAAAAAAA=="}); + + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; + + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; + + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b, "xex")?); + + assert_eq!( + result, "QKgUAAAAAAAAAAAAAAAAAA==", + "Failure. Calulated result was: {}", + result + ); + Ok(()) + } + + #[test] + fn gfmul_task03() -> Result<()> { + let args: Value = json!({"a": "AwEAAAAAAAAAAAAAAAAAgA==", "b": "oBAAAAAAAAAAAAAAAAAAAA=="}); + + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; + + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; + + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b, "xex")?); + + assert_eq!( + result, "UIAUAAAAAAAAAAAAAAAAAA==", + "Failure. Calulated result was: {}", + result + ); + Ok(()) + } + + #[test] + fn gfmul_task04() -> Result<()> { + let args: Value = json!({"a": "ARIAAAAAAAAAAAAAAAAAgA==", "b": "AgAAAAAAAAAAAAAAAAAAAA=="}); + + let poly1_text: String = serde_json::from_value(args["a"].clone())?; + let poly_a = BASE64_STANDARD.decode(poly1_text)?; + + let poly2_text: String = serde_json::from_value(args["b"].clone())?; + let poly_b = BASE64_STANDARD.decode(poly2_text)?; + + let result = BASE64_STANDARD.encode(gfmul(poly_a, poly_b, "xex")?); + + assert_eq!( + result, "hSQAAAAAAAAAAAAAAAAAAA==", + "Failure. Calulated result was: {}", + result + ); + Ok(()) + } } diff --git a/src/utils/math.rs b/src/utils/math.rs index f0308ba..98836a9 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -92,6 +92,10 @@ impl ByteArray { (self.0.first().unwrap() & 1) == 1 } + pub fn msb_is_one(&self) -> bool { + (self.0.last().unwrap() & 1) == 1 + } + pub fn is_empty(&self) -> bool { for i in self.0.iter() { if *i != 0 { diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 5b6fb9a..82336d7 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -19,20 +19,20 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result if poly2.LSB_is_one() { result.xor_byte_arrays(&poly1); - poly2.right_shift(semantic)?; - } else { - poly2.right_shift(semantic)?; } + poly2.right_shift(semantic)?; while !poly2.is_empty() { - if poly2.LSB_is_one() { - poly1.left_shift(semantic)?; - poly1.xor_byte_arrays(&red_poly_bytes); - result.xor_byte_arrays(&poly1); - } else { - poly1.left_shift(semantic)?; + poly1.left_shift(semantic)?; + + if poly1.msb_is_one() { poly1.xor_byte_arrays(&red_poly_bytes); } + + if poly2.LSB_is_one() { + result.xor_byte_arrays(&poly1); + } + poly2.right_shift(semantic)?; } From 28a8753d55705cad15a4e809590e629529f73214 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Wed, 30 Oct 2024 18:00:09 +0100 Subject: [PATCH 015/105] feat: add test case for XEX empty --- src/utils/ciphers.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 6ffa52a..a9548e8 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -167,4 +167,17 @@ mod tests { Ok(()) } + + #[test] + fn test_xex_encrypt_empty_case() -> Result<()> { + let key = BASE64_STANDARD.decode("B1ygNO/CyRYIUYhTSgoUysX5Y/wWLi4UiWaVeloUWs0=")?; + let tweak = BASE64_STANDARD.decode("6VXORr+YYHrd2nVe0OlA+Q==")?; + let input = BASE64_STANDARD.decode("")?; + + let output = BASE64_STANDARD.encode(xex_encrypt(key, &tweak, &input)?); + + assert_eq!(output, ""); + + Ok(()) + } } From 8db0bbaa63d89c35651f9720c82cbbde5673a25a Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Fri, 1 Nov 2024 21:20:46 +0100 Subject: [PATCH 016/105] feat: add gcm semantic to b2p and p2b --- src/tasks/mod.rs | 2 +- src/tasks/tasks01/block2poly.rs | 24 +++- src/tasks/tasks01/gfmul.rs | 2 +- src/tasks/tasks01/poly2block.rs | 11 +- src/utils/ciphers.rs | 2 +- src/utils/field.rs | 198 ++++++++++++++++++++++++++++++++ src/utils/math.rs | 194 ------------------------------- src/utils/mod.rs | 1 + src/utils/poly.rs | 71 +++++++++++- 9 files changed, 299 insertions(+), 206 deletions(-) create mode 100644 src/utils/field.rs diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 0e0f3c3..168747e 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -27,7 +27,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result { match testcase.action.as_str() { "poly2block" => { - let result = poly2block(args); + let result = BASE64_STANDARD.encode(poly2block(args)?); let json = json!({"block" : result}); Ok(json) } diff --git a/src/tasks/tasks01/block2poly.rs b/src/tasks/tasks01/block2poly.rs index 69b564f..dbdaf66 100644 --- a/src/tasks/tasks01/block2poly.rs +++ b/src/tasks/tasks01/block2poly.rs @@ -1,15 +1,17 @@ -use crate::utils::poly::{b64_2_num, get_coefficients}; +use crate::utils::poly::{b64_2_num, block_2_polynomial, get_coefficients}; use anyhow::Result; +use base64::prelude::*; use serde_json::Value; pub fn block2poly(val: &Value) -> Result> { // Convert JSON data in to a u128 // TODO: Transfer decoding into own function? let string: String = serde_json::from_value(val["block"].clone())?; + let block = BASE64_STANDARD.decode(string)?; - let number = b64_2_num(&string)?; + let semantic: String = serde_json::from_value(val["semantic"].clone())?; - let coefficients: Vec = get_coefficients(number); + let coefficients: Vec = block_2_polynomial(block, &semantic)?; //get_coefficients(number); Ok(coefficients) } @@ -24,7 +26,7 @@ mod tests { #[test] fn block2poly_task01() -> Result<()> { - let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA=="}); + let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "xex"}); let coefficients: Vec = vec![0, 9, 12, 127]; assert_eq!( block2poly(&block)?, @@ -35,4 +37,18 @@ mod tests { Ok(()) } + + #[test] + fn block2poly_task02() -> Result<()> { + let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "gcm"}); + let coefficients: Vec = vec![7, 11, 14, 120]; + assert_eq!( + block2poly(&block)?, + coefficients, + "Coefficients were: {:?}", + block2poly(&block)? + ); + + Ok(()) + } } diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 0ca5480..c4acefe 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -1,5 +1,5 @@ use crate::utils::{ - math::ByteArray, + field::ByteArray, poly::{b64_2_num, coefficient_to_binary, gfmul}, }; diff --git a/src/tasks/tasks01/poly2block.rs b/src/tasks/tasks01/poly2block.rs index 0c958a8..293d1c3 100644 --- a/src/tasks/tasks01/poly2block.rs +++ b/src/tasks/tasks01/poly2block.rs @@ -1,8 +1,9 @@ -use crate::utils::poly::{self}; +use crate::utils::poly::{self, polynomial_2_block}; +use anyhow::{Ok, Result}; use base64::prelude::*; use serde_json::Value; -pub fn poly2block(args: &Value) -> String { +pub fn poly2block(args: &Value) -> Result> { let coefficients: Vec = args["coefficients"] .as_array() .unwrap() @@ -10,5 +11,9 @@ pub fn poly2block(args: &Value) -> String { .map(|x| x.as_u64().unwrap() as u8) .collect(); - BASE64_STANDARD.encode(poly::coefficient_to_binary(coefficients).to_ne_bytes()) + let semantic: String = serde_json::from_value(args["semantic"].clone())?; + + let result = polynomial_2_block(coefficients, &semantic).unwrap(); + + Ok(result) } diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index a9548e8..885b1c3 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -3,7 +3,7 @@ use std::io::BufRead; use anyhow::Result; use openssl::symm::{Cipher, Crypter, Mode}; -use crate::utils::math::ByteArray; +use crate::utils::field::ByteArray; use super::math::xor_bytes; diff --git a/src/utils/field.rs b/src/utils/field.rs new file mode 100644 index 0000000..afa9b06 --- /dev/null +++ b/src/utils/field.rs @@ -0,0 +1,198 @@ +use anyhow::{anyhow, Ok, Result}; +use base64::Engine; + +use super::poly::gfmul; + +#[derive(Debug)] +pub struct ByteArray(pub Vec); + +impl ByteArray { + pub fn left_shift(&mut self, semantic: &str) -> Result { + match semantic { + "xex" => { + let mut carry = 0u8; + for byte in self.0.iter_mut() { + let new_carry = *byte >> 7; + *byte = (*byte << 1) | carry; + carry = new_carry; + } + Ok(carry) + } + "gcm" => { + let mut carry = 0u8; + for byte in self.0.iter_mut() { + let new_carry = *byte & 1; + *byte = (*byte >> 1) | (carry << 7); + carry = new_carry; + } + Ok(carry) + } + _ => Err(anyhow!("Failure in lsh. No compatible action found")), + } + } + + pub fn left_shift_reduce(&mut self, semantic: &str) { + match semantic { + "xex" => { + let alpha_poly: Vec = base64::prelude::BASE64_STANDARD + .decode("AgAAAAAAAAAAAAAAAAAAAA==") + .expect("Decode failed"); + 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.clone(), alpha_poly, "gcm").unwrap(); + } + _ => {} + } + } + + pub fn right_shift(&mut self, semantic: &str) -> Result { + match semantic { + "xex" => { + let mut carry = 0u8; + for byte in self.0.iter_mut().rev() { + let new_carry = *byte & 1; + *byte = (*byte >> 1) | (carry << 7); + carry = new_carry; + } + Ok(carry) + } + "gcm" => { + let mut carry = 0u8; + for byte in self.0.iter_mut().rev() { + let new_carry = *byte & 1; + *byte = (*byte << 1) | carry; + carry = new_carry; + } + Ok(carry) + } + _ => Err(anyhow!("Failure in rsh. No valid semantic found")), + } + } + + pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) { + self.0 + .iter_mut() + .zip(vec2.0.iter()) + .for_each(|(x1, x2)| *x1 ^= *x2); + } + + pub fn LSB_is_one(&self) -> bool { + (self.0.first().unwrap() & 1) == 1 + } + + pub fn msb_is_one(&self) -> bool { + (self.0.last().unwrap() & 1) == 1 + } + + pub fn is_empty(&self) -> bool { + for i in self.0.iter() { + if *i != 0 { + return false; + } + } + true + } +} + +#[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"); + + assert_eq!(byte_array.0, shifted_array.0); + } + + #[test] + fn test_byte_array_shift2() { + let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); + let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]); + byte_array.left_shift("xex"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:?}", + byte_array.0 + ); + } + + #[test] + fn test_byte_array_shift1_gcm() { + let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); + let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]); + byte_array.left_shift("gcm"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:02X?}", + byte_array.0 + ); + } + + #[test] + fn test_byte_array_shift1_right_gcm() { + let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); + let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]); + byte_array.right_shift("gcm"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:02X?}", + byte_array.0 + ); + } + + #[test] + fn test_byte_array_shift_right() { + let mut byte_array: ByteArray = ByteArray(vec![0x02]); + let shifted_array: ByteArray = ByteArray(vec![0x01]); + byte_array.right_shift("xex"); + + assert_eq!( + byte_array.0, shifted_array.0, + "Failure: Shifted array was: {:?}", + byte_array.0 + ); + } + + #[test] + fn test_lsb_one() { + let byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]); + assert!(!byte_array.LSB_is_one()); + + let byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]); + assert!(!byte_array2.LSB_is_one()); + + let byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]); + assert!(byte_array3.LSB_is_one()); + } + + #[test] + fn test_byte_xor() { + let mut byte_array: ByteArray = ByteArray(vec![0x25, 0x25]); + let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]); + + byte_array.xor_byte_arrays(&byte_array2); + + assert_eq!(byte_array.0, vec![0x70, 0x70]); + } + + #[test] + fn test_byte_xor2() { + let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x00]); + let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]); + + byte_array.xor_byte_arrays(&byte_array2); + + assert_eq!(byte_array.0, vec![0x55, 0x55]); + } +} diff --git a/src/utils/math.rs b/src/utils/math.rs index 98836a9..4021522 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -10,197 +10,3 @@ pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { Ok(vec2) } - -#[derive(Debug)] -pub struct ByteArray(pub Vec); - -impl ByteArray { - pub fn left_shift(&mut self, semantic: &str) -> Result { - match semantic { - "xex" => { - let mut carry = 0u8; - for byte in self.0.iter_mut() { - let new_carry = *byte >> 7; - *byte = (*byte << 1) | carry; - carry = new_carry; - } - Ok(carry) - } - "gcm" => { - let mut carry = 0u8; - for byte in self.0.iter_mut() { - let new_carry = *byte & 1; - *byte = (*byte >> 1) | (carry << 7); - carry = new_carry; - } - Ok(carry) - } - _ => Err(anyhow!("Failure in lsh. No compatible action found")), - } - } - - pub fn left_shift_reduce(&mut self, semantic: &str) { - match semantic { - "xex" => { - let alpha_poly: Vec = base64::prelude::BASE64_STANDARD - .decode("AgAAAAAAAAAAAAAAAAAAAA==") - .expect("Decode failed"); - 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.clone(), alpha_poly, "gcm").unwrap(); - } - _ => {} - } - } - - pub fn right_shift(&mut self, semantic: &str) -> Result { - match semantic { - "xex" => { - let mut carry = 0u8; - for byte in self.0.iter_mut().rev() { - let new_carry = *byte & 1; - *byte = (*byte >> 1) | (carry << 7); - carry = new_carry; - } - Ok(carry) - } - "gcm" => { - let mut carry = 0u8; - for byte in self.0.iter_mut().rev() { - let new_carry = *byte & 1; - *byte = (*byte << 1) | carry; - carry = new_carry; - } - Ok(carry) - } - _ => Err(anyhow!("Failure in rsh. No valid semantic found")), - } - } - - pub fn xor_byte_arrays(&mut self, vec2: &ByteArray) { - self.0 - .iter_mut() - .zip(vec2.0.iter()) - .for_each(|(x1, x2)| *x1 ^= *x2); - } - - pub fn LSB_is_one(&self) -> bool { - (self.0.first().unwrap() & 1) == 1 - } - - pub fn msb_is_one(&self) -> bool { - (self.0.last().unwrap() & 1) == 1 - } - - pub fn is_empty(&self) -> bool { - for i in self.0.iter() { - if *i != 0 { - return false; - } - } - true - } -} - -#[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"); - - assert_eq!(byte_array.0, shifted_array.0); - } - - #[test] - fn test_byte_array_shift2() { - let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); - let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]); - byte_array.left_shift("xex"); - - assert_eq!( - byte_array.0, shifted_array.0, - "Failure: Shifted array was: {:?}", - byte_array.0 - ); - } - - #[test] - fn test_byte_array_shift1_gcm() { - let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); - let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]); - byte_array.left_shift("gcm"); - - assert_eq!( - byte_array.0, shifted_array.0, - "Failure: Shifted array was: {:02X?}", - byte_array.0 - ); - } - - #[test] - fn test_byte_array_shift1_right_gcm() { - let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); - let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]); - byte_array.right_shift("gcm"); - - assert_eq!( - byte_array.0, shifted_array.0, - "Failure: Shifted array was: {:02X?}", - byte_array.0 - ); - } - - #[test] - fn test_byte_array_shift_right() { - let mut byte_array: ByteArray = ByteArray(vec![0x02]); - let shifted_array: ByteArray = ByteArray(vec![0x01]); - byte_array.right_shift("xex"); - - assert_eq!( - byte_array.0, shifted_array.0, - "Failure: Shifted array was: {:?}", - byte_array.0 - ); - } - - #[test] - fn test_lsb_one() { - let byte_array: ByteArray = ByteArray(vec![0x00, 0xFF]); - assert!(!byte_array.LSB_is_one()); - - let byte_array2: ByteArray = ByteArray(vec![0x02, 0xFF]); - assert!(!byte_array2.LSB_is_one()); - - let byte_array3: ByteArray = ByteArray(vec![0xFF, 0x00]); - assert!(byte_array3.LSB_is_one()); - } - - #[test] - fn test_byte_xor() { - let mut byte_array: ByteArray = ByteArray(vec![0x25, 0x25]); - let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]); - - byte_array.xor_byte_arrays(&byte_array2); - - assert_eq!(byte_array.0, vec![0x70, 0x70]); - } - - #[test] - fn test_byte_xor2() { - let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x00]); - let byte_array2: ByteArray = ByteArray(vec![0x55, 0x55]); - - byte_array.xor_byte_arrays(&byte_array2); - - assert_eq!(byte_array.0, vec![0x55, 0x55]); - } -} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index fcbb75b..2f12ed4 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,4 +1,5 @@ pub mod ciphers; +pub mod field; pub mod math; pub mod parse; pub mod poly; diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 82336d7..ec316a4 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,8 +1,10 @@ -use crate::utils::math::ByteArray; -use anyhow::Result; +use crate::utils::field::ByteArray; +use anyhow::{anyhow, Result}; use base64::prelude::*; use serde_json::Value; use std::{str::FromStr, u128, u8, usize}; + +use super::field; pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result> { @@ -41,6 +43,15 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result Ok(result.0) } +pub fn convert_gcm_to_xex(gcm_poly: Vec) -> Result> { + let xex_poly = gcm_poly + .into_iter() + .map(|block| block.reverse_bits()) + .collect(); + + Ok(xex_poly) +} + pub fn get_alpha_rep(num: u128) -> String { let powers: Vec = get_coefficients(num); @@ -92,6 +103,62 @@ pub fn get_bit_indices_from_byte(byte: u8) -> Vec { coefficients } +pub fn block_2_polynomial(block: Vec, semantic: &str) -> Result> { + let mut output: Vec = vec![]; + match semantic { + "xex" => { + for i in 0u8..=15 { + for j in 0u8..=7 { + if (block[i as usize] >> j) & 1 == 1 { + output.push(8 * i + j); + } + } + } + output.sort(); + Ok(output) + } + "gcm" => { + for i in 0u8..=15 { + for j in 0u8..=7 { + if (block[i as usize] >> j) & 1 == 1 { + output.push(8 * i + 7 - j); + } + } + } + output.sort(); + Ok(output) + } + _ => Err(anyhow!("Error in b2p")), + } +} + +pub fn polynomial_2_block(coefficients: Vec, semantic: &str) -> Result> { + let mut output: Vec = Vec::with_capacity(16); + output.resize(16, 0); + + match semantic { + "xex" => { + for coefficient in coefficients { + let byte_position = coefficient / 8; + let bit_position = coefficient % 8; + + output[byte_position as usize] ^= 1 << bit_position; + } + Ok(output) + } + "gcm" => { + for coefficient in coefficients { + let byte_position = coefficient / 8; + let bit_position = coefficient % 8; + + output[byte_position as usize] ^= 1 << 7 - bit_position; + } + Ok(output) + } + _ => Err(anyhow!("Error in b2p")), + } +} + 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 { From e33a26adab062b873f9a34fd6199f822d01e92fd Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 3 Nov 2024 10:58:52 +0100 Subject: [PATCH 017/105] feat: gfmul and aes gcm working --- src/utils/ciphers.rs | 116 ++++++++++++++++++++++++++++++++++++++++++- src/utils/field.rs | 4 ++ src/utils/math.rs | 6 +++ src/utils/poly.rs | 17 +++++-- 4 files changed, 137 insertions(+), 6 deletions(-) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 885b1c3..8b5e831 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,9 +1,9 @@ -use std::io::BufRead; +use std::{io::BufRead, process::Output}; use anyhow::Result; use openssl::symm::{Cipher, Crypter, Mode}; -use crate::utils::field::ByteArray; +use crate::utils::{field::ByteArray, math::reverse_bits_in_bytevec, poly::gfmul}; use super::math::xor_bytes; @@ -122,6 +122,92 @@ pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result Ok(output) } +pub fn gcm_encrypt_aes( + mut nonce: Vec, + key: Vec, + plaintext: Vec, + ad: Vec, +) -> Result<(Vec, Vec, Vec, Vec)> { + let mut ciphertext: Vec = vec![]; + + let mut counter: u32 = 1; + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); + eprintln!("{:001X?}", nonce); + + let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; + + let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; + + let plaintext_chunks: Vec> = plaintext.chunks(16).map(|x| x.to_vec()).collect(); + + counter = 2; + for chunk in plaintext_chunks { + nonce.drain(12..); + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + + eprintln!("{:001X?}", nonce); + + let inter1 = aes_128_encrypt(&key, &nonce)?; + + let mut inter2 = xor_bytes(&inter1, chunk.clone())?; + + ciphertext.append(inter2.as_mut()); + counter += 1; + } + + let mut l_field: Vec = ((ad.len() * 8) as u64).to_be_bytes().to_vec(); + let mut c_len: Vec = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec(); + l_field.append(c_len.as_mut()); + + let auth_tag = xor_bytes( + &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, + auth_tag_xor, + )?; + + Ok((ciphertext, auth_tag, l_field, auth_key_h)) +} + +pub fn ghash( + auth_key_h: Vec, + mut ad: Vec, + mut ciphertext: Vec, + l_field: Vec, +) -> Result> { + let output: Vec = vec![0; 16]; + + eprintln!("{:?}", (ad.len() % 16) as u8); + eprintln!("{:001X?}", ad); + + if ad.len() % 16 != 0 { + ad.append(vec![0u8; ad.len() % 16].as_mut()); + } + + if ciphertext.len() % 16 != 0 { + ciphertext.append(vec![0u8; ciphertext.len() % 16].as_mut()); + } + + eprintln!("{:001X?}", ad); + eprintln!("{:001X?}", ciphertext); + + let inter1 = xor_bytes(&output, ad)?; + let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?; + + inter_loop = inter_loop; + + let cipher_chunks = ciphertext.chunks(16); + + for chunk in cipher_chunks { + let inter3 = xor_bytes(&inter_loop, chunk.to_vec())?; + inter_loop = gfmul(inter3, auth_key_h.clone(), "gcm")?; + } + + let inter4 = xor_bytes(&inter_loop, l_field)?; + inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?; + + Ok(inter_loop) +} + /* * let mut bytes: [u8; 16] = [0u8; 16]; bytes.copy_from_slice(&ciphertext); @@ -180,4 +266,30 @@ mod tests { Ok(()) } + + #[test] + fn test_gcm_encrypt_aes() -> Result<()> { + let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; + let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?; + let plaintext = BASE64_STANDARD.decode("RGFzIGlzdCBlaW4gVGVzdA==")?; + let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?; + + let (ciphertext, auth_tag, l_field, auth_key_h) = + gcm_encrypt_aes(nonce, key, plaintext, ad)?; + + eprintln!( + "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}", + BASE64_STANDARD.encode(&ciphertext), + BASE64_STANDARD.encode(&auth_tag), + BASE64_STANDARD.encode(&l_field), + BASE64_STANDARD.encode(&auth_key_h) + ); + + assert_eq!(BASE64_STANDARD.encode(ciphertext), ""); + assert_eq!(BASE64_STANDARD.encode(auth_tag), ""); + assert_eq!(BASE64_STANDARD.encode(l_field), ""); + assert_eq!(BASE64_STANDARD.encode(auth_key_h), ""); + + Ok(()) + } } diff --git a/src/utils/field.rs b/src/utils/field.rs index afa9b06..5645b04 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -96,6 +96,10 @@ impl ByteArray { } true } + + pub fn reverse_bits_in_bytevec(&mut self) { + self.0 = self.0.iter_mut().map(|byte| byte.reverse_bits()).collect(); + } } #[cfg(test)] diff --git a/src/utils/math.rs b/src/utils/math.rs index 4021522..cf87e0c 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -10,3 +10,9 @@ pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { Ok(vec2) } + +pub fn reverse_bits_in_bytevec(mut vec: Vec) -> Vec { + vec = vec.iter_mut().map(|byte| byte.reverse_bits()).collect(); + + vec +} diff --git a/src/utils/poly.rs b/src/utils/poly.rs index ec316a4..78889c8 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -4,7 +4,7 @@ use base64::prelude::*; use serde_json::Value; use std::{str::FromStr, u128, u8, usize}; -use super::field; +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> { @@ -17,15 +17,20 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result 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, 0]); if poly2.LSB_is_one() { result.xor_byte_arrays(&poly1); } - poly2.right_shift(semantic)?; + poly2.right_shift("xex")?; while !poly2.is_empty() { - poly1.left_shift(semantic)?; + poly1.left_shift("xex")?; if poly1.msb_is_one() { poly1.xor_byte_arrays(&red_poly_bytes); @@ -35,11 +40,15 @@ pub fn gfmul(poly_a: Vec, poly_b: Vec, semantic: &str) -> Result result.xor_byte_arrays(&poly1); } - poly2.right_shift(semantic)?; + poly2.right_shift("xex")?; } result.0.remove(16); + if semantic == "gcm" { + result.reverse_bits_in_bytevec(); + } + Ok(result.0) } From 6bef350301186006185ce269e1bd878ce8bcfbba Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 3 Nov 2024 11:20:09 +0100 Subject: [PATCH 018/105] feat: adapt test runner for gcm aes and add test cases --- src/tasks/mod.rs | 39 ++++++++++++++++++++++++++++++++++++-- src/tasks/tasks01/gcm.rs | 26 +++++++++++++++++++++++++ src/tasks/tasks01/mod.rs | 1 + src/utils/ciphers.rs | 14 ++++++++++---- test_json/gcm_encrypt.json | 14 ++++++++++++++ 5 files changed, 88 insertions(+), 6 deletions(-) create mode 100644 src/tasks/tasks01/gcm.rs create mode 100644 test_json/gcm_encrypt.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 168747e..f4eaab3 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -1,10 +1,14 @@ 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_encrypt, gfmul::gfmul_task, poly2block::poly2block, sea128::sea128, @@ -53,6 +57,17 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gcm_encrypt" => { + let (ciphertext, auth_tag, l_field, auth_key_h) = gcm_encrypt(args)?; + let out_ciph = BASE64_STANDARD.encode(&ciphertext); + let out_tag = BASE64_STANDARD.encode(&auth_tag); + let out_l = BASE64_STANDARD.encode(&l_field); + let out_h = BASE64_STANDARD.encode(&auth_key_h); + + let json = json!({"ciphertext" : out_ciph, "tag" : out_tag, "L" : out_l, "H" : out_h}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, @@ -166,4 +181,24 @@ mod tests { Ok(()) } + + #[test] + fn test_task_gcm_encrypt_aes_case() -> Result<()> { + let json = fs::read_to_string("test_json/gcm_encrypt.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : { + "ciphertext": "ET3RmvH/Hbuxba63EuPRrw==", + "tag": "Mp0APJb/ZIURRwQlMgNN/w==", + "L": "AAAAAAAAAEAAAAAAAAAAgA==", + "H": "Bu6ywbsUKlpmZXMQyuGAng==" + }}}); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } } diff --git a/src/tasks/tasks01/gcm.rs b/src/tasks/tasks01/gcm.rs new file mode 100644 index 0000000..4763d53 --- /dev/null +++ b/src/tasks/tasks01/gcm.rs @@ -0,0 +1,26 @@ +use anyhow::{anyhow, Result}; +use base64::prelude::*; +use serde_json::Value; + +use crate::utils::ciphers::gcm_encrypt_aes; + +pub fn gcm_encrypt(args: &Value) -> Result<(Vec, Vec, Vec, Vec)> { + let nonce_text: String = serde_json::from_value(args["nonce"].clone())?; + let nonce = BASE64_STANDARD.decode(nonce_text)?; + + let key_text: String = serde_json::from_value(args["key"].clone())?; + let key = BASE64_STANDARD.decode(key_text)?; + + let plaintext_text: String = serde_json::from_value(args["plaintext"].clone())?; + let plaintext = BASE64_STANDARD.decode(plaintext_text)?; + + let ad_text: String = serde_json::from_value(args["ad"].clone())?; + let ad = BASE64_STANDARD.decode(ad_text)?; + + let alg_text: String = serde_json::from_value(args["algorithm"].clone())?; + + match alg_text.as_str() { + "aes128" => Ok(gcm_encrypt_aes(nonce, key, plaintext, ad)?), + _ => Err(anyhow!("No compatible algorithm found")), + } +} diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs index 97ea4d7..d1f3e99 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -1,4 +1,5 @@ pub mod block2poly; +pub mod gcm; pub mod gfmul; pub mod poly2block; pub mod sea128; diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 8b5e831..2be30fb 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -285,10 +285,16 @@ mod tests { BASE64_STANDARD.encode(&auth_key_h) ); - assert_eq!(BASE64_STANDARD.encode(ciphertext), ""); - assert_eq!(BASE64_STANDARD.encode(auth_tag), ""); - assert_eq!(BASE64_STANDARD.encode(l_field), ""); - assert_eq!(BASE64_STANDARD.encode(auth_key_h), ""); + assert_eq!( + BASE64_STANDARD.encode(ciphertext), + "ET3RmvH/Hbuxba63EuPRrw==" + ); + assert_eq!(BASE64_STANDARD.encode(auth_tag), "Mp0APJb/ZIURRwQlMgNN/w=="); + assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAEAAAAAAAAAAgA=="); + assert_eq!( + BASE64_STANDARD.encode(auth_key_h), + "Bu6ywbsUKlpmZXMQyuGAng==" + ); Ok(()) } diff --git a/test_json/gcm_encrypt.json b/test_json/gcm_encrypt.json new file mode 100644 index 0000000..347475e --- /dev/null +++ b/test_json/gcm_encrypt.json @@ -0,0 +1,14 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "gcm_encrypt", + "arguments": { + "algorithm": "aes128", + "nonce": "4gF+BtR3ku/PUQci", + "key": "Xjq/GkpTSWoe3ZH0F+tjrQ==", + "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==", + "ad": "QUQtRGF0ZW4=" + } + } + } +} From 6b2775cde1764125a9ed779ca0a5f71f2dc08028 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 3 Nov 2024 14:12:48 +0100 Subject: [PATCH 019/105] feat: add aes/sea encrypt/decrypt in gcm and add test cases --- src/tasks/mod.rs | 66 ++++++++- src/tasks/tasks01/gcm.rs | 28 +++- src/utils/ciphers.rs | 242 ++++++++++++++++++++++++++++++++- test_json/gcm_decrypt_aes.json | 14 ++ test_json/gcm_decrypt_sea.json | 14 ++ test_json/gcm_encrypt_sea.json | 14 ++ 6 files changed, 373 insertions(+), 5 deletions(-) create mode 100644 test_json/gcm_decrypt_aes.json create mode 100644 test_json/gcm_decrypt_sea.json create mode 100644 test_json/gcm_encrypt_sea.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index f4eaab3..6c003b2 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -8,7 +8,7 @@ use crate::utils::{ }; use tasks01::{ block2poly::block2poly, - gcm::gcm_encrypt, + gcm::{gcm_decrypt, gcm_encrypt}, gfmul::gfmul_task, poly2block::poly2block, sea128::sea128, @@ -68,6 +68,14 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gcm_decrypt" => { + let (plaintext, valid) = gcm_decrypt(args)?; + let out_plain = BASE64_STANDARD.encode(&plaintext); + let json = json!({ "authentic" : valid, "plaintext" : out_plain}); + + Ok(json) + } + _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, @@ -201,4 +209,60 @@ mod tests { Ok(()) } + + #[test] + fn test_task_gcm_encrypt_sea_case() -> Result<()> { + let json = fs::read_to_string("test_json/gcm_encrypt_sea.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : { + "ciphertext": "0cI/Wg4R3URfrVFZ0hw/vg==", + "tag": "ysDdzOSnqLH0MQ+Mkb23gw==", + "L": "AAAAAAAAAEAAAAAAAAAAgA==", + "H": "xhFcAUT66qWIpYz+Ch5ujw==" + }}}); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } + + #[test] + fn test_task_gcm_decrypt_aes_case() -> Result<()> { + let json = fs::read_to_string("test_json/gcm_decrypt_aes.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : { + "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==", + "authentic": true, + }}}); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } + + #[test] + fn test_task_gcm_decrypt_sea_case() -> Result<()> { + let json = fs::read_to_string("test_json/gcm_decrypt_sea.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ "responses" : { "b856d760-023d-4b00-bad2-15d2b6da22fe" : { + "plaintext": "RGFzIGlzdCBlaW4gVGVzdA==", + "authentic": true, + }}}); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } } diff --git a/src/tasks/tasks01/gcm.rs b/src/tasks/tasks01/gcm.rs index 4763d53..dd13744 100644 --- a/src/tasks/tasks01/gcm.rs +++ b/src/tasks/tasks01/gcm.rs @@ -2,7 +2,7 @@ use anyhow::{anyhow, Result}; use base64::prelude::*; use serde_json::Value; -use crate::utils::ciphers::gcm_encrypt_aes; +use crate::utils::ciphers::{gcm_decrypt_aes, gcm_decrypt_sea, gcm_encrypt_aes, gcm_encrypt_sea}; pub fn gcm_encrypt(args: &Value) -> Result<(Vec, Vec, Vec, Vec)> { let nonce_text: String = serde_json::from_value(args["nonce"].clone())?; @@ -21,6 +21,32 @@ pub fn gcm_encrypt(args: &Value) -> Result<(Vec, Vec, Vec, Vec)> match alg_text.as_str() { "aes128" => Ok(gcm_encrypt_aes(nonce, key, plaintext, ad)?), + "sea128" => Ok(gcm_encrypt_sea(nonce, key, plaintext, ad)?), + _ => Err(anyhow!("No compatible algorithm found")), + } +} + +pub fn gcm_decrypt(args: &Value) -> Result<(Vec, bool)> { + let nonce_text: String = serde_json::from_value(args["nonce"].clone())?; + let nonce = BASE64_STANDARD.decode(nonce_text)?; + + let key_text: String = serde_json::from_value(args["key"].clone())?; + let key = BASE64_STANDARD.decode(key_text)?; + + let plaintext_text: String = serde_json::from_value(args["ciphertext"].clone())?; + let plaintext = BASE64_STANDARD.decode(plaintext_text)?; + + let ad_text: String = serde_json::from_value(args["ad"].clone())?; + let ad = BASE64_STANDARD.decode(ad_text)?; + + let tag_text: String = serde_json::from_value(args["tag"].clone())?; + let tag = BASE64_STANDARD.decode(tag_text)?; + + let alg_text: String = serde_json::from_value(args["algorithm"].clone())?; + + match alg_text.as_str() { + "aes128" => Ok(gcm_decrypt_aes(nonce, key, plaintext, ad, tag)?), + "sea128" => Ok(gcm_decrypt_sea(nonce, key, plaintext, ad, tag)?), _ => Err(anyhow!("No compatible algorithm found")), } } diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 2be30fb..1485ee6 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,9 +1,9 @@ use std::{io::BufRead, process::Output}; -use anyhow::Result; -use openssl::symm::{Cipher, Crypter, Mode}; - 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; @@ -168,6 +168,158 @@ pub fn gcm_encrypt_aes( Ok((ciphertext, auth_tag, l_field, auth_key_h)) } +pub fn gcm_decrypt_aes( + mut nonce: Vec, + key: Vec, + ciphertext: Vec, + ad: Vec, + tag: Vec, +) -> Result<(Vec, bool)> { + let mut plaintext: Vec = vec![]; + + let mut counter: u32 = 1; + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); + eprintln!("{:001X?}", nonce); + + let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; + + let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; + + let ciphertext_chunks: Vec> = ciphertext.chunks(16).map(|x| x.to_vec()).collect(); + + counter = 2; + for chunk in ciphertext_chunks { + nonce.drain(12..); + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + + eprintln!("{:001X?}", nonce); + + let inter1 = aes_128_encrypt(&key, &nonce)?; + + let mut inter2 = xor_bytes(&inter1, chunk.clone())?; + + plaintext.append(inter2.as_mut()); + counter += 1; + } + + let mut l_field: Vec = ((ad.len() * 8) as u64).to_be_bytes().to_vec(); + let mut c_len: Vec = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec(); + l_field.append(c_len.as_mut()); + + let auth_tag = xor_bytes( + &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, + auth_tag_xor, + )?; + + let valid = auth_tag == tag; + + Ok((plaintext, valid)) +} + +pub fn gcm_encrypt_sea( + mut nonce: Vec, + key: Vec, + plaintext: Vec, + ad: Vec, +) -> Result<(Vec, Vec, Vec, Vec)> { + let mut ciphertext: Vec = vec![]; + + let mut counter: u32 = 1; + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); + eprintln!("{:001X?}", nonce); + + let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; + + let auth_key_h = sea_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; + + let plaintext_chunks: Vec> = plaintext.chunks(16).map(|x| x.to_vec()).collect(); + + counter = 2; + for chunk in plaintext_chunks { + nonce.drain(12..); + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + + eprintln!("{:001X?}", nonce); + + let inter1 = sea_128_encrypt(&key, &nonce)?; + + let mut inter2 = xor_bytes(&inter1, chunk.clone())?; + + ciphertext.append(inter2.as_mut()); + counter += 1; + } + + let mut l_field: Vec = ((ad.len() * 8) as u64).to_be_bytes().to_vec(); + let mut c_len: Vec = ((ciphertext.len() * 8) as u64).to_be_bytes().to_vec(); + l_field.append(c_len.as_mut()); + + let auth_tag = xor_bytes( + &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, + auth_tag_xor, + )?; + + Ok((ciphertext, auth_tag, l_field, auth_key_h)) +} + +pub fn gcm_decrypt_sea( + mut nonce: Vec, + key: Vec, + ciphertext: Vec, + ad: Vec, + tag: Vec, +) -> Result<(Vec, bool)> { + let mut plaintext: Vec = vec![]; + + let mut counter: u32 = 1; + nonce.append(counter.to_be_bytes().to_vec().as_mut()); + //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); + eprintln!("Nonce 1: {:001X?}", nonce); + + let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; + + let auth_key_h = sea_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; + + let plaintext_chunks: Vec> = 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())?; + + plaintext.append(inter2.as_mut()); + counter += 1; + } + + let mut l_field: Vec = ((ad.len() * 8) as u64).to_be_bytes().to_vec(); + 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)) +} + pub fn ghash( auth_key_h: Vec, mut ad: Vec, @@ -205,6 +357,8 @@ pub fn ghash( let inter4 = xor_bytes(&inter_loop, l_field)?; inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?; + eprintln!("GHASH auth tag: {}", BASE64_STANDARD.encode(&inter_loop)); + Ok(inter_loop) } @@ -298,4 +452,86 @@ mod tests { Ok(()) } + + #[test] + fn test_gcm_encrypt_sea() -> Result<()> { + let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; + let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?; + let plaintext = BASE64_STANDARD.decode("RGFzIGlzdCBlaW4gVGVzdA==")?; + let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?; + + let (ciphertext, auth_tag, l_field, auth_key_h) = + gcm_encrypt_sea(nonce, key, plaintext, ad)?; + + eprintln!( + "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}", + BASE64_STANDARD.encode(&ciphertext), + BASE64_STANDARD.encode(&auth_tag), + BASE64_STANDARD.encode(&l_field), + BASE64_STANDARD.encode(&auth_key_h) + ); + + assert_eq!( + BASE64_STANDARD.encode(ciphertext), + "0cI/Wg4R3URfrVFZ0hw/vg==" + ); + assert_eq!(BASE64_STANDARD.encode(auth_tag), "ysDdzOSnqLH0MQ+Mkb23gw=="); + assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAEAAAAAAAAAAgA=="); + assert_eq!( + BASE64_STANDARD.encode(auth_key_h), + "xhFcAUT66qWIpYz+Ch5ujw==" + ); + + Ok(()) + } + + #[test] + fn test_gcm_decrypt_aes() -> Result<()> { + let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; + let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?; + let ciphertext = BASE64_STANDARD.decode("ET3RmvH/Hbuxba63EuPRrw==")?; + let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?; + let tag = BASE64_STANDARD.decode("Mp0APJb/ZIURRwQlMgNN/w==")?; + + let (plaintext, valid) = gcm_decrypt_aes(nonce, key, ciphertext, ad, tag)?; + + eprintln!( + "Cipher: {:001X?} \n Valids: {:001X?}", + BASE64_STANDARD.encode(&plaintext), + &valid, + ); + + assert_eq!( + BASE64_STANDARD.encode(plaintext), + "RGFzIGlzdCBlaW4gVGVzdA==" + ); + assert_eq!(valid, true); + + Ok(()) + } + + #[test] + fn test_gcm_decrypt_sea() -> Result<()> { + let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; + let key = BASE64_STANDARD.decode("Xjq/GkpTSWoe3ZH0F+tjrQ==")?; + let ciphertext = BASE64_STANDARD.decode("0cI/Wg4R3URfrVFZ0hw/vg==")?; + let ad = BASE64_STANDARD.decode("QUQtRGF0ZW4=")?; + let tag = BASE64_STANDARD.decode("ysDdzOSnqLH0MQ+Mkb23gw==")?; + + let (plaintext, valid) = gcm_decrypt_sea(nonce, key, ciphertext, ad, tag)?; + + eprintln!( + "Plaintext: {:001X?} \n Valid: {:001X?}", + BASE64_STANDARD.encode(&plaintext), + &valid, + ); + + assert_eq!( + BASE64_STANDARD.encode(plaintext), + "RGFzIGlzdCBlaW4gVGVzdA==" + ); + assert_eq!(valid, true); + + Ok(()) + } } diff --git a/test_json/gcm_decrypt_aes.json b/test_json/gcm_decrypt_aes.json new file mode 100644 index 0000000..720881d --- /dev/null +++ b/test_json/gcm_decrypt_aes.json @@ -0,0 +1,14 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "gcm_decrypt", +"arguments": { +"algorithm": "aes128", +"nonce": "4gF+BtR3ku/PUQci", +"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==", +"ciphertext": "ET3RmvH/Hbuxba63EuPRrw==", +"ad": "QUQtRGF0ZW4=", +"tag": "Mp0APJb/ZIURRwQlMgNN/w==" +} } + } +} diff --git a/test_json/gcm_decrypt_sea.json b/test_json/gcm_decrypt_sea.json new file mode 100644 index 0000000..c246686 --- /dev/null +++ b/test_json/gcm_decrypt_sea.json @@ -0,0 +1,14 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "gcm_decrypt", +"arguments": { +"algorithm": "sea128", +"nonce": "4gF+BtR3ku/PUQci", +"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==", +"ciphertext": "0cI/Wg4R3URfrVFZ0hw/vg==", +"ad": "QUQtRGF0ZW4=", +"tag": "ysDdzOSnqLH0MQ+Mkb23gw==" +} } + } +} diff --git a/test_json/gcm_encrypt_sea.json b/test_json/gcm_encrypt_sea.json new file mode 100644 index 0000000..6a2a6a5 --- /dev/null +++ b/test_json/gcm_encrypt_sea.json @@ -0,0 +1,14 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "gcm_encrypt", + "arguments": { +"algorithm": "sea128", +"nonce": "4gF+BtR3ku/PUQci", +"key": "Xjq/GkpTSWoe3ZH0F+tjrQ==", +"plaintext": "RGFzIGlzdCBlaW4gVGVzdA==", +"ad": "QUQtRGF0ZW4=" +} + } + } +} From 0d8f1109027c35c754bbb3fe6da8fe48ad4e1b17 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 3 Nov 2024 17:52:40 +0100 Subject: [PATCH 020/105] fix: add handling for larger ad values --- src/utils/ciphers.rs | 97 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 91 insertions(+), 6 deletions(-) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 1485ee6..7fb6e63 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -164,6 +164,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)) } @@ -213,6 +214,7 @@ pub fn gcm_decrypt_aes( )?; let valid = auth_tag == tag; + eprintln!("aes auth tag: {:001X?}", auth_tag); Ok((plaintext, valid)) } @@ -328,24 +330,35 @@ 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.append(vec![0u8; ad.len() % 16].as_mut()); + ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut()); } if ciphertext.len() % 16 != 0 { - ciphertext.append(vec![0u8; ciphertext.len() % 16].as_mut()); + ciphertext.append(vec![0u8; 16 - (ciphertext.len() % 16)].as_mut()); } eprintln!("{:001X?}", ad); eprintln!("{:001X?}", ciphertext); - let inter1 = xor_bytes(&output, ad)?; - let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?; + let mut ad_chunks = ad.chunks(16); - inter_loop = inter_loop; + eprintln!("Ad chunks before first next {:001X?}", ad_chunks); + + let inter1 = xor_bytes(&output, ad_chunks.next().unwrap().to_vec())?; + let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?; + eprintln!("Ad chunks after first next {:001X?}", ad_chunks); + + for chunk in ad_chunks { + eprintln!("Inside ad chunk loop"); + eprintln!("Ad chunk in loop {:001X?}", chunk); + let inter2 = xor_bytes(&inter_loop, chunk.to_vec())?; + inter_loop = gfmul(inter2, auth_key_h.clone(), "gcm")?; + } let cipher_chunks = ciphertext.chunks(16); @@ -357,7 +370,7 @@ pub fn ghash( let inter4 = xor_bytes(&inter_loop, l_field)?; inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?; - eprintln!("GHASH auth tag: {}", BASE64_STANDARD.encode(&inter_loop)); + eprintln!("GHASH auth tag: {:001X?}", inter_loop); Ok(inter_loop) } @@ -453,6 +466,78 @@ mod tests { Ok(()) } + #[test] + fn test_gcm_encrypt_aes_long_ad() -> Result<()> { + let nonce = BASE64_STANDARD.decode("yv66vvrO263eyviI")?; + let key = BASE64_STANDARD.decode("/v/pkoZlcxxtao+UZzCDCA==")?; + let plaintext = BASE64_STANDARD.decode( + "2TEyJfiEBuWlWQnFr/UmmoanqVMVNPfaLkwwPYoxinIcPAyVlWgJUy/PDiRJprUlsWrt9aoN5le6Y3s5", + )?; + let ad = BASE64_STANDARD.decode("/u36zt6tvu/+7frO3q2+76ut2tI=")?; + + let (ciphertext, auth_tag, l_field, auth_key_h) = + gcm_encrypt_aes(nonce, key, plaintext, ad)?; + + eprintln!( + "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}", + BASE64_STANDARD.encode(&ciphertext), + BASE64_STANDARD.encode(&auth_tag), + BASE64_STANDARD.encode(&l_field), + BASE64_STANDARD.encode(&auth_key_h) + ); + + assert_eq!( + BASE64_STANDARD.encode(ciphertext), + "QoMewiF3dCRLciG3hNDUnOOqIS8sAqTgNcF+IymsoS4h1RSyVGaTHH2PalqshKoFG6MLOWoKrJc9WOCR" + ); + assert_eq!(BASE64_STANDARD.encode(auth_tag), "W8lPvDIhpduU+ula5xIaRw=="); + assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAKAAAAAAAAAB4A=="); + assert_eq!( + BASE64_STANDARD.encode(auth_key_h), + "uDtTNwi/U10KpuUpgNU7eA==" + ); + + Ok(()) + } + /* + * TODO:Not sure if this case can really happen in our data + + #[test] + fn test_gcm_encrypt_aes_long_0000() -> Result<()> { + let nonce = BASE64_STANDARD.decode( + "kxMiXfiEBuVVkJxa/1Jpqmp6lThTT32h5MMD0qMYpyjDwMlRVoCVOfzw4kKaa1JUFq7b9aDealemN7Ob", + )?; + let key = BASE64_STANDARD.decode("/v/pkoZlcxxtao+UZzCDCP7/6ZKGZXMcbWqPlGcwgwg=")?; + let plaintext = BASE64_STANDARD.decode( + "2TEyJfiEBuWlWQnFr/UmmoanqVMVNPfaLkwwPYoxinIcPAyVlWgJUy/PDiRJprUlsWrt9aoN5le6Y3s5", + )?; + let ad = BASE64_STANDARD.decode("/u36zt6tvu/+7frO3q2+76ut2tI=")?; + + let (ciphertext, auth_tag, l_field, auth_key_h) = + gcm_encrypt_aes(nonce, key, plaintext, ad)?; + + eprintln!( + "Cipher: {:001X?} \n Tag: {:001X?} \n L_Field: {:001X?} \n H: {:001X?}", + BASE64_STANDARD.encode(&ciphertext), + BASE64_STANDARD.encode(&auth_tag), + BASE64_STANDARD.encode(&l_field), + BASE64_STANDARD.encode(&auth_key_h) + ); + + assert_eq!( + BASE64_STANDARD.encode(ciphertext), + "Wo3vLwyeU/H3XXhTZZ4qIO6ysiqv3mQZoFirT290a/QPwMO3gPJERS2j6/HF2CzeokGJlyAO+C5Ern4/" + ); + assert_eq!(BASE64_STANDARD.encode(auth_tag), "pEqCZu4cjrDItdTPWunxmg=="); + assert_eq!(BASE64_STANDARD.encode(l_field), "AAAAAAAAAKAAAAAAAAAB4A=="); + assert_eq!( + BASE64_STANDARD.encode(auth_key_h), + "rL7yBXm0uOvOiJushzLa1w==" + ); + + Ok(()) + } + */ #[test] fn test_gcm_encrypt_sea() -> Result<()> { let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; From 1dfed264e9436367fb4a375cd541c11d41f9b82b Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 3 Nov 2024 20:15:55 +0100 Subject: [PATCH 021/105] fix: add padding to empty ad case --- src/utils/ciphers.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 7fb6e63..56b4ead 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -334,7 +334,7 @@ pub fn ghash( eprintln!("{:?}", (ad.len() % 16) as u8); eprintln!("{:001X?}", ad); - if ad.len() % 16 != 0 { + if ad.len() % 16 != 0 || ad.is_empty() { ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut()); } From b81bbab16c289c9d13a86fc3495c807014ee73cb Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Mon, 4 Nov 2024 15:46:09 +0100 Subject: [PATCH 022/105] doc: add docmentation and test --- src/tasks/tasks01/gfmul.rs | 20 +++++++++++++++ src/utils/ciphers.rs | 50 +++++++++++++++----------------------- 2 files changed, 40 insertions(+), 30 deletions(-) diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index c4acefe..01731f6 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -108,4 +108,24 @@ mod tests { ); 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==", + "Failure. Calulated result was: {}", + result + ); + Ok(()) + } } diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 56b4ead..917a1c7 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -7,6 +7,9 @@ use openssl::symm::{Cipher, Crypter, Mode}; use super::math::xor_bytes; +/// AES ENCRYPT +/// Function to perform encryption with AES ECB mode +/// Function does not use padding for blocks pub fn aes_128_encrypt(key: &Vec, input: &Vec) -> Result> { let mut encrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Encrypt, &key, None)?; encrypter.pad(false); @@ -22,6 +25,9 @@ pub fn aes_128_encrypt(key: &Vec, input: &Vec) -> Result> { Ok(ciphertext) } +/// AES DECRPYT +/// Function to perform decryption with AES ECB mode +/// Function does not use padding for blocks pub fn aes_128_decrypt(key: &Vec, input: &Vec) -> Result> { let mut decrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Decrypt, key, None)?; decrypter.pad(false); @@ -39,8 +45,14 @@ pub fn aes_128_decrypt(key: &Vec, input: &Vec) -> Result> { Ok(plaintext) } +/// SEA ENCRYPT +/// Function to perform sea encrption. +/// At its core, the function ses the AES ENCRYPT, but then xors with a constant value of: +/// 0xc0ffeec0ffeec0ffeec0ffeec0ffee11 pub fn sea_128_encrypt(key: &Vec, input: &Vec) -> Result> { + // Constant value used for XOR let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11; + let sea128_out = xor_bytes( &aes_128_encrypt(key, input)?, xor_val.to_be_bytes().to_vec(), @@ -48,38 +60,30 @@ pub fn sea_128_encrypt(key: &Vec, input: &Vec) -> Result> { Ok(sea128_out) } +/// SEA DECRYPT +/// Function to perform sea decryption. +/// At its core, the function ses the AES DECRYPT, but then xors with a constant value of: +/// 0xc0ffeec0ffeec0ffeec0ffeec0ffee11 pub fn sea_128_decrypt(key: &Vec, input: &Vec) -> Result> { + // Constant value used for XOR let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11; let intermediate = xor_bytes(input, xor_val.to_be_bytes().to_vec())?; Ok(aes_128_decrypt(&key, &intermediate)?) } +/// Function to perform xex encryption. +/// The function performs the encryption for XEX on the basis of the SEA ENCRYPT. pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result> { let key2: Vec = key.split_off(16); - //let key1: ByteArray = ByteArray(vec![key_parts[0]]); - //let key2: ByteArray = ByteArray(vec![key_parts[1]]); let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); let mut output: Vec = vec![]; - //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); - //dbg!("input_chunks: {:001X?}", &input_chunks); - for chunk in input_chunks { let plaintext_intermediate = xor_bytes(&tweak_block.0, chunk)?; - /* - assert!( - plaintext_intermediate.len() % 16 == 0, - "Failure: plaintext_intermediate len was {}", - plaintext_intermediate.len() - ); - */ - //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let cypher_block_intermediate = sea_128_encrypt(&key, &plaintext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, cypher_block_intermediate)?; output.append(cypher_block.as_mut()); @@ -91,28 +95,13 @@ pub fn xex_encrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result pub fn xex_decrypt(mut key: Vec, tweak: &Vec, input: &Vec) -> Result> { let key2: Vec = key.split_off(16); - //let key1: ByteArray = ByteArray(vec![key_parts[0]]); - //let key2: ByteArray = ByteArray(vec![key_parts[1]]); - let input_chunks: Vec> = input.chunks(16).map(|x| x.to_vec()).collect(); let mut output: Vec = vec![]; - //assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - //assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); let mut tweak_block: ByteArray = ByteArray(sea_128_encrypt(&key2, tweak)?); for chunk in input_chunks { let cyphertext_intermediate = xor_bytes(&tweak_block.0, chunk)?; - - /* - assert!( - cyphertext_intermediate.len() % 16 == 0, - "Failure: plaintext_intermediate len was {}", - cyphertext_intermediate.len() - ); - assert!(key.len() % 16 == 0, "Failure: Key len {}", key.len()); - assert!(key2.len() % 16 == 0, "Failure: Key2 len {}", key2.len()); - */ let plaintext_block_intermediate = sea_128_decrypt(&key, &cyphertext_intermediate)?; let mut cypher_block = xor_bytes(&tweak_block.0, plaintext_block_intermediate)?; output.append(cypher_block.as_mut()); @@ -136,6 +125,7 @@ pub fn gcm_encrypt_aes( 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())?; From 9ae53e12fd60d4ab876763ce95f192c40f4fe37d Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Wed, 6 Nov 2024 23:38:54 +0100 Subject: [PATCH 023/105] feat: Initial padding oracle working. Pending check for special case. The initial padding oracle attack is working. More tests need to be added and there needs to be a check for the special case of the 02 01, 02 02 padding case --- src/tasks/mod.rs | 7 ++ src/tasks/tasks01/mod.rs | 1 + src/tasks/tasks01/pad_oracle.rs | 136 ++++++++++++++++++++++++++++++++ src/utils/mod.rs | 1 + src/utils/net.rs | 1 + test_json/padding_oracle.json | 13 +++ 6 files changed, 159 insertions(+) create mode 100644 src/tasks/tasks01/pad_oracle.rs create mode 100644 src/utils/net.rs create mode 100644 test_json/padding_oracle.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 6c003b2..0fa72d6 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -10,6 +10,7 @@ use tasks01::{ block2poly::block2poly, gcm::{gcm_decrypt, gcm_encrypt}, gfmul::gfmul_task, + pad_oracle::padding_oracle, poly2block::poly2block, sea128::sea128, xex::{self, fde_xex}, @@ -75,7 +76,13 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "padding_oracle" => { + let plaintext = padding_oracle(args)?; + let out_plain = BASE64_STANDARD.encode(&plaintext); + let json = json!({"plaintext" : out_plain}); + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs index d1f3e99..479fe47 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -1,6 +1,7 @@ pub mod block2poly; pub mod gcm; pub mod gfmul; +pub mod pad_oracle; 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 new file mode 100644 index 0000000..31b739c --- /dev/null +++ b/src/tasks/tasks01/pad_oracle.rs @@ -0,0 +1,136 @@ +use anyhow::Result; +use base64::prelude::*; +use serde_json::Value; +use std::io::prelude::*; +use std::net::TcpStream; +use std::time::Duration; +use std::{thread, usize}; + +pub fn padding_oracle(args: &Value) -> Result> { + let hostname: String = serde_json::from_value(args["hostname"].clone())?; + + let port_val: Value = serde_json::from_value(args["port"].clone())?; + let port: u64 = port_val.as_u64().expect("Failure in parsing port number"); + + let iv_string: String = serde_json::from_value(args["iv"].clone())?; + let iv: Vec = BASE64_STANDARD.decode(iv_string)?; + + let cipher_text: String = serde_json::from_value(args["ciphertext"].clone())?; + let ciphertext: Vec = BASE64_STANDARD.decode(cipher_text)?; + + // Initialise tracker to adapt correct byte + let byte_counter = 15; + eprintln!("byte_counter is: {}", byte_counter); + + let mut plaintext: Vec = vec![]; + eprintln!("Ciphertext: {:002X?}", ciphertext); + + let cipher_chunks: Vec<&[u8]> = ciphertext.chunks(16).rev().collect(); + let mut chunk_counter = 0; + + for chunk in &cipher_chunks { + let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?; + stream.set_nonblocking(false)?; + + // Track value sent to server + let mut attack_counter: Vec = vec![0; 16]; + + // Amount of q blocks to send to server. + // TODO:: May be increased via function + let q_block_count: u16 = 255; + + //Send the first ciphertext chunk + eprintln!("Sending Ciphertext chunk: {:002X?}", chunk); + stream.flush()?; + stream.write_all(&chunk)?; + stream.flush()?; + + for i in (0..=15).rev() { + // Craft length message + // FIXME: Assignment is redundant for now + // TODO: Goal is to maybe add speed increase in the future + let l_msg: [u8; 2] = q_block_count.to_le_bytes(); + //eprintln!("Sending l_msg: {:02X?}", l_msg); + stream.write_all(&l_msg)?; + stream.flush()?; + //eprintln!("L_msg sent"); + + // Generate attack blocks + for j in 0..q_block_count { + // Next byte + //eprintln!("Sending attack block: {:02X?}", attack_counter); + + //thread::sleep(Duration::from_millis(1000)); + stream.write_all(&attack_counter)?; + stream.flush()?; + attack_counter[i as usize] += 1; + } + + // Read server response + let mut buf = [0u8; 0xFF]; + stream.read_exact(&mut buf)?; + //eprintln!("{:02X?}", buf); + + // extract valid position + let valid_val = buf.iter().position(|&r| r == 0x01).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 { + eprintln!("XOR IV"); + + plaintext.push(iv[i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1))); + } + //eprintln!("Attack counter after set: {:02X?}", attack_counter); + for pos in i..=15 { + //eprintln!("i is: {:02X?}", i); + //eprintln!("i + 1 is: {:02X?}", ((16 - i) as u8).to_le()); + /* + eprintln!( + "attack_counter[pos as usize]: {:02X?}", + attack_counter[pos as usize] + ); + eprintln!( + "attack_counter[pos as usize] ^ 0x02 {:02X?}", + attack_counter[pos as usize] ^ (15 - i as u8 + 1) + ); + */ + let intermediate = attack_counter[pos as usize] ^ (15 - i as u8 + 1); + + attack_counter[pos as usize] = intermediate ^ ((15 - i as u8 + 1) + 1); + } + stream.flush()?; + + // Write plaintext + //eprintln!("{:02X?}", plaintext); + } + chunk_counter += 1; + stream.flush()?; + // break; + drop(stream); + } + + plaintext.reverse(); + + eprintln!("{:02X?}", BASE64_STANDARD.encode(&plaintext)); + Ok(plaintext) +} // the stream is closed here + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn test_connection() -> Result<()> { + Ok(()) + } +} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 2f12ed4..298415b 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,5 +1,6 @@ pub mod ciphers; pub mod field; pub mod math; +pub mod net; pub mod parse; pub mod poly; diff --git a/src/utils/net.rs b/src/utils/net.rs new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/utils/net.rs @@ -0,0 +1 @@ + diff --git a/test_json/padding_oracle.json b/test_json/padding_oracle.json new file mode 100644 index 0000000..c837963 --- /dev/null +++ b/test_json/padding_oracle.json @@ -0,0 +1,13 @@ +{ + "testcases": { + "254eaee7-05fd-4e0d-8292-9b658a852245": { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QENCRURHRklIS0pNTE9OUQAAAAAAAAAASUlJSUlJSUk=" + } + } + } +} From 757afbdc959cf60efb21a2958749bc21673a08e3 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Thu, 7 Nov 2024 09:32:18 +0100 Subject: [PATCH 024/105] refactor: Hopefully increase speed by reducing send code --- src/tasks/tasks01/pad_oracle.rs | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 31b739c..35db6fd 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -40,7 +40,7 @@ pub fn padding_oracle(args: &Value) -> Result> { let q_block_count: u16 = 255; //Send the first ciphertext chunk - eprintln!("Sending Ciphertext chunk: {:002X?}", chunk); + //eprintln!("Sending Ciphertext chunk: {:002X?}", chunk); stream.flush()?; stream.write_all(&chunk)?; stream.flush()?; @@ -56,16 +56,20 @@ pub fn padding_oracle(args: &Value) -> Result> { //eprintln!("L_msg sent"); // Generate attack blocks + // TODO: Collect all and send in one + let mut payload: Vec = vec![]; for j in 0..q_block_count { // Next byte //eprintln!("Sending attack block: {:02X?}", attack_counter); //thread::sleep(Duration::from_millis(1000)); - stream.write_all(&attack_counter)?; - stream.flush()?; + payload.append(attack_counter.clone().as_mut()); attack_counter[i as usize] += 1; } + stream.write_all(&payload)?; + stream.flush()?; + // Read server response let mut buf = [0u8; 0xFF]; stream.read_exact(&mut buf)?; @@ -73,19 +77,19 @@ pub fn padding_oracle(args: &Value) -> Result> { // extract valid position let valid_val = buf.iter().position(|&r| r == 0x01).expect("No valid found") as u8; - //eprintln!("Valid value found: {:02X?}", valid_val); + 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"); + //eprintln!("XOR Next Ciph block"); plaintext.push( cipher_chunks[chunk_counter + 1][i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1)), ); } else { - eprintln!("XOR IV"); + //seprintln!("XOR IV"); plaintext.push(iv[i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1))); } From 0f8d202a06fef902012a410cdef639b0c78e87ec Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Thu, 7 Nov 2024 10:28:09 +0100 Subject: [PATCH 025/105] feat: Add edge case treatment --- src/tasks/tasks01/pad_oracle.rs | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 35db6fd..1215bd7 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -77,11 +77,37 @@ pub fn padding_oracle(args: &Value) -> Result> { // extract valid position let valid_val = buf.iter().position(|&r| r == 0x01).expect("No valid found") as u8; - eprintln!("Valid value found: {:02X?}", valid_val); - + //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 check_q_block: Vec = vec![0; 16]; + check_q_block[15] = attack_counter[15] ^ (15 - i as u8); + check_q_block[14] = !check_q_block[15]; + + stream.write_all(&[0x01, 0x00])?; + stream.write_all(&check_q_block)?; + let mut buf = [0u8; 0x01]; + stream.read(&mut buf)?; + + if buf == [0x01] { + eprintln!("Valid padding"); + } else { + eprintln!("Invalid padding"); + // Search for second hit + let valid_val = buf + .iter() + .rev() + .position(|&r| r == 0x01) + .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( @@ -111,6 +137,7 @@ pub fn padding_oracle(args: &Value) -> Result> { attack_counter[pos as usize] = intermediate ^ ((15 - i as u8 + 1) + 1); } + stream.flush()?; // Write plaintext From 10fd837be92503e8bd38b94cff91f4fb7225e40c Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Thu, 7 Nov 2024 17:45:05 +0100 Subject: [PATCH 026/105] refactor: improve performance --- src/tasks/tasks01/pad_oracle.rs | 31 +- test_json/padding_oracle.json | 12006 +++++++++++++++++++++++++++++- 2 files changed, 12023 insertions(+), 14 deletions(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 1215bd7..5d062e1 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -3,7 +3,7 @@ use base64::prelude::*; use serde_json::Value; use std::io::prelude::*; use std::net::TcpStream; -use std::time::Duration; +use std::time::{Duration, Instant}; use std::{thread, usize}; pub fn padding_oracle(args: &Value) -> Result> { @@ -29,7 +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))?; + let start = Instant::now(); + + let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port))?; stream.set_nonblocking(false)?; // Track value sent to server @@ -51,32 +53,36 @@ pub fn padding_oracle(args: &Value) -> Result> { // 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()?; + //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![]; + 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.append(attack_counter.clone().as_mut()); + payload.extend(&attack_counter); attack_counter[i as usize] += 1; } + //eprintln!("Time for qblocks: {:?}", start.elapsed()); stream.write_all(&payload)?; stream.flush()?; // Read server response - let mut buf = [0u8; 0xFF]; - stream.read_exact(&mut buf)?; + let mut server_q_resp = [0u8; 0xFF]; + stream.read_exact(&mut server_q_resp)?; //eprintln!("{:02X?}", buf); // extract valid position - let valid_val = buf.iter().position(|&r| r == 0x01).expect("No valid found") as u8; + let valid_val = server_q_resp + .iter() + .position(|&r| r == 0x01) + .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; @@ -85,19 +91,19 @@ pub fn padding_oracle(args: &Value) -> Result> { if i == 15 { let mut check_q_block: Vec = vec![0; 16]; check_q_block[15] = attack_counter[15] ^ (15 - i as u8); - check_q_block[14] = !check_q_block[15]; + check_q_block[14] = check_q_block[15].reverse_bits(); 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 = buf + let valid_val = server_q_resp .iter() .rev() .position(|&r| r == 0x01) @@ -147,6 +153,7 @@ pub fn padding_oracle(args: &Value) -> Result> { stream.flush()?; // break; drop(stream); + eprintln!("Time rest of calc: {:?}", start.elapsed()); } plaintext.reverse(); diff --git a/test_json/padding_oracle.json b/test_json/padding_oracle.json index c837963..f098cb7 100644 --- a/test_json/padding_oracle.json +++ b/test_json/padding_oracle.json @@ -6,8 +6,12010 @@ "hostname": "localhost", "port": 1337, "iv": "AAAAAAAAAAAAAAAAAAAAAA==", - "ciphertext": "QENCRURHRklIS0pNTE9OUQAAAAAAAAAASUlJSUlJSUk=" + "ciphertext": "AgEABwYFBAsKCQgPDwwNEQ==" + } + }, + + "79475065-c272-4f43-8721-34d1e817acea": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wuCsSHOGvDom2xRWfTslutPyv1xmkKsiP8EPSmAlOro=" } } - } + +, + "aa8a1b5b-ca2a-46eb-a775-662408d8bafc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LKXbLmsF2FKiYVG5S96uGj23yDp+E89Ku3tKpVbAsRo=" + } + } + +, + "2e6c3fbb-dd97-48dc-8239-00a6788b591e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "U+5lMyf9D4TA0LGXjlt370L8dicy6xic2cqqi5NFaO8=" + } + } + +, + "c3bbdf14-d8e3-41a2-ac84-fa8192daa4bd": { + + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WdVVYNTwNn8BWC7ekC4NBEjHRnTB5iFnGEI1wo0wEgQ=" + } + } + +, + "968c6dfd-fa8b-4143-a927-a677f7152fe9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BYZNm5n6OseIBFxw3wlcuxSUXo+M7C3fkR5HbMIXQ7s=" + } + } + +, + "7151f5a8-5214-428a-8cd4-ef80c2527154": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hsj1qw1sarC1X/YsQz0hzJfa5r8Yen2orEXtMF4jPsw=" + } + } + +, + "0bcf7291-ea89-4ba7-9bb0-ffa38d08f52d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ysTKOd0krOCIXJwS+6tAwNvW2S3IMrv4kUaHDua1X8A=" + } + } + +, + "5e61bb2c-b143-41bf-8d48-582573c953f9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Cuw/wQOnIWYau/kox+nuCRv+LNUWsTZ+A6HiNNr38Qk=" + } + } + +, + "bdd90faa-4ba6-4655-af09-2dd470122600": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zg7aGOt1uVJ9aesqHfjzut8cyQz+Y65KZHPwNgDm7Lo=" + } + } + +, + "0b9f04df-1040-4ba9-9934-2e2d9a2bb1de": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bXnKIyAMRU78K4AKeObNzXxr2Tc1GlJW5TGbFmX40s0=" + } + } + +, + "f94d738c-8655-4790-ae5e-d3be12f47f30": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YkLfX2SmtfjriL9nZGYLSnNQzEtxsKLg8pKke3l4FEo=" + } + } + +, + "d3fd1ad2-f380-4a96-818f-ab44407274b3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "emlfokHnveqFPk69G6q/s2t7TLZU8arynCRVoQa0oLM=" + } + } + +, + "15cc8090-f0cd-4312-882f-a3350acab787": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jRa54vvKkyF9bT1yl22CvpwEqvbu3IQ5ZHcmbopznb4=" + } + } + +, + "429dd0f0-dcc5-43af-8248-aa9349cb970a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "l3yzIjQweq/0rvVuFGJxwoZuoDYhJm237bTucgl8bsI=" + } + } + +, + "2393d9dc-ab03-49ba-b28d-39766749f7b1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tSTGrMFXTAzSOqHsdzt56KQ21bjUQVsUyyC68GolZug=" + } + } + +, + "e3dde0df-2494-4922-8fee-d3895a8f15cb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vx8s8xKKvNoo77y4GnU/HkYNP+cHnKvCMfWnpAdrIB4=" + } + } + +, + "c05db0bd-fcd9-4560-b699-462d401e03f5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5L5NajntQ50LMbTGFFTRd/WsXn4s+1SFEiuv2glKznc=" + } + } + +, + "78e3e77e-65e1-44d0-8a3f-9fc9a173cea8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "th+gRD+XEGM8wZawjqAi5qcNs1AqgQd7JduNrJO+PeY=" + } + } + +, + "b2abea21-39bb-40d1-ab4c-283ddc552897": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cI/n4iaKXFycQpQDa42ENWGd9PYznEtEhViPH3aTmzU=" + } + } + +, + "d1f97791-708b-4a2c-bbc7-d2c4f6cb55ed": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QS3cmHhuKrugn/2OE0TPFlA/z4xteD2juYXmkg5a0BY=" + } + } + +, + "a2bb1c1d-fdbe-4e06-bded-ad549aca25a2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2irtZfj+YXoN4DdgdzPzlcs4/nHt6HZiFPosfGot7JU=" + } + } + +, + "8c1d0f4c-8a77-4954-a5f1-8eff96e74291": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ky6wyVQuha/5GekwJhQgFII8o91BOJK34APyLDsKPxQ=" + } + } + +, + "6c6ad91b-a8ec-4b74-a7e2-b98b3425d923": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AKlLLatRqy56hBeO5Ey69hG7WDm+R7w2Y54MkvlSpfY=" + } + } + +, + "31f4a421-ea1f-45c6-88a5-a9d80ce27453": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5O+VIj0GMfkCiG+9hBUa9fX9hjYoECbhG5J0oZkLBfU=" + } + } + +, + "51a672fd-a351-4b7a-ad63-d4ab3c8d3840": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dUb04Us9/BMMUQ7CeAzXZmRU5/VeK+sLFUsV3mUSyGY=" + } + } + +, + "23c60029-a52c-4413-8667-ddf3e919746c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mjLa7SDsEmfCJXvJWOlbtYsgyfk1+gV/2z9g1UX3RLU=" + } + } + +, + "768d8157-a418-4793-9ffa-29d5d90cc06a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AhYTV3j8WEDCu8DkNyr/KhMEAENt6k9Y26Hb+Co04Co=" + } + } + +, + "c27d256a-c612-4cb0-a3d3-9a0e6f2b479a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tf2X/DMSmTr1OKEOwISrwFzvhOgmBI4i7CK6Et2atMA=" + } + } + +, + "1ef41c26-76b1-49ad-a72b-05f10d6e0229": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qUby8fya+N9eOel5YwqjrbhU4eXpjO/HRyPyZX4UvK0=" + } + } + +, + "c003d5fd-b620-441d-a2ad-2d997ecb7ead": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+F7qOBxIKW0YSM+GCJKeYOlM+SwJXj51AVLUmhWMgWA=" + } + } + +, + "676108b1-d0f1-47b7-9a38-77e78f9f6070": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sxYE+69TQ5n+C6MSnVdxZ6IEF++6RVSB5xG4DoBJbmc=" + } + } + +, + "13942eed-98b0-4491-b5e5-a77b63786088": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "odcpOvUg3m2A3GZ45z4pFrDFOi7gNsl1mcZ9ZPogNhY=" + } + } + +, + "9b92c9b1-b555-4d7a-9d28-1c2ef4556391": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "thOYAriNEtasdbyzfD18GKcBixatmwXOtW+nr2EjYxg=" + } + } + +, + "be84e6d5-2399-4a70-8b12-c85c57305eca": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DbPaRmiSgG4FZWUORvd1QByhyVJ9hJd2HH9+ElvpakA=" + } + } + +, + "19db8187-692f-450f-9d73-3f60114e43cb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LPG4shaGdPVoWSfV3SJTaz3jq6YDkGPtcUM8ycA8TGs=" + } + } + +, + "141ad199-373a-43bc-b8a5-1c6564e23f6f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C5pcjnAHCrNf+oBUeUqIFBqIT5plER2rRuCbSGRUlxQ=" + } + } + +, + "37856fef-3904-48da-a90f-c26a1d6b8ec0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1F0rq0sqQy/5lwKsBQP5y8VPOL9ePFQ34I0ZsBgd5ss=" + } + } + +, + "8f8a40e5-f806-46e2-b158-4f7c9e576fa3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qxQ8IINIVZNgTQgZBXnnsboGLzSWXkKLeVcTBRhn+LE=" + } + } + +, + "fbb94fcc-b07e-417e-88d5-12af3efad5ca": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "60UzFFZ96YM/dp5m6BHphfpXIABDa/6bJmyFevUP9oU=" + } + } + +, + "67ccebb1-0987-4baa-9d2d-df7cef46434d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uCU/StfV1sZlD+92xGy9G6k3LF7Cw8HefBX0atlyohs=" + } + } + +, + "3215408e-833a-453c-98b5-bd507003b020": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ndNtSui+IzXhqw/cKGCIeIzBfl79qDQt+LEUwDV+l3g=" + } + } + +, + "02623348-f933-4341-b97f-977d73b0bc62": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cwK3FUQPgbKAyt1T6M7Zj2IQpAFRGZaqmdDGT/XQxo8=" + } + } + +, + "6c32b392-fc86-48e6-9257-71456e5e0233": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2VnI1YWVUdwUXOaFEbgeichL28GQg0bEDUb9mQymAYk=" + } + } + +, + "b619b2f7-f53d-4afc-9384-92b2f1a6fc85": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ENtD5rlkd4emyz8hhFCbHwHJUPKscmCfv9EkPZlOhB8=" + } + } + +, + "0a32a502-a6f1-4735-b277-ef3311deb33c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zlJ4f5uFsmkkxxrsd/aO8t9Aa2uOk6VxPd0B8GrokfI=" + } + } + +, + "e33c9d5a-78a6-4d4b-8f72-11bc788156cc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8YEbDIa2o47CMhNCrmDvXuCTCBiToLSW2ygIXrN+8F4=" + } + } + +, + "1585ff59-409e-4caa-8aff-4d2ae014f15d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "z1SYPYO8aUdAM/9unpqX495GiymWqn5fWSnkcoOEiOM=" + } + } + +, + "3be9e271-bed1-4df3-aa32-584b43b60b05": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KY5YKMys+zD4sANgsSNtkTicSzzZuuwo4aoYfKw9cpE=" + } + } + +, + "545bbdb5-0fda-4229-9d07-0d3f364cda3c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ev36wokuTJrgG5W/UBAkY2vv6dacOFuC+QGOo00OO2M=" + } + } + +, + "1d76e215-1b8d-4f1a-b4a3-f1c934b62aef": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "0NltOUiIjDuh93WLhgn3B8HLfi1dnpsjuO1ul5sX6Ac=" + } + } + +, + "b516c807-79b6-42f8-9e7a-31c0c2ced565": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1ROGw77+naE7SwcDeXc8p8QBlder6Iq5IlEcH2RpI6c=" + } + } + +, + "46e2ef15-c66a-47de-abf0-8efd392ca7b5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lmEBGItSbGnGMUKdlYcrFodzEgyeRHtx3ytZgYiZNBY=" + } + } + +, + "7fdbbf06-f5a5-4738-aa15-b2f82aa8c93c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iARtcx9qk8KRszM6sIq79pkWfmcKfITaiKkoJq2UpPY=" + } + } + +, + "69adb4ae-5b78-4fd4-a1b9-b98d377aab4f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "b8RfwYsf1l90cbyImhUAC37WTNWeCcFHbWunlIcLHws=" + } + } + +, + "7b5a227e-ba23-46e5-b256-2cd4a3bff0b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "N7BLt2st0se8WKfCmHh0YiaiWKN+O8XfpUK83oVma2I=" + } + } + +, + "05aa21f5-ec4b-4370-87ce-320475959442": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9i2oFt0iwu5eKsEAtBQK0ec/uwLINNX2RzDaHKkKFdE=" + } + } + +, + "d49151a3-e1df-4679-8893-cdcd8d032d89": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jVtMx7pkcss6FSb8OihHgpxJX9OvcmXTIw894Cc2WII=" + } + } + +, + "156026ed-e93b-4928-91f9-fe7693014475": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "H7GShGHMDvgzN4dqJp+j7A6jgZB02hngKi2cdjuBvOw=" + } + } + +, + "434466ff-fc6f-40d9-8620-a463092a4309": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "M3v/WuLnZgn/SinB8HJzFyJp7E738XER5lAy3e1sbBc=" + } + } + +, + "ade154d0-3797-439d-8e36-3f9a382446ec": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nHI8epl3QQev7CZT2Dtc341gL26MYVYftvY9T8UlQ98=" + } + } + +, + "677b9492-dec1-4971-b8e2-aa4634a6efd1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7dVeHtZgnXNkMN2EBnnUufzHTQrDdoprfSrGmBtny7k=" + } + } + +, + "abfe0912-c0c9-48d2-bc18-963a3212bd5e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NX8de/ZPnLvUK/1QLY0g7SRtDm/jWYujzTHmTDCTP+0=" + } + } + +, + "1391c326-db3a-4cda-ad66-47e13f0957c8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5poPqSUMWrU0RlwH2rmjPveIHL0wGk2tLVxHG8envD4=" + } + } + +, + "bde38912-70f6-4ac0-a55d-538cfd761796": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oImwiPoBZySnOAvq9CcHObGbo5zvF3A8viIQ9uk5GDk=" + } + } + +, + "5caa3e55-6f01-4b6c-839b-95411a230126": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CasEfEK50jkR2PtGt40TFRi5F2hXr8UhCMLgWqqTDBU=" + } + } + +, + "3cc80073-4ed3-4c3f-8d4d-6c4b130a923b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4kKrDmnRbmAEAqTAw7d7mvNQuBp8x3l4HRi/3N6pZJo=" + } + } + +, + "a128f415-747b-42fb-b75f-91c616a32384": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oHyMQBfoTtumKt99H9w/2rFun1QC/lnDvzDEYQLCINo=" + } + } + +, + "3308d80f-2d05-4b9c-93eb-e24538d9ae19": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Kwn6AczyQcOPeOmBM8rZrDob6RXZ5FbblmLynS7Uxqw=" + } + } + +, + "5eed1266-2e4e-4647-8819-e0f2f157c6ad": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yuZkQ0uN+2z/jTWCmOtw19v0d1dem+x05pcunoX1b9c=" + } + } + +, + "24b3ab20-c210-4bf5-bfae-77b442c22579": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hCjdHnCpOqxQ45WeLdIWiZU6zgplvy20SfmOgjDMCYk=" + } + } + +, + "995806f0-079a-42ff-bf99-1e4c2800a8ab": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7Uo9B32R+hImWRqoFgdZvfxYLhNoh+0KP0MBtAsZRr0=" + } + } + +, + "5f2db46c-59e9-40d2-b66c-a1331dc38945": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UyTmb7FF3lA/skOvVqIKX0I29XukU8lIJqhYs0u8FV8=" + } + } + +, + "87e4998c-18d1-4289-a6fd-5b8590c04611": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QVwk7k98bUdexppwiGDFJVBON/paanpfR9yBbJV+2iU=" + } + } + +, + "553d4405-c32c-43c0-8ac9-6c3bafe75d32": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BuNe+BLp0Kpr0kHK590qDxfxTewH/8eycsha1vrDNQ8=" + } + } + +, + "3a76763a-6e02-4c0d-89a2-0af072cfeba4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "h/ciXC8UKGLUPQ4WUGAtSpblMUg6Aj96zScVCk1+Mko=" + } + } + +, + "75dc9ea3-da79-4ad0-8b1c-c05bec066efb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TF/pueSavmkPizEm9587a11N+q3xjKlxFpEqOuqBJGs=" + } + } + +, + "d5d38f30-1ad5-4d89-8c78-dd86e1a25b46": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SC9o/xRw8Chh/SwSduLSQVk9e+sBZucweOc3Dmv8zUE=" + } + } + +, + "2b4bee58-4257-464e-8c87-61a92187a5ce": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yS/q4zLoE+X+AkDd1BNCE9g9+fcn/gT95xhbwckNXRM=" + } + } + +, + "b89518ae-b954-41c0-b05f-9e5d890e69d2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C1v9cGqaXAhhrbMfW5G8dxpJ7mR/jEsQeLeoA0aPo3c=" + } + } + +, + "d6254a36-ae97-49d0-8e22-5f3da57431c1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "S5iwlIFgyyQMxFsYVW6kflqKo4CUdtw8Fd5ABEhwu34=" + } + } + +, + "aa182a23-1aca-479d-a8e5-030d4c0d240f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vv2FvSZVhZqek+qk1DV6H0fvlqkzQ5KCh4nxuMkrZR8=" + } + } + +, + "5a4c7350-87cb-4f87-ac2c-6eeda4dea87a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NzPyR/lmUww1xa70XQJoVyYh4VPscEQULN+16EAcd1c=" + } + } + +, + "a728a2d2-5a28-4ba9-aed7-b537f7f6df94": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "J3vgRHNBcC1SZKGp/dt+mzZp81BmV2c1S366teDFYZs=" + } + } + +, + "157b1098-1ea8-467f-a0f7-8deb1b684afa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ze7AvAz0l3EVnN4refOwMHT806gZ4oBpDIbFN2TtrzA=" + } + } + +, + "7fcdfda8-ce4a-4010-8b49-08208ebf0422": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "h2OHWZ5BRMEgsJcQ8FiGH5ZxlE2LV1PZOaqMDO1GmR8=" + } + } + +, + "7bdc636a-f651-4025-a261-a556f4136739": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "85X5lD82u/EYTkA7VSG4Q+KH6oAqIKzpAVRbJ0g/p0M=" + } + } + +, + "8dea459d-893a-484f-b2e0-9bae7422abc9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HIPUqLzvGrHNZTZIFLxWGA2Rx7yp+Q2p1H8tVAmiSRg=" + } + } + +, + "4f62dad0-bb20-4091-86fc-629c36dbb958": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oXDdSN/ppWenWthEw1l8XLBizlzK/7J/vkDDWN5HY1w=" + } + } + +, + "9ee88136-9c0a-4bf9-bbea-678e25554e44": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HTvUzBJQkoNDXZvkDQCO2gwpx9gHRoWbWkeA+BAekdo=" + } + } + +, + "f384e7ef-9c69-4916-abc0-32983aeb962d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AQdVwgBpYnPpNMQuvjgtvBAVRtYVf3Vr8C7fMqMmMrw=" + } + } + +, + "6d6b428e-7b6f-463e-901f-01f81d3125c7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XoMpAjyRhaOcSTbbhqzYjk+ROhYph5K7hVMtx5uyx44=" + } + } + +, + "8c039e22-0eb4-49fe-902a-c1e720d8ef13": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uWKnlH+wQRVt4KDTTlGBFahwtIBqplYNdPq7z1NPnhU=" + } + } + +, + "72d5837b-a3c0-4ce7-b213-3fece94758ba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AkdFCHCGTjgRpBV9Hj1kKhNVVhxlkFkgCL4OYQMjeyo=" + } + } + +, + "a5763f8f-0f07-4857-825b-aecc6673ee95": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NOwWzOxhTTjL3KMS0RV7NiX+Bdj5d1og0sa4DswLZDY=" + } + } + +, + "ea3d4cf0-683d-4d29-ad75-9c6b82fe2059": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PJbGvcc5Bha5W06dHR2nOy2E1anSLxEOoEFVgQADuDs=" + } + } + +, + "30a7c087-ac4f-4e0c-8954-32f2a508d8f3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+aGiJWp6No09U61KN7fGTeizsTF/bCGVJEm2Viqp2U0=" + } + } + +, + "730b393e-019b-41dc-a714-7f3a380f4164": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CuWv8PuAn9epyBpIbIGR6hv3vOTulojPsNIBVHGfjuo=" + } + } + +, + "68aec5bf-9e07-4129-a6f4-87d3b91f4c75": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hj9uz5hDLAUL2y2TRe6HMJctfduNVTsdEsE2j1jwmDA=" + } + } + +, + "86dc49a8-ae93-4e33-93f7-fbc978cccf28": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZdIhvcwL/SEcq7Ak0ZOJInTAMqnZHeo5BbGrOMyNliI=" + } + } + +, + "7ee6f118-1c52-4cdf-956d-6c783bff9014": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rt6bjRtiolIvgH61ys3/db/MiJkOdLVKNpplqdfT4HU=" + } + } + +, + "b8ab202f-8020-4ed1-9374-afaf4656a700": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ksT0T1FT8ehj3hCLTB1FgYPW51tERebwesQLl1EDWoE=" + } + } + +, + "bbfc1019-2ebf-4d1e-91ad-c1073d221698": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+IhDX8ZU/HPPQsrhPfsse+maUEvTQutr1ljR/SDlM3s=" + } + } + +, + "46f7cbd3-00c5-487c-a8ec-678e5f3f3f13": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bcYPqBY+cmhmPvElhqMbS3zUHLwDKGVwfyTqOZu9BEs=" + } + } + +, + "fb605e00-44b4-4d3e-b4aa-ddc02a589077": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ixg+FQcZhU05IjRPykmkxDIKLQESD5JVIDgvU9dXu8Q=" + } + } + +, + "36519502-c2c0-4e9f-b7a2-713e6c6664b4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ya2FePCx0pMe7mQrxdAb63C/lmzlp8WLB/R/N9jOBOs=" + } + } + +, + "fd4d448e-88b2-4aef-9f88-3800d76283cb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xiXwX5brrCp/ffj7BwW4ctc340uD/bsyZmfj5xobp3I=" + } + } + +, + "f8d5f916-6c73-45f9-b721-07db7b1625a2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hvTC4cF/BOMkw1+jY7dldJfm0fXUaRP7PdlEv36penQ=" + } + } + +, + "4e6ca1dc-d276-491c-b247-bcc56ff69874": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bw0RNS7yoX009OZgLMz9J34fAiE75LZlLe79fDHS4ic=" + } + } + +, + "552a79ff-dcb7-4f5a-a271-95cfaf3ed565": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "w70WEcBjCowaUb+rgeRLd9KvBQXVdR2UA0ukt5z6VHc=" + } + } + +, + "019894c7-ed68-4b50-a8da-7165b5796d90": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Z1nDhI2K2H1GNmLMRpO1unZL0JCYnM9lXyx50FuNqro=" + } + } + +, + "df130773-e35c-4c99-8da7-d2c21635a6d6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tw5FA9LMUASolXwTEow/tF4cVhfH2kccsY9nDw+SILQ=" + } + } + +, + "c9dec0e8-0d3c-4c98-b16a-77b0e1e2fc1c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "paTj8WaSuoamd8db3USDOrS28OVzhK2ev23cR8BanDo=" + } + } + +, + "cf34f30c-e508-49c0-9f8c-511a71eba307": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CThcXROSYI6JFuDElAIsSRgqT0kGhHeWkAz72IkcM0k=" + } + } + +, + "45b36d76-f8a4-4b5c-8294-f29ff85fc770": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MH4V9lNlO7W4LdrS51N2ZiFsBuJGcyytoTfBzvpNaWY=" + } + } + +, + "84fb4d80-0b29-44a5-836b-3df124c168bc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PeYZLnqmTKyPvIc8wKsqPCz0CjpvsFu0lqacIN21NTw=" + } + } + +, + "0ebcd91d-e45c-41ff-a6ec-59fa3b53abc1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "j+XUuvIvy3ZXgu1Mkczsyp73x67nOdxuTpj2UIzS88o=" + } + } + +, + "eb1f2157-cd82-4773-9042-9d6a0760d71c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2XpR85H7JCotm0+7s3xWF8hoQueE7TMyNIFUp65iSRc=" + } + } + +, + "fb7c4955-ee33-40f6-98a5-4e555335633f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jVTV0IU4A4hDwFwLCqxq35xGxsSQLhSQWtpHFxeydd8=" + } + } + +, + "6cdc3803-a988-48e3-9290-ae479df7970b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rx0LvT3ecZ1vUVeX12hlTL4PGKkoyGaFdktMi8p2ekw=" + } + } + +, + "1325afcb-d899-42da-ac16-de82b5084903": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "j7lVTmEvXR7frDyEUkAJBZ6rRlp0OUoGxrYnmE9eFgU=" + } + } + +, + "dc827b01-9bbc-4e1e-8ce0-c790fe097a6a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Z/1/lEhZzER9Ca7saXgLy3bvbIBdT9tcZBO18HRmFMs=" + } + } + +, + "d7eb4301-3627-442a-959b-64f234b7b385": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gzOOz69b1R3664d+P4wE85Ihndu6TcIF4/GcYiKSG/M=" + } + } + +, + "cda9e8b8-2b07-448a-a79b-3b6c410858e0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iz/cTRlAFq+TGIpumMICb5otz1kMVgG3igKRcoXcHW8=" + } + } + +, + "898fffb5-6bbb-46f8-951c-5d385ecaddf7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aojSWtEYroUudpDPQ8al83uawU7EDrmdN2yL017YuvM=" + } + } + +, + "d9c25d4c-b727-4b63-8a10-031ccbc6f82d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Z7CNE6KksrzFpdtDWFa/EHainge3sqWk3L/AX0VIoBA=" + } + } + +, + "1981827a-a936-4479-a33e-a33cfc014e2c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+LnV8u4AbkeLmrexjnbl3emrxub7FnlfkoCsrZNo+t0=" + } + } + +, + "f012a49a-92e8-4428-9504-152f12eba26a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9/YamvAxMgU23a1XO5ruhebkCY7lJyUdL8e2SyaE8YU=" + } + } + +, + "88aab03b-f269-4a3f-bada-9ebf142ee813": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q+MdOkj/0Fc5VRDq4Ve1ebrxDi5d6cdPIE8L9vxJqnk=" + } + } + +, + "fb7f00c8-96f8-4adf-83d0-3245a24e6ffe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "scCZ5PhAeTArOiJDXNJ1VqDSivDtVm4oMiA5X0HMalY=" + } + } + +, + "580dc78c-0460-405d-8d62-21a2d55ae13e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5fV4yACoua0Kmo90Z5bpvPTna9wVvq61E4CUaHqI9rw=" + } + } + +, + "1f06f0a2-2d09-48ac-857e-8a63dfcc1688": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZNblSISQ73+v2ZG8wFH9HnXE9lyRhvhntsOKoN1P4h4=" + } + } + +, + "c417b637-b08c-41a0-9bc5-d427666f558e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "S2hInkbcE4IOjevXYvqlg1p6W4pTygSaF5fwy3/kuoM=" + } + } + +, + "cb149503-a350-441b-b91c-2b6c1101e01f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xpb85ubCDE6b64yAinB2r9eE7/Lz1BtWgvGXnJduaa8=" + } + } + +, + "ab8c776d-13b9-48f2-afb6-3c953441e4d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bASaCVzLsCCKqxPYwKZ9jn0WiR1J3ac4k7EIxN24Yo4=" + } + } + +, + "e71b9915-900b-4342-8a59-2bd0bd12aee6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8EF22Bsc2+7Ne4VSa/krg+FTZcwOCsz21GGeTnbnNIM=" + } + } + +, + "b11fd229-5d2e-4764-a206-58fda223a6c1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ruxCs5oMXsInEPuzjsYSJ7/+UaePGknaPgrgr5PYDSc=" + } + } + +, + "04e5e7db-acb5-47ac-aeb7-65d0360a7e71": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "IgNvGC+uUikM+q1yf/1txzMRfAw6uEUxFeC2bmLjcsc=" + } + } + +, + "f15e7d7e-fc52-43d1-9c49-abb912e546e1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cOzeu0k8mzkwB2QSv4pyf2H+za9cKowhKR1/DqKUbX8=" + } + } + +, + "2e72812e-7900-48e5-8798-8f825fb230f3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "izqPIp6Ov6bzUNvSnhOn0JoonDaLmKi+6krAzoMNuNA=" + } + } + +, + "87713f36-59c7-4c26-9f48-aaf027956f61": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nUYqCk5FCqMMyb12JX9w4oxUOR5bUx27FdOmajhhb+I=" + } + } + +, + "6c81f22d-6b99-4ef1-b66b-179418b0c733": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cQD09bzlwDCZ6UTFGSIUzmAS5+Gp89cogPNf2QQ8C84=" + } + } + +, + "8386ee3f-98c7-492d-bebb-694873067ac5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ndZCEhZqH9Xda09+IV3NLozEUQYDfAjNxHFUYjxD0i4=" + } + } + +, + "2646e392-8242-469a-99b1-56541414523c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BRiNwd46qA0jXiR3qEWr6RQKntXLLL8VOkQ/a7VbtOk=" + } + } + +, + "d6a0271c-c650-4c79-b005-5c3c11345388": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nefZPAWOPBsc2EIoYXr7wYz1yigQmCsDBcJZNHxk5ME=" + } + } + +, + "359558f6-cb25-4d4f-bac1-70caa03f8673": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GITHwvNn8DjWrhrWTQAc2AmW1Nbmcecgz7QBylAeA9g=" + } + } + +, + "dffa7c46-3074-4bb7-b0ed-828f11b1148d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QNQRnT8a+stLG4BFsfYAYFHGAokqDO3TUgGbWazoH2A=" + } + } + +, + "47ca4744-bca7-4baf-bedb-03ce2d6bcdcc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nmViBrxwc+6bNr+zzFDCn493cRKpZmT2giykr9FO3Z8=" + } + } + +, + "479a1c0d-7557-4d4c-bf25-937925e16323": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tWKAKaZLBojdO/mvhqO0G6Rwkz2zXRGQxCHis5u9qxs=" + } + } + +, + "13e86a08-fb43-4776-a104-36a0097a8d1d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "03G/dfTP+8JDtCS7tGgrhcJjrGHh2ezaWq4/p6l2NIU=" + } + } + +, + "31223a84-4942-480c-a9f2-e5586aff6fcd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5ylesMhcB3jOh7yNXdLW2/Y7TaTdShBg152nkUDMyds=" + } + } + +, + "4f34865b-626c-4319-8768-5ee051b13525": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wlnU6mw9bohOY2kkdmsAVNNLx/55K3mQV3lyOGt1H1Q=" + } + } + +, + "e3e576d5-b161-4a9b-a447-b08cd68f009b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zTLqr+AQoeGEPduJFFd0PNwg+bv1Brb5nSfAlQlJazw=" + } + } + +, + "5619c237-ee89-45cc-b12f-77a1b8a6eaba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kdzSsJJdoiz0MkpJ1rBmt4DOwaSHS7U07ShRVcuuebc=" + } + } + +, + "d2021d02-8c5a-4780-b1c2-354a5391b7bc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SpSZC0OxQxovCm2LUZ4LhVuGih9Wp1QCNhB2l0yAFIU=" + } + } + +, + "f231344d-0f90-4329-9a09-139cc0d7545f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gqaNYn7+NVghOENLSARIVZO0nnZr6CJAOCJYV1UaV1U=" + } + } + +, + "b2acf4f8-ec0c-40d1-a6ce-1096d9a44be3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fOf7up8Dlzxli+9aj5nX42316K6KFYAkfJH0RpKHyOM=" + } + } + +, + "d45f19d6-1daa-4592-ad02-e3df7f434034": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AaRtn3reYoLLgBiA2cTSIhC2fotvyHWa0poDnMTazSI=" + } + } + +, + "7854c573-faac-4eea-a3b8-c3f9f46fc809": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "51Kp3fkmm/BXIcdrxUe70vZAusnsMIzoTjvcd9hZpNI=" + } + } + +, + "091cceb8-3c24-4252-9ade-68a2c613667d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cdtRlJ8M+LNXGgymC1kU/WDJQoCKGu+rTgAXuhZHC/0=" + } + } + +, + "ea051e7a-c787-4354-8175-9c349a2c6286": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "s6vJYWKY30VlzbuicNDHVaK52nV3jshdfNegvm3O2FU=" + } + } + +, + "4a0b4c96-cd32-47cb-ada6-1930bc369343": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lohxWhrVrhDVkcL0fXsZ4YeaYk4Pw7kIzIvZ6GBlBuE=" + } + } + +, + "1618ed52-43df-4f77-8e8e-2f4663bbd240": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YxWsBhI1bMsuNA7saIoGZ3IHvxIHI3vTNy4V8HWUGWc=" + } + } + +, + "5b7f0ddc-6479-403f-91c7-843fdc049d40": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AWQDy1e+LkW2eoWTbyr0ERB2EN9CqDldr2Cej3I06xE=" + } + } + +, + "ab4bf76b-88fb-4ad5-bccf-34fa2a9e9b4f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mudHubFCThMRM90YzcBXQYv1VK2kVFkLCCnGBNDeSEE=" + } + } + +, + "98b608ee-0b00-4c70-8f58-035c422d02bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kXjtFWYHLt00j9S5Ij+TTYBq/gFzETnFLZXPpT8hjE0=" + } + } + +, + "b414181e-0d16-45ac-933f-4061e0cd1b11": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fQeAAPcyvNL7N5pYk2QEbmwVkxTiJKvK4i2BRI56G24=" + } + } + +, + "8909068f-dcae-4a04-a795-6a743ee995f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vc02gyVLz7o+m5GK9glGWETfJZcwXdiiJ4GKlusXWVg=" + } + } + +, + "203d42e8-b493-4e38-8b16-43908eeebe96": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RsrDU+s09caI8bWl8TvvhVfY0Ef+IuLekeuuuewl8IU=" + } + } + +, + "f678f58f-260c-478a-bb91-7ef0b329c82d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SNQgHFG+8Z2X6c+iG0lcYVnGMwhEqOaFjvPUvgZXQ2E=" + } + } + +, + "d530a331-9cf6-491b-89c6-9b2e4e5a0d38": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "v6U+wEFseSHI32NSLvBY9q63LdRUem450cV4TjPuR/Y=" + } + } + +, + "48110ec6-91a0-4a0a-81a4-b13f89fc6fb9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jPr/oZ7pusPGwQ2G80Yn3Z3o7LWL/63b39sWmu5YON0=" + } + } + +, + "8da0d2cb-5d4b-4f16-9aee-4f127a7fc831": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+pUMa5G8/Ml8Xt9RZAyNVOuHH3+EquvRZUTETXkSklQ=" + } + } + +, + "363c1bb4-c822-4fed-8c7d-812c1d1b901a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Do/RxR6dimYhs+ZZmWp0zx+dwtELi51+OKn9RYR0a88=" + } + } + +, + "3360b51a-5e86-41d0-be79-b3ca2b8dd3e2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Va/7UGZBeTz8xmzUvy6ztUS96ERzV24k5dx3yKIwrLU=" + } + } + +, + "88dfc068-420d-429f-92d8-3cc962de0fb3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UXAKZd7Q1sy7k5domEcgQ0BiGXHLxsHUoomMdIVZP0M=" + } + } + +, + "efd3625e-26b7-4a29-96fa-f71f7b38ec0a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sogRsTKnElEq1v3fAKoW5aOaAqUnsQVJM8zmwx20CeU=" + } + } + +, + "e6750d67-8a79-43ee-8dfe-60beedeca774": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GaVE0udR0XBBhH/xHSRVHAi3V8byR8ZoWJ5k7QA6Shw=" + } + } + +, + "a657295b-c211-41b3-9c55-4099d9a1fab0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Dxmla8nE9kI0eg2N0AJavx4Ltn/c0uFaLWAWkc0cRb8=" + } + } + +, + "65f20161-a85c-4a2d-8f0f-8002765405d8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PmCM1kqpkuknj94UGXAr3y9yn8Jfv4XxPpXFCARuNN8=" + } + } + +, + "230b596b-b6eb-437f-a8f9-bea3a5313883": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5FkeWYN0UuS6pCIvELcwrfVLDU2WYkX8o745Mw2pL60=" + } + } + +, + "8cff03e0-2fbc-4835-8a9a-f7257148cfab": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8z12k6rkteTlia+9bg5Ov+IvZYe/8qL8/JO0oXMQUb8=" + } + } + +, + "77324f36-e2c7-48fc-ad5e-345a0e171f18": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GO+r2LWrCGT4ECuaL7k4kwn9uMygvR984QowhjKnJ5M=" + } + } + +, + "2ae59dc3-9fea-49e6-9009-3299b04d09bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KtC/qoM5WG+lqXUrewnjdjvCrL6WL093vLNuN2YX/HY=" + } + } + +, + "735fd1f2-2c41-4313-b5e2-308625f49a6f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6sVIvHftOZBf56PlVu9ZX/vXW6hi+y6IRv24+UvxRl8=" + } + } + +, + "ac2c0f09-55ea-46f5-bf8e-b35a130307d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CFvIjga1qfAUCnzR8cYGaBlJ25oTo77oDRBnzezYGWg=" + } + } + +, + "53bd9e67-e41b-453d-87b0-cf165269674c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hzg2MeUYZJ16256KRxYpx5YqJSXwDnOFY8GFlloINsc=" + } + } + +, + "bfe947ed-475e-4472-88d3-116668be7429": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YDz8JRRrVQjZjJuVakaR73Eu7zEBfUIQwJaAiXdYju8=" + } + } + +, + "65c64a7a-73a4-477d-97ce-b95deca63af5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ypbr1pqsegzp163elyMCcduE+MKPum0U8M22woo9HXE=" + } + } + +, + "3737fcf3-341c-4532-9cbc-36388f1c05a3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "u/ikEHQorJb6AgnqGwXAfKrqtwRhPruO4xgS9gYb33w=" + } + } + +, + "5b58b246-3649-4e23-befb-4c07432b7523": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sHPYSO6LSP3urn+ArjuOOaFhy1z7nV/l97RknLMlkTk=" + } + } + +, + "7ddab643-a334-4d41-9c04-0276a3332756": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "w7hhHqD50Uw4koayWrbaQtKqcgq178ZUIYidrkeoxUI=" + } + } + +, + "af40854c-a9fd-4a4a-880b-1de19285026c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "usomQUe2eega/3actyYAlavYNVVSoG7wA+VtgKo4H5U=" + } + } + +, + "a9acab3b-7c61-4881-8f6c-db73d351f7ca": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DIoKzahpOK3noUq0fQtAUh2YGdm9fy+1/rtRqGAVX1I=" + } + } + +, + "32c0a2b3-340b-436e-9ac3-05d8857599d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HYgpL/qzPxEopMNif2o0swyaOjvvpSgJMb7YfmJ0K7M=" + } + } + +, + "913d0a99-541e-481d-9881-c3c5093b6a70": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4ptV/TqyVizIXaWaiBvQ3POJRukvpEE00Ue+hpUFz9w=" + } + } + +, + "89e4d109-5692-4977-af8a-ee00902b613c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gYE9dQIQiofyw2ytZzPw+pCTLmEXBp2f69l3sXot7/o=" + } + } + +, + "32887223-24bb-4fb7-a969-83f7c601b35e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "loESMrTis6bV665R/9LoUYeTASah9KS+zPG1TeLM91E=" + } + } + +, + "c65839f5-5755-4ba1-9605-3ec94ed7f8be": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GEugbJIoiXps0tCIKfveqAlZs3iHPp5idcjLlDTlwag=" + } + } + +, + "db5c8fc0-1472-4a17-beb9-2637ab8ceb1b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "n+siwmU+e8dglW1zK/wu4o75MdZwKGzfeY92bzbiMeI=" + } + } + +, + "05309e7c-0ab0-4890-b5bb-dac166997413": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7pebEugJ8GtA8uGxO715Kv+FiAb9H+dzWej6rSajZio=" + } + } + +, + "ef657fc7-d46c-4f57-87e6-7d3fcb912379": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ceM7o2KO8VvlfmzZF3ANlmDxKLd3mOZD/GR3xQpuEpY=" + } + } + +, + "da87c56f-08c5-4c6d-8a84-7a4fc0620764": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LlrG03vWCZMnt7E1gWt6Vz9I1cduwB6LPq2qKZx1ZVc=" + } + } + +, + "b9dcd191-5329-42cc-a7e7-e870457a30f2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "u+Bh76xvyxVzhPcCESQ5Sarycvu5edwNap7sHgw6Jkk=" + } + } + +, + "b45a20ae-c376-4fc5-9aa8-6b9a5acc3c59": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iRxc/b4n8/MW6lPSgKbjxZgOT+mrMeTrD/BIzp24/MU=" + } + } + +, + "05d35ff1-ba92-4689-b93e-1e8a4d0c2d32": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vdrg3TuOZmVXGMjqhSXMK0TI88kumHF9TgLT9pg70ys=" + } + } + +, + "95b389f9-b5ed-4164-b70c-b401033ca71f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZDHzBowT7wqyVM6I6HgScHUj4BKZBfgSq07VlPVmDXA=" + } + } + +, + "121d7de7-0089-4fab-bed6-1fb632f6c94b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NiJTb9SFCkXmjXjlekMkeicwQHvBkx1d/5dj+WddO3o=" + } + } + +, + "93f46b3a-0f20-4275-8abc-34c958caaf1e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qnrvk26+7k5xPiiNtmafvrto/Id7qPlWaCQzkat4gL4=" + } + } + +, + "333e5aac-3c85-4395-97d0-e7b99c1b6272": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GOQP8V9aplyptZOF4fRcagn2HOVKTLFEsK+ImfzqQ2o=" + } + } + +, + "71bbfbce-ce3c-450d-af21-a0fbac108524": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ws8AE49bHGlUnPUydSG1d9PdEweaTQtxTYbuLmg/qnc=" + } + } + +, + "466b21b5-4f55-4f99-ac4a-7ac8c8ff8852": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "awXD9OxlYtSD+GcQEGFD23oX0OD5c3XMmuJ8DA1/XNs=" + } + } + +, + "f431e916-000f-4088-863f-80470dbb1427": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/vXW5GJRu3ldpfh46/EAlO/nxfB3R6xhRL/jZPbvH5Q=" + } + } + +, + "2f1c11f0-fce7-4186-b8b7-c7e694e52ae9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/nbmZnFO8Qw0bEFM2yRNrO9k9XJkWOYULXZaUMY6Uqw=" + } + } + +, + "b6d987a4-730e-4986-971e-43bb0f0a73d4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UDITpBGQfq8uUD10/EXgfUEgALAEhmm3N0omaOFb/30=" + } + } + +, + "e461b8e5-f206-4ba7-a35b-235237f4daa6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "d0vt+7eBINipLlujaO8L+WZZ/u+ilzfAsDRAv3XxFPk=" + } + } + +, + "bd8e4c2e-8f70-4b97-9de4-291c7bd9fc14": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tTDefixqIAGB0ylWkBuP1KQizWo5fDcZmMkySo0FkNQ=" + } + } + +, + "484c7ce6-f928-4414-abd9-f304d1cae421": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LLWZqTzvUn9+0jZLP7cONj2nir0p+UVnZ8gtVyKpETY=" + } + } + +, + "d976da0f-8bdd-4fe5-8dcb-0640c6503e9d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aOR9w1ulBZ/Xh3CENumoRXn2btdOsxKHzp1rmCv3t0U=" + } + } + +, + "84d865f3-5da9-485b-beb4-66b61607526b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "EcSbrjh7nMwiAuQTUVFCOwDWiLotbYvUOxj/D0xPXTs=" + } + } + +, + "8dd71463-b050-479b-ba8e-dbcd48d78cb2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tqJxVBHFXTyOaBBiEq5vAaewYkAE00okl3ILfg+wcAE=" + } + } + +, + "d39c16cf-a751-48f7-98fd-2b8a246bc99a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oTBbxpFqqG/Vr9iBgLgiIbAiSNKEfL93zLXDnZ2mPSE=" + } + } + +, + "2c9dcacd-74d6-4dfe-9300-d5a2be4340bd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "i79hzuKu2w/y1kRWGc8pWJqtctr3uMwX68xfSgTRNlg=" + } + } + +, + "e4c84f66-80c7-4251-a780-4affac44e792": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VCyBlJHUnR8jxcrmjWfBTEU+koCEwooHOt/R+pB53kw=" + } + } + +, + "51930c98-2197-440e-99e8-231932df0e38": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BOtL7wjMibe53lwJPLAXMxX5WPsd2p6voMRHFSGuCDM=" + } + } + +, + "a94dd2f2-f223-491e-98f9-95a8b3c47571": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RV67pX5IhZpvFTOMN+eFn1RMqLFrXpKCdg8okCr5mp8=" + } + } + +, + "62154124-fdf0-43fe-89e5-02a3a7d66bde": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9kKPDUbnS8C9ZTgYN7FnhedQnBlT8VzYpH8jBCqveIU=" + } + } + +, + "04552555-93bd-4f1b-bbf3-c349624baacb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hQLVt4NUJRz5D6lSMW9jiZQQxqOWQjIE4BWyTixxfIk=" + } + } + +, + "494fe446-34e0-417b-b6c2-6d8722968381": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2hG6F1WrtN0N/v/fuBaryssDqQNAvaPFFOTkw6UItMo=" + } + } + +, + "9728210e-2d7e-415b-8e3c-381e81c5a404": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NRR8Ye49aOuxhQaaDlbNKSQGb3X7K3/zqJ8dhhNI0ik=" + } + } + +, + "0bd210ec-57bf-44db-882f-e023bdd3d042": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4zotyBNY1rccUBV3pukxe/IoPtwGTsGvBUoOa7v3Lns=" + } + } + +, + "37dc0e13-43c9-4526-a70b-f8ff9fc7d3af": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8SpX6x0cb71Wwo77Cm02Z+A4RP8ICnilT9iV5xdzKWc=" + } + } + +, + "7aa79a76-d135-4103-8b55-8bacefa95348": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uh9P45KiHA++TsHCj6TbRKsNXPeHtAsXp1Ta3pK6xEQ=" + } + } + +, + "3cb4d3f9-0279-46c3-b5a5-963265d0cd17": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WjP+xLQoepF1as8cjMxvH0sh7dChPm2JbHDUAJHScB8=" + } + } + +, + "66f82d1a-cac0-4d50-a69c-144f3f0f3084": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "p1AjsZ4ndRYn4700JzVTwrZCMKWLMWIOPvmmKDorTMI=" + } + } + +, + "fb137e68-783d-4d56-886c-0fe2e8bc4535": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "e8/+7HShG0BkK8z/A3Kt9Wrd7fhhtwxYfTHX4x5ssvU=" + } + } + +, + "db6e0845-8c8d-44fd-8d82-0acf02170ba5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "U8yPjUxyS4fKsZTRPGssIkLenJlZZFyf06uPzSF1MyI=" + } + } + +, + "6a8d6a11-6f06-442b-a774-5a5a1a5a2b2b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aiLnTwH9iGh4OI3ouPDyA3sw9FsU659wYSKW9KXu7QM=" + } + } + +, + "8dcb39f0-58f7-4976-a70a-98fe9cdbc278": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8m80IpLCQ4bq5FsjsBAJxuN9JzaH1FSe8/5AP60OFsY=" + } + } + +, + "f75c2c0c-2b26-4ccd-94cf-fe9e7b3c0bea": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1M7qh9Sw4URz3iKdVcfwVsXc+ZPBpvZcasQ5gUjZ71Y=" + } + } + +, + "e20fca74-e4cc-4487-a01f-7c1aeed72ba3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "S2m3DaUsmVVQYMuyueD3h1p7pBmwOo5NSXrQrqT+6Ic=" + } + } + +, + "de5c95ee-cc51-421e-bc40-58311cfb0ff7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bu37cXMWFTzR40sJmWQo93//6GVmAAIkyPlQFYR6N/c=" + } + } + +, + "79de52a4-b67a-4199-89cd-d0800d630801": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wo5kyC7rL7Fe3eEd7crzqEucd9w7/TipR8f6AfDU7Kg=" + } + } + +, + "9e2adf35-311e-49cd-a333-e326315be795": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wnU0GeS7adfR3HgGb6j10NNnJw3xrX7PyMZjGnK26tA=" + } + } + +, + "190f96ec-faea-429a-a9c5-9abac891bdcb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wjN8rfk5EmKy2kDLAKmJ79Mhb7nsLwV6q8Bb1x23lu8=" + } + } + +, + "809dc335-50cf-44c6-997c-470e03409d25": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "INVHuLhPLWLdj3wV8gqx1DHHVKytWTp6xJVnCe8UrtQ=" + } + } + +, + "c0ca18fa-24a9-4197-a881-43892b4074f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+eI3l7GBvmzRsKz6cgxEx+jwJIOkl6l0yKq35m8SW8c=" + } + } + +, + "e179fe6b-ba38-4a2b-8f35-75e3617953f2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+0ecrj0Cubm6RJOgHLEDhepVj7ooFK6ho16IvAGvHIU=" + } + } + +, + "2094ec8e-765f-4239-a925-d53933b4585f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZfCGtrQDlP23ahz0rBtC6nTilaKhFYPlrnAH6LEFXeo=" + } + } + +, + "71338d7c-75c6-4b7d-a535-fdac51d3729f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Cba9X4l7n1xQwZt8e7Kt1RikrkucbYhESduAYGasstU=" + } + } + +, + "f8673331-480b-4608-827c-3fd5879a90b8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Jy/nD0axIgARFWbCxWvstDY99BtTpzUYCA993th187Q=" + } + } + +, + "f2c23025-0258-4da0-a5b9-f39269100302": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ofLmbx6PwiVuJJJG1SyXwrDg9XsLmdU9dz6JWsgyiMI=" + } + } + +, + "37ff1edf-90f9-4d91-ba5b-191a3f413910": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mV2Ilx2j0oSZ5hI4ahjK94hPm4MItcWcgPwJJHcG1fc=" + } + } + +, + "ddfc92c1-db96-40df-8e75-cc51b33645d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "siluD0CV9pXJx/XUGHivuqM7fRtVg+GN0N3uyAVmsLo=" + } + } + +, + "57992d5d-d0d5-4637-bba5-d8a97ea98f9b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "g3PXJCy+4ZytUUW35voZApJhxDA5qPaEtEteq/vkBgI=" + } + } + +, + "be1c57ff-c4d2-405f-bf8c-c9f155f190e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5bUKfpdYd3LAHLO5bEJnqPSnGWqCTmBq2QaopXFceKg=" + } + } + +, + "bf702d42-1333-4423-9b0f-ad161871c36e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cYZQ6aBVp/+bgYye+5gKkWCUQ/21Q7DngpuXguaGFZE=" + } + } + +, + "b116708f-9fe7-461b-98d5-529725ce1cd0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CKySjnWddiPq2wxAo2w6dBm+gZpgi2E788EXXL5yJXQ=" + } + } + +, + "0868a410-92e2-48ba-a151-895c59e498d5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "COQQlpOV5RGq2h4fjFGv4Bn2A4KGg/IJs8AFA5FPsOA=" + } + } + +, + "3caad17e-9570-4bba-857e-2ad3744f1059": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CoLhzVVoQcT2mgj7IFro+BuQ8tlAflbc74AT5z1E9/g=" + } + } + +, + "5a18df37-8843-479e-8c45-241f33e3e21a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "t5RTzjLPFEhamtk8d6086qaGQNon2QNQQ4DCIGqzI+o=" + } + } + +, + "d15a2791-ab02-4754-8c46-94a74dd44b43": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZG6qvx2C/AxEEdsGjSbJ23V8uasIlOsUXQvAGpA41ts=" + } + } + +, + "c3be7c59-07e8-489a-9308-834ca70b3c6f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "s9QEPbZgQH++wXq3vJVAWaLGFymjdldnp9thq6GLX1k=" + } + } + +, + "9e1bfee8-13de-4854-aef0-e90c64052ebf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TNfzhyk0bAsewxHy/0kewF3F4JM8InsTB9kK7uJXAcA=" + } + } + +, + "266deda9-876c-437a-bb12-8d61fb05c4c5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lXy4eUbP7EKLfU5H+XS1qYRuq21T2ftakmdVW+Rqqqk=" + } + } + +, + "1f6a5a72-75c8-4187-84b8-85fee313bd12": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PtAS8QHIDCa9axy1cLg8BC/CAeUU3hs+pHEHqW2mIwQ=" + } + } + +, + "558f495d-db8e-4be3-909d-6affd15220d4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ACUXvGn/IwKg64QR0olAIxE3BKh86TQaufGfDc+XXyM=" + } + } + +, + "ace7bd18-d508-48e4-81aa-57fa2f02e3aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vg9uIWF15eZhGtdS3P+/jK8dfTV0Y/L+eADMTsHhoIw=" + } + } + +, + "f2ebc263-a8ec-4f93-ba83-9a6890d1b960": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Mxy20R/fkj6BsdKzrY898yIOpcUKyYUmmKvJr7CRIvM=" + } + } + +, + "42d14995-80c7-49f0-884b-c930746a429c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8z7S4sLi6Ohmu6SDbbPbNOIswfbX9P/wf6G/n3CtxDQ=" + } + } + +, + "4a51a147-f387-4829-983b-ab3e0ec5928d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3XplyybXPDFBe/9/cUPcK8xodt8zwSspWGHkY2xdwys=" + } + } + +, + "01e5d203-c6bd-488f-9ce1-739a44fe019a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qth7M0/D6wgat+Uj6WP7C7vKaCda1fwQA63+P/R95As=" + } + } + +, + "2ea0b0a8-9f60-46ba-88b0-351c198e92c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5F/UwJqyQGXg6lB6XbN9jvVNx9SPpFd9+fBLZkCtYo4=" + } + } + +, + "3f36bd99-bc8e-43f0-a31c-f2f67daa664a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "j8qAYdyriI/hPaiS5RvVlZ7Yk3XJvZ+X+CezjvgFypU=" + } + } + +, + "956b9bc5-2faf-4321-9db6-1382140f3be3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XjvpW2BDTruvDOUhk0hThk8p+k91VVmjthb+PY5WTIY=" + } + } + +, + "d3f4bd9a-3f2c-4286-9a1a-44dd1a646b9c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "x3aOhyf17LF3gznDCQXVGtZknZMy4/upbpki3xQbyho=" + } + } + +, + "33c109d5-95fa-4b87-9139-4bbeab0052a0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HYzc8jTfNwnhwI2k7Fzymwyez+YhySAR+NqWuPFC7Zs=" + } + } + +, + "cbcb81d6-20e1-469e-b2b5-0f1bcefe3a65": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LItkIj2pWfOqiNAzhgweoD2ZdzYov07rs5LLL5sSAaA=" + } + } + +, + "8b2ae2e1-3380-4e6c-8fa7-694035f6f46d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "F5g9i0FwMzT4RTVd6VktWQaKLp9UZiQs4V8uQfRHMlk=" + } + } + +, + "6b133df6-5bf2-4105-a357-ce5fc27bce00": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YWRxNs6E2VkKZt4AvIqiR3B2YiLbks5BE3zFHKGUvUc=" + } + } + +, + "15fc1d06-4abb-4c9c-9600-25e9a62f77fa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YD0yaXyvLvbg9w4RGfEJyXEvIX1puTnu+e0VDQTvFsk=" + } + } + +, + "dedfd3db-55ec-4234-8eb3-b8cccb61bffe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iVSNVNielnTRskV1ceLqbJhGnkDNiIFsyKheaWz89Ww=" + } + } + +, + "3904f1df-e5ac-4915-a0a5-abfd837d2b58": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Sr4hxUz/fV+fvMIbjsaz7lusMtFZ6WpHhqbZB5PYrO4=" + } + } + +, + "24393ad9-97c9-4c3d-9cc7-bbcaac49b741": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2Zh2rrG2vWCc+WXadFF1pciKZbqkoKp4heN+xmlPaqU=" + } + } + +, + "a6d60e80-1b74-4b74-b4bb-0aa0c7013e78": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rEzbWLhp2tEX9c29/1o8fL1eyEytf83JDu/WoeJEI3w=" + } + } + +, + "194213c5-42a2-4197-bf55-93a7cf1acc76": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "eXjyq7LVyLfiMkmLuNmBCGhq4b+nw9+v+yhSl6XHngg=" + } + } + +, + "1e305557-7897-400d-8b3d-df33beac7d42": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UjxbnUoDtd6ARkbSnNlw7kMuSIlfFaLGmVxdzoHHb+4=" + } + } + +, + "de3f556c-5fda-4d5c-a9d8-54757a0e4d03": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5L/PhKNO1kYJJ11RHXtPlPWt3JC2WMFeED1GTQBlUJQ=" + } + } + +, + "93ee3af7-40b5-4f54-b551-e71230a8f368": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KEUi8iQioA9fM362POGaFTlXMeYxNLcXRillqiH/hRU=" + } + } + +, + "5a32e5f1-18a1-49c8-aad8-fe01588a95d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4fgiZM6fWgVLQG+omh/xj/DqMXDbiU0dUlp0tIcB7o8=" + } + } + +, + "f3f6d485-2901-4f6e-b33d-2b1be5237818": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "caiQdPgjziKtPXtNWdE8n2C6g2DtNdk6tCdgUUTPI58=" + } + } + +, + "d00a4758-5bd8-41e3-96b1-0da5dc9a248f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MaaoP5UAoPBGC5y3u0M/iiC0uyuAFrfoXxGHq6ZdIIo=" + } + } + +, + "368e7475-3310-4a90-9be9-4c9cda102a49": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "l922C+BGRMSI/B4NoxMmv4bPpR/1UFPckeYFEb4NOb8=" + } + } + +, + "1e6e897b-fde9-4537-af38-f7d6e0779413": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "grqYDya3QIXzGlHGDrREN5OoixszoVed6gBK2hOqWzc=" + } + } + +, + "008dfe2e-b8b7-444d-8eed-592e1f3f7426": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mQWNDLpg212Hi+RtkdbxdYgXnhivdsxFnpH/cYzI7nU=" + } + } + +, + "f93be057-7e5a-4852-aa27-a56e7cbe5252": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+h+5SQ+9bOxYgui+AwmnJOsNql0aq3v0QZjzoh4XuCQ=" + } + } + +, + "6feb1060-8fa8-4d2a-95c8-23b46a7bc665": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "v09J9p3i90G6KjRBNQlMBK5dWuKI9OBZozAvXSgXUwQ=" + } + } + +, + "e64c58cf-375d-499c-820c-dea0fe0e247f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "803jwswJJ5XKGgjHDLhx8+Jf8NbZHzCN0wAT2xGmbvM=" + } + } + +, + "1ade4c39-2828-4624-b783-5f68ae6119cd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/2+apRtt8WzMk3VeoO583u59ibEOe+Z01YluQr3wY94=" + } + } + +, + "ba254c79-62f5-4931-89d0-e6787944b950": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aBJCg8WLV9JfaZNQXLcAF3kAUZfQnUDKRnOITEGpHxc=" + } + } + +, + "5d7fdd1b-8f1c-48bb-ab46-70a1e1fe7b03": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1FwjiKGLrAveswejxA8KtsVOMJy0nbsTx6kcv9kRFbY=" + } + } + +, + "75923ce5-9b81-4517-8de0-a7857663b57b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uMGXB6L5r9Eo4JCuCm/8RKnThBO377jJMfqLshdx40Q=" + } + } + +, + "d6e723af-b653-4255-98f7-fd0d72bb3f67": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "a/T8jVB6NdHdzWc66BZCKnrm75lFbCLJxNd8JvUIXSo=" + } + } + +, + "312a68f4-2df9-48a4-882a-6f7c7d161aa6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bd6TtS8/sHWD4fC0Rob+j3zMgKE6KadtmvvrqFuY4Y8=" + } + } + +, + "42633268-27dc-4986-942c-9b619240a33e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GDhY4H4E7IXzE2G543n8CwkqS/RrEvud6gl6pf5n4ws=" + } + } + +, + "c1ec1bda-01d4-4cd3-86f5-adb72659e05c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ljqVtb7lB9pRsWdvk+osIIcohqGr8xDCSKt8c470MyA=" + } + } + +, + "d08f81ef-512a-4110-b5ad-0f88d3bd6144": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5VCiJclslgdrvZHL00nCU/RCsTHceoEfcqeK185X3VM=" + } + } + +, + "9c3573a0-e5ee-4c0b-9098-e9d1cb6bace2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jbDbi41AlrFZxXuaGG9RP5yiyJ+YVoGpQN9ghgVxTj8=" + } + } + +, + "56b83af1-ca04-45cd-b63a-a1cd2ff5227c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BIamwMP3zTWvpGfM3/jlZRWUtdTW4dottr580MLm+mU=" + } + } + +, + "1ac44759-6bc9-4094-9894-5bdff20a7926": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Jf1+piEUlbBNvkLMOSsmLzTvbbI0AoKoVKRZ0CQ1OS8=" + } + } + +, + "8fb26eb1-555e-464b-a3e0-e691e8bc2a1f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mmwCC8FFMImToIt+iLShE4t+ER/UUyeRirqQYpWqvhM=" + } + } + +, + "1d3234b3-fedc-470d-a589-402efbe18676": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rM8baeoRkTfjIzFIQfwgqr3dCH3/B4Yv+jkqVFziP6o=" + } + } + +, + "a5ec78f8-f16d-41f9-a744-1a904279ee0c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wVdE9JedX6FgXKj+YjSwAtBFV+CCi0i5eUaz4n8qrwI=" + } + } + +, + "6ac3ad4a-812b-4cb9-80e7-2429e2f53909": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "53pFGAA1Uu0NUgDZc3B9x/ZoVgwVI0X1FEgbxW5uYsc=" + } + } + +, + "99dc480a-c8a9-4386-8537-625e225c1226": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+FDFMm0jUIMDOWc50OWGK+lC1iZ4NUebGiN8Jc37mSs=" + } + } + +, + "73e4298a-2c4b-4349-81b5-004e0bbef7ce": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/DiHFd6VaWEDESMj+cqQa+0qlAHLg355Ggs4P+TUj2s=" + } + } + +, + "562e75fd-8949-4ed0-b668-733d0b95d4f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gYAApQ7FVqmuovxaYGsD+ZCSE7Eb00Gxt7jnRn11HPk=" + } + } + +, + "a85426d6-faac-4c6d-9da5-4809a94a4505": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Hqn+hmwq4GWo8jy+s4ZZVg+77ZJ5PPd9segnoq6YRlY=" + } + } + +, + "162bf690-b1b1-47c9-85de-2b1a2773c611": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1J9zcAuKlHVFX5Vx2Xo3nsWNYGQenINtXEWObcRkKJ4=" + } + } + +, + "8f276480-b78a-48ca-b59e-e0ca9d426e25": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fg1hx0iuJMYEy6sms2SAbm8fctNduDPeHdGwOq56n24=" + } + } + +, + "ac1db7aa-3c63-435f-9dae-5cfb662e68f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DWMC/FQ3ep8kwG6d70C5MhxxEehBIW2HPdp1gfJepjI=" + } + } + +, + "c56e0b2a-e435-4600-b04d-5b11bd436dd0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mbrzFWGWT87oWHcZb3jSKIio4AF0gFjW8UJsBXJmzSg=" + } + } + +, + "198776fb-1e26-4477-920e-926d7afa72c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HXHQjhXpLwzeU6hYzzMAWgxjw5oA/zgUx0mzRNItH1o=" + } + } + +, + "5c66491f-34db-4e3c-9343-05ef094846d6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZIYnq9asQUhNht8Ohhbd7XWUNL/DulZQVJzEEpsIwu0=" + } + } + +, + "fcf162e2-09f2-4d06-9496-550a947133e8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "z8jLCXHjUpKo8XIcHQaUqd7a2B1k9UWKsetpAAAYi6k=" + } + } + +, + "05e2ba4c-8340-4b88-ad17-b3b67770f494": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8xlA97QPQB1WQkI8I8nMBeILU+OhGVcFT1hZID7X0wU=" + } + } + +, + "7f802e80-48f1-488f-8b5c-364ba945fa79": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FcSXPBHK8CWJODEuRHjbtATWhCgE3Oc9kCIqMllmxLQ=" + } + } + +, + "d82a00f4-4c21-4a94-b6c1-e23f18ec77af": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DrxGGrqUlDVDJGv4XMnJLR+uVQ6vgoMtWj5w5EHX1i0=" + } + } + +, + "3627a11e-f025-486d-a36b-99635db1bdba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WftXVoYijJKR1rlg/p9QOEjpREKTNJuKiMyifOOBTzg=" + } + } + +, + "5190a125-cc20-4c49-a047-92e03e0cac92": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "epiBNknBSz4JtIsuMZySDWuKkiJc11wmEK6QMiyCjQ0=" + } + } + +, + "f783ce4c-1fc0-40aa-9238-171ed8c1fa48": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jpMskhkRi1Fdnr+cQWaomJ+BP4YMB5xJRISkgFx4t5g=" + } + } + +, + "36fd9282-6397-4e40-b266-fb1fe95a5f60": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8QPkWHlsqoLGWIhyY17OOeAR90xser2a30KTbn5A0Tk=" + } + } + +, + "0d725f34-3999-4800-a09d-a918c8a7deaa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "41QONvcbnsfVqCdQk6jsNfJGHSLiDYnfzLI8TI628zU=" + } + } + +, + "7aa540f2-2834-4870-b615-1531ac3065d9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vKuvA8TRDiOQExj+nbVSmq25vBfRxxk7iQkD4oCrTZo=" + } + } + +, + "219e843a-0412-4fe7-8e3d-0dd822a7d840": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PpmGqh+nwm0CKi8tQ+tMDi+Llb4KsdV1GzA0MV71Uw4=" + } + } + +, + "85778784-e004-401d-ac82-39044d1ba675": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "eNOVqD7zJyeE5hMzBc2ZjGnBhrwr5TA/nfwILxjThow=" + } + } + +, + "93d15fbf-03c4-458c-a976-4771d08953cd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1HGBET575ahPVN1O7XhAncVjkgUrbfKwVk7GUvBmX50=" + } + } + +, + "350ef97c-4b57-48b8-84ee-9bc75c4742dc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9Vk+1bQPTMu3EsMvkBeze+RLLcGhGVvTrgjYM40JrHs=" + } + } + +, + "42c3a0db-7197-41c5-b064-1dd7c5a39244": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tVZRF2DHTxgUa7QNUaB47qREQgN10VgADXGvEUy+Z+4=" + } + } + +, + "d48f46cd-c169-41a9-95e9-119f9b5289c2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rGRKsdQzEOA74+oMxQfJVL12WaXBJQf4IvnxENgZ1lQ=" + } + } + +, + "4922d19d-3202-4a7b-8cfd-5f3e784d8ba0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pZUBn3TCgJvvIhME269MNbSHEoth1JeD9jgIGMaxUzU=" + } + } + +, + "8c526fe7-a851-4499-89b1-eb00a5d0500a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uY+8OhnObR64bu6vbJUMF6idry4M2HoGoXT1s3GLExc=" + } + } + +, + "cf530bd6-7721-47f7-bfe5-829d066b6909": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "heNU4WgZ1XOPVWs5sWby/ZTxR/V9D8Jrlk9wJax47f0=" + } + } + +, + "d5e5fca3-5b6b-4416-ba63-da0f441f34a8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CoGMwQ34ALwvWIzeQPGDKxuTn9UY7hekNkKXwl3vnCs=" + } + } + +, + "9b0b0b53-c759-4453-8d9c-fb5b27853731": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gB5pmN8pqE0fgeFKYAE8fpEMeozKP79VBpv6Vn0fI34=" + } + } + +, + "3c3403f4-8661-41c6-b4a3-4f37f49e3eb8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DRGAyrOlMB0VXWBspaAlthwDk96msycFDEd7cLi+OrY=" + } + } + +, + "51224ef7-9653-4e5b-a084-3ef4fcdbbf98": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GFJl/6FZDQa7BsCOp9lDvQlAduu0TxoeohzbkrrHXL0=" + } + } + +, + "4ba1d7ad-f96c-4964-98be-c281e0c49f02": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Y4GwrAB88teM2p9Sczh4I3KTo7gVauXPlcCETm4mZyM=" + } + } + +, + "5b6c9e97-cb84-403d-932c-5b1805c46f4b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "c5SzLyNuCOWlW4XRQQVN/2KGoDs2eB/9vEGezVwbUv8=" + } + } + +, + "c73613b9-b30a-495c-a254-61eab631928b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "JjSoKaZDZzjJDXrX2wtLbDcmuz2zVXAg0Bdhy8YVVGw=" + } + } + +, + "729fb905-6ab8-467a-aeea-538a965033dc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nLvc/VDl4iGYL3J4kwP3yY2pz+lF8/U5gTVpZI4d6Mk=" + } + } + +, + "566d1eeb-f973-4e0c-b8d0-286cc56ad933": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kxMaAV2xZzQqZm5Easd+IoIBCRVIp3AsM3x1WHfZYSI=" + } + } + +, + "fe576e8e-74ab-42f2-8fb2-30f36e448b29": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KowA7tstn1V1J+aeZ6cz/jueE/rOO4hNbD39gnq5LP4=" + } + } + +, + "f2477abd-9c68-48a0-ad71-2576678fcad9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4gYBE93Z/2D+9mFtfk6tqvMUEgfIz+h45+x6cWNQsqo=" + } + } + +, + "a74ecf90-deb9-4b63-8f5f-2eee9fb2502d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4CTpbSNcEJzXGivSDWxmffE2+nk2SgeEzgAwzhByeX0=" + } + } + +, + "69c09f1d-9555-4a1e-8c5a-733fbebd160e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NDAkJBH9XmCnGys9c6yl6yUiNzAE60l4vgEwIW6yuus=" + } + } + +, + "447464ff-ced8-4922-8d4d-9db49703414c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "upq74I5sjm5ziP2/cQz0yauIqPSbepl2apLmo2wS68k=" + } + } + +, + "57dff16b-5a27-46cf-8346-d0b4bbe4f804": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jTQaFWeukgJ0eOlJFsOJcZwmCQFyuIUabWLyVQvdlnE=" + } + } + +, + "30e89038-ba1b-4ffd-9135-77386674183c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/Iq52Jna6VbJ7EZ+xIO7pe2YqsyMzP5O0PZdYtmdpKU=" + } + } + +, + "04806ff8-7540-4853-97d7-08e4ceb233b5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "taEm+C78HpeHIkteMKNCJ6SzNew76gmPnjhQQi29XSc=" + } + } + +, + "38b2a640-0e8e-46d9-9afd-9a96e3d32e09": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5FUFumgrV1B/W8RvkuMWUvVHFq59PUBIZkHfc4/9CVI=" + } + } + +, + "2c56b600-8c89-446b-adbb-09cdc04b68b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "EUiuvQAtaJKscwJBz6lavwBavakVO3+KtWkZXdK3Rb8=" + } + } + +, + "a0993b6c-ebce-4009-9eca-9dc9ba13fb45": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qZsrp7S3/Gh9TUSMaHVsgbiJOLOhoetwZFdfkHVrc4E=" + } + } + +, + "513079f5-2b67-4a2c-a69d-444d2e6e00e6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nHPXgKM16pRBrWYXUc43vo1hxJS2I/2MWLd9C0zQKL4=" + } + } + +, + "d268ef7f-14fe-40b8-96f6-a6936f276b48": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vfXge8pPapy+zcf9tUnNa6zn82/fWX2Ep9fc4ahX0ms=" + } + } + +, + "c65fe509-7da8-4734-9061-50087f9deaf4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "0+RY0KeI9LUs1+s7ciIZ7ML2S8SynuOtNc3wJ288Buw=" + } + } + +, + "2581fa6f-f013-4fcd-8819-f881b2649b49": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5g4i3bVhfANQ4J2gsCsgF/ccMcmgd2sbSfqGvK01Pxc=" + } + } + +, + "13215f89-c909-473d-b1ee-4833288dbbd6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+OsidLFVOjE0I/9pY5yoCun5MWCkQy0pLTnkdX6Ctwo=" + } + } + +, + "21d2c967-eb22-440b-ac24-aec5392a764d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "d4nGisE+c1m+xyfEJtFpVWab1Z7UKGRBp9082DvPdlU=" + } + } + +, + "b93cf97e-f096-493e-9a41-0868d8c688fe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Zww9/EB5SBWxfmToxHhe0XYeLuhVb18NqGR/9NlmQdE=" + } + } + +, + "9d3c99a9-3fb4-4ed7-803a-25b15176fe4b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dGgnbCR/z/M31W59zZUQv2V6NHgxadjrLs91YdCLD78=" + } + } + +, + "337e476f-2570-4c0a-b3b7-ec206d705c27": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wZaDHR5FxJeGD6RJEnAgnNCEkAkLU9OPnxW/VQ9uP5w=" + } + } + +, + "b46327ac-5971-4f2f-9fee-6003e58bd83f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "htH7hUv3G0U43vlI5fQ7q5fD6JFe4QxdIcTiVPjqJKs=" + } + } + +, + "68115a84-ca00-4cb8-af05-8180c479f6f3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lCnxCloGYN4EQ8TS17aIxIU74h5PEHfGHVnfzsqol8Q=" + } + } + +, + "2d8a063e-b0ae-49d5-8d07-569f22279c4f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XrQnz0O7CGfVUXKxg+58/k+mNNtWrR9/zEtprZ7wY/4=" + } + } + +, + "bf20d6ab-a3a9-4a6d-9b4c-74bbb281b37c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YhETD59iRyhBR3udd6ALSHMDABuKdFAwWF1ggWq+FEg=" + } + } + +, + "2c49545f-1d27-48cf-92b0-004884337cbd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uNr3l2kIIGxmBU1qroX4JanI5IN8Hjd0fx9WdrOb5yU=" + } + } + +, + "1d0cb7aa-ae32-4ed1-a468-15f812e852d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Bx77biA2E9w5i3iiK5EgkxYM6Ho1IATEIJFjvjaPP5M=" + } + } + +, + "523eec3f-b1c7-4a11-817f-cf076f154867": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HbyLOfWh7j1kj/eeHFUC2wyumC3gt/klfZXsggFLHds=" + } + } + +, + "0b16332a-6e6c-4724-86cd-62ae04ee3b9d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5PYas5bDgFT0CJ10U19NTvXkCaeD1ZdM7RKGaE5BUk4=" + } + } + +, + "d3abbeaf-ff65-4f1f-9d5c-33f622e64b46": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ikfcgdHsfgtLdBBwtcRL1ptVz5XE+mkTUm4LbKjaVNY=" + } + } + +, + "ad02aefe-9d35-486d-a3da-9c2fc74bcbe1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2S92b3to9wSlUNO6I9swnMg9ZXtufuAcvErIpj7FL5w=" + } + } + +, + "46bd1d7d-9164-4295-9cd8-ff6231c5f851": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ms7JpKnn8fpyjV5M0Dt5GyPc2rC88ebia5dFUM0lZhs=" + } + } + +, + "629285c9-3d95-4c90-a445-30a6e81fae6c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wlSTPh4x4EhOLiiJRocUHdNGgCoLJ/dQVzQzlVuZCx0=" + } + } + +, + "35080d70-c864-4917-bb55-126d47c0a66e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UaFxr+aCFvMvHQ9tFeCpt0CzYrvzlAHrNgcUcQj+trc=" + } + } + +, + "30d15715-fcf8-4a11-b1a8-afa272e80422": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "eBEkIl4CzeCKmHF2wxWvB2kDNzZLFNr4k4Jqat4LsAc=" + } + } + +, + "619f99a5-25af-489c-916c-fb72eab52e1a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3C/PmRh4cySgVC3o/O6TwM093I0NbmQ8uU429OHwjMA=" + } + } + +, + "d770a452-66e5-4b7b-91f8-7b4332eff999": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bZ/sDYPLo/dmOJUFzPfZ0XyN/xmW3bTvfyKOGdHpxtE=" + } + } + +, + "5f3ef58d-e39f-45f1-beac-015c1bf73d9b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tx0Al/EcYD11Se8h7F3iBaYPE4PkCnclbFP0PfFD/QU=" + } + } + +, + "566682b8-6f8a-4259-806e-d8fcd3358efc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mWnIsKekSFheg3zFe/9QbYh726Sysl9AR5ln2WbhT20=" + } + } + +, + "7389d87b-2c06-4977-89bd-9bbb1ff57e1d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+ePiPF/+OGWH2VcMhxvVr+jx8ShK6C99nsNMEJoFyq8=" + } + } + +, + "b668c455-65ce-4b40-a5d9-d9776db0e7aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "eqWtZDkh4M92pkDalqNxJmu3vnAsN/fXb7xbxou9biY=" + } + } + +, + "da7c762c-8b0f-4a7f-87cf-4fe264b52f87": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BbTpGk0rQ40Y161fMmsDqRSm+g5YPVSVAc22Qy91HKk=" + } + } + +, + "ae22899e-f766-4975-9b14-a9675c0d66ac": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7h7YFzTEiyhts8AJt/v0xv8MywMh0pwwdKnbFarl68Y=" + } + } + +, + "3755a0c1-7ac5-416c-ad34-c24aab2f7576": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yeiE1xM+AtRFgKwf5VxVMNj6l8MGKBXMXJq3A/hCSjA=" + } + } + +, + "8e055e0e-6234-4f22-a48d-97a33dc0d33c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qOioECqWEB2NftBPVQrfW7n6uwQ/gAcFlGTLU0gUwFs=" + } + } + +, + "8838d632-b04c-40d8-ae39-345bc4047140": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lLSviHtnIZaHDkOp19nV/4WmvJxucTaOnhRYtcrHyv8=" + } + } + +, + "969cd47a-dbdc-471f-84fd-b8e9055927d5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1HLUWOGGIqQavsFYohlpesVgx0z0kDW8A6TaRL8Hdno=" + } + } + +, + "fb534f66-54e2-4f7e-93a5-d01bcf5b5edf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LjBCyLV4vsCN0yGCvJy1Cz8iUdygbqnYlMk6nqGCqgs=" + } + } + +, + "417f1799-3869-4e52-9198-ae79145c8902": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5VqAR61acIiD6bHg5pIfXPRIk1O4TGeQmvOq/PuMAFw=" + } + } + +, + "e09049e3-3602-47c2-818f-347692fa7e6b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Xu2NG1bchdimqNeVkWdxmE//ng9DypLAv7LMiYx5bpg=" + } + } + +, + "cde42855-d359-48ae-8793-e048fbaf636f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GLPrfnfMSRgYhUyNmp6suAmh+Gpi2l4AAZ9XkYeAs7g=" + } + } + +, + "107fb1d7-0525-484b-8aaf-66e2bbd34524": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "emM2tbQxHEDYjboQyIShi2txJaGhJwtYwZehDNWavos=" + } + } + +, + "8791591f-03e7-4240-a0a0-09b5a38f535d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TGsBVqFyvbTcbzhbd7xy0V15EkK0ZKqsxXUjR2qibdE=" + } + } + +, + "84b0c1d5-ebd1-44e3-8256-daca2b09784d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GQAPSgyQ8Ze21Bz4y++hxwgSHF4ZhuaPr84H5Nbxvsc=" + } + } + +, + "07fa90a5-72c8-42b1-9837-6a2daf7fa6ca": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "e38qz2CqcyyryOidoFIxn2ptOdt1vGQ0stLzgb1MLp8=" + } + } + +, + "02ee3b3b-acd7-4fd2-ad6f-1117896ff84b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GeQZkhGdIvq8bQfFp7GboQj2CoYEizXipXcc2bqvhKE=" + } + } + +, + "26097a0d-8c96-43d9-aad9-301def42f973": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LdDz20FKj7YqKPoxCBua1jzC4M9UXJiuMzLhLRUFhdY=" + } + } + +, + "3f325076-4c5f-422d-8db5-80950e669beb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G1owLBEptEys7Hgdv2G4TgpIIzgEP6NUtfZjAaJ/p04=" + } + } + +, + "a257688a-6a5f-43e7-8dbf-af01bf81682b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8OpXjCwcQsdITsePclEQreH4RJg5ClXfUVTck29PD60=" + } + } + +, + "acc7d5a8-77df-4131-af46-16256ef838ef": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5sgmEpOzB1GxDFsrKFkd3/faNQaGpRBJqBZANzVHAt8=" + } + } + +, + "8929c4cc-2e96-4d0a-afe6-8d0c0b775652": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VJ3iVkuQD8kqYxp6apgq+0WP8UJehhjRM3kBZneGNfs=" + } + } + +, + "926a1c40-ac82-472b-a59c-80798874118d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hdWBx52VmtwdaGasnpdrmZTHktOIg43EBHJ9sIOJdJk=" + } + } + +, + "8febdf14-cc21-418a-abdf-afa835c5457e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dsUjUhKdpewSEQ8xo+uGzWfXMEYHi7L0CwsULb71mc0=" + } + } + +, + "2c0c7928-c808-451d-8bf4-68459103d2b8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XKG27/WiHtlequ0+is+4fk2zpfvgtAnBR7D2IpfRp34=" + } + } + +, + "d6c22b96-7c55-463a-9f40-893d846be98b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uWnbqEdPPClxGlMHFAP9aah7yLxSWSsxaABIGwkd4mk=" + } + } + +, + "046c823c-2839-4e69-9aa0-a565ec15a2da": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ilz9CPKSSiH8BIh5xO+k9JtO7hznhF055R6TZdnxu/Q=" + } + } + +, + "61c93539-ce58-4b20-bf00-f0c1d305353d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NGNYFB48joTfMvCL32togSVxSwALKpmcxijrl8J1d4E=" + } + } + +, + "ff4c54f1-6fd9-4bdc-927f-4f8066ec0955": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6codhWPq1jtL2bzVKlVcNvjYDpF2/MEjUsOnyTdLQzY=" + } + } + +, + "5ddf39bc-14d6-442d-a846-50486b647eb5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Gye4pR0D2X1gfZLpT251two1q7EIFc5leWeJ9VJwarc=" + } + } + +, + "8b260137-98f6-4ce5-93f4-95c5a194e68c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Y4YNgZ1njBG4KJVHd1AC5XKUHpWIcZsJoTKOW2pOHeU=" + } + } + +, + "89f62f60-dd48-4bd3-b448-b992ff5b76ad": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ej41H+ncYTeMKfslsXnCwgMsJgv8ynYvlTPgOaxn3cI=" + } + } + +, + "5ee8fdac-826e-4449-a9f9-91af825982d8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "v0puZirhf41zmREeeb6p1q5YfXI/92iVaoMKAmSgttY=" + } + } + +, + "4f05e419-2907-41dd-9677-8bd1fb63e5a6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RqU5HF9gBZnbWGEO+iWr6Ve3KghKdhKBwkJ6Euc7tOk=" + } + } + +, + "41b24e50-6767-404d-b4ba-e4edf15bbbc1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "b5AppMki7VFxUgl9fI98r36COrDcNPpJaEgSYWGRY68=" + } + } + +, + "e63deb37-d4ff-486b-a389-e6cb600fc040": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KSkYAo38+uifuzJOiZ+W0Tg7CxaY6u3whqEpUpSBidE=" + } + } + +, + "d54c6752-b6a7-4a10-a2a0-6c324586d865": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PcNyu1Q5pS0WphOhZl66yyzRYa9BL7I1D7wIvXtApcs=" + } + } + +, + "71de6d38-af43-404b-a3c1-a903a20b499b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Dl+RFBafBexWEn+/eu/Vgx9NggADiRL0Twhko2fxyoM=" + } + } + +, + "ed5e47db-2eb4-4aca-a983-1aad09c374ce": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tygv8ult/az00hG/0bFgMF46POb8e+q07cgKo8yvfzA=" + } + } + +, + "7110a3fa-965c-45f5-b941-c36c4efe9975": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NuKpc2JaLA1o/Cd6HTOjPCfwumd3TDsVceY8ZgAtvDw=" + } + } + +, + "98ded351-377d-420d-a550-ace09b1b373f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8+K/tHAykG1c2qI9XeR78+LwrKBlJId1RcC5IUD6ZPM=" + } + } + +, + "56dce616-910a-4699-ad6a-cd5f75281e58": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "exhPHREiOY2WYXw6/GIn9GoKXAkENC6Vj3tnJuF8OPQ=" + } + } + +, + "d4f1d255-6393-4f89-a4ee-5c39160ab7f7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ylj8ml8OrA344DvlRQ9VUdtK745KGLsV4fog+VgRSlE=" + } + } + +, + "5fedb57a-8f3e-42ac-a78f-82000c696d45": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "b8LVSfpJjPbZ7QiHTfx5tH7Qxl3vX5vuwPcTm1DiZrQ=" + } + } + +, + "cc5febd8-5012-4f19-93bc-6f12881b8ef7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hmQPuTTEDKvbFYv25mGGHpd2HK0h0huzwg+Q6vt/mR4=" + } + } + +, + "f52dc78f-6c2c-4df1-9044-624d53f4b1da": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "s/mY2fxixvRb7LxCMLQIJKLri83pdNHsQvanXi2qFyQ=" + } + } + +, + "99cc7d42-90fe-4d78-af00-182fd34d037e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/xjUe07RGXM2XmUAPklnOe4Kx29bxw5rL0R+HCNXeDk=" + } + } + +, + "d5ca4491-c88f-4e9a-89b2-fd8badd4d6da": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ukc2xLfN7LgFbxRXTF0ZGqtVJdCi2/ugHHUPS1FDBho=" + } + } + +, + "c40949d5-8479-47fa-8707-ba7bf66a167c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bAOReoY4jXnqzFsF3CrGtn0Rgm6TLpph89ZAGcE02bY=" + } + } + +, + "e932cffa-3643-4e45-b56a-eb65fb97cc44": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Qqh+HmQDA58YKwEXxyaNclO6bQpxFRSHATEaC9o4knI=" + } + } + +, + "a3c24d1c-ec1c-4041-9ef4-d6335be10334": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8hf36zUvJvmAfuaf6X2k3uMF5P8gOTHhmWT9g/Rju94=" + } + } + +, + "07782c2c-9598-4ac2-99db-a4240e9fb3d0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FX9GpM+G4+JUGbA+t/wIUQRtVbDakPT6TQOrIqriF1E=" + } + } + +, + "7ff44416-d7dd-466e-86cd-0ed90e689e4b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BRhwl5ddDbJzyGer2/hlWRQKY4OCSxqqatJ8t8bmelk=" + } + } + +, + "0b4b00ab-f5a8-4ba4-b7b7-2a1dcc593770": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mqRJ7qeVgiwaCzimF+FdUYu2Wvqyg5U0AxEjugr/QlE=" + } + } + +, + "d7685ca3-a265-4f87-a736-06bc6a318b91": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VetbtnUIVMgx/rcn5S+DCkT5SKJgHkPQKOSsO/gxnAo=" + } + } + +, + "902242fb-22e8-4b6f-804d-032f5fd0c8b2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "OStKCgsMnRVtlgZ+hpUgXCg5WR4eGooNdIwdYpuLP1w=" + } + } + +, + "39d228d3-164f-4ac9-827b-20831bc0f038": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5ZTsSc3Q/AD2EkO+Wh3lZfSG/13YxusY7whYokcD+mU=" + } + } + +, + "0785edae-1402-45c7-9de2-f93dcba386c6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VrlecFICaqohsQi4pG0dKEerTWRHFH2yOKsTpLlzAig=" + } + } + +, + "f58c7dea-d28e-40ac-833a-6973e5515829": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tj7naRaLUCfFEODv5nyTjF8s9H0DnUc/3Ar78/tijIw=" + } + } + +, + "4c8e0117-2bea-46bb-ab2a-60b3b27d47ad": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TTaX5uUEmlE4FLk6VVF/NVwkhPLwEo1JIQ6iJkhPYDU=" + } + } + +, + "255cddfa-23ab-4e76-b477-219aab6e9e2c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Z55Besc5vFGlDkir/SFlinaMUm7SL6tJvBRTt+A/eoo=" + } + } + +, + "2d62c30a-4420-4e88-abeb-edaff1b6f9b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vy0AxC2axj/IiJkJc1uHaEY/E9A4jNEn0ZKCFW5FmGg=" + } + } + +, + "99629fb4-4105-4bf6-9892-7038f0dcce6d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YMzlYRt4aafBSu0kdY6B+XHe9nUObn6/2FD2OGiQnvk=" + } + } + +, + "3c6f530f-3b9e-4ec7-9a32-34624934e4d5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fZgIc/JDiTrKWy5lgn6nA2yKG2fnVZ4i00E1eZ9guAM=" + } + } + +, + "d1d06221-6cdc-4a6d-852d-030cccd15eeb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2q2dUw+FHMgbmfhjczhdysu/jkcakwvQAoPjf24mQso=" + } + } + +, + "e2f3b484-3eb0-4e21-bb75-152f65d919c4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GmO9kC/GdXgld+BKIs88zwtxroQ60GJgPG37Vj/RI88=" + } + } + +, + "a3449753-19b7-496e-ba97-0c7d4ad9b399": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rznVEa2sHvCozIRsAdp2ML4rxgW4ugnosdafcBzEaTA=" + } + } + +, + "e1dcc39a-0212-4b07-812f-ba70e6060e9f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qTbR7M5gRwIn/cilikC1qbgkwvjbdlAaPufTuZdeqqk=" + } + } + +, + "d2b6be34-5c72-4fdc-a353-e7f9852c55ff": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uvda7gozgmfT11SejAbC5qvlSfofJZV/ys1PgpEY3eY=" + } + } + +, + "a35c411c-dfab-4a44-b753-b00ac2c4b3e1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fUOFSbIlRrp4IxpxeIfxQ2xRll2nM1GiYTkBbWWZ7kM=" + } + } + +, + "aefb227f-13d2-4e3f-a99f-0ae502a9216b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fKjcAIFVMU/fp8QWz8Gr5226zxSUQyZXxr3fCtLftOc=" + } + } + +, + "75478883-24d8-40fb-ae95-5dbd506fe196": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Im8OP+gFeZjxL3OMj9rdTTN9HSv9E26A6DVokJLEwk0=" + } + } + +, + "de5bb475-0a5f-410b-996a-ae31227c8f2b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aIYyJ1xBJ1KJtNoAZjgKwnmUITNJVzBKkK7BHHsmFcI=" + } + } + +, + "22d5eda8-86cb-4268-a0ac-c002b9dec859": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2yLFLPTIpyD/S00GKUyEwcow1jjh3rA45lFWGjRSm8E=" + } + } + +, + "86050e11-75d9-43f7-b79b-6d410b4c5d89": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "K8d+g3ZuzxSr2XbyvBLB4zrVbZdjeNgMssNt7qEM3uM=" + } + } + +, + "f9e60029-c913-4d66-9def-0c413a2ca190": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C83s7fXCqps8zl9f4jmV7Rrf//ng1L2DJdREQ/8niu0=" + } + } + +, + "9f4c3ce5-efff-41e7-af32-e27d429f2a86": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ptJtJ1II5/2gy7eNKJn2v7fAfjNHHvDludGskTWH6b8=" + } + } + +, + "7ed2ff98-23a5-4f86-86dc-22e498035f44": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/Fadv6Yo8RoSXUpoVUJ7jO1EjquzPuYCC0dRdEhcZIw=" + } + } + +, + "295fca80-81f2-44ca-bbb2-6ddd53d4f4e3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gIC+MdIvYrx1BMM6hYVRK5GSrSXHOXWkbB7YJpibTis=" + } + } + +, + "522d2764-2bb6-4a5a-bc8d-24c39085f2e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mAs6/Iteq4szIqsj4pre9okZKeieSLyTKjiwP/+EwfY=" + } + } + +, + "7ea402bd-e385-4800-9445-f526d92e6de7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "J6U4f7D+PEO8o7TJYYNHqja3K2ul6Ctbpbmv1XydWKo=" + } + } + +, + "daf270e0-5f85-4062-bf61-0f37a7142480": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vlyg+TVW2k+PCJ1JkbHEeUdOs+0gQM1XlhKGVYyv23k=" + } + } + +, + "e4a1e590-ad15-4cfc-be9b-36049ab10302": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cQ1oadepwpUei7uI4y8CA2Afe33Cv9WNB5GglP4xHQM=" + } + } + +, + "d5e7855c-4e1a-4996-824d-1e9bcfcd850a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "T6Gu2Iz4LjDNIeYEPMjziV6zvcyZ7jko1Dv9GCHW7Ik=" + } + } + +, + "71a76413-3f7f-4a11-bd1d-88c3ffcbaf93": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5Z2jW8cY+SDmDizl4pJDmfSPsE/SDu44/xQ3+f+MXJk=" + } + } + +, + "134b6fdd-a630-44af-80a1-df65115103a2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Db/XVasObFl8dA2V+y04RRytxEG+GHtBZW4WieYzJ0U=" + } + } + +, + "ea468ecf-2ffa-4608-bd9b-958925eea097": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LZ4SuneJG6UmgHwcixV9IjyMAa5inwy9P5pnAJYLYiI=" + } + } + +, + "f5510152-cc38-468d-af1d-ea8cfdbfd97c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vE/xGF9sSnlvEfid+u/4f61d4gxKel1hdgvjgefx538=" + } + } + +, + "1428232c-587c-4744-9647-3e5cdd74236a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FneYH3pdxnmyu1tZRUPjngdliwtvS9Fhq6FARVhd/J4=" + } + } + +, + "57741a65-26f6-477c-93d0-b258bef296e2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nUoV3RzMcRdtOTarQndJAoxYBskJ2mYPdCMtt19pVgI=" + } + } + +, + "07cb1e44-896e-4855-80a7-a8b4a5351bed": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iwqkndDrDj7HiKdrRp3TjZoYt4nF/Rkm3pK8d1uDzI0=" + } + } + +, + "d69218ad-258e-4b80-889f-3a2edbc83ef5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VXNvp9DIKG58hPMIZH5wWkRhfLPF3j92ZZ7oFHlgb1o=" + } + } + +, + "1bed2cb2-28a1-404b-95ec-576fb19e7e31": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "a32lnI9mdyls9u+wD5Scc3pvtoiacGAxdez0rBKKg3M=" + } + } + +, + "64292eeb-24a1-43e2-94e9-f4e33c7f88e0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "EFUxvUAM9B1mEO9PqlOknAFHIqlVGuMFfwr0U7dNu5w=" + } + } + +, + "248a634e-1456-4572-8b8e-a211d24ce8e2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2dtLE9nfMNPNuvJfz1umZsjJWAfMySfL1KDpQ9JFuWY=" + } + } + +, + "cb9085f0-9beb-4345-af7e-83a89091ce4a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3hmIohBF2kx4yUFylyUbJc8Lm7YFU81UYdNaboo7BCU=" + } + } + +, + "cbf8a550-5a93-4b3f-91d6-9caa1640f320": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UeksfW980orfrXc6A5b3ekD7P2l6asWSxrdsJh6I6Ho=" + } + } + +, + "7e71cf0b-2f44-419b-ba87-7532d771949f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "e24ikkcJLDj5bMB/xrBHzmp8MYZSHzsg4HbbY9uuWM4=" + } + } + +, + "8cfbda02-eb38-4225-9387-de7c926deafe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QWRhled1K2MtD56jbe7WN1B2coHyYzx7NBWFv3DwyTc=" + } + } + +, + "6e7bc4c7-8a77-4caf-a05f-9c7c4856e702": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "I51OZXPlNE27UJPCh9pRrDKPXXFm8yNVokqI3prETqw=" + } + } + +, + "7cc89c02-6a11-4b2c-a0e4-95fb23b9a793": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "A0uPJ6wKQ2mfGpkwtetgVBJZnDO5HFRxhgCCLKj1f1Q=" + } + } + +, + "cfc277d3-b76e-4cc4-a5c7-3ccee6aab250": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vk1RSWfZ9KBi8f9ouPPgDUdfQl1yz+O4e+vkdKXt/w0=" + } + } + +, + "95c7b7c6-dbe4-40d2-b21a-24fce62b3c49": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FSBzyon0LfsVoMi1+jSvVgQyYN6c4jrjDLrTqecqsFY=" + } + } + +, + "1ae5c8b4-5fba-4aca-bd28-c6c3c81d9c1c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SM7118mjG/KlNvm/JJCUK1nc5sPctQzqvCziozmOiys=" + } + } + +, + "3ce8c88f-630c-4c69-8909-e21ba231e53c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wt6hlvCiG+QqLjHsa95OykvMsoLltAz8MzQq8HbAUco=" + } + } + +, + "6a305de0-2e30-4e3d-878b-ff916517944d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "x+01++F+XSmVBQdHtJ5S59b/Ju/0aEoxjB8cW6mATec=" + } + } + +, + "518bd056-c8a5-4014-b875-48615bd19987": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VynfLysPMwYwOmyPcyLG30Y7zDs+GSQeKSB3k2482d8=" + } + } + +, + "c70f5ffa-d24d-444e-9c83-770632d3f13f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "o8hDM5LTAseTUjwuvrF3WrLaUCeHxRXfikgnMqOvaFo=" + } + } + +, + "ba3adfad-7b65-4dc5-8a64-e6eb97c5eb8f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "OCs9DkAoYb2f6R24JO0bYyk5LhpVPnalhvMGpDnzBGM=" + } + } + +, + "a3d4802b-6a65-454e-aa49-aa21ebdf5726": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kRE17NBv2cuFGnHMr9mWWoADJvjFec7TnABq0LLHiVo=" + } + } + +, + "0af6969d-4c87-4c9a-8d2e-7112d7aeee44": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "y+Zg5NehTf3PXOji3Yo4pNr0c/DCt1rl1kbz/sCUJ6Q=" + } + } + +, + "4dc3b159-61d2-40f2-b3ef-4eae8eb45fcc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WdQHmscgXfAPDHql/fDACUjGFI7SNkroFhZhueDu3wk=" + } + } + +, + "5d4032df-8af1-4a0a-b451-0ec298779d44": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RcHY99g77aRSwpSHDurF11TTy+PNLfq8S9iPmxP02tc=" + } + } + +, + "17052406-502a-486c-a6ea-ed9e560829bc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bPG7pHQjNeKZiLho9v/d4X3jqLBhNSL6gJKjdOvhwuE=" + } + } + +, + "3e5c6505-136b-485d-9d13-9d6602ee4284": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CS7/EYe1MhRrag3ON+Clixg87AWSoyUMcnAW0ir+uos=" + } + } + +, + "f6a16f2d-eeec-41d5-8bfb-f93fa2ddbbed": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HuwSB4Y+zkFRSdYkOZSspg/+AROTKNlZSFPNOCSKs6Y=" + } + } + +, + "56217ec8-4bc2-45a3-aee6-ca7cbff9c40c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hZNX5iSo6oi+2SLYw+NjCJSBRPIxvv2Qp8M5xN79fAg=" + } + } + +, + "d0afcc86-0e98-4f51-8c29-97861dee8413": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "p2OqFO+LKEQxaZII/NnFeLZxuQD6nT9cKHOJFOHH2ng=" + } + } + +, + "632d804b-c013-4b57-8d2d-07a922db3d0c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yZAwwSJZgC5CFZwch1gn4tiCI9U3T5c2Ww+HAJpGOOI=" + } + } + +, + "85af0551-f291-4ff1-937d-12e634903265": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YWRYp3zsWjPbdL3EeJAXHXB2S7Np+k0rwm6m2GWOCB0=" + } + } + +, + "8593e179-1a8e-442b-be11-e6c24a7db9ab": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "F41MQLgzd+iTlkEPw8ya5gafX1StJWDwioxaE97SheY=" + } + } + +, + "0770a203-2d9b-453c-84d3-9ca09729e749": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cc3TYB76HwatXBv4CFjgDmDfwHQL7AgetEYA5BVG/w4=" + } + } + +, + "396678ba-717e-49a9-9b66-bc4958d05e78": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AMqqRuQo1FtEt5Id1WGyphHYuVLxPsNDXa2JAch/raY=" + } + } + +, + "28d22296-4a3f-4894-a3d8-290edac2c44b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "poOMF/qD+Ca160UiBt3RH7eRnwPvle8+rPFePhvDzh8=" + } + } + +, + "6d608e8d-2a70-4276-866d-02f25a44c37a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kLBAO/79E+BC9+3KAdjULYGiUy/r6wT4W+321hzGyy0=" + } + } + +, + "223b4f66-bf7a-4ed2-bce8-81223755eec6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MUOGMAntPy+A7DnlSbKGaCBRlSQc+yg3mfYi+VSsmWg=" + } + } + +, + "a305fbc4-8118-41d2-9403-e32298f16152": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "K7zjEiHrSvJ6Dt8Ax+LdYDqu8AY0/V3qYxTEHNr8wmA=" + } + } + +, + "b75c1e5b-54e9-428f-9783-189bff1fb1cb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FFJqlXPVoA+b/eXA4E7+nAVAeYFmw7cXguf+3P1Q4Zw=" + } + } + +, + "509c2128-ff53-41be-9bc8-eb5996d235b9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RIPDyvXAkS023HAFoI58IVWR0N7g1oY1L8ZrGb2QYyE=" + } + } + +, + "0a723249-5184-4c5f-b22c-e65aa20f96dc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "riPnrFzus1qfEFxoZ/SDxr8x9LhJ+KRChgpHdHrqnMY=" + } + } + +, + "0d85995a-5560-4339-8beb-49934a3b012b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8rIljMSSMzBVMfPKbEbWweOgNpjRhCQoTCvo1nFYycE=" + } + } + +, + "5a9254aa-b173-45d5-a336-98e70ca7b4b4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VMDvJd5TAE60ZgJrQpOMt0XS/DHLRRdWrXwZd1+Nk7c=" + } + } + +, + "7bffbb19-ee83-4360-b183-d49e810dd116": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Mc5VTTP0pXVJssPxk05l6SDcRlkm4rJtUKjY7Y5Qeuk=" + } + } + +, + "f0013a82-64ab-4945-b471-f73a82e299fa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/zmUuh4s1lIrQ2C1mZ64rO4rh64LOsFKMll7qYSAp6w=" + } + } + +, + "7ba48ec6-a65e-443e-a38f-e20b6ee635b8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SwZh9YZRXyV5Jjr+t3mqJVoUcuGTR0g9YDwh4qpntSU=" + } + } + +, + "41b2d7df-925d-4bea-8826-90e20252e91d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Q4Me9Nv2AnyEwV/6KRo5ClKRDeDO4BVkndtE5jQEJgo=" + } + } + +, + "d67f6206-d628-421a-8341-8da4ed2c048f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LtaoPLqSfLRWuzPOoTV7yT/EuyivhGusT6Eo0rwrZMk=" + } + } + +, + "ebe5c477-363a-4038-9d66-9d4d3cfe6803": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "64y2aXfJSc4ju1S8cJPTIvqepX1i317WOqFPoG2NzCI=" + } + } + +, + "8aadca50-99db-4471-808b-3099bd0d37ee": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "svfnxbMnSc4HP+QXvcEQ2qPl9NGmMV7WHiX/C6DfD9o=" + } + } + +, + "28d8fae5-e225-4cff-88f9-bd7d969d6185": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gEUElYHioATXXhT21R3yxJFXF4GU9LcczkQP6sgD7cQ=" + } + } + +, + "e84b8587-e3ef-4f28-8f73-b130947b0b8f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iSUkELWWPoaAYTCHgNxGfpg3NwSggCmemXsrm53CWX4=" + } + } + +, + "b152dba2-c7f7-4a89-9a53-b6de20e0a9fb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+MIgWotaj0bG7TPq0f8SzunQM06eTJhe3/co9szhDc4=" + } + } + +, + "674ea9c3-3860-482f-a84c-e3be7b28c51e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UzR1MPhA36gb+xLJ76FW3EImZiTtVsiwAuEJ1fK/Sdw=" + } + } + +, + "abe0e357-1b9b-4c39-81fa-ebffbf520de6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ofQVZPi8RX9QcfryZWhUt7DmBnDtqlJnSWvh7nh2S7c=" + } + } + +, + "9aaf1af5-7001-4e82-aabc-7be978d61398": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "W2J/3wID1nHtChTmcNR6p0pwbMsXFcFp9BAP+m3KZac=" + } + } + +, + "3c751ccb-7d05-4568-888e-b7a9836875b2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KlzSIq2UqjgWSCf0/+xbXTtOwTa4gr0gD1I86OLyRF0=" + } + } + +, + "cb2a5dc2-1f4d-413a-96e0-d4036c173ad6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bB+zkObXrqP+vtoq7c8LR30NoITzwbm756TBNvDRFEc=" + } + } + +, + "a93600d5-2b50-4256-b254-86dbbbffd6e3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PaAolSYdDKGTtvc2qiuuqSyyO4EzCxu5iqzsKrc1sak=" + } + } + +, + "1baa7999-8eaf-49cd-9e30-901bb13625be": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hwpmBbvmK6qA9NBGlnSiyJYYdRGu8Dyyme7LWotqvcg=" + } + } + +, + "8d4f5580-d3d3-431b-8b03-1992fcb58b40": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mFRfxBvbNOlCdaZrfqqIpolGTNAOzSPxW2+9d2O0l6Y=" + } + } + +, + "6146bfe1-7cff-4c97-8024-c8ab2abf2f72": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qeELZa11MhWFVu96xnTqTrjzGHG4YyUNnEz0Zttq9U4=" + } + } + +, + "48b043ec-d793-4531-971a-219969533ef1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+g5cQwMl68wSka4ODuCOh+scT1cWM/zUC4u1EhP+kYc=" + } + } + +, + "8cfa06fa-1192-4d6f-b236-2717a6692cf1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MP5rAyRyaZFUjYugeJm/ZSHseBcxZH6JTZeQvGWHoGU=" + } + } + +, + "3d7f1c0c-9c07-47fd-ac7c-8473d5755ac9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nMnyF8aaPLIqdAiMM3P3lo3b4QPTjCuqM24TkC5t6JY=" + } + } + +, + "00e1690e-79e6-4b5d-8974-d83ab067577b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vxulMOW7olcpDNkOe+Hgiq4JtiTwrbVPMBbCEmb//4o=" + } + } + +, + "b600d78c-4e32-4664-9176-1e107f406f37": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "f1Qb8PC5wzhW0kjjfcevYm5GCOTlr9QgT8hT/2DZsGI=" + } + } + +, + "f5ace44a-1da8-4e3a-b9e6-354d8cc45ce6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "n42d9FmHMkpl7Dd797Plm46fjuBMkSVSfPYsZ+qt+ps=" + } + } + +, + "a48015a4-b596-4149-ab30-1b97f6b25398": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cmSC80yyM/F6dGU2r1z1/2N2kedZpCTpY25+KrJC6v8=" + } + } + +, + "6ff814fe-917b-42db-881a-2559c951ce47": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rjHTw4fkpmgKTeJMZXmbf78jwNeS8rFwE1f5UHhnhH8=" + } + } + +, + "d7c0530a-2330-4b90-9997-8a4179b04a11": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5GuOSdJyxqxjAfBdCjuQO/V5nV3HZNG0ehvrQRcljzs=" + } + } + +, + "3bec3eb7-3763-4c04-82de-56051ce8ca63": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kUdC9oEIOh4Bfc2F2Ie1XYBVUeKUHi0GGGfWmcWZql0=" + } + } + +, + "92467a0d-3c99-45d4-a5f4-2ee924604f2b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wz10zr9Pm7EPwJM2+jGlZ0ovZ9qqWYypFtqIKucvumc=" + } + } + +, + "3a2bbb82-ce45-496c-bf19-0d37d18210a7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "50S/Jz+ND4tx+giE2fkYZvZWrDMqmxiTaOATmMTnB2Y=" + } + } + +, + "58283a75-455e-4dda-8b4d-5cb4833676ca": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MUSxUVkqtRkTfD6GLxwy8CBWokVMPKIBCmYlmjICLfA=" + } + } + +, + "e5c58804-71c1-416c-a858-b77a3c45dd5e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "V1097w3+QQ8xIMS6zEX8UEZPLvsY6FYXKDrfptFb41A=" + } + } + +, + "26d54a5b-8f9e-4140-b0d0-bd40d7be3fd0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/6jhb7Stx4nrCsvd02V5fO668nuhu9CR8hDQwc57Znw=" + } + } + +, + "d844dbb6-2c7b-4a82-bb91-d71d25e7d463": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Rj9yutlQjwgblFf02eFSoFctYa7MRpgQAo5M6MT/TaA=" + } + } + +, + "de2acf02-00eb-4875-97b3-fc0c3a921120": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bABTT2PK5ZINtjVMk9NZWH0SQFt23PKKFKwuUI7NRlg=" + } + } + +, + "5e9736c1-4db3-4607-a0f0-44002102d024": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YsyxIuj4IzaNQW/r7Ur5FnPeojb97jQulFt09/BU5hY=" + } + } + +, + "38c107e2-d152-46e8-93d1-a0fe80dc6318": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NFxeEnu0Gk87K05+N4XdYSVOTQZuog1XIjFVYiqbwmE=" + } + } + +, + "830bb339-2b9c-4218-bba1-ad455c49af71": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kyhXRpXG5EQVXTg+cflBR4I6RFKA0PNcDEcjImznXkc=" + } + } + +, + "e0f6100e-58d8-43ea-a853-003cb923be0a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vny3QEe2NJW9VHucAyRBR0dupFRSoCONpE5ggB46Xkc=" + } + } + +, + "46e37dfb-ffb9-48cc-9066-fcbff2748e55": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "y5zVjrD7ptO6sStcHJ6v79qOxpql7bHLo6swQAGAsO8=" + } + } + +, + "a4ac6f00-eda0-4112-95e0-67ed8f153fb9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dgFcRRjXHg5luYrSE9JqRGcTT1ENwQkWfKORzg7MdUQ=" + } + } + +, + "b74b52c0-61ea-4a8e-9443-3e001c9c5b93": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LOxk3qZEJGuQeF2W0RyC8T3+d8qzUjNziWJGiswCnfE=" + } + } + +, + "45232448-706a-4849-be52-895683852d37": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kX+PXjcREkIb2DA8rACqvYBtnEoiBwVaAsIrILEetb0=" + } + } + +, + "b43e74aa-4f6b-4e25-be6d-501af3602e56": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SBEUHwsdGi0AhiLgcRwzU1kDBwseCw01GZw5/GwCLFM=" + } + } + +, + "5d306260-6558-4bea-9c87-7514ed611cfd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "U37Wi9AUPPyiDVcQE++vZ0JsxZ/FAivkuxdMDA7xsGc=" + } + } + +, + "5db2c59b-faf4-492e-a6c5-c587a44307c2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hywQOlcK9dF9k5PPoKrrMpY+Ay5CHOLJZImI07209DI=" + } + } + +, + "67a6f576-d00a-4f41-8789-32c812b5316e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "OLXrllaBUIuqfuTjgQ9MgCmn+IJDl0eTs2T//5wRU4A=" + } + } + +, + "5af55a88-899d-4bd1-a2e3-71d2932f0b4e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/aa6bAhldsbTz+ObGo1J7uy0qXgdc2HeytX4hweTVu4=" + } + } + +, + "36caa0ce-25bd-4e25-902b-85a1f85c5374": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vwAbjyzaNMjvvbB1vcrFaK4SCJs5zCPQ9qeraaDU2mg=" + } + } + +, + "1bd8a949-8408-413e-b473-f624eb5187c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HvEZj50/Wa9xh5I3TWICJg/jCpuIKU63aJ2JK1B8HSY=" + } + } + +, + "d48c580d-9b12-4c6f-bb65-0afae599e374": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bRccnL3brHE60g16NsqlcnwFD4iozbtpI8gWZivUunI=" + } + } + +, + "5cb72688-63a4-4a68-b86b-3111c301f1c1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VzUAwKK1ROzmBLB7yJECn0YnE9S3o1P0/x6rZ9WPHZ8=" + } + } + +, + "1bd56274-0762-418f-ab33-200a098eea41": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pQI+ut5e8yFCGP0kU/VLbbQQLa7LSOQ5WwLmOE7rVG0=" + } + } + +, + "e7e5edbc-5616-4ef3-b0b2-a792a5ea49a7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AcQBh7o5Ws5zx5IkCLFNBBDWEpOvL03Wat2JOBWvUgQ=" + } + } + +, + "703de02d-be4e-4ac6-8d4a-0d7ee07d0c13": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HZ4pANBpKb7kgf3Sh1DURwyMOhTFfz6m/ZvmzppOy0c=" + } + } + +, + "e247ad6c-8707-480f-9430-b0af2f0b8c90": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hiqUyoyrAeWdtF5y3DNrSJc4h96ZvRb9hK5FbsEtdEg=" + } + } + +, + "bf25ee5b-4cb9-434a-bc5e-db8a4404045e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "beL8pqRv/QMfzVkDwI+5A3zw77KxeeobBtdCH92RpgM=" + } + } + +, + "c884cd9f-2f19-42e2-b997-2c6d6e209277": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wxTafn5qeZzHUI7hbYGbPtIGyWprfG6E3kqV/XCfhD4=" + } + } + +, + "5b577864-766e-4143-88b8-6738ef94d7d5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "P2rnMPeNDjYLOq3T/ak/Ei549CTimxkuEiC2z+C3IBI=" + } + } + +, + "09292c0a-970e-4331-8899-117b203ca86d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PinUl2YvfP8uTxlMVaEv1C87x4NzOWvnN1UCUEi/MNQ=" + } + } + +, + "d734386a-1f67-47ac-94bd-beee5d3096db": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pjcauiuJ/dgU1p2UyOqNv7clCa4+n+rADcyGiNX0kr8=" + } + } + +, + "29514362-4530-4776-82e4-9ee9bccd12cd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "POrUCAY6roLG2rZ1rD0+Mi34xxwTLLma38CtabEjITI=" + } + } + +, + "0ee0a4f4-efc8-4a48-b948-d16d87b00fd7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZshTcusYvIkKLoniHsXeKnfaQGb+DquREzSS/gPbwSo=" + } + } + +, + "3a68c423-97bf-4633-bd51-8efa142e4fc0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8sl+qiiSq/7TgsJB0sIDZePbbb49hLzmypjZXc/cHGU=" + } + } + +, + "432a4fea-678a-4abd-9cb0-2c5587319631": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ohTmHlkQSO9hmSK9tCbEYbMG9QpMBl/3eIM5oak422E=" + } + } + +, + "251fdd95-e1fe-4870-a6ef-2362ba58f5bc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rURHVTe4sh3sSOl/kQR24rxWVEEirqUF9VLyY4waaeI=" + } + } + +, + "5a3ef016-5152-4846-8ab3-70a24cb7ed85": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TgmM8lJsKzoOWVkFZIG0wF8bn+ZHejwiF0NCGXmfq8A=" + } + } + +, + "387cf692-2a2c-4976-b635-0366f99c291c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "P76NmyYH+i9W7x6+75Q5bC6sno8zEe03T/UFovKKJmw=" + } + } + +, + "63a4b09c-b471-45d4-8938-1ff78d1845e0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tvuAeb+hnuPDatgLr4Dt/afpk22qt4n72nDDF7Ke8v0=" + } + } + +, + "50b93001-5bcb-4d89-b938-5f84096a7c0a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7KKi6g30Gu/OYn5HCi1fdf2wsf4Y4g3313hlWxczQHU=" + } + } + +, + "99bca4e6-1415-4d49-a72e-ebf443597f5a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "20lfiIpIoWNNUzILg3BY2spbTJyfXrZ7VEkpF55uR9o=" + } + } + +, + "048fbf29-d185-42cb-bbbc-ea1f2ff0cecf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CzptBdUqmZi+IAslATzcIxoofhHAPI6ApzoQORwiwyM=" + } + } + +, + "68e74dec-1b2e-4982-98bf-29a257a1dad2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LRUCzP2RvfsFbS+gvXTqOjwHEdjoh6rjHHc0vKBq9To=" + } + } + +, + "9fa4d2bf-0e4f-4c7b-baf8-16cc226c79be": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RD2sNjMGnxX+MQACrTssBlUvvyImEIgN5ysbHrAlMwY=" + } + } + +, + "d542d446-5018-455f-b684-e6c3ed10b687": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fcOlAHBbx2BqtbnyNXDIZGzRthRlTdB4c6+i7ihu12Q=" + } + } + +, + "9c8706b5-5760-4a9c-b647-b74a205a546b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "a2d+I2eKBqGDiLZk805vCHp1bTdynBG5mpKteO5QcAg=" + } + } + +, + "b8f68e44-0ffa-4a5c-873b-ef57b971b238": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TUH6I0SB7rHNguG/KN6aJFxT6TdRl/mp1Jj6ozXAhSQ=" + } + } + +, + "2d4a5714-2d8e-4ee1-9ede-f02b2dfa20ae": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mDWaC4HNEqF55XobX2NoVYkniR+U2wW5YP9hB0J9d1U=" + } + } + +, + "120996c0-ea24-41ab-b006-2322af566efe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KgN+h4fAkm4ePGFiHASy3DsRbZOS1oV2ByZ6fgEardw=" + } + } + +, + "f090d78d-34f3-4a16-b3de-e98f567d5041": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "I1136KHPcS1aLFouHpIA9zJPZPy02WY1QzZBMgOMH/c=" + } + } + +, + "287b12f5-4f5b-4247-9af1-54fb6309fd6c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VvukbpclkmQlDsTLZN+uFkfpt3qCM4V8PBTf13nBsRY=" + } + } + +, + "53234ea5-fc49-4b7e-a2d2-6576f2634789": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NUNN480kzmc64Ak74sMoAyRRXvfYMtl/I/oSJ//dNwM=" + } + } + +, + "4e13401f-bd4b-4d33-a24f-71c98f313493": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "a2QNWTc3EqKlqaHNbm92jnp2Hk0iIQW6vLO60XNxaY4=" + } + } + +, + "31707fe4-ceb8-492b-8524-06ac2d3016d5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G46stBje2jpEfmtSKUgX0Qqcv6ANyM0iXWRwTjRWCNE=" + } + } + +, + "2a36dcc4-5dcd-44f6-8b9b-7f9cb2bbbd4d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1p3CpI10ibWKOHU7pPGgMseP0bCYYp6tkyJuJ7nvvzI=" + } + } + +, + "bdaa30ce-5e05-4f42-96e7-55f1d29884e3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dsAGKQrXWrr9Y5jETh58hWfSFT0fwU2i5HmD2FMAY4U=" + } + } + +, + "f6983269-d180-464f-b4a4-40c4bbedc3f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CytEnEYn/NG2Il5fV9tKHRo5V4hTMevJrzhFQ0rFVR0=" + } + } + +, + "89b86dac-15f6-40b1-90a6-62efc634f58f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sKUdWExIh8FoKO/OMVjzYqG3DkxZXpDZcTL00ixG7GI=" + } + } + +, + "c0092f3f-cd93-4c2c-a0d8-b65a4952807e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Y6eD+L5KzT6piLnnn73oMHK1kOyrXNomsJKi+4Kj9zA=" + } + } + +, + "79a3e979-d54d-494d-a655-54d9f3c81c38": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XKoJUAfFQumMrzfzXcc/ok24GkQS01XxlbUs70DZIKI=" + } + } + +, + "321cd834-68d0-46b6-ad23-cec17fc5e48a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q1PnAj8dRQiw+zNlG03PMLpB9BYqC1IQqeEoeQZT0DA=" + } + } + +, + "62d5e838-ae8e-41e9-a9a2-b8282f7cfb1b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vlhYfirnKl7o+uD8XSts/q9KS2o/8T1G8eD74EA1c/4=" + } + } + +, + "713dd74d-ef27-48c7-a287-7b07ec4dfc04": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "z8PDKhINYWFLqEd8fujf897R0D4HG3Z5UrJcYGP2wPM=" + } + } + +, + "8dca819c-828d-43d2-8a02-2b496097b3cd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MVWSxlxOATnmEvwgqCliFCBHgdJJWBYh/wjnPLU3fRQ=" + } + } + +, + "3b2d17f0-3447-4a34-adee-e52d9cc17fa2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GLYjJ3swcVKF5WlJAGW/aAmkMDNuJmZKnP9yVR17oGg=" + } + } + +, + "323715b5-a062-4f16-a430-423e60dc1ec7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oP4cWNoblw/AT6hWkqhYTbHsD0zPDYAX2VWzSo+2R00=" + } + } + +, + "eae56a86-d37c-41b6-94fb-c575b83990bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Sa7mQH/Ozfa+H79PhD1ke1i89VRq2NrupwWkU5kje3s=" + } + } + +, + "c1e7c29c-10a6-4ef7-9610-01be4876fd13": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SVTrVd+oAJjRJtbMjGM731hG+EHKvheAyDzN0JF9JN8=" + } + } + +, + "71fab42d-43b9-425e-a354-278cb1c8bf50": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "70sFTMYZ+2YmzX7/ozWDlv5ZFljTD+x+P9dl474rnJY=" + } + } + +, + "f290cf39-c96b-4a5a-88d0-9e238547df88": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jFW3jX8WNGFpyxy0o96Wt51HpJlqACN5cNEHqL7Aibc=" + } + } + +, + "82c0c6f0-9249-47e5-8817-73945367160c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Lyyit7/K06z1nJkbycRfvD4+saOq3MS07IaCB9TaQLw=" + } + } + +, + "31e14b51-6fca-49f5-878a-f6cde1ebfdd4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "obZzps5sRmAs1PlaHv5lLLCkYLLbelF4Nc7iRgPgeiw=" + } + } + +, + "3c46f18c-d121-4808-8081-315408001cdb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1A8kzp0orNRg9m6RAw7ozcUdN9qIPrvMeex1jR4Q980=" + } + } + +, + "a2cbf3c7-2424-4730-b789-2d998a82a69b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cUEvsAm04R5mKDmihZ09hWBTPKQcovYGfzIivpiDIoU=" + } + } + +, + "0beda024-e256-42d3-b483-80a1682f2393": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5Hx6LCSlxEAkB3lnlX39APVuaTgxs9NYPR1ie4hj4gA=" + } + } + +, + "9ea80d5c-8262-4e30-bf5f-188d838b7c95": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kRCQzBs0D8Dk9skv1ezlRIACg9gOIhjY/ezSM8jy+kQ=" + } + } + +, + "e379a5e4-d79d-44f8-8641-c492550de511": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C8YRt4Zrj5Shzx5Oda58HRrUAqOTfZiMuNUFUmiwYx0=" + } + } + +, + "08c236d7-964f-498a-9fa0-7113d9685c22": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XQTlG/9SaZbuVI+ZPP1HM0wW9g/qRH6O906UhSHjWDM=" + } + } + +, + "d2674efa-c262-4cd2-9b70-78dc7489964e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "csDdv5nFP5tMH3H3F2y9tmPSzquM0yiDVQVq6wpyorY=" + } + } + +, + "f44ff606-1872-4f4c-bdaf-5511a822b4d2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ANnTiuDYLDyLby1j/8rGDBHLwJ71zjskknU2f+LU2Qw=" + } + } + +, + "0d61ff66-036f-4e77-93d4-fd2b066c575e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "05v4Nn8cqRCLRkAg9W1UfcKJ6yJqCr4IklxbPOhzS30=" + } + } + +, + "3e47fa04-e828-4e4c-92d0-59cd15c39065": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+7mM68snhwV4e9hKB+w6Deqrn//eMZAdYWHDVhryJQ0=" + } + } + +, + "2ae7bb58-329f-425c-aa66-c9fe1732e78a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Sl6iJNX3MQhomDSSsJxWEltMsTDA4SYQcYIvjq2CSRI=" + } + } + +, + "33bafd89-81e8-43fc-a755-45036fb7361b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "f0cP/rrhuBaGIumz+W0TCm5VHOqv968Onzjyr+RzDAo=" + } + } + +, + "411cd04b-ae82-4d70-8b3b-a80fad4f26a6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "L9OXnUOuE6ckJEWU9hd6kj7BhIlWuAS/PT5eiOsJZZI=" + } + } + +, + "15335bd6-d92e-4945-b50a-1d9f649119e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AUJKR9bMeZsglLRf23bG6xBQWVPD2m6DOY6vQ8Zo2es=" + } + } + +, + "b1b848ea-aadd-42f2-9d55-c531bf9c0101": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yTWAc+aAD5EA0lK42kfA5dgnk2fzlhiJGchJpMdZ3+U=" + } + } + +, + "352c4362-c6a8-4b2e-9015-ad29d2a41fbc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KjvMQ8/inlzHgFC+FI2XdDsp31fa9IlE3ppLogmTiHQ=" + } + } + +, + "3f3f8509-76c2-4084-a2e9-0a62902fbf6e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Mn0LUUSJRdU+Ld1mVbGzniNvGEVRn1LNJzfGekivrJ4=" + } + } + +, + "8ff2751b-8bf2-45d8-a433-8ffc97c518b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RaOtmY2OHpSYkLLFGDUMHFSxvo2YmAmMgYqp2QUrExw=" + } + } + +, + "e8135d2c-0c72-4780-9712-1101a358eaf2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "b3oyBVM++XEQOIoUheRQO35oIRFGKO5pCSKRCJj6Tzs=" + } + } + +, + "c5097fa7-59b9-4161-82bc-0a8b5bc81b92": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rGvYb1v4UUS9QvztvdTZzr15y3tO7kZcpFjn8aDKxs4=" + } + } + +, + "e5a2f892-5733-4f7e-a158-21e4093394c8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9WfbqBLYIZt3McLbzVN+XuR1yLwHzjaDbivZx9BNYV4=" + } + } + +, + "f533e83d-a55e-48ed-8243-eefeb455a6e2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "j2G5yDYt4mxmgshfRF99VJ5zqtwjO/V0f5jTQ1lBYlQ=" + } + } + +, + "bdba2775-9d6c-4143-9975-38f887f638af": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gHvtKFxBgvUtoJ7VfK6EqZFp/jxJV5XtNLqFyWGwm6k=" + } + } + +, + "25e8a25e-b533-405b-8dff-b01af92be764": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bSFrc8V3A3KF9e6kizhNt3wzeGfQYRRqnO/1uJYmUrc=" + } + } + +, + "e1300365-7053-4ce0-9bd0-f20422afc21b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "c+hid1uZkLio0F/pIcxLbGL6cWNOj4egscpE9TzSVGw=" + } + } + +, + "171eb1ad-456c-42bf-b25a-d8815de76e16": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YV395bZUuL0llTl7cp6FxnBP7vGjQq+lPI8iZ2+AmsY=" + } + } + +, + "be29deca-d647-4387-bdbe-817cd52de900": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GgjUXGl01q+DhB3xboRXmgsax0h8YsG3mp4G7XOaSJo=" + } + } + +, + "02195e7f-74fb-4ed9-a57c-a3b6367d6445": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2kZW2HvTKKxkRKYbavjrr8tURcxuxT+0fV69B3fm9K8=" + } + } + +, + "8cd9106d-5698-4462-baf4-3c4f24d30f12": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "odhs6eJ6RXjS3Lg90olJ77DKf/33bFJgy8ajIc+XVu8=" + } + } + +, + "12a44fa6-dd7d-47cf-863d-d30cbd6d818d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G+ti+jQm/1DnRU2k6MNRhgr5ce4hMOhI/l9WuPXdToY=" + } + } + +, + "9d3c3f1b-1164-45cb-b771-5f2c0c73380b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vfs/6nSLc4yq3BbDO2aepKzpLP5hnWSUs8YN3yZ4gaQ=" + } + } + +, + "68e3c061-6e48-4efb-9649-00223f7e8292": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Iz1CvBVxQ+gLq52v/T+AtDIvUagAZ1TwErGGs+Ahn7Q=" + } + } + +, + "771d0859-3505-4a73-a436-1f4146ed048b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5QcbJGVKgJnVvlHdm1fG6fQVCDBwXJeBzKRKwYZJ2ek=" + } + } + +, + "6ce960e5-c876-4751-8b9c-d49990507b2c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+wudQNzaLayS+lilA1dNkeoZjlTJzDq0i+BDuR5JUpE=" + } + } + +, + "2027b724-d342-4d06-b0e2-0aaac7f9fbfc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GHFc1LuRmG4Tkz5j5VueOAljT8Cuh492Coklf/hFgTg=" + } + } + +, + "4b52228a-b2f1-43e7-ad79-ff5bee2d9f88": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AO/FPKQ5O+Mei/EKjUYAChH91iixLyz7B5HqFpBYHwo=" + } + } + +, + "742a3269-4bd0-4ea3-8b59-933e279405d1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "A6EASOT0t3x1in+HhoCCeBKzE1zx4qBkbJBkm5uenXg=" + } + } + +, + "b7e68694-dcae-423b-b8d4-f563cdf163f9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+tQGP/dTrOjKZFsu4qNKPevGFSviRbvw035AMv+9VT0=" + } + } + +, + "d4b5bf29-f120-434a-8701-792590a415c4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5/jUtAPgds3haaSCdsxRUPbqx6AW9mHV+HO/nmvSTlA=" + } + } + +, + "dbe78ae6-007f-4e26-b88f-473e2f61f54d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jgS4Fz8TZqTPAj1y373XhZ8WqwMqBXG81hgmbsKjyIU=" + } + } + +, + "7a436e5e-3870-4d5a-ba6c-79aef4b25070": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ojmxc8mEr9ftAIJ6Dg5DwLMromfckrjP9BqZZhMQXMA=" + } + } + +, + "bb4460e0-f30a-41c4-a141-6fa48f803cf8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FknqTt1HXYasSmZLZibXzgdb+VrIUUqetVB9V3s4yM4=" + } + } + +, + "de713cb8-c7f1-4ad2-8cae-49b8d4678396": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "brcHnvx8wd+Mpm2B14wetX+lFIrpatbHlbx2ncqSAbU=" + } + } + +, + "6c43640b-2791-4379-b3be-e038fc3afa34": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ATAofF84C8GK3mCWay1jJhAiO2hKLhzZk8R7inYzfCY=" + } + } + +, + "28384ae1-8094-45a8-bde6-8ec409bc6a79": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ViSTLAgjYNP9oFFlrTBnREc2gDgdNXfL5LpKebAueEQ=" + } + } + +, + "37bfcfac-8ec9-44e4-bbcb-34b9af5c1915": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "udmRJkRoHSCmxNja6/QQ4qjLgjJRfgo4v97DxvbqD+I=" + } + } + +, + "465f6c4a-c3ff-4d83-a5c9-673792711c99": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VH1leehMcbnj2E0e7SR2IkVvdm39Wmah+sJWAvA6aSI=" + } + } + +, + "80d71aa2-0ce6-46cb-8103-c83f86267351": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/0SJn0IT97lson/ApcBjm+5WmotXBeChdbhk3LjefJs=" + } + } + +, + "935d9737-4f07-49cd-8635-9aeec802a1ee": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FJcL8qmDiKz7Pr2GmQzVrAWFGOa8lZ+04iSmmoQSyqw=" + } + } + +, + "6a172c91-6315-49de-89d5-fe6ca40e4405": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DMG2VHwocANzvoRhikWCRB3TpUBpPmcbaqSffZdbnUQ=" + } + } + +, + "80fbd5ae-f18a-43c7-8a35-f2da632db583": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cWfG7NNM+D/JYJfr5xqyNGB11fjGWu8n0HqM9/oErTQ=" + } + } + +, + "712d28bf-d389-41c0-ba35-23290f92902a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3YbIOSzvKhtPUFT6sRBq0MyU2y05+T0DVkpP5qwOddA=" + } + } + +, + "8f4ad34d-2725-41e7-9571-06560056233e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ATXbKf43jPSdtzfNfcCeShAnyD3rIZvshK0s0WDegUo=" + } + } + +, + "5832df00-0fff-40ce-b90e-32ff84c560aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CPZOHP8WZc1u7g6ZZiiz8BnkXQjqAHLVd/QVhXs2rPA=" + } + } + +, + "031f632c-4533-4e7f-bd22-df9f0945e828": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rqw7yP3dpjGgqthw9xHZBr++KNzoy7EpubDDbOoPxgY=" + } + } + +, + "07322387-3d85-4b22-9c2a-022d4cbf8d6c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9edE6eLXJ4MjhWBEQhNKquT1V/33wTCbOp97WF8NVao=" + } + } + +, + "d3b61437-4646-4654-bf33-fa532d79b170": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XCaAjwVBdJNg/dop59zel000k5sQV2OLeefBNfrCwZc=" + } + } + +, + "273092e3-c4ab-4638-baf2-8022c6ea10d3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZIUfKYDJcgiaYXgVGtaw5XWXDD2V32UQg3tjCQfIr+U=" + } + } + +, + "689a429e-44e4-404c-ae42-a2add07a4221": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UupY5zxHMvGrjQcooUTEoEP4S/MpUSXpspccNLxa26A=" + } + } + +, + "5e0cc878-d6fb-412e-9326-38406ce69cd8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Xax+/GgPuDWw7REB2Qwoy0y+beh9Ga8tqfcKHcQSN8s=" + } + } + +, + "b2bbb3cc-bba6-49c3-9c25-f104071b201b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uaHJYKRgREdLk2HJ626udKiz2nSxdlNfUol61fZwsXQ=" + } + } + +, + "c14317d5-5948-4927-b943-17f7a4f6985a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "A/DytlsoRLAAxaTsKkDDJBLi4aJOPlOoGd+/8Dde3CQ=" + } + } + +, + "7a019080-e725-434c-8aa6-1fddb5319551": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vuelsw0Nvbfh2LaijVCmPEf1tqcYG6qv+MKtvpBOuTw=" + } + } + +, + "4d34b3dc-32b7-468b-b72a-9043224f2d38": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "v9clUcTYxAlJah07Vn7Ynq7FNkXRztMRUHAGJ0tgx54=" + } + } + +, + "fe3f4d4d-cca9-458a-9e15-0f6edb1087a5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NvY4cAkL93wY5hfPEnjsYCfkK2QcHeBkAfwM0w9m82A=" + } + } + +, + "07b930f3-3a53-4a7b-b01f-0031dd9fceb6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AxKMpYHikRON4+IHkYgC5xIAn7GU9IYLlPn5G4yWHec=" + } + } + +, + "0cda79af-779c-49a0-b377-fe142c2cccfa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pSUIexCvSpYAFVp0dH3kPbQ3G28FuV2OGQ9BaGlj+z0=" + } + } + +, + "aeabcad2-410a-43ca-a3fc-3019fe86a751": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aETDre/JtQygL2eOVrV7aHlW0Ln636IUuTV8kkurZGg=" + } + } + +, + "32f6d225-13df-47fb-9a71-2902b9ee4754": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "JdM2FkleorUYbzsIeWxOAjTBJQJcSLWtAXUgFGRyUQI=" + } + } + +, + "876b798f-d656-406f-b7ff-199d0014ba89": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "0/Mu6PkCVAE0sgYgWVMJbcLhPfzsFEMZLagdPERNFm0=" + } + } + +, + "ffe3e9b7-ac16-4b3e-a4f6-ec3921779765": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YG8QkS332d/TylfWAShKNXF9A4U44c7HytBMyhw2VTU=" + } + } + +, + "df344847-39e0-4e9a-b809-15c0c7bb15fb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "OjSg0kuEKeIsq+jyufTkRysms8Zekj76NbHz7qTq+0c=" + } + } + +, + "64309404-1fdc-4f25-b4d4-5d1d44578faf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "D+7x4lEBUAnp55ZyclvhdB784vZEF0cR8P2Nbm9F/nQ=" + } + } + +, + "28e6c51a-336c-425b-9de6-8c0df7303ab0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C2O949NOrnAm2lm64cLkERpxrvfGWLloP8BCpvzc+xE=" + } + } + +, + "15d64c75-b561-4bfb-8f26-e7b906a78b80": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Kq8p+jcfddAl0MnoB0qA3ju9Ou4iCWLIPMrS9BpUn94=" + } + } + +, + "5e6d1cf0-3f8c-4f51-ba21-e4244a6752ef": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q/cdn6ECWlOcebiV9OdRibrlDou0FE1LhWOjien5Tok=" + } + } + +, + "b9b7025e-70d7-4d77-824b-9b22e9a540c0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Y/ou88QnH9msIB48V14cPHLoPefRMQjBtToFIEpAAzw=" + } + } + +, + "a2b1dbbf-8678-4930-a604-129dfc9483f4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uWY7D/XWlfBcdS32y1iU+Kh0KBvgwILoRW826tZGi/g=" + } + } + +, + "19bad784-ed4d-4668-98ae-429ce698e442": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8qjIIvuNU1Q0DhObTG1VgOO62zbum0RMLRQIh1FzSoA=" + } + } + +, + "4f9a41ed-92f9-44df-86b1-38efb2acc0c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iZ6UwaFa4hQuWOb1CYrKiZiMh9W0TPUMN0L96RSU1Yk=" + } + } + +, + "cf7cd21a-9b07-4657-be9f-ce4c10e13e7e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NJ4cFd0VmDug8jQMcSxUsSWMDwHIA48juegvEGwyS7E=" + } + } + +, + "39f6c048-ed10-4a88-9ea6-ec4cc95c9692": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CULYXMOBPMPSX8N8OoQh+BhQy0jWlyvby0XYYCeaPvg=" + } + } + +, + "2d9bd604-eb33-4b24-ab3d-4c558c89390d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "IDlPjcY/7phGaF6W5QMESjErXJnTKfmAX3JFivgdG0o=" + } + } + +, + "9c826fe0-4d02-4c0c-8c11-f08434e3bec6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dXVAEFxarGppWv7rqSMem2RnUwRJTLtycEDl97Q9AZs=" + } + } + +, + "76b7d38d-1fe0-4f2e-93f5-36d5edaf68b3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3gTs2/rXzd97buIKa4RLZM8W/8/vwdrHYnT5FnaaVGQ=" + } + } + +, + "3403599c-79e5-4ab6-8de8-5f8c199e2ce2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "x0t0AlbHpD7baoOtvH7pu9ZZZxZD0bMmwnCYsaFg9rs=" + } + } + +, + "5f23e20b-b120-4e70-8d6d-20ab48ad0276": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6C0ZNQdO1UTTLQnFZ6X4lvk/CiESWMJcyjcS2Xq755Y=" + } + } + +, + "66335e8b-99cc-4cd3-bd7c-cef494b833c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KWHJNyGIDWAvIHshfOdVtDhz2iM0nhp4NjpgPWH5SrQ=" + } + } + +, + "0794b981-050a-4054-a69b-0a47f15ca0a6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/+lmwTnafISACHX5bjaXDu77ddUszGucmRJu5XMoiA4=" + } + } + +, + "779e48a5-b519-4b67-aa04-ae665b1c6519": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WXWv/1qj6q4ODjzcGRdKV0hnvOtPtf22FxQnwAQJVVc=" + } + } + +, + "6e79731e-3eb1-40ed-9657-c265b3e2ecf3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "JnWjed0lHLQMkt6056W2BTdnsG3IMwusFYjFqPq7qQU=" + } + } + +, + "a64c2589-18d6-4968-a368-150932fc200e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lSFltfhYjV9H8XspHkZSRYQzdqHtTppHXutgNQNYTUU=" + } + } + +, + "1b93fc41-b35b-4b19-a96a-98831a0614f3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+51PRq59eOQlCgweuyEHtOqPXFK7a2/8PBAXAqY/GLQ=" + } + } + +, + "8faba5c2-76b5-4a62-b612-c28a28828e14": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "82VEZ59Cuqkld8/RQ9e6RuJ3V3OKVK2xPG3UzV7JpUY=" + } + } + +, + "f63fd297-7631-4771-9c88-1bdc80c204c6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aor4INhckWLf64BRsOH7pXuY6zTNSoZ6xvGbTa3/5KU=" + } + } + +, + "02ad2e0e-7afc-426f-aeb0-6a6e20f99ff9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pmohrOumjXPrkWsdGWW80Ld4Mrj+sJpr8otwAQR7o9A=" + } + } + +, + "edec81a4-ef9a-42ee-8d37-ba9884991138": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Of0FPIs8DEJriaaFSDoYoijvFiieKhtacpO9mVUkB6I=" + } + } + +, + "30f1b446-eb9c-422a-9ffc-1ab189667a36": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4MSqe9d6dR4vO7Uu7Z53rfHWuW/CbGIGNiGuMvCAaK0=" + } + } + +, + "44bbfe2d-a31b-40e1-8043-d2aa5e45fe41": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pmk1evpIecO8X0Qqk3bK/bd7Jm7vXm7bpUVfNo5o1f0=" + } + } + +, + "1e37ad13-de21-4b98-b3e7-aedfeb38115f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YWH/5++t+1kM+E8mr+SPe3Bz7PP6u+xBFeJUOrL6kHs=" + } + } + +, + "d3f9464c-0a2d-4f1d-ba1b-6d5fafa31223": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BJR9pbAXBUhE9/Odc/qd3xWGbrGlARJQXe3ogW7kgt8=" + } + } + +, + "5472eeb2-a1b4-4bd9-9cfe-974a4c1d1e72": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "K1z/1v4fBhj6rQSXK+gV9DpO7MLrCREA47cfizb2CvQ=" + } + } + +, + "311a92d9-7ad4-4681-a4ec-85c3cc190fba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/oyr0/1MmxypbSzpcEd4R++euMfoWowEsHc39W1ZZ0c=" + } + } + +, + "ca444710-c6ec-4fdb-a0dc-a0056673881d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1kIDemqBT4jV/wTC3WjN28dQEG5/l1iQzOUf3sB20ts=" + } + } + +, + "4e6445e1-5a94-41e4-bb49-14236582fdda": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "x111n2ZsK6D1eDOLgifDTtZPZotzejy47GIol5853E4=" + } + } + +, + "ab9a1f66-4cf3-4c29-8b65-4b407cf29dd0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "z0Jqlwo2Y2MJDquBxi/2Nt5QeYMfIHR7EBSwndsx6TY=" + } + } + +, + "d99d8ccc-d5d3-4080-ac1e-68cc151bf2e1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zRzvzmmwPCv7H01us+JUh9wO/Np8pisz4gVWcq78S4c=" + } + } + +, + "a4544718-ce7c-41a8-ab0d-4e4d8e6eb251": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "StvYQTXR4sKimL+FSFKpNlvJy1Ugx/Xau4KkmVVMtjY=" + } + } + +, + "e20bcaa7-5245-4b49-b027-896a3a863c1d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "d//slJ45jUFX3BwNEBfBxGbt/4CLL5pZTsYHEQ0J3sQ=" + } + } + +, + "6996328b-a899-457b-bfe5-768b9556a1be": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dqkMKtc7IQszWAXlxwjrAWe7Hz7CLTYTKkIe+doW9AE=" + } + } + +, + "7350e337-9637-4f52-942d-795e9378f5fd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NoDM3lmXawJsDcxCAiFcvieS38pMgXwadRfXXh8/Q74=" + } + } + +, + "5d479f6d-d41a-4c87-8887-5288c94653af": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4qwGH5d4Z+hBZJ6QdKRzjvO+FQuCbnDwWH6FjGm6bI4=" + } + } + +, + "edd93692-a0c7-4bd7-a881-a4c6e47d988f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lgkDnlTnV5X1MHsS3Q4KgYcbEIpB8UCN7CpgDsAQFYE=" + } + } + +, + "3d9a9d4a-7759-4632-8ffd-4cae6dce2e79": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dSf/X+NMiIfoUnOaPRsF4WQ17Ev2Wp+f8UhohiAFGuE=" + } + } + +, + "0a00e5bb-7515-4614-9f18-470d8ab73d76": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+OCl15vCFjzUxNaZLniFXOnytsOO1AEkzd7NhTNmmlw=" + } + } + +, + "2ae3e89d-ea51-4115-b0d0-455776df3e56": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HSrXEMBg15Qzu8OB22yZUww4xATVdsCMKqHYncZyhlM=" + } + } + +, + "cb98eeaa-55ed-497b-9f16-41717b52c1df": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dbLbIOl8KTnuYoqGrLtd3WSgyDT8aj4h93iRmrGlQt0=" + } + } + +, + "7be29f21-a9c3-4e79-8260-2b7de9cbe9f4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "okBFDkDBBHfvurZKIaxXhbNSVhpV1xNv9qCtVjyySIU=" + } + } + +, + "ae4c3929-89ee-4cd6-8f34-91bf03e12cc8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Sf0EoA6JweEmO1W7LQipr1jvF7Qbn9b5PyFOpzAWtq8=" + } + } + +, + "ec6b6f8b-1582-41fe-ac6e-926a05b6ad18": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jYoUFBI6W2G7PEm7VphAlpyYBwAHLEx5oiZSp0uGX5Y=" + } + } + +, + "506dfe90-e5a3-4ac4-bd3f-32d222b3f9fb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DgdkJjcRfJNaxXLPaDXjbh8VdzIiB2uLQ99p03Ur/G4=" + } + } + +, + "3d0bc1af-204f-476d-a8b4-edb249a8535e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PVKtlOhXX30XRzL8ocaUSSxAvoD9QUhlDl0p4LzYi0k=" + } + } + +, + "0db3f2f4-e705-4a16-b819-22373cc4f0e1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "P7Hhev/DTRMxpiPoUZNvdy6j8m7q1VoLKLw49EyNcHc=" + } + } + +, + "8560a079-f98b-46e7-a3c2-a8b536edf263": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6uIMOLiLstyKo4m4B0jaLPvwHyytnaXEk7mSpBpWxSw=" + } + } + +, + "f8f96b1e-b796-4718-9f34-ba7213cb29e5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WvW7LJSOnQ3K4Q1oJSiMKkvnqDiBmIoV0/sWdDg2kyo=" + } + } + +, + "88b8bf77-e624-4b0d-ae07-e9f17d35a786": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sq2RVZZf0sg4Foo/iTcjs6O/gkGDScXQIQyRI5QpPLM=" + } + } + +, + "c826c8db-1fc8-4273-b96e-89387a8bb8bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Fsj1I/ypE2bF+X+qHkMt0Afa5jfpvwR+3ONktgNdMtA=" + } + } + +, + "c22be8fd-6d27-47ff-8c60-504d4aa5ffbe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "M40VdQFWyRS1vN8rzYHNISKfBmEUQN4MrKbEN9Cf0iE=" + } + } + +, + "66e1192b-29a1-4f61-823d-6c36ab7b79d3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tdVM8iPedFTDBQvJeXp8e6THX+Y2yGNM2h8Q1WRkY3s=" + } + } + +, + "07a3f9d9-8181-4c3b-98a2-071df684afd3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fPm0m4z8UGoRQbR6Fjy0yW3rp4+Z6kdyCFuvZgsiq8k=" + } + } + +, + "d98195a7-b020-403c-a32e-7ede6651232d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xBC3oN1z0gKVuQcfkc4jktUCpLTIZcUajKMcA4zQPJI=" + } + } + +, + "45009f1f-341c-483a-8ad7-5f8c32a22270": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "97bj6f3u6QN2IWJR/x6aqeak8P3o+P4bbzt5TeIAhak=" + } + } + +, + "7d98460b-5ecd-4baf-84c3-f824fc254999": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PrB/nHM0IsjF69ukL/ZdmS+ibIhmIjXQ3PHAuDLoQpk=" + } + } + +, + "2dc0567a-068a-4f5d-9af3-d74f09c8b571": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "m5ajpRGfWezTN5xYQTg+NIqEsLEEiU70yi2HRFwmITQ=" + } + } + +, + "35269459-e74c-4e68-930d-4e5320ff8715": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "j5Mj6tNNtEm/htBtGLmQ156BMP7GW6NRppzLcQWnj9c=" + } + } + +, + "f2ff0867-4f8d-428d-b311-4854307d9c9c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CGv9k9QDSiRtAK7ZvgwAuxl57ofBFV08dBq1xaMSH7s=" + } + } + +, + "9aea41d8-faeb-4e2b-86f9-fc7d40e505c7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iWwcha6BcRPf/1j/dLBkLJh+D5G7l2YLxuVD42mueyw=" + } + } + +, + "00090102-b916-4def-a893-8407866dae94": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "x9CyOKtmqq9zJ4wf0ipihtbCoSy+cL23aj2XA880fYY=" + } + } + +, + "ac488184-a8f0-40c4-9715-ef56f4d581ab": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "URSSBH4C9xQWAIIIZl4hxUAGgRBrFOAMDxqZFHtAPsU=" + } + } + +, + "2a676a64-47a9-4133-989d-5ba014f3501f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aEJVTNmOvV91xWyhJ34mwXlQRljMmKpHbN93vTpgOcE=" + } + } + +, + "1e91a9b5-b059-463c-8f05-64578bbbb391": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3I7Av+jPEpNa3NBHE4qtRs2c06v92QWLQ8bLWw6UskY=" + } + } + +, + "f995209d-c826-4071-a34b-8826c2c6cd4d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mOsDa0p1qKcvjkvXzOzFmYn5EH9fY7+/NpRQy9Hy2pk=" + } + } + +, + "969f4c90-60df-4e6b-bc7b-058957e590ea": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rYxNDsP9YqTB0Vxetznn7byeXhrW63W82MtHQqon+O0=" + } + } + +, + "94ac2550-eca8-40d6-9d3c-fe8f25c9ac47": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tT2K5iu6Zo3mc3aKYUHzoaQvmfI+rHGV/2ltlnxf7KE=" + } + } + +, + "32103331-3434-453b-b00a-9999f2f37661": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "COTq2AbLK0yls2pbjFHHLRn2+cwT3TxUvKlxR5FP2C0=" + } + } + +, + "9274e2b6-ada7-45b1-bef6-c0686bc2f83e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hN7wkgvv0pmASY9VLwe08JXM44Ye+cWBmVOUSTIZq/A=" + } + } + +, + "32581966-2497-4f0c-9b09-0d4a7b9afb7f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CxYDVgC5v8wyRP2t1XddWBoEEEIVr6jUK17mschpQlg=" + } + } + +, + "49711728-7a2f-47e3-9700-c356314b5ed6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UAUPsohdVUsuHPkVep1gH0EXHKadS0JTNwbiCWeDfx8=" + } + } + +, + "f335d8db-6b99-4122-9e0c-85cb06bc244a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "FaTNxwBg1iQy2pEnFR2HEAS23tMVdsE8K8CKOwgDmBA=" + } + } + +, + "e99361a7-28e1-4124-ac3b-047b7e350ded": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Elvq6UE5RvXGrnAk+ASTGQNJ+f1UL1Ht37RrOOUajBk=" + } + } + +, + "8090814d-4994-4c61-8553-96e68a835f32": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xH5Ta+M/XZ7Y2EKguVvLoNVsQH/2KUqGwcJZvKRF1KA=" + } + } + +, + "7143effa-eb94-4e53-9b3e-9011a976116f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bFfHQ6VqiT5eD+m/D/tCS31F1FewfJ4mRxXyoxLlXUs=" + } + } + +, + "5c96811d-09a7-42a9-a2d7-ee00dac3d851": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Y21laI3UDGzMTOXKV2BkM3J/dnyYwht01Vb+1kp+ezM=" + } + } + +, + "7784fad0-4ccb-48d2-af50-b98b9a60b4a9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rUfJxT0hCiv5UH3ji5KQkLxV2tEoNx0z4Epm/5aMj5A=" + } + } + +, + "9874f13f-1e36-4527-9f9a-05784b24ac11": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "trzdgjYx3AQIh1fVcRYuraeuzpYjJ8scEZ1MyWwIMa0=" + } + } + +, + "10649f85-08be-432b-85d8-4909e2371807": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6hK+UEVlr3MYisYpCl3wTfsArURQc7hrAZDdNRdD700=" + } + } + +, + "538031fe-cf77-49d6-b225-58bc3b435155": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wm9czrtezw6bMKW+o7ApPEt9T9quSNgWgiq+or6uNjw=" + } + } + +, + "07348b56-9814-4386-8242-c0f1b6a4b104": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/+dgmqlWmwv7WQahJjwkve71c468QIwT4kMdvTsiO70=" + } + } + +, + "f2d14c49-7346-4c67-8314-bc4c69e02f66": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "B4HXjGc7ivLJg8Ece9jMBRaTxJhyLZ3q0JnaAGbG0wU=" + } + } + +, + "891acfc4-b650-488e-9660-47f0515adc1e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "t2Setfo5ZPEoVskDbS1N96Z2jaHvL3PpMUzSH3AzUvc=" + } + } + +, + "657cb4df-4f06-4ce1-831a-bde4c92d056b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "T0CqcamvtO2hAUZFoci8nV5SuWW8uaP1uBtdWbzWo50=" + } + } + +, + "2fe6f533-6087-4f5b-9cc9-f2d3fd7a9e7b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vTOQxJIRnmsILzn0tPKVeqwhg9CHB4lzETUi6Knsino=" + } + } + +, + "b950d71f-092c-4838-a1f1-35713085426e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XRqPUl5H/NQ2TkycxmeUwkwInEZLUevML1RXgNt5i8I=" + } + } + +, + "2e987b8f-1dd4-42eb-b9c3-a0b2af0c0d2a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Kxn8UgY0EMpMezyrqbaXyToL70YTIgfSVWEnt7SoiMk=" + } + } + +, + "a9f76d4d-74f0-4b76-8ab9-81b872fb4de7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6f4niMZaMqdkInT4B+AECfjsNJzTTCW/fThv5Br+Gwk=" + } + } + +, + "ea9f786a-53d5-4655-a10c-b470db708fa1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zcivLmG3V0RndaEZY/6HTNzavDp0oUBcfm+6BX7gmEw=" + } + } + +, + "1c83bb39-f4cd-436d-a586-7d083dcddc8a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XgurY9UDWGaB2LPLZAFmKE8ZuHfAFU9+mMKo13kfeSg=" + } + } + +, + "4306c95e-94e1-4b05-8d36-c52e689fa323": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "72OEHNB27GEBnoUizW83T/5xlwjFYPt5GISePtBxKE8=" + } + } + +, + "bdcbf1f4-2296-4723-99a3-75a9fcfae24f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "IESpAip3cs8faAangbbHNTFWuhY/YWXXBnIdu5yo2DU=" + } + } + +, + "4991612e-a6c5-4adb-90b3-b54857422968": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1ZRfn9nke6VaZGza0VAnhMSGTIvM8my9Q353xsxOOIQ=" + } + } + +, + "f145717d-32bc-4b85-b859-7c92ca4836bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1BQAm/ncNus4pU9Y4q5nH8UGE4/syiHzIb9URP+weB8=" + } + } + +, + "0d95fba2-37e7-4150-83fa-f62cdbacfce4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1o/IRzjXzKt7Mbr2CyBROced21MtwduzYiuh6hY+Tjk=" + } + } + +, + "d2961313-2fe4-45c8-97a6-2e8ffaad4085": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pdpT1XYUyaRM5htuyR1uRLTIQMFjAt68VfwActQDcUQ=" + } + } + +, + "9a90ba94-c71b-480e-a837-02ee7d85c379": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vcJyBRVxgo4HFM+KoRQU/azQYREAZ5WWHg7UlrwKC/0=" + } + } + +, + "24dda73a-21e9-4a5a-9ed7-f79463f4b957": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C/dvX4TKcTOYSRkIoCkp4hrlfEuR3GYrgVMCFL03NuI=" + } + } + +, + "10c4e9f4-accc-4464-a0e1-9ca508dc89f7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cWGbEHBchef18fJOzUmJN2BziARlSpL/7OvpUtBXljc=" + } + } + +, + "f201198f-654b-46cf-bd8a-00331e19fb21": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7FUL4WhWBeg3BWsng9gKKP1HGPV9QBLwLh9wO57GFSg=" + } + } + +, + "d630e658-5e07-4e4e-a3fc-32d42d676919": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VHzVCZAYWKIpLltaSmk6CkVuxh2FDk+6MDRARld3JQo=" + } + } + +, + "9a2a8f9e-3869-4216-9298-75faee8e51ef": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aRAY6sWcxl4gJqNItlixZngCC/7QitFGOTy4VKtGrmY=" + } + } + +, + "24620636-e6a3-4775-a5a2-12ed101747a9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WZNBUpLv3zHn1w0BDTT4CEiBUkaH+cgp/s0WHRAq5wg=" + } + } + +, + "4cfe047f-d008-4bbe-8fa3-fa4fe5c8d191": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gu6elJWCIjtyokTTFZmF4JP8jYCAlDUja7hfzwiHmuA=" + } + } + +, + "7bbcfb13-9445-4204-a28e-9802c35252ba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "IG/hvBp2l7M9PUBsQwg1+DF98qgPYICrJCdbcF4WKvg=" + } + } + +, + "76e82ffe-bdac-4392-8a7e-7931050d886f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Q1GHnQMQxDc/egStbTu661JDlIkWBtMvJmAfsXAlpes=" + } + } + +, + "eadc527a-615b-46a5-adb9-5218d33208dc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LF+vrOcrxscWrgMY9ubtGz1NvLjyPdHfD7QYBOv48hs=" + } + } + +, + "bafa8e1c-db4d-4fcd-bd7d-c683e54e16c4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZZ6Gyg+sQope4IndJgg4j3SMld4aulWSR/qSwTsWJ48=" + } + } + +, + "a8d017dc-2e74-4594-89b6-1264b2277028": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q/xdKSmlRpeyBKEuW3pV0bruTj08s1GPqx66MkZkStE=" + } + } + +, + "ac568d0f-17fc-4c34-a3fc-f6e8d1682089": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+rJFcwLSD6wc5Kw9pChIIOugVmcXxBi0Bf63Ibk2VyA=" + } + } + +, + "ad47d6e5-fca2-43f2-80f9-f70b97e0eee9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/f5hYIRplEr6ixm81/6ZFOzscnSRf4NS45ECoMrghhQ=" + } + } + +, + "d14c62a1-71ce-4ca3-a599-79ea14c15a89": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q0qk32JmG/o60lO9iFAEC7pYt8t3cAziI8hIoZVOGws=" + } + } + +, + "12225cae-99a8-4895-8e45-203be58ff6dd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bBLv9PAIre4bkyelwaHOgX0A/ODlHrr2Aok8udy/0YE=" + } + } + +, + "98936116-94a6-4d85-8982-cc10a8ca7d13": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "51SkUkHlR3Q7/FlSgnVv9fZGt0ZU81BsIuZCTp9rcPU=" + } + } + +, + "4d8f0bf9-87e0-4fa8-b56d-602338e47f78": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lTVn2PQ5ttEsHVFUvZUQL4QndMzhL6HJNQdKSKCLDy8=" + } + } + +, + "909d2f73-9b3a-4df2-803b-8d8cc0238c5f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Cs2azDOcj62XKMX7S0l74Rvfidgmipi1jjLe51ZXZOE=" + } + } + +, + "f3ef6794-813f-48b4-9677-4bd1864fe52f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "elKGS+PAOSwQXJ9q4dmWk2tAlV/21i40CUaEdvzHiZM=" + } + } + +, + "8aff1344-0853-4d56-a668-a5df5fe83dcc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nQX1llVHiL2rr28KkEtM74wX5oJAUZ+lsrV0Fo1VU+8=" + } + } + +, + "c252d847-108e-4002-93e9-994bcb9dcf16": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "N6KB1+Op2iMPO9jV74jOnCawksP2v807FiHDyfKW0Zw=" + } + } + +, + "539c0848-b8cb-4ed0-adb5-c1f73f38a0bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "o7gM1ps3ZTYNsp/QlWKDvLKqH8KOIXIuFKiEzIh8nLw=" + } + } + +, + "b36ec276-f038-436a-96a6-3fc589c25bdf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "miB15X/doPbr5eKfWyHL8IsyZvFqy7fu8v/5g0Y/1PA=" + } + } + +, + "ec9918ba-86b9-4eb2-9ea3-85af4a4147e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VCXVZWpw/ISychYtffAB1kU3xnF/Zuucq2gNMWDuHtY=" + } + } + +, + "f6af4e57-3fb8-448d-bf11-dc45d6697bbd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7/L2DScRyRyLEPptBT+QY/7g5RkyB94EkgrhcRghj2M=" + } + } + +, + "de59b26f-b04d-42cc-bbe4-096610e49122": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xHNkRaYhDzTE1iJDtfwaLNVhd1GzNxgs3cw5X6jiBSw=" + } + } + +, + "66e222d9-eff7-4e34-9230-b9530960b05b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vhZ0fOncduI/Xfsr6gVJSq8EZ2j8ymH6JkfgN/cbVko=" + } + } + +, + "4dfa033b-d1e5-4341-8504-8d8e6b340a59": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "EOTJ1IAzRNbmVV7YHRtfkgH22sCVJVPO/09FxAAFQJI=" + } + } + +, + "c6098cdf-01b3-44b0-b610-8877a0ebb0a9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HC6KGMVf7bAy0xa5qbrfeg08mQzQSfqoK8kNpbSkwHo=" + } + } + +, + "c16fce5f-a2b2-4b54-ae18-bbe0c3f1b291": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hFZKcELH7OImAWTO0zyrDpVEWWRX0fv6Pxt/0s4itA4=" + } + } + +, + "41b0677a-85e9-413e-8abd-3e2094595998": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "eiNFnSxy5HxYhe5kikURnWsxVok5ZPNkQZ/1eJdbDp0=" + } + } + +, + "7ae0ed16-b23d-48b5-872f-422489a20821": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TNg1QlYJZNotL32R/Cv2/13KJlZDH3PCNDVmjeE16f8=" + } + } + +, + "a4dad79e-18f2-4739-b957-0ead6cf938b6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "47+NuzTrSpAp2tbSM1hoVPKtnq8h/V2IMMDNzi5Gd1Q=" + } + } + +, + "f00ef034-7f13-4957-b14d-129f11230c9c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2Q75quXdqtxyPwkzmGekxMgc6r7wy73EayUSL4V5u8Q=" + } + } + +, + "cf8a5e2c-06a5-4d57-8140-2617afc612e8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yIpJ6K3HEneIn6LtmpNM/tmYWvy40QVvkYW58YeNU/4=" + } + } + +, + "bb2d16bc-a8b9-4cfe-bab4-122260d69fc6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Km9FYcLzlzGoZbPmJn/pMDt9VnXX5YApsX+o+jth9jA=" + } + } + +, + "74908436-0d89-470d-b9de-7e4a34497f34": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "t8G2zvgdyIBN4XXM4YTWFKbTpdrtC9+YVPtu0PyayRQ=" + } + } + +, + "da8396e0-deda-44d3-bf54-6bb3b3aed1ef": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KJq3hQWxks1KFP7BkPMr9jmIpJEQp4XVUw7l3Y3tNPY=" + } + } + +, + "fc4e647c-7483-43ef-8a28-d23417601bc3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Uh5oS6Dk60YDCU5sUNHPlUMMe1+18vxeGhNVcE3P0JU=" + } + } + +, + "8fea9c87-e01b-4d33-8693-da96687294b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WliN84rBmZ2Pjqggu32duUtKnuef146FlpSzPKZjgrk=" + } + } + +, + "75fb123b-1f22-4161-ab8e-72610f9e58af": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pauRoyzBlZ2egFHCP8CyobS5grc514KFh5pK3iLeraE=" + } + } + +, + "f4722afa-ff76-45cd-8a3e-f2a0c3848bdb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "T8pFOK403v0CwXp/v1cOVF7YViy7IsnlG9thY6JJEVQ=" + } + } + +, + "10e261fc-cf4d-4fe9-aaec-1694938076a0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nsHHWlet5Q4fbFzE61GITo/T1E5Cu/IWBnZH2PZPl04=" + } + } + +, + "ff95ba8d-d250-4146-9f0c-d085f42a0152": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QNYpkqi2CJNE8jIpO3LFIVHEOoa9oB+LXegpNSZs2iE=" + } + } + +, + "4ca3dac5-0831-4a12-83af-b57e8aa49a43": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "naSHy5rS71FXnRpl1a1Lxoy2lN+PxPhJTocBecizVMY=" + } + } + +, + "311155f8-7933-4115-b38c-7f08e24f1646": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6dX/FFsH8QB+yLYYAmN2SvjH7ABOEeYYZ9KtBB99aUo=" + } + } + +, + "6061df00-4824-4bd4-8d7c-df2bddee6d8c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xPrKS7eP+9tQW/FJj4RyeNXo2V+imezDSUHqVZKabXg=" + } + } + +, + "7b34d9de-f7d2-491a-861b-ad7a60cbbd6f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "F4yxe2qvkNKHuiN1S8nWUwaeom9/uYfKnqA4aVbXyVM=" + } + } + +, + "a7611fca-5191-474b-b04b-b83d4b7c9874": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1nLO5eRtWkf7/6aHNcaCJcdg3fHxe01f4uW9myjYnSU=" + } + } + +, + "ce408ecd-2e52-4cb1-8e2e-cb38d51e4414": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HEKksOp5C4F5xjrMLFwy1w1Qt6T/bxyZYNwh0DFCLdc=" + } + } + +, + "75b0ddcc-1477-4875-9a01-52253bb20edc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vtlnxJTPaV1gRlq+ywNR0q/LdNCB2X5FeVxBotYdTtI=" + } + } + +, + "36f2133d-a077-4328-951b-a1d8938031de": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UmDaIHMIb3e6VQFDvMu51kNyyTRmHnhvo08aX6HVptY=" + } + } + +, + "10be8b26-0c85-4b01-8ca1-a197be66c57a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VlcxuMdstWOCDm0K7rVxkkdFIqzSeqJ7mxR2FvOrbpI=" + } + } + +, + "586de6e8-3dfc-4922-93f3-fc610d1a1ac3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sizz1vMFDmYWLLnZLCakgqM+4MLmExl+DzaixTE4u4I=" + } + } + +, + "f2e5094e-6622-4142-8d9a-b34547105dc7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vnEjIyLg6IumBM93xoTjPK9jMDc39v+Tvx7Ua9ua/Dw=" + } + } + +, + "d912ece3-363f-4328-81ae-64be5a3fecbe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uB58VB7AiGlO0e8o1CzSAqkMb0AL1p9xV8v0NMkyzQI=" + } + } + +, + "913ab89d-cd85-4447-851d-b7d34f130df5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "R1ePj/G6cCtG5t69CMARG1ZFnJvkrGczX/zFoRXeDhs=" + } + } + +, + "a0ddd732-cf01-4a37-8ad2-752fffd2bc61": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TAVss4uMUze9RMS7qVLOYl0Xf6eemkQvpF7fp7RM0WI=" + } + } + +, + "9f762c37-9eec-4a5f-8515-bbacf7ac1c3f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9S7PH9aSTk6OXukFz9kEPOQ83AvDhFlWl0TyGdLHGzw=" + } + } + +, + "840c344c-a58c-4afd-aee6-939f91c1cc40": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+XM8SSBBt+IfE9a2bU3L0ehhL101V6D6BgnNqnBT1NE=" + } + } + +, + "377175b9-24e2-4a98-afed-dcbb0f9528c4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nl+H7XqHTnW9h2KnGoSzPI9NlPlvkVltpJ15uwearDw=" + } + } + +, + "5ba169b5-c942-4351-b458-66732502540b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zwbDAY0N1QuHnJOQkYW1094U0BWYG8ITnoaIjIybqtM=" + } + } + +, + "a858903f-efad-4087-865f-8d0103562f7f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GC8T+9/THtMjxzPALywF1Ak9AO/KxQnLOt0o3DIyGtQ=" + } + } + +, + "2607fe44-5dc7-4552-abbc-591409f738e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tpnBWw+yAj9tImldPRWsfaeL0k8apBUndDhyQSALs30=" + } + } + +, + "a8bd7c75-83c4-4eef-8ff7-237dbcb024bc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VpVhxIyVzeGXEKNjQ11CkkeHctCZg9r5jgq4f15DXZI=" + } + } + +, + "163654e9-9aa2-4d43-9073-4b7b08e5a4c8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tGWGr+t9W2jexLZGV/rgaKV3lbv+a0xwx96tWkrk/2g=" + } + } + +, + "ef6e9fae-4d2b-4c39-bfbc-8e3cf80744cc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "u41Wr/LhZ86eNl2N6aE1GKqfRbvn93DWhyxGkfS/Khg=" + } + } + +, + "23884cad-7306-491c-b670-f02696169977": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "W8D0nkKZT4GbjO1ENS3VcErS54pXj1iZgpb2WCgzynA=" + } + } + +, + "937a7ad0-137b-4b78-ac70-b56d53cf0325": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LqjnVj5Hy+DgYoBi2juMwj+69EIrUdz4+Xibfsclk8I=" + } + } + +, + "0321197b-5b90-459f-9e5e-8beef9143b9e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4tFfa2MgytoGYGUMuuKfrvPDTH92Nt3CH3p+EKf8gK4=" + } + } + +, + "3f9ffdd2-7d18-442c-8afc-61517c050008": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "I0Hl0wdujBtOy4E8IyFwCjJT9scSeJsDV9GaID4/bwo=" + } + } + +, + "0f159750-e6e6-40eb-b680-093e597cb089": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pY5TJDCT8pj0VgWICyOw87ScQDAlheWA7UwelBY9r/M=" + } + } + +, + "3ac425d1-4c6a-42e8-a2a9-153df22c59aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yJZJp+NhBrKJn96vhPvobtmEWrP2dxGqkIXFs5nl924=" + } + } + +, + "1140f509-9962-4703-b227-6cd3d30c6ea1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zrkg+NyM9wsDRLKJ49pgv9+rM+zJmuATGl6plf7Ef78=" + } + } + +, + "502f3de7-37ad-4376-996a-83ca2de7ce3f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wcz9CWD3u6RSQehiLuFCdUje7h114ay8S1vzfjP/XXU=" + } + } + +, + "563bdf13-48d6-4db5-acf1-da6f21a9298c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rOLiSThETDJ7nGjM/DQR1b3w8V0tUlsqYoZz0OEqDtU=" + } + } + +, + "0b44afda-4c6d-4d20-879f-232ff0d68254": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4Pp1eq9BEl5XcRDbonm9m/HoZm66VwVGTmsLx79nops=" + } + } + +, + "87be121a-8e4f-4bbc-803a-df2a1cf1fd94": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "7vnHfpBmrQFlMHODBRq+Sf/r1GqFcLoZfCponxgEoUk=" + } + } + +, + "68c0f583-45fe-433f-a153-87b84dac2795": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "wHSDk1YD+QaYo/so8TeyVtFmkIdDFe4egbngNOwprVY=" + } + } + +, + "18ecd72e-0338-4bd9-b1dc-b7f2bd268629": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "otWBEQlLGo6gFcua91BYN7PHkgUcXQ2WuQ/QhupORzc=" + } + } + +, + "936dced9-5908-4587-b362-73998ddd87ee": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Wm8BjlPeoJo2pb0tmKSjXkt9EppGyLeCL7+mMYW6vF4=" + } + } + +, + "64782065-172e-4d1a-8b13-7c069ef01130": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kF1pBFT9+7qj9w4FkEIhZIFPehBB6+yiuu0VGY1cPmQ=" + } + } + +, + "81579b32-bc89-4ea3-b008-9fcc7cc49ad0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6jD6cNpdBWmgNT7PQDObLPsi6WTPSxJxuS8l010thCw=" + } + } + +, + "75a8861b-31b4-4af5-bc29-a1a679f901d3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4EjcMyESSaqUQsMX5IKKAvFazyc0BF6yjVjYC/mclQI=" + } + } + +, + "f8f7b522-703a-478d-9250-290badccd7e3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vhVR6RFqJx25772RrIlklq8HQv0EfDAFoPWmjbGXe5Y=" + } + } + +, + "5217ad31-e6f1-4e09-a2fd-36130cf21c8b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9HHv9NWH0korkbqQBDd4W+Vj/ODAkcVSMouhjBkpZ1s=" + } + } + +, + "3c681984-c32f-40af-92cb-978de280c504": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sAW6I+h+sCtbe1Psq8L3xKEXqTf9aKczQmFI8Lbc6MQ=" + } + } + +, + "f7a90ca4-2a1c-4dda-9253-d2a988048cc9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aLKnvjc/jBX/9QKi4O7kzHmgtKoiKZsN5u8Zvv3w+8w=" + } + } + +, + "1f05c87e-7f02-486d-870d-3f2b45cb23cc": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YEKddcyEbfgciJ9mkNzCMHFQjmHZknrgBZKEeo3C3TA=" + } + } + +, + "db3180fb-57b4-4314-993b-46194f022155": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+kuycB/nInhJb8j7ZSX4wOtZoWQK8TVgUHXT53g758A=" + } + } + +, + "d0e09e62-3afb-44cd-9cce-ad10e7cfa080": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vZjrPMISBJCOlqlvuWS7mKyK+CjXBBOIl4yyc6R6pJg=" + } + } + +, + "5244efa1-587e-403b-9710-37cf2cf9bee5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ezr2qVk2cIPM3hKIo3Q+DGoo5b1MIGeb1cQJlL5qIQw=" + } + } + +, + "0f1c1ec7-592c-43f0-bb3a-4af3016eab45": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "V9zDnAKJ/hdklx81Z5flfEbO0IgXn+kPfY0EKXqJ+nw=" + } + } + +, + "95a1efd8-ee37-4d07-98cf-e355647df47d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HFhFgn2lS/IEI3TfqhWyrg1KVpZos1zqHTlvw7cLra4=" + } + } + +, + "68bb752e-e31b-41a5-95fb-fbf0d8d81302": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "kl7SOAuLHtCRc/uPTUILo4NMwSwenQnIiGngk1BcFKM=" + } + } + +, + "6e4a8d48-d137-4e4a-8832-4229b5318065": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+H+pNl1+eaVJa5lvMPxu6OltuiJIaG69UHGCcy3iceg=" + } + } + +, + "6a40bb83-215d-4639-97f4-e65c15ee1f52": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "T15eWbom94ULmQklS7KT0F5MTU2vMOCdEoMSOVasjNA=" + } + } + +, + "e81aad3b-f613-46b8-bdb1-c2a612b89eb0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "YNL/BnEPXppkWwXtCxApknHA7BJkGUmCfUEe8RYONpI=" + } + } + +, + "e067a370-2f95-449a-b3a4-3ed37e4f4a63": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QhlXt122j0AYm1VDMP/3vFMLRKNIoJhYAYFOXy3h6Lw=" + } + } + +, + "530fac64-0d57-4eba-86fa-b22bbd8ce1ad": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "A0Rx+gWN3ug54GLCxPEzZRJWYu4Qm8nwIPp53tnvLGU=" + } + } + +, + "2b36c858-10e9-4b96-a17d-f249160de6c3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iXI9xuGiXQs05X7exbzQVphgLtL0tEoTLf9lwtiiz1Y=" + } + } + +, + "9d7e1337-987b-4095-b297-8b8cbc63f3b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6R3v97QJsfj8sUQlJBj+LfgP/OOhH6bg5atfOTkG4S0=" + } + } + +, + "fa8c80fa-55bd-4339-9a5c-acbac0ca65ed": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9BIv4Hg5shrgoX0yTWb7l+UAPPRtL6UC+btmLlB45Jc=" + } + } + +, + "284bbffb-34de-4525-a21e-064da30cb2d9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zEN1BdlkjZsj3t+TDhA4EN1RZhHMcpqDOsTEjxMOJxA=" + } + } + +, + "c462b298-b816-4b26-80a5-35735f7a9d4c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tV7Y6Dr/rn030GhKfnS51KRMy/wv6bllLspzVmNqptQ=" + } + } + +, + "a19cd24b-7bf6-4ae6-8a56-e16c8d604224": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dYXDyIpt/ogLZ318lqo5Q2SX0Nyfe+mQEn1mYIu0JkM=" + } + } + +, + "cf8e744d-6328-4e93-bbaa-ddffc4309f48": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "03yRqSZ32k3QxG4IiddQvcJugr0zYc1Vyd51FJTJT70=" + } + } + +, + "c2c574b2-a05f-4e03-9ac7-49cfd42069df": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "57BKoC3O1Zu1W4rWFrc/3faiWbQ42MKDrEGRygupIN0=" + } + } + +, + "3e3bda39-7664-43ef-8c8d-cc704d082869": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xmHB1IiFQt1/zMBylkBm5ddz0sCdk1XFZtbbboteeeU=" + } + } + +, + "2cbbee8c-621e-4bba-9048-906e4084fd54": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bcF+ZXUDm/aU7/nfIdmiDXzTbXFgFYzujfXiwzzHvQ0=" + } + } + +, + "61b12b0a-df11-4d43-874a-519332c9d008": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8CELbyuZH6MuTneGnABHVOEzGHs+jwi7N1RsmoEeWFQ=" + } + } + +, + "b3ca1f0d-e1b3-4f64-9f19-dc75c364422b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ih+HYtf2r2b5KAOCt9tEqJsNlHbC4Lh+4DIYnqrFW6g=" + } + } + +, + "b9eebdad-5015-4003-a58b-4077ff1f136b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "8nkOkJeM2+OeWeTkcMUKvuNrHYSCmsz7h0P/+G3bFb4=" + } + } + +, + "d55a2703-d6ce-4b86-bf43-35eaf7b4a7aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9cKscUETK29it0MIWFvmZOTQv2VUBTx3e61YFEVF+WQ=" + } + } + +, + "30f7f106-c15e-42b7-b970-8a88d36365df": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "O9KAkgk18zqnXkc1CpInzyrAk4YcI+QivkRcKReMOM8=" + } + } + +, + "301632c8-1e9f-4071-a002-63d0dfe83414": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "And9wP+3kH3Y54xippq38hNlbtTqoYdlwf2XfruEqPI=" + } + } + +, + "eed01faf-95fc-4569-b481-5ea51884bc08": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PC9wzKXwG/d9LlkkBj1gzC09Y9iw5gzvZDRCOBsjf8w=" + } + } + +, + "04f2ab00-4051-4bb7-9407-a11cc4a60edf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vFmLM6QoPb9cGnrIMqHd461LmCexPiqnRQBh1C+/wuM=" + } + } + +, + "ba65f63a-7f90-43e5-805a-cd7029b852f8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HNcMKuO3LRzWthEBvbZS4Q3FHz72oToEz6wKHaCoTeE=" + } + } + +, + "407e2f9e-3b62-41a2-a895-103e0e1165bf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MJs7LecbZCR4Rw6fx1Hk2yGJKDnyDXM8YV0Vg9pP+9s=" + } + } + +, + "778aab71-4115-4e35-8d7d-18d91b08bccf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cmyiB3fCd4QohizVmEA9VmN+sRNi1GCcMZw3yYVeIlY=" + } + } + +, + "f6a432d2-4948-44bc-b85c-14e36f033540": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XNjuYToBROiRsVXtk+ex403K/XUvF1PwiKtO8Y75ruM=" + } + } + +, + "ce6aa016-24d3-4cb4-8c01-d5190726c2b4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4skjsdS3Ty2oXUocMhUVE/PbMKXBoVg1sUdRAC8LChM=" + } + } + +, + "0a84aeb7-d6d3-495c-a395-3c1d3e74181f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "LsCb9jFDQnEQdmDPHD75Wz/SiOIkVVVpCWx70wEg5ls=" + } + } + +, + "5c2aca7c-a49c-4322-ad59-b20b8c7fab9b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CBGc8GUDyY8WcWtZ/SPzTBkDj+RwFd6XD2twReA97Ew=" + } + } + +, + "3aa8a878-6907-41e6-94ae-e4bd540dbe51": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G+t8oXObG5wv8Y9iq64TpAr5b7VmjQyENuuUfrawDKQ=" + } + } + +, + "0fceeb3c-67d2-4f8a-bae2-3996cf4d815e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lX3VjSrkHDZPOEevGqkOgYRvxpk/8gsuViJcswe3EYE=" + } + } + +, + "5d9f77a0-a019-4c7b-87dc-161513aa3c59": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XSymsUcqMFMNnmG8nJAv/0w+taVSPCdLFIR6oIGOMP8=" + } + } + +, + "915f5206-45fd-48eb-b463-281414fdaf80": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/S9GZVxSLF0Q9pIuECj8Z+w9VXFJRDtFCeyJMg0242c=" + } + } + +, + "b5c3dbbb-4327-4eb0-a056-0ff786fe7ae2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Cnvz+5M3F47fsuRTSzHY2xtp4O+GIQCWxqj/T1Yvx9s=" + } + } + +, + "2fb8cde7-ed28-48ac-94fa-400c8ad85b85": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "F9zBFUmfBdwA69z39oFdRAbO0gFciRLEGfHH6+ufQkQ=" + } + } + +, + "04d1e106-1219-4699-8910-8b09814c71a0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "9sQUPqD4mgE+sB/Ln8Up7OfWByq17o0ZJ6oE14LbNuw=" + } + } + +, + "2a4888df-4679-431a-86d8-2ee1a002a027": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sPNY5KTxdjuQSTDvLuyGHqHhS/Cx52EjiVMr8zPymR4=" + } + } + +, + "a12cd0db-b725-437d-8afa-8228f4ac39aa": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3+TRwmDhKWIh3KRMT57D+c72wtZ19z56OMa/UFKA3Pk=" + } + } + +, + "e39477ba-91b7-40e0-849b-80bb0b2e6ab9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/VvekfFSRVpONODxv0tCdOxJzYXkRFJCVy777aJVXXQ=" + } + } + +, + "2c478377-6f5d-44d1-be75-8574f5be84bb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "rZsJlA2RPvZK+CM++cV97ryJGoAYhynuU+I4IuTbYu4=" + } + } + +, + "573495c1-d797-4296-8811-65f2298968c8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tRyolT6PS7Q7Gaixf1AWeKQOu4ErmVysIgOzrWJOCXg=" + } + } + +, + "f03e4a74-a007-4d28-836c-914326d7b230": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "DK/T9fpT5Qp7iHWtsXI6Kx29wOHvRfISYpJusaxsJSs=" + } + } + +, + "c93f2b4b-4c1d-4c8a-8bcd-dd915b0b66c0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Oj3mkfWnLeUnnSrF+A/oWSsv9YXgsTr9Pocx2eUR91k=" + } + } + +, + "6466cd47-ea2e-425d-80bd-3a09ea0343f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "56ln49XwFlKvfxjmFBq3zfa7dPfA5gFKtmUD+gkEqM0=" + } + } + +, + "bf887630-097f-4f1b-b12a-6122f642c679": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "TCKCBqUKmO1TUQaQvQYNTl0wkRKwHI/1SksdjKAYEk4=" + } + } + +, + "2fc75cea-71ea-440f-b7f6-577b8ccbb112": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "i0b9B/ghcdww/KYSJUaByZpU7hPtN2bEKea9DjhYnsk=" + } + } + +, + "6885c804-0cd7-4a1a-b066-c86b0043d7df": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "n38MWEHnNM4JhUORZ40AHY5tH0xU8SPWEJ9YjXqTHx0=" + } + } + +, + "36e26700-0652-4adb-8791-cf38080c616d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "o9JAj5AkOhSqBD2PmCZzwbLAU5uFMi0Msx4mk4U4bME=" + } + } + +, + "2d7b432e-39be-4ff9-9b3b-2853f3c89e50": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "IEztE7twP7LgsXZjsqgOcTFe/geuZiiq+attf6+2EXE=" + } + } + +, + "facb381c-1bc8-438b-ab66-b4bc747ae5e8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vUCiHTu5/5vT8W5M5OYe0qxSsQkur+iDyut1UPn4AdI=" + } + } + +, + "879be74f-ae54-4c4e-b8dc-88646b4d2f58": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tli1+HqgFVaYBIHBV5gWD19KpuxvtgJOgR6a3UqGCQ8=" + } + } + +, + "d6380f52-5840-45fc-9a10-db7ac5cbbeb2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NllrDVi3AHxehdfifP5IFSdLeBlNoRdkR5/M/mHgVxU=" + } + } + +, + "52d9893e-4e1b-4dec-80c7-7ae85baabfb4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "y5Vy4xoGBJaTZveidYpibNqHYfcPEBOOinzsvmiUfWw=" + } + } + +, + "f605b261-bb87-4793-b15e-2831030f9c5c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Si8s4cDGPdbym1jX5AmfAls9P/XV0CrO64FDy/kXgAI=" + } + } + +, + "0f5a45a5-0e26-49a8-b7b0-4d2c519350f4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Q4yj2rUMPnWZcsUff2xVdVKesM6gGiltgGjeA2JySnU=" + } + } + +, + "24786841-b10f-4e4a-9625-3c68a41fc972": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fFi2dQ0m97nxZIbGXTpszm1KpWEYMOCh6H6d2kAkc84=" + } + } + +, + "c91192f9-bcc9-4c23-aebc-4cc532fbc30f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "M+5LTE1bLxMSzlG1vt1jDiL8WFhYTTgLC9RKqaPDfA4=" + } + } + +, + "b4ea1f50-81a6-4ba2-b0c5-3c4c12095110": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "pUceL+PzFRJiGZqpsABDCLRVDTv25QIKewOBta0eXAg=" + } + } + +, + "080ffada-c79c-4ad9-a500-dd12c858e73d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "crwk1nQ+BAVJN8f3IP1mwWOuN8JhKBMdUC3c6z3jecE=" + } + } + +, + "050f8e94-f101-43f6-b0da-5b5a0e62b159": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WAkSJTOy7UMsY/yHIGhs9EkbATEmpPpbNXnnmz12c/Q=" + } + } + +, + "ab3d1aea-9be6-4445-ba35-fe471c11bb2b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1NumeZV5aATC2n74Q7RRVsXJtW2Ab38c28Bl5F6qTlY=" + } + } + +, + "285f5b1b-61a6-4089-915f-2c85f73a889f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "M6PbJbmtuyV+iBJr6W2SySKxyDGsu6w9Z5IJd/Rzjck=" + } + } + +, + "e5582bf1-fd8e-4404-879a-3f4646fc77e4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5k/Nwm/ZXWT1HR9icNLdc/dd3tZ6z0p87AcEfm3MwnM=" + } + } + +, + "c0c75fe7-3e5a-4679-ae58-c8f6af06dbb5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VbPwQG7xf73fy6j6CAXI80Sh41R752ilxtGz5hUb1/M=" + } + } + +, + "16d1406e-ac67-4a84-8b6e-6c44b8224f68": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vprihYB+FOpDeEcl+LyZcK+I8ZGVaAPyWmJcOeWihnA=" + } + } + +, + "acb969f2-5e47-425d-bcca-76569aeb8736": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+S4G5wyiznwhtoHgSPM6I+g8FfMZtNlkOKya/FXtJSM=" + } + } + +, + "b5e09a09-a81c-4d65-9703-96bbbf5bf267": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MKTTKW2Xl/E7Rz2UAOSA8iG2wD14gYDpIl0miB36n/I=" + } + } + +, + "bfc130cb-c373-4d52-9ea2-3d54c1cc26cf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "sFRfT6RLakTZ/jpTq91J2aFGTFuxXX1cwOQhT7bDVtk=" + } + } + +, + "aded6b85-5f03-4a9f-af62-cc52bf74d0df": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "C01/pVehIIs5H7dzVCUbrRpfbLFCtzeTIAWsb0k7BK0=" + } + } + +, + "2a068eb2-915c-4dde-8447-2baf8664187d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "mnEqF2G96okVaZe/vzjXbYtjOQN0q/2RDHOMo6ImyG0=" + } + } + +, + "ccf0fd2d-1a70-4706-a4b8-6038e5e3e6d6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "oNkifEwKo7REHATJ+QNGu7HLMWhZHLSsXQYf1eQdWbs=" + } + } + +, + "391df563-05d1-49c1-b612-1e5cdc29e49e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Jog0hAW8HcpPckkjWCg7tjeaJ5AQqgrSVmhSP0U2JLY=" + } + } + +, + "c1967705-52ac-4b61-b97f-2b07139078eb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "MTNpNlHvVtGr4t7U28QTfyAheiJE+UHJsvjFyMbaDH8=" + } + } + +, + "0496ca06-97a0-4fa8-bfb1-35998a1c89cf": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KIPzmEEBbb6EeEAyXMeZTTmR4IxUF3qmnWJbLkHZhk0=" + } + } + +, + "1c099013-0bfe-4377-9873-48b7c630e66f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5JcwjcZwesBTNoIqWsGB7/WFI5nTZm3YSiyZNkffnu8=" + } + } + +, + "970bf302-9ad1-4d5b-8ddf-72c7823f4ed6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4lTgDYJ+o+R4YnGFYLv1hPNG8xmXaLT8YXhqmX2l6oQ=" + } + } + +, + "56debe8f-97e0-4460-99bf-e6a57484f596": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Jq/8UTGgcfgphlYGfaMThje970UktmbgMJxNGmC9DIY=" + } + } + +, + "81c87b68-f193-4ea7-a706-0e74c31a7dc4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "M8X+D3S+vt7engd/eFu2XCLX7RthqKnGx4QcY2VFqVw=" + } + } + +, + "cb599154-ad49-43bc-8946-675085b44744": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GecrNhV5G1oeAG2Heq7rDAj1OCIAbwxCBxp2m2ew9Aw=" + } + } + +, + "7363c9bf-d6a4-4f9c-be49-abb379212e89": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "PikoENTDUxp56+v+fg609i87OwTB1UQCYPHw4mMQq/Y=" + } + } + +, + "50428914-b5b1-48ef-a542-bb954579034f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "H7KyRKhrsDGn29RnQ7Qb/g6goVC9facpvsHPe16qBP4=" + } + } + +, + "3b7659a7-370b-4241-9deb-a44076d5457a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zNiBiOiWUB2NBwv6zw01td3Kkpz9gEcFlB0Q5tITKrU=" + } + } + +, + "15dbe3e2-6b1c-4742-93ee-d058d0d7e6d2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "tMzPWGM3k0Sqk472ZoFO6aXe3Ex2IYRcs4mV6nufUek=" + } + } + +, + "787bd937-0e3e-4b66-9cf3-930d131a7028": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BmayDR4bcnKX81c8LtymARd0oRkLDWVqjulMIDPCuQE=" + } + } + +, + "7d5159b1-098d-42c9-b2c7-daca3ed60aa2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "A129oID54TbKDE71Td6OvhJPrrSV7/Yu0xZV6VDAkb4=" + } + } + +, + "49c7c4e9-c124-4f75-b6b7-d07d738feeb4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VvF0fmTOkInOYnXfmp8mtUfjZ2px2IeR13huw4eBObU=" + } + } + +, + "876c5ef3-44e1-4e5f-a4cd-971b24b571ae": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "4LSE20wKjpFt/fOr6xpUM/Gml89ZHJmJdOfot/YESzM=" + } + } + +, + "6cdff16b-b554-4f42-83d8-7b8408d3ee2a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CWush4NYmGoa7RNyCuG5QRh5v5OWTo9yA/cIbhf/pkE=" + } + } + +, + "e7b6b23d-4f52-4763-9c9b-960b7444029b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WHOtNpF31rIDzWXJLOER/klhviKEYcGqGtd+1TH/Dv4=" + } + } + +, + "9daa5236-eddc-41a6-9ed6-6a8864b505bd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nsfKlEjDgVmAm2BtZckDb4/V2YBd1ZZBmYF7cXjXHG8=" + } + } + +, + "6ce39357-6624-4f44-a95d-03f76d3f9c5d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "zD17rZ31JWUmAPkDH9ZcTt0vaLmI4zJ9PxriHwLIQ04=" + } + } + +, + "c263b811-c890-4834-902b-424547e1ea24": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "nkTam/v+/2Ew+WlFyV3wjo9WyY/u6Oh5KeNyWdRD744=" + } + } + +, + "6f4380ea-2910-45cd-a68b-5eda37904891": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "okrCYVvEv6O0Ot81jld3LbNY0XVO0qi7rSDEKZNJaC0=" + } + } + +, + "31180589-f070-45fd-8309-c458a4b468d6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qMPhJLauxFTzi79WaiurubnR8jCjuNNM6pGkSnc1tLk=" + } + } + +, + "06e0c7e6-78c1-4db0-9966-6d2b35b9ea9d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uhqMyNGEqXZ+Yx/KvYcyC6sIn9zEkr5uZ3kE1qCZLQs=" + } + } + +, + "c2ee1afa-2467-422f-b4bd-38fc8eb12230": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bIVEme64Zo+bGOPUT8es532XV437rnGXggL4yFLZs+c=" + } + } + +, + "a336a9d1-7fa0-4e86-ae42-c3d06c0535eb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5YsxYTMkaUvwkdwiyZbK+fSZInUmMn5T6YvHPtSI1fk=" + } + } + +, + "2d51cc52-0321-4bb6-96a8-f59df018512b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "2pAja8fJGap4GzXEwVXIJMuCMH/S3w6yYQEu2NxL1yQ=" + } + } + +, + "82d72542-0c0a-49f3-8618-3a203c9f5645": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XYJ18YmGklK9yWLHXKEW7kyQZuWckIVKpNN520G/Ce4=" + } + } + +, + "902ea175-e3ac-4751-9314-4faa830ae7ba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+CP5mVwHpCHcfcv8EeMCrOkx6o1JEbM5xWfQ4Az9Haw=" + } + } + +, + "e812707f-b3e0-4083-991b-acd8681cb4f0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "g0jl+yizHEasA9/jHgVI5pJa9u89pQtetRnE/wMbV+Y=" + } + } + +, + "5a6591de-b40b-4409-816d-9ff11ddbe2c1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vdhX8+EoeO+7kmcxOPl1BqzKROf0Pm/3ooh8LSXnagY=" + } + } + +, + "c94c82e7-96df-4ffd-a82d-8a2b5da33b00": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "jbJBbwViSXUi+gViB0DFIpygUnsQdF5tO+Aefhpe2iI=" + } + } + +, + "b58b3949-3545-4805-87dc-0517d286149f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KyFWgRXhLAGwTefjwDEsrDozRZUA9zsZqVf8/90vM6w=" + } + } + +, + "336bebae-32f4-4511-9f43-5416893b2b0e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "c45MFv5EQOe8VWXsIbpdSmKcXwLrUlf/pU9+8DykQko=" + } + } + } + +} + From 95de66aca0e87409a445bd7f4b78b682475061c5 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Thu, 7 Nov 2024 20:55:57 +0100 Subject: [PATCH 027/105] fix: Fix performance and algorithm issues Consolidate sent to server to save time Add full range to q block sending --- src/tasks/tasks01/pad_oracle.rs | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 5d062e1..1a0c144 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -39,7 +39,7 @@ pub fn padding_oracle(args: &Value) -> Result> { // Amount of q blocks to send to server. // TODO:: May be increased via function - let q_block_count: u16 = 255; + let q_block_count: u16 = 256; //Send the first ciphertext chunk //eprintln!("Sending Ciphertext chunk: {:002X?}", chunk); @@ -74,7 +74,7 @@ pub fn padding_oracle(args: &Value) -> Result> { stream.flush()?; // Read server response - let mut server_q_resp = [0u8; 0xFF]; + let mut server_q_resp = [0u8; 256]; stream.read_exact(&mut server_q_resp)?; //eprintln!("{:02X?}", buf); @@ -82,7 +82,7 @@ pub fn padding_oracle(args: &Value) -> Result> { let valid_val = server_q_resp .iter() .position(|&r| r == 0x01) - .expect("No valid found") as u8; + .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; @@ -90,8 +90,8 @@ pub fn padding_oracle(args: &Value) -> Result> { // Check for edgecase if i == 15 { let mut check_q_block: Vec = vec![0; 16]; - check_q_block[15] = attack_counter[15] ^ (15 - i as u8); - check_q_block[14] = check_q_block[15].reverse_bits(); + check_q_block[15] = attack_counter[15]; + check_q_block[14] = !check_q_block[15]; stream.write_all(&[0x01, 0x00])?; stream.write_all(&check_q_block)?; @@ -103,11 +103,12 @@ pub fn padding_oracle(args: &Value) -> Result> { } else { eprintln!("Invalid padding"); // Search for second hit - let valid_val = server_q_resp - .iter() - .rev() - .position(|&r| r == 0x01) - .expect("No valid found") as u8; + let valid_val = (255 + - server_q_resp + .iter() + .rev() + .position(|&r| r == 0x01) + .expect("No valid found") as u8); eprintln!("Valid value found: {:02X?}", valid_val); // Craft next attack vector padding; 0x01, 0x02, ... attack_counter[i as usize] = valid_val; From 84d99f24149559409c084e3e4860b3fe3f99f509 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Thu, 7 Nov 2024 22:47:24 +0100 Subject: [PATCH 028/105] fix: performance improvements --- src/tasks/tasks01/pad_oracle.rs | 34 +- test_json/padding_long.json | 1203 +++++++++++++++++++++++++++++++ 2 files changed, 1226 insertions(+), 11 deletions(-) create mode 100644 test_json/padding_long.json diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 1a0c144..64eb2d1 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -31,7 +31,7 @@ pub fn padding_oracle(args: &Value) -> Result> { for chunk in &cipher_chunks { let start = Instant::now(); - let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port))?; + let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?; stream.set_nonblocking(false)?; // Track value sent to server @@ -66,6 +66,7 @@ pub fn padding_oracle(args: &Value) -> Result> { //thread::sleep(Duration::from_millis(1000)); payload.extend(&attack_counter); + //eprintln!("I in q builder {}", i); attack_counter[i as usize] += 1; } //eprintln!("Time for qblocks: {:?}", start.elapsed()); @@ -82,34 +83,44 @@ pub fn padding_oracle(args: &Value) -> Result> { let valid_val = server_q_resp .iter() .position(|&r| r == 0x01) - .expect("No valid found in main loop") as u8; + .unwrap_or(0x00) as u8; + if valid_val == 0x00 { + eprintln!("No valid found in main loop"); + } //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]; - stream.write_all(&[0x01, 0x00])?; - stream.write_all(&check_q_block)?; + l_msg_check.extend(check_q_block.as_slice()); + + stream.write_all(&l_msg_check)?; + //stream.write_all(&check_q_block)?; let mut buf = [0u8; 0x01]; stream.read(&mut buf)?; - eprintln!("Buffer from pad check: {:02X?}", buf); + //eprintln!("I = {}", i); + //eprintln!("Buffer from pad check: {:02X?}", buf); if buf == [0x01] { - eprintln!("Valid padding"); + //eprintln!("Valid padding"); } else { - eprintln!("Invalid padding"); + //eprintln!("Invalid padding"); // Search for second hit let valid_val = (255 - server_q_resp .iter() .rev() .position(|&r| r == 0x01) - .expect("No valid found") as u8); - eprintln!("Valid value found: {:02X?}", valid_val); + .unwrap_or(0x00) as u8); + if valid_val == 0x00 { + eprintln!("No valid found"); + } + //eprintln!("Valid value found: {:02X?}", valid_val); // Craft next attack vector padding; 0x01, 0x02, ... attack_counter[i as usize] = valid_val; } @@ -127,7 +138,8 @@ pub fn padding_oracle(args: &Value) -> Result> { plaintext.push(iv[i] ^ (attack_counter[i as usize] ^ (15 - i as u8 + 1))); } //eprintln!("Attack counter after set: {:02X?}", attack_counter); - for pos in i..=15 { + let range = i; + for pos in range..=15 { //eprintln!("i is: {:02X?}", i); //eprintln!("i + 1 is: {:02X?}", ((16 - i) as u8).to_le()); /* @@ -154,7 +166,7 @@ pub fn padding_oracle(args: &Value) -> Result> { stream.flush()?; // break; drop(stream); - eprintln!("Time rest of calc: {:?}", start.elapsed()); + //eprintln!("Time rest of calc: {:?}", start.elapsed()); } plaintext.reverse(); diff --git a/test_json/padding_long.json b/test_json/padding_long.json new file mode 100644 index 0000000..3b37422 --- /dev/null +++ b/test_json/padding_long.json @@ -0,0 +1,1203 @@ +{ + "testcases": { + "2397d270-6a7d-48e8-8a7b-e464bcb00063": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vm7Urlq3BHFPy34hxIn9yJJ4xKnmJYnkD02uUgznoIw8K+2HxtJLItkOcdXbIk2ADNXgjc3aQiTeCnTX2CJMng==" + } + } + +, + "44c19d5d-2149-400d-ab96-0764c440acac": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "SlelDIsQJ+qLVsVJaAQpyo/kaNAZ54eJrXOYaYqFuvf8SrED9lst6Iv/CdW0ydh76fy8Cf1TJO6M+wzXt8nZZQ==" + } + } + +, + "4a3ecbcb-a8ed-4c46-b63b-09f8fae33371": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uWkaarF8CoHqIqWtNv5FkIebZ/e4v6QVvH09z2Ew8XehLpc6BgiAB5r3KXtJMuwdJjuaMA0AiQGd8yx5SjLtAw==" + } + } + +, + "ed63e4c3-db96-4d3e-b2b8-91fb78dc970f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "y1wFLXHmhe2rHDgpeAISDU4kv6cJf77367yods6RxUT/bUuOr5N3u+APaRvZE5PRZrZGhKSbfr3nC2wZ2hOSzw==" + } + } + +, + "5a9de26e-5ad3-42e8-9523-cb5ad069a1db": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "xBVHDKq5LsWkoTaEti6ltXLiBvZAN/LvHWv1N/mFBH8TGZyt84nYHHw0r0cyCrAEC4WRp/iB0Rp7MKpFMQqxGg==" + } + } + +, + "e2fcaa72-d396-4ba9-885d-8c8449e48645": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "F8rc8G3tvt1lUfB664zqmawpXoxzM08hgpyjQnbE7MwW7M3noC9s8ez65PW3s6uYKbDA7asnZffr/uH3tLOqhg==" + } + } + +, + "541dc95b-080c-47a1-8c6f-86063c960ac4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "0aDij+0vWLj+PfQJhqiLSBynGHhk+IvXw3mfT2YHQsCaRegAHHuWFT16VrHIncQtORnlChdznxM6flOzy53FMw==" + } + } + +, + "0314b333-aaed-4c48-9418-411233140585": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HFeCxKmP42XhzuY8w0sMamhazEymf3b7EDzP0iskU4FKBKZAzc8tF5fv8YWWqiIZrxqrSsbHJBGQ6/SHlaojBw==" + } + } + +, + "b20e9178-af52-4112-8183-50c0112d0275": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Z15CHkQ1iOkOwdZ/+TvmAMSS3UITjxaJ5N230T0bKql58C0KLiPqx3TlcKoC281Y6bUgACUr48Fz4XWoAdvMRg==" + } + } + +, + "7ee6d7e7-d4fa-4398-a615-6801555c6406": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "w516YKGlRGANdg+30RBCyGKPnGmv7o/uv567VzbBsNz76Dcv1TZxGlq8rcH9vek5W486Jd4+eBxduKjD/r3oJw==" + } + } + +, + "f590c5e7-52b8-4c5b-916e-ee0d3cd4a867": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bB5OrSvRcitV8Q6k5IYhxZGHwK7tL6n4pO8mO9qY+lEn8PWUKjN29bVJhqlp6r4nnfr4niE7f/OyTYOrauq/OQ==" + } + } + +, + "382599d8-e079-4dea-a0e2-84349b0836a2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Vet2VvnayHeF5OF+FrBBMRZz5FXg+ziTPAWcW4ICYrEl8E8dlGN8Cj7UyUMTgMsXs8FCF59rdQw50MxBEIDKCQ==" + } + } + +, + "c9581cf4-b380-4f19-820b-924a108fdfab": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/N7OSIyd0rJe+WI2BIgn/C+X9EZ+iGAfgE0CHepbkFSjyf49Dxd4JUMkcj26ggucl+3zNwQfcSNEIHc/uYIKgg==" + } + } + +, + "eecd178c-5d86-47c4-830e-1bf5aed430f9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZQj80wGTXZiBwtoMbC3eRK0awvIdRhcUEzln9qEoWKilGytMXS9a6NlOA6IOxDG4IaQmRlYnU+7eSgagDcQwpg==" + } + } + +, + "4c1501ab-7cae-4567-a576-c359c1e7695e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "AaG6i5IwVVr9ycYDaTYIw8AcBYEZkSIaqQE7ttR4hqlSfp8Wr1zKV+q965Za3r3o0HGSHKRUw1Htue6UWd689g==" + } + } + +, + "807bdda6-26ef-4e97-b6e9-bf27539187fe": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "fbPGRKxBPpXkqWfQltwOhpXqoWxz3La9rlyf8M3ppfg45jwlWydWlXGHfuXHfq7Rr10xL1AvX5N2g3vnxH6vzw==" + } + } + +, + "829d1b66-700c-458d-8116-b76890e97537": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "r8KymEWRwDRyOj0GB5Pt3swuAJ+Cdi7+DxGSY62R6qOCcg2OnGDEkmvDHTlrSv6qeDoAhJdozZRsxxg7aEr/tA==" + } + } + +, + "caa6a14d-6fe3-427d-a445-c6b15cf8b25c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ZTq4Us+pnWzcBFfsNTncXNVR8iVoV2epE1xeP15cJEQDW0erZpZSTJdafN8LnLVc15ZKoW2eW0qQXnndCJy0Qg==" + } + } + +, + "df9ae9f0-51ab-4613-b3c2-56e6f2de74b6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "D5X0/aOPzv/YnaevH3A0zrrt/MPG68P9+o16Vs9R+Yr0dKbVdx0oCZraoQe9u5iSLvKr33wVIQ+d3qQFvruZjA==" + } + } + +, + "c591b3d2-05b5-4792-a502-da4641461533": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "y2IUs+cKPmUpeY9hdDDSTGatuvZVthvWqmdC5/unBWr5OKFFXuI+9BIv9pRIctmY5iusT1XqN/IVK/OWS3LYhg==" + } + } + +, + "3f5c5abc-81e6-4540-873a-ea5498df297c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yDfhetbRPSBFlGvLotAsnD4E4knnUcppjw/gREIy9YHeNOmqoRu3LDsQbRUw6tQHm6XkoKoTvio8FGgXM+rVGQ==" + } + } + +, + "5b6c1490-a77d-4a2a-9976-9d4635cf195c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "NabDKqpsyhbP+wPVnpDYakbwpyn/z/rJWra2XDUBHRRCkreZR2nODjwKQY47X3i7or66k0xhxwg7DkSMOF95pQ==" + } + } + +, + "852c775a-0bff-42e4-87f4-3991b58eb1dd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RCm+XJz0gMd0OCVhrvACw+lpNkiOJEiT0EbZt/cMgToNjqsRM95ncabJZnqKmqiuzOamGzjWbnehzWN4iZqpsA==" + } + } + +, + "a5a86d99-4bfc-42b4-9d8a-07f1a6f6cbba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UZRcMpvxPxszgcIYtp9vGbL/f9EQ0AVRaHw5WF3C8EEjo7J68BHKNeoKVA16F/FduyG/cPsZwzPtDlEPeRfwQw==" + } + } + +, + "cb260f8a-508f-428b-a135-00d8b0348832": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ICiC/LcF4LhQSKrAi7w/HzTef5YyDwE6sjNe+XZeoH/OkclPUsj3mo/xoJuGOSfzBUDERVnA/pyI9aWZhTkm7Q==" + } + } + +, + "e8aa9530-60ae-4c5a-9e0b-93dbfd0d6660": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5kE3TUL4Lq2jKNgNlVYxqKZ1nM5x2yCx09yrNs9f8fWjBzdEENHczF5uHZ3uKIfoxgU6ThvZ1cpZahif7SiG9g==" + } + } + +, + "7c5067be-0e0e-4b07-bac6-ffdd8652db55": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6piHQ3VtWEvfOa/zf4VWJS6PH+QWlb7+aZDwyJlcfDIDalbg9+G9WT9YJhcrYix9XV9b6vzptF84XCMVKGItYw==" + } + } + +, + "6ffc6d43-0346-4a7c-a525-c93842ff2074": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UzXj9SuFBZTpiEEqzw/DVgv1sLzN5ncacQbfK5DbUg91sKz12uzQoBvUTeXIG2qOTbmh/9Hk2aYc0EjnyxtrkA==" + } + } + +, + "b7567d39-e6a8-4259-a292-8e6790df08b1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "lNc3wjie7beF0ZLOfhzX6Tzosr+02y9idqgrv48u3Yyd0okKnK7AmLQEHAiQe0qGK5WEAJemyZ6zABkKk3tLmA==" + } + } + +, + "c34d7d89-a620-432b-aa98-8f1074c826ba": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Cg0XaEGegQNznReu8KeQ+NDEArv5nZbYfui2Nny8omXeHofazD2jgDnq0ui8uov9V56K0Mc1qoY+7tfqv7qK4w==" + } + } + +, + "6b823c15-919b-4525-95b6-a64eff1a671b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1u2ethWeOGIavEEWsbgSqkUth+0cmPFgN4pYvT67oyxvWk1vGEv28vvDjy1OmPMIB95AZRND//T8x4ovTZjyFg==" + } + } + +, + "72145942-656a-40ff-b981-79b0224ae80b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qIv/gRp4qoNhw6d2pZK2NhI3+rXboQ7CUQ7vmFsL8AA67qvcb1OrOxj1Z63cEvmBAfSm1mRboj0f8WKv3xL4nw==" + } + } + +, + "8ade9aa1-7cea-4d1f-ae32-dfa72c3fa322": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Hn97+gE6oeY1h4W7xN/olVE7koHA/PILlbJk8Vh56c9V/SSSZVRneIUmrl1Z/82JUfQpmG5cbn6CIqtfWv/Mlw==" + } + } + +, + "7e894b2e-d5a0-4590-bc3d-e93672dd9261": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "ttx3yJh+GDifmTwxjCqcv8zUZoi4ExKzogq2ilOTK3ab1agUmk/pRxrMKH1s0Nya0IGlHpFH4EEdyC1/b9DdhA==" + } + } + +, + "d1ce21a1-6295-4729-a9f0-e39cc4aa4f40": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "BqB4yVG2NY2fmvaAGYc6otIgW32JKOaHv86vD8Zz+MNZPz0sR7PR+qsD15vKkE6SxGIwJky72PysB9KZyZBPjA==" + } + } + +, + "f4d6f056-650c-4b6f-ae51-6f44918968c2": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Ga9utTnt8SCSBV4l2sDJ6n0SLkx6ajuFI5MZU/V4LGl4QYMCuOIeYxPqpLsYaBl+1LqOCLPqF2UU7qG5G2gYYA==" + } + } + +, + "55dc70a5-e5b4-4ada-bab0-0e0f51cdd6e0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "g+E+xh8lT3kNEC5nC3wEmgaV47JEa0cxVj2XzTLZimbNNhmWAT9Enhe5T5463QOvHqYUnAo3TZgQvUqcOd0CsQ==" + } + } + +, + "db3533ad-300b-4067-a394-4b4506d7e740": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cMbGvtBs3pEcfs2wmgTfEGwzpuvN+03DVCUXRnuhjXdUhoPSqu/+6nF+7W42f7C/jzCO2KHn9+x2euhsNX+xoQ==" + } + } + +, + "7ba96858-7e5d-4d76-9151-4c24a89f141a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "S12Mc1V7Q7hPAWPk3JKrOPPWwoJNrhvVQDhQLFMPDUxtrduMRXbAosYcp9zbHK/Zp6zWhk5+yaTBGKLe2Byuxw==" + } + } + +, + "45650223-8b12-43ec-8ba4-5739d7f8e1b7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bq0ehniEAiH6yNKeyvCNGmwl6ifyJiWm/Jh3+pgSqJ+oiJ2+GASK20JCQWuOAVXeNSGQtBMMg91FRkRpjQFUwA==" + } + } + +, + "25535889-3ce4-4315-a60c-d17cade233b6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G1JIQcHRZeL5vhZOEHk3R+lnnfJKtmW0ehGKo7NNaf3p+muo6B4NSR1ev2z+3BapaUZmouMWBE8aWrpu/dwXtw==" + } + } + +, + "6e48220f-0dbb-4a70-88d5-3843d92beb22": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "03u4zIxW/dc3n+TPZ46nohJwrGUnEr8Kw4pqfc7ewJKmBrMk/AGP35zI7JT96wQZ25e+LvcJhtmbzOmW/usFBw==" + } + } + +, + "c064be77-b978-45e1-8872-12d810f51c7c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CUlnUH1Oykz+tVfAx08vx4n1KTfkGix9J7EcHO/UQ/wtRs/qdhLCgGM3QL86K0vAemvC4H0ay4ZkM0W9OStK3g==" + } + } + +, + "daa98c74-3bb6-482b-8515-35130b328a37": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "CujN9/8yzR8n7JjQ6lcWa5FbAjSqYPwnd1htDi7nstjGVQJMD5tSlz8t6FbH73b/WzoPRgSTW5E4Ke1UxO934Q==" + } + } + +, + "faf4fdad-f71e-45e1-8cd9-35ab5c83a94e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "koNoZ0F+7UP8XGmmGvzqsMxEibKLRKer8j0/HP6N3HaOJ4N7eeyn6sRCNuBC8Q9HCriOcXLkruzDRjPiQfEOWQ==" + } + } + +, + "539aed2a-be20-4837-9571-bf72cbbce7c1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "P5BRSYQQwC+e3Wr6a0iZmCDOWrwD0Oqbl2nd3CpjCkjQ6rKAPSuusYc8yGVnCQHeo6a/ijYjp7eAOM1nZAkAwA==" + } + } + +, + "5b97b7c1-2ea6-4324-8208-fc8b60421a71": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "GThxMuyHpeSFMuO2E9x6ZLJxY3bqqbSjEFPONgHRbcNIC9qbORFkJhJdzL5SbW7nPLbXkTIZbSAVWcm8UW1v+Q==" + } + } + +, + "a457cfe1-4972-48c1-9ffd-f6cd58259cb4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "RWZSt4GByw8blm0TPnNJQWx8Z5M7jahfmCuSrXcNdFu+t4kcyeuUSTNGpQsZIQy4iX2EFsLjnU80QqAJGiENpg==" + } + } + +, + "fde675ab-8ceb-461d-b917-752ad5e10683": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UYnLQHhdhWXjImgi9vj6EECVlol0EFzLojOdD5P0zml4llbHYtxaS2EntJwb31SUsQtbzWnUU01mI7GeGN9Vig==" + } + } + +, + "13f792e3-5f90-4f1a-9f2c-d9ad7546e965": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "iUaOYIKxDD3m1gnBcDqxENggOM8Ct0GZbxgzCcr8+d4SZGsTNTBegtltYyLNIveNqEpmGT44V4TeaWYgziL2kw==" + } + } + +, + "1363c336-61c3-44f2-b034-a7df4f51cac0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+8NreDMpSmce1BS0CwlWTe6Fbvh2wGhl7pY5YjfPQ3Y1cCjYYdLGKeadiQMs2UhUzpcl0mrazy/hmYwBL9lJSg==" + } + } + +, + "dacfb5cd-794e-447a-a73f-5727a4be381b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aHZaILzJqHrpeagmBOELoHIk4WkMx3Tt+vQ3IQcG48H7Y2GH24+YL6Hnm+24w7nkt8tsjdCHkSmm457vu8O4+g==" + } + } + +, + "8f57a6b7-ae39-4701-82c9-b6b93797e501": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "6sLGtM2rLi1YBtcoHVAhirDLpbl50CNCCKRmxsxLVxJS78+dGozdAsF7zt74sWEJ2ILClxGE1ATGf8vc+7FgFw==" + } + } + +, + "ed4852b2-ae49-471b-aa43-5ca40520f5fb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "p77RUg7oMOEAmQmWetO3INtX9T4UJCeqNmdILmufV6pCqTmQ7V6oIijdSRrelvw7viU0muZWoSQv2UwY3Zb9JQ==" + } + } + +, + "384ac609-7112-4c25-a1e9-8f470b2998c9": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VrDXpBoOuWJ2zoJlcmBmj3E1CXm3bOj3Xw6yMZymH0JocA0RqBmHtHaei5tNJlwdYmsAG6MRjrJxmo6ZTiZdAw==" + } + } + +, + "22542b77-5761-427f-b0c0-e04feec5f1b4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "1iA+cp1BATVWLvJQC8WbYowiGLpvQnmkiNVHy+j+fbid2fwlplsq1Xz3aIB8kLWCdPPxL61TI9N7822Cf5C0nA==" + } + } + +, + "fd978de7-ad93-4f4c-b0fc-53a0cd82aa6c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "f5M4Cljp9wYiFtLeeY0xullO97md6wc25/IeM//u4luv+xRfwV8uOlTesdGEMsG2KaoZVcpXJzxT2rTThzLAqA==" + } + } + +, + "2cb54cb5-4c3b-49f8-9fd8-5612e062a794": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "h7MAdEyFyMeQkeaST+JzXT9LLoMr1oN0sSbHh99bHv47amSZ0wnob1drT3DRMWcV0X9pk9gB4WlQb0py0jFmCw==" + } + } + +, + "6fa0219c-5b86-44a3-8906-d23b947a2bc4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bYC+gQ/FQgTshymtgqKI18BdFGqHddn1kGktLkYnL+Y9aLzwk1X9c45tEiuUdRfkkYqx+phd9HWJaRcpl3UW+g==" + } + } + +, + "413f61b6-4830-4537-aa37-4d7a9217e83e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "o/ttuaXRBEYcrqRvrO4Rx5iX076H7spBRJGLbYn8o/aUEAAdIPF1V0HPtAooYAfTb2UNFyv5fFFGy7EIK2AGzQ==" + } + } + +, + "c23d0451-e97e-4cb1-89bd-1d0f8c161b84": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "h8Kwck8yxXgGHIRiQpfMeHqaEBEgaZAx8+sEYA2XU4Fe0Ustok2D/8FqtfN6UC86uMVGJ6lFivnGbrDxeVAuJA==" + } + } + +, + "14db3036-ad5b-43b1-b0cd-63c7d275c901": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "n3f2r/oc/F5cRt/KtLRs5oRi92ixYVyq1q4c90K0Eg+jJnb2x4i4JcjAhQxhKtsq5TZ7/MyAsSPPxIAOYiraNA==" + } + } + +, + "495b74a6-84d7-4704-9f2d-d4d02e3b2deb": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "VUDL46a2gYXIzruEzCwoILc8eA4rx0oGDB0rEyR0vj504Pj5RD0RYA474ZH+/lwAkhj18081GGYJP+ST/f5dHg==" + } + } + +, + "09111522-0191-49c1-baee-9e7452ade6d6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "R7x6DtdfjxMKn7umK1YP6Ih1tmRfXG7Ea7r9/897ELESJQzZTbVgRxHtDIBif3StsvMB00a9aUEW6QmCYX91sw==" + } + } + +, + "04e31e23-bf5b-488d-98ea-0916ea054a57": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vTpRyVKVxIlBH+SVp/+dGaLnicvNd3OnlzEbYoPv1Y++pZCSjStzPHeAOmOexYut5IidmIYjejpwhD9hncWKsw==" + } + } + +, + "db4e4f3e-af56-4e80-915e-2833e1720152": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "qNJ6UWDZtHbuLU8XJ63XoZx0732T6dXl27+uRiEaUCbKKfW28dBao9fWUxxgNNInpzz4vPrYU6XQ0lYeYzTTOQ==" + } + } + +, + "4c27df40-e586-4454-96fd-bbd38d9c254d": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "3R9meuHw44Q4I7gPKLb9yj/KiixEw50lPXL0Ccad28idMKbspSBcP9msU5G6NW1B7Zir5q4oVTneqFaTuTVsXw==" + } + } + +, + "4bc30fc8-6515-4da4-b9ec-d3659e26977e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "5cN2IR5Ml/JXaD6GXjdOhWaZj86JypxJgD2Dx82DOd0NfGmgS8tdplA+iOk2qvIVWjRkqkDDVKBXOo3rNarzCw==" + } + } + +, + "30857906-6323-484f-a42e-2a9383a878a5": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "0DQEb9ILeloWef9d4Blr6fmxTBwrW6jkDfBXsrCAHV02UEkMuGFKlq9v6aMZK9EFR11EBrNpQ5Coa+yhGivQGw==" + } + } + +, + "a483d63f-115b-4e15-a8a4-9d6f69c30534": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "HyGdkwKolhIEXPXWdjJ8mWUL1Rlwuvfx8DJss5NM2cNqWLDOF+e0pU5iBF9NgoRGWom9xBzvvaNJZgFdToKFWA==" + } + } + +, + "9c7f225f-0fa8-45aa-8fba-995cc0880827": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vqwFkwWUqcrca9kLD4GfMQ8Kdi1E3FV5Ar2p9+XrN9FE7R/UUjtcyOFVKDZJrZHa6+wS3lkzVc7mUS00Sq2QxA==" + } + } + +, + "3c531189-5fa2-46fd-a913-c5da0bd26e5b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "XUNMJYgLjnoUh+RaP7fFjslFehaIteonz5eMQFXeU0BQ48MWYAlOsN1q/0QpxdsNrbnOHGsBR7babvpGKsXaEw==" + } + } + +, + "8fcf110e-7b2f-4bef-bdca-cb3e4e852309": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "gQHsqB57y8oIWZvnO1IXhtV70YGLTgihQ/l338iqqw0eO+oRuOBupNwr9ePqdy+lxFTnG7PoZ6LbL/Dh6Xcuuw==" + } + } + +, + "8369fe41-f1c8-45ac-9823-2eb4d6644e0b": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "KF/IEz9b9JC0H7WmymmXZ6qADb0+wmFvZsB87y4rwqMvmnkcvTJhjgm0WVeFJDJk3gV0FrY6aIgOsFxVhiQzeg==" + } + } + +, + "aac997d9-c874-41ff-b9cb-70c3c966b1d4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Tq2DLoykYhAPmjf8Y+G8ADsFvtanTCJHq9bV0iKDM86RwdEvT3m3MYoxQwi6Zm8/CJTcJURxvjeNNUYKuWZuIQ==" + } + } + +, + "571a4cec-707c-49ec-96ad-d1035d212087": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cd6JdgsmhX4QyBWhRmEFbvnfDLwuoCmgtwTDHtsGVEAnt5Yj/w1pszvu05Djlp33BwebKfQFYLU86taS4Jac6Q==" + } + } + +, + "af25e252-7418-4fa1-a9f4-acde2d55c989": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "yHYApE1BDfVL6EgbDLjXK1mA+godz5Ho1eeCLEGpocxGdlWluJGilib6X8tTL3teKA5Yr7OZq5Ah/lrJUC96QA==" + } + } + +, + "4cb90117-6313-4deb-9ac5-19f81f0fa0d7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "hYVhDlhDSfGOZrdm/cfQs5+pwgsX6KVssfh3sIHXL59i8PoGk/fxIwyJd8/TL5Gymh73DJj/+CULjXLN0C+QrA==" + } + } + +, + "4a7da8a2-3ed9-4c69-bbc0-84c12d8dda26": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uOBBTKX9bc9P729W0L6FnlD9JN4gDCPAP5xVN9TrvjJCo+u7J5lNo87BJIxiRxI+vazmsSyRRKXJxSGOYUcTIA==" + } + } + +, + "dc4e9268-1faf-4e59-9bd0-632f98fc54b1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "/ryLcAF/i4K0Q908nNTVn5ORHINBk3BVcAWfZY04WD0C8X8DpeO0tiUWTzq6zfHCC39yCa7rvbAiEko4uc3w3A==" + } + } + +, + "02b0b683-f7c8-47c6-9d4c-b368ad41c6ac": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "Dh5oC6q/jnBkFSi/pqoD7v+zOm/QZVLGtBkkaBe2yf4FQ+F68esNu4FxJhDK8gjqpnfscPrjBL2GdSMSyfIJ9A==" + } + } + +, + "4acf39d6-d489-45c7-bfcd-6d2e15a634dd": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "c1BvpQp0fAz4FFC7NCEja9iP4oDJb5ihj8ZfG8NZkMNpMfs1cX/6jKv8fRi6ua2SlRX2P3p384qs+HgaubmsjA==" + } + } + +, + "99ed3f0a-2e2f-4779-8afa-cd85b9c4fd0e": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aTlxJX03/IMHzxK4ox6l7Vx9Y8sFYb63JC0JulVWxaePM/1+zGz47sIBI4gjLz7+qgvwdMdk8ejFBSaKIC8/4A==" + } + } + +, + "073e7165-34c5-4378-b782-571f8f1a68e3": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "vpRYbgOlxfsXgI5E14rtbHOGmA1am/gNNPuJcEI7qHXyeVegrfZeRXKDpPVbZfZEFJpaqqb+V0N1h6H3WGX3Wg==" + } + } + +, + "de43e72c-2c95-43e6-8c2e-357ca7538390": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "bUqEnu51k6UorPZh3coyIpFotnyqQ0NMVJblugfhUYXOsKexkxTkohMDywuHVusDjsiqu5gc7aQUB84JhFbqHQ==" + } + } + +, + "a0d4e7f3-eb77-4a0d-9a20-b2415038b0c7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "aTDl1UOaGhyfAM/oMIUXOlEsZdQ91ByWbNMZ7DMbx1poVBMWBmkRdAEC8W6W6UkvtY4eHA1hGHIGBvRslelIMQ==" + } + } + +, + "691e973a-3598-45f4-93b1-74348a423bd4": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "dsBQl0VypyGciDcGbFZEsSO9xWarGMwHTlXk+0qgWYQ61Jo931Dy3aLUAWjhq8BUtYOXN9RY+9ul0ARq4qvBSg==" + } + } + +, + "5cbb74c3-b71e-4482-9324-d3ec31944ae1": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cnWbIbq2LFSyEuVA7CvtaNdEvOGbJtyuArna4Co+d0mSsAWfKPhOk+yEFLsa4bbdSjUIlSPwR5XrgBG5GeG3ww==" + } + } + +, + "5ba9b9a7-b347-4942-8c77-0697328cb6a0": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "q1Aqo8bOgalL5OUeLMOlUFBm1XO9wr+V9uBSS4XZ2aY6SBt3kS1diUGjewx5zYOjqhIWfZolVI9Gp34Oes2CvQ==" + } + } + +, + "6c42e851-cb6f-4c1d-8c17-9bdc8e0e6de7": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "UTmqk0zLVPAXxObZ3mtdE8c0bmys8uC/F9tbOCec474T3Yo2WbWrVBakp4awM3F+Vv+HPFK9olIRoKKEszNwYA==" + } + } + +, + "5c18d55f-a0fd-46a5-a1ac-93a810646e32": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "v8ADatzqlIjOhap07uLTuntszynDas18n19UEI4GyDTqdjjkgJNlvjKuk98yqHIyQtA17oubbLg1qpbdMahzLA==" + } + } + +, + "6b1b291e-8def-4c0f-83e0-6291d4ab240c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "G/CjHOiAwXTQ3xcS6Db/X7Xqw84UGA26YEcmGfRCWUVcBXe9hwi7ppwcOQeVBlcOJNJ6t4wAsqCbGDwFlgZWEA==" + } + } + +, + "364012fc-464f-438e-ba9f-e63c203887f6": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "uqMG21goTh4x+ZDjcPOKwkbiTUIGSNtLLr9Gr36jFCwS7wwRJGoYNYBg2VNCyyDHEDkBGy9iETOHZNxRQcsh2Q==" + } + } + +, + "f0656f9e-f46a-4839-a370-f62229cfb725": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "cIM41ydOUh6wTFj8wuCFP21NbrtApWsrbpnZYIcLF0jpzkC6/TruFNsPGawOavVvqYZNsPYy5xLcCxyuDWr0cQ==" + } + } + +, + "0c465f36-3609-49ed-97a0-f3f466074014": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+4M26CAsDZSQGPgauO26O9hRmL8swl4YNW6kqfifk6bHsAb3ti8NpIduNp0ql9FWFBwL/b0nBKKAajOfKZfQSA==" + } + } + +, + "f487be27-8e21-4c99-a0e8-24ccbf91df0c": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "r1Vg5MBZTWUlTSmBZbsZiNxnDA9p9ikQs1ZOeW/JsLetmmVTYjaxcvMU+GPUTnS6k8xoWWk+uHT0EP1h1051pA==" + } + } + +, + "2d8899bf-6130-4211-8df6-331d6d102c76": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "+6/kIzx1obQkV1F0ZeCeif4wxrYER3KUepAbgbakQ69SrXWZaSVrzdMpdNSiy9WRsdV4k2ItYsvULXHWocvUjw==" + } + } + +, + "a321a245-030a-481d-b348-3cc27aecc4a8": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "EMQYQ3iCqrqlYlukmHOuLdBzf9NxziuNRsLjpC494kJMllEtotoFr4Zn7t4pWviK4xRcJ6nSDKmBY+vcKlr5lA==" + } + } + +, + "b378f388-943e-440d-81f5-e15f76f4e68a": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "QFXeShopbJ7B+GS3dv4XJ9tYjJCnJNOl1etTxY9dG/Lhuozib7f27uQBsSCQxCPUEJyB6GS//+jjBbQik8Qiyg==" + } + } + +, + "16d21da6-76af-42bf-a395-4699f8c3fd4f": + { + "action": "padding_oracle", + "arguments": { + "hostname": "localhost", + "port": 1337, + "iv": "AAAAAAAAAAAAAAAAAAAAAA==", + "ciphertext": "WMoU8g20SWQ8N1wBAq9gfa0EhfUnPTS34bY783m/2NFvXHiikuIUx//qRepcHOmdzSF1qJnqHcH47kDoXxzogw==" + } + } + +} +} From 811e2b21f65169d70f360d94b644cfabb7ff99f0 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Fri, 8 Nov 2024 13:09:12 +0100 Subject: [PATCH 029/105] feat: Implement field object and addition Starting work on proper field object Polynomial addition working --- src/utils/field.rs | 70 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 67 insertions(+), 3 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 5645b04..37ceb74 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,7 +1,59 @@ -use anyhow::{anyhow, Ok, Result}; -use base64::Engine; +use std::ops::{Add, Mul}; -use super::poly::gfmul; +use anyhow::{anyhow, Ok, Result}; +use base64::prelude::*; + +use super::{math::xor_bytes, poly::gfmul}; + +#[derive(Debug)] +pub struct FieldElement { + polynomial: Vec, +} + +impl FieldElement { + pub const IRREDUCIBLE_POLYNOMIAL: [u8; 17] = [ + 87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01, + ]; + + pub const fn new(polynomial: Vec) -> Self { + Self { polynomial } + } + + pub fn mul(&self, poly_a: Vec, poly_b: Vec) -> Result> { + gfmul(poly_a, poly_b, "gcm") + } +} + +impl Mul for FieldElement { + type Output = Self; + + fn mul(self, rhs: Self) -> Self::Output { + FieldElement::new( + gfmul(self.polynomial, rhs.polynomial, "gcm").expect("Error during multiplication"), + ) + } +} + +impl Add for FieldElement { + type Output = Self; + fn add(self, rhs: Self) -> Self::Output { + FieldElement::new(xor_bytes(&self.polynomial, rhs.polynomial).expect("Error in poly add")) + } +} + +impl AsRef<[u8]> for FieldElement { + fn as_ref(&self) -> &[u8] { + &self.polynomial.as_ref() + } +} + +/* +impl From> for FieldElement { + fn from(item: Vec) -> Self { + FieldElement { bytes: item } + } +} +*/ #[derive(Debug)] pub struct ByteArray(pub Vec); @@ -105,6 +157,7 @@ impl ByteArray { #[cfg(test)] mod tests { use super::*; + use base64::prelude::*; use std::fs; #[test] @@ -199,4 +252,15 @@ 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!(BASE64_STANDARD.encode(sum), "H1d3GuyA9/0OxeYouUpAAA=="); + } } From 6e33e2e44c0b3f5592409c633de4a0fd793d2342 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Sun, 10 Nov 2024 18:30:41 +0100 Subject: [PATCH 030/105] feat: Initial multiplication working --- src/utils/field.rs | 186 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 179 insertions(+), 7 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 37ceb74..f0da8f0 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,13 +1,104 @@ -use std::ops::{Add, Mul}; +use std::{ + env::args, + ops::{Add, Mul}, +}; use anyhow::{anyhow, Ok, Result}; use base64::prelude::*; +use serde_json::Value; use super::{math::xor_bytes, poly::gfmul}; +#[derive(Debug)] +pub struct Polynomial { + polynomial: Vec, +} + +impl Polynomial { + pub const fn new(polynomial: Vec) -> Self { + Self { polynomial } + } + + 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(); + + eprintln!("{:?}", c_array); + + 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(BASE64_STANDARD.encode(coeff)); + } + + output + } +} + +impl Mul for Polynomial { + type Output = Self; + + fn mul(self, rhs: Self) -> Self::Output { + let mut polynomial: Vec = + vec![FieldElement::new(vec![0; 16]); 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 { + FieldElement::new( + xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"), + ) + } +} + +/* +impl Add for Polynomial { + type Output = Self; + fn add(self, rhs: Self) -> Self::Output { + FieldElement::new( + xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"), + ) + } +} + +impl AsRef<[u8]> for Polynomial { + fn as_ref(&self) -> &[u8] { + &self.field_element.as_ref() + } +} +*/ + #[derive(Debug)] pub struct FieldElement { - polynomial: Vec, + field_element: Vec, } impl FieldElement { @@ -15,8 +106,8 @@ impl FieldElement { 87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01, ]; - pub const fn new(polynomial: Vec) -> Self { - Self { polynomial } + pub const fn new(field_element: Vec) -> Self { + Self { field_element } } pub fn mul(&self, poly_a: Vec, poly_b: Vec) -> Result> { @@ -29,7 +120,19 @@ impl Mul for FieldElement { fn mul(self, rhs: Self) -> Self::Output { FieldElement::new( - gfmul(self.polynomial, rhs.polynomial, "gcm").expect("Error during multiplication"), + gfmul(self.field_element, rhs.field_element, "gcm") + .expect("Error during multiplication"), + ) + } +} + +impl Mul for &FieldElement { + type Output = FieldElement; + + fn mul(self, rhs: &FieldElement) -> FieldElement { + FieldElement::new( + gfmul(self.field_element.clone(), rhs.field_element.clone(), "gcm") + .expect("Error during multiplication"), ) } } @@ -37,13 +140,32 @@ impl Mul for FieldElement { impl Add for FieldElement { type Output = Self; fn add(self, rhs: Self) -> Self::Output { - FieldElement::new(xor_bytes(&self.polynomial, rhs.polynomial).expect("Error in poly add")) + FieldElement::new( + 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( + 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.polynomial.as_ref() + &self.field_element.as_ref() + } +} + +impl Clone for FieldElement { + fn clone(&self) -> Self { + FieldElement { + field_element: self.field_element.clone(), + } } } @@ -158,6 +280,7 @@ impl ByteArray { mod tests { use super::*; use base64::prelude::*; + use serde_json::json; use std::fs; #[test] @@ -263,4 +386,53 @@ mod tests { assert_eq!(BASE64_STANDARD.encode(sum), "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!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA=="); + } + + #[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!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA=="); + } + + #[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; + + eprintln!("Result = {:?}", result.to_c_array()); + + assert!(false); + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } } From 6431a6636ed777e190355b36d81d850946b98244 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Mon, 11 Nov 2024 10:31:59 +0100 Subject: [PATCH 031/105] feat: start working on add for polynomial --- src/utils/field.rs | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index f0da8f0..63e2230 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,6 +1,6 @@ use std::{ env::args, - ops::{Add, Mul}, + ops::{Add, BitXor, Mul}, }; use anyhow::{anyhow, Ok, Result}; @@ -73,9 +73,13 @@ impl Mul for Polynomial { impl Add for Polynomial { type Output = Self; fn add(self, rhs: Self) -> Self::Output { - FieldElement::new( - xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"), - ) + 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) } } @@ -169,6 +173,14 @@ impl Clone for FieldElement { } } +/* +impl BitXor for FieldElement { + fn bitxor(self, rhs: Self) -> Self::Output { + FieldElement + } +} +*/ + /* impl From> for FieldElement { fn from(item: Vec) -> Self { From 11916e29f0bbd361d39d7e4c18a8e68325f7c9f7 Mon Sep 17 00:00:00 2001 From: alivecow Date: Tue, 12 Nov 2024 18:58:20 +0100 Subject: [PATCH 032/105] feat: initial pow support working --- src/tasks/tasks01/gfmul.rs | 20 ------ src/utils/field.rs | 141 +++++++++++++++++++++++++++++++++++-- 2 files changed, 135 insertions(+), 26 deletions(-) diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 01731f6..c4acefe 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -108,24 +108,4 @@ mod tests { ); 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==", - "Failure. Calulated result was: {}", - result - ); - Ok(()) - } } diff --git a/src/utils/field.rs b/src/utils/field.rs index 63e2230..25088cf 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -52,6 +52,42 @@ impl Polynomial { output } + + pub fn pow(&self, mut exponent: u128) -> Polynomial { + if exponent == 0 { + // Return polynomial with coefficient 1 + return Polynomial::new(vec![FieldElement::new(vec![1])]); + } + + let base = self.clone(); + let mut result = base.clone(); + exponent -= 1; // Subtract 1 because we already set result to base + + while exponent > 0 { + result = result * base.clone(); + exponent -= 1; + } + + result + } + /* + pub fn to_b64(&self) -> String { + let mut output: Vec = vec![]; + for coeff in self.polynomial { + output.push(BASE64_STANDARD.encode(coeff)); + } + + output + } + */ +} + +impl Clone for Polynomial { + fn clone(&self) -> Self { + Polynomial { + polynomial: self.polynomial.clone(), + } + } } impl Mul for Polynomial { @@ -70,9 +106,11 @@ impl Mul for Polynomial { } } -impl Add for Polynomial { - type Output = Self; - fn add(self, rhs: Self) -> Self::Output { +impl Mul for &Polynomial { + type Output = Polynomial; + fn mul(self, rhs: Self) -> Self::Output { + let mut polynomial: Vec = + vec![FieldElement::new(vec![0; 16]); 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] @@ -83,6 +121,40 @@ impl Add for 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(); + } + } + + Polynomial::new(polynomial) + } +} + +impl AsRef<[FieldElement]> for Polynomial { + fn as_ref(&self) -> &[FieldElement] { + &self.polynomial + } +} + +/* +impl AsRef<[u8]> for Polynomial { + fn as_ref(&self) -> &[u8] { + &self.polynomial + } +} +*/ /* impl Add for Polynomial { type Output = Self; @@ -117,6 +189,10 @@ impl FieldElement { 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(&self.field_element) + } } impl Mul for FieldElement { @@ -173,6 +249,19 @@ impl Clone for FieldElement { } } +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(result) + } +} + /* impl BitXor for FieldElement { fn bitxor(self, rhs: Self) -> Self::Output { @@ -424,7 +513,15 @@ mod tests { let sum = element2 + element1; - assert_eq!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA=="); + assert_eq!( + sum.to_c_array(), + vec![ + "H1d3GuyA9/0OxeYouUpAAA==", + "OZuIncPAGEp4tYouDownAA==", + "NeverGonnaRunAroundAAA==", + "AndDesertYouAAAAAAAAAA==" + ] + ); } #[test] @@ -442,9 +539,41 @@ mod tests { let result = element1 * element2; - eprintln!("Result = {:?}", result.to_c_array()); + assert_eq!( + result.to_c_array(), + vec![ + "MoAAAAAAAAAAAAAAAAAAAA==", + "sUgAAAAAAAAAAAAAAAAAAA==", + "MbQAAAAAAAAAAAAAAAAAAA==", + "AAhAAAAAAAAAAAAAAAAAAA==" + ] + ); + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } - assert!(false); + #[test] + fn test_field_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=="); } } From a05f2f02b678c21968ecf94675ac5a73dfe27ef6 Mon Sep 17 00:00:00 2001 From: alivecow Date: Wed, 13 Nov 2024 20:27:20 +0100 Subject: [PATCH 033/105] feat/refactor: Change gfmul to take references and add field div --- src/tasks/tasks01/gfmul.rs | 10 +-- src/utils/ciphers.rs | 8 +-- src/utils/field.rs | 138 +++++++++++++++++++++++++++++-------- src/utils/poly.rs | 6 +- 4 files changed, 120 insertions(+), 42 deletions(-) diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index c4acefe..2c1d6b8 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -16,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) } @@ -39,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==", @@ -59,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==", @@ -79,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==", @@ -99,7 +99,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==", diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 917a1c7..333ec13 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -340,25 +340,25 @@ pub fn ghash( eprintln!("Ad chunks before first next {:001X?}", ad_chunks); let inter1 = xor_bytes(&output, ad_chunks.next().unwrap().to_vec())?; - let mut inter_loop = gfmul(inter1, auth_key_h.clone(), "gcm")?; + let mut inter_loop = gfmul(&inter1, &auth_key_h, "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.clone(), "gcm")?; + inter_loop = gfmul(&inter2, &auth_key_h, "gcm")?; } let cipher_chunks = ciphertext.chunks(16); for chunk in cipher_chunks { let inter3 = xor_bytes(&inter_loop, chunk.to_vec())?; - inter_loop = gfmul(inter3, auth_key_h.clone(), "gcm")?; + inter_loop = gfmul(&inter3, &auth_key_h, "gcm")?; } let inter4 = xor_bytes(&inter_loop, l_field)?; - inter_loop = gfmul(inter4, auth_key_h.clone(), "gcm")?; + inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?; eprintln!("GHASH auth tag: {:001X?}", inter_loop); diff --git a/src/utils/field.rs b/src/utils/field.rs index 25088cf..c8de249 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,12 +1,15 @@ use std::{ env::args, - ops::{Add, BitXor, Mul}, + ops::{Add, BitXor, Div, Mul, Rem, Sub}, + result, }; use anyhow::{anyhow, Ok, Result}; use base64::prelude::*; use serde_json::Value; +use crate::{tasks::tasks01::poly2block::poly2block, utils::poly::polynomial_2_block}; + use super::{math::xor_bytes, poly::gfmul}; #[derive(Debug)] @@ -142,36 +145,32 @@ impl Add for Polynomial { } } +// Helper implementation for subtraction +impl Sub for &FieldElement { + type Output = FieldElement; + + fn sub(self, rhs: Self) -> FieldElement { + // In a field of characteristic 2, addition and subtraction are the same operation (XOR) + self + rhs + } +} + +// Helper trait for checking emptiness +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 AsRef<[u8]> for Polynomial { - fn as_ref(&self) -> &[u8] { - &self.polynomial - } -} -*/ -/* -impl Add for Polynomial { - type Output = Self; - fn add(self, rhs: Self) -> Self::Output { - FieldElement::new( - xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"), - ) - } -} - -impl AsRef<[u8]> for Polynomial { - fn as_ref(&self) -> &[u8] { - &self.field_element.as_ref() - } -} -*/ - #[derive(Debug)] pub struct FieldElement { field_element: Vec, @@ -187,12 +186,48 @@ impl FieldElement { } pub fn mul(&self, poly_a: Vec, poly_b: Vec) -> Result> { - gfmul(poly_a, poly_b, "gcm") + gfmul(&poly_a, &poly_b, "gcm") } pub fn to_b64(&self) -> String { BASE64_STANDARD.encode(&self.field_element) } + + pub fn pow(&self, mut exponent: u128) -> FieldElement { + if exponent == 0 { + // Return polynomial with coefficient 1 + return FieldElement::new(vec![1]); + } + + let base = self.clone(); + let mut result = base.clone(); + exponent -= 1; // Subtract 1 because we already set result to base + + while exponent > 0 { + result = result * base.clone(); + exponent -= 1; + } + + result + } + + pub fn inv(mut self) -> Self { + let mut inverser: u128 = 0xfffffffffffffffffffffffffffffffe; + let mut inverse: Vec = polynomial_2_block(vec![0], "gcm").unwrap(); + eprintln!("Inverse start {:02X?}", inverse); + + while inverser > 0 { + //eprintln!("{:02X}", inverser); + if inverser & 1 == 1 { + inverse = gfmul(&self.field_element, &inverse, "gcm").unwrap(); + } + inverser >>= 1; + self.field_element = gfmul(&self.field_element, &self.field_element, "gcm") + .expect("Error in sqrmul sqr"); + } + eprintln!("Inverse rhs {:?}", inverse); + FieldElement::new(inverse) + } } impl Mul for FieldElement { @@ -200,7 +235,7 @@ impl Mul for FieldElement { fn mul(self, rhs: Self) -> Self::Output { FieldElement::new( - gfmul(self.field_element, rhs.field_element, "gcm") + gfmul(&self.field_element, &rhs.field_element, "gcm") .expect("Error during multiplication"), ) } @@ -211,7 +246,7 @@ impl Mul for &FieldElement { fn mul(self, rhs: &FieldElement) -> FieldElement { FieldElement::new( - gfmul(self.field_element.clone(), rhs.field_element.clone(), "gcm") + gfmul(&self.field_element, &rhs.field_element, "gcm") .expect("Error during multiplication"), ) } @@ -262,6 +297,36 @@ impl BitXor for FieldElement { } } +impl Div for FieldElement { + type Output = Self; + fn div(self, rhs: Self) -> Self::Output { + eprintln!("RHS in div{:02X?}", &rhs); + + let inverse = rhs.inv(); + eprintln!("Inverse in div{:02X?}", inverse); + self.clone() * inverse + } +} + +impl Div for &FieldElement { + type Output = FieldElement; + + fn div(self, rhs: Self) -> Self::Output { + // First clone and invert the divisor (rhs) + let rhs_inv = rhs.clone().inv(); + // Multiply original number by the inverse + self.clone() * rhs_inv + } +} +/* +//TODO: Not yet ready + impl Rem for FieldElement { + fn rem(self, rhs: Self) -> Self::Output { + + } +} +*/ + /* impl BitXor for FieldElement { fn bitxor(self, rhs: Self) -> Self::Output { @@ -312,13 +377,13 @@ impl ByteArray { let alpha_poly: Vec = base64::prelude::BASE64_STANDARD .decode("AgAAAAAAAAAAAAAAAAAAAA==") .expect("Decode failed"); - self.0 = gfmul(self.0.clone(), alpha_poly, "xex").unwrap(); + self.0 = gfmul(&self.0, &alpha_poly, "xex").unwrap(); } "gcm" => { let alpha_poly: Vec = base64::prelude::BASE64_STANDARD .decode("AgAAAAAAAAAAAAAAAAAAAA==") .expect("Decode failed"); - self.0 = gfmul(self.0.clone(), alpha_poly, "gcm").unwrap(); + self.0 = gfmul(&self.0, &alpha_poly, "gcm").unwrap(); } _ => {} } @@ -576,4 +641,17 @@ mod tests { ); //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } + + #[test] + fn test_poly_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!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); + } } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 78889c8..6425577 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -7,14 +7,14 @@ use std::{str::FromStr, u128, u8, usize}; 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> { +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); + let mut poly1: ByteArray = ByteArray(poly_a.to_owned()); poly1.0.push(0x00); - let mut poly2: ByteArray = ByteArray(poly_b); + let mut poly2: ByteArray = ByteArray(poly_b.to_owned()); poly2.0.push(0x00); if semantic == "gcm" { From deb426112106e13bd5f2d3fc1e684d4438d2490c Mon Sep 17 00:00:00 2001 From: alivecow Date: Thu, 14 Nov 2024 22:30:55 +0100 Subject: [PATCH 034/105] feat: add division and powmod (WIP) and start adapting task runner --- src/tasks/mod.rs | 7 ++ src/tasks/tasks01/mod.rs | 1 + src/tasks/tasks01/pfmath.rs | 15 +++ src/utils/field.rs | 176 ++++++++++++++++++++++++++++++++---- 4 files changed, 183 insertions(+), 16 deletions(-) create mode 100644 src/tasks/tasks01/pfmath.rs diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 0fa72d6..f7475be 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -11,6 +11,7 @@ use tasks01::{ gcm::{gcm_decrypt, gcm_encrypt}, gfmul::gfmul_task, pad_oracle::padding_oracle, + pfmath::gfpoly_add, poly2block::poly2block, sea128::sea128, xex::{self, fde_xex}, @@ -83,6 +84,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_add" => { + let result = gfpoly_add(args)?; + let json = json!({"plaintext" : result.to_c_array()}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, diff --git a/src/tasks/tasks01/mod.rs b/src/tasks/tasks01/mod.rs index 479fe47..8200de5 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -2,6 +2,7 @@ pub mod block2poly; pub mod gcm; 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/pfmath.rs b/src/tasks/tasks01/pfmath.rs new file mode 100644 index 0000000..b0c978e --- /dev/null +++ b/src/tasks/tasks01/pfmath.rs @@ -0,0 +1,15 @@ +use anyhow::Result; +use base64::{prelude::BASE64_STANDARD, Engine}; +use serde_json::Value; + +use crate::utils::field::Polynomial; + +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) +} diff --git a/src/utils/field.rs b/src/utils/field.rs index c8de249..59ffc18 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -58,14 +58,12 @@ impl Polynomial { pub fn pow(&self, mut exponent: u128) -> Polynomial { if exponent == 0 { - // Return polynomial with coefficient 1 - return Polynomial::new(vec![FieldElement::new(vec![1])]); + return Polynomial::new(vec![FieldElement::new(vec![0])]); } let base = self.clone(); let mut result = base.clone(); - exponent -= 1; // Subtract 1 because we already set result to base - + exponent -= 1; while exponent > 0 { result = result * base.clone(); exponent -= 1; @@ -73,16 +71,90 @@ impl Polynomial { result } - /* - pub fn to_b64(&self) -> String { - let mut output: Vec = vec![]; - for coeff in self.polynomial { - output.push(BASE64_STANDARD.encode(coeff)); + + 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(), + )]); + + eprintln!("Initial result: {:?}", result); + while exponent > 0 { + eprintln!("Current exponent: {:02X}", exponent); + if exponent & 1 == 1 { + let temp = &self * &result; + eprintln!("After multiplication: {:?}", temp); + result = temp.div(&modulus).1; + eprintln!("After mod: {:?}", result); + } + let temp_square = &self * &self; + eprintln!("After squaring: {:?}", temp_square); + self = temp_square.div(&modulus).1; + eprintln!("After mod: {:?}", self); + exponent >>= 1; + } + result + } + + // Returns (quotient, remainder) + pub fn div(self, rhs: &Self) -> (Self, Self) { + // Div by zero check ommitted since data is guaranteed to be non 0 + + 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::new( + polynomial_2_block(vec![0; 16], "gcm").unwrap(), + )]), + remainder, + ); } - output + let mut quotient_coeffs = + vec![ + FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); + 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 subtrahend = + vec![FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); deg_diff]; + subtrahend.extend( + divisor + .polynomial + .iter() + .map(|x| x.clone() * quot_coeff.clone()), + ); + let subtrahend_poly = Polynomial::new(subtrahend); + + remainder = remainder + subtrahend_poly; + + while !remainder.polynomial.is_empty() + && remainder + .polynomial + .last() + .unwrap() + .as_ref() + .iter() + .all(|&x| x == 0) + { + remainder.polynomial.pop(); + } + } + + (Polynomial::new(quotient_coeffs), remainder) } - */ } impl Clone for Polynomial { @@ -318,15 +390,20 @@ impl Div for &FieldElement { self.clone() * rhs_inv } } -/* -//TODO: Not yet ready - impl Rem for FieldElement { - fn rem(self, rhs: Self) -> Self::Output { +/* +impl Rem for FieldElement { + type Output = Self; + fn rem(self, rhs: Self) -> Self::Output { + let result: FieldElement = self.field_element; + + while self.field_element[15] != 0x00 { + self.field_element + } + todo!(); } } */ - /* impl BitXor for FieldElement { fn bitxor(self, rhs: Self) -> Self::Output { @@ -642,6 +719,32 @@ mod tests { //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_poly_div_01() { let element1 = @@ -654,4 +757,45 @@ mod tests { assert_eq!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); } + + #[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_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!["XrEhmKuat+Glt5zZWtMo6g=="]); + } } From 68d9f13a3dd05dbf96c898a19f4a165ffdae1073 Mon Sep 17 00:00:00 2001 From: alivecow Date: Thu, 14 Nov 2024 23:08:20 +0100 Subject: [PATCH 035/105] feat: finialise test runner and add testing json --- src/tasks/mod.rs | 54 +++++++++++++++++++- src/tasks/tasks01/pfmath.rs | 56 ++++++++++++++++++++- src/utils/field.rs | 16 +++--- test_json/pfmath_tests.json | 98 +++++++++++++++++++++++++++++++++++++ 4 files changed, 213 insertions(+), 11 deletions(-) create mode 100644 test_json/pfmath_tests.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index f7475be..b024471 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -11,7 +11,7 @@ use tasks01::{ gcm::{gcm_decrypt, gcm_encrypt}, gfmul::gfmul_task, pad_oracle::padding_oracle, - pfmath::gfpoly_add, + pfmath::{gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_mul, gfpoly_pow, gfpoly_powmod}, poly2block::poly2block, sea128::sea128, xex::{self, fde_xex}, @@ -86,10 +86,42 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } "gfpoly_add" => { let result = gfpoly_add(args)?; - let json = json!({"plaintext" : result.to_c_array()}); + 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 = BASE64_STANDARD.encode(result); + 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) + } + _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", testcase, @@ -279,4 +311,22 @@ mod tests { 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_distrubute(&parsed)?).unwrap(), + serde_json::to_value(expected).unwrap() + ); + + Ok(()) + } } diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index b0c978e..4ad3ac7 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -2,7 +2,7 @@ use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::utils::field::Polynomial; +use crate::utils::field::{FieldElement, Polynomial}; pub fn gfpoly_add(args: &Value) -> Result { let poly_a = Polynomial::from_c_array(&args["A"].clone()); @@ -13,3 +13,57 @@ pub fn gfpoly_add(args: &Value) -> Result { 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) +} diff --git a/src/utils/field.rs b/src/utils/field.rs index 59ffc18..fac51f2 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -77,19 +77,19 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Initial result: {:?}", result); + //eprintln!("Initial result: {:?}", result); while exponent > 0 { - eprintln!("Current exponent: {:02X}", exponent); + //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - eprintln!("After multiplication: {:?}", temp); + //eprintln!("After multiplication: {:?}", temp); result = temp.div(&modulus).1; - eprintln!("After mod: {:?}", result); + //eprintln!("After mod: {:?}", result); } let temp_square = &self * &self; - eprintln!("After squaring: {:?}", temp_square); + //eprintln!("After squaring: {:?}", temp_square); self = temp_square.div(&modulus).1; - eprintln!("After mod: {:?}", self); + //eprintln!("After mod: {:?}", self); exponent >>= 1; } result @@ -286,7 +286,7 @@ impl FieldElement { pub fn inv(mut self) -> Self { let mut inverser: u128 = 0xfffffffffffffffffffffffffffffffe; let mut inverse: Vec = polynomial_2_block(vec![0], "gcm").unwrap(); - eprintln!("Inverse start {:02X?}", inverse); + //eprintln!("Inverse start {:02X?}", inverse); while inverser > 0 { //eprintln!("{:02X}", inverser); @@ -297,7 +297,7 @@ impl FieldElement { self.field_element = gfmul(&self.field_element, &self.field_element, "gcm") .expect("Error in sqrmul sqr"); } - eprintln!("Inverse rhs {:?}", inverse); + //eprintln!("Inverse rhs {:?}", inverse); FieldElement::new(inverse) } } diff --git a/test_json/pfmath_tests.json b/test_json/pfmath_tests.json new file mode 100644 index 0000000..b9cc6e0 --- /dev/null +++ b/test_json/pfmath_tests.json @@ -0,0 +1,98 @@ +{ + "testcases": { + "gfpoly_add": { + "action": "gfpoly_add", + "arguments": { + "A": [ + "NeverGonnaGiveYouUpAAA==", + "NeverGonnaLetYouDownAA==", + "NeverGonnaRunAroundAAA==", + "AndDesertYouAAAAAAAAAA==" + ], + "B": [ + "KryptoanalyseAAAAAAAAA==", + "DHBWMannheimAAAAAAAAAA==" + ] + } + }, + "gfpoly_mul": { + "action": "gfpoly_mul", + "arguments": { + "A": [ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "B": [ + "0AAAAAAAAAAAAAAAAAAAAA==", + "IQAAAAAAAAAAAAAAAAAAAA==" + ] + } + }, + "gfpoly_mul_10": { + "action": "gfpoly_mul", + "arguments": { + "A": [ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "B": [ + "AAAAAAAAAAAAAAAAAAAAAA==" + ] + } + }, + "gfpoly_mul_01": { + "action": "gfpoly_mul", + "arguments": { + "A": [ + "AAAAAAAAAAAAAAAAAAAAAA==" + ], + "B": [ + "0AAAAAAAAAAAAAAAAAAAAA==", + "IQAAAAAAAAAAAAAAAAAAAA==" + ] + } + }, + "gfpoly_pow": { + "action": "gfpoly_pow", + "arguments": { + "A": [ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "k": 3 + } + }, + "gfpoly_pow_k0": { + "action": "gfpoly_pow", + "arguments": { + "A": [ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "k": 0 + } + }, + "gfpoly_pow_k1": { + "action": "gfpoly_pow", + "arguments": { + "A": [ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "k": 1 + } + }, + "gfdiv": { + "action": "gfdiv", + "arguments": { + "a": "JAAAAAAAAAAAAAAAAAAAAA==", + "b": "wAAAAAAAAAAAAAAAAAAAAA==" + } + } + } +} From 9785b8d8aa5af3f12091eec2a2f54cc750ce23f9 Mon Sep 17 00:00:00 2001 From: alivecow Date: Thu, 14 Nov 2024 23:42:38 +0100 Subject: [PATCH 036/105] refactor: apply rust suggested code cleanups --- src/main.rs | 2 +- src/tasks/mod.rs | 9 +++------ src/tasks/tasks01/block2poly.rs | 2 +- src/tasks/tasks01/gfmul.rs | 5 +---- src/tasks/tasks01/pad_oracle.rs | 10 ++++------ src/tasks/tasks01/poly2block.rs | 3 +-- src/tasks/tasks01/sea128.rs | 2 -- src/utils/ciphers.rs | 5 +---- src/utils/field.rs | 8 ++------ src/utils/math.rs | 4 +--- src/utils/parse.rs | 2 -- src/utils/poly.rs | 4 +--- 12 files changed, 16 insertions(+), 40 deletions(-) diff --git a/src/main.rs b/src/main.rs index 5816ecb..201533c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,5 @@ use std::{ - env::{self, args}, + env::{self}, fs, }; diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index b024471..bdb2fb0 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -1,11 +1,8 @@ use base64::prelude::*; -use std::{collections::HashMap, env::args}; +use std::collections::HashMap; -use crate::utils::{ - ciphers::gcm_encrypt_aes, - parse::{Responses, Testcase, Testcases}, -}; +use crate::utils::parse::{Responses, Testcase, Testcases}; use tasks01::{ block2poly::block2poly, gcm::{gcm_decrypt, gcm_encrypt}, @@ -14,7 +11,7 @@ use tasks01::{ pfmath::{gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_mul, gfpoly_pow, gfpoly_powmod}, poly2block::poly2block, sea128::sea128, - xex::{self, fde_xex}, + xex::{fde_xex}, }; use anyhow::{anyhow, Result}; diff --git a/src/tasks/tasks01/block2poly.rs b/src/tasks/tasks01/block2poly.rs index dbdaf66..3e636eb 100644 --- a/src/tasks/tasks01/block2poly.rs +++ b/src/tasks/tasks01/block2poly.rs @@ -1,4 +1,4 @@ -use crate::utils::poly::{b64_2_num, block_2_polynomial, get_coefficients}; +use crate::utils::poly::block_2_polynomial; use anyhow::Result; use base64::prelude::*; use serde_json::Value; diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 2c1d6b8..70ab788 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -1,7 +1,4 @@ -use crate::utils::{ - field::ByteArray, - poly::{b64_2_num, coefficient_to_binary, gfmul}, -}; +use crate::utils::poly::gfmul; use anyhow::Result; use base64::prelude::*; diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 64eb2d1..90e4295 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -3,8 +3,8 @@ use base64::prelude::*; use serde_json::Value; use std::io::prelude::*; use std::net::TcpStream; -use std::time::{Duration, Instant}; -use std::{thread, usize}; +use std::time::Instant; +use std::usize; pub fn padding_oracle(args: &Value) -> Result> { let hostname: String = serde_json::from_value(args["hostname"].clone())?; @@ -29,8 +29,6 @@ pub fn padding_oracle(args: &Value) -> Result> { let mut chunk_counter = 0; for chunk in &cipher_chunks { - let start = Instant::now(); - let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?; stream.set_nonblocking(false)?; @@ -111,12 +109,12 @@ pub fn padding_oracle(args: &Value) -> Result> { } 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); + .unwrap_or(0x00) as u8; if valid_val == 0x00 { eprintln!("No valid found"); } diff --git a/src/tasks/tasks01/poly2block.rs b/src/tasks/tasks01/poly2block.rs index 293d1c3..6d5ad95 100644 --- a/src/tasks/tasks01/poly2block.rs +++ b/src/tasks/tasks01/poly2block.rs @@ -1,6 +1,5 @@ -use crate::utils::poly::{self, polynomial_2_block}; +use crate::utils::poly::{polynomial_2_block}; use anyhow::{Ok, Result}; -use base64::prelude::*; use serde_json::Value; pub fn poly2block(args: &Value) -> Result> { diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index 3f5c40d..6d76909 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -12,7 +12,6 @@ pub fn sea128(args: &Value) -> Result { 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() { @@ -34,7 +33,6 @@ 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 333ec13..35181a5 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,6 +1,4 @@ -use std::{io::BufRead, process::Output}; - -use crate::utils::{field::ByteArray, math::reverse_bits_in_bytevec, poly::gfmul}; +use crate::utils::{field::ByteArray, poly::gfmul}; use anyhow::Result; use base64::prelude::*; use openssl::symm::{Cipher, Crypter, Mode}; @@ -40,7 +38,6 @@ 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) } diff --git a/src/utils/field.rs b/src/utils/field.rs index fac51f2..14d0c46 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,14 +1,10 @@ -use std::{ - env::args, - ops::{Add, BitXor, Div, Mul, Rem, Sub}, - result, -}; +use std::ops::{Add, BitXor, Div, Mul, Sub}; use anyhow::{anyhow, Ok, Result}; use base64::prelude::*; use serde_json::Value; -use crate::{tasks::tasks01::poly2block::poly2block, utils::poly::polynomial_2_block}; +use crate::utils::poly::polynomial_2_block; use super::{math::xor_bytes, poly::gfmul}; diff --git a/src/utils/math.rs b/src/utils/math.rs index cf87e0c..c1809e2 100644 --- a/src/utils/math.rs +++ b/src/utils/math.rs @@ -1,7 +1,5 @@ -use anyhow::{anyhow, Ok, Result}; -use base64::Engine; +use anyhow::{Ok, Result}; -use super::poly::gfmul; pub fn xor_bytes(vec1: &Vec, mut vec2: Vec) -> Result> { for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) { diff --git a/src/utils/parse.rs b/src/utils/parse.rs index 5cc1781..6e5d2dd 100644 --- a/src/utils/parse.rs +++ b/src/utils/parse.rs @@ -28,8 +28,6 @@ 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 6425577..3866e49 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,10 +1,8 @@ use crate::utils::field::ByteArray; use anyhow::{anyhow, Result}; use base64::prelude::*; -use serde_json::Value; use std::{str::FromStr, u128, u8, usize}; -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> { @@ -172,7 +170,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 From 5dc299372a742b2ba76302574c36ca2f6d5f9ad4 Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 10:13:05 +0100 Subject: [PATCH 037/105] fix: Add handling of zero mulitplication for polynomials --- src/utils/field.rs | 105 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 102 insertions(+), 3 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 14d0c46..758ea75 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -151,6 +151,15 @@ impl Polynomial { (Polynomial::new(quotient_coeffs), remainder) } + + fn is_zero(&self) -> bool { + for field_element in &self.polynomial { + if !field_element.is_zero() { + return false; + } + } + true + } } impl Clone for Polynomial { @@ -163,8 +172,10 @@ impl Clone for Polynomial { impl Mul for Polynomial { type Output = Self; - fn mul(self, rhs: Self) -> Self::Output { + if self.is_zero() || rhs.is_zero() { + return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } let mut polynomial: Vec = vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; for i in 0..self.polynomial.len() { @@ -180,6 +191,9 @@ impl Mul for Polynomial { impl Mul for &Polynomial { type Output = Polynomial; fn mul(self, rhs: Self) -> Self::Output { + if self.is_zero() || rhs.is_zero() { + return Polynomial::new(vec![FieldElement::new(vec![0])]); + } let mut polynomial: Vec = vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; for i in 0..self.polynomial.len() { @@ -296,6 +310,10 @@ impl FieldElement { //eprintln!("Inverse rhs {:?}", inverse); FieldElement::new(inverse) } + + fn is_zero(&self) -> bool { + self.field_element.iter().all(|&x| x == 0x00) + } } impl Mul for FieldElement { @@ -662,6 +680,68 @@ mod tests { ); } + #[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!([ @@ -690,7 +770,26 @@ mod tests { } #[test] - fn test_field_pow_01() { + 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==", @@ -792,6 +891,6 @@ mod tests { let result = element1.pow_mod(1000, modulus); eprintln!("Result is: {:02X?}", result); - assert_eq!(result.to_c_array(), vec!["XrEhmKuat+Glt5zZWtMo6g=="]); + assert_eq!(result.to_c_array(), vec!["oNXl5P8xq2WpUTP92u25zg=="]); } } From 2a9db307d9f79c480bef7885bacf38f18659bd54 Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 10:26:38 +0100 Subject: [PATCH 038/105] fix: Add handling of pow with 0 --- src/utils/field.rs | 67 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 59 insertions(+), 8 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 758ea75..5f47fce 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -54,7 +54,9 @@ impl Polynomial { pub fn pow(&self, mut exponent: u128) -> Polynomial { if exponent == 0 { - return Polynomial::new(vec![FieldElement::new(vec![0])]); + return Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); } let base = self.clone(); @@ -69,6 +71,12 @@ impl Polynomial { } pub fn pow_mod(mut self, mut exponent: u128, modulus: Polynomial) -> Polynomial { + if exponent == 0 { + return Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); + } + let mut result: Polynomial = Polynomial::new(vec![FieldElement::new( polynomial_2_block(vec![0], "gcm").unwrap(), )]); @@ -536,15 +544,13 @@ impl ByteArray { #[cfg(test)] mod tests { use super::*; - use base64::prelude::*; use serde_json::json; - use std::fs; #[test] fn test_byte_array_shift1() { let mut byte_array: ByteArray = ByteArray(vec![0x00, 0x01]); let shifted_array: ByteArray = ByteArray(vec![0x00, 0x02]); - byte_array.left_shift("xex"); + byte_array.left_shift("xex").unwrap(); assert_eq!(byte_array.0, shifted_array.0); } @@ -553,7 +559,7 @@ mod tests { fn test_byte_array_shift2() { let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x01]); - byte_array.left_shift("xex"); + byte_array.left_shift("xex").unwrap(); assert_eq!( byte_array.0, shifted_array.0, @@ -566,7 +572,7 @@ mod tests { fn test_byte_array_shift1_gcm() { let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); let shifted_array: ByteArray = ByteArray(vec![0x7F, 0x80]); - byte_array.left_shift("gcm"); + byte_array.left_shift("gcm").unwrap(); assert_eq!( byte_array.0, shifted_array.0, @@ -579,7 +585,7 @@ mod tests { fn test_byte_array_shift1_right_gcm() { let mut byte_array: ByteArray = ByteArray(vec![0xFF, 0x00]); let shifted_array: ByteArray = ByteArray(vec![0xFE, 0x00]); - byte_array.right_shift("gcm"); + byte_array.right_shift("gcm").unwrap(); assert_eq!( byte_array.0, shifted_array.0, @@ -592,7 +598,7 @@ mod tests { fn test_byte_array_shift_right() { let mut byte_array: ByteArray = ByteArray(vec![0x02]); let shifted_array: ByteArray = ByteArray(vec![0x01]); - byte_array.right_shift("xex"); + byte_array.right_shift("xex").unwrap(); assert_eq!( byte_array.0, shifted_array.0, @@ -814,6 +820,21 @@ mod tests { //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!([ @@ -840,6 +861,36 @@ mod tests { //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_pow_mod_10mill() { + let json1 = json!([ + "JAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ]); + let element1: Polynomial = Polynomial::from_c_array(&json1); + + let result = element1.pow(10000000); + + assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]); + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } + #[test] fn test_poly_div_01() { let element1 = From 0784c264562ec791b2acc8201205695d92303689 Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 11:29:25 +0100 Subject: [PATCH 039/105] fix: Add handling for larger divisor --- src/utils/field.rs | 35 +++++++++++++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 5f47fce..3bd1c89 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -103,6 +103,12 @@ impl Polynomial { pub fn div(self, rhs: &Self) -> (Self, Self) { // Div by zero check ommitted since data is guaranteed to be non 0 + eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); + + if self.polynomial.len() < rhs.polynomial.len() { + return (Polynomial::new(vec![FieldElement::new(vec![0; 16])]), self); + } + let mut remainder = self.clone(); let divisor = rhs; let dividend_deg = remainder.polynomial.len() - 1; @@ -883,11 +889,13 @@ mod tests { "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(10000000); + let result = element1.pow_mod(10000000, modulus); - assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]); + assert!(!result.is_zero()) //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } @@ -928,6 +936,29 @@ mod tests { //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_powmod_01() { let json1 = json!([ From 6a04e00fb2fd58a811fd1e3aeaf8a4342681591a Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 15:27:13 +0100 Subject: [PATCH 040/105] fix: Fix remainder output of div function --- src/utils/field.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 3bd1c89..164a04c 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -71,12 +71,6 @@ impl Polynomial { } pub fn pow_mod(mut self, mut exponent: u128, modulus: Polynomial) -> Polynomial { - if exponent == 0 { - return Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); - } - let mut result: Polynomial = Polynomial::new(vec![FieldElement::new( polynomial_2_block(vec![0], "gcm").unwrap(), )]); @@ -163,6 +157,9 @@ impl Polynomial { } } + if remainder.is_empty() { + remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } (Polynomial::new(quotient_coeffs), remainder) } From 67bbf67f18bfbf0d4e777ef9fa39a36dd1c37f9d Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 20:02:16 +0100 Subject: [PATCH 041/105] fix: Handle response on adding arbit. len equal polynomials --- src/utils/field.rs | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/utils/field.rs b/src/utils/field.rs index 164a04c..859978b 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -234,6 +234,12 @@ impl Add for Polynomial { } } + for i in (0..polynomial.len() - 1).rev() { + if polynomial[i].is_zero() { + polynomial.pop(); + } + } + Polynomial::new(polynomial) } } @@ -689,6 +695,35 @@ mod tests { ); } + #[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!([ @@ -956,6 +991,7 @@ mod tests { ); //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } + #[test] fn test_field_poly_powmod_01() { let json1 = json!([ From 7dc6fa1ac982e1b4960c54d012005c7ebcf124a5 Mon Sep 17 00:00:00 2001 From: alivecow Date: Fri, 15 Nov 2024 20:14:54 +0100 Subject: [PATCH 042/105] fix: Fix handling of special cases in powmod --- src/utils/field.rs | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/utils/field.rs b/src/utils/field.rs index 859978b..37502f6 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -75,6 +75,18 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); + if exponent == 1 { + return self; + } + + if exponent == 0 { + Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![1], "gcm").unwrap(), + )]) + .div(&modulus) + .1; + } + //eprintln!("Initial result: {:?}", result); while exponent > 0 { //eprintln!("Current exponent: {:02X}", exponent); @@ -1008,4 +1020,30 @@ mod tests { 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=="]); + 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() { + 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=="]); + } } From 295ed98c1e3805756370df8b6bc919b80d82bfd6 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 16 Nov 2024 14:59:31 +0100 Subject: [PATCH 043/105] fix: Add further handling to leading zero blocks in add and powmod --- src/utils/field.rs | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 37502f6..02eac1e 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -81,7 +81,7 @@ impl Polynomial { if exponent == 0 { Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![1], "gcm").unwrap(), + polynomial_2_block(vec![0], "gcm").unwrap(), )]) .div(&modulus) .1; @@ -102,6 +102,23 @@ impl Polynomial { //eprintln!("After mod: {:?}", self); 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::new(vec![FieldElement::new(vec![0; 16])]); + } + result } @@ -246,10 +263,13 @@ impl Add for Polynomial { } } - for i in (0..polynomial.len() - 1).rev() { - if polynomial[i].is_zero() { - polynomial.pop(); - } + 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::new(vec![0; 16])]); } Polynomial::new(polynomial) From ca2067c04e7ea8a04c6bd77975ff0c79e89db8bc Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 16 Nov 2024 20:31:16 +0100 Subject: [PATCH 044/105] fix: Add better handling of special cases to powmod --- src/utils/field.rs | 132 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 110 insertions(+), 22 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 02eac1e..e4fff9c 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -76,15 +76,19 @@ impl Polynomial { )]); if exponent == 1 { - return self; + eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); + + return self.div(&modulus).1; } if exponent == 0 { - Polynomial::new(vec![FieldElement::new( + let inter = Polynomial::new(vec![FieldElement::new( polynomial_2_block(vec![0], "gcm").unwrap(), - )]) - .div(&modulus) - .1; + )]); + let result = inter.div(&modulus); + + eprintln!("Returned value is: {:02X?}", result); + return result.1; } //eprintln!("Initial result: {:?}", result); @@ -103,6 +107,8 @@ impl Polynomial { exponent >>= 1; } + eprintln!("result in powmod before reduction: {:02X?}", result); + while !result.polynomial.is_empty() && result .polynomial @@ -115,6 +121,8 @@ impl Polynomial { result.polynomial.pop(); } + eprintln!("result in powmod after reduction: {:02X?}", result); + if result.is_empty() { result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); } @@ -946,23 +954,6 @@ mod tests { //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } - #[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()) - //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); - } - #[test] fn test_poly_div_01() { let element1 = @@ -1024,6 +1015,38 @@ mod tests { //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!([ @@ -1043,6 +1066,19 @@ mod tests { #[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_k1_modulus_is_deg0() { let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]); let json2 = json!(["KryptoanalyseAAAAAAAAA=="]); let element1: Polynomial = Polynomial::from_c_array(&json1); @@ -1054,6 +1090,41 @@ mod tests { assert_eq!(result.to_c_array(), vec!["JAAAAAAAAAAAAAAAAAAAAA=="]); } + #[test] + fn test_field_poly_powmod_k1_eqdeg() { + let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="]); + let json2 = json!(["KryptoanalyseAAAAAAAAA==", "KryptoanalyseAAAAAAAAA=="]); + 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!(!(0 < 0)); + assert_eq!( + result.to_c_array(), + vec!["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="] + ); + } + + #[test] + fn test_field_poly_powmod_kn_eqdeg() { + let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="]); + let json2 = json!(["KryptoanalyseAAAAAAAAA==", "KryptoanalyseAAAAAAAAA=="]); + let element1: Polynomial = Polynomial::from_c_array(&json1); + let modulus: Polynomial = Polynomial::from_c_array(&json2); + + let result = element1.pow_mod(100000, modulus); + + eprintln!("Result is: {:02X?}", result); + + assert!(!(0 < 0)); + assert_eq!( + result.to_c_array(), + vec!["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="] + ); + } #[test] fn test_field_poly_powmod_k0() { let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]); @@ -1066,4 +1137,21 @@ mod tests { 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()) + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } } From bb5e762a1df258465ff6592d69625a0a4a17caae Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 16 Nov 2024 23:21:10 +0100 Subject: [PATCH 045/105] chore: Try pushing again because no response was received from pipeline --- src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index f546561..fd69ac4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,7 +3,7 @@ use std::{ fs, }; -// TESTING +// TESTING 2 use anyhow::Result; From c3ea652c87bc271a373d10ec7ff30459368b0cce Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 20 Nov 2024 19:37:46 +0100 Subject: [PATCH 046/105] feat: Sorting of polynomial array with rust standard sort implemented --- src/tasks/mod.rs | 12 +++- src/tasks/tasks01/pfmath.rs | 74 +++++++++++++++++++- src/utils/field.rs | 132 ++++++++++++++++++++++++++++-------- 3 files changed, 185 insertions(+), 33 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index bdb2fb0..a4751e4 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -8,10 +8,12 @@ use tasks01::{ gcm::{gcm_decrypt, gcm_encrypt}, gfmul::gfmul_task, pad_oracle::padding_oracle, - pfmath::{gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_mul, gfpoly_pow, gfpoly_powmod}, + pfmath::{ + gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, + }, poly2block::poly2block, sea128::sea128, - xex::{fde_xex}, + xex::fde_xex, }; use anyhow::{anyhow, Result}; @@ -118,6 +120,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_sort" => { + let result = gfpoly_sort(args)?; + let json = json!({"sorted_polys" : json!(result)}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 4ad3ac7..9742be8 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -2,7 +2,7 @@ use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::utils::field::{FieldElement, Polynomial}; +use crate::utils::field::{sort_polynomial_array, FieldElement, Polynomial}; pub fn gfpoly_add(args: &Value) -> Result { let poly_a = Polynomial::from_c_array(&args["A"].clone()); @@ -67,3 +67,75 @@ pub fn gfpoly_powmod(args: &Value) -> Result { 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) +} + +#[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=="); + } +} diff --git a/src/utils/field.rs b/src/utils/field.rs index e4fff9c..a682eff 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,4 +1,7 @@ -use std::ops::{Add, BitXor, Div, Mul, Sub}; +use std::{ + cmp::Ordering, + ops::{Add, BitXor, Div, Mul, Sub}, +}; use anyhow::{anyhow, Ok, Result}; use base64::prelude::*; @@ -8,7 +11,7 @@ use crate::utils::poly::polynomial_2_block; use super::{math::xor_bytes, poly::gfmul}; -#[derive(Debug)] +#[derive(Debug, serde::Serialize)] pub struct Polynomial { polynomial: Vec, } @@ -284,17 +287,14 @@ impl Add for Polynomial { } } -// Helper implementation for subtraction impl Sub for &FieldElement { type Output = FieldElement; fn sub(self, rhs: Self) -> FieldElement { - // In a field of characteristic 2, addition and subtraction are the same operation (XOR) self + rhs } } -// Helper trait for checking emptiness trait IsEmpty { fn is_empty(&self) -> bool; } @@ -310,7 +310,66 @@ impl AsRef<[FieldElement]> for Polynomial { } } -#[derive(Debug)] +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 { + if self.polynomial.len() != other.polynomial.len() { + return Some(self.polynomial.len().cmp(&other.polynomial.len())); + } else { + for (field_a, field_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { + match field_a.cmp(field_b) { + std::cmp::Ordering::Equal => continue, + other => return Some(other.reverse()), + } + } + Some(Ordering::Equal) + } + } +} + +impl Eq for Polynomial {} + +impl Ord for Polynomial { + fn cmp(&self, other: &Self) -> Ordering { + match self.polynomial.len().cmp(&other.polynomial.len()) { + Ordering::Equal => { + for (field_a, field_b) in + self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) + { + match field_a.cmp(field_b) { + std::cmp::Ordering::Equal => continue, + other => return other.reverse(), + } + } + Ordering::Equal + } + other => other, + } + } +} + +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) +} + +#[derive(Debug, serde::Serialize)] pub struct FieldElement { field_element: Vec, } @@ -462,34 +521,39 @@ impl Div for &FieldElement { } } -/* -impl Rem for FieldElement { - type Output = Self; - fn rem(self, rhs: Self) -> Self::Output { - let result: FieldElement = self.field_element; - - while self.field_element[15] != 0x00 { - self.field_element +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()) { + match byte_a.reverse_bits().cmp(&byte_b.reverse_bits()) { + std::cmp::Ordering::Equal => continue, + other => return Some(other), + } } - todo!(); + Some(Ordering::Equal) } } -*/ -/* -impl BitXor for FieldElement { - fn bitxor(self, rhs: Self) -> Self::Output { - FieldElement - } -} -*/ -/* -impl From> for FieldElement { - fn from(item: Vec) -> Self { - FieldElement { bytes: item } +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().zip(other.as_ref().iter()) { + match byte_a.reverse_bits().cmp(&byte_b.reverse_bits()) { + std::cmp::Ordering::Equal => continue, + other => return other, + } + } + Ordering::Equal } } -*/ #[derive(Debug)] pub struct ByteArray(pub Vec); @@ -1110,8 +1174,16 @@ mod tests { #[test] fn test_field_poly_powmod_kn_eqdeg() { - let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="]); - let json2 = json!(["KryptoanalyseAAAAAAAAA==", "KryptoanalyseAAAAAAAAA=="]); + let json1 = json!([ + "JAAAAAAAAAAAAAAAAAAAAA==", + "JAAAAAAAAAAAAAAAAAAAAA==", + "KryptoanalyseAAAAAAAAA==" + ]); + let json2 = json!([ + "KryptoanalyseAAAAAAAAA==", + "KryptoanalyseAAAAAAAAA==", + "JAAAAAAAAABBAAAAAAAAAA==" + ]); let element1: Polynomial = Polynomial::from_c_array(&json1); let modulus: Polynomial = Polynomial::from_c_array(&json2); From bad946e9acbd312b8b2a9fa075e8c778d98ef9d6 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 20 Nov 2024 19:50:26 +0100 Subject: [PATCH 047/105] feat: Add proper handling in testcase runner and add testing json file --- src/tasks/mod.rs | 8 +++++++- test_json/poly_algs.json | 29 +++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 test_json/poly_algs.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index a4751e4..9d24f8b 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -121,7 +121,13 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } "gfpoly_sort" => { - let result = gfpoly_sort(args)?; + 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) diff --git a/test_json/poly_algs.json b/test_json/poly_algs.json new file mode 100644 index 0000000..b4a687e --- /dev/null +++ b/test_json/poly_algs.json @@ -0,0 +1,29 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + +"action": "gfpoly_sort", +"arguments": { +"polys": [ +[ +"NeverGonnaGiveYouUpAAA==", +"NeverGonnaLetYouDownAA==", +"NeverGonnaRunAroundAAA==", +"AndDesertYouAAAAAAAAAA==" +], +[ +"WereNoStrangersToLoveA==", +"YouKnowTheRulesAAAAAAA==", +"AndSoDoIAAAAAAAAAAAAAA==" +], +[ +"NeverGonnaMakeYouCryAA==", +"NeverGonnaSayGoodbyeAA==", +"NeverGonnaTellALieAAAA==", +"AndHurtYouAAAAAAAAAAAA==" +] +] +} +} + } +} From b63dc86c7eb4b4888759da475fc899e869ddb277 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 21 Nov 2024 16:56:28 +0100 Subject: [PATCH 048/105] WIP: feat: Change soring behaviour and add new testcase --- src/tasks/tasks01/pfmath.rs | 54 +++++++++++++++++++++++++++++++++++++ src/utils/field.rs | 21 ++++++++------- 2 files changed, 66 insertions(+), 9 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 9742be8..71d6991 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -138,4 +138,58 @@ mod tests { 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!([ + [ + "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=="); + } } diff --git a/src/utils/field.rs b/src/utils/field.rs index a682eff..2c80b51 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -324,17 +324,20 @@ impl PartialEq for Polynomial { } impl PartialOrd for Polynomial { - fn partial_cmp(&self, other: &Self) -> Option { - if self.polynomial.len() != other.polynomial.len() { - return Some(self.polynomial.len().cmp(&other.polynomial.len())); - } else { - for (field_a, field_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { - match field_a.cmp(field_b) { - std::cmp::Ordering::Equal => continue, - other => return Some(other.reverse()), + fn partial_cmp(&self, other: &Self) -> Option { + match self.polynomial.len().cmp(&other.polynomial.len()) { + Ordering::Equal => { + for (field_a, field_b) in + self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) + { + match field_a.cmp(field_b) { + std::cmp::Ordering::Equal => continue, + other => return Some(other.reverse()), + } } + Some(Ordering::Equal) } - Some(Ordering::Equal) + other => Some(other), } } } From 81fe06941dbf7d43d05ab12c6f9375c327dded67 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 21 Nov 2024 17:20:29 +0100 Subject: [PATCH 049/105] fix: add fix for powmod spcial case k=0 --- src/utils/field.rs | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 2c80b51..3c7c683 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -85,13 +85,12 @@ impl Polynomial { } if exponent == 0 { - let inter = Polynomial::new(vec![FieldElement::new( + let result = Polynomial::new(vec![FieldElement::new( polynomial_2_block(vec![0], "gcm").unwrap(), )]); - let result = inter.div(&modulus); eprintln!("Returned value is: {:02X?}", result); - return result.1; + return result; } //eprintln!("Initial result: {:?}", result); @@ -1175,6 +1174,20 @@ mod tests { ); } + #[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_kn_eqdeg() { let json1 = json!([ From a520a811b41fa35ef269a341a66447ac804043b0 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 11:37:35 +0100 Subject: [PATCH 050/105] fix/feat: Attempt more fixes for the sorting function and add initial monic function --- src/tasks/tasks01/pfmath.rs | 59 ++++++++++++++++------------------- src/utils/field.rs | 62 ++++++++++++++++++++++++------------- 2 files changed, 67 insertions(+), 54 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 71d6991..1df7e96 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -143,43 +143,38 @@ mod tests { 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 - ] - ],}); + [ + "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=="], [ - "WereNoStrangersToLoveA==", - "YouKnowTheRulesAAAAAAA==", - "AndSoDoIAAAAAAAAAAAAAA==" + "AQAAAAAAAAAAAAAAAAAAAA==", + "AgAAAAAAAAAAAAAAAAAAAA==", + "BAAAAAAAAAAAAAAAAAAAAA==" ], [ - "NeverGonnaMakeYouCryAA==", - "NeverGonnaSayGoodbyeAA==", - "NeverGonnaTellALieAAAA==", - "AndHurtYouAAAAAAAAAAAA==" - ], - [ - "NeverGonnaGiveYouUpAAA==", - "NeverGonnaLetYouDownAA==", - "NeverGonnaRunAroundAAA==", - "AndDesertYouAAAAAAAAAA==" + "AQAAAAAAAAAAAAAAAAAAAA==", + "AgAAAAAAAAAAAAAAAAAAAA==", + "AwAAAAAAAAAAAAAAAAAAAA==" ] ]); diff --git a/src/utils/field.rs b/src/utils/field.rs index 2c80b51..4f1e211 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,5 +1,6 @@ use std::{ cmp::Ordering, + mem::discriminant, ops::{Add, BitXor, Div, Mul, Sub}, }; @@ -9,7 +10,10 @@ use serde_json::Value; use crate::utils::poly::polynomial_2_block; -use super::{math::xor_bytes, poly::gfmul}; +use super::{ + math::{reverse_bits_in_bytevec, xor_bytes}, + poly::gfmul, +}; #[derive(Debug, serde::Serialize)] pub struct Polynomial { @@ -211,6 +215,16 @@ impl Polynomial { } true } + + 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(); + } + + todo!(); + } } impl Clone for Polynomial { @@ -325,19 +339,21 @@ impl PartialEq for Polynomial { impl PartialOrd for Polynomial { fn partial_cmp(&self, other: &Self) -> Option { - match self.polynomial.len().cmp(&other.polynomial.len()) { + 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.cmp(field_b) { - std::cmp::Ordering::Equal => continue, - other => return Some(other.reverse()), + for (field_a, field_b) in self.as_ref().iter().zip(other.as_ref().iter()) { + match field_a + .reverse_bits() + .partial_cmp(&field_b.reverse_bits()) + .unwrap() + { + Ordering::Equal => continue, + other => return Some(other), } } Some(Ordering::Equal) } - other => Some(other), + other => Some(other.reverse()), } } } @@ -346,19 +362,17 @@ impl Eq for Polynomial {} impl Ord for Polynomial { fn cmp(&self, other: &Self) -> Ordering { - match self.polynomial.len().cmp(&other.polynomial.len()) { + 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.cmp(field_b) { - std::cmp::Ordering::Equal => continue, - other => return other.reverse(), + for (field_a, field_b) in self.as_ref().iter().zip(other.as_ref().iter()) { + match field_a.reverse_bits().cmp(&field_b.reverse_bits()) { + Ordering::Equal => continue, + other => return other, } } Ordering::Equal } - other => other, + other => other.reverse(), } } } @@ -433,6 +447,10 @@ impl FieldElement { fn is_zero(&self) -> bool { self.field_element.iter().all(|&x| x == 0x00) } + + fn reverse_bits(&self) -> Self { + FieldElement::new(reverse_bits_in_bytevec(self.field_element.clone())) + } } impl Mul for FieldElement { @@ -526,10 +544,10 @@ impl Div for &FieldElement { 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()) { - match byte_a.reverse_bits().cmp(&byte_b.reverse_bits()) { + for (byte_a, byte_b) in self.as_ref().iter().zip(other.as_ref().iter()) { + match byte_a.partial_cmp(&byte_b).unwrap() { std::cmp::Ordering::Equal => continue, - other => return Some(other), + other => return Some(other.reverse()), } } Some(Ordering::Equal) @@ -549,9 +567,9 @@ impl Eq for FieldElement { impl Ord for FieldElement { fn cmp(&self, other: &Self) -> Ordering { for (byte_a, byte_b) in self.as_ref().iter().zip(other.as_ref().iter()) { - match byte_a.reverse_bits().cmp(&byte_b.reverse_bits()) { + match byte_a.cmp(&byte_b) { std::cmp::Ordering::Equal => continue, - other => return other, + other => return other.reverse(), } } Ordering::Equal From ad8326b51e4bdb26b4e23aba420c3152d649d9a1 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 14:36:20 +0100 Subject: [PATCH 051/105] fix: Modifiy the sorting behavior and remove unneded testcases --- src/utils/field.rs | 100 +++++++++++++++------------------------------ 1 file changed, 34 insertions(+), 66 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 86f545d..2864a5e 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -340,7 +340,15 @@ 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().zip(other.as_ref().iter()) { + for (field_a, field_b) in + self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) + { + eprintln!( + "Poly partord: {:02X?} {:02X?} ", + self.clone().to_c_array(), + other.clone().to_c_array() + ); + match field_a .reverse_bits() .partial_cmp(&field_b.reverse_bits()) @@ -363,7 +371,9 @@ 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().zip(other.as_ref().iter()) { + 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.reverse_bits()) { Ordering::Equal => continue, other => return other, @@ -543,10 +553,17 @@ impl Div for &FieldElement { impl PartialOrd for FieldElement { fn partial_cmp(&self, other: &Self) -> Option { - for (byte_a, byte_b) in self.as_ref().iter().zip(other.as_ref().iter()) { - match byte_a.partial_cmp(&byte_b).unwrap() { - std::cmp::Ordering::Equal => continue, - other => return Some(other.reverse()), + for (byte_a, byte_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { + eprintln!("Field Partial Ord Bytes: {:02X} {:02X}", byte_a, byte_b); + if byte_a > byte_b { + eprintln!("Bytes were greater"); + return Some(Ordering::Greater); + } else if byte_a < byte_b { + eprintln!("Bytes were less"); + return Some(Ordering::Less); + } else { + eprintln!("Bytes were equal"); + continue; } } Some(Ordering::Equal) @@ -565,10 +582,17 @@ impl Eq for FieldElement { impl Ord for FieldElement { fn cmp(&self, other: &Self) -> Ordering { - for (byte_a, byte_b) in self.as_ref().iter().zip(other.as_ref().iter()) { - match byte_a.cmp(&byte_b) { - std::cmp::Ordering::Equal => continue, - other => return other.reverse(), + for (byte_a, byte_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { + eprintln!("Field Ord Bytes: {:02X} {:02X}", byte_a, byte_b); + if byte_a > byte_b { + eprintln!("Bytes were greater"); + return Ordering::Greater; + } else if byte_a < byte_b { + eprintln!("Bytes were less"); + return Ordering::Less; + } else { + eprintln!("Bytes were equal"); + continue; } } Ordering::Equal @@ -1161,37 +1185,6 @@ mod tests { assert_eq!(result.to_c_array(), vec!["JAAAAAAAAAAAAAAAAAAAAA=="]); } - #[test] - fn test_field_poly_powmod_k1_modulus_is_deg0() { - 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(1, modulus); - - eprintln!("Result is: {:02X?}", result); - assert_eq!(result.to_c_array(), vec!["JAAAAAAAAAAAAAAAAAAAAA=="]); - } - - #[test] - fn test_field_poly_powmod_k1_eqdeg() { - let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="]); - let json2 = json!(["KryptoanalyseAAAAAAAAA==", "KryptoanalyseAAAAAAAAA=="]); - 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!(!(0 < 0)); - assert_eq!( - result.to_c_array(), - vec!["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="] - ); - } - #[test] fn test_field_poly_powmod_k0_special() { let json1 = json!(["NeverGonnaGiveYouUpAAA=="]); @@ -1206,31 +1199,6 @@ mod tests { assert_eq!(result.to_c_array(), vec!["gAAAAAAAAAAAAAAAAAAAAA=="]); } - #[test] - fn test_field_poly_powmod_kn_eqdeg() { - let json1 = json!([ - "JAAAAAAAAAAAAAAAAAAAAA==", - "JAAAAAAAAAAAAAAAAAAAAA==", - "KryptoanalyseAAAAAAAAA==" - ]); - let json2 = json!([ - "KryptoanalyseAAAAAAAAA==", - "KryptoanalyseAAAAAAAAA==", - "JAAAAAAAAABBAAAAAAAAAA==" - ]); - let element1: Polynomial = Polynomial::from_c_array(&json1); - let modulus: Polynomial = Polynomial::from_c_array(&json2); - - let result = element1.pow_mod(100000, modulus); - - eprintln!("Result is: {:02X?}", result); - - assert!(!(0 < 0)); - assert_eq!( - result.to_c_array(), - vec!["JAAAAAAAAAAAAAAAAAAAAA==", "JAAAAAAAAAAAAAAAAAAAAA=="] - ); - } #[test] fn test_field_poly_powmod_k0() { let json1 = json!(["JAAAAAAAAAAAAAAAAAAAAA==",]); From a5a3ea61faa236cbbebb507e331bc21a05ade249 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 15:28:00 +0100 Subject: [PATCH 052/105] refactor: Split Polynomial class into poly.rs file --- src/tasks/tasks01/pfmath.rs | 2 +- src/utils/field.rs | 802 +---------------------------------- src/utils/poly.rs | 819 +++++++++++++++++++++++++++++++++++- 3 files changed, 825 insertions(+), 798 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 1df7e96..9fb7014 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -2,7 +2,7 @@ use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::utils::field::{sort_polynomial_array, FieldElement, Polynomial}; +use crate::utils::{field::FieldElement, poly::Polynomial}; pub fn gfpoly_add(args: &Value) -> Result { let poly_a = Polynomial::from_c_array(&args["A"].clone()); diff --git a/src/utils/field.rs b/src/utils/field.rs index 2864a5e..6894023 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,3 +1,6 @@ +use base64::prelude::*; +use std::{str::FromStr, u128, u8, usize}; + use std::{ cmp::Ordering, mem::discriminant, @@ -5,396 +8,14 @@ use std::{ }; use anyhow::{anyhow, Ok, Result}; -use base64::prelude::*; use serde_json::Value; -use crate::utils::poly::polynomial_2_block; - +use super::poly::polynomial_2_block; use super::{ math::{reverse_bits_in_bytevec, xor_bytes}, poly::gfmul, }; -#[derive(Debug, serde::Serialize)] -pub struct Polynomial { - polynomial: Vec, -} - -impl Polynomial { - pub const fn new(polynomial: Vec) -> Self { - Self { polynomial } - } - - 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(); - - eprintln!("{:?}", c_array); - - 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(BASE64_STANDARD.encode(coeff)); - } - - output - } - - pub fn pow(&self, mut exponent: u128) -> Polynomial { - if exponent == 0 { - return Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); - } - - let base = self.clone(); - let mut result = base.clone(); - exponent -= 1; - while exponent > 0 { - result = result * base.clone(); - exponent -= 1; - } - - 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 { - eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); - - return self.div(&modulus).1; - } - - if exponent == 0 { - let result = Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); - - eprintln!("Returned value is: {:02X?}", result); - return result; - } - - //eprintln!("Initial result: {:?}", result); - while exponent > 0 { - //eprintln!("Current exponent: {:02X}", exponent); - if exponent & 1 == 1 { - let temp = &self * &result; - //eprintln!("After multiplication: {:?}", temp); - result = temp.div(&modulus).1; - //eprintln!("After mod: {:?}", result); - } - let temp_square = &self * &self; - //eprintln!("After squaring: {:?}", temp_square); - self = temp_square.div(&modulus).1; - //eprintln!("After mod: {:?}", self); - exponent >>= 1; - } - - eprintln!("result in powmod before reduction: {:02X?}", result); - - while !result.polynomial.is_empty() - && result - .polynomial - .last() - .unwrap() - .as_ref() - .iter() - .all(|&x| x == 0) - { - result.polynomial.pop(); - } - - eprintln!("result in powmod after reduction: {:02X?}", result); - - if result.is_empty() { - result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); - } - - result - } - - // Returns (quotient, remainder) - pub fn div(self, rhs: &Self) -> (Self, Self) { - // Div by zero check ommitted since data is guaranteed to be non 0 - - eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); - - if self.polynomial.len() < rhs.polynomial.len() { - return (Polynomial::new(vec![FieldElement::new(vec![0; 16])]), self); - } - - 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::new( - polynomial_2_block(vec![0; 16], "gcm").unwrap(), - )]), - remainder, - ); - } - - let mut quotient_coeffs = - vec![ - FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); - 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 subtrahend = - vec![FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); deg_diff]; - subtrahend.extend( - divisor - .polynomial - .iter() - .map(|x| x.clone() * quot_coeff.clone()), - ); - let subtrahend_poly = Polynomial::new(subtrahend); - - remainder = remainder + subtrahend_poly; - - while !remainder.polynomial.is_empty() - && remainder - .polynomial - .last() - .unwrap() - .as_ref() - .iter() - .all(|&x| x == 0) - { - remainder.polynomial.pop(); - } - } - - if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); - } - (Polynomial::new(quotient_coeffs), remainder) - } - - fn is_zero(&self) -> bool { - for field_element in &self.polynomial { - if !field_element.is_zero() { - return false; - } - } - true - } - - 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(); - } - - todo!(); - } -} - -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::new(vec![FieldElement::new(vec![0; 16])]); - } - let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); 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::new(vec![FieldElement::new(vec![0])]); - } - let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); 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::new(vec![0; 16])]); - } - - Polynomial::new(polynomial) - } -} - -impl Sub for &FieldElement { - type Output = FieldElement; - - fn sub(self, rhs: Self) -> FieldElement { - self + rhs - } -} - -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()) - { - eprintln!( - "Poly partord: {:02X?} {:02X?} ", - self.clone().to_c_array(), - other.clone().to_c_array() - ); - - match field_a - .reverse_bits() - .partial_cmp(&field_b.reverse_bits()) - .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.reverse_bits()) { - Ordering::Equal => continue, - other => return other, - } - } - Ordering::Equal - } - other => other.reverse(), - } - } -} - -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) -} - #[derive(Debug, serde::Serialize)] pub struct FieldElement { field_element: Vec, @@ -453,11 +74,11 @@ impl FieldElement { FieldElement::new(inverse) } - fn is_zero(&self) -> bool { + pub fn is_zero(&self) -> bool { self.field_element.iter().all(|&x| x == 0x00) } - fn reverse_bits(&self) -> Self { + pub fn reverse_bits(&self) -> Self { FieldElement::new(reverse_bits_in_bytevec(self.field_element.clone())) } } @@ -817,415 +438,4 @@ mod tests { assert_eq!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA=="); } - - #[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_poly_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!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); - } - - #[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()) - //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); - } } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 3866e49..99def36 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,8 +1,391 @@ use crate::utils::field::ByteArray; -use anyhow::{anyhow, Result}; use base64::prelude::*; use std::{str::FromStr, u128, u8, usize}; +use std::{ + cmp::Ordering, + mem::discriminant, + ops::{Add, BitXor, Div, Mul, Sub}, +}; + +use anyhow::{anyhow, Ok, Result}; +use serde_json::Value; + +use super::field::FieldElement; +use super::math::{reverse_bits_in_bytevec, xor_bytes}; + +#[derive(Debug, serde::Serialize)] +pub struct Polynomial { + polynomial: Vec, +} + +impl Polynomial { + pub const fn new(polynomial: Vec) -> Self { + Self { polynomial } + } + + 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(); + + eprintln!("{:?}", c_array); + + 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(BASE64_STANDARD.encode(coeff)); + } + + output + } + + pub fn pow(&self, mut exponent: u128) -> Polynomial { + if exponent == 0 { + return Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); + } + + let base = self.clone(); + let mut result = base.clone(); + exponent -= 1; + while exponent > 0 { + result = result * base.clone(); + exponent -= 1; + } + + 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 { + eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); + + return self.div(&modulus).1; + } + + if exponent == 0 { + let result = Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); + + eprintln!("Returned value is: {:02X?}", result); + return result; + } + + //eprintln!("Initial result: {:?}", result); + while exponent > 0 { + //eprintln!("Current exponent: {:02X}", exponent); + if exponent & 1 == 1 { + let temp = &self * &result; + //eprintln!("After multiplication: {:?}", temp); + result = temp.div(&modulus).1; + //eprintln!("After mod: {:?}", result); + } + let temp_square = &self * &self; + //eprintln!("After squaring: {:?}", temp_square); + self = temp_square.div(&modulus).1; + //eprintln!("After mod: {:?}", self); + exponent >>= 1; + } + + eprintln!("result in powmod before reduction: {:02X?}", result); + + while !result.polynomial.is_empty() + && result + .polynomial + .last() + .unwrap() + .as_ref() + .iter() + .all(|&x| x == 0) + { + result.polynomial.pop(); + } + + eprintln!("result in powmod after reduction: {:02X?}", result); + + if result.is_empty() { + result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } + + result + } + + // Returns (quotient, remainder) + pub fn div(self, rhs: &Self) -> (Self, Self) { + // Div by zero check ommitted since data is guaranteed to be non 0 + + eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); + + if self.polynomial.len() < rhs.polynomial.len() { + return (Polynomial::new(vec![FieldElement::new(vec![0; 16])]), self); + } + + 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::new( + polynomial_2_block(vec![0; 16], "gcm").unwrap(), + )]), + remainder, + ); + } + + let mut quotient_coeffs = + vec![ + FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); + 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 subtrahend = + vec![FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); deg_diff]; + subtrahend.extend( + divisor + .polynomial + .iter() + .map(|x| x.clone() * quot_coeff.clone()), + ); + let subtrahend_poly = Polynomial::new(subtrahend); + + remainder = remainder + subtrahend_poly; + + while !remainder.polynomial.is_empty() + && remainder + .polynomial + .last() + .unwrap() + .as_ref() + .iter() + .all(|&x| x == 0) + { + remainder.polynomial.pop(); + } + } + + if remainder.is_empty() { + remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } + (Polynomial::new(quotient_coeffs), remainder) + } + + fn is_zero(&self) -> bool { + for field_element in &self.polynomial { + if !field_element.is_zero() { + return false; + } + } + true + } + + 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(); + } + + self + } +} + +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::new(vec![FieldElement::new(vec![0; 16])]); + } + let mut polynomial: Vec = + vec![FieldElement::new(vec![0; 16]); 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::new(vec![FieldElement::new(vec![0])]); + } + let mut polynomial: Vec = + vec![FieldElement::new(vec![0; 16]); 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::new(vec![0; 16])]); + } + + 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()) + { + eprintln!( + "Poly partord: {:02X?} {:02X?} ", + self.clone().to_c_array(), + other.clone().to_c_array() + ); + + match field_a + .reverse_bits() + .partial_cmp(&field_b.reverse_bits()) + .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.reverse_bits()) { + Ordering::Equal => continue, + other => return other, + } + } + Ordering::Equal + } + other => other.reverse(), + } + } +} + +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) +} + pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result> { @@ -189,6 +572,7 @@ pub fn coefficient_to_binary(coefficients: Vec) -> u128 { mod tests { 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::*; @@ -256,4 +640,437 @@ 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_poly_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!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); + } + + #[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()) + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } + + #[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); + //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } } From 5e50ef6091f4c3a72586432757dfc063f701201e Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 15:28:36 +0100 Subject: [PATCH 053/105] refactor: apply cargo recommended cleanups --- src/tasks/tasks01/pad_oracle.rs | 1 - src/utils/field.rs | 6 ++---- src/utils/poly.rs | 4 +--- 3 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 90e4295..4286e37 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -3,7 +3,6 @@ use base64::prelude::*; use serde_json::Value; use std::io::prelude::*; use std::net::TcpStream; -use std::time::Instant; use std::usize; pub fn padding_oracle(args: &Value) -> Result> { diff --git a/src/utils/field.rs b/src/utils/field.rs index 6894023..82234da 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,14 +1,12 @@ use base64::prelude::*; -use std::{str::FromStr, u128, u8, usize}; +use std::{u128, u8, usize}; use std::{ cmp::Ordering, - mem::discriminant, - ops::{Add, BitXor, Div, Mul, Sub}, + ops::{Add, BitXor, Div, Mul}, }; use anyhow::{anyhow, Ok, Result}; -use serde_json::Value; use super::poly::polynomial_2_block; use super::{ diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 99def36..bb05366 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -4,15 +4,13 @@ use std::{str::FromStr, u128, u8, usize}; use std::{ cmp::Ordering, - mem::discriminant, - ops::{Add, BitXor, Div, Mul, Sub}, + ops::{Add, Div, Mul}, }; use anyhow::{anyhow, Ok, Result}; use serde_json::Value; use super::field::FieldElement; -use super::math::{reverse_bits_in_bytevec, xor_bytes}; #[derive(Debug, serde::Serialize)] pub struct Polynomial { From 6391912bc4fdb9bb67c829c588249ecc8405f595 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 15:47:59 +0100 Subject: [PATCH 054/105] feat: Add and improve poly monic function with testcases Make a polynomial monic by dividing all field elements with the leading element --- src/utils/poly.rs | 45 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index bb05366..e624361 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -219,6 +219,22 @@ impl Polynomial { *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 } } @@ -1047,7 +1063,6 @@ mod tests { let result = element1.pow_mod(10000000, modulus); assert!(!result.is_zero()) - //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } #[test] @@ -1069,6 +1084,32 @@ mod tests { let result = element1.monic(); assert_eq!(json!(result.to_c_array()), expected); - //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); + } + + #[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); } } From f75e7de73385f802267763cd50c032a83babaf08 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 20:48:06 +0100 Subject: [PATCH 055/105] feat: Add polynomial square root algo --- src/utils/field.rs | 43 +++++++++++++++---- src/utils/poly.rs | 101 ++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 125 insertions(+), 19 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 82234da..184b2c6 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -36,21 +36,46 @@ impl FieldElement { BASE64_STANDARD.encode(&self.field_element) } - pub fn pow(&self, mut exponent: u128) -> FieldElement { + pub fn pow(mut self, mut exponent: u128) -> FieldElement { + let mut result: FieldElement = + FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()); + + if exponent == 1 { + eprintln!("special case 1: {:02X?}", self.clone()); + + return self; + } + if exponent == 0 { - // Return polynomial with coefficient 1 - return FieldElement::new(vec![1]); + let result = FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()); + + eprintln!("Returned value is: {:02X?}", result); + return result; } - let base = self.clone(); - let mut result = base.clone(); - exponent -= 1; // Subtract 1 because we already set result to base - + //eprintln!("Initial result: {:?}", result); while exponent > 0 { - result = result * base.clone(); - exponent -= 1; + //eprintln!("Current exponent: {:02X}", exponent); + if exponent & 1 == 1 { + let temp = &self * &result; + eprintln!("Mult"); + eprintln!("After mod: {:?}", temp); + + result = temp + } + let temp_square = &self * &self; + eprintln!("Square"); + + eprintln!("After squaring: {:?}", temp_square); + self = temp_square; + //eprintln!("After mod: {:?}", self); + exponent >>= 1; } + eprintln!("result in powmod before reduction: {:02X?}", result); + + eprintln!("result in powmod after reduction: {:02X?}", result); + result } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index e624361..642be5c 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -56,19 +56,63 @@ impl Polynomial { output } - pub fn pow(&self, mut exponent: u128) -> Polynomial { - if exponent == 0 { - return Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); + 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 { + eprintln!("special case 1: {:02X?}", self.clone()); + + return self; } - let base = self.clone(); - let mut result = base.clone(); - exponent -= 1; + if exponent == 0 { + let result = Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); + + eprintln!("Returned value is: {:02X?}", result); + return result; + } + + //eprintln!("Initial result: {:?}", result); while exponent > 0 { - result = result * base.clone(); - exponent -= 1; + //eprintln!("Current exponent: {:02X}", exponent); + if exponent & 1 == 1 { + let temp = &self * &result; + eprintln!("Mult"); + eprintln!("After mod: {:?}", temp); + + result = temp + } + let temp_square = &self * &self; + eprintln!("Square"); + + eprintln!("After squaring: {:?}", temp_square); + self = temp_square; + //eprintln!("After mod: {:?}", self); + exponent >>= 1; + } + + eprintln!("result in powmod before reduction: {:02X?}", result); + + while !result.polynomial.is_empty() + && result + .polynomial + .last() + .unwrap() + .as_ref() + .iter() + .all(|&x| x == 0) + { + result.polynomial.pop(); + } + + eprintln!("result in powmod after reduction: {:02X?}", result); + + if result.is_empty() { + result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); } result @@ -237,6 +281,18 @@ impl Polynomial { self } + + 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) + } } impl Clone for Polynomial { @@ -1112,4 +1168,29 @@ mod tests { 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); + } } From 5bb9bcebff5f649818da9ef1ad514c411d16351d Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 21:16:53 +0100 Subject: [PATCH 056/105] feat: ready test runner for monic and sqrt tasks --- src/tasks/mod.rs | 15 +++++++++++++- src/tasks/tasks01/pfmath.rs | 16 +++++++++++++++ src/utils/field.rs | 12 +++++------ src/utils/poly.rs | 40 ++++++++++++++++--------------------- 4 files changed, 53 insertions(+), 30 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 9d24f8b..87ca189 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,7 +9,8 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, + gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, + gfpoly_sort, gfpoly_sqrt, }, poly2block::poly2block, sea128::sea128, @@ -132,6 +133,18 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_make_monic" => { + let result = gfpoly_make_monic(args)?; + let json = json!({"S" : result.to_c_array()}); + + Ok(json) + } + "gfpoly_sqrt" => { + let result = gfpoly_sqrt(args)?; + let json = json!({"S" : result.to_c_array()}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 9fb7014..9a9859c 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -81,6 +81,22 @@ pub fn gfpoly_sort(args: &Value) -> Result> { Ok(polys) } +pub fn gfpoly_make_monic(args: &Value) -> Result { + let mut poly_a = Polynomial::from_c_array(&args["A"].clone()); + + poly_a.monic(); + + Ok(poly_a) +} + +pub fn gfpoly_sqrt(args: &Value) -> Result { + let poly_a = Polynomial::from_c_array(&args["Q"].clone()); + + let result = poly_a.sqrt(); + + Ok(result) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/field.rs b/src/utils/field.rs index 184b2c6..28f7bb5 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -58,23 +58,23 @@ impl FieldElement { //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - eprintln!("Mult"); - eprintln!("After mod: {:?}", temp); + //eprintln!("Mult"); + //eprintln!("After mod: {:?}", temp); result = temp } let temp_square = &self * &self; - eprintln!("Square"); + // eprintln!("Square"); - eprintln!("After squaring: {:?}", temp_square); + // eprintln!("After squaring: {:?}", temp_square); self = temp_square; //eprintln!("After mod: {:?}", self); exponent >>= 1; } - eprintln!("result in powmod before reduction: {:02X?}", result); + // eprintln!("result in powmod before reduction: {:02X?}", result); - eprintln!("result in powmod after reduction: {:02X?}", result); + // eprintln!("result in powmod after reduction: {:02X?}", result); result } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 642be5c..fa4b343 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -81,21 +81,21 @@ impl Polynomial { //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - eprintln!("Mult"); - eprintln!("After mod: {:?}", temp); + //eprintln!("Mult"); + //eprintln!("After mod: {:?}", temp); result = temp } let temp_square = &self * &self; - eprintln!("Square"); + //eprintln!("Square"); - eprintln!("After squaring: {:?}", temp_square); + //eprintln!("After squaring: {:?}", temp_square); self = temp_square; //eprintln!("After mod: {:?}", self); exponent >>= 1; } - eprintln!("result in powmod before reduction: {:02X?}", result); + //eprintln!("result in powmod before reduction: {:02X?}", result); while !result.polynomial.is_empty() && result @@ -109,7 +109,7 @@ impl Polynomial { result.polynomial.pop(); } - eprintln!("result in powmod after reduction: {:02X?}", result); + //eprintln!("result in powmod after reduction: {:02X?}", result); if result.is_empty() { result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); @@ -256,7 +256,7 @@ impl Polynomial { true } - fn monic(mut self) -> Self { + pub fn monic(&mut self) { let divident = self.polynomial.last().unwrap().clone(); for fieldelement in &mut self.polynomial.iter_mut() { @@ -274,15 +274,9 @@ impl Polynomial { { self.polynomial.pop(); } - - if self.is_empty() { - self = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); - } - - self } - fn sqrt(self) -> Self { + pub fn sqrt(self) -> Self { let mut result = vec![]; for (position, element) in self.polynomial.iter().enumerate() { @@ -1135,22 +1129,22 @@ mod tests { "1Ial5rAJGOucIdUe3zh5bw==", "gAAAAAAAAAAAAAAAAAAAAA==" ]); - let element1: Polynomial = Polynomial::from_c_array(&json1); + let mut element1: Polynomial = Polynomial::from_c_array(&json1); - let result = element1.monic(); + element1.monic(); - assert_eq!(json!(result.to_c_array()), expected); + assert_eq!(json!(element1.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 mut element1: Polynomial = Polynomial::from_c_array(&json1); - let result = element1.monic(); + element1.monic(); - assert_eq!(json!(result.to_c_array()), expected); + assert_eq!(json!(element1.to_c_array()), expected); } #[test] @@ -1162,11 +1156,11 @@ mod tests { "AAAAAAAAAAAAAAAAAAAAAA==" ]); let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]); - let element1: Polynomial = Polynomial::from_c_array(&json1); + let mut element1: Polynomial = Polynomial::from_c_array(&json1); - let result = element1.monic(); + element1.monic(); - assert_eq!(json!(result.to_c_array()), expected); + assert_eq!(json!(element1.to_c_array()), expected); } #[test] From 1290adcd9b7b699a0d2b06dece06e8dcc285024d Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 22 Nov 2024 21:34:01 +0100 Subject: [PATCH 057/105] fix: Fix error in calling of monic function --- src/tasks/tasks01/pfmath.rs | 6 +++--- src/utils/poly.rs | 25 +++++++++++++++---------- 2 files changed, 18 insertions(+), 13 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 9a9859c..b1e7516 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -82,11 +82,11 @@ pub fn gfpoly_sort(args: &Value) -> Result> { } pub fn gfpoly_make_monic(args: &Value) -> Result { - let mut poly_a = Polynomial::from_c_array(&args["A"].clone()); + let poly_a = Polynomial::from_c_array(&args["A"].clone()); - poly_a.monic(); + let result = poly_a.monic(); - Ok(poly_a) + Ok(result) } pub fn gfpoly_sqrt(args: &Value) -> Result { diff --git a/src/utils/poly.rs b/src/utils/poly.rs index fa4b343..f56abf4 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -256,7 +256,7 @@ impl Polynomial { true } - pub fn monic(&mut self) { + pub fn monic(mut self) -> Self { let divident = self.polynomial.last().unwrap().clone(); for fieldelement in &mut self.polynomial.iter_mut() { @@ -274,6 +274,11 @@ impl Polynomial { { self.polynomial.pop(); } + + if self.is_empty() { + self = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } + self } pub fn sqrt(self) -> Self { @@ -1129,22 +1134,22 @@ mod tests { "1Ial5rAJGOucIdUe3zh5bw==", "gAAAAAAAAAAAAAAAAAAAAA==" ]); - let mut element1: Polynomial = Polynomial::from_c_array(&json1); + let element1: Polynomial = Polynomial::from_c_array(&json1); - element1.monic(); + let result = element1.monic(); - assert_eq!(json!(element1.to_c_array()), expected); + assert_eq!(json!(result.to_c_array()), expected); } #[test] fn test_poly_monic_poly_zero() { let json1 = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]); let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]); - let mut element1: Polynomial = Polynomial::from_c_array(&json1); + let element1: Polynomial = Polynomial::from_c_array(&json1); - element1.monic(); + let result = element1.monic(); - assert_eq!(json!(element1.to_c_array()), expected); + assert_eq!(json!(result.to_c_array()), expected); } #[test] @@ -1156,11 +1161,11 @@ mod tests { "AAAAAAAAAAAAAAAAAAAAAA==" ]); let expected = json!(["AAAAAAAAAAAAAAAAAAAAAA=="]); - let mut element1: Polynomial = Polynomial::from_c_array(&json1); + let element1: Polynomial = Polynomial::from_c_array(&json1); - element1.monic(); + let result = element1.monic(); - assert_eq!(json!(element1.to_c_array()), expected); + assert_eq!(json!(result.to_c_array()), expected); } #[test] From b595276143b311e1b7afb90a9ab500dde3bc202b Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 09:44:47 +0100 Subject: [PATCH 058/105] fix: Fix incorrect naming of response json object for monic --- src/tasks/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 87ca189..2cc97b7 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -135,7 +135,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } "gfpoly_make_monic" => { let result = gfpoly_make_monic(args)?; - let json = json!({"S" : result.to_c_array()}); + let json = json!({"A*" : result.to_c_array()}); Ok(json) } From 4b1bca8ee023824e45ea17c1bf5f279d110c0551 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 10:17:08 +0100 Subject: [PATCH 059/105] feat: add function for polynomial differentiation --- src/tasks/mod.rs | 10 +++++-- src/tasks/tasks01/pfmath.rs | 8 ++++++ src/utils/field.rs | 4 +++ src/utils/poly.rs | 54 +++++++++++++++++++++++-------------- test_json/sandbox.json | 15 +++++++++++ 5 files changed, 69 insertions(+), 22 deletions(-) create mode 100644 test_json/sandbox.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 2cc97b7..e72b502 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,8 +9,8 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_divmod, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, - gfpoly_sort, gfpoly_sqrt, + gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, + gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, }, poly2block::poly2block, sea128::sea128, @@ -145,6 +145,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_diff" => { + let result = gfpoly_diff(args)?; + let json = json!({"F'" : result.to_c_array()}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index b1e7516..3da23fc 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -97,6 +97,14 @@ pub fn gfpoly_sqrt(args: &Value) -> Result { 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) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/field.rs b/src/utils/field.rs index 28f7bb5..ce0b8a4 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -24,6 +24,10 @@ impl FieldElement { 87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01, ]; + pub fn zero(self) -> Self { + FieldElement::new(vec![0]) + } + pub const fn new(field_element: Vec) -> Self { Self { field_element } } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index f56abf4..8dc0105 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -292,6 +292,19 @@ impl Polynomial { Polynomial::new(result) } + + pub fn diff(mut self) -> Self { + // Pop first element + self.polynomial.remove(0); + + for (position, element) in self.polynomial.iter_mut().enumerate() { + if position % 2 == 1 { + *element = FieldElement::new(vec![0; 16]); + } + } + + self + } } impl Clone for Polynomial { @@ -645,26 +658,6 @@ mod tests { // 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; @@ -1192,4 +1185,25 @@ mod tests { 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); + } } diff --git a/test_json/sandbox.json b/test_json/sandbox.json new file mode 100644 index 0000000..8a670d3 --- /dev/null +++ b/test_json/sandbox.json @@ -0,0 +1,15 @@ +{ + "testcases": { + "sandbox": { + "action": "gfpoly_diff", + "arguments": { + "F": [ + "IJustWannaTellYouAAAAA==", + "HowImFeelingAAAAAAAAAA==", + "GottaMakeYouAAAAAAAAAA==", + "UnderstaaaaaaaaaaaaanQ==" + ] + } + } + } +} From 8be8dc7a5464842dae3cbb90cbb295a0f3f40d66 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 10:26:32 +0100 Subject: [PATCH 060/105] feat: Add edge case handling for poly diff Add handling for cases in which poly is of degree 0 or 1 --- src/utils/poly.rs | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 8dc0105..8c5c51a 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -295,9 +295,17 @@ impl Polynomial { pub fn diff(mut self) -> Self { // Pop first element - self.polynomial.remove(0); + // 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]); } @@ -1206,4 +1214,16 @@ mod tests { 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); + } } From 1a2910b28fcd8ff92d9d685ba085baa40c311add Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 11:42:05 +0100 Subject: [PATCH 061/105] fix: Add removal of leading zeros in poly diff --- src/utils/poly.rs | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 8c5c51a..f999351 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -311,6 +311,22 @@ impl Polynomial { } } + 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 } } @@ -1226,4 +1242,22 @@ mod tests { 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); + eprintln!("Starting poly sqrt"); + + let result = element1.diff(); + + assert_eq!(json!(result.to_c_array()), expected); + } } From 0b18ba1bffa822349678c77801d0bb21175aeea1 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 12:31:27 +0100 Subject: [PATCH 062/105] feat: Adding gcd implementation --- src/tasks/mod.rs | 10 ++++-- src/tasks/tasks01/pfmath.rs | 14 ++++++++- src/utils/poly.rs | 62 +++++++++++++++++++++++++++++++++++++ test_json/sandbox.json | 25 +++++++++++---- 4 files changed, 102 insertions(+), 9 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index e72b502..0613d93 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,8 +9,8 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, - gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, + gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_gcd, gfpoly_make_monic, gfpoly_mul, + gfpoly_pow, gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, }, poly2block::poly2block, sea128::sea128, @@ -151,6 +151,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_gcd" => { + let result = gfpoly_gcd(args)?; + let json = json!({"G" : result.to_c_array()}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 3da23fc..ea60e78 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -2,7 +2,10 @@ use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::utils::{field::FieldElement, poly::Polynomial}; +use crate::utils::{ + field::FieldElement, + poly::{gcd, Polynomial}, +}; pub fn gfpoly_add(args: &Value) -> Result { let poly_a = Polynomial::from_c_array(&args["A"].clone()); @@ -105,6 +108,15 @@ pub fn gfpoly_diff(args: &Value) -> Result { 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, poly_b); + + Ok(result) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 8c5c51a..5b5f737 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -467,6 +467,14 @@ impl Ord for Polynomial { } } +pub fn gcd(a: Polynomial, b: Polynomial) -> Polynomial { + if a.is_zero() { + return b; + } + + return gcd(b.div(&a).1.monic(), a); +} + pub fn sort_polynomial_array(mut polys: Vec) -> Result> { // Algorithm to sort polynomials // First sorting round @@ -1226,4 +1234,58 @@ mod tests { 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); + } } diff --git a/test_json/sandbox.json b/test_json/sandbox.json index 8a670d3..48d59ed 100644 --- a/test_json/sandbox.json +++ b/test_json/sandbox.json @@ -1,13 +1,26 @@ { "testcases": { "sandbox": { - "action": "gfpoly_diff", + "action": "gfpoly_gcd", "arguments": { - "F": [ - "IJustWannaTellYouAAAAA==", - "HowImFeelingAAAAAAAAAA==", - "GottaMakeYouAAAAAAAAAA==", - "UnderstaaaaaaaaaaaaanQ==" + "A": [ + "DNWpXnnY24XecPa7a8vrEA==", + "I8uYpCbsiPaVvUznuv1IcA==", + "wsbiU432ARWuO93He3vbvA==", + "zp0g3o8iNz7Y+8oUxw1vJw==", + "J0GekE3uendpN6WUAuJ4AA==", + "wACd0e6u1ii4AAAAAAAAAA==", + "ACAAAAAAAAAAAAAAAAAAAA==" + ], + "B": [ + "I20VjJmlSnRSe88gaDiLRQ==", + "0Cw5HxJm/pfybJoQDf7/4w==", + "8ByrMMf+vVj5r3YXUNCJ1g==", + "rEU/f2UZRXqmZ6V7EPKfBA==", + "LfdALhvCrdhhGZWl9l9DSg==", + "KSUKhN0n6/DZmHPozd1prw==", + "DQrRkuA9Zx279wAAAAAAAA==", + "AhCEAAAAAAAAAAAAAAAAAA==" ] } } From 69a2026c843a278c2a1b2f48e0aced63ba0f89de Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 13:33:51 +0100 Subject: [PATCH 063/105] fix: Make all polynomials monic in task fn --- src/tasks/tasks01/pfmath.rs | 2 +- src/utils/poly.rs | 16 +++++++++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index ea60e78..4fc686e 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -112,7 +112,7 @@ 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, poly_b); + let result = gcd(poly_a.monic(), poly_b.monic()); Ok(result) } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 0be3b89..b820e01 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1267,7 +1267,7 @@ mod tests { assert_eq!(json!(result.to_c_array()), expected); } - + #[test] fn test_poly_gcd() { let a = json!([ @@ -1304,4 +1304,18 @@ mod tests { 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); + } } From 17bade8a6241163798bbd138e857f03c51197183 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 19:07:30 +0100 Subject: [PATCH 064/105] WIP: feat: Initial implementation of ssf. Sort missinf --- src/tasks/tasks01/pfmath.rs | 2 +- src/utils/dff.rs | 0 src/utils/edf.rs | 0 src/utils/field.rs | 2 +- src/utils/mod.rs | 3 ++ src/utils/poly.rs | 20 ++++---- src/utils/sff.rs | 91 +++++++++++++++++++++++++++++++++++++ 7 files changed, 108 insertions(+), 10 deletions(-) create mode 100644 src/utils/dff.rs create mode 100644 src/utils/edf.rs create mode 100644 src/utils/sff.rs diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 4fc686e..182e17d 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -112,7 +112,7 @@ 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()); + let result = gcd(&poly_a.monic(), &poly_b.monic()); Ok(result) } diff --git a/src/utils/dff.rs b/src/utils/dff.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/utils/edf.rs b/src/utils/edf.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/utils/field.rs b/src/utils/field.rs index ce0b8a4..626d40d 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -14,7 +14,7 @@ use super::{ poly::gfmul, }; -#[derive(Debug, serde::Serialize)] +#[derive(Debug, serde::Serialize, serde::Deserialize)] pub struct FieldElement { field_element: Vec, } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 298415b..35fb781 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,6 +1,9 @@ pub mod ciphers; +pub mod dff; +pub mod edf; pub mod field; pub mod math; pub mod net; pub mod parse; pub mod poly; +pub mod sff; diff --git a/src/utils/poly.rs b/src/utils/poly.rs index b820e01..b4a1060 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -12,7 +12,7 @@ use serde_json::Value; use super::field::FieldElement; -#[derive(Debug, serde::Serialize)] +#[derive(Debug, serde::Serialize, serde::Deserialize)] pub struct Polynomial { polynomial: Vec, } @@ -178,13 +178,16 @@ impl Polynomial { } // Returns (quotient, remainder) - pub fn div(self, rhs: &Self) -> (Self, Self) { + pub fn div(&self, rhs: &Self) -> (Self, Self) { // Div by zero check ommitted since data is guaranteed to be non 0 eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); if self.polynomial.len() < rhs.polynomial.len() { - return (Polynomial::new(vec![FieldElement::new(vec![0; 16])]), self); + return ( + Polynomial::new(vec![FieldElement::new(vec![0; 16])]), + self.clone(), + ); } let mut remainder = self.clone(); @@ -483,12 +486,13 @@ impl Ord for Polynomial { } } -pub fn gcd(a: Polynomial, b: Polynomial) -> Polynomial { +pub fn gcd(a: &Polynomial, b: &Polynomial) -> Polynomial { if a.is_zero() { - return b; + return b.clone(); } - return gcd(b.div(&a).1.monic(), a); + let monic_b = b.div(&a).1.monic(); + return gcd(&monic_b, a); } pub fn sort_polynomial_array(mut polys: Vec) -> Result> { @@ -1300,7 +1304,7 @@ mod tests { let a: Polynomial = Polynomial::from_c_array(&a); let b: Polynomial = Polynomial::from_c_array(&b); - let result = gcd(a.monic(), b.monic()); + let result = gcd(&a.monic(), &b.monic()); assert_eq!(json!(result.to_c_array()), expected); } @@ -1314,7 +1318,7 @@ mod tests { let a: Polynomial = Polynomial::from_c_array(&a); let b: Polynomial = Polynomial::from_c_array(&b); - let result = gcd(a.monic(), b.monic()); + let result = gcd(&a.monic(), &b.monic()); assert_eq!(json!(result.to_c_array()), expected); } diff --git a/src/utils/sff.rs b/src/utils/sff.rs new file mode 100644 index 0000000..fc0705a --- /dev/null +++ b/src/utils/sff.rs @@ -0,0 +1,91 @@ +use serde::{Deserialize, Serialize}; + +use crate::utils::{ + field::FieldElement, + poly::{gcd, polynomial_2_block}, +}; + +use super::poly::Polynomial; + +#[derive(Debug, Serialize, Deserialize)] +struct Factors { + factor: Vec, + exponent: u32, +} + +pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { + let mut c = gcd(&f, &f.clone().diff()); + f = f.div(&c).0; + let mut z: Vec<(Polynomial, u32)> = vec![]; + let mut e: u32 = 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 factors = sff(poly_f); + let mut result: Vec = vec![]; + + for (factor, exponent) in factors { + result.push(Factors { + factor: factor.to_c_array(), + exponent, + }); + } + + println!("{:?}", result.sort()); + let bit_indices: Vec = vec![0]; + assert!(false) + } +} From 2d4f7a111033c23d6007144f928422d9db186256 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 23 Nov 2024 19:20:25 +0100 Subject: [PATCH 065/105] feat: sff working in testcase --- src/utils/sff.rs | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/src/utils/sff.rs b/src/utils/sff.rs index fc0705a..04eb439 100644 --- a/src/utils/sff.rs +++ b/src/utils/sff.rs @@ -1,3 +1,5 @@ +use std::usize; + use serde::{Deserialize, Serialize}; use crate::utils::{ @@ -10,13 +12,13 @@ use super::poly::Polynomial; #[derive(Debug, Serialize, Deserialize)] struct Factors { factor: Vec, - exponent: u32, + exponent: usize, } -pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { +pub fn sff(mut f: Polynomial) -> Vec { let mut c = gcd(&f, &f.clone().diff()); f = f.div(&c).0; - let mut z: Vec<(Polynomial, u32)> = vec![]; + let mut z: Vec = vec![]; let mut e: u32 = 1; let one_element = Polynomial::new(vec![FieldElement::new( @@ -26,7 +28,7 @@ pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { while f != one_element { let y = gcd(&f, &c); if f != y { - z.push(((f.div(&y).0), e)); + z.push(f.div(&y).0); } f = y.clone(); @@ -36,8 +38,8 @@ pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { if c != one_element { let r = sff(c.sqrt()); - for (f_star, e_star) in r { - z.push((f_star, 2 * e_star)); + for f_star in r { + z.push(f_star); } } @@ -74,17 +76,19 @@ mod tests { ]); let poly_f = Polynomial::from_c_array(&json_f); - let factors = sff(poly_f); + let mut factors = sff(poly_f); + factors.sort(); + let mut result: Vec = vec![]; - for (factor, exponent) in factors { + for (exponent, factor) in factors.iter().enumerate() { result.push(Factors { - factor: factor.to_c_array(), - exponent, + factor: factor.clone().to_c_array(), + exponent: exponent + 1, }); } - println!("{:?}", result.sort()); + println!("{:?}", result); let bit_indices: Vec = vec![0]; assert!(false) } From 1c9948ac6210142416ef22800cbe43642efbcc46 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sun, 24 Nov 2024 14:07:37 +0100 Subject: [PATCH 066/105] fix: Change sff to use the exponent as a tuple again --- src/utils/sff.rs | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/utils/sff.rs b/src/utils/sff.rs index 04eb439..f2478b5 100644 --- a/src/utils/sff.rs +++ b/src/utils/sff.rs @@ -1,5 +1,3 @@ -use std::usize; - use serde::{Deserialize, Serialize}; use crate::utils::{ @@ -12,13 +10,13 @@ use super::poly::Polynomial; #[derive(Debug, Serialize, Deserialize)] struct Factors { factor: Vec, - exponent: usize, + exponent: u32, } -pub fn sff(mut f: Polynomial) -> Vec { +pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { let mut c = gcd(&f, &f.clone().diff()); f = f.div(&c).0; - let mut z: Vec = vec![]; + let mut z: Vec<(Polynomial, u32)> = vec![]; let mut e: u32 = 1; let one_element = Polynomial::new(vec![FieldElement::new( @@ -28,7 +26,7 @@ pub fn sff(mut f: Polynomial) -> Vec { while f != one_element { let y = gcd(&f, &c); if f != y { - z.push(f.div(&y).0); + z.push(((f.div(&y).0), e)); } f = y.clone(); @@ -38,8 +36,8 @@ pub fn sff(mut f: Polynomial) -> Vec { if c != one_element { let r = sff(c.sqrt()); - for f_star in r { - z.push(f_star); + for (f_star, e_star) in r { + z.push((f_star, 2 * e_star)); } } @@ -78,13 +76,12 @@ mod tests { let mut factors = sff(poly_f); factors.sort(); - let mut result: Vec = vec![]; - for (exponent, factor) in factors.iter().enumerate() { + for (factor, exponent) in factors { result.push(Factors { - factor: factor.clone().to_c_array(), - exponent: exponent + 1, + factor: factor.to_c_array(), + exponent, }); } From 6856420ff90e66a866d29e5019906f22bf335582 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Mon, 25 Nov 2024 14:19:41 +0100 Subject: [PATCH 067/105] feat: Add task runner for the sff task --- src/tasks/mod.rs | 10 ++++++++-- src/tasks/tasks01/pfmath.rs | 18 ++++++++++++++++++ src/utils/dff.rs | 10 ++++++++++ src/utils/poly.rs | 4 ++++ src/utils/sff.rs | 6 +++--- test_json/sandbox.json | 38 ++++++++++++++++++------------------- 6 files changed, 62 insertions(+), 24 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 0613d93..2c3a428 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,8 +9,8 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_gcd, gfpoly_make_monic, gfpoly_mul, - gfpoly_pow, gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, + gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_factor_sff, gfpoly_gcd, + gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, }, poly2block::poly2block, sea128::sea128, @@ -157,6 +157,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_factor_sff" => { + let result = gfpoly_factor_sff(args)?; + let json = json!({"factors" : result}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 182e17d..b9067cc 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -5,6 +5,7 @@ use serde_json::Value; use crate::utils::{ field::FieldElement, poly::{gcd, Polynomial}, + sff::{sff, Factors}, }; pub fn gfpoly_add(args: &Value) -> Result { @@ -117,6 +118,23 @@ pub fn gfpoly_gcd(args: &Value) -> Result { 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) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/dff.rs b/src/utils/dff.rs index e69de29..575d9de 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -0,0 +1,10 @@ +use super::poly::Polynomial; + +pub fn dff(f: Polynomial) { + let q = 2u128.pow(128); + let z: Vec<(Polynomial, u32)> = vec![]; + let d = 1; + let f_start = f.clone(); + + while f_start.degree() >= 2 * d {} +} diff --git a/src/utils/poly.rs b/src/utils/poly.rs index b4a1060..786c67a 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -22,6 +22,10 @@ impl Polynomial { Self { polynomial } } + pub fn degree(&self) -> usize { + self.polynomial.len() + } + pub fn from_c_array(array: &Value) -> Self { let mut polynomial: Vec = vec![]; let c_array: Vec = array diff --git a/src/utils/sff.rs b/src/utils/sff.rs index f2478b5..f8f1358 100644 --- a/src/utils/sff.rs +++ b/src/utils/sff.rs @@ -8,9 +8,9 @@ use crate::utils::{ use super::poly::Polynomial; #[derive(Debug, Serialize, Deserialize)] -struct Factors { - factor: Vec, - exponent: u32, +pub struct Factors { + pub factor: Vec, + pub exponent: u32, } pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { diff --git a/test_json/sandbox.json b/test_json/sandbox.json index 48d59ed..007d487 100644 --- a/test_json/sandbox.json +++ b/test_json/sandbox.json @@ -1,26 +1,26 @@ { "testcases": { "sandbox": { - "action": "gfpoly_gcd", + "action": "gfpoly_factor_sff", "arguments": { - "A": [ - "DNWpXnnY24XecPa7a8vrEA==", - "I8uYpCbsiPaVvUznuv1IcA==", - "wsbiU432ARWuO93He3vbvA==", - "zp0g3o8iNz7Y+8oUxw1vJw==", - "J0GekE3uendpN6WUAuJ4AA==", - "wACd0e6u1ii4AAAAAAAAAA==", - "ACAAAAAAAAAAAAAAAAAAAA==" - ], - "B": [ - "I20VjJmlSnRSe88gaDiLRQ==", - "0Cw5HxJm/pfybJoQDf7/4w==", - "8ByrMMf+vVj5r3YXUNCJ1g==", - "rEU/f2UZRXqmZ6V7EPKfBA==", - "LfdALhvCrdhhGZWl9l9DSg==", - "KSUKhN0n6/DZmHPozd1prw==", - "DQrRkuA9Zx279wAAAAAAAA==", - "AhCEAAAAAAAAAAAAAAAAAA==" + "F": [ + "vL77UwAAAAAAAAAAAAAAAA==", + "mEHchYAAAAAAAAAAAAAAAA==", + "9WJa0MAAAAAAAAAAAAAAAA==", + "akHfwWAAAAAAAAAAAAAAAA==", + "E12o/QAAAAAAAAAAAAAAAA==", + "vKJ/FgAAAAAAAAAAAAAAAA==", + "yctWwAAAAAAAAAAAAAAAAA==", + "c1BXYAAAAAAAAAAAAAAAAA==", + "o0AtAAAAAAAAAAAAAAAAAA==", + "AbP2AAAAAAAAAAAAAAAAAA==", + "k2YAAAAAAAAAAAAAAAAAAA==", + "vBYAAAAAAAAAAAAAAAAAAA==", + "dSAAAAAAAAAAAAAAAAAAAA==", + "69gAAAAAAAAAAAAAAAAAAA==", + "VkAAAAAAAAAAAAAAAAAAAA==", + "a4AAAAAAAAAAAAAAAAAAAA==", + "gAAAAAAAAAAAAAAAAAAAAA==" ] } } From 341b22e18422c847affd2bf9f8063cadd6a55480 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 26 Nov 2024 13:19:07 +0100 Subject: [PATCH 068/105] feat: Add ddf algorithm --- Cargo.toml | 1 + src/tasks/mod.rs | 11 ++++- src/tasks/tasks01/pfmath.rs | 32 ++++++++++++-- src/utils/dff.rs | 85 ++++++++++++++++++++++++++++++++++--- src/utils/poly.rs | 77 +++++++++++++++++++++++++++++++++ 5 files changed, 193 insertions(+), 13 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e127c7e..8582eed 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,7 @@ base64 = "0.22" openssl = "0.10" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" +num = "0.4" [source.crates-io] replace-with = "vendored-sources" diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 2c3a428..a129f04 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,8 +9,9 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_factor_sff, gfpoly_gcd, - gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, gfpoly_sqrt, + gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_factor_ddf, gfpoly_factor_sff, + gfpoly_gcd, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, + gfpoly_sqrt, }, poly2block::poly2block, sea128::sea128, @@ -163,6 +164,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_factor_ddf" => { + let result = gfpoly_factor_ddf(args)?; + let json = json!({"factors" : result}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index b9067cc..dec3b6e 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -1,11 +1,18 @@ +use std::usize; + use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::utils::{ - field::FieldElement, - poly::{gcd, Polynomial}, - sff::{sff, Factors}, +use crate::{ + tasks, + utils::{ + self, + dff::ddf, + field::FieldElement, + poly::{gcd, Polynomial}, + sff::{sff, Factors}, + }, }; pub fn gfpoly_add(args: &Value) -> Result { @@ -135,6 +142,23 @@ pub fn gfpoly_factor_sff(arsg: &Value) -> Result> { 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) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 575d9de..6335d27 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -1,10 +1,81 @@ -use super::poly::Polynomial; +use std::usize; -pub fn dff(f: Polynomial) { - let q = 2u128.pow(128); - let z: Vec<(Polynomial, u32)> = vec![]; - let d = 1; - let f_start = f.clone(); +use num::{pow::Pow, traits::ToBytes, BigUint, FromPrimitive}; +use serde::{Deserialize, Serialize}; - while f_start.degree() >= 2 * d {} +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, usize)> { + let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128); + eprintln!("q: {:?}", q); + + let mut z: Vec<(Polynomial, usize)> = vec![]; + let mut d: u32 = 1; + let mut f_star = f.clone(); + + let one_cmp = Polynomial::one(); + while f_star.degree() >= (2 * d) as usize { + let h = Polynomial::x().bpow_mod(q.clone().pow(d), f_star.clone()) + + Polynomial::x().div(&f_star).1; + + let g = gcd(&h, &f_star); + if g != one_cmp { + z.push((g.clone(), d as usize)); + f_star = f_star.div(&g).0; + } + + d += 1; + } + if f_star != one_cmp { + z.push((f_star.clone(), f_star.degree())); + } 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/poly.rs b/src/utils/poly.rs index 786c67a..42e6916 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,5 +1,7 @@ use crate::utils::field::ByteArray; +use base64::alphabet::BIN_HEX; use base64::prelude::*; +use num::{BigInt, BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; use std::{ @@ -26,6 +28,23 @@ impl Polynomial { self.polynomial.len() } + pub fn one() -> Self { + Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]) + } + + pub fn x() -> Self { + Polynomial::new(vec![ + FieldElement::new(vec![0; 16]), + FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()), + ]) + } + + pub fn zero() -> Self { + Polynomial::new(vec![FieldElement::new(vec![0; 16])]) + } + pub fn from_c_array(array: &Value) -> Self { let mut polynomial: Vec = vec![]; let c_array: Vec = array @@ -122,6 +141,64 @@ impl Polynomial { 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() { + eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); + + return self.div(&modulus).1; + } + + if exponent == BigUint::zero() { + let result = Polynomial::new(vec![FieldElement::new( + polynomial_2_block(vec![0], "gcm").unwrap(), + )]); + + eprintln!("Returned value is: {:02X?}", result); + return result; + } + + //eprintln!("Initial result: {:?}", result); + while &exponent > &BigUint::zero() { + //eprintln!("Current exponent: {:02X}", exponent); + if &exponent & BigUint::one() == BigUint::one() { + let temp = &self * &result; + //eprintln!("After multiplication: {:?}", temp); + result = temp.div(&modulus).1; + //eprintln!("After mod: {:?}", result); + } + let temp_square = &self * &self; + //eprintln!("After squaring: {:?}", temp_square); + self = temp_square.div(&modulus).1; + //eprintln!("After mod: {:?}", self); + exponent >>= 1; + } + + eprintln!("result in powmod before reduction: {:02X?}", result); + + while !result.polynomial.is_empty() + && result + .polynomial + .last() + .unwrap() + .as_ref() + .iter() + .all(|&x| x == 0) + { + result.polynomial.pop(); + } + + eprintln!("result in powmod after reduction: {:02X?}", result); + + if result.is_empty() { + result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + } + + 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(), From b54753fe7e2bd80494d15bc5c0cc2a4c2ada1571 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 26 Nov 2024 14:55:40 +0100 Subject: [PATCH 069/105] fix: Remove mod from X subtrahend in dff The modular operation is likely incorrect in this case. Removig it. --- src/utils/dff.rs | 13 ++++++------- src/utils/sff.rs | 8 ++++---- test_json/sandbox.json | 23 +++++++---------------- 3 files changed, 17 insertions(+), 27 deletions(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 6335d27..2cd754e 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -11,29 +11,28 @@ pub struct Factors { pub degree: u32, } -pub fn ddf(f: Polynomial) -> Vec<(Polynomial, usize)> { +pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128); eprintln!("q: {:?}", q); - let mut z: Vec<(Polynomial, usize)> = vec![]; - let mut d: u32 = 1; + 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() >= (2 * d) as usize { - let h = Polynomial::x().bpow_mod(q.clone().pow(d), f_star.clone()) - + Polynomial::x().div(&f_star).1; + 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 as usize)); + 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())); + z.push((f_star.clone(), f_star.degree() as u128)); } else if z.len() == 0 { z.push((f.clone(), 1)); } diff --git a/src/utils/sff.rs b/src/utils/sff.rs index f8f1358..e7a154a 100644 --- a/src/utils/sff.rs +++ b/src/utils/sff.rs @@ -10,14 +10,14 @@ use super::poly::Polynomial; #[derive(Debug, Serialize, Deserialize)] pub struct Factors { pub factor: Vec, - pub exponent: u32, + pub exponent: u128, } -pub fn sff(mut f: Polynomial) -> Vec<(Polynomial, u32)> { +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, u32)> = vec![]; - let mut e: u32 = 1; + 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(), diff --git a/test_json/sandbox.json b/test_json/sandbox.json index 007d487..d0a0f3c 100644 --- a/test_json/sandbox.json +++ b/test_json/sandbox.json @@ -1,24 +1,15 @@ { "testcases": { "sandbox": { - "action": "gfpoly_factor_sff", + "action": "gfpoly_factor_ddf", "arguments": { "F": [ - "vL77UwAAAAAAAAAAAAAAAA==", - "mEHchYAAAAAAAAAAAAAAAA==", - "9WJa0MAAAAAAAAAAAAAAAA==", - "akHfwWAAAAAAAAAAAAAAAA==", - "E12o/QAAAAAAAAAAAAAAAA==", - "vKJ/FgAAAAAAAAAAAAAAAA==", - "yctWwAAAAAAAAAAAAAAAAA==", - "c1BXYAAAAAAAAAAAAAAAAA==", - "o0AtAAAAAAAAAAAAAAAAAA==", - "AbP2AAAAAAAAAAAAAAAAAA==", - "k2YAAAAAAAAAAAAAAAAAAA==", - "vBYAAAAAAAAAAAAAAAAAAA==", - "dSAAAAAAAAAAAAAAAAAAAA==", - "69gAAAAAAAAAAAAAAAAAAA==", - "VkAAAAAAAAAAAAAAAAAAAA==", + "tpkgAAAAAAAAAAAAAAAAAA==", + "m6MQAAAAAAAAAAAAAAAAAA==", + "8roAAAAAAAAAAAAAAAAAAA==", + "3dUAAAAAAAAAAAAAAAAAAA==", + "FwAAAAAAAAAAAAAAAAAAAA==", + "/kAAAAAAAAAAAAAAAAAAAA==", "a4AAAAAAAAAAAAAAAAAAAA==", "gAAAAAAAAAAAAAAAAAAAAA==" ] From d599292d3a758805634ac88756d4890160787528 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 27 Nov 2024 10:17:29 +0100 Subject: [PATCH 070/105] fix: Fix dff algorithm attempt --- src/utils/dff.rs | 11 ++++++++--- src/utils/field.rs | 11 ----------- src/utils/poly.rs | 6 +----- 3 files changed, 9 insertions(+), 19 deletions(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 2cd754e..19a6b63 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -1,6 +1,6 @@ use std::usize; -use num::{pow::Pow, traits::ToBytes, BigUint, FromPrimitive}; +use num::{cast::AsPrimitive, pow::Pow, traits::ToBytes, BigUint, FromPrimitive}; use serde::{Deserialize, Serialize}; use super::poly::{gcd, Polynomial}; @@ -13,25 +13,30 @@ pub struct Factors { pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128); - eprintln!("q: {:?}", q); 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() >= (2 * d) as usize { + while f_star.degree() as u128 >= (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 { + eprintln!("d is: {}", d); + eprintln!("g is: {:?}", &g.clone().to_c_array()); + z.push((g.clone(), d)); f_star = f_star.div(&g).0; } + eprintln!("d outer is: {}", d); + eprintln!("F star degree is {:?}", &f_star.degree()); d += 1; } if f_star != one_cmp { + eprintln!("fstar not one"); z.push((f_star.clone(), f_star.degree() as u128)); } else if z.len() == 0 { z.push((f.clone(), 1)); diff --git a/src/utils/field.rs b/src/utils/field.rs index 626d40d..bbdfa91 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -180,10 +180,7 @@ impl BitXor for FieldElement { impl Div for FieldElement { type Output = Self; fn div(self, rhs: Self) -> Self::Output { - eprintln!("RHS in div{:02X?}", &rhs); - let inverse = rhs.inv(); - eprintln!("Inverse in div{:02X?}", inverse); self.clone() * inverse } } @@ -202,15 +199,11 @@ impl Div for &FieldElement { 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()) { - eprintln!("Field Partial Ord Bytes: {:02X} {:02X}", byte_a, byte_b); if byte_a > byte_b { - eprintln!("Bytes were greater"); return Some(Ordering::Greater); } else if byte_a < byte_b { - eprintln!("Bytes were less"); return Some(Ordering::Less); } else { - eprintln!("Bytes were equal"); continue; } } @@ -231,15 +224,11 @@ impl Eq for FieldElement { 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()) { - eprintln!("Field Ord Bytes: {:02X} {:02X}", byte_a, byte_b); if byte_a > byte_b { - eprintln!("Bytes were greater"); return Ordering::Greater; } else if byte_a < byte_b { - eprintln!("Bytes were less"); return Ordering::Less; } else { - eprintln!("Bytes were equal"); continue; } } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 42e6916..ef625ce 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -177,8 +177,6 @@ impl Polynomial { exponent >>= 1; } - eprintln!("result in powmod before reduction: {:02X?}", result); - while !result.polynomial.is_empty() && result .polynomial @@ -191,8 +189,6 @@ impl Polynomial { result.polynomial.pop(); } - eprintln!("result in powmod after reduction: {:02X?}", result); - if result.is_empty() { result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); } @@ -262,7 +258,7 @@ impl Polynomial { pub fn div(&self, rhs: &Self) -> (Self, Self) { // Div by zero check ommitted since data is guaranteed to be non 0 - eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); + //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); if self.polynomial.len() < rhs.polynomial.len() { return ( From fa7d33aaf6c9e482092cca96ca409408d1fafe31 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 27 Nov 2024 13:47:13 +0100 Subject: [PATCH 071/105] fix: Attempting further ddf fixes --- src/utils/dff.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 19a6b63..a4ebda8 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -38,8 +38,6 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { if f_star != one_cmp { eprintln!("fstar not one"); z.push((f_star.clone(), f_star.degree() as u128)); - } else if z.len() == 0 { - z.push((f.clone(), 1)); } z From 6532c576c6737cc5500adac328de28ae03792353 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 27 Nov 2024 14:06:40 +0100 Subject: [PATCH 072/105] fix: Fix incorrect degree calculation --- src/utils/dff.rs | 3 ++- src/utils/poly.rs | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index a4ebda8..7ae23e1 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -19,7 +19,7 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { let mut f_star = f.clone(); let one_cmp = Polynomial::one(); - while f_star.degree() as u128 >= (d) { + 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); @@ -35,6 +35,7 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { d += 1; } + if f_star != one_cmp { eprintln!("fstar not one"); z.push((f_star.clone(), f_star.degree() as u128)); diff --git a/src/utils/poly.rs b/src/utils/poly.rs index ef625ce..91d96ac 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -25,7 +25,7 @@ impl Polynomial { } pub fn degree(&self) -> usize { - self.polynomial.len() + self.polynomial.len() - 1 } pub fn one() -> Self { From b898c32ded3389952710f4523cbcf4ca56260fbe Mon Sep 17 00:00:00 2001 From: Alivecow Date: Wed, 27 Nov 2024 14:13:30 +0100 Subject: [PATCH 073/105] fix: Re-Add else-if case --- src/utils/dff.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 7ae23e1..fe60b9a 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -39,6 +39,8 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { if f_star != one_cmp { eprintln!("fstar not one"); z.push((f_star.clone(), f_star.degree() as u128)); + } else if z.len() == 0 { + z.push((f.clone(), 1)); } z From 39c4d9b80d671f5cbae8c52cbe6095e1adcd6e68 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 13:17:51 +0100 Subject: [PATCH 074/105] feat: Add edf calculation --- src/utils/dff.rs | 2 +- src/utils/edf.rs | 105 +++++++++++++++++++++++++++++++++++++++++++++ src/utils/field.rs | 6 +++ src/utils/poly.rs | 20 ++++++++- 4 files changed, 131 insertions(+), 2 deletions(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index a4ebda8..da41e33 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -20,7 +20,7 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { let one_cmp = Polynomial::one(); while f_star.degree() as u128 >= (d) { - let h = Polynomial::x().bpow_mod(q.clone().pow(d), f_star.clone()) + Polynomial::x(); + let h = Polynomial::x().bpow_mod(q.clone().pow(d), &f_star) + Polynomial::x(); let g = gcd(&h, &f_star); if g != one_cmp { diff --git a/src/utils/edf.rs b/src/utils/edf.rs index e69de29..134a743 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -0,0 +1,105 @@ +use base64::{prelude::BASE64_STANDARD, Engine}; +use num::{BigUint, FromPrimitive, Integer, One}; +use rand::Rng; + +use crate::utils::{field::FieldElement, poly::non_monic_gcd}; + +use super::poly::{gcd, Polynomial}; + +pub fn edf(f: Polynomial, d: u32) -> Vec { + eprintln!("Starting edf"); + + 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 { + //eprintln!("z len {}", z.len()); + //eprintln!("n len {}", n); + + let h = Polynomial::rand(&rand::thread_rng().gen_range(0..f.degree())); + //eprintln!("h: {:02X?}", h); + + let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap(); + eprintln!("q before for {:0X?}", exponent); + + let g = h.bpow_mod(exponent, &f) + Polynomial::one(); + //eprintln!("g before for {:0X?}", g); + + //eprintln!("z before for {:0X?}", z); + + for i in 0..z.len() { + if z[i].degree() as u32 > d { + //eprintln!("Inside if"); + let j = gcd(&z[i], &g); + + eprintln!("j: {:02X?}", j); + if j != one_cmp && j != z[i] { + eprintln!("Working on Z"); + let intemediate = z[i].div(&j).0; + z.remove(i); + z.push(j.clone()); + z.push(intemediate); + } + } + } + + //eprintln!("z after for {:0X?}", z); + } + + 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 bbdfa91..2dea48b 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,4 +1,5 @@ use base64::prelude::*; +use rand::{random, Rng, RngCore}; use std::{u128, u8, usize}; use std::{ @@ -24,6 +25,11 @@ impl FieldElement { 87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01, ]; + pub fn rand() -> Self { + let rand_field: [u8; 16] = rand::random(); + FieldElement::new(rand_field.to_vec()) + } + pub fn zero(self) -> Self { FieldElement::new(vec![0]) } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index ef625ce..84194cd 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -41,6 +41,15 @@ impl Polynomial { ]) } + 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::new(vec![0; 16])]) } @@ -141,7 +150,7 @@ impl Polynomial { result } - pub fn bpow_mod(mut self, mut exponent: BigUint, modulus: Polynomial) -> Polynomial { + 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(), )]); @@ -572,6 +581,15 @@ pub fn gcd(a: &Polynomial, b: &Polynomial) -> Polynomial { return gcd(&monic_b, 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 From 444000a10168d2a3f668fc57f66db1cb53b3f025 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 13:30:44 +0100 Subject: [PATCH 075/105] fix: Adding fix after merge error --- src/utils/dff.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 2d325a0..be63040 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -21,7 +21,7 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { 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 h = Polynomial::x().bpow_mod(q.clone().pow(d), &f_star.clone()) + Polynomial::x(); let g = gcd(&h, &f_star); if g != one_cmp { From 905e905c350fd2beb5b9dbafc42968131f40ccef Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 13:36:56 +0100 Subject: [PATCH 076/105] fix: Add needed dependency --- Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/Cargo.toml b/Cargo.toml index 8582eed..28fc780 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ openssl = "0.10" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" num = "0.4" +rand = "0.8" [source.crates-io] replace-with = "vendored-sources" From f7f3c44acb8d7d1bc724479b447a6e5622cc7f31 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 14:00:47 +0100 Subject: [PATCH 077/105] feat: Add testing runner for edf --- src/tasks/mod.rs | 12 +++++++++--- src/tasks/tasks01/pfmath.rs | 18 ++++++++++++++++++ 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index a129f04..84a4f31 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -9,9 +9,9 @@ use tasks01::{ gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ - gfdiv, gfpoly_add, gfpoly_diff, gfpoly_divmod, gfpoly_factor_ddf, gfpoly_factor_sff, - gfpoly_gcd, gfpoly_make_monic, gfpoly_mul, gfpoly_pow, gfpoly_powmod, gfpoly_sort, - gfpoly_sqrt, + 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, @@ -170,6 +170,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gfpoly_factor_edf" => { + let result = gfpoly_factor_edf(args)?; + let json = json!({"factors" : result}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index dec3b6e..0f5d134 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -9,6 +9,7 @@ use crate::{ utils::{ self, dff::ddf, + edf::edf, field::FieldElement, poly::{gcd, Polynomial}, sff::{sff, Factors}, @@ -159,6 +160,23 @@ pub fn gfpoly_factor_ddf(arsg: &Value) -> Result> { 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::*; From dd19c90ae12045774321d3d369874cc92e2cb2d7 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 15:10:02 +0100 Subject: [PATCH 078/105] refactor: Apply cargo recommended refactoring --- src/tasks/tasks01/pfmath.rs | 12 ++++-------- src/utils/dff.rs | 2 +- src/utils/edf.rs | 4 +--- src/utils/field.rs | 1 - src/utils/poly.rs | 3 +-- 5 files changed, 7 insertions(+), 15 deletions(-) diff --git a/src/tasks/tasks01/pfmath.rs b/src/tasks/tasks01/pfmath.rs index 0f5d134..6830e1a 100644 --- a/src/tasks/tasks01/pfmath.rs +++ b/src/tasks/tasks01/pfmath.rs @@ -1,20 +1,16 @@ -use std::usize; use anyhow::Result; use base64::{prelude::BASE64_STANDARD, Engine}; use serde_json::Value; -use crate::{ - tasks, - utils::{ +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()); @@ -126,7 +122,7 @@ pub fn gfpoly_gcd(args: &Value) -> Result { Ok(result) } -pub fn gfpoly_factor_sff(arsg: &Value) -> 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); @@ -143,7 +139,7 @@ pub fn gfpoly_factor_sff(arsg: &Value) -> Result> { Ok(result) } -pub fn gfpoly_factor_ddf(arsg: &Value) -> 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); diff --git a/src/utils/dff.rs b/src/utils/dff.rs index be63040..bcd1ca0 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -1,6 +1,6 @@ use std::usize; -use num::{cast::AsPrimitive, pow::Pow, traits::ToBytes, BigUint, FromPrimitive}; +use num::{pow::Pow, BigUint, FromPrimitive}; use serde::{Deserialize, Serialize}; use super::poly::{gcd, Polynomial}; diff --git a/src/utils/edf.rs b/src/utils/edf.rs index 134a743..80f552c 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -1,8 +1,6 @@ -use base64::{prelude::BASE64_STANDARD, Engine}; -use num::{BigUint, FromPrimitive, Integer, One}; +use num::{BigUint, FromPrimitive, One}; use rand::Rng; -use crate::utils::{field::FieldElement, poly::non_monic_gcd}; use super::poly::{gcd, Polynomial}; diff --git a/src/utils/field.rs b/src/utils/field.rs index 2dea48b..dd2e982 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -1,5 +1,4 @@ use base64::prelude::*; -use rand::{random, Rng, RngCore}; use std::{u128, u8, usize}; use std::{ diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 48242ab..ac2b756 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,7 +1,6 @@ use crate::utils::field::ByteArray; -use base64::alphabet::BIN_HEX; use base64::prelude::*; -use num::{BigInt, BigUint, One, Zero}; +use num::{BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; use std::{ From 270abdb7b726ad37166da7b5a5685e53fe16d756 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 28 Nov 2024 17:45:10 +0100 Subject: [PATCH 079/105] refactor: Change gcd implementation to attempt faster calc --- src/utils/poly.rs | 16 ++++++++++++++-- test_json/sandbox.json | 16 ++++++++-------- 2 files changed, 22 insertions(+), 10 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 48242ab..5b4d86f 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -576,9 +576,21 @@ pub fn gcd(a: &Polynomial, b: &Polynomial) -> Polynomial { if a.is_zero() { return b.clone(); } + if b.is_zero() { + return a.clone(); + } - let monic_b = b.div(&a).1.monic(); - return gcd(&monic_b, a); + 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 { diff --git a/test_json/sandbox.json b/test_json/sandbox.json index d0a0f3c..836b3c8 100644 --- a/test_json/sandbox.json +++ b/test_json/sandbox.json @@ -1,18 +1,18 @@ { "testcases": { "sandbox": { - "action": "gfpoly_factor_ddf", + "action": "gfpoly_factor_edf", "arguments": { "F": [ - "tpkgAAAAAAAAAAAAAAAAAA==", - "m6MQAAAAAAAAAAAAAAAAAA==", - "8roAAAAAAAAAAAAAAAAAAA==", - "3dUAAAAAAAAAAAAAAAAAAA==", + "mmAAAAAAAAAAAAAAAAAAAA==", + "AbAAAAAAAAAAAAAAAAAAAA==", + "zgAAAAAAAAAAAAAAAAAAAA==", "FwAAAAAAAAAAAAAAAAAAAA==", - "/kAAAAAAAAAAAAAAAAAAAA==", - "a4AAAAAAAAAAAAAAAAAAAA==", + "AAAAAAAAAAAAAAAAAAAAAA==", + "wAAAAAAAAAAAAAAAAAAAAA==", "gAAAAAAAAAAAAAAAAAAAAA==" - ] + ], + "d": 3 } } } From 5b27a4ad9c9b1dad0ea34e94c03e4578c98243d9 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 13:49:57 +0100 Subject: [PATCH 080/105] feat/refactor: Change unneded vec initialisations and start on possible new gfmul --- src/utils/field.rs | 28 ++++++++++-------- src/utils/poly.rs | 72 +++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 81 insertions(+), 19 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 2dea48b..7b4059c 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -9,6 +9,8 @@ use std::{ use anyhow::{anyhow, Ok, Result}; +use crate::utils::poly::bgfmul; + use super::poly::polynomial_2_block; use super::{ math::{reverse_bits_in_bytevec, xor_bytes}, @@ -22,7 +24,7 @@ pub struct FieldElement { impl FieldElement { pub const IRREDUCIBLE_POLYNOMIAL: [u8; 17] = [ - 87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01, + 0x87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x01, ]; pub fn rand() -> Self { @@ -30,10 +32,14 @@ impl FieldElement { FieldElement::new(rand_field.to_vec()) } - pub fn zero(self) -> Self { + pub fn zero() -> Self { FieldElement::new(vec![0]) } + pub fn one() -> Self { + FieldElement::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) + } + pub const fn new(field_element: Vec) -> Self { Self { field_element } } @@ -47,8 +53,7 @@ impl FieldElement { } pub fn pow(mut self, mut exponent: u128) -> FieldElement { - let mut result: FieldElement = - FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()); + let mut result: FieldElement = FieldElement::one(); if exponent == 1 { eprintln!("special case 1: {:02X?}", self.clone()); @@ -57,7 +62,7 @@ impl FieldElement { } if exponent == 0 { - let result = FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()); + let result = FieldElement::one(); eprintln!("Returned value is: {:02X?}", result); return result; @@ -90,8 +95,10 @@ impl FieldElement { } pub fn inv(mut self) -> Self { - let mut inverser: u128 = 0xfffffffffffffffffffffffffffffffe; - let mut inverse: Vec = polynomial_2_block(vec![0], "gcm").unwrap(); + const INVERSER_START: u128 = 0xfffffffffffffffffffffffffffffffe; + + let mut inverser = INVERSER_START; + let mut inverse: Vec = vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; //eprintln!("Inverse start {:02X?}", inverse); while inverser > 0 { @@ -187,7 +194,7 @@ impl Div for FieldElement { type Output = Self; fn div(self, rhs: Self) -> Self::Output { let inverse = rhs.inv(); - self.clone() * inverse + self * inverse } } @@ -195,10 +202,7 @@ impl Div for &FieldElement { type Output = FieldElement; fn div(self, rhs: Self) -> Self::Output { - // First clone and invert the divisor (rhs) - let rhs_inv = rhs.clone().inv(); - // Multiply original number by the inverse - self.clone() * rhs_inv + self.clone() * rhs.clone().inv() } } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 5b4d86f..82e991a 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,6 +1,7 @@ use crate::utils::field::ByteArray; use base64::alphabet::BIN_HEX; use base64::prelude::*; +use num::traits::FromBytes; use num::{BigInt, BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; @@ -13,6 +14,7 @@ use anyhow::{anyhow, Ok, Result}; use serde_json::Value; use super::field::FieldElement; +use super::math::reverse_bits_in_bytevec; #[derive(Debug, serde::Serialize, serde::Deserialize)] pub struct Polynomial { @@ -291,10 +293,7 @@ impl Polynomial { } let mut quotient_coeffs = - vec![ - FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); - dividend_deg - divisor_deg + 1 - ]; + vec![FieldElement::new(vec![0; 16]); dividend_deg - divisor_deg + 1]; while remainder.polynomial.len() >= divisor.polynomial.len() { let deg_diff = remainder.polynomial.len() - divisor.polynomial.len(); @@ -305,8 +304,7 @@ impl Polynomial { quotient_coeffs[deg_diff] = quot_coeff.clone(); - let mut subtrahend = - vec![FieldElement::new(polynomial_2_block(vec![0; 16], "gcm").unwrap()); deg_diff]; + let mut subtrahend = vec![FieldElement::new(vec![0; 16]); deg_diff]; subtrahend.extend( divisor .polynomial @@ -658,6 +656,53 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result> { + //TODO: Implement gfmul with bigint + let red_poly_bytes: BigUint = BigUint::from_slice(&[ + 0x87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x01, + ]); + + let mut poly1: BigUint = BigUint::from_le_bytes(&reverse_bits_in_bytevec(poly_a.to_owned())); + + let mut poly2: BigUint = BigUint::from_le_bytes(&reverse_bits_in_bytevec(poly_b.to_owned())); + + /* + if semantic == "gcm" { + poly1.re; + poly2.reverse_bits_in_bytevec(); + } + */ + + let mut result: BigUint = BigUint::zero(); + + if (&poly2 & (BigUint::one() << 127)) == BigUint::one() { + result = &result ^ &poly1; + } + poly2 = &poly2 >> 1; + + while &poly2 != &BigUint::zero() { + poly1 = &poly1 << 1; + + if (&poly1 & (BigUint::one() << 127)) == BigUint::one() { + poly1 = &poly1 ^ &red_poly_bytes; + } + + if &poly2 & BigUint::one() == BigUint::one() { + result = &result ^ &poly1; + } + + poly2 = &poly2 >> 1; + } + + /* + if semantic == "gcm" { + result.reverse_bits_in_bytevec(); + } + */ + + Ok(reverse_bits_in_bytevec(result.to_bytes_le())) +} + pub fn convert_gcm_to_xex(gcm_poly: Vec) -> Result> { let xex_poly = gcm_poly .into_iter() @@ -795,7 +840,7 @@ pub fn coefficient_to_binary(coefficients: Vec) -> u128 { #[cfg(test)] mod tests { - use crate::utils::poly::b64_2_num; + use crate::utils::poly::{b64_2_num, gcd}; use anyhow::Result; use serde_json::json; // Note this useful idiom: importing names from outer (for mod tests) scope. @@ -1429,4 +1474,17 @@ mod tests { 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); + } } From e8c9cb1ade5853862f2bf63c5902580f2e61b51a Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 14:31:52 +0100 Subject: [PATCH 081/105] refactor: Imrpove gfmul to remove unneded vec manipulation and imporve performanve --- src/utils/poly.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 82e991a..eeffc34 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -613,20 +613,20 @@ pub const RED_POLY: u128 = 0x87000000_00000000_00000000_00000000; 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); + //red_poly_bytes.0.push(0x01); let mut poly1: ByteArray = ByteArray(poly_a.to_owned()); - poly1.0.push(0x00); + //poly1.0.push(0x00); let mut poly2: ByteArray = ByteArray(poly_b.to_owned()); - poly2.0.push(0x00); + //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, 0]); + let mut result: ByteArray = ByteArray(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); if poly2.LSB_is_one() { result.xor_byte_arrays(&poly1); @@ -634,9 +634,9 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result Date: Fri, 29 Nov 2024 16:50:19 +0100 Subject: [PATCH 082/105] refactor: Change implementation to only switch semantic once --- src/utils/field.rs | 57 ++++++++++++++++++++++++++-------------- src/utils/poly.rs | 65 +++++++++++++++------------------------------- 2 files changed, 59 insertions(+), 63 deletions(-) diff --git a/src/utils/field.rs b/src/utils/field.rs index 9b9876b..7d40732 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -28,18 +28,24 @@ impl FieldElement { pub fn rand() -> Self { let rand_field: [u8; 16] = rand::random(); - FieldElement::new(rand_field.to_vec()) + FieldElement::new_no_convert(rand_field.to_vec()) } pub fn zero() -> Self { - FieldElement::new(vec![0]) + FieldElement::new_no_convert(vec![0; 16]) } pub fn one() -> Self { - FieldElement::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) + FieldElement::new_no_convert(vec![0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) } - pub const fn new(field_element: Vec) -> Self { + 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 } } @@ -48,7 +54,7 @@ impl FieldElement { } pub fn to_b64(&self) -> String { - BASE64_STANDARD.encode(&self.field_element) + BASE64_STANDARD.encode(reverse_bits_in_bytevec(self.field_element.to_owned())) } pub fn pow(mut self, mut exponent: u128) -> FieldElement { @@ -97,20 +103,20 @@ impl FieldElement { const INVERSER_START: u128 = 0xfffffffffffffffffffffffffffffffe; let mut inverser = INVERSER_START; - let mut inverse: Vec = vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let mut inverse: Vec = vec![0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; //eprintln!("Inverse start {:02X?}", inverse); while inverser > 0 { //eprintln!("{:02X}", inverser); if inverser & 1 == 1 { - inverse = gfmul(&self.field_element, &inverse, "gcm").unwrap(); + inverse = gfmul(&self.field_element, &inverse, "xex").unwrap(); } inverser >>= 1; - self.field_element = gfmul(&self.field_element, &self.field_element, "gcm") + self.field_element = gfmul(&self.field_element, &self.field_element, "xex") .expect("Error in sqrmul sqr"); } //eprintln!("Inverse rhs {:?}", inverse); - FieldElement::new(inverse) + FieldElement::new_no_convert(inverse) } pub fn is_zero(&self) -> bool { @@ -118,7 +124,7 @@ impl FieldElement { } pub fn reverse_bits(&self) -> Self { - FieldElement::new(reverse_bits_in_bytevec(self.field_element.clone())) + FieldElement::new_no_convert(reverse_bits_in_bytevec(self.field_element.clone())) } } @@ -126,8 +132,8 @@ impl Mul for FieldElement { type Output = Self; fn mul(self, rhs: Self) -> Self::Output { - FieldElement::new( - gfmul(&self.field_element, &rhs.field_element, "gcm") + FieldElement::new_no_convert( + gfmul(&self.field_element, &rhs.field_element, "xex") .expect("Error during multiplication"), ) } @@ -137,8 +143,8 @@ impl Mul for &FieldElement { type Output = FieldElement; fn mul(self, rhs: &FieldElement) -> FieldElement { - FieldElement::new( - gfmul(&self.field_element, &rhs.field_element, "gcm") + FieldElement::new_no_convert( + gfmul(&self.field_element, &rhs.field_element, "xex") .expect("Error during multiplication"), ) } @@ -147,7 +153,7 @@ impl Mul for &FieldElement { impl Add for FieldElement { type Output = Self; fn add(self, rhs: Self) -> Self::Output { - FieldElement::new( + FieldElement::new_no_convert( xor_bytes(&self.field_element, rhs.field_element).expect("Error in poly add"), ) } @@ -156,7 +162,7 @@ impl Add for FieldElement { impl Add for &FieldElement { type Output = FieldElement; fn add(self, rhs: Self) -> Self::Output { - FieldElement::new( + FieldElement::new_no_convert( xor_bytes(&self.field_element, rhs.field_element.clone()).expect("Error in poly add"), ) } @@ -185,7 +191,7 @@ impl BitXor for FieldElement { .zip(rhs.field_element.iter()) .map(|(&x1, &x2)| x1 ^ x2) .collect(); - FieldElement::new(result) + FieldElement::new_no_convert(result) } } @@ -450,7 +456,7 @@ mod tests { FieldElement::new(BASE64_STANDARD.decode("KryptoanalyseAAAAAAAAA==").unwrap()); let sum = element2 + element1; - assert_eq!(BASE64_STANDARD.encode(sum), "H1d3GuyA9/0OxeYouUpAAA=="); + assert_eq!(sum.to_b64(), "H1d3GuyA9/0OxeYouUpAAA=="); } #[test] @@ -461,6 +467,19 @@ mod tests { FieldElement::new(BASE64_STANDARD.decode("DHBWMannheimAAAAAAAAAA==").unwrap()); let sum = element2 + element1; - assert_eq!(BASE64_STANDARD.encode(sum), "OZuIncPAGEp4tYouDownAA=="); + 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/poly.rs b/src/utils/poly.rs index 68edb82..0d7b122 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -32,15 +32,13 @@ impl Polynomial { } pub fn one() -> Self { - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]) + Polynomial::new(vec![FieldElement::one()]) } pub fn x() -> Self { Polynomial::new(vec![ FieldElement::new(vec![0; 16]), - FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()), + FieldElement::new(polynomial_2_block(vec![0], "xex").unwrap()), ]) } @@ -54,7 +52,7 @@ impl Polynomial { } pub fn zero() -> Self { - Polynomial::new(vec![FieldElement::new(vec![0; 16])]) + Polynomial::new(vec![FieldElement::zero()]) } pub fn from_c_array(array: &Value) -> Self { @@ -85,7 +83,7 @@ impl Polynomial { pub fn to_c_array(self) -> Vec { let mut output: Vec = vec![]; for coeff in self.polynomial { - output.push(BASE64_STANDARD.encode(coeff)); + output.push(coeff.to_b64()); } output @@ -219,9 +217,7 @@ impl Polynomial { } if exponent == 0 { - let result = Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); + let result = Polynomial::new(vec![FieldElement::one()]); eprintln!("Returned value is: {:02X?}", result); return result; @@ -273,10 +269,7 @@ impl Polynomial { //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); if self.polynomial.len() < rhs.polynomial.len() { - return ( - Polynomial::new(vec![FieldElement::new(vec![0; 16])]), - self.clone(), - ); + return (Polynomial::new(vec![FieldElement::zero()]), self.clone()); } let mut remainder = self.clone(); @@ -285,16 +278,10 @@ impl Polynomial { let divisor_deg = divisor.polynomial.len() - 1; if dividend_deg < divisor_deg { - return ( - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0; 16], "gcm").unwrap(), - )]), - remainder, - ); + return (Polynomial::new(vec![FieldElement::zero()]), remainder); } - let mut quotient_coeffs = - vec![FieldElement::new(vec![0; 16]); dividend_deg - divisor_deg + 1]; + 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(); @@ -305,7 +292,7 @@ impl Polynomial { quotient_coeffs[deg_diff] = quot_coeff.clone(); - let mut subtrahend = vec![FieldElement::new(vec![0; 16]); deg_diff]; + let mut subtrahend = vec![FieldElement::zero(); deg_diff]; subtrahend.extend( divisor .polynomial @@ -330,7 +317,7 @@ impl Polynomial { } if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + remainder = Polynomial::new(vec![FieldElement::zero()]); } (Polynomial::new(quotient_coeffs), remainder) } @@ -431,10 +418,10 @@ impl Mul for Polynomial { type Output = Self; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + 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] @@ -449,10 +436,10 @@ impl Mul for &Polynomial { type Output = Polynomial; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + 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] @@ -486,7 +473,7 @@ impl Add for Polynomial { } if polynomial.is_empty() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::new(vec![FieldElement::zero()]); } Polynomial::new(polynomial) @@ -535,8 +522,8 @@ impl PartialOrd for Polynomial { ); match field_a - .reverse_bits() - .partial_cmp(&field_b.reverse_bits()) + //.reverse_bits() + .partial_cmp(&field_b) .unwrap() { Ordering::Equal => continue, @@ -559,7 +546,10 @@ impl Ord for Polynomial { 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.reverse_bits()) { + match field_a + //.reverse_bits() + .cmp(&field_b) + { Ordering::Equal => continue, other => return other, } @@ -1136,19 +1126,6 @@ mod tests { //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } - #[test] - fn test_poly_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!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); - } - #[test] fn test_field_poly_div_01() { let json1 = json!([ From 007bbddfcd75532d995909ece70135c026ec36a5 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 17:22:47 +0100 Subject: [PATCH 083/105] fix: Fix incorrect ouput in gfdiv task --- src/tasks/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 84a4f31..d2c57b7 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -105,7 +105,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } "gfdiv" => { let result = gfdiv(args)?; - let out = BASE64_STANDARD.encode(result); + let out = result.to_b64(); let json = json!({"q" : out}); Ok(json) From bf4c3ee4ca71c928e978aafaca2083cdaa7badf7 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 19:02:37 +0100 Subject: [PATCH 084/105] refactor: Remove unneded prints and change gfmul --- Cargo.toml | 4 ++++ src/utils/ciphers.rs | 37 ------------------------------------- src/utils/edf.rs | 6 ------ src/utils/field.rs | 3 --- src/utils/poly.rs | 31 +++++-------------------------- 5 files changed, 9 insertions(+), 72 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 28fc780..9cf5fa2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,3 +18,7 @@ replace-with = "vendored-sources" [source.vendored-sources] directory = "vendor" + +[profile.profiling] +inherits = "release" +debug = true diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 35181a5..82af34b 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -119,10 +119,8 @@ pub fn gcm_encrypt_aes( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; - eprintln!("Y0 {:001X?}", auth_tag_xor); let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; @@ -133,8 +131,6 @@ pub fn gcm_encrypt_aes( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = aes_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -151,7 +147,6 @@ pub fn gcm_encrypt_aes( &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, auth_tag_xor, )?; - eprintln!("aes auth tag: {:001X?}", &auth_tag); Ok((ciphertext, auth_tag, l_field, auth_key_h)) } @@ -168,7 +163,6 @@ pub fn gcm_decrypt_aes( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; @@ -181,8 +175,6 @@ pub fn gcm_decrypt_aes( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = aes_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -201,7 +193,6 @@ pub fn gcm_decrypt_aes( )?; let valid = auth_tag == tag; - eprintln!("aes auth tag: {:001X?}", auth_tag); Ok((plaintext, valid)) } @@ -217,7 +208,6 @@ pub fn gcm_encrypt_sea( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; @@ -230,8 +220,6 @@ pub fn gcm_encrypt_sea( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = sea_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -264,7 +252,6 @@ pub fn gcm_decrypt_sea( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("Nonce 1: {:001X?}", nonce); let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; @@ -272,17 +259,11 @@ 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())?; @@ -295,15 +276,11 @@ 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)) @@ -317,10 +294,6 @@ 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()); } @@ -329,20 +302,12 @@ 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")?; - 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")?; } @@ -357,8 +322,6 @@ pub fn ghash( let inter4 = xor_bytes(&inter_loop, l_field)?; inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?; - eprintln!("GHASH auth tag: {:001X?}", inter_loop); - Ok(inter_loop) } diff --git a/src/utils/edf.rs b/src/utils/edf.rs index 80f552c..72f687d 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -1,12 +1,9 @@ use num::{BigUint, FromPrimitive, One}; use rand::Rng; - use super::poly::{gcd, Polynomial}; pub fn edf(f: Polynomial, d: u32) -> Vec { - eprintln!("Starting edf"); - 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()]; @@ -20,7 +17,6 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { //eprintln!("h: {:02X?}", h); let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap(); - eprintln!("q before for {:0X?}", exponent); let g = h.bpow_mod(exponent, &f) + Polynomial::one(); //eprintln!("g before for {:0X?}", g); @@ -32,9 +28,7 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { //eprintln!("Inside if"); let j = gcd(&z[i], &g); - eprintln!("j: {:02X?}", j); if j != one_cmp && j != z[i] { - eprintln!("Working on Z"); let intemediate = z[i].div(&j).0; z.remove(i); z.push(j.clone()); diff --git a/src/utils/field.rs b/src/utils/field.rs index 9b9876b..4876271 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -55,15 +55,12 @@ impl FieldElement { let mut result: FieldElement = FieldElement::one(); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone()); - return self; } if exponent == 0 { let result = FieldElement::one(); - eprintln!("Returned value is: {:02X?}", result); return result; } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 68edb82..3816dac 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -70,8 +70,6 @@ impl Polynomial { }) .collect(); - eprintln!("{:?}", c_array); - for coefficient in c_array { polynomial.push(FieldElement::new( BASE64_STANDARD @@ -97,8 +95,6 @@ impl Polynomial { )]); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone()); - return self; } @@ -107,7 +103,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -159,8 +154,6 @@ impl Polynomial { )]); if exponent == BigUint::one() { - eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); - return self.div(&modulus).1; } @@ -169,7 +162,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -213,8 +205,6 @@ impl Polynomial { )]); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); - return self.div(&modulus).1; } @@ -223,7 +213,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -243,8 +232,6 @@ impl Polynomial { exponent >>= 1; } - eprintln!("result in powmod before reduction: {:02X?}", result); - while !result.polynomial.is_empty() && result .polynomial @@ -257,8 +244,6 @@ impl Polynomial { result.polynomial.pop(); } - eprintln!("result in powmod after reduction: {:02X?}", result); - if result.is_empty() { result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); } @@ -528,12 +513,6 @@ impl PartialOrd for Polynomial { for (field_a, field_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { - eprintln!( - "Poly partord: {:02X?} {:02X?} ", - self.clone().to_c_array(), - other.clone().to_c_array() - ); - match field_a .reverse_bits() .partial_cmp(&field_b.reverse_bits()) @@ -616,10 +595,10 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result) -> Result> { From 2623bd9a8d9807c56c58e2ef7f83e59e000d9e62 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 19:31:10 +0100 Subject: [PATCH 085/105] refactor: Change initialisations of field elements to be cleaner --- src/utils/poly.rs | 65 +++++++++++++++-------------------------------- 1 file changed, 21 insertions(+), 44 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 3816dac..969a144 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -32,15 +32,13 @@ impl Polynomial { } pub fn one() -> Self { - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]) + Polynomial::new(vec![FieldElement::one()]) } pub fn x() -> Self { Polynomial::new(vec![ FieldElement::new(vec![0; 16]), - FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()), + FieldElement::new(polynomial_2_block(vec![0], "xex").unwrap()), ]) } @@ -54,7 +52,7 @@ impl Polynomial { } pub fn zero() -> Self { - Polynomial::new(vec![FieldElement::new(vec![0; 16])]) + Polynomial::new(vec![FieldElement::zero()]) } pub fn from_c_array(array: &Value) -> Self { @@ -83,7 +81,7 @@ impl Polynomial { pub fn to_c_array(self) -> Vec { let mut output: Vec = vec![]; for coeff in self.polynomial { - output.push(BASE64_STANDARD.encode(coeff)); + output.push(coeff.to_b64()); } output @@ -209,9 +207,7 @@ impl Polynomial { } if exponent == 0 { - let result = Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); + let result = Polynomial::new(vec![FieldElement::one()]); return result; } @@ -258,10 +254,7 @@ impl Polynomial { //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); if self.polynomial.len() < rhs.polynomial.len() { - return ( - Polynomial::new(vec![FieldElement::new(vec![0; 16])]), - self.clone(), - ); + return (Polynomial::new(vec![FieldElement::zero()]), self.clone()); } let mut remainder = self.clone(); @@ -270,16 +263,10 @@ impl Polynomial { let divisor_deg = divisor.polynomial.len() - 1; if dividend_deg < divisor_deg { - return ( - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0; 16], "gcm").unwrap(), - )]), - remainder, - ); + return (Polynomial::new(vec![FieldElement::zero()]), remainder); } - let mut quotient_coeffs = - vec![FieldElement::new(vec![0; 16]); dividend_deg - divisor_deg + 1]; + 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(); @@ -290,7 +277,7 @@ impl Polynomial { quotient_coeffs[deg_diff] = quot_coeff.clone(); - let mut subtrahend = vec![FieldElement::new(vec![0; 16]); deg_diff]; + let mut subtrahend = vec![FieldElement::zero(); deg_diff]; subtrahend.extend( divisor .polynomial @@ -315,7 +302,7 @@ impl Polynomial { } if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + remainder = Polynomial::new(vec![FieldElement::zero()]); } (Polynomial::new(quotient_coeffs), remainder) } @@ -416,10 +403,10 @@ impl Mul for Polynomial { type Output = Self; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + 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] @@ -434,10 +421,10 @@ impl Mul for &Polynomial { type Output = Polynomial; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + 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] @@ -471,7 +458,7 @@ impl Add for Polynomial { } if polynomial.is_empty() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::new(vec![FieldElement::zero()]); } Polynomial::new(polynomial) @@ -514,8 +501,8 @@ impl PartialOrd for Polynomial { self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { match field_a - .reverse_bits() - .partial_cmp(&field_b.reverse_bits()) + //.reverse_bits() + .partial_cmp(&field_b) .unwrap() { Ordering::Equal => continue, @@ -538,7 +525,10 @@ impl Ord for Polynomial { 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.reverse_bits()) { + match field_a + //.reverse_bits() + .cmp(&field_b) + { Ordering::Equal => continue, other => return other, } @@ -1115,19 +1105,6 @@ mod tests { //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } - #[test] - fn test_poly_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!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); - } - #[test] fn test_field_poly_div_01() { let json1 = json!([ From 7dbcf20891716b64dc653dc5b57b5903c17d1009 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 21:12:42 +0100 Subject: [PATCH 086/105] feat/fix: add initial MT and remove extend from div for performance --- Cargo.toml | 2 ++ src/main.rs | 2 +- src/tasks/mod.rs | 71 +++++++++++++++++++++++++++++++++++++--------- src/utils/parse.rs | 4 +-- src/utils/poly.rs | 28 ++++++------------ 5 files changed, 71 insertions(+), 36 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 9cf5fa2..0d58d2b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,8 @@ 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" diff --git a/src/main.rs b/src/main.rs index fd69ac4..0bb3127 100644 --- a/src/main.rs +++ b/src/main.rs @@ -14,7 +14,7 @@ fn main() -> Result<()> { let json = fs::read_to_string(path_to_workload).unwrap(); let workload = kauma::utils::parse::parse_json(json)?; - let response = kauma::tasks::task_distrubute(&workload)?; + let response = kauma::tasks::task_distribute(&workload)?; println!("{}", serde_json::to_string(&response)?); Ok(()) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index d2c57b7..d86e661 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -185,16 +185,61 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } } -pub fn task_distrubute(testcases: &Testcases) -> 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"); let mut responses: HashMap = HashMap::new(); for (id, testcase) in &testcases.testcases { responses.insert(id.to_owned(), task_deploy(testcase).unwrap()); } - Ok(Responses { - responses: responses, - }) + Ok(Responses { responses }) +} + +pub fn task_distribute(testcases: &Testcases) -> Result { + let cpus = num_cpus::get(); + //TODO: Deactivate MT for now + if cpus > 10000000000 { + task_distribute_mt(testcases) + } else { + task_distribute_st(testcases) + } } #[cfg(test)] @@ -227,7 +272,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -251,7 +296,7 @@ mod tests { }); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -266,7 +311,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -284,7 +329,7 @@ mod tests { }}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -304,7 +349,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -324,7 +369,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -342,7 +387,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -360,7 +405,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -378,7 +423,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); diff --git a/src/utils/parse.rs b/src/utils/parse.rs index 6e5d2dd..4b71b29 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)] +#[derive(Debug, Serialize, Deserialize, Clone)] pub struct Testcase { pub action: String, pub arguments: Value, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] pub struct Responses { pub responses: HashMap, } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 969a144..c294ccb 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -247,12 +247,7 @@ impl Polynomial { result } - // Returns (quotient, remainder) pub fn div(&self, rhs: &Self) -> (Self, Self) { - // Div by zero check ommitted since data is guaranteed to be non 0 - - //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); - if self.polynomial.len() < rhs.polynomial.len() { return (Polynomial::new(vec![FieldElement::zero()]), self.clone()); } @@ -270,24 +265,20 @@ impl Polynomial { 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 subtrahend = vec![FieldElement::zero(); deg_diff]; - subtrahend.extend( - divisor - .polynomial - .iter() - .map(|x| x.clone() * quot_coeff.clone()), - ); - let subtrahend_poly = Polynomial::new(subtrahend); - - remainder = remainder + subtrahend_poly; + 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); + } + // Remove trailing zeros while !remainder.polynomial.is_empty() && remainder .polynomial @@ -301,9 +292,6 @@ impl Polynomial { } } - if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::zero()]); - } (Polynomial::new(quotient_coeffs), remainder) } From 3687733b7f04cb47300e06dc6f36f5972a35b511 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 30 Nov 2024 16:07:11 +0100 Subject: [PATCH 087/105] feat: Enable MT --- src/tasks/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index d86e661..a019cfe 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -234,8 +234,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - //TODO: Deactivate MT for now - if cpus > 10000000000 { + if cpus > 1 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) From 8064dcb9e805c395235c261a3c8cd3bd5ccc5621 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 30 Nov 2024 16:07:39 +0100 Subject: [PATCH 088/105] fix: Fix incorrect dic output. Remainder could be zero. --- src/utils/poly.rs | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index c294ccb..7f9cbe6 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -140,7 +140,7 @@ impl Polynomial { //eprintln!("result in powmod after reduction: {:02X?}", result); if result.is_empty() { - result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + result = Polynomial::zero(); } result @@ -192,7 +192,7 @@ impl Polynomial { } if result.is_empty() { - result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + result = Polynomial::zero(); } result @@ -241,7 +241,7 @@ impl Polynomial { } if result.is_empty() { - result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + result = Polynomial::zero(); } result @@ -278,20 +278,16 @@ impl Polynomial { remainder.polynomial[pos] = a + &(divisor_coeff * c); } - // Remove trailing zeros - while !remainder.polynomial.is_empty() - && remainder - .polynomial - .last() - .unwrap() - .as_ref() - .iter() - .all(|&x| x == 0) + 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) } From e2ef29bfd53876afce3df0c8f37de04c6c8b2cab Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 30 Nov 2024 21:16:47 +0100 Subject: [PATCH 089/105] refactor: test with MT disabled --- src/tasks/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index a019cfe..d26cbac 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -234,7 +234,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - if cpus > 1 { + if cpus > 1000000 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) From e8f4a5873236382d9093e40d0e438deb6ada9308 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 30 Nov 2024 23:46:59 +0100 Subject: [PATCH 090/105] fix: Fix error in random polynomial generation in edf Upper bound wa incorrect --- src/tasks/mod.rs | 2 +- src/utils/edf.rs | 23 ++++++++++++++--------- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index d26cbac..0b9fce7 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -234,7 +234,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - if cpus > 1000000 { + if cpus > 100000 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) diff --git a/src/utils/edf.rs b/src/utils/edf.rs index 72f687d..da05db5 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -4,30 +4,34 @@ use rand::Rng; use super::poly::{gcd, Polynomial}; pub fn edf(f: Polynomial, d: u32) -> Vec { + eprintln!("edf started: {:?}", f.clone().to_c_array()); 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 { - //eprintln!("z len {}", z.len()); - //eprintln!("n len {}", n); + eprintln!("z len {}", z.len()); + eprintln!("n len {}", n); - let h = Polynomial::rand(&rand::thread_rng().gen_range(0..f.degree())); - //eprintln!("h: {:02X?}", h); + let h = Polynomial::rand(&rand::thread_rng().gen_range(1..=f.degree())); + eprintln!("h: {:02X?}", h); let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap(); let g = h.bpow_mod(exponent, &f) + Polynomial::one(); - //eprintln!("g before for {:0X?}", g); + eprintln!("g before for {:0X?}", g); - //eprintln!("z before for {:0X?}", z); + eprintln!("z before for {:0X?}", z); - for i in 0..z.len() { + for i in (0..z.len()).rev() { if z[i].degree() as u32 > d { - //eprintln!("Inside if"); + eprintln!("Inside if"); let j = gcd(&z[i], &g); + eprintln!("j != one_cmp {:?}", j != one_cmp); + eprintln!("j != z[i] {:?}", j != z[i]); + eprintln!("Inside if"); if j != one_cmp && j != z[i] { let intemediate = z[i].div(&j).0; z.remove(i); @@ -37,9 +41,10 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { } } - //eprintln!("z after for {:0X?}", z); + eprintln!("z after for {:0X?}", z); } + eprintln!("edf finished"); z } From 16b65b0de485f34f582eeb32f9c2ac8c649254c3 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sat, 30 Nov 2024 23:47:41 +0100 Subject: [PATCH 091/105] refactor: re-enable multi threading --- src/tasks/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 0b9fce7..a019cfe 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -234,7 +234,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - if cpus > 100000 { + if cpus > 1 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) From 4c9adb9fdcbeeb1d71cbd70061b35bca53195daf Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 16:52:21 +0100 Subject: [PATCH 092/105] feat: add the gcm crack Example testcase is working --- src/tasks/mod.rs | 9 +- src/tasks/tasks01/gcm_crack.rs | 197 +++++++++++++++++++++++++++++++++ src/tasks/tasks01/mod.rs | 1 + src/utils/dff.rs | 6 - src/utils/field.rs | 12 ++ src/utils/poly.rs | 10 +- test_json/sandbox.json | 42 ++++--- 7 files changed, 253 insertions(+), 24 deletions(-) create mode 100644 src/tasks/tasks01/gcm_crack.rs diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index a019cfe..aeca1c7 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -6,6 +6,7 @@ use crate::utils::parse::{Responses, Testcase, Testcases}; use tasks01::{ block2poly::block2poly, gcm::{gcm_decrypt, gcm_encrypt}, + gcm_crack::gcm_crack, gfmul::gfmul_task, pad_oracle::padding_oracle, pfmath::{ @@ -176,6 +177,12 @@ pub fn task_deploy(testcase: &Testcase) -> Result { Ok(json) } + "gcm_crack" => { + let result = gcm_crack(args)?; + let json = json!({"factors" : result}); + + Ok(json) + } _ => Err(anyhow!( "Fatal. No compatible action found. Json data was {:?}. Arguments were; {:?}", @@ -234,7 +241,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - if cpus > 1 { + if cpus > 1000000 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs new file mode 100644 index 0000000..203b029 --- /dev/null +++ b/src/tasks/tasks01/gcm_crack.rs @@ -0,0 +1,197 @@ +use std::{env::args, fs::canonicalize, slice::Chunks}; + +use anyhow::{Ok, Result}; +use base64::{prelude::BASE64_STANDARD, Engine}; +use openssl::derive; +use serde::{Deserialize, Serialize}; +use serde_json::{map, Value}; + +use crate::utils::{ + self, + 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 ciphertext_bytes: Vec = BASE64_STANDARD.decode(ciphertext_text)?; + let mut ciphertext_chunks: Vec = ciphertext_bytes + .chunks(16) + .into_iter() + .map(|chunk| FieldElement::new(chunk.to_vec())) + .collect(); + //ciphertext_chunks; + let ciphertext: Polynomial = Polynomial::new(ciphertext_chunks.clone()); + + 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 mut ad_chunks: Vec = ad_bytes + .chunks(16) + .into_iter() + .map(|chunk| FieldElement::new(chunk.to_vec())) + .collect(); + //ad_chunks; + let ad: Polynomial = Polynomial::new(ad_chunks.clone()); + + 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()); + let tag: Polynomial = Polynomial::new(vec![tag_field.clone()]); + + let mut c_len: Vec = ((ciphertext_bytes.len() * 8) as u64).to_be_bytes().to_vec(); + 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 { + let nonce: String = serde_json::from_value(args["nonce"].clone())?; + + let crack_poly: Polynomial = Polynomial::empty(); + + // Prepare first equation + let (m1_data, m1_h_poly) = parse_message(&args["m1"])?; + + let (m2_data, m2_h_poly) = parse_message(&args["m2"])?; + + let (m3_data, m3_h_poly) = parse_message(&args["m3"])?; + + eprintln!("m1 poly: {:?}", m1_h_poly.clone().to_c_array()); + eprintln!("m2 poly: {:?}", m2_h_poly.clone().to_c_array()); + + let combine_poly = m1_h_poly + m2_h_poly; + + eprintln!("combine poly: {:?}", combine_poly.clone().to_c_array()); + + 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)); + } + + eprintln!("combine_ddf: {:?}", combine_ddf); + + let mut combine_edf: Vec = vec![]; + for (factor, degree) in combine_ddf { + if degree == 1 { + combine_edf.extend(edf(factor, degree as u32)); + } + } + + eprintln!("combine_edf: {:?}", combine_edf); + + 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); + eprintln!("H candidate: {:02X?}", h_candidate.to_b64()); + 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 { + eprintln!("Candidate valid"); + eprintln!("{:02X?}", m3_auth_tag); + break; + } else { + eprintln!("H candidate not valid"); + } + } + } + + eprintln!( + "M3 Authentication TAG {:02X?}", + BASE64_STANDARD.encode(&m3_auth_tag) + ); + + if m3_auth_tag.is_empty() { + eprintln!("No valid candidate found"); + } + + 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(); + + 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/mod.rs b/src/tasks/tasks01/mod.rs index 8200de5..64d24da 100644 --- a/src/tasks/tasks01/mod.rs +++ b/src/tasks/tasks01/mod.rs @@ -1,5 +1,6 @@ pub mod block2poly; pub mod gcm; +pub mod gcm_crack; pub mod gfmul; pub mod pad_oracle; pub mod pfmath; diff --git a/src/utils/dff.rs b/src/utils/dff.rs index bcd1ca0..4cd4b39 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -25,20 +25,14 @@ pub fn ddf(f: Polynomial) -> Vec<(Polynomial, u128)> { let g = gcd(&h, &f_star); if g != one_cmp { - eprintln!("d is: {}", d); - eprintln!("g is: {:?}", &g.clone().to_c_array()); - z.push((g.clone(), d)); f_star = f_star.div(&g).0; } - eprintln!("d outer is: {}", d); - eprintln!("F star degree is {:?}", &f_star.degree()); d += 1; } if f_star != one_cmp { - eprintln!("fstar not one"); z.push((f_star.clone(), f_star.degree() as u128)); } else if z.len() == 0 { z.push((f.clone(), 1)); diff --git a/src/utils/field.rs b/src/utils/field.rs index 7d359c8..13029cd 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -39,6 +39,18 @@ impl FieldElement { 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 padd(&mut self) { + if self.field_element.len() % 16 != 0 || ad.is_empty() { + ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut()); + } + } + */ + pub fn new(field_element: Vec) -> Self { Self { field_element: reverse_bits_in_bytevec(field_element), diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 7f9cbe6..61109f8 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,7 +1,7 @@ use crate::utils::field::ByteArray; use base64::prelude::*; -use num::traits::FromBytes; +use num::traits::{FromBytes, ToBytes}; use num::{BigInt, BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; @@ -31,6 +31,10 @@ impl Polynomial { self.polynomial.len() - 1 } + pub fn empty() -> Polynomial { + Polynomial::new(vec![]) + } + pub fn one() -> Self { Polynomial::new(vec![FieldElement::one()]) } @@ -373,6 +377,10 @@ impl Polynomial { self } + + pub fn extract_component(&self, i: u32) -> FieldElement { + self.polynomial[i as usize].clone() + } } impl Clone for Polynomial { diff --git a/test_json/sandbox.json b/test_json/sandbox.json index 836b3c8..e3f5e1f 100644 --- a/test_json/sandbox.json +++ b/test_json/sandbox.json @@ -1,19 +1,29 @@ { - "testcases": { - "sandbox": { - "action": "gfpoly_factor_edf", - "arguments": { - "F": [ - "mmAAAAAAAAAAAAAAAAAAAA==", - "AbAAAAAAAAAAAAAAAAAAAA==", - "zgAAAAAAAAAAAAAAAAAAAA==", - "FwAAAAAAAAAAAAAAAAAAAA==", - "AAAAAAAAAAAAAAAAAAAAAA==", - "wAAAAAAAAAAAAAAAAAAAAA==", - "gAAAAAAAAAAAAAAAAAAAAA==" - ], - "d": 3 - } + "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": "" + } + } + } } - } } From b632e0c803560b95e9b53f11207c1092797451d7 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 17:00:23 +0100 Subject: [PATCH 093/105] refactor: clen edf code --- src/utils/edf.rs | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/utils/edf.rs b/src/utils/edf.rs index da05db5..dfb59cf 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -4,34 +4,21 @@ use rand::Rng; use super::poly::{gcd, Polynomial}; pub fn edf(f: Polynomial, d: u32) -> Vec { - eprintln!("edf started: {:?}", f.clone().to_c_array()); 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 { - eprintln!("z len {}", z.len()); - eprintln!("n len {}", n); - let h = Polynomial::rand(&rand::thread_rng().gen_range(1..=f.degree())); - eprintln!("h: {:02X?}", h); let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap(); let g = h.bpow_mod(exponent, &f) + Polynomial::one(); - eprintln!("g before for {:0X?}", g); - - eprintln!("z before for {:0X?}", z); for i in (0..z.len()).rev() { if z[i].degree() as u32 > d { - eprintln!("Inside if"); let j = gcd(&z[i], &g); - eprintln!("j != one_cmp {:?}", j != one_cmp); - eprintln!("j != z[i] {:?}", j != z[i]); - - eprintln!("Inside if"); if j != one_cmp && j != z[i] { let intemediate = z[i].div(&j).0; z.remove(i); @@ -40,11 +27,8 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { } } } - - eprintln!("z after for {:0X?}", z); } - eprintln!("edf finished"); z } From b348c19c6cb6f87cbea3e0e61e48d3436090cac4 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 17:09:43 +0100 Subject: [PATCH 094/105] refactor: clean up gcm_crack code --- src/tasks/tasks01/gcm_crack.rs | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index 203b029..d8aab77 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -35,13 +35,11 @@ struct Message { fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { let ciphertext_text: String = serde_json::from_value(val["ciphertext"].clone())?; let ciphertext_bytes: Vec = BASE64_STANDARD.decode(ciphertext_text)?; - let mut ciphertext_chunks: Vec = ciphertext_bytes + let ciphertext_chunks: Vec = ciphertext_bytes .chunks(16) .into_iter() .map(|chunk| FieldElement::new(chunk.to_vec())) .collect(); - //ciphertext_chunks; - let ciphertext: Polynomial = Polynomial::new(ciphertext_chunks.clone()); let ad_text: String = serde_json::from_value(val["associated_data"].clone())?; let mut ad_bytes: Vec = BASE64_STANDARD.decode(ad_text)?; @@ -50,18 +48,15 @@ fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { if ad_bytes.len() % 16 != 0 || ad_bytes.is_empty() { ad_bytes.append(vec![0u8; 16 - (ad_bytes.len() % 16)].as_mut()); } - let mut ad_chunks: Vec = ad_bytes + let ad_chunks: Vec = ad_bytes .chunks(16) .into_iter() .map(|chunk| FieldElement::new(chunk.to_vec())) .collect(); - //ad_chunks; - let ad: Polynomial = Polynomial::new(ad_chunks.clone()); 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()); - let tag: Polynomial = Polynomial::new(vec![tag_field.clone()]); let mut c_len: Vec = ((ciphertext_bytes.len() * 8) as u64).to_be_bytes().to_vec(); l_field.append(c_len.as_mut()); @@ -90,16 +85,12 @@ fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { } pub fn gcm_crack(args: &Value) -> Result { - let nonce: String = serde_json::from_value(args["nonce"].clone())?; - - let crack_poly: Polynomial = Polynomial::empty(); - // Prepare first equation let (m1_data, m1_h_poly) = parse_message(&args["m1"])?; - let (m2_data, m2_h_poly) = parse_message(&args["m2"])?; + let (_, m2_h_poly) = parse_message(&args["m2"])?; - let (m3_data, m3_h_poly) = parse_message(&args["m3"])?; + let (m3_data, _) = parse_message(&args["m3"])?; eprintln!("m1 poly: {:?}", m1_h_poly.clone().to_c_array()); eprintln!("m2 poly: {:?}", m2_h_poly.clone().to_c_array()); From 6a2f631e4689ab504c354afda5b6ff467ca17db6 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 17:51:59 +0100 Subject: [PATCH 095/105] fix: Fix the output of mask if mask is empty --- src/tasks/tasks01/gcm_crack.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index d8aab77..6cabe38 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -180,6 +180,10 @@ pub fn gcm_crack(args: &Value) -> Result { 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(), From 9e31b6cc5b116800d280d23317f8b2eb3a191754 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 22:58:10 +0100 Subject: [PATCH 096/105] fix: Add ciphertext padding to gcm_crack --- src/tasks/tasks01/gcm_crack.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index 6cabe38..5dc2236 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -34,7 +34,10 @@ struct Message { fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { let ciphertext_text: String = serde_json::from_value(val["ciphertext"].clone())?; - let ciphertext_bytes: Vec = BASE64_STANDARD.decode(ciphertext_text)?; + let mut ciphertext_bytes: Vec = BASE64_STANDARD.decode(ciphertext_text)?; + 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() From 90d61a655ed60e432b40a78cfa8107d090a50fc8 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Tue, 3 Dec 2024 23:15:42 +0100 Subject: [PATCH 097/105] fix: Fix length field implementation in gcm_crack Length field was calculated after padding --- src/tasks/tasks01/gcm_crack.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index 5dc2236..05d8886 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -35,9 +35,12 @@ struct Message { 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() @@ -61,7 +64,6 @@ fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { let tag_bytes: Vec = BASE64_STANDARD.decode(tag_text)?; let tag_field: FieldElement = FieldElement::new(tag_bytes.clone()); - let mut c_len: Vec = ((ciphertext_bytes.len() * 8) as u64).to_be_bytes().to_vec(); l_field.append(c_len.as_mut()); // Combine all data From 7a0d1219f90a2d083da8931c9fcf0977abbba1a3 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 5 Dec 2024 15:57:18 +0100 Subject: [PATCH 098/105] fix: Fix GCM crack output --- src/tasks/mod.rs | 2 +- src/tasks/tasks01/gcm_crack.rs | 62 +++++++++++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 2 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index aeca1c7..d48952d 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -179,7 +179,7 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } "gcm_crack" => { let result = gcm_crack(args)?; - let json = json!({"factors" : result}); + let json = json!(result); Ok(json) } diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index 05d8886..cce3df6 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -54,6 +54,7 @@ fn parse_message(val: &Value) -> Result<(Message, Polynomial)> { 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() @@ -128,7 +129,6 @@ pub fn gcm_crack(args: &Value) -> Result { for candidate in combine_edf { if candidate.degree() == 1 { h_candidate = candidate.extract_component(0); - eprintln!("H candidate: {:02X?}", h_candidate.to_b64()); let m1_ghash = ghash( reverse_bits_in_bytevec(h_candidate.to_vec()), m1_data.ad.clone(), @@ -170,6 +170,7 @@ pub fn gcm_crack(args: &Value) -> Result { ); if m3_auth_tag.is_empty() { + assert!(false); eprintln!("No valid candidate found"); } @@ -195,3 +196,62 @@ pub fn gcm_crack(args: &Value) -> Result { mask: BASE64_STANDARD.encode(eky0), }) } + +#[cfg(test)] +mod tests { + + use anyhow::Result; + + use rand::Rng; + + use serde_json::json; + use utils::ciphers::{aes_128_encrypt, gcm_encrypt_aes}; + // Note this useful idiom: importing names from outer (for mod tests) scope. + use super::*; + + #[test] + fn test_random() -> Result<()> { + let key = vec![1, 1, 1, 1]; + let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; + let ad = vec![0]; + + let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); + let plain1 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; + let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); + let plain2 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; + let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); + let plain3 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; + + let crack_input = json!({ + "testcases": { + "gcm_crack46": { + "action": "gcm_crack", + "arguments": { + "nonce": "4gF+BtR3ku/PUQci", + "m1": { + "ciphertext": BASE64_STANDARD.encode(plain1.0), + "associated_data": "", + "tag": BASE64_STANDARD.encode(plain1.1) + }, + "m2": { + "ciphertext": BASE64_STANDARD.encode(plain2.0), + "associated_data": "", + "tag": BASE64_STANDARD.encode(plain2.1) + }, + "m3": { + "ciphertext": BASE64_STANDARD.encode(plain3.0), + "associated_data": "", + "tag": BASE64_STANDARD.encode(plain3.1) + }, + "forgery": { + "ciphertext": "AXe/ZQ==", + "associated_data": "" + } + } + } + } + }); + + todo!(); + } +} From 6d1b735a0ba0aefcb51d3f2df2074cc9d5c158b5 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 5 Dec 2024 16:37:54 +0100 Subject: [PATCH 099/105] refactor: remove unneded prints and enable mt --- src/tasks/mod.rs | 2 +- src/tasks/tasks01/gcm_crack.rs | 80 ---------------------------------- 2 files changed, 1 insertion(+), 81 deletions(-) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index d48952d..8a8b782 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -241,7 +241,7 @@ pub fn task_distribute_st(testcases: &Testcases) -> Result { pub fn task_distribute(testcases: &Testcases) -> Result { let cpus = num_cpus::get(); - if cpus > 1000000 { + if cpus > 1 { task_distribute_mt(testcases) } else { task_distribute_st(testcases) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index cce3df6..89788c7 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -98,13 +98,8 @@ pub fn gcm_crack(args: &Value) -> Result { let (m3_data, _) = parse_message(&args["m3"])?; - eprintln!("m1 poly: {:?}", m1_h_poly.clone().to_c_array()); - eprintln!("m2 poly: {:?}", m2_h_poly.clone().to_c_array()); - let combine_poly = m1_h_poly + m2_h_poly; - eprintln!("combine poly: {:?}", combine_poly.clone().to_c_array()); - let combine_sff = sff(combine_poly.monic()); let mut combine_ddf: Vec<(Polynomial, u128)> = vec![]; @@ -112,8 +107,6 @@ pub fn gcm_crack(args: &Value) -> Result { combine_ddf.extend(ddf(factor)); } - eprintln!("combine_ddf: {:?}", combine_ddf); - let mut combine_edf: Vec = vec![]; for (factor, degree) in combine_ddf { if degree == 1 { @@ -121,8 +114,6 @@ pub fn gcm_crack(args: &Value) -> Result { } } - eprintln!("combine_edf: {:?}", combine_edf); - let mut m3_auth_tag: Vec = vec![]; let mut h_candidate: FieldElement = FieldElement::zero(); let mut eky0: Vec = vec![]; @@ -155,8 +146,6 @@ pub fn gcm_crack(args: &Value) -> Result { ); if m3_auth_tag == m3_data.tag { - eprintln!("Candidate valid"); - eprintln!("{:02X?}", m3_auth_tag); break; } else { eprintln!("H candidate not valid"); @@ -164,16 +153,6 @@ pub fn gcm_crack(args: &Value) -> Result { } } - eprintln!( - "M3 Authentication TAG {:02X?}", - BASE64_STANDARD.encode(&m3_auth_tag) - ); - - if m3_auth_tag.is_empty() { - assert!(false); - eprintln!("No valid candidate found"); - } - let (forgery_data, _) = parse_message(&args["forgery"])?; let forgery_ghash = ghash( @@ -196,62 +175,3 @@ pub fn gcm_crack(args: &Value) -> Result { mask: BASE64_STANDARD.encode(eky0), }) } - -#[cfg(test)] -mod tests { - - use anyhow::Result; - - use rand::Rng; - - use serde_json::json; - use utils::ciphers::{aes_128_encrypt, gcm_encrypt_aes}; - // Note this useful idiom: importing names from outer (for mod tests) scope. - use super::*; - - #[test] - fn test_random() -> Result<()> { - let key = vec![1, 1, 1, 1]; - let nonce = BASE64_STANDARD.decode("4gF+BtR3ku/PUQci")?; - let ad = vec![0]; - - let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); - let plain1 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; - let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); - let plain2 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; - let input: Vec = Vec::with_capacity(rand::thread_rng().gen_range(0..=60)); - let plain3 = gcm_encrypt_aes(nonce.clone(), key.clone(), input, ad.clone())?; - - let crack_input = json!({ - "testcases": { - "gcm_crack46": { - "action": "gcm_crack", - "arguments": { - "nonce": "4gF+BtR3ku/PUQci", - "m1": { - "ciphertext": BASE64_STANDARD.encode(plain1.0), - "associated_data": "", - "tag": BASE64_STANDARD.encode(plain1.1) - }, - "m2": { - "ciphertext": BASE64_STANDARD.encode(plain2.0), - "associated_data": "", - "tag": BASE64_STANDARD.encode(plain2.1) - }, - "m3": { - "ciphertext": BASE64_STANDARD.encode(plain3.0), - "associated_data": "", - "tag": BASE64_STANDARD.encode(plain3.1) - }, - "forgery": { - "ciphertext": "AXe/ZQ==", - "associated_data": "" - } - } - } - } - }); - - todo!(); - } -} From 0da047110f94996cbb76fc30e2cdeeaf0beb4bac Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 5 Dec 2024 17:48:31 +0100 Subject: [PATCH 100/105] feat: enable tcp no delay option --- src/tasks/tasks01/pad_oracle.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 4286e37..6ea7d3e 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -29,6 +29,7 @@ pub fn padding_oracle(args: &Value) -> Result> { for chunk in &cipher_chunks { let mut stream = TcpStream::connect(format!("{}:{}", hostname, port))?; + stream.set_nodelay(true).expect("Error on no delay"); stream.set_nonblocking(false)?; // Track value sent to server From 2f0e265ed69adc1a9a8f684eca5dc22f366f2942 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Thu, 5 Dec 2024 18:12:26 +0100 Subject: [PATCH 101/105] refactor: Change vector init in padding oracle --- src/tasks/tasks01/pad_oracle.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 6ea7d3e..60356b4 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -57,7 +57,8 @@ pub fn padding_oracle(args: &Value) -> Result> { // Generate attack blocks // TODO: Collect all and send in one - let mut payload: Vec = l_msg.to_vec(); + let mut payload: Vec = Vec::with_capacity(2 + 16 * 265); + payload.extend(l_msg.to_vec()); for j in 0..q_block_count { // Next byte //eprintln!("Sending attack block: {:02X?}", attack_counter); From b24c70342900eb3f994dcc3179925bb96506c3a8 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Sun, 22 Dec 2024 18:13:23 +0100 Subject: [PATCH 102/105] refactor: Apply general cargo recommendations --- src/tasks/tasks01/gcm_crack.rs | 5 +---- src/utils/ciphers.rs | 1 - src/utils/field.rs | 2 -- src/utils/poly.rs | 5 ++--- 4 files changed, 3 insertions(+), 10 deletions(-) diff --git a/src/tasks/tasks01/gcm_crack.rs b/src/tasks/tasks01/gcm_crack.rs index 89788c7..09ccb2c 100644 --- a/src/tasks/tasks01/gcm_crack.rs +++ b/src/tasks/tasks01/gcm_crack.rs @@ -1,13 +1,10 @@ -use std::{env::args, fs::canonicalize, slice::Chunks}; use anyhow::{Ok, Result}; use base64::{prelude::BASE64_STANDARD, Engine}; -use openssl::derive; use serde::{Deserialize, Serialize}; -use serde_json::{map, Value}; +use serde_json::Value; use crate::utils::{ - self, ciphers::ghash, dff::ddf, edf::edf, diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 82af34b..f147c5a 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -1,6 +1,5 @@ use crate::utils::{field::ByteArray, poly::gfmul}; use anyhow::Result; -use base64::prelude::*; use openssl::symm::{Cipher, Crypter, Mode}; use super::math::xor_bytes; diff --git a/src/utils/field.rs b/src/utils/field.rs index 13029cd..b5a65dc 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -8,9 +8,7 @@ use std::{ use anyhow::{anyhow, Ok, Result}; -use crate::utils::poly::bgfmul; -use super::poly::polynomial_2_block; use super::{ math::{reverse_bits_in_bytevec, xor_bytes}, poly::gfmul, diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 61109f8..361108e 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -2,7 +2,7 @@ use crate::utils::field::ByteArray; use base64::prelude::*; use num::traits::{FromBytes, ToBytes}; -use num::{BigInt, BigUint, One, Zero}; +use num::{BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; @@ -15,7 +15,6 @@ use anyhow::{anyhow, Ok, Result}; use serde_json::Value; use super::field::FieldElement; -use super::math::reverse_bits_in_bytevec; #[derive(Debug, serde::Serialize, serde::Deserialize)] pub struct Polynomial { @@ -574,7 +573,7 @@ pub fn sort_polynomial_array(mut polys: Vec) -> Result, poly_b: &Vec, semantic: &str) -> Result> { - let mut red_poly_bytes: ByteArray = ByteArray(RED_POLY.to_be_bytes().to_vec()); + let 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()); From c9c26b39712112381b9237eeb7839f7d74812439 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Mon, 23 Dec 2024 10:27:23 +0100 Subject: [PATCH 103/105] refactor: remove commented code --- src/tasks/tasks01/block2poly.rs | 1 - src/tasks/tasks01/pad_oracle.rs | 37 -------------------------- src/tasks/tasks01/sea128.rs | 5 ---- src/utils/ciphers.rs | 9 ------- src/utils/field.rs | 23 ---------------- src/utils/poly.rs | 47 ++------------------------------- 6 files changed, 2 insertions(+), 120 deletions(-) diff --git a/src/tasks/tasks01/block2poly.rs b/src/tasks/tasks01/block2poly.rs index 3e636eb..3377bf6 100644 --- a/src/tasks/tasks01/block2poly.rs +++ b/src/tasks/tasks01/block2poly.rs @@ -19,7 +19,6 @@ 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/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 60356b4..067a55f 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -40,7 +40,6 @@ 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()?; @@ -50,10 +49,6 @@ 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 @@ -61,14 +56,9 @@ pub fn padding_oracle(args: &Value) -> Result> { payload.extend(l_msg.to_vec()); for j in 0..q_block_count { // Next byte - //eprintln!("Sending attack block: {:02X?}", attack_counter); - - //thread::sleep(Duration::from_millis(1000)); payload.extend(&attack_counter); - //eprintln!("I in q builder {}", i); attack_counter[i as usize] += 1; } - //eprintln!("Time for qblocks: {:?}", start.elapsed()); stream.write_all(&payload)?; stream.flush()?; @@ -76,7 +66,6 @@ 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 @@ -86,7 +75,6 @@ pub fn padding_oracle(args: &Value) -> Result> { if valid_val == 0x00 { eprintln!("No valid found in main loop"); } - //eprintln!("Valid value found: {:02X?}", valid_val); // Craft next attack vector padding; 0x01, 0x02, ... attack_counter[i as usize] = valid_val; @@ -100,15 +88,10 @@ pub fn padding_oracle(args: &Value) -> Result> { l_msg_check.extend(check_q_block.as_slice()); stream.write_all(&l_msg_check)?; - //stream.write_all(&check_q_block)?; let mut buf = [0u8; 0x01]; stream.read(&mut buf)?; - //eprintln!("I = {}", i); - //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 - server_q_resp @@ -119,38 +102,21 @@ pub fn padding_oracle(args: &Value) -> Result> { if valid_val == 0x00 { eprintln!("No valid found"); } - //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))); } - //eprintln!("Attack counter after set: {:02X?}", attack_counter); let range = i; for pos in range..=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); @@ -159,13 +125,10 @@ 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(); diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index 6d76909..2a6a7e2 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -6,18 +6,13 @@ 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 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) diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index f147c5a..0b558af 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -161,7 +161,6 @@ pub fn gcm_decrypt_aes( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); - //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; @@ -250,7 +249,6 @@ pub fn gcm_decrypt_sea( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); - //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; @@ -324,13 +322,6 @@ pub fn ghash( 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/field.rs b/src/utils/field.rs index b5a65dc..0a06662 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -8,7 +8,6 @@ use std::{ use anyhow::{anyhow, Ok, Result}; - use super::{ math::{reverse_bits_in_bytevec, xor_bytes}, poly::gfmul, @@ -41,14 +40,6 @@ impl FieldElement { self.field_element.clone() } - /* - pub fn padd(&mut self) { - if self.field_element.len() % 16 != 0 || ad.is_empty() { - ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut()); - } - } - */ - pub fn new(field_element: Vec) -> Self { Self { field_element: reverse_bits_in_bytevec(field_element), @@ -80,29 +71,18 @@ impl FieldElement { return result; } - //eprintln!("Initial result: {:?}", result); while exponent > 0 { - //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - //eprintln!("Mult"); - //eprintln!("After mod: {:?}", temp); result = temp } let temp_square = &self * &self; - // eprintln!("Square"); - // eprintln!("After squaring: {:?}", temp_square); self = temp_square; - //eprintln!("After mod: {:?}", self); exponent >>= 1; } - // eprintln!("result in powmod before reduction: {:02X?}", result); - - // eprintln!("result in powmod after reduction: {:02X?}", result); - result } @@ -111,10 +91,8 @@ impl FieldElement { 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]; - //eprintln!("Inverse start {:02X?}", inverse); while inverser > 0 { - //eprintln!("{:02X}", inverser); if inverser & 1 == 1 { inverse = gfmul(&self.field_element, &inverse, "xex").unwrap(); } @@ -122,7 +100,6 @@ impl FieldElement { self.field_element = gfmul(&self.field_element, &self.field_element, "xex") .expect("Error in sqrmul sqr"); } - //eprintln!("Inverse rhs {:?}", inverse); FieldElement::new_no_convert(inverse) } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 361108e..90ef5e0 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -1,14 +1,14 @@ use crate::utils::field::ByteArray; use base64::prelude::*; -use num::traits::{FromBytes, ToBytes}; +use num::traits::FromBytes; use num::{BigUint, One, Zero}; use std::{str::FromStr, u128, u8, usize}; use std::{ cmp::Ordering, - ops::{Add, Div, Mul}, + ops::{Add, Mul}, }; use anyhow::{anyhow, Ok, Result}; @@ -107,27 +107,18 @@ impl Polynomial { return result; } - //eprintln!("Initial result: {:?}", result); while exponent > 0 { - //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - //eprintln!("Mult"); - //eprintln!("After mod: {:?}", temp); result = temp } let temp_square = &self * &self; - //eprintln!("Square"); - //eprintln!("After squaring: {:?}", temp_square); self = temp_square; - //eprintln!("After mod: {:?}", self); exponent >>= 1; } - //eprintln!("result in powmod before reduction: {:02X?}", result); - while !result.polynomial.is_empty() && result .polynomial @@ -140,8 +131,6 @@ impl Polynomial { result.polynomial.pop(); } - //eprintln!("result in powmod after reduction: {:02X?}", result); - if result.is_empty() { result = Polynomial::zero(); } @@ -166,19 +155,13 @@ impl Polynomial { return result; } - //eprintln!("Initial result: {:?}", result); while &exponent > &BigUint::zero() { - //eprintln!("Current exponent: {:02X}", exponent); if &exponent & BigUint::one() == BigUint::one() { let temp = &self * &result; - //eprintln!("After multiplication: {:?}", temp); result = temp.div(&modulus).1; - //eprintln!("After mod: {:?}", result); } let temp_square = &self * &self; - //eprintln!("After squaring: {:?}", temp_square); self = temp_square.div(&modulus).1; - //eprintln!("After mod: {:?}", self); exponent >>= 1; } @@ -215,19 +198,13 @@ impl Polynomial { return result; } - //eprintln!("Initial result: {:?}", result); while exponent > 0 { - //eprintln!("Current exponent: {:02X}", exponent); if exponent & 1 == 1 { let temp = &self * &result; - //eprintln!("After multiplication: {:?}", temp); result = temp.div(&modulus).1; - //eprintln!("After mod: {:?}", result); } let temp_square = &self * &self; - //eprintln!("After squaring: {:?}", temp_square); self = temp_square.div(&modulus).1; - //eprintln!("After mod: {:?}", self); exponent >>= 1; } @@ -574,13 +551,10 @@ 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()); - //red_poly_bytes.0.push(0x01); let mut poly1: ByteArray = ByteArray(poly_a.to_vec()); - //poly1.0.push(0x00); let mut poly2: ByteArray = ByteArray(poly_b.to_vec()); - //poly2.0.push(0x00); if semantic == "gcm" { poly1.reverse_bits_in_bytevec(); @@ -618,7 +592,6 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result> { - //TODO: Implement gfmul with bigint let red_poly_bytes: BigUint = BigUint::from_slice(&[ 0x87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x01, ]); @@ -627,13 +600,6 @@ pub fn bgfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result> 1; } - /* - if semantic == "gcm" { - result.reverse_bits_in_bytevec(); - } - */ - Ok(result.to_bytes_le()) } @@ -676,8 +636,6 @@ pub fn convert_gcm_to_xex(gcm_poly: Vec) -> 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 { @@ -704,7 +662,6 @@ 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); } From 848ad15bb8ed531ab246777f76635528b90d2612 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Mon, 23 Dec 2024 10:29:12 +0100 Subject: [PATCH 104/105] refactor: Remove unneded imports --- src/tasks/tasks01/gfmul.rs | 1 - src/tasks/tasks01/pad_oracle.rs | 3 +-- src/tasks/tasks01/poly2block.rs | 2 +- src/utils/dff.rs | 2 +- src/utils/field.rs | 1 - src/utils/poly.rs | 2 +- src/utils/sff.rs | 2 +- 7 files changed, 5 insertions(+), 8 deletions(-) diff --git a/src/tasks/tasks01/gfmul.rs b/src/tasks/tasks01/gfmul.rs index 70ab788..8bca55f 100644 --- a/src/tasks/tasks01/gfmul.rs +++ b/src/tasks/tasks01/gfmul.rs @@ -21,7 +21,6 @@ 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::*; diff --git a/src/tasks/tasks01/pad_oracle.rs b/src/tasks/tasks01/pad_oracle.rs index 067a55f..234babf 100644 --- a/src/tasks/tasks01/pad_oracle.rs +++ b/src/tasks/tasks01/pad_oracle.rs @@ -54,7 +54,7 @@ pub fn padding_oracle(args: &Value) -> Result> { // 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 { + for _j in 0..q_block_count { // Next byte payload.extend(&attack_counter); attack_counter[i as usize] += 1; @@ -140,7 +140,6 @@ 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/poly2block.rs b/src/tasks/tasks01/poly2block.rs index 6d5ad95..7557981 100644 --- a/src/tasks/tasks01/poly2block.rs +++ b/src/tasks/tasks01/poly2block.rs @@ -1,4 +1,4 @@ -use crate::utils::poly::{polynomial_2_block}; +use crate::utils::poly::polynomial_2_block; use anyhow::{Ok, Result}; use serde_json::Value; diff --git a/src/utils/dff.rs b/src/utils/dff.rs index 4cd4b39..21dde69 100644 --- a/src/utils/dff.rs +++ b/src/utils/dff.rs @@ -75,7 +75,7 @@ mod tests { } println!("Result: {:?}", result); - let bit_indices: Vec = vec![0]; + let _bit_indices: Vec = vec![0]; assert!(false) } } diff --git a/src/utils/field.rs b/src/utils/field.rs index 0a06662..739b466 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -337,7 +337,6 @@ impl ByteArray { #[cfg(test)] mod tests { use super::*; - use serde_json::json; #[test] fn test_byte_array_shift1() { diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 90ef5e0..f2e7d33 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -788,7 +788,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()), diff --git a/src/utils/sff.rs b/src/utils/sff.rs index e7a154a..de2bef6 100644 --- a/src/utils/sff.rs +++ b/src/utils/sff.rs @@ -86,7 +86,7 @@ mod tests { } println!("{:?}", result); - let bit_indices: Vec = vec![0]; + let _bit_indices: Vec = vec![0]; assert!(false) } } From 0a573d84da8d0984f4ea5d14a04f27c0f7fb14e9 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Mon, 23 Dec 2024 10:30:21 +0100 Subject: [PATCH 105/105] refactor: Remove unused function --- src/utils/poly.rs | 33 --------------------------------- 1 file changed, 33 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index f2e7d33..6a61853 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -591,39 +591,6 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result> { - let red_poly_bytes: BigUint = BigUint::from_slice(&[ - 0x87, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x01, - ]); - - let mut poly1: BigUint = BigUint::from_le_bytes(poly_a); - - let mut poly2: BigUint = BigUint::from_le_bytes(poly_b); - - let mut result: BigUint = BigUint::zero(); - - if (&poly2 & (BigUint::one() << 127)) == BigUint::one() { - result = &result ^ &poly1; - } - poly2 = &poly2 >> 1; - - while &poly2 != &BigUint::zero() { - poly1 = &poly1 << 1; - - if (&poly1 & (BigUint::one() << 127)) == BigUint::one() { - poly1 = &poly1 ^ &red_poly_bytes; - } - - if &poly2 & BigUint::one() == BigUint::one() { - result = &result ^ &poly1; - } - - poly2 = &poly2 >> 1; - } - - Ok(result.to_bytes_le()) -} - pub fn convert_gcm_to_xex(gcm_poly: Vec) -> Result> { let xex_poly = gcm_poly .into_iter()