0xalivecow/kauma
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: 0xalivecow:main
Branches Tags
0xalivecow:main
0xalivecow:dev
0xalivecow:feat_gcm_crack
0xalivecow:feat_poly_algs
0xalivecow:feat_field_element
0xalivecow:feat_pad_oracle
0xalivecow:feat_gcm_aes_sea
0xalivecow:feat_new_gfmul_gcm
0xalivecow:feat_polynomial_gcm
0xalivecow:feat_gcm
0xalivecow:feat_gfmul_gcm
0xalivecow:feat_xex
0xalivecow:dbg_pipeline
0xalivecow:feat_gfmul
0xalivecow:feat_sea_128
0xalivecow:feat_polynomial
..
compare: 0xalivecow:feat_polynomial
Branches Tags
0xalivecow:main
0xalivecow:dev
0xalivecow:feat_gcm_crack
0xalivecow:feat_poly_algs
0xalivecow:feat_field_element
0xalivecow:feat_pad_oracle
0xalivecow:feat_gcm_aes_sea
0xalivecow:feat_new_gfmul_gcm
0xalivecow:feat_polynomial_gcm
0xalivecow:feat_gcm
0xalivecow:feat_gfmul_gcm
0xalivecow:feat_xex
0xalivecow:dbg_pipeline
0xalivecow:feat_gfmul
0xalivecow:feat_sea_128
0xalivecow:feat_polynomial

No commits in common. "main" and "feat_polynomial" have entirely different histories.
main ... feat_polyn

46 changed files with 75 additions and 17848 deletions
Download patch file Download diff file Expand all files Collapse all files

5
.cargo/config.toml
View file

@ -1,5 +0,0 @@
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"

70
.github/workflows/kauma.yaml vendored
View file

@ -1,70 +0,0 @@
name: Kauma Pipeline (labwork-docker)
on:
push:
branches:
- master
- devel
- main
- '**'
jobs:
check_requirements:
name: Check requirements
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: build script may be present for compiling code
id: check-build
run: |
if [ -f ./build ]; then
echo "OK"
else
echo "WARNING: No \`build\` found (not required)" >> $GITHUB_STEP_SUMMARY
fi
- name: build script must be executable
id: check-build-exec
run: |
if [ -f ./build ]; then
if [ -x ./build ]; then
echo "OK"
else
echo "ERROR: \`build\` is not executable" >> $GITHUB_STEP_SUMMARY
echo "*HINT: The git command \`git add --chmod=+x build\` can be used*" >> $GITHUB_STEP_SUMMARY
exit 1
fi
fi
- name: kauma script must be present for running code
id: check-run
run: |
if [ -f ./kauma ]; then
echo "OK"
else
echo "ERROR: No \`run\` found (required)" >> $GITHUB_STEP_SUMMARY
exit 1
fi
- name: kauma script must be executable
id: check-run-exec
run: |
if [ -x ./kauma ]; then
echo "OK"
else
echo "ERROR: \`kauma\` is not executable" >> $GITHUB_STEP_SUMMARY
echo "*HINT: The git command \`git add --chmod=+x kauma\` can be used*" >> $GITHUB_STEP_SUMMARY
exit 1
fi
labwork_docker_run:
name: Test project inside labwork-docker container
needs: check_requirements
runs-on: ubuntu-latest
steps:
- name: get repo
uses: actions/checkout@v4
- name: Pull labwork-docker image
run: |
docker pull ghcr.io/johndoe31415/labwork-docker:master
docker tag ghcr.io/johndoe31415/labwork-docker:master labwork
- name: Run labwork container
run: |
docker run -v $PWD:/dut/ labwork /bin/bash -c '/dut/build && /dut/kauma ./test_json/kauma_tests.json'

5
.gitignore vendored
View file

@ -1,8 +1,7 @@
# Generated by Cargo
# will have compiled files and executables
# debug/
debug/
target/
vendor/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
@ -19,4 +18,4 @@ Cargo.lock
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
#.idea/

21
Cargo.toml
View file

@ -2,25 +2,8 @@
name = "kauma"
version = "0.1.0"
edition = "2021"
rust = "1.75"
[dependencies]
anyhow = "1.0.91"
base64 = "0.22"
openssl = "0.10"
serde = { version = "1.0", features = ["derive"] }
base64 = "0.22.1"
serde = { version = "1.0.210", features = ["derive"] }
serde_json = "1.0"
num = "0.4"
rand = "0.8"
threadpool = "1.8"
num_cpus = "1.16.0"
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"
[profile.profiling]
inherits = "release"
debug = true

