From 4ada2f61c5b0dde492b12a1877ca73ec87de7dc6 Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Sun, 28 Jul 2024 10:31:35 -0600 Subject: [PATCH 1/5] [WIP] Bump `digest`, `ed25519`, `signature`, and `sha2` Bumps the aforementioned dependencies to their latest (pre)releases --- curve25519-dalek/Cargo.toml | 4 ++-- curve25519-dalek/src/edwards.rs | 2 +- curve25519-dalek/src/ristretto.rs | 2 +- curve25519-dalek/src/scalar.rs | 2 +- ed25519-dalek/Cargo.toml | 11 +++++------ ed25519-dalek/src/hazmat.rs | 2 +- ed25519-dalek/src/signing.rs | 2 +- ed25519-dalek/src/verifying.rs | 2 +- 8 files changed, 13 insertions(+), 14 deletions(-) diff --git a/curve25519-dalek/Cargo.toml b/curve25519-dalek/Cargo.toml index f0896ba74..13eaf6acc 100644 --- a/curve25519-dalek/Cargo.toml +++ b/curve25519-dalek/Cargo.toml @@ -30,7 +30,7 @@ rustdoc-args = [ features = ["serde", "rand_core", "digest", "legacy_compatibility", "group-bits"] [dev-dependencies] -sha2 = { version = "0.10", default-features = false } +sha2 = { version = "=0.11.0-pre.4", default-features = false } bincode = "1" criterion = { version = "0.5", features = ["html_reports"] } hex = "0.4.2" @@ -50,7 +50,7 @@ cfg-if = "1" ff = { version = "0.13", default-features = false, optional = true } group = { version = "0.13", default-features = false, optional = true } rand_core = { version = "0.6.4", default-features = false, optional = true } -digest = { version = "0.10", default-features = false, optional = true } +digest = { version = "=0.11.0-pre.9", default-features = false, optional = true } subtle = { version = "2.6.0", default-features = false } serde = { version = "1.0", default-features = false, optional = true, features = ["derive"] } zeroize = { version = "1", default-features = false, optional = true } diff --git a/curve25519-dalek/src/edwards.rs b/curve25519-dalek/src/edwards.rs index 856fac12f..9b5770901 100644 --- a/curve25519-dalek/src/edwards.rs +++ b/curve25519-dalek/src/edwards.rs @@ -104,7 +104,7 @@ use core::ops::{Mul, MulAssign}; use cfg_if::cfg_if; #[cfg(feature = "digest")] -use digest::{generic_array::typenum::U64, Digest}; +use digest::{array::typenum::U64, Digest}; #[cfg(feature = "group")] use { diff --git a/curve25519-dalek/src/ristretto.rs b/curve25519-dalek/src/ristretto.rs index c9d16aba3..3877fd53c 100644 --- a/curve25519-dalek/src/ristretto.rs +++ b/curve25519-dalek/src/ristretto.rs @@ -173,7 +173,7 @@ use core::ops::{Mul, MulAssign}; use rand_core::CryptoRngCore; #[cfg(feature = "digest")] -use digest::generic_array::typenum::U64; +use digest::array::typenum::U64; #[cfg(feature = "digest")] use digest::Digest; diff --git a/curve25519-dalek/src/scalar.rs b/curve25519-dalek/src/scalar.rs index 6afd74eef..9081271d0 100644 --- a/curve25519-dalek/src/scalar.rs +++ b/curve25519-dalek/src/scalar.rs @@ -134,7 +134,7 @@ use rand_core::RngCore; use rand_core::CryptoRngCore; #[cfg(feature = "digest")] -use digest::generic_array::typenum::U64; +use digest::array::typenum::U64; #[cfg(feature = "digest")] use digest::Digest; diff --git a/ed25519-dalek/Cargo.toml b/ed25519-dalek/Cargo.toml index 626b8da92..fd273bc94 100644 --- a/ed25519-dalek/Cargo.toml +++ b/ed25519-dalek/Cargo.toml @@ -27,9 +27,9 @@ features = ["batch", "digest", "hazmat", "pem", "serde"] [dependencies] curve25519-dalek = { version = "4", path = "../curve25519-dalek", default-features = false, features = ["digest"] } -ed25519 = { version = ">=2.2, <2.3", default-features = false } -signature = { version = ">=2.0, <2.3", optional = true, default-features = false } -sha2 = { version = "0.10", default-features = false } +ed25519 = { version = "=2.3.0-pre.0", default-features = false } +signature = { version = "=2.3.0-pre.4", optional = true, default-features = false } +sha2 = { version = "=0.11.0-pre.4", default-features = false } subtle = { version = "2.3.0", default-features = false } # optional features @@ -41,8 +41,8 @@ zeroize = { version = "1.5", default-features = false, optional = true } [dev-dependencies] curve25519-dalek = { version = "4", path = "../curve25519-dalek", default-features = false, features = ["digest", "rand_core"] } x25519-dalek = { version = "2", path = "../x25519-dalek", default-features = false, features = ["static_secrets"] } -blake2 = "0.10" -sha3 = "0.10" +blake2 = "=0.11.0-pre.4" +sha3 = "=0.11.0-pre.4" hex = "0.4" bincode = "1.0" serde_json = "1.0" @@ -63,7 +63,6 @@ default = ["fast", "std", "zeroize"] alloc = ["curve25519-dalek/alloc", "ed25519/alloc", "serde?/alloc", "zeroize/alloc"] std = ["alloc", "ed25519/std", "serde?/std", "sha2/std"] -asm = ["sha2/asm"] batch = ["alloc", "merlin", "rand_core"] fast = ["curve25519-dalek/precomputed-tables"] digest = ["signature/digest"] diff --git a/ed25519-dalek/src/hazmat.rs b/ed25519-dalek/src/hazmat.rs index 784961304..f99ecc5b8 100644 --- a/ed25519-dalek/src/hazmat.rs +++ b/ed25519-dalek/src/hazmat.rs @@ -22,7 +22,7 @@ use zeroize::{Zeroize, ZeroizeOnDrop}; // These are used in the functions that are made public when the hazmat feature is set use crate::{Signature, VerifyingKey}; -use curve25519_dalek::digest::{generic_array::typenum::U64, Digest}; +use curve25519_dalek::digest::{array::typenum::U64, Digest}; /// Contains the secret scalar and domain separator used for generating signatures. /// diff --git a/ed25519-dalek/src/signing.rs b/ed25519-dalek/src/signing.rs index 8999f50d2..e7dd7fcee 100644 --- a/ed25519-dalek/src/signing.rs +++ b/ed25519-dalek/src/signing.rs @@ -24,7 +24,7 @@ use sha2::Sha512; use subtle::{Choice, ConstantTimeEq}; use curve25519_dalek::{ - digest::{generic_array::typenum::U64, Digest}, + digest::{array::typenum::U64, Digest}, edwards::{CompressedEdwardsY, EdwardsPoint}, scalar::Scalar, }; diff --git a/ed25519-dalek/src/verifying.rs b/ed25519-dalek/src/verifying.rs index 246951b44..0e85ac345 100644 --- a/ed25519-dalek/src/verifying.rs +++ b/ed25519-dalek/src/verifying.rs @@ -13,7 +13,7 @@ use core::fmt::Debug; use core::hash::{Hash, Hasher}; use curve25519_dalek::{ - digest::{generic_array::typenum::U64, Digest}, + digest::{array::typenum::U64, Digest}, edwards::{CompressedEdwardsY, EdwardsPoint}, montgomery::MontgomeryPoint, scalar::Scalar, From 44508ba8652ae3445608ad3c56b63ef528ddfb93 Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Sun, 28 Jul 2024 10:36:42 -0600 Subject: [PATCH 2/5] Bump ed25519-dalek version --- ed25519-dalek/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ed25519-dalek/Cargo.toml b/ed25519-dalek/Cargo.toml index fd273bc94..484ab91e9 100644 --- a/ed25519-dalek/Cargo.toml +++ b/ed25519-dalek/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ed25519-dalek" -version = "2.1.1" +version = "2.2.0-pre" edition = "2021" authors = [ "isis lovecruft ", From e7d61b5621b80fc6adcfa56f03eee383d7b06e41 Mon Sep 17 00:00:00 2001 From: Arthur Gautier Date: Mon, 30 Sep 2024 16:46:53 -0700 Subject: [PATCH 3/5] ed25519-dalek: fixup pkcs8 API break (#709) --- .github/workflows/ed25519-dalek.yml | 4 ++-- .github/workflows/workspace.yml | 2 +- Cargo.toml | 2 ++ .../src/backend/vector/avx2/edwards.rs | 2 +- .../src/backend/vector/packed_simd.rs | 12 +++++++++-- curve25519-dalek/src/edwards.rs | 18 ++++++++--------- curve25519-dalek/src/montgomery.rs | 4 ++-- curve25519-dalek/src/ristretto.rs | 20 +++++++++---------- ed25519-dalek/Cargo.toml | 2 +- ed25519-dalek/src/signing.rs | 6 +++--- 10 files changed, 41 insertions(+), 31 deletions(-) diff --git a/.github/workflows/ed25519-dalek.yml b/.github/workflows/ed25519-dalek.yml index a49d83450..406864624 100644 --- a/.github/workflows/ed25519-dalek.yml +++ b/.github/workflows/ed25519-dalek.yml @@ -20,7 +20,7 @@ env: jobs: msrv: - name: Current MSRV is 1.60.0 + name: Current MSRV is 1.72.0 runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 @@ -29,5 +29,5 @@ jobs: - run: cargo update -Z minimal-versions # Now check that `cargo build` works with respect to the oldest possible # deps and the stated MSRV - - uses: dtolnay/rust-toolchain@1.60.0 + - uses: dtolnay/rust-toolchain@1.72.0 - run: cargo build diff --git a/.github/workflows/workspace.yml b/.github/workflows/workspace.yml index b8e44dc50..5e7fa44e5 100644 --- a/.github/workflows/workspace.yml +++ b/.github/workflows/workspace.yml @@ -85,7 +85,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@1.73.0 + - uses: dtolnay/rust-toolchain@1.81.0 with: components: clippy - run: cargo clippy --target x86_64-unknown-linux-gnu --all-features diff --git a/Cargo.toml b/Cargo.toml index a891c6705..9bc2cba16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,3 +10,5 @@ resolver = "2" [profile.dev] opt-level = 2 +[patch.crates-io] +ed25519 = { git = "https://github.com/RustCrypto/signatures.git" } diff --git a/curve25519-dalek/src/backend/vector/avx2/edwards.rs b/curve25519-dalek/src/backend/vector/avx2/edwards.rs index fd70d7d2f..4909ce15e 100644 --- a/curve25519-dalek/src/backend/vector/avx2/edwards.rs +++ b/curve25519-dalek/src/backend/vector/avx2/edwards.rs @@ -14,7 +14,7 @@ //! This module currently has two point types: //! //! * `ExtendedPoint`: a point stored in vector-friendly format, with -//! vectorized doubling and addition; +//! vectorized doubling and addition; //! //! * `CachedPoint`: used for readdition. //! diff --git a/curve25519-dalek/src/backend/vector/packed_simd.rs b/curve25519-dalek/src/backend/vector/packed_simd.rs index fe83b1865..61912db4f 100644 --- a/curve25519-dalek/src/backend/vector/packed_simd.rs +++ b/curve25519-dalek/src/backend/vector/packed_simd.rs @@ -240,7 +240,9 @@ impl u64x4 { pub const fn new_const(x0: u64, x1: u64, x2: u64, x3: u64) -> Self { // SAFETY: Transmuting between an array and a SIMD type is safe // https://rust-lang.github.io/unsafe-code-guidelines/layout/packed-simd-vectors.html - unsafe { Self(core::mem::transmute([x0, x1, x2, x3])) } + unsafe { + Self(core::mem::transmute::<[u64; 4], core::arch::x86_64::__m256i>([x0, x1, x2, x3])) + } } /// A constified variant of `splat`. @@ -290,7 +292,13 @@ impl u32x8 { ) -> Self { // SAFETY: Transmuting between an array and a SIMD type is safe // https://rust-lang.github.io/unsafe-code-guidelines/layout/packed-simd-vectors.html - unsafe { Self(core::mem::transmute([x0, x1, x2, x3, x4, x5, x6, x7])) } + unsafe { + Self( + core::mem::transmute::<[u32; 8], core::arch::x86_64::__m256i>([ + x0, x1, x2, x3, x4, x5, x6, x7, + ]), + ) + } } /// A constified variant of `splat`. diff --git a/curve25519-dalek/src/edwards.rs b/curve25519-dalek/src/edwards.rs index 9b5770901..2fa9f9900 100644 --- a/curve25519-dalek/src/edwards.rs +++ b/curve25519-dalek/src/edwards.rs @@ -52,19 +52,19 @@ //! Scalar multiplication on Edwards points is provided by: //! //! * the `*` operator between a `Scalar` and a `EdwardsPoint`, which -//! performs constant-time variable-base scalar multiplication; +//! performs constant-time variable-base scalar multiplication; //! //! * the `*` operator between a `Scalar` and a -//! `EdwardsBasepointTable`, which performs constant-time fixed-base -//! scalar multiplication; +//! `EdwardsBasepointTable`, which performs constant-time fixed-base +//! scalar multiplication; //! //! * an implementation of the -//! [`MultiscalarMul`](../traits/trait.MultiscalarMul.html) trait for -//! constant-time variable-base multiscalar multiplication; +//! [`MultiscalarMul`](../traits/trait.MultiscalarMul.html) trait for +//! constant-time variable-base multiscalar multiplication; //! //! * an implementation of the -//! [`VartimeMultiscalarMul`](../traits/trait.VartimeMultiscalarMul.html) -//! trait for variable-time variable-base multiscalar multiplication; +//! [`VartimeMultiscalarMul`](../traits/trait.VartimeMultiscalarMul.html) +//! trait for variable-time variable-base multiscalar multiplication; //! //! ## Implementation //! @@ -1234,9 +1234,9 @@ impl EdwardsPoint { /// # Return /// /// * `true` if `self` has zero torsion component and is in the - /// prime-order subgroup; + /// prime-order subgroup; /// * `false` if `self` has a nonzero torsion component and is not - /// in the prime-order subgroup. + /// in the prime-order subgroup. /// /// # Example /// diff --git a/curve25519-dalek/src/montgomery.rs b/curve25519-dalek/src/montgomery.rs index 2be35cdc7..50fe4ddac 100644 --- a/curve25519-dalek/src/montgomery.rs +++ b/curve25519-dalek/src/montgomery.rs @@ -209,10 +209,10 @@ impl MontgomeryPoint { /// # Return /// /// * `Some(EdwardsPoint)` if `self` is the \\(u\\)-coordinate of a - /// point on (the Montgomery form of) Curve25519; + /// point on (the Montgomery form of) Curve25519; /// /// * `None` if `self` is the \\(u\\)-coordinate of a point on the - /// twist of (the Montgomery form of) Curve25519; + /// twist of (the Montgomery form of) Curve25519; /// pub fn to_edwards(&self, sign: u8) -> Option { // To decompress the Montgomery u coordinate to an diff --git a/curve25519-dalek/src/ristretto.rs b/curve25519-dalek/src/ristretto.rs index 3877fd53c..5a79d3e41 100644 --- a/curve25519-dalek/src/ristretto.rs +++ b/curve25519-dalek/src/ristretto.rs @@ -93,19 +93,19 @@ //! Scalar multiplication on Ristretto points is provided by: //! //! * the `*` operator between a `Scalar` and a `RistrettoPoint`, which -//! performs constant-time variable-base scalar multiplication; +//! performs constant-time variable-base scalar multiplication; //! //! * the `*` operator between a `Scalar` and a -//! `RistrettoBasepointTable`, which performs constant-time fixed-base -//! scalar multiplication; +//! `RistrettoBasepointTable`, which performs constant-time fixed-base +//! scalar multiplication; //! //! * an implementation of the -//! [`MultiscalarMul`](../traits/trait.MultiscalarMul.html) trait for -//! constant-time variable-base multiscalar multiplication; +//! [`MultiscalarMul`](../traits/trait.MultiscalarMul.html) trait for +//! constant-time variable-base multiscalar multiplication; //! //! * an implementation of the -//! [`VartimeMultiscalarMul`](../traits/trait.VartimeMultiscalarMul.html) -//! trait for variable-time variable-base multiscalar multiplication; +//! [`VartimeMultiscalarMul`](../traits/trait.VartimeMultiscalarMul.html) +//! trait for variable-time variable-base multiscalar multiplication; //! //! ## Random Points and Hashing to Ristretto //! @@ -113,11 +113,11 @@ //! used to implement //! //! * `RistrettoPoint::random()`, which generates random points from an -//! RNG - enabled by `rand_core` feature; +//! RNG - enabled by `rand_core` feature; //! //! * `RistrettoPoint::from_hash()` and -//! `RistrettoPoint::hash_from_bytes()`, which perform hashing to the -//! group. +//! `RistrettoPoint::hash_from_bytes()`, which perform hashing to the +//! group. //! //! The Elligator map itself is not currently exposed. //! diff --git a/ed25519-dalek/Cargo.toml b/ed25519-dalek/Cargo.toml index 484ab91e9..8045338be 100644 --- a/ed25519-dalek/Cargo.toml +++ b/ed25519-dalek/Cargo.toml @@ -16,7 +16,7 @@ keywords = ["cryptography", "ed25519", "curve25519", "signature", "ECC"] categories = ["cryptography", "no-std"] description = "Fast and efficient ed25519 EdDSA key generations, signing, and verification in pure Rust." exclude = [ ".gitignore", "TESTVECTORS", "VALIDATIONVECTORS", "res/*" ] -rust-version = "1.60" +rust-version = "1.72" [package.metadata.docs.rs] rustdoc-args = [ diff --git a/ed25519-dalek/src/signing.rs b/ed25519-dalek/src/signing.rs index e7dd7fcee..aeda05004 100644 --- a/ed25519-dalek/src/signing.rs +++ b/ed25519-dalek/src/signing.rs @@ -713,10 +713,10 @@ impl From<&SigningKey> for pkcs8::KeypairBytes { } #[cfg(feature = "pkcs8")] -impl TryFrom> for SigningKey { +impl TryFrom> for SigningKey { type Error = pkcs8::Error; - fn try_from(private_key: pkcs8::PrivateKeyInfo<'_>) -> pkcs8::Result { + fn try_from(private_key: pkcs8::PrivateKeyInfoRef<'_>) -> pkcs8::Result { pkcs8::KeypairBytes::try_from(private_key)?.try_into() } } @@ -774,7 +774,7 @@ impl<'d> Deserialize<'d> for SigningKey { )); } - SigningKey::try_from(bytes).map_err(serde::de::Error::custom) + Ok(SigningKey::from(bytes)) } } From 88e1efaae36d4438fd3f17ad3cb043dd3da844d4 Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Sat, 31 May 2025 11:19:10 -0600 Subject: [PATCH 4/5] [WIP] Bump `digest`, `ed25519`, `signature`, and `sha2` Bumps the aforementioned dependencies to their latest (pre)releases --- Cargo.toml | 3 --- curve25519-dalek/Cargo.toml | 4 ++-- ed25519-dalek/Cargo.toml | 14 +++++++------- ed25519-dalek/src/errors.rs | 4 ++-- 4 files changed, 11 insertions(+), 14 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 9bc2cba16..f0b3f9945 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,3 @@ resolver = "2" [profile.dev] opt-level = 2 - -[patch.crates-io] -ed25519 = { git = "https://github.com/RustCrypto/signatures.git" } diff --git a/curve25519-dalek/Cargo.toml b/curve25519-dalek/Cargo.toml index 993aa6dc9..f0646ee09 100644 --- a/curve25519-dalek/Cargo.toml +++ b/curve25519-dalek/Cargo.toml @@ -30,7 +30,7 @@ rustdoc-args = [ features = ["serde", "rand_core", "digest", "legacy_compatibility", "group-bits"] [dev-dependencies] -sha2 = { version = "=0.11.0-pre.4", default-features = false } +sha2 = { version = "0.11.0-rc.0", default-features = false } bincode = "1" criterion = { version = "0.5", features = ["html_reports"] } hex = "0.4.2" @@ -50,7 +50,7 @@ cfg-if = "1" ff = { version = "0.13", default-features = false, optional = true } group = { version = "0.13", default-features = false, optional = true } rand_core = { version = "0.6.4", default-features = false, optional = true } -digest = { version = "=0.11.0-pre.9", default-features = false, optional = true } +digest = { version = "0.11.0-rc.0", default-features = false, optional = true } subtle = { version = "2.6.0", default-features = false, features = ["const-generics"] } serde = { version = "1.0", default-features = false, optional = true, features = ["derive"] } zeroize = { version = "1", default-features = false, optional = true } diff --git a/ed25519-dalek/Cargo.toml b/ed25519-dalek/Cargo.toml index 2dd071334..b921328af 100644 --- a/ed25519-dalek/Cargo.toml +++ b/ed25519-dalek/Cargo.toml @@ -27,9 +27,9 @@ features = ["batch", "digest", "hazmat", "pem", "serde"] [dependencies] curve25519-dalek = { version = "4", path = "../curve25519-dalek", default-features = false, features = ["digest"] } -ed25519 = { version = "=2.3.0-pre.0", default-features = false } -signature = { version = "=2.3.0-pre.4", optional = true, default-features = false } -sha2 = { version = "=0.11.0-pre.4", default-features = false } +ed25519 = { version = "=3.0.0-pre.0", default-features = false } +signature = { version = "3.0.0-rc.0", optional = true, default-features = false } +sha2 = { version = "0.11.0-rc.0", default-features = false } subtle = { version = "2.3.0", default-features = false } # optional features @@ -41,8 +41,8 @@ zeroize = { version = "1.5", default-features = false, optional = true } [dev-dependencies] curve25519-dalek = { version = "4", path = "../curve25519-dalek", default-features = false, features = ["digest", "rand_core"] } x25519-dalek = { version = "2", path = "../x25519-dalek", default-features = false, features = ["static_secrets"] } -blake2 = "=0.11.0-pre.4" -sha3 = "=0.11.0-pre.4" +blake2 = "0.11.0-rc.0" +sha3 = "0.11.0-rc.0" hex = "0.4" bincode = "1.0" serde_json = "1.0" @@ -60,8 +60,8 @@ required-features = ["rand_core"] [features] default = ["fast", "std", "zeroize"] -alloc = ["curve25519-dalek/alloc", "ed25519/alloc", "serde?/alloc", "zeroize/alloc"] -std = ["alloc", "ed25519/std", "serde?/std", "sha2/std"] +alloc = ["curve25519-dalek/alloc", "ed25519/alloc", "serde?/alloc", "signature/alloc", "zeroize/alloc"] +std = ["alloc", "ed25519/std", "serde?/std"] batch = ["alloc", "merlin", "rand_core"] fast = ["curve25519-dalek/precomputed-tables"] diff --git a/ed25519-dalek/src/errors.rs b/ed25519-dalek/src/errors.rs index 7cba06db5..ffd9aef73 100644 --- a/ed25519-dalek/src/errors.rs +++ b/ed25519-dalek/src/errors.rs @@ -107,12 +107,12 @@ impl Error for InternalError {} pub type SignatureError = ed25519::signature::Error; impl From for SignatureError { - #[cfg(not(feature = "std"))] + #[cfg(not(feature = "alloc"))] fn from(_err: InternalError) -> SignatureError { SignatureError::new() } - #[cfg(feature = "std")] + #[cfg(feature = "alloc")] fn from(err: InternalError) -> SignatureError { SignatureError::from_source(err) } From 423dbb2cd39b0a25207d646f771e5494ee14aeef Mon Sep 17 00:00:00 2001 From: Arthur Gautier Date: Tue, 6 May 2025 14:27:41 -0700 Subject: [PATCH 5/5] fixup rand 0.9 migration --- .github/workflows/workspace.yml | 2 +- curve25519-dalek/Cargo.toml | 4 +- curve25519-dalek/benches/dalek_benchmarks.rs | 16 ++--- curve25519-dalek/src/edwards.rs | 38 +++++----- curve25519-dalek/src/montgomery.rs | 20 +++--- curve25519-dalek/src/ristretto.rs | 76 +++++++++++++------- curve25519-dalek/src/scalar.rs | 26 +++---- ed25519-dalek/Cargo.toml | 2 +- ed25519-dalek/src/batch.rs | 8 +-- ed25519-dalek/src/batch/transcript.rs | 7 +- ed25519-dalek/src/context.rs | 9 +-- ed25519-dalek/src/hazmat.rs | 20 +++--- ed25519-dalek/src/lib.rs | 26 ++++--- ed25519-dalek/src/signing.rs | 16 +++-- ed25519-dalek/tests/ed25519.rs | 51 +++++++------ x25519-dalek/README.md | 21 +++--- x25519-dalek/benches/x25519.rs | 6 +- x25519-dalek/src/x25519.rs | 38 +++++----- x25519-dalek/tests/x25519_tests.rs | 18 ++--- 19 files changed, 227 insertions(+), 177 deletions(-) diff --git a/.github/workflows/workspace.yml b/.github/workflows/workspace.yml index cf5c47eca..dc5ac8d91 100644 --- a/.github/workflows/workspace.yml +++ b/.github/workflows/workspace.yml @@ -78,7 +78,7 @@ jobs: - name: no_std / no feat ${{ matrix.crate }} run: cargo build -p ${{ matrix.crate }} --target thumbv7em-none-eabi --release --no-default-features - name: no_std / cargo hack ${{ matrix.crate }} - run: cargo hack build -p ${{ matrix.crate }} --target thumbv7em-none-eabi --release --each-feature --exclude-features default,std,getrandom + run: cargo hack build -p ${{ matrix.crate }} --target thumbv7em-none-eabi --release --each-feature --exclude-features default,std,os_rng clippy: name: Check that clippy is happy diff --git a/curve25519-dalek/Cargo.toml b/curve25519-dalek/Cargo.toml index 946785463..6fa3d32bd 100644 --- a/curve25519-dalek/Cargo.toml +++ b/curve25519-dalek/Cargo.toml @@ -47,8 +47,8 @@ required-features = ["alloc", "rand_core"] [dependencies] cfg-if = "1" -ff = { version = "0.13", default-features = false, optional = true } -group = { version = "0.13", default-features = false, optional = true } +ff = { version = "=0.14.0-pre.0", default-features = false, optional = true } +group = { version = "=0.14.0-pre.0", default-features = false, optional = true } rand_core = { version = "0.9", default-features = false, optional = true } digest = { version = "0.11.0-rc.0", default-features = false, optional = true } subtle = { version = "2.6.0", default-features = false, features = ["const-generics"] } diff --git a/curve25519-dalek/benches/dalek_benchmarks.rs b/curve25519-dalek/benches/dalek_benchmarks.rs index 0b2653e2c..a56d24f0a 100644 --- a/curve25519-dalek/benches/dalek_benchmarks.rs +++ b/curve25519-dalek/benches/dalek_benchmarks.rs @@ -1,6 +1,6 @@ #![allow(non_snake_case)] -use rand::{rngs::OsRng, thread_rng}; +use rand::{rng, rngs::OsRng, TryRngCore}; use criterion::{ criterion_main, measurement::Measurement, BatchSize, BenchmarkGroup, BenchmarkId, Criterion, @@ -29,7 +29,7 @@ mod edwards_benches { BenchmarkId::new("Batch EdwardsPoint compression", batch_size), &batch_size, |b, &size| { - let mut rng = OsRng; + let mut rng = OsRng.unwrap_err(); let points: Vec = (0..size).map(|_| EdwardsPoint::random(&mut rng)).collect(); b.iter(|| EdwardsPoint::compress_batch(&points)); @@ -62,7 +62,7 @@ mod edwards_benches { fn vartime_double_base_scalar_mul(c: &mut BenchmarkGroup) { c.bench_function("Variable-time aA+bB, A variable, B fixed", |bench| { - let mut rng = thread_rng(); + let mut rng = rng(); let A = EdwardsPoint::mul_base(&Scalar::random(&mut rng)); bench.iter_batched( || (Scalar::random(&mut rng), Scalar::random(&mut rng)), @@ -96,12 +96,12 @@ mod multiscalar_benches { use curve25519_dalek::traits::VartimePrecomputedMultiscalarMul; fn construct_scalars(n: usize) -> Vec { - let mut rng = thread_rng(); + let mut rng = rng(); (0..n).map(|_| Scalar::random(&mut rng)).collect() } fn construct_points(n: usize) -> Vec { - let mut rng = thread_rng(); + let mut rng = rng(); (0..n) .map(|_| EdwardsPoint::mul_base(&Scalar::random(&mut rng))) .collect() @@ -269,7 +269,7 @@ mod ristretto_benches { |b, &&size| { let mut rng = OsRng; let points: Vec = (0..size) - .map(|_| RistrettoPoint::random(&mut rng)) + .map(|_| RistrettoPoint::try_from_rng(&mut rng).unwrap()) .collect(); b.iter(|| RistrettoPoint::double_and_compress_batch(&points)); }, @@ -319,7 +319,7 @@ mod scalar_benches { use super::*; fn scalar_arith(c: &mut BenchmarkGroup) { - let mut rng = thread_rng(); + let mut rng = rng(); c.bench_function("Scalar inversion", |b| { let s = Scalar::from(897987897u64).invert(); @@ -354,7 +354,7 @@ mod scalar_benches { BenchmarkId::new("Batch scalar inversion", *batch_size), &batch_size, |b, &&size| { - let mut rng = OsRng; + let mut rng = OsRng.unwrap_err(); let scalars: Vec = (0..size).map(|_| Scalar::random(&mut rng)).collect(); b.iter(|| { diff --git a/curve25519-dalek/src/edwards.rs b/curve25519-dalek/src/edwards.rs index ca469d322..0511dc2c9 100644 --- a/curve25519-dalek/src/edwards.rs +++ b/curve25519-dalek/src/edwards.rs @@ -110,6 +110,7 @@ use digest::{array::typenum::U64, Digest}; #[cfg(feature = "group")] use { group::{cofactor::CofactorGroup, prime::PrimeGroup, GroupEncoding}, + rand_core::TryRngCore, subtle::CtOption, }; @@ -667,7 +668,7 @@ impl EdwardsPoint { /// Uses rejection sampling, generating a random `CompressedEdwardsY` and then attempting point /// decompression, rejecting invalid points. #[cfg(any(test, feature = "rand_core"))] - pub fn random(mut rng: impl RngCore) -> Self { + pub fn random(rng: &mut R) -> Self { let mut repr = CompressedEdwardsY([0u8; 32]); loop { rng.fill_bytes(&mut repr.0); @@ -1364,9 +1365,16 @@ impl Debug for EdwardsPoint { impl group::Group for EdwardsPoint { type Scalar = Scalar; - fn random(rng: impl RngCore) -> Self { - // Call the inherent `pub fn random` defined above - Self::random(rng) + fn try_from_rng(rng: &mut R) -> Result { + let mut repr = CompressedEdwardsY([0u8; 32]); + loop { + rng.try_fill_bytes(&mut repr.0)?; + if let Some(p) = repr.decompress() { + if !IsIdentity::is_identity(&p) { + break Ok(p); + } + } + } } fn identity() -> Self { @@ -1609,20 +1617,20 @@ impl Zeroize for SubgroupPoint { impl group::Group for SubgroupPoint { type Scalar = Scalar; - fn random(mut rng: impl RngCore) -> Self { + fn try_from_rng(rng: &mut R) -> Result { use group::ff::Field; // This will almost never loop, but `Group::random` is documented as returning a // non-identity element. let s = loop { - let s: Scalar = Field::random(&mut rng); + let s: Scalar = Field::try_from_rng(rng)?; if !s.is_zero_vartime() { break s; } }; // This gives an element of the prime-order subgroup. - Self::generator() * s + Ok(Self::generator() * s) } fn identity() -> Self { @@ -1688,9 +1696,7 @@ impl CofactorGroup for EdwardsPoint { mod test { use super::*; - // If `group` is set, then this is already imported in super - #[cfg(not(feature = "group"))] - use rand_core::RngCore; + use rand_core::TryRngCore; #[cfg(feature = "alloc")] use alloc::vec::Vec; @@ -1985,7 +1991,7 @@ mod test { #[cfg(feature = "precomputed-tables")] let random_point = { let mut b = [0u8; 32]; - csprng.fill_bytes(&mut b); + csprng.try_fill_bytes(&mut b).unwrap(); EdwardsPoint::mul_base_clamped(b) + constants::EIGHT_TORSION[1] }; // Make a basepoint table from the random point. We'll use this with mul_base_clamped @@ -2011,7 +2017,7 @@ mod test { for _ in 0..100 { // This will be reduced mod l with probability l / 2^256 ≈ 6.25% let mut a_bytes = [0u8; 32]; - csprng.fill_bytes(&mut a_bytes); + csprng.try_fill_bytes(&mut a_bytes).unwrap(); assert_eq!( EdwardsPoint::mul_base_clamped(a_bytes), @@ -2096,7 +2102,7 @@ mod test { #[cfg(feature = "alloc")] #[test] fn compress_batch() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); // TODO(tarcieri): proptests? // Make some points deterministically then randomly @@ -2152,7 +2158,7 @@ mod test { // A single iteration of a consistency check for MSM. #[cfg(feature = "alloc")] fn multiscalar_consistency_iter(n: usize) { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); // Construct random coefficients x0, ..., x_{n-1}, // followed by some extra hardcoded ones. @@ -2215,7 +2221,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn batch_to_montgomery() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let scalars = (0..128) .map(|_| Scalar::random(&mut rng)) @@ -2240,7 +2246,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn vartime_precomputed_vs_nonprecomputed_multiscalar() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let static_scalars = (0..128) .map(|_| Scalar::random(&mut rng)) diff --git a/curve25519-dalek/src/montgomery.rs b/curve25519-dalek/src/montgomery.rs index 29f0e492b..b07f049c4 100644 --- a/curve25519-dalek/src/montgomery.rs +++ b/curve25519-dalek/src/montgomery.rs @@ -57,7 +57,7 @@ use core::{ use crate::constants::{APLUS2_OVER_FOUR, MONTGOMERY_A, MONTGOMERY_A_NEG}; use crate::edwards::{CompressedEdwardsY, EdwardsPoint}; use crate::field::FieldElement; -use crate::scalar::{clamp_integer, Scalar}; +use crate::scalar::{Scalar, clamp_integer}; use crate::traits::Identity; @@ -437,7 +437,7 @@ mod test { #[cfg(feature = "alloc")] use alloc::vec::Vec; - use rand_core::{CryptoRng, RngCore}; + use rand_core::{CryptoRng, RngCore, TryRngCore}; #[test] fn identity_in_different_coordinates() { @@ -521,8 +521,8 @@ mod test { } /// Returns a random point on the prime-order subgroup - fn rand_prime_order_point(mut rng: impl RngCore + CryptoRng) -> EdwardsPoint { - let s: Scalar = Scalar::random(&mut rng); + fn rand_prime_order_point(rng: &mut R) -> EdwardsPoint { + let s: Scalar = Scalar::random(rng); EdwardsPoint::mul_base(&s) } @@ -540,10 +540,10 @@ mod test { #[test] fn montgomery_ladder_matches_edwards_scalarmult() { - let mut csprng = rand_core::OsRng; + let mut csprng = rand_core::OsRng.unwrap_err(); for _ in 0..100 { - let p_edwards = rand_prime_order_point(csprng); + let p_edwards = rand_prime_order_point(&mut csprng); let p_montgomery: MontgomeryPoint = p_edwards.to_montgomery(); let s: Scalar = Scalar::random(&mut csprng); @@ -558,11 +558,11 @@ mod test { // multiplying by the Scalar representation of the same bits #[test] fn montgomery_mul_bits_be() { - let mut csprng = rand_core::OsRng; + let mut csprng = rand_core::OsRng.unwrap_err(); for _ in 0..100 { // Make a random prime-order point P - let p_edwards = rand_prime_order_point(csprng); + let p_edwards = rand_prime_order_point(&mut csprng); let p_montgomery: MontgomeryPoint = p_edwards.to_montgomery(); // Make a random integer b @@ -583,7 +583,7 @@ mod test { // integers b₁, b₂ and random (curve or twist) point P. #[test] fn montgomery_mul_bits_be_twist() { - let mut csprng = rand_core::OsRng; + let mut csprng = rand_core::OsRng.unwrap_err(); for _ in 0..100 { // Make a random point P on the curve or its twist @@ -629,7 +629,7 @@ mod test { for _ in 0..100 { // This will be reduced mod l with probability l / 2^256 ≈ 6.25% let mut a_bytes = [0u8; 32]; - csprng.fill_bytes(&mut a_bytes); + csprng.try_fill_bytes(&mut a_bytes).unwrap(); assert_eq!( MontgomeryPoint::mul_base_clamped(a_bytes), diff --git a/curve25519-dalek/src/ristretto.rs b/curve25519-dalek/src/ristretto.rs index a9816ec7e..d48d20299 100644 --- a/curve25519-dalek/src/ristretto.rs +++ b/curve25519-dalek/src/ristretto.rs @@ -169,9 +169,6 @@ use core::ops::{Add, Neg, Sub}; use core::ops::{AddAssign, SubAssign}; use core::ops::{Mul, MulAssign}; -#[cfg(any(test, feature = "rand_core"))] -use rand_core::CryptoRngCore; - #[cfg(feature = "digest")] use digest::array::typenum::U64; #[cfg(feature = "digest")] @@ -183,10 +180,16 @@ use crate::field::FieldElement; #[cfg(feature = "group")] use { group::{cofactor::CofactorGroup, prime::PrimeGroup, GroupEncoding}, - rand_core::RngCore, + rand_core::TryRngCore, subtle::CtOption, }; +#[cfg(any(test, feature = "rand_core"))] +use { + core::convert::Infallible, + rand_core::{CryptoRng, TryCryptoRng}, +}; + use subtle::Choice; use subtle::ConditionallyNegatable; use subtle::ConditionallySelectable; @@ -532,12 +535,12 @@ impl RistrettoPoint { #[cfg_attr(feature = "rand_core", doc = "```")] #[cfg_attr(not(feature = "rand_core"), doc = "```ignore")] /// # use curve25519_dalek::ristretto::RistrettoPoint; - /// use rand_core::OsRng; + /// use rand_core::{OsRng, TryRngCore}; /// /// # // Need fn main() here in comment so the doctest compiles /// # // See https://doc.rust-lang.org/book/documentation.html#documentation-as-tests /// # fn main() { - /// let mut rng = OsRng; + /// let mut rng = OsRng.unwrap_err(); /// /// let points: Vec = /// (0..32).map(|_| RistrettoPoint::random(&mut rng)).collect(); @@ -696,8 +699,7 @@ impl RistrettoPoint { /// /// # Inputs /// - /// * `rng`: any RNG which implements `CryptoRngCore` - /// (i.e. `CryptoRng` + `RngCore`) interface. + /// * `rng`: any RNG which implements `CryptoRng` interface. /// /// # Returns /// @@ -709,11 +711,34 @@ impl RistrettoPoint { /// discrete log of the output point with respect to any other /// point should be unknown. The map is applied twice and the /// results are added, to ensure a uniform distribution. - pub fn random(rng: &mut R) -> Self { + pub fn random(rng: &mut R) -> Self { + Self::try_from_rng(rng) + .map_err(|_: Infallible| {}) + .expect("[bug] unfallible rng failed") + } + + #[cfg(any(test, feature = "rand_core"))] + /// Return a `RistrettoPoint` chosen uniformly at random using a user-provided RNG. + /// + /// # Inputs + /// + /// * `rng`: any RNG which implements `TryCryptoRng` interface. + /// + /// # Returns + /// + /// A random element of the Ristretto group. + /// + /// # Implementation + /// + /// Uses the Ristretto-flavoured Elligator 2 map, so that the + /// discrete log of the output point with respect to any other + /// point should be unknown. The map is applied twice and the + /// results are added, to ensure a uniform distribution. + pub fn try_from_rng(rng: &mut R) -> Result { let mut uniform_bytes = [0u8; 64]; - rng.fill_bytes(&mut uniform_bytes); + rng.try_fill_bytes(&mut uniform_bytes)?; - RistrettoPoint::from_uniform_bytes(&uniform_bytes) + Ok(RistrettoPoint::from_uniform_bytes(&uniform_bytes)) } #[cfg(feature = "digest")] @@ -1192,11 +1217,11 @@ impl Debug for RistrettoPoint { impl group::Group for RistrettoPoint { type Scalar = Scalar; - fn random(mut rng: impl RngCore) -> Self { + fn try_from_rng(rng: &mut R) -> Result { // NOTE: this is duplicated due to different `rng` bounds let mut uniform_bytes = [0u8; 64]; - rng.fill_bytes(&mut uniform_bytes); - RistrettoPoint::from_uniform_bytes(&uniform_bytes) + rng.try_fill_bytes(&mut uniform_bytes)?; + Ok(RistrettoPoint::from_uniform_bytes(&uniform_bytes)) } fn identity() -> Self { @@ -1289,7 +1314,7 @@ mod test { use super::*; use crate::edwards::CompressedEdwardsY; - use rand_core::OsRng; + use rand_core::{OsRng, TryRngCore}; #[test] #[cfg(feature = "serde")] @@ -1482,7 +1507,7 @@ mod test { #[test] fn four_torsion_random() { - let mut rng = OsRng; + let mut rng = OsRng.unwrap_err(); let P = RistrettoPoint::mul_base(&Scalar::random(&mut rng)); let P_coset = P.coset4(); for point in P_coset { @@ -1807,7 +1832,7 @@ mod test { #[test] fn random_roundtrip() { - let mut rng = OsRng; + let mut rng = OsRng.unwrap_err(); for _ in 0..100 { let P = RistrettoPoint::mul_base(&Scalar::random(&mut rng)); let compressed_P = P.compress(); @@ -1817,14 +1842,15 @@ mod test { } #[test] - #[cfg(all(feature = "alloc", feature = "rand_core"))] + #[cfg(all(feature = "alloc", feature = "rand_core", feature = "group"))] fn double_and_compress_1024_random_points() { + use group::Group; let mut rng = OsRng; let mut points: Vec = (0..1024) - .map(|_| RistrettoPoint::random(&mut rng)) + .map(|_| RistrettoPoint::try_from_rng(&mut rng).unwrap()) .collect(); - points[500] = RistrettoPoint::identity(); + points[500] = ::identity(); let compressed = RistrettoPoint::double_and_compress_batch(&points); @@ -1836,7 +1862,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn vartime_precomputed_vs_nonprecomputed_multiscalar() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let static_scalars = (0..128) .map(|_| Scalar::random(&mut rng)) @@ -1887,7 +1913,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn partial_precomputed_mixed_multiscalar_empty() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let n_static = 16; let n_dynamic = 8; @@ -1930,7 +1956,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn partial_precomputed_mixed_multiscalar() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let n_static = 16; let n_dynamic = 8; @@ -1975,7 +2001,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn partial_precomputed_multiscalar() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let n_static = 16; @@ -2004,7 +2030,7 @@ mod test { #[test] #[cfg(feature = "alloc")] fn partial_precomputed_multiscalar_empty() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); let n_static = 16; diff --git a/curve25519-dalek/src/scalar.rs b/curve25519-dalek/src/scalar.rs index f290b4650..71c77bde2 100644 --- a/curve25519-dalek/src/scalar.rs +++ b/curve25519-dalek/src/scalar.rs @@ -127,11 +127,11 @@ use group::ff::{Field, FromUniformBytes, PrimeField}; #[cfg(feature = "group-bits")] use group::ff::{FieldBits, PrimeFieldBits}; -#[cfg(any(test, feature = "group"))] -use rand_core::RngCore; +#[cfg(feature = "group")] +use rand_core::TryRngCore; #[cfg(any(test, feature = "rand_core"))] -use rand_core::CryptoRngCore; +use rand_core::CryptoRng; #[cfg(feature = "digest")] use digest::array::typenum::U64; @@ -576,8 +576,7 @@ impl Scalar { /// /// # Inputs /// - /// * `rng`: any RNG which implements `CryptoRngCore` - /// (i.e. `CryptoRng` + `RngCore`) interface. + /// * `rng`: any RNG which implements `CryptoRng` interface. /// /// # Returns /// @@ -589,12 +588,12 @@ impl Scalar { /// # fn main() { /// use curve25519_dalek::scalar::Scalar; /// - /// use rand_core::OsRng; + /// use rand_core::{OsRng, TryRngCore}; /// - /// let mut csprng = OsRng; + /// let mut csprng = OsRng.unwrap_err(); /// let a: Scalar = Scalar::random(&mut csprng); /// # } - pub fn random(rng: &mut R) -> Self { + pub fn random(rng: &mut R) -> Self { let mut scalar_bytes = [0u8; 64]; rng.fill_bytes(&mut scalar_bytes); Scalar::from_bytes_mod_order_wide(&scalar_bytes) @@ -1213,11 +1212,11 @@ impl Field for Scalar { const ZERO: Self = Self::ZERO; const ONE: Self = Self::ONE; - fn random(mut rng: impl RngCore) -> Self { + fn try_from_rng(rng: &mut R) -> Result { // NOTE: this is duplicated due to different `rng` bounds let mut scalar_bytes = [0u8; 64]; - rng.fill_bytes(&mut scalar_bytes); - Self::from_bytes_mod_order_wide(&scalar_bytes) + rng.try_fill_bytes(&mut scalar_bytes)?; + Ok(Self::from_bytes_mod_order_wide(&scalar_bytes)) } fn square(&self) -> Self { @@ -1393,6 +1392,7 @@ pub const fn clamp_integer(mut bytes: [u8; 32]) -> [u8; 32] { #[cfg(test)] pub(crate) mod test { use super::*; + use rand_core::RngCore; #[cfg(feature = "alloc")] use alloc::vec::Vec; @@ -1552,7 +1552,7 @@ pub(crate) mod test { #[test] fn non_adjacent_form_random() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); for _ in 0..1_000 { let x = Scalar::random(&mut rng); for w in &[5, 6, 7, 8] { @@ -2046,7 +2046,7 @@ pub(crate) mod test { // was reduced and b was clamped and unreduced. This checks that was always well-defined. #[test] fn test_mul_reduction_invariance() { - let mut rng = rand::thread_rng(); + let mut rng = rand::rng(); for _ in 0..10 { // Also define c that's clamped. We'll make sure that clamping doesn't affect diff --git a/ed25519-dalek/Cargo.toml b/ed25519-dalek/Cargo.toml index 510c3478e..8bd181f8d 100644 --- a/ed25519-dalek/Cargo.toml +++ b/ed25519-dalek/Cargo.toml @@ -62,7 +62,7 @@ required-features = ["rand_core"] [features] default = ["fast", "std", "zeroize"] -alloc = ["curve25519-dalek/alloc", "ed25519/alloc", "serde?/alloc", "signature/alloc", "zeroize/alloc"] +alloc = ["curve25519-dalek/alloc", "ed25519/alloc", "serde?/alloc", "zeroize/alloc", "signature/alloc"] std = ["alloc", "ed25519/std", "serde?/std"] batch = ["alloc", "dep:keccak", "rand_core"] diff --git a/ed25519-dalek/src/batch.rs b/ed25519-dalek/src/batch.rs index 2c65c5c22..15907bf5b 100644 --- a/ed25519-dalek/src/batch.rs +++ b/ed25519-dalek/src/batch.rs @@ -66,11 +66,6 @@ impl rand_core::RngCore for ZeroRng { /// `ENC_{state}(00000000000000000000000000000000)` operation, which is /// identical to the STROBE `MAC` operation. fn fill_bytes(&mut self, _dest: &mut [u8]) {} - - fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> { - self.fill_bytes(dest); - Ok(()) - } } // `TranscriptRngBuilder::finalize()` requires a `CryptoRng` @@ -130,9 +125,10 @@ fn gen_u128(rng: &mut R) -> u128 { /// verify_batch, SigningKey, VerifyingKey, Signer, Signature, /// }; /// use rand::rngs::OsRng; +/// use rand_core::TryRngCore; /// /// # fn main() { -/// let mut csprng = OsRng; +/// let mut csprng = OsRng.unwrap_err(); /// let signing_keys: Vec<_> = (0..64).map(|_| SigningKey::generate(&mut csprng)).collect(); /// let msg: &[u8] = b"They're good dogs Brant"; /// let messages: Vec<_> = (0..64).map(|_| msg).collect(); diff --git a/ed25519-dalek/src/batch/transcript.rs b/ed25519-dalek/src/batch/transcript.rs index 6af752c2d..1035c9953 100644 --- a/ed25519-dalek/src/batch/transcript.rs +++ b/ed25519-dalek/src/batch/transcript.rs @@ -1,5 +1,5 @@ -use super::strobe::Strobe128; use super::MERLIN_PROTOCOL_LABEL; +use super::strobe::Strobe128; fn encode_usize_as_u32(x: usize) -> [u8; 4] { u32::try_from(x).expect("usize too large").to_le_bytes() @@ -199,11 +199,6 @@ impl rand_core::RngCore for TranscriptRng { self.strobe.meta_ad(&dest_len, false); self.strobe.prf(dest, false); } - - fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> { - self.fill_bytes(dest); - Ok(()) - } } impl rand_core::CryptoRng for TranscriptRng {} diff --git a/ed25519-dalek/src/context.rs b/ed25519-dalek/src/context.rs index 2a27edd9d..5aa06fa88 100644 --- a/ed25519-dalek/src/context.rs +++ b/ed25519-dalek/src/context.rs @@ -24,9 +24,10 @@ use crate::{InternalError, SignatureError}; /// use ed25519_dalek::{Signature, SigningKey, VerifyingKey, Sha512}; /// # use curve25519_dalek::digest::Digest; /// # use rand::rngs::OsRng; +/// # use rand_core::TryRngCore; /// use ed25519_dalek::{DigestSigner, DigestVerifier}; /// -/// # let mut csprng = OsRng; +/// # let mut csprng = OsRng.unwrap_err(); /// # let signing_key = SigningKey::generate(&mut csprng); /// # let verifying_key = signing_key.verifying_key(); /// let context_str = b"Local Channel 3"; @@ -84,13 +85,13 @@ mod test { use crate::{Signature, SigningKey, VerifyingKey}; use curve25519_dalek::digest::Digest; - use ed25519::signature::{DigestSigner, DigestVerifier}; - use rand::rngs::OsRng; + use rand::{rngs::OsRng, TryRngCore}; use sha2::Sha512; + use signature::{DigestSigner, DigestVerifier}; #[test] fn context_correctness() { - let mut csprng = OsRng; + let mut csprng = OsRng.unwrap_err(); let signing_key: SigningKey = SigningKey::generate(&mut csprng); let verifying_key: VerifyingKey = signing_key.verifying_key(); diff --git a/ed25519-dalek/src/hazmat.rs b/ed25519-dalek/src/hazmat.rs index 87686cffc..ce53f430d 100644 --- a/ed25519-dalek/src/hazmat.rs +++ b/ed25519-dalek/src/hazmat.rs @@ -17,7 +17,7 @@ use core::fmt::Debug; use crate::{InternalError, SignatureError}; -use curve25519_dalek::scalar::{clamp_integer, Scalar}; +use curve25519_dalek::scalar::{Scalar, clamp_integer}; use subtle::{Choice, ConstantTimeEq}; #[cfg(feature = "zeroize")] @@ -25,7 +25,7 @@ use zeroize::{Zeroize, ZeroizeOnDrop}; // These are used in the functions that are made public when the hazmat feature is set use crate::{Signature, VerifyingKey}; -use curve25519_dalek::digest::{array::typenum::U64, Digest}; +use curve25519_dalek::digest::{Digest, array::typenum::U64}; /// Contains the secret scalar and domain separator used for generating signatures. /// @@ -258,7 +258,7 @@ mod test { use super::*; - use rand::{rngs::OsRng, CryptoRng, RngCore}; + use rand::{CryptoRng, TryRngCore, rngs::OsRng}; // Pick distinct, non-spec 512-bit hash functions for message and sig-context hashing type CtxDigest = blake2::Blake2b512; @@ -267,7 +267,7 @@ mod test { impl ExpandedSecretKey { // Make a random expanded secret key for testing purposes. This is NOT how you generate // expanded secret keys IRL. They're the hash of a seed. - fn random(mut rng: R) -> Self { + fn random(rng: &mut R) -> Self { let mut bytes = [0u8; 64]; rng.fill_bytes(&mut bytes); ExpandedSecretKey::from_bytes(&bytes) @@ -278,8 +278,8 @@ mod test { #[test] fn sign_verify_nonspec() { // Generate the keypair - let rng = OsRng; - let esk = ExpandedSecretKey::random(rng); + let mut rng = OsRng.unwrap_err(); + let esk = ExpandedSecretKey::random(&mut rng); let vk = VerifyingKey::from(&esk); let msg = b"Then one day, a piano fell on my head"; @@ -297,8 +297,8 @@ mod test { use curve25519_dalek::digest::Digest; // Generate the keypair - let rng = OsRng; - let esk = ExpandedSecretKey::random(rng); + let mut rng = OsRng.unwrap_err(); + let esk = ExpandedSecretKey::random(&mut rng); let vk = VerifyingKey::from(&esk); // Hash the message @@ -317,8 +317,8 @@ mod test { #[test] fn sign_byupdate() { // Generate the keypair - let rng = OsRng; - let esk = ExpandedSecretKey::random(rng); + let mut rng = OsRng.unwrap_err(); + let esk = ExpandedSecretKey::random(&mut rng); let vk = VerifyingKey::from(&esk); let msg = b"realistic"; diff --git a/ed25519-dalek/src/lib.rs b/ed25519-dalek/src/lib.rs index e44d7535c..8f2aabe5f 100644 --- a/ed25519-dalek/src/lib.rs +++ b/ed25519-dalek/src/lib.rs @@ -23,10 +23,11 @@ //! # fn main() { //! // $ cargo add ed25519_dalek --features rand_core //! use rand::rngs::OsRng; +//! use rand_core::TryRngCore; //! use ed25519_dalek::SigningKey; //! use ed25519_dalek::Signature; //! -//! let mut csprng = OsRng; +//! let mut csprng = OsRng.unwrap_err(); //! let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! # } //! ``` @@ -37,8 +38,9 @@ #![cfg_attr(not(feature = "rand_core"), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::SigningKey; -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! use ed25519_dalek::{Signature, Signer}; //! let message: &[u8] = b"This is a test of the tsunami alert system."; @@ -53,8 +55,9 @@ #![cfg_attr(not(feature = "rand_core"), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::{SigningKey, Signature, Signer}; -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! # let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature: Signature = signing_key.sign(message); @@ -70,11 +73,12 @@ #![cfg_attr(not(feature = "rand_core"), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::SigningKey; //! # use ed25519_dalek::Signature; //! # use ed25519_dalek::Signer; //! use ed25519_dalek::{VerifyingKey, Verifier}; -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! # let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature: Signature = signing_key.sign(message); @@ -96,9 +100,10 @@ #![cfg_attr(not(feature = "rand_core"), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::{SigningKey, Signature, Signer, VerifyingKey}; //! use ed25519_dalek::{PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, KEYPAIR_LENGTH, SIGNATURE_LENGTH}; -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! # let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature: Signature = signing_key.sign(message); @@ -116,10 +121,11 @@ #![cfg_attr(not(feature = "rand_core"), doc = "```ignore")] //! # use core::convert::{TryFrom, TryInto}; //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::{SigningKey, Signature, Signer, VerifyingKey, SecretKey, SignatureError}; //! # use ed25519_dalek::{PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, KEYPAIR_LENGTH, SIGNATURE_LENGTH}; //! # fn do_test() -> Result<(SigningKey, VerifyingKey, Signature), SignatureError> { -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key_orig: SigningKey = SigningKey::generate(&mut csprng); //! # let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature_orig: Signature = signing_key_orig.sign(message); @@ -193,9 +199,10 @@ #![cfg_attr(not(all(feature = "rand_core", feature = "serde")), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::{SigningKey, Signature, Signer, Verifier, VerifyingKey}; //! use bincode::serialize; -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! # let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature: Signature = signing_key.sign(message); @@ -214,11 +221,12 @@ #![cfg_attr(not(all(feature = "rand_core", feature = "serde")), doc = "```ignore")] //! # fn main() { //! # use rand::rngs::OsRng; +//! # use rand_core::TryRngCore; //! # use ed25519_dalek::{SigningKey, Signature, Signer, Verifier, VerifyingKey}; //! # use bincode::serialize; //! use bincode::deserialize; //! -//! # let mut csprng = OsRng; +//! # let mut csprng = OsRng.unwrap_err(); //! # let signing_key: SigningKey = SigningKey::generate(&mut csprng); //! let message: &[u8] = b"This is a test of the tsunami alert system."; //! # let signature: Signature = signing_key.sign(message); @@ -286,7 +294,7 @@ pub use crate::verifying::*; // Re-export the `Signer` and `Verifier` traits from the `signature` crate #[cfg(feature = "digest")] -pub use ed25519::signature::{DigestSigner, DigestVerifier}; +pub use ::signature::{DigestSigner, DigestVerifier}; pub use ed25519::signature::{Signer, Verifier}; pub use ed25519::Signature; diff --git a/ed25519-dalek/src/signing.rs b/ed25519-dalek/src/signing.rs index 5e3582fc8..77068ecf5 100644 --- a/ed25519-dalek/src/signing.rs +++ b/ed25519-dalek/src/signing.rs @@ -15,7 +15,7 @@ use core::fmt::Debug; use ed25519::pkcs8; #[cfg(any(test, feature = "rand_core"))] -use rand_core::CryptoRngCore; +use rand_core::CryptoRng; #[cfg(feature = "serde")] use serde::{Deserialize, Deserializer, Serialize, Serializer}; @@ -188,9 +188,10 @@ impl SigningKey { #[cfg_attr(not(feature = "rand_core"), doc = "```ignore")] /// # fn main() { /// use rand::rngs::OsRng; + /// use rand_core::TryRngCore; /// use ed25519_dalek::{Signature, SigningKey}; /// - /// let mut csprng = OsRng; + /// let mut csprng = OsRng.unwrap_err(); /// let signing_key: SigningKey = SigningKey::generate(&mut csprng); /// # } /// ``` @@ -199,7 +200,7 @@ impl SigningKey { /// /// A CSPRNG with a `fill_bytes()` method, e.g. `rand_os::OsRng`. #[cfg(any(test, feature = "rand_core"))] - pub fn generate(csprng: &mut R) -> SigningKey { + pub fn generate(csprng: &mut R) -> SigningKey { let mut secret = SecretKey::default(); csprng.fill_bytes(&mut secret); Self::from_bytes(&secret) @@ -240,9 +241,10 @@ impl SigningKey { /// use ed25519_dalek::Signature; /// use sha2::Sha512; /// use rand::rngs::OsRng; + /// use rand_core::TryRngCore; /// /// # fn main() { - /// let mut csprng = OsRng; + /// let mut csprng = OsRng.unwrap_err(); /// let signing_key: SigningKey = SigningKey::generate(&mut csprng); /// let message: &[u8] = b"All I want is to pet all of the dogs."; /// @@ -285,9 +287,10 @@ impl SigningKey { /// # use ed25519_dalek::SignatureError; /// # use sha2::Sha512; /// # use rand::rngs::OsRng; + /// # use rand_core::TryRngCore; /// # /// # fn do_test() -> Result { - /// # let mut csprng = OsRng; + /// # let mut csprng = OsRng.unwrap_err(); /// # let signing_key: SigningKey = SigningKey::generate(&mut csprng); /// # let message: &[u8] = b"All I want is to pet all of the dogs."; /// # let mut prehashed: Sha512 = Sha512::new(); @@ -364,9 +367,10 @@ impl SigningKey { /// use ed25519_dalek::SignatureError; /// use sha2::Sha512; /// use rand::rngs::OsRng; + /// use rand_core::TryRngCore; /// /// # fn do_test() -> Result<(), SignatureError> { - /// let mut csprng = OsRng; + /// let mut csprng = OsRng.unwrap_err(); /// let signing_key: SigningKey = SigningKey::generate(&mut csprng); /// let message: &[u8] = b"All I want is to pet all of the dogs."; /// diff --git a/ed25519-dalek/tests/ed25519.rs b/ed25519-dalek/tests/ed25519.rs index dd49c6e9c..8f8031ee6 100644 --- a/ed25519-dalek/tests/ed25519.rs +++ b/ed25519-dalek/tests/ed25519.rs @@ -27,9 +27,10 @@ mod vectors { scalar::Scalar, traits::IsIdentity, }; + use rand_core::TryRngCore; #[cfg(not(feature = "digest"))] - use sha2::{digest::Digest, Sha512}; + use sha2::{Sha512, digest::Digest}; use std::{ fs::File, @@ -104,7 +105,9 @@ mod vectors { let sec_bytes = hex!("833fe62409237b9d62ec77587520911e9a759cec1d19755b7da901b96dca3d42"); let pub_bytes = hex!("ec172b93ad5e563bf4932c70e1245034c35467ef2efd4d64ebf819683467e2bf"); let msg_bytes = hex!("616263"); - let sig_bytes = hex!("98a70222f0b8121aa9d30f813d683f809e462b469c7ff87639499bb94e6dae4131f85042463c2a355a2003d062adf5aaa10b8c61e636062aaad11c2a26083406"); + let sig_bytes = hex!( + "98a70222f0b8121aa9d30f813d683f809e462b469c7ff87639499bb94e6dae4131f85042463c2a355a2003d062adf5aaa10b8c61e636062aaad11c2a26083406" + ); let signing_key = SigningKey::from_bytes(&sec_bytes); let expected_verifying_key = VerifyingKey::from_bytes(&pub_bytes).unwrap(); @@ -180,7 +183,7 @@ mod vectors { // Pick a random Scalar fn non_null_scalar() -> Scalar { - let mut rng = rand::rngs::OsRng; + let mut rng = rand::rngs::OsRng.unwrap_err(); let mut s_candidate = Scalar::random(&mut rng); while s_candidate == Scalar::ZERO { s_candidate = Scalar::random(&mut rng); @@ -268,27 +271,31 @@ mod vectors { let signature = serialize_signature(&r, &s); let vk = VerifyingKey::from_bytes(pubkey.compress().as_bytes()).unwrap(); let sig = Signature::try_from(&signature[..]).unwrap(); - assert!(vk - .verify_prehashed(message1.clone(), context_str, &sig) - .is_ok()); - assert!(vk - .verify_prehashed(message2.clone(), context_str, &sig) - .is_ok()); + assert!( + vk.verify_prehashed(message1.clone(), context_str, &sig) + .is_ok() + ); + assert!( + vk.verify_prehashed(message2.clone(), context_str, &sig) + .is_ok() + ); // Check that verify_prehashed_strict fails on both sigs - assert!(vk - .verify_prehashed_strict(message1.clone(), context_str, &sig) - .is_err()); - assert!(vk - .verify_prehashed_strict(message2.clone(), context_str, &sig) - .is_err()); + assert!( + vk.verify_prehashed_strict(message1.clone(), context_str, &sig) + .is_err() + ); + assert!( + vk.verify_prehashed_strict(message2.clone(), context_str, &sig) + .is_err() + ); } } #[cfg(feature = "rand_core")] mod integrations { use super::*; - use rand::rngs::OsRng; + use rand::{TryRngCore, rngs::OsRng}; use std::collections::HashMap; #[test] @@ -298,7 +305,7 @@ mod integrations { let good: &[u8] = "test message".as_bytes(); let bad: &[u8] = "wrong message".as_bytes(); - let mut csprng = OsRng; + let mut csprng = OsRng.unwrap_err(); let signing_key: SigningKey = SigningKey::generate(&mut csprng); let verifying_key = signing_key.verifying_key(); @@ -339,7 +346,7 @@ mod integrations { fn sign_verify_digest_equivalence() { // TestSignVerify - let mut csprng = OsRng {}; + let mut csprng = OsRng.unwrap_err(); let good: &[u8] = "test message".as_bytes(); let bad: &[u8] = "wrong message".as_bytes(); @@ -384,7 +391,7 @@ mod integrations { let good: &[u8] = b"test message"; let bad: &[u8] = b"wrong message"; - let mut csprng = OsRng; + let mut csprng = OsRng.unwrap_err(); // 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(); @@ -459,7 +466,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 = OsRng; + let mut csprng = OsRng.unwrap_err(); let mut signing_keys: Vec = Vec::new(); let mut signatures: Vec = Vec::new(); @@ -478,7 +485,7 @@ mod integrations { #[test] fn public_key_hash_trait_check() { - let mut csprng = OsRng {}; + let mut csprng = OsRng.unwrap_err(); let secret: SigningKey = SigningKey::generate(&mut csprng); let public_from_secret: VerifyingKey = (&secret).into(); @@ -505,7 +512,7 @@ mod integrations { #[test] fn montgomery_and_edwards_conversion() { - let mut rng = rand::rngs::OsRng; + let mut rng = rand::rngs::OsRng.unwrap_err(); let signing_key = SigningKey::generate(&mut rng); let verifying_key = signing_key.verifying_key(); diff --git a/x25519-dalek/README.md b/x25519-dalek/README.md index c1604dac8..0dc801ffa 100644 --- a/x25519-dalek/README.md +++ b/x25519-dalek/README.md @@ -51,11 +51,12 @@ loudly meows `bob_public` back to Alice. Alice now computes her shared secret with Bob by doing: ```rust -# use rand_core::OsRng; +# use rand_core::{OsRng, TryRngCore}; # use x25519_dalek::{EphemeralSecret, PublicKey}; -# let alice_secret = EphemeralSecret::random_from_rng(OsRng); +# let mut rng = OsRng.unwrap_err(); +# let alice_secret = EphemeralSecret::random_from_rng(&mut rng); # let alice_public = PublicKey::from(&alice_secret); -# let bob_secret = EphemeralSecret::random_from_rng(OsRng); +# let bob_secret = EphemeralSecret::random_from_rng(&mut rng); # let bob_public = PublicKey::from(&bob_secret); let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); ``` @@ -63,11 +64,12 @@ let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); Similarly, Bob computes a shared secret by doing: ```rust -# use rand_core::OsRng; +# use rand_core::{OsRng, TryRngCore}; # use x25519_dalek::{EphemeralSecret, PublicKey}; -# let alice_secret = EphemeralSecret::random_from_rng(OsRng); +# let mut rng = OsRng.unwrap_err(); +# let alice_secret = EphemeralSecret::random_from_rng(&mut rng); # let alice_public = PublicKey::from(&alice_secret); -# let bob_secret = EphemeralSecret::random_from_rng(OsRng); +# let bob_secret = EphemeralSecret::random_from_rng(&mut rng); # let bob_public = PublicKey::from(&bob_secret); let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); ``` @@ -75,11 +77,12 @@ let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); These secrets are the same: ```rust -# use rand_core::OsRng; +# use rand_core::{OsRng, TryRngCore}; # use x25519_dalek::{EphemeralSecret, PublicKey}; -# let alice_secret = EphemeralSecret::random_from_rng(OsRng); +# let mut rng = OsRng.unwrap_err(); +# let alice_secret = EphemeralSecret::random_from_rng(&mut rng); # let alice_public = PublicKey::from(&alice_secret); -# let bob_secret = EphemeralSecret::random_from_rng(OsRng); +# let bob_secret = EphemeralSecret::random_from_rng(&mut rng); # let bob_public = PublicKey::from(&bob_secret); # let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); # let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); diff --git a/x25519-dalek/benches/x25519.rs b/x25519-dalek/benches/x25519.rs index 77c832db0..a9bea3974 100644 --- a/x25519-dalek/benches/x25519.rs +++ b/x25519-dalek/benches/x25519.rs @@ -13,18 +13,18 @@ use criterion::{criterion_group, criterion_main, Criterion}; -use rand_core::OsRng; +use rand_core::{OsRng, TryRngCore}; use x25519_dalek::EphemeralSecret; use x25519_dalek::PublicKey; fn bench_diffie_hellman(c: &mut Criterion) { - let bob_secret = EphemeralSecret::random_from_rng(OsRng); + let bob_secret = EphemeralSecret::random_from_rng(&mut OsRng.unwrap_err()); let bob_public = PublicKey::from(&bob_secret); c.bench_function("diffie_hellman", move |b| { b.iter_with_setup( - || EphemeralSecret::random_from_rng(OsRng), + || EphemeralSecret::random_from_rng(&mut OsRng.unwrap_err()), |alice_secret| alice_secret.diffie_hellman(&bob_public), ) }); diff --git a/x25519-dalek/src/x25519.rs b/x25519-dalek/src/x25519.rs index 11ca80ec1..4a945e10a 100644 --- a/x25519-dalek/src/x25519.rs +++ b/x25519-dalek/src/x25519.rs @@ -17,7 +17,8 @@ use curve25519_dalek::{edwards::EdwardsPoint, montgomery::MontgomeryPoint, traits::IsIdentity}; use rand_core::CryptoRng; -use rand_core::RngCore; +#[cfg(feature = "os_rng")] +use rand_core::TryRngCore; #[cfg(feature = "zeroize")] use zeroize::{Zeroize, ZeroizeOnDrop}; @@ -85,12 +86,12 @@ impl EphemeralSecret { since = "2.0.0", note = "Renamed to `random_from_rng`. This will be removed in 2.1.0" )] - pub fn new(mut csprng: T) -> Self { - Self::random_from_rng(&mut csprng) + pub fn new(csprng: &mut R) -> Self { + Self::random_from_rng(csprng) } /// Generate a new [`EphemeralSecret`] with the supplied RNG. - pub fn random_from_rng(mut csprng: T) -> Self { + pub fn random_from_rng(csprng: &mut R) -> Self { // The secret key is random bytes. Clamping is done later. let mut bytes = [0u8; 32]; csprng.fill_bytes(&mut bytes); @@ -100,7 +101,7 @@ impl EphemeralSecret { /// Generate a new [`EphemeralSecret`]. #[cfg(feature = "os_rng")] pub fn random() -> Self { - Self::random_from_rng(rand_core::OsRng) + Self::random_from_rng(&mut rand_core::OsRng.unwrap_err()) } } @@ -147,12 +148,12 @@ impl ReusableSecret { since = "2.0.0", note = "Renamed to `random_from_rng`. This will be removed in 2.1.0." )] - pub fn new(mut csprng: T) -> Self { - Self::random_from_rng(&mut csprng) + pub fn new(csprng: &mut R) -> Self { + Self::random_from_rng(csprng) } /// Generate a new [`ReusableSecret`] with the supplied RNG. - pub fn random_from_rng(mut csprng: T) -> Self { + pub fn random_from_rng(csprng: &mut R) -> Self { // The secret key is random bytes. Clamping is done later. let mut bytes = [0u8; 32]; csprng.fill_bytes(&mut bytes); @@ -160,9 +161,9 @@ impl ReusableSecret { } /// Generate a new [`ReusableSecret`]. - #[cfg(feature = "getrandom")] + #[cfg(feature = "os_rng")] pub fn random() -> Self { - Self::random_from_rng(rand_core::OsRng) + Self::random_from_rng(&mut rand_core::OsRng.unwrap_mut()) } } @@ -207,12 +208,12 @@ impl StaticSecret { since = "2.0.0", note = "Renamed to `random_from_rng`. This will be removed in 2.1.0" )] - pub fn new(mut csprng: T) -> Self { - Self::random_from_rng(&mut csprng) + pub fn new(csprng: &mut R) -> Self { + Self::random_from_rng(csprng) } /// Generate a new [`StaticSecret`] with the supplied RNG. - pub fn random_from_rng(mut csprng: T) -> Self { + pub fn random_from_rng(csprng: &mut R) -> Self { // The secret key is random bytes. Clamping is done later. let mut bytes = [0u8; 32]; csprng.fill_bytes(&mut bytes); @@ -220,9 +221,9 @@ impl StaticSecret { } /// Generate a new [`StaticSecret`]. - #[cfg(feature = "getrandom")] + #[cfg(feature = "os_rng")] pub fn random() -> Self { - Self::random_from_rng(rand_core::OsRng) + Self::random_from_rng(&mut rand_core::OsRng.unwrap_mut()) } /// Extract this key's bytes for serialization. @@ -340,17 +341,20 @@ impl AsRef<[u8]> for SharedSecret { #[cfg_attr(not(feature = "static_secrets"), doc = "```ignore")] /// use rand_core::OsRng; /// use rand_core::RngCore; +/// use rand_core::TryRngCore; /// /// use x25519_dalek::x25519; /// use x25519_dalek::StaticSecret; /// use x25519_dalek::PublicKey; /// +/// let mut rng = OsRng.unwrap_err(); +/// /// // Generate Alice's key pair. -/// let alice_secret = StaticSecret::random_from_rng(&mut OsRng); +/// let alice_secret = StaticSecret::random_from_rng(&mut rng); /// let alice_public = PublicKey::from(&alice_secret); /// /// // Generate Bob's key pair. -/// let bob_secret = StaticSecret::random_from_rng(&mut OsRng); +/// let bob_secret = StaticSecret::random_from_rng(&mut rng); /// let bob_public = PublicKey::from(&bob_secret); /// /// // Alice and Bob should now exchange their public keys. diff --git a/x25519-dalek/tests/x25519_tests.rs b/x25519-dalek/tests/x25519_tests.rs index d589b3e44..8304b7727 100644 --- a/x25519-dalek/tests/x25519_tests.rs +++ b/x25519-dalek/tests/x25519_tests.rs @@ -181,34 +181,34 @@ fn rfc7748_ladder_test2() { mod rand_core { use super::*; - use ::rand_core::OsRng; + use ::rand_core::{OsRng, TryRngCore}; #[test] fn ephemeral_from_rng() { #[allow(deprecated)] - EphemeralSecret::new(OsRng); - EphemeralSecret::random_from_rng(OsRng); + EphemeralSecret::new(&mut OsRng.unwrap_err()); + EphemeralSecret::random_from_rng(&mut OsRng.unwrap_err()); } #[test] #[cfg(feature = "reusable_secrets")] fn reusable_from_rng() { #[allow(deprecated)] - ReusableSecret::new(OsRng); - ReusableSecret::random_from_rng(OsRng); + ReusableSecret::new(&mut OsRng.unwrap_err()); + ReusableSecret::random_from_rng(&mut OsRng.unwrap_err()); } #[test] #[cfg(feature = "static_secrets")] fn static_from_rng() { #[allow(deprecated)] - StaticSecret::new(OsRng); - StaticSecret::random_from_rng(OsRng); + StaticSecret::new(&mut OsRng.unwrap_err()); + StaticSecret::random_from_rng(&mut OsRng.unwrap_err()); } } -#[cfg(feature = "getrandom")] -mod getrandom { +#[cfg(feature = "os_rng")] +mod os_rng { use super::*;