Skip to content

Commit

Permalink
api fix
Browse files Browse the repository at this point in the history
  • Loading branch information
@eschorn1
eschorn1 committed May 23, 2024
1 parent b1d5941 commit b53d7e0
Show file tree
Hide file tree
Showing 16 changed files with 257 additions and 307 deletions.
6 changes: 3 additions & 3 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,16 +33,16 @@ use fips204::traits::{SerDes, Signer, Verifier};
let message = [0u8, 1, 2, 3, 4, 5, 6, 7];

// Generate key pair and signature
let (pk1, sk) = ml_dsa_44::try_keygen_vt()?; // Generate both public and secret keys
let sig = sk.try_sign_ct(&message)?; // Use the secret key to generate a message signature
let (pk1, sk) = ml_dsa_44::try_keygen()?; // Generate both public and secret keys
let sig = sk.try_sign(&message)?; // Use the secret key to generate a message signature

// Serialize then send the public key, message and signature
let (pk_send, msg_send, sig_send) = (pk1.into_bytes(), message, sig);
let (pk_recv, msg_recv, sig_recv) = (pk_send, msg_send, sig_send);

// Deserialize the public key and signature, then verify the message
let pk2 = ml_dsa_44::PublicKey::try_from_bytes(pk_recv)?;
let v = pk2.try_verify_vt(&msg_recv, &sig_recv)?; // Use the public to verify message signature
let v = pk2.try_verify(&msg_recv, &sig_recv)?; // Use the public to verify message signature
assert!(v);
# Ok(())
# }
Expand Down
34 changes: 17 additions & 17 deletions benches/README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,28 +6,28 @@ Near-obvious uplift can be had with more careful modular multiplication & additi
using fewer reductions. Also, 'u16' arithmetic has a performance penalty.

