From 1f2562b9d9351c31aa45e8f2553b521a45b54de5 Mon Sep 17 00:00:00 2001 From: "Dr. Capybara" Date: Mon, 16 Oct 2023 17:57:20 -0700 Subject: [PATCH] completed refactor and bench updates --- README.md | 7 +++ benches/benchmark_e222_256.rs | 65 ++++++++++----------- benches/benchmark_e521_512.rs | 68 +++++++++++----------- src/curves.rs | 39 +++---------- src/lib.rs | 48 +++++++++++++++- src/ops.rs | 104 ++++++++++------------------------ tests/ops_tests.rs | 98 +++++++++++++------------------- tests/sponge_tests.rs | 18 +++--- 8 files changed, 205 insertions(+), 242 deletions(-) diff --git a/README.md b/README.md index 58443e9..fdf03e4 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,13 @@ Add the following line to your `Cargo.toml` file: capycrypt = "0.3.1" ``` +### Note: Building the `rug` Crate + +This library uses an FFI to GMP by means of the rug crate. To successfully build the `rug` crate, please ensure that you have the `m4` library installed on your system. `m4` is a prerequisite for certain components of the build process. You can install it on debian-like systems with: +```bash +apt-get install m4 +``` + ## Benches This library uses the criterion crate for benches. Running: ```bash diff --git a/benches/benchmark_e222_256.rs b/benches/benchmark_e222_256.rs index f453ad5..9d03e15 100644 --- a/benches/benchmark_e222_256.rs +++ b/benches/benchmark_e222_256.rs @@ -1,61 +1,62 @@ -use capycrypt::curves::{ - ArbitraryPoint, EdCurvePoint, - EdCurves::{self, E222}, +use capycrypt::{ + curves::EdCurves::{self, E222}, + KeyEncryptable, KeyPair, Message, PwEncryptable, Signable, }; -use capycrypt::ops::Message; + use capycrypt::sha3::aux_functions::byte_utils::get_random_bytes; use criterion::{criterion_group, criterion_main, Criterion}; -use std::borrow::BorrowMut; + const SELECTED_CURVE: EdCurves = E222; /// Symmetric encrypt and decrypt roundtrip -fn sym_enc(pw: &mut Vec, mut message: Message) { - let mut cg2 = Box::new(encrypt_with_pw(&mut pw.clone(), &mut message, 256)); - decrypt_with_pw(&mut pw.clone(), &mut cg2.borrow_mut(), 256); +fn sym_enc(pw: &mut Vec, mut msg: Message) { + msg.pw_encrypt(&mut pw.clone(), 256); + msg.pw_decrypt(&mut pw.clone(), 256); } /// Asymmetric encrypt and decrypt roundtrip + keygen -fn key_gen_enc_dec(pw: &mut Vec, mut message: Box>) { - let owner = "test key".to_string(); - let key_obj = gen_keypair(&mut pw.clone(), owner, 256); - let x = key_obj.pub_x; - let y = key_obj.pub_y; - let pub_key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); - let mut enc = encrypt_with_key(pub_key, &mut message, 256); - decrypt_with_key(&mut pw.clone(), enc.borrow_mut(), 256); +fn key_gen_enc_dec(pw: &mut Vec, mut msg: Message) { + let key_pair = KeyPair::new(pw, "test key".to_string(), SELECTED_CURVE, 256); + msg.key_encrypt(&key_pair.pub_key, 256); + msg.key_decrypt(&key_pair.priv_key, 256); } /// Signature generation + verification roundtrip -pub fn sign_verify(pw: &mut Vec, mut message: Box>) { - let key_obj = gen_keypair(&mut pw.clone(), "test".to_string(), 256); - let x = key_obj.pub_x; - let y = key_obj.pub_y; - let key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); - let sig = sign_with_key(&mut pw.clone(), &mut message, 256); - verify_signature(&sig, key, &mut message, 256); +pub fn sign_verify(mut key_pair: KeyPair, mut msg: Message) { + msg.sign(&mut key_pair.priv_key, 512); + msg.verify(key_pair.pub_key, 512); } fn bench_sign_verify(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Signature Generation + Verification Roundtrip", |b| { - b.iter(|| sign_verify(&mut pw.clone(), message.clone())) + b.iter(|| { + sign_verify( + KeyPair::new(&get_random_bytes(16), "test key".to_string(), SELECTED_CURVE, 512), + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } fn bench_sym_enc(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Symmetric Encrypt + Decrypt Roundtrip", |b| { - b.iter(|| sym_enc(&mut pw.clone(), message.clone())) + b.iter(|| { + sym_enc( + &mut get_random_bytes(64), + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } fn bench_key_gen_enc_dec(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Keygen + Asymmetric Encrypt + Decrypt Roundtrip", |b| { - b.iter(|| key_gen_enc_dec(&mut pw.clone(), message.clone())) + b.iter(|| { + key_gen_enc_dec( + &mut KeyPair::new(&get_random_bytes(32), "test key".to_string(), SELECTED_CURVE, 256).priv_key, + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } diff --git a/benches/benchmark_e521_512.rs b/benches/benchmark_e521_512.rs index 46c0a3e..20bf257 100644 --- a/benches/benchmark_e521_512.rs +++ b/benches/benchmark_e521_512.rs @@ -1,64 +1,62 @@ -use capycrypt::curves::{ - ArbitraryPoint, EdCurvePoint, - EdCurves::{self, E521}, -}; -use capycrypt::ops::{ - decrypt_with_key, decrypt_with_pw, encrypt_with_key, encrypt_with_pw, gen_keypair, - sign_with_key, verify_signature, +use capycrypt::{ + curves::EdCurves::{self, E521}, + KeyEncryptable, KeyPair, Message, PwEncryptable, Signable, }; + use capycrypt::sha3::aux_functions::byte_utils::get_random_bytes; use criterion::{criterion_group, criterion_main, Criterion}; -use std::borrow::BorrowMut; + const SELECTED_CURVE: EdCurves = E521; /// Symmetric encrypt and decrypt roundtrip -fn sym_enc(pw: &mut Vec, mut message: Box>) { - let mut cg2 = Box::new(encrypt_with_pw(&mut pw.clone(), &mut message, 512)); - decrypt_with_pw(&mut pw.clone(), &mut cg2.borrow_mut(), 512); +fn sym_enc(pw: &mut Vec, mut msg: Message) { + msg.pw_encrypt(&mut pw.clone(), 512); + msg.pw_decrypt(&mut pw.clone(), 512); } /// Asymmetric encrypt and decrypt roundtrip + keygen -fn key_gen_enc_dec(pw: &mut Vec, mut message: Box>) { - let owner = "test key".to_string(); - let key_obj = gen_keypair(&mut pw.clone(), owner, 512); - let x = key_obj.pub_x; - let y = key_obj.pub_y; - let pub_key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); - let mut enc = encrypt_with_key(pub_key, &mut message, 512); - decrypt_with_key(&mut pw.clone(), enc.borrow_mut(), 512); +fn key_gen_enc_dec(pw: &mut Vec, mut msg: Message) { + let key_pair = KeyPair::new(pw, "test key".to_string(), SELECTED_CURVE, 512); + msg.key_encrypt(&key_pair.pub_key, 512); + msg.key_decrypt(&key_pair.priv_key, 512); } /// Signature generation + verification roundtrip -pub fn sign_verify(pw: &mut Vec, mut message: Box>) { - let key_obj = gen_keypair(&mut pw.clone(), "test".to_string(), 512); - let x = key_obj.pub_x; - let y = key_obj.pub_y; - let key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); - let sig = sign_with_key(&mut pw.clone(), &mut message, 512); - verify_signature(&sig, key, &mut message, 512); +pub fn sign_verify(mut key_pair: KeyPair, mut msg: Message) { + msg.sign(&mut key_pair.priv_key, 512); + msg.verify(key_pair.pub_key, 512); } fn bench_sign_verify(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Signature Generation + Verification Roundtrip", |b| { - b.iter(|| sign_verify(&mut pw.clone(), message.clone())) + b.iter(|| { + sign_verify( + KeyPair::new(&get_random_bytes(16), "test key".to_string(), SELECTED_CURVE, 512), + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } fn bench_sym_enc(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Symmetric Encrypt + Decrypt Roundtrip", |b| { - b.iter(|| sym_enc(&mut pw.clone(), message.clone())) + b.iter(|| { + sym_enc( + &mut get_random_bytes(64), + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } fn bench_key_gen_enc_dec(c: &mut Criterion) { - let pw = get_random_bytes(16); - let message = Box::new(get_random_bytes(5242880).to_owned()); c.bench_function("Keygen + Asymmetric Encrypt + Decrypt Roundtrip", |b| { - b.iter(|| key_gen_enc_dec(&mut pw.clone(), message.clone())) + b.iter(|| { + key_gen_enc_dec( + &mut KeyPair::new(&get_random_bytes(32), "test key".to_string(), SELECTED_CURVE, 512).priv_key, + Message::new(&mut get_random_bytes(5242880)), + ) + }); }); } diff --git a/src/curves.rs b/src/curves.rs index 89c68f9..6c954b8 100644 --- a/src/curves.rs +++ b/src/curves.rs @@ -75,12 +75,6 @@ pub trait Generator { fn generator(curve: EdCurves, msb: bool) -> EdCurvePoint; } -/// Specifies the function for producing a coordinate pair. -/// Does not check that point is on curve. -pub trait ArbitraryPoint { - fn arbitrary_point(curve: EdCurves, x: rug::Integer, y: rug::Integer) -> EdCurvePoint; -} - /// Specifies the function for verifying that a point is on the curve. pub trait IsPoint { fn is_point(&self) -> bool; @@ -102,7 +96,7 @@ impl Add<&EdCurvePoint> for EdCurvePoint { /// excessive cloning in this function is a consequence of the /// Rug Integer GMP FFI which does not implement ```copy``` trait. Observed complexity /// impact appears minimal. - fn add(self, p2: &EdCurvePoint) -> EdCurvePoint { + fn add(mut self, p2: &EdCurvePoint) -> EdCurvePoint { let x1 = &self.x; let y1 = &self.y; let x2 = p2.x.clone(); @@ -130,7 +124,9 @@ impl Add<&EdCurvePoint> for EdCurvePoint { let new_x = ((x1y2y1x2_sum * one_plus_dx1x2y1y2inv) % p.clone() + p.clone()) % p.clone(); // (y₁y₂ − x₁x₂) / (1 − dx₁x₂y₁y₂) let new_y = ((y1y2x1x2_difference * one_minus_dx1x2y1y2inv) % p.clone() + p.clone()) % p; - EdCurvePoint::arbitrary_point(self.curve, new_x, new_y) + self.x = new_x; + self.y = new_y; + self } } @@ -233,8 +229,9 @@ impl Mul for EdCurvePoint { /// If a point is defined as (x, y) then its negation is (-x, y) impl Neg for EdCurvePoint { type Output = EdCurvePoint; - fn neg(self) -> EdCurvePoint { - EdCurvePoint::arbitrary_point(self.curve, self.p - self.x, self.y) + fn neg(mut self) -> EdCurvePoint { + self.x = self.p.clone() - self.x.clone(); + self } } @@ -245,28 +242,6 @@ impl PartialEq for EdCurvePoint { } } -/// Returns CurvePoint(x, y) for any x, y. Assumes valid curve point. -/// -/// # Arguments -/// -/// * `x: rug::Integer` x-coordinate for point. -/// * `y: rug::Integer` y-coordinate for point. -/// -/// # Examples -impl ArbitraryPoint for EdCurvePoint { - fn arbitrary_point(req_curve: EdCurves, x: Integer, y: Integer) -> EdCurvePoint { - EdCurvePoint { - x, - y, - p: curve_p(req_curve), - d: curve_d(req_curve), - r: curve_r(req_curve), - n: order(req_curve), - curve: req_curve, - } - } -} - /// Performs modular inverse via euclidian algorithm. /// * `n`: Integer value to mod /// * `p`: modulus diff --git a/src/lib.rs b/src/lib.rs index 1c2a9c4..b9c9d9f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,4 @@ -use curves::EdCurvePoint; +use curves::{EdCurvePoint, EdCurves}; use rug::Integer; /* @@ -50,4 +50,50 @@ pub struct KeyPair { pub priv_key: Vec, /// Date key was generated pub date_created: String, + /// Selected curve type + pub curve: EdCurves +} + +impl Message { + pub fn new(data: &mut Vec) -> Message { + Message { + msg: Box::new(data.to_owned()), + sym_nonce: None, + asym_nonce: None, + digest: None, + op_result: None, + sig: None, + } + } +} + +#[derive(Debug)] +/// Message type for which cryptographic traits are defined. +pub struct Message { + pub msg: Box>, + pub sym_nonce: Option>, + pub asym_nonce: Option, + pub digest: Option>, + pub op_result: Option, + pub sig: Option, +} + +pub trait Hashable { + fn compute_sha3_hash(&mut self, d: u64); + fn compute_tagged_hash(&mut self, pw: &mut Vec, s: &str, d: u64); +} + +pub trait PwEncryptable { + fn pw_encrypt(&mut self, pw: &[u8], d: u64); + fn pw_decrypt(&mut self, pw: &[u8], d: u64); +} + +pub trait KeyEncryptable { + fn key_encrypt(&mut self, pub_key: &EdCurvePoint, d: u64); + fn key_decrypt(&mut self, pw: &[u8], d: u64); +} + +pub trait Signable { + fn sign(&mut self, pw: &mut Vec, d: u64); + fn verify(&mut self, pub_key: EdCurvePoint, d: u64); } diff --git a/src/ops.rs b/src/ops.rs index 2afed3e..4956721 100644 --- a/src/ops.rs +++ b/src/ops.rs @@ -1,8 +1,3 @@ -use crate::curves::{ - order, EdCurvePoint, - EdCurves::{self, E448}, - Generator, -}; use crate::sha3::{ aux_functions::{ byte_utils::{ @@ -12,6 +7,14 @@ use crate::sha3::{ }, sponge::{sponge_absorb, sponge_squeeze}, }; +use crate::{ + curves::{ + order, EdCurvePoint, + EdCurves::{self, E448}, + Generator, + }, + Hashable, KeyEncryptable, Message, PwEncryptable, Signable, +}; use crate::{KeyPair, Signature}; use rug::Integer; @@ -129,7 +132,7 @@ impl Hashable for Message { /// ## Usage: /// ``` /// ``` - fn compute_tagged_hash(&mut self, pw: &mut Vec, s: &mut str, d: u64) { + fn compute_tagged_hash(&mut self, pw: &mut Vec, s: &str, d: u64) { self.digest = match d { 224 | 256 | 384 | 512 => Some(kmac_xof(pw, &self.msg, d, s, d)), _ => panic!("Value must be either 224, 256. 384, or 512"), @@ -214,15 +217,16 @@ impl KeyPair { /// ## Usage: /// ``` /// ``` - pub fn new(pw: &Vec, owner: String, d: u64) -> KeyPair { + pub fn new(pw: &Vec, owner: String, curve: EdCurves, d: u64) -> KeyPair { let s: Integer = (bytes_to_big(kmac_xof(&mut pw.to_owned(), &vec![], 512, "K", d)) * 4) % order(SELECTED_CURVE); - let v = EdCurvePoint::generator(SELECTED_CURVE, false) * (s); + let pub_key = EdCurvePoint::generator(SELECTED_CURVE, false) * (s); KeyPair { owner, - pub_key: v, + pub_key, priv_key: pw.to_vec(), date_created: get_date_and_time_as_string(), + curve } } } @@ -246,19 +250,19 @@ impl KeyEncryptable for Message { /// ## Usage: /// ``` /// ``` - fn key_encrypt(&mut self, pub_key: EdCurvePoint, d: u64) { + fn key_encrypt(&mut self, pub_key: &EdCurvePoint, d: u64) { let k: Integer = (bytes_to_big(get_random_bytes(64)) * 4) % order(SELECTED_CURVE); - let w = pub_key * k.clone(); + let w = pub_key.clone() * k.clone(); let z = EdCurvePoint::generator(SELECTED_CURVE, false) * k; + let ke_ka = kmac_xof(&mut big_to_bytes(w.x), &vec![], 1024, "PK", d); let ke = &mut ke_ka[..64].to_vec(); let ka = &mut ke_ka[64..].to_vec(); - let t = kmac_xof(&mut ka.clone(), self.msg.borrow(), 512, "PKA", d); - let len = (self.msg.len() * 8) as u64; - let c = kmac_xof(ke, &vec![], len, "PKE", d); + + let t = kmac_xof(ka, self.msg.borrow(), 512, "PKA", d); + let c = kmac_xof(ke, &vec![], (self.msg.len() * 8) as u64, "PKE", d); xor_bytes(&mut self.msg, &c); - self.msg = Box::new(c); self.digest = Some(t); self.asym_nonce = Some(z); } @@ -283,17 +287,16 @@ impl KeyEncryptable for Message { /// ``` fn key_decrypt(&mut self, pw: &[u8], d: u64) { let z = self.asym_nonce.clone().unwrap(); - let s: Integer = (bytes_to_big(kmac_xof(&mut pw.to_owned(), &vec![], 512, "K", d)) * 4) % z.clone().n; - let w = z * s; + let ke_ka = kmac_xof(&mut big_to_bytes(w.x), &vec![], 1024, "PK", d); let ke = &mut ke_ka[..64].to_vec(); let ka = &mut ke_ka[64..].to_vec(); - let len = self.msg.len() * 8; - let m = Box::new(kmac_xof(ke, &vec![], (len) as u64, "PKE", d)); - xor_bytes(&mut self.msg, m.borrow()); + + let m = Box::new(kmac_xof(ke, &vec![], (self.msg.len() * 8) as u64, "PKE", d)); + xor_bytes(&mut self.msg, &m); let t_p = kmac_xof(&mut ka.clone(), &self.msg, 512, "PKA", d); self.op_result = Some(t_p == self.digest.clone().unwrap()); } @@ -319,16 +322,15 @@ impl Signable for Message { let s: Integer = bytes_to_big(kmac_xof(pw, &vec![], 512, "K", d)) * 4; let mut s_bytes = big_to_bytes(s.clone()); - let k: Integer = - bytes_to_big(kmac_xof(&mut s_bytes, self.msg.borrow_mut(), 512, "N", d)) * 4; + let k: Integer = bytes_to_big(kmac_xof(&mut s_bytes, &self.msg, 512, "N", d)) * 4; let u = EdCurvePoint::generator(SELECTED_CURVE, false) * k.clone(); let mut ux_bytes = big_to_bytes(u.x); - let h = kmac_xof(&mut ux_bytes, self.msg.borrow_mut(), 512, "T", d); + let h = kmac_xof(&mut ux_bytes, &self.msg, 512, "T", d); let h_big = bytes_to_big(h.clone()); //(a % b + b) % b let z = ((k - (h_big * s)) % u.r.clone() + u.r.clone()) % u.r; - self.signature = Some(Signature { h, z }) + self.sig = Some(Signature { h, z }) } /// # Signature Verification /// Verifies a signature (h, 𝑍) for a byte array m under the (Schnorr/ @@ -344,55 +346,11 @@ impl Signable for Message { /// ## Usage /// ``` /// ``` - fn verify(&mut self, sig: &Signature, pub_key: EdCurvePoint, d: u64) { - let mut u = EdCurvePoint::generator(SELECTED_CURVE, false) * sig.z.clone(); - let hv = pub_key * (bytes_to_big(sig.h.clone())); + fn verify(&mut self, pub_key: EdCurvePoint, d: u64) { + let mut u = EdCurvePoint::generator(SELECTED_CURVE, false) * self.sig.clone().unwrap().z; + let hv = pub_key * bytes_to_big(self.sig.clone().unwrap().h); u = u + &hv; - let h_p = kmac_xof(&mut big_to_bytes(u.x), self.msg.borrow_mut(), 512, "T", d); - self.op_result = Some(h_p == sig.h) - } -} - -impl Message { - pub fn new(data: &mut Vec) -> Message { - Message { - msg: Box::new(data.to_owned()), - sym_nonce: None, - asym_nonce: None, - digest: None, - op_result: None, - signature: None, - } + let h_p = kmac_xof(&mut big_to_bytes(u.x), &self.msg, 512, "T", d); + self.op_result = Some(h_p == self.sig.clone().unwrap().h) } } - -#[derive(Debug)] -/// Message type for which cryptographic traits are defined. -pub struct Message { - pub msg: Box>, - pub sym_nonce: Option>, - pub asym_nonce: Option, - pub digest: Option>, - pub op_result: Option, - pub signature: Option, -} - -pub trait Hashable { - fn compute_sha3_hash(&mut self, d: u64); - fn compute_tagged_hash(&mut self, pw: &mut Vec, s: &mut str, d: u64); -} - -pub trait PwEncryptable { - fn pw_encrypt(&mut self, pw: &[u8], d: u64); - fn pw_decrypt(&mut self, pw: &[u8], d: u64); -} - -pub trait KeyEncryptable { - fn key_encrypt(&mut self, pub_key: EdCurvePoint, d: u64); - fn key_decrypt(&mut self, pw: &[u8], d: u64); -} - -pub trait Signable { - fn sign(&mut self, pw: &mut Vec, d: u64); - fn verify(&mut self, sig: &Signature, pub_key: EdCurvePoint, d: u64); -} diff --git a/tests/ops_tests.rs b/tests/ops_tests.rs index 00e06ad..390927e 100644 --- a/tests/ops_tests.rs +++ b/tests/ops_tests.rs @@ -1,9 +1,8 @@ #[cfg(test)] pub mod ops_tests { - use capycrypt::ops::{KeyEncryptable, Message, PwEncryptable, Signable}; use capycrypt::sha3::aux_functions::byte_utils::get_random_bytes; - use capycrypt::KeyPair; - use std::borrow::BorrowMut; + use capycrypt::{KeyEncryptable, KeyPair, Message, PwEncryptable, Signable}; + use capycrypt::curves::EdCurves::E448; use std::time::Instant; #[test] @@ -32,71 +31,50 @@ pub mod ops_tests { fn test_key_gen_enc_dec_256() { //check conversion to and from bytes. let mut msg = Message::new(&mut get_random_bytes(5242880)); - let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), 256); + let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), E448, 256); - msg.key_encrypt(key_pair.pub_key, 256); + msg.key_encrypt(&key_pair.pub_key, 256); msg.key_decrypt(&key_pair.priv_key, 256); let res = msg.op_result.unwrap(); assert!(res); } -} -// #[test] -// fn test_key_gen_enc_dec_512() { -// //check conversion to and from bytes. -// let pw = get_random_bytes(64); -// let owner = "test key".to_string(); -// let mut message = Box::new(get_random_bytes(5242880).to_owned()); //5mb -// let key_obj = gen_keypair(&mut pw.clone(), owner, 512); -// let x = key_obj.pub_x; -// let y = key_obj.pub_y; -// let pub_key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); -// let mut enc = encrypt_with_key(pub_key, &mut message, 512); -// let res = decrypt_with_key(&mut pw.clone(), enc.borrow_mut(), 512); -// assert!(res); -// } + #[test] + fn test_key_gen_enc_dec_512() { + //check conversion to and from bytes. + let mut msg = Message::new(&mut get_random_bytes(5242880)); + let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), E448, 512); -// #[test] -// pub fn test_signature_512() { -// let mut message = Box::new(get_random_bytes(5242880).to_owned()); -// let pw = get_random_bytes(64); -// let key_obj = gen_keypair(&mut pw.clone(), "test".to_string(), 512); -// let x = key_obj.pub_x; -// let y = key_obj.pub_y; -// let key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); -// let sig = sign_with_key(&mut pw.clone(), &mut message, 512); -// let res = verify_signature(&sig, key, &mut message, 512); -// assert!(res); -// } + msg.key_encrypt(&key_pair.pub_key, 512); + msg.key_decrypt(&key_pair.priv_key, 512); + + let res = msg.op_result.unwrap(); + assert!(res); + } + #[test] + pub fn test_signature_512() { + let mut msg = Message::new(&mut get_random_bytes(5242880)); + let mut pw = get_random_bytes(64); + let key_pair = KeyPair::new(&pw, "test key".to_string(), E448, 512); -// #[test] -// fn test_sig_timing_side_channel() { -// for i in 0..32 { -// let mut message = Box::new(get_random_bytes(16).to_owned()); -// let pw = get_random_bytes(1 + i); -// let key_obj = gen_keypair(&mut pw.clone(), "test".to_string(), 256); -// let x = key_obj.pub_x; -// let y = key_obj.pub_y; -// let key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); + msg.sign(&mut pw, 512); + msg.verify(key_pair.pub_key, 512); -// let now = Instant::now(); -// let _result = sign_with_key(&mut pw.clone(), &mut message, 256); -// println!("{} needed {} micro seconds", i, now.elapsed().as_micros()); -// assert!(verify_signature(&_result, key, &mut message, 256)); -// } -// } + assert!(msg.op_result.unwrap()); + } + #[test] + fn test_sig_timing_side_channel() { + for i in 0..32 { + let mut msg = Message::new(&mut get_random_bytes(16)); + let mut pw = get_random_bytes(2 ^ i); + let key_pair = KeyPair::new(&pw, "test key".to_string(), E448, 512); -// #[test] -// pub fn test_signature_256() { -// let mut message = Box::new(get_random_bytes(5242880).to_owned()); -// let pw = get_random_bytes(32); -// let key_obj = gen_keypair(&mut pw.clone(), "test".to_string(), 256); -// let x = key_obj.pub_x; -// let y = key_obj.pub_y; -// let key = EdCurvePoint::arbitrary_point(SELECTED_CURVE, x, y); -// let sig = sign_with_key(&mut pw.clone(), &mut message, 256); -// let res = verify_signature(&sig, key, &mut message, 256); -// assert!(res); -// } -// } + let now = Instant::now(); + msg.sign(&mut pw, 512); + println!("{} needed {} microseconds", i, now.elapsed().as_micros()); + msg.verify(key_pair.pub_key, 512); + assert!(msg.op_result.unwrap()); + } + } +} diff --git a/tests/sponge_tests.rs b/tests/sponge_tests.rs index 1584066..cb3ce38 100644 --- a/tests/sponge_tests.rs +++ b/tests/sponge_tests.rs @@ -1,4 +1,4 @@ -use capycrypt::ops::{Hashable, Message}; +use capycrypt::{Hashable, Message}; /// Test cases for cSHAKE and KMAC functionality. All values labeled /// "exptected" in cshake and kmac tests are official test vectors supplied by NIST. @@ -14,8 +14,8 @@ mod sponge_tests { let key_str = "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"; let s_str = "My Tagged Application"; let mut key_bytes = hex::decode(key_str).unwrap(); - let mut data = hex::decode("00010203").unwrap(); - let res = kmac_xof(&mut key_bytes, &mut data, 64, &s_str, 512); + let data = hex::decode("00010203").unwrap(); + let res = kmac_xof(&mut key_bytes, &data, 64, &s_str, 512); let expected = "1755133f1534752a"; assert_eq!(hex::encode(res), expected) } @@ -26,9 +26,9 @@ mod sponge_tests { let s_str = "My Tagged Application"; let mut key_bytes = hex::decode(key_str).unwrap(); - let mut data = hex::decode("000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7").unwrap(); + let data = hex::decode("000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7").unwrap(); - let res = kmac_xof(&mut key_bytes, &mut data, 512, &s_str, 512); + let res = kmac_xof(&mut key_bytes, &data, 512, &s_str, 512); let expected = "d5be731c954ed7732846bb59dbe3a8e30f83e77a4bff4459f2f1c2b4ecebb8ce67ba01c62e8ab8578d2d499bd1bb276768781190020a306a97de281dcc30305d"; assert_eq!(hex::encode(res), expected) } @@ -204,20 +204,20 @@ fn test_shake_512() { #[test] fn test_compute_tagged_hash_256() { - let mut s = "".to_owned(); + let s = "".to_owned(); let mut pw = "".as_bytes().to_vec(); let mut data = Message::new(&mut Box::new("".as_bytes().to_owned())); let expected = "3f9259e80b35e0719c26025f7e38a4a38172bf1142a6a9c1930e50df03904312"; - data.compute_tagged_hash(&mut pw, &mut s, 256); + data.compute_tagged_hash(&mut pw, &s, 256); assert!(hex::encode(data.digest.unwrap().to_vec()) == expected); } #[test] fn test_compute_tagged_hash_512() { - let mut s = "".to_owned(); + let s = "".to_owned(); let mut pw = "test".as_bytes().to_vec(); let mut data = Message::new(&mut Box::new("".as_bytes().to_owned())); let expected = "0f9b5dcd47dc08e08a173bbe9a57b1a65784e318cf93cccb7f1f79f186ee1caeff11b12f8ca3a39db82a63f4ca0b65836f5261ee64644ce5a88456d3d30efbed"; - data.compute_tagged_hash(&mut pw, &mut s, 512); + data.compute_tagged_hash(&mut pw, &s, 512); assert!(hex::encode(data.digest.unwrap().to_vec()) == expected); }