8
build
View file

@ -1,8 +0,0 @@
#!/bin/bash
SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
cd $SCRIPT_DIR
ln -s /rust/vendor $SCRIPT_DIR/vendor
cargo build --release --offline

4
kauma
View file

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

4
src/lib.rs
View file

@ -1,2 +1,2 @@
pub mod tasks;
pub mod utils;
mod tasks;
mod utils;

22
src/main.rs
View file

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

439
src/tasks/mod.rs
View file

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

71
src/tasks/tasks01/block2poly.rs
View file

@ -1,53 +1,52 @@
use crate::utils::poly::block_2_polynomial;
use anyhow::Result;
use std::str::Bytes;
use crate::utils::poly;
use base64::prelude::*;
use serde_json::Value;
pub fn block2poly(val: &Value) -> Result<Vec<u8>> {
fn block2poly(block: &str) -> Vec<u8> {
// Convert JSON data in to a u128
// TODO: Transfer decoding into own function?
let string: String = serde_json::from_value(val["block"].clone())?;
let block = BASE64_STANDARD.decode(string)?;
let decoded: Vec<u8> = BASE64_STANDARD.decode(block).unwrap();
let mut bytes: [u8; 16] = [0u8; 16];
bytes.copy_from_slice(&decoded);
let number: u128 = <u128>::from_ne_bytes(bytes);
let semantic: String = serde_json::from_value(val["semantic"].clone())?;
let mut coefficients: Vec<u8> = vec![];
let coefficients: Vec<u8> = block_2_polynomial(block, &semantic)?; //get_coefficients(number);
for shift in 0..128 {
//println!("{:?}", ((num >> shift) & 1));
if (((number >> shift) & 1) == 1) {
println!("Shift success");
coefficients.push(shift);
}
}
Ok(coefficients)
//Legacy code.
// TODO: Remove
/*
let mut counter: u8 = 0;
let mut coefficients: Vec<u8> = vec![];
for blk in decoded {
let indices: Vec<u8> = poly::get_bit_indices_from_byte(blk);
for index in indices {
coefficients.push(counter*8+index);
}
counter += 1;
}
*/
coefficients
}
#[cfg(test)]
mod tests {
use serde_json::json;
use std::str::FromStr;
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
#[test]
fn block2poly_task01() -> Result<()> {
let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "xex"});
fn block2poly_task01() {
let block: &str = "ARIAAAAAAAAAAAAAAAAAgA==";
let coefficients: Vec<u8> = vec![0, 9, 12, 127];
assert_eq!(
block2poly(&block)?,
coefficients,
"Coefficients were: {:?}",
block2poly(&block)?
);
Ok(())
assert_eq!(block2poly(block), coefficients);
}
#[test]
fn block2poly_task02() -> Result<()> {
let block: Value = json!({"block" : "ARIAAAAAAAAAAAAAAAAAgA==", "semantic" : "gcm"});
let coefficients: Vec<u8> = vec![7, 11, 14, 120];
assert_eq!(
block2poly(&block)?,
coefficients,
"Coefficients were: {:?}",
block2poly(&block)?
);
Ok(())
}
}
}

52
src/tasks/tasks01/gcm.rs
View file

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

174
src/tasks/tasks01/gcm_crack.rs
View file

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

107
src/tasks/tasks01/gfmul.rs
View file

@ -1,107 +0,0 @@
use crate::utils::poly::gfmul;
use anyhow::Result;
use base64::prelude::*;
use serde_json::Value;
pub fn gfmul_task(args: &Value) -> Result<Vec<u8>> {
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 semantic: String = serde_json::from_value(args["semantic"].clone())?;
let result = gfmul(&poly_a, &poly_b, &semantic)?;
Ok(result)
}
#[cfg(test)]
mod tests {
use serde_json::json;
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
#[test]
fn gfmul_task01() -> 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(())
}
#[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(())
}
}

11
src/tasks/tasks01/mod.rs
View file

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

148
src/tasks/tasks01/pad_oracle.rs
View file

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

282
src/tasks/tasks01/pfmath.rs
View file

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

21
src/tasks/tasks01/poly2block.rs
View file

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

54
src/tasks/tasks01/sea128.rs
View file

