From 3a777cab00bceaf8d3e98e04fa28ec5e7992b7d3 Mon Sep 17 00:00:00 2001 From: 0xalivecow Date: Tue, 22 Oct 2024 12:28:23 +0200 Subject: [PATCH] feat: task runner adapted for sea128 task --- src/tasks/mod.rs | 28 ++++++++++++++ src/tasks/tasks01/sea128.rs | 76 ++++++++++++++++++++++++++----------- src/test_json/sea128.json | 20 ++++++++++ 3 files changed, 102 insertions(+), 22 deletions(-) create mode 100644 src/test_json/sea128.json diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index 65b06d2..6adc2e5 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -8,6 +8,7 @@ use crate::utils::parse::{Responses, Testcase, Testcases}; use tasks01::{ block2poly::block2poly, poly2block::{self, poly2block}, + sea128::sea128, }; use anyhow::{anyhow, Result}; @@ -36,6 +37,11 @@ pub fn task_deploy(testcase: &Testcase) -> Result { let json = json!({"coefficients" : result}); Ok(json) } + "sea128" => { + let result = sea128(args)?; + let json = json!({"output" : result}); + Ok(json) + } _ => Err(anyhow!("Fatal. No compatible action found")), } } @@ -86,4 +92,26 @@ mod tests { serde_json::to_value(expected).unwrap() ); } + + #[test] + fn test_task_sea128_task_full() { + let json = fs::read_to_string("src/test_json/sea128.json").unwrap(); + let parsed = parse_json(json).unwrap(); + + let expected = json!({ + "responses": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "output": "D5FDo3iVBoBN9gVi9/MSKQ==" + }, + "254eaee7-05fd-4e0d-8292-9b658a852245": { + "output": "yv66vvrO263eyviIiDNEVQ==" + } + } + }); + + assert_eq!( + serde_json::to_value(task_distrubute(&parsed)).unwrap(), + serde_json::to_value(expected).unwrap() + ); + } } diff --git a/src/tasks/tasks01/sea128.rs b/src/tasks/tasks01/sea128.rs index 720b0dc..b6e6135 100644 --- a/src/tasks/tasks01/sea128.rs +++ b/src/tasks/tasks01/sea128.rs @@ -1,4 +1,4 @@ -use anyhow::Result; +use anyhow::{anyhow, Result}; use base64::prelude::*; use openssl::symm::{Cipher, Crypter, Mode}; use serde_json::Value; @@ -9,33 +9,57 @@ 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 plaintexts_string: String = serde_json::from_value(args["input"].clone())?; + //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 plaintexts = BASE64_STANDARD.decode(plaintexts_string)?; - eprintln!("{:?}", plaintexts); - + let input = BASE64_STANDARD.decode(input_string)?; let xor_val: u128 = 0xc0ffeec0ffeec0ffeec0ffeec0ffee11; - let mut encrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Encrypt, &key, None)?; - encrypter.pad(false); + let mode: String = serde_json::from_value(args["mode"].clone())?; + match mode.as_str() { + "encrypt" => { + //eprintln!("{:?}", plaintexts); + let mut encrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Encrypt, &key, None)?; + encrypter.pad(false); - let mut ciphertext = [0; 32].to_vec(); + let mut ciphertext = [0; 32].to_vec(); - let mut count = encrypter.update(&plaintexts, &mut ciphertext)?; - count += encrypter.finalize(&mut ciphertext)?; - ciphertext.truncate(count); + let mut count = encrypter.update(&input, &mut ciphertext)?; + count += encrypter.finalize(&mut ciphertext)?; + ciphertext.truncate(count); - eprintln!("{:?}", &ciphertext[..]); + //eprintln!("{:?}", &ciphertext[..]); - let mut bytes: [u8; 16] = [0u8; 16]; - bytes.copy_from_slice(&ciphertext); - let number: u128 = ::from_be_bytes(bytes); + let mut bytes: [u8; 16] = [0u8; 16]; + bytes.copy_from_slice(&ciphertext); + let number: u128 = ::from_be_bytes(bytes); - let output = BASE64_STANDARD.encode((number ^ xor_val).to_be_bytes()); + let output = BASE64_STANDARD.encode((number ^ xor_val).to_be_bytes()); - Ok(output) + Ok(output) + } + "decrypt" => { + let mut decrypter = Crypter::new(Cipher::aes_128_ecb(), Mode::Decrypt, &key, None)?; + decrypter.pad(false); + + let mut bytes: [u8; 16] = [0u8; 16]; + bytes.copy_from_slice(&input); + let input_num: u128 = ::from_be_bytes(bytes); + + let input_afer_xor = (input_num ^ xor_val).to_be_bytes(); + + let mut plaintext = [0; 32].to_vec(); + + let mut count = decrypter.update(&input_afer_xor, &mut plaintext)?; + count += decrypter.finalize(&mut plaintext)?; + plaintext.truncate(count); + + let output = BASE64_STANDARD.encode(plaintext); + + Ok(output) + } + _ => Err(anyhow!("Failure. no valid mode detected")), + } } #[cfg(test)] @@ -48,12 +72,20 @@ mod tests { use super::*; #[test] - fn test_sea128() -> Result<()> { - let args = - json!({"key" : "istDASeincoolerKEYrofg==", "input" : "yv66vvrO263eyviIiDNEVQ=="}); + fn test_sea128_encrypt() -> Result<()> { + let args = json!({"mode" : "encrypt", "key" : "istDASeincoolerKEYrofg==", "input" : "yv66vvrO263eyviIiDNEVQ=="}); assert_eq!(sea128(&args)?, "D5FDo3iVBoBN9gVi9/MSKQ=="); Ok(()) } + + #[test] + fn test_sea128_decrypt() -> Result<()> { + let args = json!({"mode" : "decrypt", "key" : "istDASeincoolerKEYrofg==", "input" : "D5FDo3iVBoBN9gVi9/MSKQ=="}); + + assert_eq!(sea128(&args)?, "yv66vvrO263eyviIiDNEVQ=="); + + Ok(()) + } } diff --git a/src/test_json/sea128.json b/src/test_json/sea128.json new file mode 100644 index 0000000..28b3537 --- /dev/null +++ b/src/test_json/sea128.json @@ -0,0 +1,20 @@ +{ + "testcases": { + "b856d760-023d-4b00-bad2-15d2b6da22fe": { + "action": "sea128", + "arguments": { + "mode": "encrypt", + "key": "istDASeincoolerKEYrofg==", + "input": "yv66vvrO263eyviIiDNEVQ==" + } + }, + "254eaee7-05fd-4e0d-8292-9b658a852245": { + "action": "sea128", + "arguments": { + "mode": "decrypt", + "key": "istDASeincoolerKEYrofg==", + "input": "D5FDo3iVBoBN9gVi9/MSKQ==" + } + } + } +}