~~~
May 10, 2024
Intel® Core™ i7-7700K CPU @ 4.20GHz × 8 Circa 2017 w/ Rust 1.77
May 23, 2024
Intel® Core™ i7-7700K CPU @ 4.20GHz × 8 Circa 2017 w/ Rust 1.77.2
$ RUSTFLAGS="-C target-cpu=native" cargo bench
ml_dsa_44 keygen time: [85.502 µs 85.521 µs 85.543 µs]
ml_dsa_65 keygen time: [162.17 µs 162.23 µs 162.34 µs]
ml_dsa_87 keygen time: [232.24 µs 232.26 µs 232.28 µs]
ml_dsa_44 keygen time: [81.914 µs 82.700 µs 83.926 µs]
ml_dsa_65 keygen time: [156.96 µs 157.10 µs 157.27 µs]
ml_dsa_87 keygen time: [218.36 µs 218.39 µs 218.43 µs]
ml_dsa_44 sk sign time: [301.10 µs 303.62 µs 306.12 µs]
ml_dsa_65 sk sign time: [486.54 µs 491.62 µs 496.69 µs]
ml_dsa_87 sk sign time: [593.29 µs 599.69 µs 606.20 µs]
ml_dsa_44 sk sign time: [294.03 µs 296.72 µs 299.43 µs]
ml_dsa_65 sk sign time: [467.49 µs 471.89 µs 476.52 µs]
ml_dsa_87 sk sign time: [563.69 µs 571.15 µs 578.91 µs]
ml_dsa_44 esk sign time: [233.84 µs 236.39 µs 239.00 µs]
ml_dsa_65 esk sign time: [375.86 µs 380.61 µs 385.48 µs]
ml_dsa_87 esk sign time: [401.26 µs 406.48 µs 411.66 µs]
ml_dsa_44 esk sign time: [234.98 µs 237.67 µs 240.41 µs]
ml_dsa_65 esk sign time: [369.19 µs 373.82 µs 378.42 µs]
ml_dsa_87 esk sign time: [377.20 µs 383.07 µs 388.71 µs]
ml_dsa 44 pk verify time: [78.619 µs 78.630 µs 78.640 µs]
ml_dsa 65 pk verify time: [130.59 µs 130.64 µs 130.69 µs]
ml_dsa 87 pk verify time: [219.01 µs 219.06 µs 219.12 µs]
ml_dsa_44 pk verify time: [74.240 µs 74.313 µs 74.391 µs]
ml_dsa_65 pk verify time: [123.13 µs 123.21 µs 123.31 µs]
ml_dsa_87 pk verify time: [204.39 µs 204.70 µs 205.27 µs]
ml_dsa 44 epk verify time: [20.677 µs 20.694 µs 20.712 µs]
ml_dsa 65 epk verify time: [26.972 µs 26.980 µs 26.987 µs]
ml_dsa 87 epk verify time: [36.188 µs 36.203 µs 36.218 µs]
ml_dsa_44 epk verify time: [21.200 µs 21.232 µs 21.264 µs]
ml_dsa_65 epk verify time: [26.797 µs 26.815 µs 26.830 µs]
ml_dsa_87 epk verify time: [36.227 µs 36.249 µs 36.265 µs]
~~~
95 changes: 38 additions & 57 deletions benches/benchmark.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@ impl RngCore for TestRng {
fn fill_bytes(&mut self, _out: &mut [u8]) { unimplemented!() }

fn try_fill_bytes(&mut self, out: &mut [u8]) -> Result<(), rand_core::Error> {
out.iter_mut().for_each(|b| *b = 0);
out.iter_mut().for_each(|b| *b = self.value.to_le_bytes()[0]);
out[0..4].copy_from_slice(&self.value.to_be_bytes());
self.value = self.value.wrapping_add(1);
Ok(())
Expand All @@ -28,63 +28,44 @@ impl RngCore for TestRng {
impl CryptoRng for TestRng {}


#[allow(clippy::redundant_closure)]
pub fn criterion_benchmark(c: &mut Criterion) {
let mut bench_rng = TestRng { value: 0 };
let message = [0u8, 1, 2, 3, 4, 5, 6, 7];

let (pk44, sk44) = ml_dsa_44::try_keygen_with_rng_vt(&mut bench_rng).unwrap();
let esk44 = ml_dsa_44::KG::gen_expanded_private_vt(&sk44).unwrap();
let epk44 = ml_dsa_44::KG::gen_expanded_public_vt(&pk44).unwrap();
let sig44 = sk44.try_sign_ct(&message).unwrap();

let (pk65, sk65) = ml_dsa_65::try_keygen_with_rng_vt(&mut bench_rng).unwrap();
let esk65 = ml_dsa_65::KG::gen_expanded_private_vt(&sk65).unwrap();
let epk65 = ml_dsa_65::KG::gen_expanded_public_vt(&pk65).unwrap();
let sig65 = sk65.try_sign_ct(&message).unwrap();

let (pk87, sk87) = ml_dsa_87::try_keygen_with_rng_vt(&mut bench_rng).unwrap();
let esk87 = ml_dsa_87::KG::gen_expanded_private_vt(&sk87).unwrap();
let epk87 = ml_dsa_87::KG::gen_expanded_public_vt(&pk87).unwrap();
let sig87 = sk87.try_sign_ct(&message).unwrap();

c.bench_function("ml_dsa_44 keygen", |b| {
b.iter(|| ml_dsa_44::try_keygen_with_rng_vt(&mut bench_rng))
});
c.bench_function("ml_dsa_65 keygen", |b| {
b.iter(|| ml_dsa_65::try_keygen_with_rng_vt(&mut bench_rng))
});
c.bench_function("ml_dsa_87 keygen", |b| {
b.iter(|| ml_dsa_87::try_keygen_with_rng_vt(&mut bench_rng))
});

c.bench_function("ml_dsa_44 sk sign", |b| {
b.iter(|| sk44.try_sign_with_rng_ct(&mut bench_rng, &message))
});
c.bench_function("ml_dsa_65 sk sign", |b| {
b.iter(|| sk65.try_sign_with_rng_ct(&mut bench_rng, &message))
});
c.bench_function("ml_dsa_87 sk sign", |b| {
b.iter(|| sk87.try_sign_with_rng_ct(&mut bench_rng, &message))
});

c.bench_function("ml_dsa_44 esk sign", |b| {
b.iter(|| esk44.try_sign_with_rng_ct(&mut bench_rng, &message))
});
c.bench_function("ml_dsa_65 esk sign", |b| {
b.iter(|| esk65.try_sign_with_rng_ct(&mut bench_rng, &message))
});
c.bench_function("ml_dsa_87 esk sign", |b| {
b.iter(|| esk87.try_sign_with_rng_ct(&mut bench_rng, &message))
});

c.bench_function("ml_dsa 44 pk verify", |b| b.iter(|| pk44.try_verify_vt(&message, &sig44)));
c.bench_function("ml_dsa 65 pk verify", |b| b.iter(|| pk65.try_verify_vt(&message, &sig65)));
c.bench_function("ml_dsa 87 pk verify", |b| b.iter(|| pk87.try_verify_vt(&message, &sig87)));

c.bench_function("ml_dsa 44 epk verify", |b| b.iter(|| epk44.try_verify_vt(&message, &sig44)));
c.bench_function("ml_dsa 65 epk verify", |b| b.iter(|| epk65.try_verify_vt(&message, &sig65)));
c.bench_function("ml_dsa 87 epk verify", |b| b.iter(|| epk87.try_verify_vt(&message, &sig87)));
let mut rng = TestRng { value: 0 };
let msg = [0u8, 1, 2, 3, 4, 5, 6, 7];

let (pk44, sk44) = ml_dsa_44::try_keygen_with_rng(&mut rng).unwrap();
let esk44 = ml_dsa_44::KG::gen_expanded_private(&sk44).unwrap();
let epk44 = ml_dsa_44::KG::gen_expanded_public(&pk44).unwrap();
let sig44 = sk44.try_sign(&msg).unwrap();

let (pk65, sk65) = ml_dsa_65::try_keygen_with_rng(&mut rng).unwrap();
let esk65 = ml_dsa_65::KG::gen_expanded_private(&sk65).unwrap();
let epk65 = ml_dsa_65::KG::gen_expanded_public(&pk65).unwrap();
let sig65 = sk65.try_sign(&msg).unwrap();

let (pk87, sk87) = ml_dsa_87::try_keygen_with_rng(&mut rng).unwrap();
let esk87 = ml_dsa_87::KG::gen_expanded_private(&sk87).unwrap();
let epk87 = ml_dsa_87::KG::gen_expanded_public(&pk87).unwrap();
let sig87 = sk87.try_sign(&msg).unwrap();

c.bench_function("ml_dsa_44 keygen", |b| b.iter(|| ml_dsa_44::try_keygen_with_rng(&mut rng)));
c.bench_function("ml_dsa_65 keygen", |b| b.iter(|| ml_dsa_65::try_keygen_with_rng(&mut rng)));
c.bench_function("ml_dsa_87 keygen", |b| b.iter(|| ml_dsa_87::try_keygen_with_rng(&mut rng)));

c.bench_function("ml_dsa_44 sk sign", |b| b.iter(|| sk44.try_sign_with_rng(&mut rng, &msg)));
c.bench_function("ml_dsa_65 sk sign", |b| b.iter(|| sk65.try_sign_with_rng(&mut rng, &msg)));
c.bench_function("ml_dsa_87 sk sign", |b| b.iter(|| sk87.try_sign_with_rng(&mut rng, &msg)));

c.bench_function("ml_dsa_44 esk sign", |b| b.iter(|| esk44.try_sign_with_rng(&mut rng, &msg)));
c.bench_function("ml_dsa_65 esk sign", |b| b.iter(|| esk65.try_sign_with_rng(&mut rng, &msg)));
c.bench_function("ml_dsa_87 esk sign", |b| b.iter(|| esk87.try_sign_with_rng(&mut rng, &msg)));

c.bench_function("ml_dsa_44 pk verify", |b| b.iter(|| pk44.try_verify(&msg, &sig44)));
c.bench_function("ml_dsa_65 pk verify", |b| b.iter(|| pk65.try_verify(&msg, &sig65)));
c.bench_function("ml_dsa_87 pk verify", |b| b.iter(|| pk87.try_verify(&msg, &sig87)));

c.bench_function("ml_dsa_44 epk verify", |b| b.iter(|| epk44.try_verify(&msg, &sig44)));
c.bench_function("ml_dsa_65 epk verify", |b| b.iter(|| epk65.try_verify(&msg, &sig65)));
c.bench_function("ml_dsa_87 epk verify", |b| b.iter(|| epk87.try_verify(&msg, &sig87)));
}

criterion_group!(benches, criterion_benchmark);
Expand Down
5 changes: 1 addition & 4 deletions ct_cm4/src/main.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,6 @@ use fips204::{ml_dsa_44::PublicKey, traits::{SerDes, Verifier}};
use hex_literal::hex;
use microbit::{board::Board, hal::{pac::DWT, prelude::OutputPin}};
use rtt_target::{rprintln, rtt_init_print};
//use panic_halt as _;
use panic_rtt_target as _;


Expand All @@ -28,8 +27,6 @@ fn main() -> ! {

let mut i = 0u32;
let pk = PublicKey::try_from_bytes(PUBLIC_KEY).unwrap();
//let (_pk, _sk) = ml_dsa_44::KG::try_keygen_with_rng_vt(&mut my_rng).unwrap();
//let _res = sk.try_sign_with_rng_ct(&mut my_rng, &message);

loop {
if (i % 10) == 0 { board.display_pins.row1.set_high().unwrap(); };
Expand All @@ -40,7 +37,7 @@ fn main() -> ! {
let start = DWT::cycle_count();
asm::isb();

assert!(pk.try_verify_vt(&MESSAGE, &SIGNATURE).unwrap()); // Use the public to verify message signature
assert!(pk.try_verify(&MESSAGE, &SIGNATURE).unwrap()); // Use the public to verify message signature

asm::isb();
let finish = DWT::cycle_count();
Expand Down
36 changes: 20 additions & 16 deletions dudect/README.md
View file
Original file line number Diff line number Diff line change
@@ -1,21 +1,25 @@
An example constant-time workbench. It can be sensitive to config/defaults, so is
not entirely definitive. A work in progress.

Need to rework the rng (to return hardcoded values)
See <https://docs.rs/dudect-bencher/latest/dudect_bencher/>

> t-values greater than 5 are generally considered a good indication that the function is not constant time. t-values less than 5 does not necessarily imply that the function is constant-time, since there may be other input distributions under which the function behaves significantly differently.
~~~
See https://docs.rs/dudect-bencher/latest/dudect_bencher/
May 22, 2024
Intel® Core™ i7-7700K CPU @ 4.20GHz × 8 Circa 2017 Rust 1.70
$ cd dudect # this directory
$ RUSTFLAGS="-C target-cpu=native" cargo run --release -- --continuous keygen_and_sign
$ RUSTFLAGS="-C target-cpu=native" cargo run --release
$ RUSTFLAGS="-C target-cpu=native" cargo run --release -- --continuous sign
running 1 benchmark continuously
bench sign seeded with 0x9eddf0cb1f0a9394
bench sign ... : n == +0.001M, max t = -1.74343, max tau = -0.05337, (5/tau)^2 = 8776
bench sign ... : n == +0.004M, max t = +1.30450, max tau = +0.02111, (5/tau)^2 = 56105
bench sign ... : n == +0.006M, max t = +2.70976, max tau = +0.03579, (5/tau)^2 = 19519
bench sign ... : n == +0.008M, max t = +1.72776, max tau = +0.01975, (5/tau)^2 = 64091
bench sign ... : n == +0.010M, max t = +2.67128, max tau = +0.02695, (5/tau)^2 = 34428
bench sign ... : n == +0.012M, max t = +2.25015, max tau = +0.02098, (5/tau)^2 = 56802
bench sign ... : n == +0.014M, max t = +2.15358, max tau = +0.01844, (5/tau)^2 = 73502
bench sign ... : n == +0.015M, max t = +2.17601, max tau = +0.01778, (5/tau)^2 = 79081
bench sign ... : n == +0.017M, max t = +1.73582, max tau = +0.01338, (5/tau)^2 = 139641
bench sign ... : n == +0.019M, max t = +1.42413, max tau = +0.01041, (5/tau)^2 = 230567
bench keygen_and_sign seeded with 0x826d7088eeda2cad
bench keygen_and_sign ... : n == +0.102M, max t = -1.97046, max tau = -0.00616, (5/tau)^2 = 659312
bench keygen_and_sign ... : n == +0.260M, max t = -2.25947, max tau = -0.00443, (5/tau)^2 = 1271689
bench keygen_and_sign ... : n == +0.388M, max t = -2.81974, max tau = -0.00453, (5/tau)^2 = 1220064
bench keygen_and_sign ... : n == +0.519M, max t = -2.66709, max tau = -0.00370, (5/tau)^2 = 1823937
bench keygen_and_sign ... : n == +0.657M, max t = -2.92324, max tau = -0.00361, (5/tau)^2 = 1920968
bench keygen_and_sign ... : n == +0.779M, max t = -3.22059, max tau = -0.00365, (5/tau)^2 = 1878485
bench keygen_and_sign ... : n == +0.923M, max t = -3.54252, max tau = -0.00369, (5/tau)^2 = 1839152
bench keygen_and_sign ... : n == +1.065M, max t = -4.01591, max tau = -0.00389, (5/tau)^2 = 1651285
...
~~~
46 changes: 13 additions & 33 deletions dudect/src/main.rs
View file
Original file line number Diff line number Diff line change
@@ -1,15 +1,10 @@
use dudect_bencher::{ctbench_main, BenchRng, Class, CtRunner};
use fips204::ml_dsa_44; // Could also be ml_dsa_65 or ml_dsa_87.
use fips204::traits::{KeyGen, SerDes, Signer};
use rand_core::{CryptoRng, RngCore};
use fips204::ml_dsa_44::PrivateKey;

// Test RNG to regurgitate incremented values when 'asked'
#[repr(align(8))]
#[derive(Clone)]
struct TestRng {
value: u8,
}
struct TestRng { value: u32 }

impl RngCore for TestRng {
fn next_u32(&mut self) -> u32 { unimplemented!() }
Expand All @@ -19,55 +14,40 @@ impl RngCore for TestRng {
fn fill_bytes(&mut self, _out: &mut [u8]) { unimplemented!() }

fn try_fill_bytes(&mut self, out: &mut [u8]) -> Result<(), rand_core::Error> {
out.iter_mut().for_each(|b| *b = self.value);
//self.value = self.value.wrapping_add(1);
out.iter_mut().for_each(|b| *b = self.value.to_le_bytes()[0]);
out[0..4].copy_from_slice(&self.value.to_le_bytes());
self.value = self.value.wrapping_add(1);
Ok(())
}
}

impl CryptoRng for TestRng {}


// TODO: note to self. goal is to show timing is independent of secret key, not randomness nor message.
// so rnd gen could be kept constant

fn sign(runner: &mut CtRunner, mut _rng: &mut BenchRng) {
const ITERATIONS_INNER: usize = 1024;
const ITERATIONS_OUTER: usize = 1024;
fn keygen_and_sign(runner: &mut CtRunner, mut _rng: &mut BenchRng) {
const ITERATIONS_INNER: usize = 5;
const ITERATIONS_OUTER: usize = 200 * 1024;

let message = [0u8, 1, 2, 3, 4, 5, 6, 7];

let mut rng_right = TestRng {value: 12};
//let (_pk1, sk_right) = ml_dsa_44::try_keygen_with_rng_vt(&mut rng_right).unwrap(); // Generate both public and secret keys
//let esk_right = ml_dsa_44::KG::gen_expanded_private_vt(&sk_right).unwrap();
let mut rng_left = TestRng {value: 56};
//let (_pk2, sk_left) = ml_dsa_44::try_keygen_with_rng_vt(&mut rng_left).unwrap(); // Generate both public and secret keys
//let esk_left = ml_dsa_44::KG::gen_expanded_private_vt(&sk_left).unwrap();

let mut classes = [Class::Right; ITERATIONS_OUTER];
let mut refs: [(TestRng, PrivateKey); ITERATIONS_OUTER] = core::array::from_fn(|_| {
let (_pk1, sk_right) = ml_dsa_44::try_keygen_with_rng_vt(&mut rng_right).unwrap();
(TestRng {value: 12}, sk_right)
});
let mut refs: [TestRng; ITERATIONS_OUTER] = core::array::from_fn(|_| TestRng {value: 12});

// Interleave left and right
for i in (0..ITERATIONS_OUTER).step_by(2) {
classes[i] = Class::Left;
let (_pk2, sk_left) = ml_dsa_44::try_keygen_with_rng_vt(&mut rng_left).unwrap();
refs[i] = (TestRng {value: 56}, sk_left);
refs[i] = TestRng {value: 56};
}

for (class, sk) in classes.into_iter().zip(refs.into_iter()) {
for (class, rng) in classes.into_iter().zip(refs.into_iter()) {
runner.run_one(class, || {
let mut rng = sk.0.clone();
let mut rng = rng.clone();
for _ in 0..ITERATIONS_INNER {
let _ = ml_dsa_44::dudect_keygen_sign_with_rng(&mut rng, &message);
//let (_pk, skX) = ml_dsa_44::try_keygen_with_rng_vt(&mut rng).unwrap();
//let _ = ml_dsa_44::KG::gen_expanded_private_vt(&sk).unwrap(); // ONLY DOES SIGN START
//let _ = skX.try_sign_with_rng_ct(&mut rng, &message);
let _ = ml_dsa_44::dudect_keygen_sign_with_rng(&mut rng, &message).unwrap();
}
})
}
}

ctbench_main!(sign);
ctbench_main!(keygen_and_sign);
26 changes: 13 additions & 13 deletions fuzz/fuzz_targets/fuzz_all.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,8 +7,8 @@ use fips204::traits::{KeyGen, SerDes, Signer, Verifier};
fuzz_target!(|data: [u8; 2560+2420+1312]| { // sk_len + sig_len + pk_len = 6292

// A good reference set
let (pk_good, sk_good) = KG::try_keygen_vt().unwrap();
let sig_good = sk_good.try_sign_ct(&[0u8, 1, 2, 3]).unwrap();
let (pk_good, sk_good) = KG::try_keygen().unwrap();
let sig_good = sk_good.try_sign(&[0u8, 1, 2, 3]).unwrap();

// Extract then deserialize a 'fuzzy' secret key
let sk_bytes = data[0..2560].try_into().unwrap();
Expand All @@ -23,31 +23,31 @@ fuzz_target!(|data: [u8; 2560+2420+1312]| { // sk_len + sig_len + pk_len = 6292

// Try to use 'fuzzy' sk
if let Ok(ref sk) = sk_fuzz {
let sig1 = sk.try_sign_ct(&[0u8, 1, 2, 3]).unwrap();
let sk2 = KG::gen_expanded_private_vt(&sk).unwrap();
let sig2 = sk2.try_sign_ct(&[4u8, 5, 6, 7]).unwrap();
let sig1 = sk.try_sign(&[0u8, 1, 2, 3]).unwrap();
let sk2 = KG::gen_expanded_private(&sk).unwrap();
let sig2 = sk2.try_sign(&[4u8, 5, 6, 7]).unwrap();
// ...with good pk
let res = pk_good.try_verify_vt(&[0u8, 1, 2, 3], &sig1);
let res = pk_good.try_verify(&[0u8, 1, 2, 3], &sig1);
assert!(res.is_err() || !res.unwrap());
let res = pk_good.try_verify_vt(&[0u8, 1, 2, 3], &sig2);
let res = pk_good.try_verify(&[0u8, 1, 2, 3], &sig2);
assert!(res.is_err() || !res.unwrap());
}

// Try to use 'fuzzy' pk
if let Ok(ref pk) = pk_fuzz {
let res = pk.try_verify_vt(&[0u8, 1, 2, 3], &sig_fuzz);
let res = pk.try_verify(&[0u8, 1, 2, 3], &sig_fuzz);
assert!(res.is_err() || !res.unwrap());
let pk2 = KG::gen_expanded_public_vt(&pk).unwrap();
let res = pk2.try_verify_vt(&[0u8, 1, 2, 3], &sig_fuzz);
let pk2 = KG::gen_expanded_public(&pk).unwrap();
let res = pk2.try_verify(&[0u8, 1, 2, 3], &sig_fuzz);
assert!(res.is_err() || !res.unwrap());
// .. with good sig
let res = pk2.try_verify_vt(&[0u8, 1, 2, 3], &sig_good);
let res = pk2.try_verify(&[0u8, 1, 2, 3], &sig_good);
assert!(res.is_err() || !res.unwrap());
}

// Try to use 'fuzzy' sk and 'fuzzy' pk
if let (Ok(sk), Ok(pk)) = (sk_fuzz, pk_fuzz) {
let _sig = sk.try_sign_ct(&[0u8, 1, 2, 3]).unwrap();
let _v = pk.try_verify_vt(&[0u8, 1, 2, 3], &sig_fuzz).unwrap();
let _sig = sk.try_sign(&[0u8, 1, 2, 3]).unwrap();
let _v = pk.try_verify(&[0u8, 1, 2, 3], &sig_fuzz).unwrap();
}
});
Loading

0 comments on commit b53d7e0

Please sign in to comment.