@ -1,54 +0,0 @@
use anyhow::{anyhow, Result};
use base64::prelude::*;
use serde_json::Value;
use crate::utils::ciphers::{sea_128_decrypt, sea_128_encrypt};
pub fn sea128(args: &Value) -> Result<String> {
let key_string: String = serde_json::from_value(args["key"].clone())?;
let key = BASE64_STANDARD.decode(key_string)?;
let input_string: String = serde_json::from_value(args["input"].clone())?;
let input = BASE64_STANDARD.decode(input_string)?;
let mode: String = serde_json::from_value(args["mode"].clone())?;
match mode.as_str() {
"encrypt" => {
let output = BASE64_STANDARD.encode(sea_128_encrypt(&key, &input)?);
Ok(output)
}
"decrypt" => {
let output = BASE64_STANDARD.encode(sea_128_decrypt(&key, &input)?);
Ok(output)
}
_ => Err(anyhow!("Failure. no valid mode detected")),
}
}
#[cfg(test)]
mod tests {
use anyhow::Result;
use serde_json::json;
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
#[test]
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(())
}
}

27
src/tasks/tasks01/xex.rs
View file

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

562
src/utils/ciphers.rs
View file

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

81
src/utils/dff.rs
View file

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

86
src/utils/edf.rs
View file

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

468
src/utils/field.rs
View file

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

16
src/utils/math.rs
View file

@ -1,16 +0,0 @@
use anyhow::{Ok, Result};
pub fn xor_bytes(vec1: &Vec<u8>, mut vec2: Vec<u8>) -> Result<Vec<u8>> {
for (byte1, byte2) in vec1.iter().zip(vec2.iter_mut()) {
*byte2 ^= byte1;
}
Ok(vec2)
}
pub fn reverse_bits_in_bytevec(mut vec: Vec<u8>) -> Vec<u8> {
vec = vec.iter_mut().map(|byte| byte.reverse_bits()).collect();
vec
}

7
src/utils/mod.rs
View file

@ -1,9 +1,2 @@
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;

1
src/utils/net.rs
View file

@ -1 +0,0 @@

141
src/utils/parse.rs
View file

@ -1,141 +1,14 @@
use std::{collections::HashMap, io::Result};
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Serialize, Deserialize)]
#[derive(Serialize, Deserialize)]
pub struct Testcases {
pub testcases: HashMap<String, Testcase>,
testcase: Vec<Testcase>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[derive(Serialize, Deserialize)]
pub struct Testcase {
pub action: String,
pub arguments: Value,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Responses {
pub responses: HashMap<String, Value>,
}
pub fn parse_json(json: String) -> Result<Testcases> {
let deserialised: Testcases = serde_json::from_str(&json)?;
Ok(deserialised)
}
#[cfg(test)]
mod tests {
use std::fs;
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
#[test]
fn test_json_parsing() {
let json = fs::read_to_string("test_json/parse_example.json").unwrap();
let parsed = parse_json(json).unwrap();
/*
* Test if struct is deserialised at all
* */
assert!(
!parsed.testcases.is_empty(),
"Testcases struct was: {:?}",
parsed.testcases
);
/*
* Test id the keys are set correctly in the hashmap
* */
assert!(
!parsed
.testcases
.contains_key("\"b856d760-023d-4b00-bad2-15d2b6da22fe\""),
"Testcases first elemient was: {:?}",
parsed.testcases
);
assert!(
!parsed
.testcases
.contains_key("\"254eaee7-05fd-4e0d-8292-9b658a852245\""),
"Testcases first element was: {:?}",
parsed.testcases
);
assert!(
!parsed
.testcases
.contains_key("\"affbf4fc-4d2a-41e3-afe0-a79e1d174781\""),
"Testcases first element was: {:?}",
parsed.testcases
);
/*
* Test if the actions are parsed correctly
* */
let testcase_1 = &parsed
.testcases
.get("b856d760-023d-4b00-bad2-15d2b6da22fe")
.unwrap();
assert_eq!(
testcase_1.action, "add_numbers",
"Test case was: {:?}",
testcase_1.action
);
}
// TODO: Reactivate tests
/*
#[test]
fn test_response_payload_generation() {
let testcase_id = "b856d760-023d-4b00-bad2-15d2b6da22fe";
let value: Value = json!({"sum" : serde_json::Number::from(666)});
let payload = serde_json::to_string(
&generate_response_payload(testcase_id.to_owned(), value).unwrap(),
)
.unwrap();
let expected = r#"{"b856d760-023d-4b00-bad2-15d2b6da22fe":{"sum":666}}"#;
assert_eq!(payload, expected);
}
#[test]
fn test_response_generation() {
let testcase1_id = "b856d760-023d-4b00-bad2-15d2b6da22fe";
let value1: Value = json!({"sum" : serde_json::Number::from(666)});
let payload1 = generate_response_payload(testcase1_id.to_owned(), value1).unwrap();
let testcase2_id = "b856d760-023d-4b00-bad2-15d2b6da22fe";
let value2: Value = json!({"sum" : serde_json::Number::from(666)});
let payload2 = generate_response_payload(testcase2_id.to_owned(), value2).unwrap();
let testcase3_id = "b856d760-023d-4b00-bad2-15d2b6da22fe";
let value3: Value = json!({"sum" : serde_json::Number::from(666)});
let payload3 = generate_response_payload(testcase3_id.to_owned(), value3).unwrap();
let mut responses_vec: HashMap<String, Value> = vec![];
responses_vec.insert(payload1);
responses_vec.push(payload2);
responses_vec.push(payload3);
let response = generate_response(responses_vec).unwrap();
let expected = json!(
{
"responses": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"sum": 357
},
"254eaee7-05fd-4e0d-8292-9b658a852245": {
"sum": 777
},
"affbf4fc-4d2a-41e3-afe0-a79e1d174781": {
"difference": -120213
}
}
});
eprintln!("{}", serde_json::to_string(&response).unwrap());
eprintln!("{}", serde_json::to_string(&expected).unwrap());
assert_eq!(response, expected);
}*/
}
uuid: String,
action: String,
arguments: Value,
}

1312
src/utils/poly.rs
View file

File diff suppressed because it is too large Load diff

92
src/utils/sff.rs
View file

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

23
test_json/b2p_p2b_example.json
View file

@ -1,23 +0,0 @@
{
"testcases": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "block2poly",
"arguments": {
"semantic": "xex",
"block": "ARIAAAAAAAAAAAAAAAAAgA=="
}
},
"254eaee7-05fd-4e0d-8292-9b658a852245": {
"action": "poly2block",
"arguments": {
"semantic": "xex",
"coefficients": [
12,
127,
9,
0
]
}
}
}
}

