relax Sized requirements on the rng

Author: baloo

Cargo.lock

@@ -31,4 +31,5 @@ crypto-bigint = { git = "https://github.com/RustCrypto/crypto-bigint.git" }
 ff = { git = "https://github.com/zkcrypto/ff.git", branch = "release-0.14.0" }
 
 # https://github.com/zkcrypto/group/pull/56
-group = { git = "https://github.com/pinkforest/group.git", branch = "bump-rand-0.9" }
+# https://github.com/zkcrypto/group/pull/57
+group = { git = "https://github.com/baloo/group.git", branch = "baloo/relax-rng" }

Cargo.toml

@@ -130,7 +130,7 @@ pub trait AeadCore {
     /// See [`AeadCore::generate_nonce`] documentation for requirements for
     /// random nonces.
     #[cfg(feature = "rand_core")]
-    fn generate_nonce_with_rng<R: CryptoRng>(rng: &mut R) -> Nonce<Self> {
+    fn generate_nonce_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Nonce<Self> {
         let mut nonce = Nonce::<Self>::default();
         rng.fill_bytes(&mut nonce);
         nonce
@@ -141,7 +141,7 @@ pub trait AeadCore {
     /// See [`AeadCore::generate_nonce`] documentation for requirements for
     /// random nonces.
     #[cfg(feature = "rand_core")]
-    fn try_generate_nonce_with_rng<R: TryCryptoRng>(
+    fn try_generate_nonce_with_rng<R: TryCryptoRng + ?Sized>(
         rng: &mut R,
     ) -> core::result::Result<Nonce<Self>, R::Error> {
         let mut nonce = Nonce::<Self>::default();

aead/src/lib.rs

@@ -196,7 +196,7 @@ pub trait KeyInit: KeySizeUser + Sized {
     /// Generate random key using the provided [`CryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn generate_key_with_rng<R: CryptoRng>(rng: &mut R) -> Key<Self> {
+    fn generate_key_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Key<Self> {
         let mut key = Key::<Self>::default();
         rng.fill_bytes(&mut key);
         key
@@ -205,7 +205,9 @@ pub trait KeyInit: KeySizeUser + Sized {
     /// Generate random key using the provided [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn try_generate_key_with_rng<R: TryCryptoRng>(rng: &mut R) -> Result<Key<Self>, R::Error> {
+    fn try_generate_key_with_rng<R: TryCryptoRng + ?Sized>(
+        rng: &mut R,
+    ) -> Result<Key<Self>, R::Error> {
         let mut key = Key::<Self>::default();
         rng.try_fill_bytes(&mut key)?;
         Ok(key)
@@ -250,7 +252,7 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random key using the provided [`CryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn generate_key_with_rng<R: CryptoRng>(rng: &mut R) -> Key<Self> {
+    fn generate_key_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Key<Self> {
         let mut key = Key::<Self>::default();
         rng.fill_bytes(&mut key);
         key
@@ -259,7 +261,9 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random key using the provided [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn try_generate_key_with_rng<R: TryCryptoRng>(rng: &mut R) -> Result<Key<Self>, R::Error> {
+    fn try_generate_key_with_rng<R: TryCryptoRng + ?Sized>(
+        rng: &mut R,
+    ) -> Result<Key<Self>, R::Error> {
         let mut key = Key::<Self>::default();
         rng.try_fill_bytes(&mut key)?;
         Ok(key)
@@ -277,7 +281,7 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random IV using the provided [`CryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn generate_iv_with_rng<R: CryptoRng>(rng: &mut R) -> Iv<Self> {
+    fn generate_iv_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Iv<Self> {
         let mut iv = Iv::<Self>::default();
         rng.fill_bytes(&mut iv);
         iv
@@ -286,7 +290,9 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random IV using the provided [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn try_generate_iv_with_rng<R: TryCryptoRng>(rng: &mut R) -> Result<Iv<Self>, R::Error> {
+    fn try_generate_iv_with_rng<R: TryCryptoRng + ?Sized>(
+        rng: &mut R,
+    ) -> Result<Iv<Self>, R::Error> {
         let mut iv = Iv::<Self>::default();
         rng.try_fill_bytes(&mut iv)?;
         Ok(iv)
@@ -304,7 +310,7 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random key and IV using the provided [`CryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn generate_key_iv_with_rng<R: CryptoRng>(rng: &mut R) -> (Key<Self>, Iv<Self>) {
+    fn generate_key_iv_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> (Key<Self>, Iv<Self>) {
         let key = Self::generate_key_with_rng(rng);
         let iv = Self::generate_iv_with_rng(rng);
         (key, iv)
@@ -313,7 +319,7 @@ pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
     /// Generate random key and IV using the provided [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn try_generate_key_iv_with_rng<R: TryCryptoRng>(
+    fn try_generate_key_iv_with_rng<R: TryCryptoRng + ?Sized>(
         rng: &mut R,
     ) -> Result<(Key<Self>, Iv<Self>), R::Error> {
         let key = Self::try_generate_key_with_rng(rng)?;
@@ -357,7 +363,7 @@ pub trait InnerIvInit: InnerUser + IvSizeUser + Sized {
     /// Generate random IV using the provided [`CryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn generate_iv_with_rng<R: CryptoRng>(rng: &mut R) -> Iv<Self> {
+    fn generate_iv_with_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Iv<Self> {
         let mut iv = Iv::<Self>::default();
         rng.fill_bytes(&mut iv);
         iv
@@ -366,7 +372,9 @@ pub trait InnerIvInit: InnerUser + IvSizeUser + Sized {
     /// Generate random IV using the provided [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
     #[inline]
-    fn try_generate_iv_with_rng<R: TryCryptoRng>(rng: &mut R) -> Result<Iv<Self>, R::Error> {
+    fn try_generate_iv_with_rng<R: TryCryptoRng + ?Sized>(
+        rng: &mut R,
+    ) -> Result<Iv<Self>, R::Error> {
         let mut iv = Iv::<Self>::default();
         rng.try_fill_bytes(&mut iv)?;
         Ok(iv)

crypto-common/src/lib.rs

@@ -575,7 +575,7 @@ impl ToEncodedPoint<MockCurve> for ProjectivePoint {
 impl group::Group for ProjectivePoint {
     type Scalar = Scalar;
 
-    fn random(_rng: impl RngCore) -> Self {
+    fn random<R: RngCore + ?Sized>(_rng: &mut R) -> Self {
         unimplemented!();
     }
 

elliptic-curve/src/dev.rs

@@ -108,7 +108,7 @@ where
     C: CurveArithmetic,
 {
     /// Generate a cryptographically random [`EphemeralSecret`].
-    pub fn random<R: CryptoRng>(rng: &mut R) -> Self {
+    pub fn random<R: CryptoRng + ?Sized>(rng: &mut R) -> Self {
         Self {
             scalar: NonZeroScalar::random(rng),
         }

elliptic-curve/src/ecdh.rs

@@ -58,9 +58,9 @@ where
     P: ConditionallySelectable + ConstantTimeEq + Curve + Default,
 {
     /// Generate a random `NonIdentity<ProjectivePoint>`.
-    pub fn random<R: CryptoRng>(mut rng: R) -> Self {
+    pub fn random<R: CryptoRng + ?Sized>(rng: &mut R) -> Self {
         loop {
-            if let Some(point) = Self::new(P::random(&mut rng)).into() {
+            if let Some(point) = Self::new(P::random(rng)).into() {
                 break point;
             }
         }

elliptic-curve/src/point/non_identity.rs

@@ -38,7 +38,7 @@ where
     C: CurveArithmetic,
 {
     /// Create a new [`BlindedScalar`] from a scalar and a [`CryptoRng`].
-    pub fn new<R: CryptoRng>(scalar: Scalar<C>, rng: &mut R) -> Self {
+    pub fn new<R: CryptoRng + ?Sized>(scalar: Scalar<C>, rng: &mut R) -> Self {
         Self {
             scalar,
             mask: Scalar::<C>::random(rng),

elliptic-curve/src/scalar/blinded.rs

@@ -65,7 +65,7 @@ where
     pub const MODULUS: C::Uint = C::ORDER;
 
     /// Generate a random [`ScalarPrimitive`].
-    pub fn random<R: CryptoRng>(rng: &mut R) -> Self {
+    pub fn random<R: CryptoRng + ?Sized>(rng: &mut R) -> Self {
         Self {
             inner: C::Uint::random_mod(rng, &NonZero::new(Self::MODULUS).unwrap()),
         }

elliptic-curve/src/scalar/primitive.rs

@@ -94,7 +94,7 @@ where
 
     /// Generate a random [`SecretKey`].
     #[cfg(feature = "arithmetic")]
-    pub fn random<R: CryptoRng>(rng: &mut R) -> Self
+    pub fn random<R: CryptoRng + ?Sized>(rng: &mut R) -> Self
     where
         C: CurveArithmetic,
     {

elliptic-curve/src/secret_key.rs

@@ -203,15 +203,17 @@ pub struct SaltString {
 impl SaltString {
     /// Generate a random B64-encoded [`SaltString`] from [`CryptoRng`].
     #[cfg(feature = "rand_core")]
-    pub fn from_rng<R: CryptoRng>(rng: &mut R) -> Self {
+    pub fn from_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Self {
         let mut bytes = [0u8; Salt::RECOMMENDED_LENGTH];
         rng.fill_bytes(&mut bytes);
         Self::encode_b64(&bytes).expect(INVARIANT_VIOLATED_MSG)
     }
 
     /// Generate a random B64-encoded [`SaltString`] from [`TryCryptoRng`].
     #[cfg(feature = "rand_core")]
-    pub fn try_from_rng<R: TryCryptoRng>(rng: &mut R) -> core::result::Result<Self, R::Error> {
+    pub fn try_from_rng<R: TryCryptoRng + ?Sized>(
+        rng: &mut R,
+    ) -> core::result::Result<Self, R::Error> {
         let mut bytes = [0u8; Salt::RECOMMENDED_LENGTH];
         rng.try_fill_bytes(&mut bytes)?;
         let salt = Self::encode_b64(&bytes).expect(INVARIANT_VIOLATED_MSG);