mirror of
https://github.com/saymrwulf/curve25519-dalek-source.git
synced 2026-09-04 20:24:10 +00:00
ce46a12d92
The API for this isn't the greatest and I apologise for that. Suggestions for
improvement welcome. One thing which @hdevalence and I considered was to
change the function signature to:
pub fn verify_batch<D, C, M, S, K>(messages: M,
signatures: S,
public_keys: K,
csprng: &mut C) -> Result<(), SignatureError>
where D: Digest<OutputSize = U64> + Default,
C: Rng + CryptoRng,
M: IntoIterator<Item = &[u8]>,
S: IntoIterator,
S::Item: Borrow<Signature>,
K: IntoIterator,
K::Item: Borrow<Signature>,
The other improvement which could be made is to implement 128-bit scalars for
the randomnesses.
* CLOSES #27
102 lines
3.3 KiB
Rust
102 lines
3.3 KiB
Rust
// -*- mode: rust; -*-
|
|
//
|
|
// This file is part of ed25519-dalek.
|
|
// Copyright (c) 2018 Isis Lovecruft
|
|
// See LICENSE for licensing information.
|
|
//
|
|
// Authors:
|
|
// - Isis Agora Lovecruft <isis@patternsinthevoid.net>
|
|
|
|
#[macro_use]
|
|
extern crate criterion;
|
|
extern crate ed25519_dalek;
|
|
extern crate rand;
|
|
extern crate sha2;
|
|
|
|
use criterion::Criterion;
|
|
|
|
mod ed25519_benches {
|
|
use super::*;
|
|
use ed25519_dalek::ExpandedSecretKey;
|
|
use ed25519_dalek::Keypair;
|
|
use ed25519_dalek::PublicKey;
|
|
use ed25519_dalek::Signature;
|
|
use ed25519_dalek::verify_batch;
|
|
use rand::thread_rng;
|
|
use rand::ThreadRng;
|
|
use sha2::Sha512;
|
|
|
|
fn sign(c: &mut Criterion) {
|
|
let mut csprng: ThreadRng = thread_rng();
|
|
let keypair: Keypair = Keypair::generate::<Sha512, _>(&mut csprng);
|
|
let msg: &[u8] = b"";
|
|
|
|
c.bench_function("Ed25519 signing", move |b| {
|
|
b.iter(| | keypair.sign::<Sha512>(msg))
|
|
});
|
|
}
|
|
|
|
fn sign_expanded_key(c: &mut Criterion) {
|
|
let mut csprng: ThreadRng = thread_rng();
|
|
let keypair: Keypair = Keypair::generate::<Sha512, _>(&mut csprng);
|
|
let expanded: ExpandedSecretKey = keypair.secret.expand::<Sha512>();
|
|
let msg: &[u8] = b"";
|
|
|
|
c.bench_function("Ed25519 signing with an expanded secret key", move |b| {
|
|
b.iter(| | expanded.sign::<Sha512>(msg, &keypair.public))
|
|
});
|
|
}
|
|
|
|
fn verify(c: &mut Criterion) {
|
|
let mut csprng: ThreadRng = thread_rng();
|
|
let keypair: Keypair = Keypair::generate::<Sha512, _>(&mut csprng);
|
|
let msg: &[u8] = b"";
|
|
let sig: Signature = keypair.sign::<Sha512>(msg);
|
|
|
|
c.bench_function("Ed25519 signature verification", move |b| {
|
|
b.iter(| | keypair.verify::<Sha512>(msg, &sig))
|
|
});
|
|
}
|
|
|
|
fn verify_batch_signatures(c: &mut Criterion) {
|
|
static BATCH_SIZES: [u8; 6] = [4, 8, 16, 32, 64, 96];
|
|
|
|
c.bench_function_over_inputs(
|
|
"Ed25519 batch signature verification",
|
|
|b, &&size| {
|
|
let mut csprng: ThreadRng = thread_rng();
|
|
let keypairs: Vec<Keypair> = (0..size).map(|_| Keypair::generate::<Sha512, _>(&mut csprng)).collect();
|
|
let msg: &[u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
|
|
let messages: Vec<&[u8]> = (0..size).map(|_| msg).collect();
|
|
let signatures: Vec<Signature> = keypairs.iter().map(|key| key.sign::<Sha512>(&msg)).collect();
|
|
let public_keys: Vec<PublicKey> = keypairs.iter().map(|key| key.public).collect();
|
|
|
|
b.iter(|| verify_batch::<Sha512, _>(&messages[..], &signatures[..], &public_keys[..], &mut csprng));
|
|
},
|
|
&BATCH_SIZES,
|
|
);
|
|
}
|
|
|
|
fn key_generation(c: &mut Criterion) {
|
|
let mut csprng: ThreadRng = thread_rng();
|
|
|
|
c.bench_function("Ed25519 keypair generation", move |b| {
|
|
b.iter(| | Keypair::generate::<Sha512, _>(&mut csprng))
|
|
});
|
|
}
|
|
|
|
criterion_group!{
|
|
name = ed25519_benches;
|
|
config = Criterion::default();
|
|
targets =
|
|
sign,
|
|
sign_expanded_key,
|
|
verify,
|
|
verify_batch_signatures,
|
|
key_generation,
|
|
}
|
|
}
|
|
|
|
criterion_main!(
|
|
ed25519_benches::ed25519_benches,
|
|
);
|