11
test_json/block2poly_example.json
View file

@ -1,11 +0,0 @@
{
"testcases": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "block2poly",
"arguments": {
"semantic": "xex",
"block": "ARIAAAAAAAAAAAAAAAAAgA=="
}
}
}
}

14
test_json/gcm_decrypt_aes.json
View file

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

14
test_json/gcm_decrypt_sea.json
View file

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

14
test_json/gcm_encrypt.json
View file

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

14
test_json/gcm_encrypt_sea.json
View file

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

12
test_json/gfmul_test.json
View file

@ -1,12 +0,0 @@
{
"testcases": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "gfmul",
"arguments": {
"semantic": "xex",
"a": "ARIAAAAAAAAAAAAAAAAAgA==",
"b": "AgAAAAAAAAAAAAAAAAAAAA=="
}
}
}
}

73
test_json/kauma_tests.json
View file

@ -1,73 +0,0 @@
{
"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=="
}
},
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "block2poly",
"arguments": {
"semantic": "xex",
"block": "ARIAAAAAAAAAAAAAAAAAgA=="
}
},
"254eafe7-05fd-4e0d-8292-9b658a852245": {
"action": "poly2block",
"arguments": {
"semantic": "xex",
"coefficients": [
12,
127,
9,
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=="
}
}
}
}

1203
test_json/padding_long.json
View file

File diff suppressed because it is too large Load diff

12015
test_json/padding_oracle.json
View file

File diff suppressed because it is too large Load diff

25
test_json/parse_example.json
View file

@ -1,25 +0,0 @@
{
"testcases": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "add_numbers",
"arguments": {
"number1": 123,
"number2": 234
}
},
"254eaee7-05fd-4e0d-8292-9b658a852245": {
"action": "add_numbers",
"arguments": {
"number1": 333,
"number2": 444
}
},
"affbf4fc-4d2a-41e3-afe0-a79e1d174781": {
"action": "subtract_numbers",
"arguments": {
"number1": 999,
"number2": 121212
}
}
}
}

98
test_json/pfmath_tests.json
View file

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

16
test_json/poly2block_example.json
View file

@ -1,16 +0,0 @@
{
"testcases": {
"b856d760-023d-4b00-bad2-15d2b6da22fe": {
"action": "poly2block",
"arguments": {
"semantic": "xex",
"coefficients": [
12,
127,
9,
0
]
}
}
}
}

29
test_json/poly_algs.json
View file

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

29
test_json/sandbox.json
View file

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

20
test_json/sea128.json
View file

@ -1,20 +0,0 @@
{
"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=="
}
}
}
}

22
test_json/xex_tests.json
View file

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