saymrwulf/betrusted-curve25519-dalek-source
1
0
Fork 0
mirror of https://github.com/saymrwulf/betrusted-curve25519-dalek-source.git synced 2026-09-05 20:30:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'release/1.0.0-pre.2'

Browse source
This commit is contained in:
Isis Lovecruft 2019-10-04 02:40:38 +00:00
commit 5870607aa7
No known key found for this signature in database
GPG key ID: AB41313533E8E812
8 changed files with 134 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
.travis.yml
View file

@ -6,23 +6,26 @@ rust:
- nightly
env:
- TEST_COMMAND=test FEATURES=''
- TEST_COMMAND=test EXTRA_FLAGS='' FEATURES=''
matrix:
include:
# We use the 64-bit optimised curve backend by default, so also test with
# the 32-bit backend (this also exercises testing with `no_std`):
- rust: nightly
env: TEST_COMMAND=build FEATURES='--no-default-features --features=u32_backend'
env: TEST_COMMAND=build EXTRA_FLAGS='--no-default-features' FEATURES='u32_backend alloc'
# Also test the batch feature:
- rust: nightly
env: TEST_COMMAND=build EXTRA_FLAGS='--no-default-features' FEATURES='u64_backend alloc batch'
# Test any nightly gated features on nightly:
- rust: nightly
env: TEST_COMMAND=test FEATURES='--features=nightly'
env: TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='nightly'
# Test serde support on stable, assuming that if it works there it'll work everywhere:
- rust: stable
env: TEST_COMMAND=test FEATURE='--features=serde'
env: TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='serde'
script:
- cargo $TEST_COMMAND $FEATURES
- cargo $TEST_COMMAND --features="$FEATURES" $EXTRA_FLAGS
notifications:
slack:

24
Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ed25519-dalek"
version = "1.0.0-pre.1"
version = "1.0.0-pre.2"
authors = ["isis lovecruft <isis@patternsinthevoid.net>"]
readme = "README.md"
license = "BSD-3-Clause"
@ -19,9 +19,19 @@ travis-ci = { repository = "dalek-cryptography/ed25519-dalek", branch = "master"
version = "1"
default-features = false
[dependencies.rand_core]
version = "0.3"
default-features = false
[dependencies.rand]
version = "0.6"
features = ["i128_support"]
default-features = false
optional = true
[dependencies.rand_os]
version = "0.1"
optional = true
[dependencies.serde]
version = "^1.0"
@ -42,16 +52,22 @@ version = "0.2"
hex = "^0.3"
bincode = "^0.9"
criterion = "0.2"
rand = "0.6"
rand_os = "0.1"
[[bench]]
name = "ed25519_benchmarks"
harness = false
# This doesn't seem to work with criterion, cf. https://github.com/bheisler/criterion.rs/issues/344
# For now, we have to bench by doing `cargo bench --features="batch"`.
# required-features = ["batch"]
[features]
default = ["std", "u64_backend"]
std = ["curve25519-dalek/std", "rand/std", "sha2/std"]
alloc = ["curve25519-dalek/alloc"]
nightly = ["curve25519-dalek/nightly", "rand/nightly", "clear_on_drop/nightly"]
std = ["curve25519-dalek/std", "rand_os", "sha2/std"]
alloc = ["curve25519-dalek/alloc", "rand_os"]
nightly = ["curve25519-dalek/nightly", "clear_on_drop/nightly"]
batch = ["rand"]
asm = ["sha2/asm"]
yolocrypto = ["curve25519-dalek/yolocrypto"]
u64_backend = ["curve25519-dalek/u64_backend"]

2
README.md
View file

@ -78,7 +78,7 @@ The numbers after the `/` in the test name refer to the size of the batch:
Ed25519 batch signature verification/256 time: [5.0124 ms 5.0290 ms 5.0491 ms]
As you can see, there's an optimal batch size for each machine, so you'll likely
want to your the benchmarks on your target CPU to discover the best size. For
want to test the benchmarks on your target CPU to discover the best size. For
this machine, around 100 signatures per batch is the optimum:
![](https://github.com/dalek-cryptography/ed25519-dalek/blob/master/res/batch-violin-benchmark.svg)

2
benches/ed25519_benchmarks.rs
View file

@ -22,7 +22,7 @@ mod ed25519_benches {
use ed25519_dalek::Signature;
use ed25519_dalek::verify_batch;
use rand::thread_rng;
use rand::rngs::ThreadRng;
use rand::prelude::ThreadRng;
fn sign(c: &mut Criterion) {
let mut csprng: ThreadRng = thread_rng();

56
src/ed25519.rs
View file

@ -9,10 +9,10 @@
//! ed25519 keypairs and batch verification.
#[allow(unused_imports)]
use core::default::Default;
use rand::CryptoRng;
use rand::Rng;
use rand_core::{CryptoRng, RngCore};
#[cfg(feature = "serde")]
use serde::de::Error as SerdeError;
@ -28,8 +28,11 @@ pub use sha2::Sha512;
use curve25519_dalek::digest::generic_array::typenum::U64;
pub use curve25519_dalek::digest::Digest;
#[cfg(all(feature = "batch", any(feature = "alloc", feature = "std")))]
use curve25519_dalek::constants;
#[cfg(all(feature = "batch", any(feature = "alloc", feature = "std")))]
use curve25519_dalek::edwards::EdwardsPoint;
#[cfg(all(feature = "batch", any(feature = "alloc", feature = "std")))]
use curve25519_dalek::scalar::Scalar;
pub use crate::constants::*;
@ -45,8 +48,7 @@ pub use crate::signature::*;
/// * `messages` is a slice of byte slices, one per signed message.
/// * `signatures` is a slice of `Signature`s.
/// * `public_keys` is a slice of `PublicKey`s.
/// * `csprng` is an implementation of `Rng + CryptoRng`, such as
/// `rand::rngs::ThreadRng`.
/// * `csprng` is an implementation of `Rng + CryptoRng`.
///
/// # Panics
///
@ -63,17 +65,16 @@ pub use crate::signature::*;
///
/// ```
/// extern crate ed25519_dalek;
/// extern crate rand;
/// extern crate rand_os;
///
/// use ed25519_dalek::verify_batch;
/// use ed25519_dalek::Keypair;
/// use ed25519_dalek::PublicKey;
/// use ed25519_dalek::Signature;
/// use rand::thread_rng;
/// use rand::rngs::ThreadRng;
/// use rand_os::OsRng;
///
/// # fn main() {
/// let mut csprng: ThreadRng = thread_rng();
/// let mut csprng: OsRng = OsRng::new().unwrap();
/// let keypairs: Vec<Keypair> = (0..64).map(|_| Keypair::generate(&mut csprng)).collect();
/// let msg: &[u8] = b"They're good dogs Brant";
/// let messages: Vec<&[u8]> = (0..64).map(|_| msg).collect();
@ -84,7 +85,7 @@ pub use crate::signature::*;
/// assert!(result.is_ok());
/// # }
/// ```
#[cfg(any(feature = "alloc", feature = "std"))]
#[cfg(all(feature = "batch", any(feature = "alloc", feature = "std")))]
#[allow(non_snake_case)]
pub fn verify_batch(
messages: &[&[u8]],
@ -92,18 +93,18 @@ pub fn verify_batch(
public_keys: &[PublicKey],
) -> Result<(), SignatureError>
{
const ASSERT_MESSAGE: &'static [u8] = b"The number of messages, signatures, and public keys must be equal.";
const ASSERT_MESSAGE: &'static str = "The number of messages, signatures, and public keys must be equal.";
assert!(signatures.len() == messages.len(), ASSERT_MESSAGE);
assert!(signatures.len() == public_keys.len(), ASSERT_MESSAGE);
assert!(public_keys.len() == messages.len(), ASSERT_MESSAGE);
#[cfg(feature = "alloc")]
use alloc::vec::Vec;
#[cfg(feature = "std")]
use std::vec::Vec;
use core::iter::once;
use rand::thread_rng;
use rand::{Rng, thread_rng};
use curve25519_dalek::traits::IsIdentity;
use curve25519_dalek::traits::VartimeMultiscalarMul;
@ -215,14 +216,15 @@ impl Keypair {
/// # Example
///
/// ```
/// extern crate rand;
/// extern crate rand_core;
/// extern crate rand_os;
/// extern crate ed25519_dalek;
///
/// # #[cfg(feature = "std")]
/// # fn main() {
///
/// use rand::Rng;
/// use rand::rngs::OsRng;
/// use rand_core::{CryptoRng, RngCore};
/// use rand_os::OsRng;
/// use ed25519_dalek::Keypair;
/// use ed25519_dalek::Signature;
///
@ -237,7 +239,7 @@ impl Keypair {
///
/// # Input
///
/// A CSPRNG with a `fill_bytes()` method, e.g. `rand_chacha::ChaChaRng`.
/// A CSPRNG with a `fill_bytes()` method, e.g. `rand_os::OsRng`.
///
/// The caller must also supply a hash function which implements the
/// `Digest` and `Default` traits, and which returns 512 bits of output.
@ -246,7 +248,7 @@ impl Keypair {
/// Other suitable hash functions include Keccak-512 and Blake2b-512.
pub fn generate<R>(csprng: &mut R) -> Keypair
where
R: CryptoRng + Rng,
R: CryptoRng + RngCore,
{
let sk: SecretKey = SecretKey::generate(csprng);
let pk: PublicKey = (&sk).into();
@ -281,17 +283,17 @@ impl Keypair {
///
/// ```
/// extern crate ed25519_dalek;
/// extern crate rand;
/// extern crate rand_os;
///
/// use ed25519_dalek::Digest;
/// use ed25519_dalek::Keypair;
/// use ed25519_dalek::Sha512;
/// use ed25519_dalek::Signature;
/// use rand::thread_rng;
/// use rand_os::OsRng;
///
/// # #[cfg(feature = "std")]
/// # fn main() {
/// let mut csprng = thread_rng();
/// let mut csprng = OsRng::new().unwrap();
/// let keypair: Keypair = Keypair::generate(&mut csprng);
/// let message: &[u8] = b"All I want is to pet all of the dogs.";
///
@ -328,17 +330,17 @@ impl Keypair {
///
/// ```
/// # extern crate ed25519_dalek;
/// # extern crate rand;
/// # extern crate rand_os;
/// #
/// # use ed25519_dalek::Digest;
/// # use ed25519_dalek::Keypair;
/// # use ed25519_dalek::Signature;
/// # use ed25519_dalek::Sha512;
/// # use rand::thread_rng;
/// # use rand_os::OsRng;
/// #
/// # #[cfg(feature = "std")]
/// # fn main() {
/// # let mut csprng = thread_rng();
/// # let mut csprng: OsRng = OsRng::new().unwrap();
/// # let keypair: Keypair = Keypair::generate(&mut csprng);
/// # let message: &[u8] = b"All I want is to pet all of the dogs.";
/// # let mut prehashed: Sha512 = Sha512::new();
@ -399,21 +401,21 @@ impl Keypair {
///
/// ```
/// extern crate ed25519_dalek;
/// extern crate rand;
/// extern crate rand_os;
///
/// use ed25519_dalek::Digest;
/// use ed25519_dalek::Keypair;
/// use ed25519_dalek::Signature;
/// use ed25519_dalek::Sha512;
/// use rand::thread_rng;
/// use rand_os::OsRng;
///
/// # #[cfg(feature = "std")]
/// # fn main() {
/// let mut csprng = thread_rng();
/// let mut csprng: OsRng = OsRng::new().unwrap();
/// let keypair: Keypair = Keypair::generate(&mut csprng);
/// let message: &[u8] = b"All I want is to pet all of the dogs.";
///
/// let mut prehashed: Sha512 = Sha512::default();
/// let mut prehashed: Sha512 = Sha512::new();
/// prehashed.input(message);
///
/// let context: &[u8] = b"Ed25519DalekSignPrehashedDoctest";

76
src/lib.rs
View file

@ -19,13 +19,14 @@
//! the operating system's builtin PRNG:
//!
//! ```
//! extern crate rand;
//! extern crate rand_core;
//! extern crate rand_os;
//! extern crate ed25519_dalek;
//!
//! # #[cfg(feature = "std")]
//! # fn main() {
//! use rand::Rng;
//! use rand::rngs::OsRng;
//! use rand_core::RngCore;
//! use rand_os::OsRng;
//! use ed25519_dalek::Keypair;
//! use ed25519_dalek::Signature;
//!
@ -40,14 +41,15 @@
//! We can now use this `keypair` to sign a message:
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::Keypair;
//! # use ed25519_dalek::Signature;
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! let message: &[u8] = b"This is a test of the tsunami alert system.";
//! let signature: Signature = keypair.sign(message);
@ -58,14 +60,15 @@
//! that `message`:
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::Keypair;
//! # use ed25519_dalek::Signature;
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! # let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature: Signature = keypair.sign(message);
@ -77,15 +80,16 @@
//! verify this signature:
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::Keypair;
//! # use ed25519_dalek::Signature;
//! use ed25519_dalek::PublicKey;
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! # let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature: Signature = keypair.sign(message);
@ -104,14 +108,15 @@
//! verify your signatures!)
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::{Keypair, Signature, PublicKey};
//! use ed25519_dalek::{PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, KEYPAIR_LENGTH, SIGNATURE_LENGTH};
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! # let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature: Signature = keypair.sign(message);
@ -127,14 +132,15 @@
//! And similarly, decoded from bytes with `::from_bytes()`:
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::{Keypair, Signature, PublicKey, SecretKey, SignatureError};
//! # use ed25519_dalek::{PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, KEYPAIR_LENGTH, SIGNATURE_LENGTH};
//! # fn do_test() -> Result<(SecretKey, PublicKey, Keypair, Signature), SignatureError> {
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair_orig: Keypair = Keypair::generate(&mut csprng);
//! # let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature_orig: Signature = keypair_orig.sign(message);
@ -169,7 +175,8 @@
//! For example, using [bincode](https://github.com/TyOverby/bincode):
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # #[cfg(feature = "serde")]
//! extern crate serde;
@ -178,11 +185,11 @@
//!
//! # #[cfg(feature = "serde")]
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::{Keypair, Signature, PublicKey};
//! use bincode::{serialize, Infinite};
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! # let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature: Signature = keypair.sign(message);
@ -200,7 +207,8 @@
//! recipient may deserialise them and verify:
//!
//! ```
//! # extern crate rand;
//! # extern crate rand_core;
//! # extern crate rand_os;
//! # extern crate ed25519_dalek;
//! # #[cfg(feature = "serde")]
//! # extern crate serde;
@ -209,13 +217,13 @@
//! #
//! # #[cfg(feature = "serde")]
//! # fn main() {
//! # use rand::Rng;
//! # use rand::thread_rng;
//! # use rand_core::RngCore;
//! # use rand_os::OsRng;
//! # use ed25519_dalek::{Keypair, Signature, PublicKey};
//! # use bincode::{serialize, Infinite};
//! use bincode::{deserialize};
//!
//! # let mut csprng = thread_rng();
//! # let mut csprng = OsRng::new().unwrap();
//! # let keypair: Keypair = Keypair::generate(&mut csprng);
//! let message: &[u8] = b"This is a test of the tsunami alert system.";
//! # let signature: Signature = keypair.sign(message);
@ -247,10 +255,16 @@
#[macro_use]
extern crate std;
#[cfg(all(feature = "alloc", not(feature = "std")))]
extern crate alloc;
extern crate clear_on_drop;
extern crate curve25519_dalek;
extern crate failure;
#[cfg(all(feature = "batch", any(feature = "std", feature = "alloc", test)))]
extern crate rand;
#[cfg(any(feature = "std", test))]
extern crate rand_os;
extern crate rand_core;
#[cfg(feature = "serde")]
extern crate serde;
extern crate sha2;

50
src/secret.rs
View file

@ -19,8 +19,7 @@ use curve25519_dalek::digest::Digest;
use curve25519_dalek::edwards::CompressedEdwardsY;
use curve25519_dalek::scalar::Scalar;
use rand::CryptoRng;
use rand::Rng;
use rand_core::{CryptoRng, RngCore};
use sha2::Sha512;
@ -126,16 +125,13 @@ impl SecretKey {
/// # Example
///
/// ```
/// extern crate rand;
/// extern crate sha2;
/// extern crate rand_os;
/// extern crate ed25519_dalek;
///
/// # #[cfg(feature = "std")]
/// # fn main() {
/// #
/// use rand::Rng;
/// use rand::rngs::OsRng;
/// use sha2::Sha512;
/// use rand_os::OsRng;
/// use ed25519_dalek::PublicKey;
/// use ed25519_dalek::SecretKey;
/// use ed25519_dalek::Signature;
@ -151,18 +147,17 @@ impl SecretKey {
/// Afterwards, you can generate the corresponding public:
///
/// ```
/// # extern crate rand;
/// # extern crate rand_os;
/// # extern crate ed25519_dalek;
/// #
/// # fn main() {
/// #
/// # use rand::Rng;
/// # use rand::thread_rng;
/// # use rand_os::OsRng;
/// # use ed25519_dalek::PublicKey;
/// # use ed25519_dalek::SecretKey;
/// # use ed25519_dalek::Signature;
/// #
/// # let mut csprng = thread_rng();
/// # let mut csprng = OsRng::new().unwrap();
/// # let secret_key: SecretKey = SecretKey::generate(&mut csprng);
///
/// let public_key: PublicKey = (&secret_key).into();
@ -174,7 +169,7 @@ impl SecretKey {
/// A CSPRNG with a `fill_bytes()` method, e.g. `rand::OsRng`
pub fn generate<T>(csprng: &mut T) -> SecretKey
where
T: CryptoRng + Rng,
T: CryptoRng + RngCore,
{
let mut sk: SecretKey = SecretKey([0u8; 32]);
@ -275,18 +270,18 @@ impl<'a> From<&'a SecretKey> for ExpandedSecretKey {
/// # Examples
///
/// ```
/// # extern crate rand;
/// # extern crate rand_core;
/// # extern crate rand_os;
/// # extern crate sha2;
/// # extern crate ed25519_dalek;
/// #
/// # fn main() {
/// #
/// use rand::Rng;
/// use rand::thread_rng;
/// use sha2::Sha512;
/// use rand_core::RngCore;
/// use rand_os::OsRng;
/// use ed25519_dalek::{SecretKey, ExpandedSecretKey};
///
/// let mut csprng = thread_rng();
/// let mut csprng = OsRng::new().unwrap();
/// let secret_key: SecretKey = SecretKey::generate(&mut csprng);
/// let expanded_secret_key: ExpandedSecretKey = ExpandedSecretKey::from(&secret_key);
/// # }
@ -323,16 +318,14 @@ impl ExpandedSecretKey {
/// # Examples
///
/// ```
/// # extern crate rand;
/// # extern crate rand_os;
/// # extern crate sha2;
/// # extern crate ed25519_dalek;
/// #
/// # #[cfg(all(feature = "sha2", feature = "std"))]
/// # #[cfg(feature = "std")]
/// # fn main() {
/// #
/// use rand::Rng;
/// use rand::rngs::OsRng;
/// use sha2::Sha512;
/// use rand_os::OsRng;
/// use ed25519_dalek::{SecretKey, ExpandedSecretKey};
///
/// let mut csprng: OsRng = OsRng::new().unwrap();
@ -343,7 +336,7 @@ impl ExpandedSecretKey {
/// assert!(&expanded_secret_key_bytes[..] != &[0u8; 64][..]);
/// # }
/// #
/// # #[cfg(any(not(feature = "sha2"), not(feature = "std")))]
/// # #[cfg(not(feature = "std"))]
/// # fn main() { }
/// ```
#[inline]
@ -365,17 +358,16 @@ impl ExpandedSecretKey {
/// # Examples
///
/// ```
/// # extern crate rand;
/// # extern crate rand_os;
/// # extern crate sha2;
/// # extern crate ed25519_dalek;
/// #
/// # use ed25519_dalek::{ExpandedSecretKey, SignatureError};
/// #
/// # #[cfg(all(feature = "sha2", feature = "std"))]
/// # #[cfg(feature = "std")]
/// # fn do_test() -> Result<ExpandedSecretKey, SignatureError> {
/// #
/// use rand::Rng;
/// use rand::rngs::OsRng;
/// use rand_os::OsRng;
/// use ed25519_dalek::{SecretKey, ExpandedSecretKey};
/// use ed25519_dalek::SignatureError;
///
@ -388,13 +380,13 @@ impl ExpandedSecretKey {
/// # Ok(expanded_secret_key_again)
/// # }
/// #
/// # #[cfg(all(feature = "sha2", feature = "std"))]
/// # #[cfg(feature = "std")]
/// # fn main() {
/// # let result = do_test();
/// # assert!(result.is_ok());
/// # }
/// #
/// # #[cfg(any(not(feature = "sha2"), not(feature = "std")))]
/// # #[cfg(not(feature = "std"))]
/// # fn main() { }
/// ```
#[inline]

18
tests/ed25519.rs
View file

@ -13,15 +13,14 @@
extern crate bincode;
extern crate ed25519_dalek;
extern crate hex;
extern crate rand;
extern crate rand_os;
extern crate sha2;
use ed25519_dalek::*;
use hex::FromHex;
use rand::thread_rng;
use rand::rngs::ThreadRng;
use rand_os::OsRng;
use sha2::Sha512;
@ -117,7 +116,6 @@ mod integrations {
#[test]
fn sign_verify() { // TestSignVerify
let mut csprng: ThreadRng;
let keypair: Keypair;
let good_sig: Signature;
let bad_sig: Signature;
@ -125,7 +123,8 @@ mod integrations {
let good: &[u8] = "test message".as_bytes();
let bad: &[u8] = "wrong message".as_bytes();
csprng = thread_rng();
let mut csprng: OsRng = OsRng::new().unwrap();
keypair = Keypair::generate(&mut csprng);
good_sig = keypair.sign(&good);
bad_sig = keypair.sign(&bad);
@ -140,7 +139,6 @@ mod integrations {
#[test]
fn ed25519ph_sign_verify() {
let mut csprng: ThreadRng;
let keypair: Keypair;
let good_sig: Signature;
let bad_sig: Signature;
@ -148,6 +146,8 @@ mod integrations {
let good: &[u8] = b"test message";
let bad: &[u8] = b"wrong message";
let mut csprng: OsRng = OsRng::new().unwrap();
// ugh… there's no `impl Copy for Sha512`… i hope we can all agree these are the same hashes
let mut prehashed_good1: Sha512 = Sha512::default();
prehashed_good1.input(good);
@ -163,7 +163,6 @@ mod integrations {
let context: &[u8] = b"testing testing 1 2 3";
csprng = thread_rng();
keypair = Keypair::generate(&mut csprng);
good_sig = keypair.sign_prehashed(prehashed_good1, Some(context));
bad_sig = keypair.sign_prehashed(prehashed_bad1, Some(context));
@ -176,6 +175,7 @@ mod integrations {
"Verification of a signature on a different message passed!");
}
#[cfg(feature = "batch")]
#[test]
fn verify_batch_seven_signatures() {
let messages: [&[u8]; 7] = [
@ -186,7 +186,7 @@ mod integrations {
b"Fuck dumbin' it down, spit ice, skip jewellery: Molotov cocktails on me like accessories.",
b"Hey, I never cared about your bucks, so if I run up with a mask on, probably got a gas can too.",
b"And I'm not here to fill 'er up. Nope, we came to riot, here to incite, we don't want any of your stuff.", ];
let mut csprng: ThreadRng = thread_rng();
let mut csprng: OsRng = OsRng::new().unwrap();
let mut keypairs: Vec<Keypair> = Vec::new();
let mut signatures: Vec<Signature> = Vec::new();
@ -204,7 +204,7 @@ mod integrations {
#[test]
fn pubkey_from_secret_and_expanded_secret() {
let mut csprng = thread_rng();
let mut csprng = OsRng::new().unwrap();
let secret: SecretKey = SecretKey::generate(&mut csprng);
let expanded_secret: ExpandedSecretKey = (&secret).into();
let public_from_secret: PublicKey = (&secret).into(); // XXX eww