fix: clippy

Author: Autoparallel

examples/aes_chained_cbc.rs

@@ -6,7 +6,7 @@
 //! attacker can detect which original message was used in the ciphertext which is shown here.
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 use ronkathon::encryption::symmetric::{
   aes::{Block, Key, AES},
   modes::cbc::CBC,
@@ -52,18 +52,18 @@ fn attacker<'a>(key: &Key<128>, iv: &Block, ciphertext: Vec<u8>) -> &'a [u8] {
 /// We simulate Chained CBC and show that attacker can know whether initial plaintext was message 1
 /// or 2.
 fn main() {
-  let mut rng = thread_rng();
+  let mut rng = rng();
 
   // generate a random key and publicly known IV, and initiate CBC with AES cipher
-  let key = Key::<128>::new(rng.gen());
-  let iv = Block(rng.gen());
+  let key = Key::<128>::new(rng.random());
+  let iv = Block(rng.random());
   let cbc = CBC::<AES<128>>::new(iv);
 
   // Chose 2 random messages, {m_0, m_1}
   let messages = attacker_chosen_message();
 
   // select a uniform bit b, and chose message m_b for encryption
-  let bit = rng.gen_range(0..=1);
+  let bit = rng.random_range(0..=1);
   let encrypted = cbc.encrypt(&key, messages[bit]);
 
   let predicted_message = attacker(&key, &iv, encrypted);

src/algebra/field/binary_towers/extension.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use rand::{
-  distributions::{Distribution, Standard},
+  distr::{Distribution, StandardUniform},
   Rng,
 };
 
@@ -262,12 +262,12 @@ where
   }
 }
 
-impl<const K: usize> Distribution<BinaryTowers<K>> for Standard
+impl<const K: usize> Distribution<BinaryTowers<K>> for StandardUniform
 where [(); 1 << K]:
 {
   #[inline]
   fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> BinaryTowers<K> {
-    let num = rng.gen_range(1..1 << (1 << K));
+    let num = rng.random_range(1..1 << (1 << K));
     let coefficients = to_bool_vec(num, 1 << K).try_into().unwrap_or_else(|v: Vec<BinaryField>| {
       panic!("Expected a Vec of length {} but it was {}", 1 << K, v.len())
     });

src/algebra/field/binary_towers/tests.rs

@@ -1,4 +1,4 @@
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 use rstest::rstest;
 
 use super::*;
@@ -54,9 +54,9 @@ fn num_digit(#[case] num: u64, #[case] digits: usize) {
 
 #[test]
 fn add_sub_neg() {
-  let mut rng = thread_rng();
-  let a = rng.gen::<BinaryTowers<3>>();
-  let b = rng.gen::<BinaryTowers<3>>();
+  let mut rng = rng();
+  let a = rng.random::<BinaryTowers<3>>();
+  let b = rng.random::<BinaryTowers<3>>();
 
   assert_eq!(a + a, BinaryTowers::<3>::ZERO);
   assert_eq!(a + a, b + b);
@@ -87,11 +87,11 @@ fn mul_div(#[case] a: BinaryTowers<3>, #[case] b: BinaryTowers<3>, #[case] res:
 
 #[test]
 fn small_by_large_mul() {
-  let mut rng = thread_rng();
+  let mut rng = rng();
   for _ in 0..100 {
-    let a = rng.gen::<BinaryTowers<5>>();
+    let a = rng.random::<BinaryTowers<5>>();
 
-    let val = rng.gen_range(0..1 << (1 << 3));
+    let val = rng.random_range(0..1 << (1 << 3));
 
     let b = BinaryTowers::<3>::from(val);
     let d = BinaryTowers::<5>::from(val);
@@ -111,8 +111,8 @@ fn small_by_large_mul() {
 
 #[test]
 fn efficient_embedding() {
-  let mut rng = thread_rng();
-  let a = rng.gen::<BinaryTowers<4>>();
+  let mut rng = rng();
+  let a = rng.random::<BinaryTowers<4>>();
 
   let (a1, a2) = a.into();
 

src/algebra/field/extension/gf_101_2.rs

@@ -8,7 +8,7 @@
 //! verified by finding out embedding degree of the curve, i.e. smallest k such that r|q^k-1.
 
 use super::*;
-use crate::{Distribution, Monomial, Polynomial, Rng, Standard};
+use crate::{Distribution, Monomial, Polynomial, Rng, StandardUniform};
 
 impl ExtensionField<2, 101> for PlutoBaseFieldExtension {
   /// irreducible polynomial used to reduce field polynomials to second degree:
@@ -127,10 +127,11 @@ impl FiniteField for PlutoBaseFieldExtension {
   const PRIMITIVE_ELEMENT: Self = Self::new([PlutoBaseField::new(14), PlutoBaseField::new(9)]);
 }
 
-impl<const N: usize, const P: usize> Distribution<GaloisField<N, P>> for Standard {
+impl<const N: usize, const P: usize> Distribution<GaloisField<N, P>> for StandardUniform {
   #[inline]
   fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> GaloisField<N, P> {
-    let coeffs = (0..N).map(|_| rng.gen::<PrimeField<P>>()).collect::<Vec<_>>().try_into().unwrap();
+    let coeffs =
+      (0..N).map(|_| rng.random::<PrimeField<P>>()).collect::<Vec<_>>().try_into().unwrap();
     GaloisField::<N, P>::new(coeffs)
   }
 }
@@ -147,7 +148,7 @@ impl Mul for PlutoBaseFieldExtension {
       Polynomial::<Monomial, PlutoBaseField, 3>::from(Self::IRREDUCIBLE_POLYNOMIAL_COEFFICIENTS);
     let product = (poly_self * poly_rhs) % poly_irred;
     let res: [PlutoBaseField; 2] =
-      array::from_fn(|i| product.coefficients.get(i).cloned().unwrap_or(PlutoBaseField::ZERO));
+      array::from_fn(|i| product.coefficients.get(i).copied().unwrap_or(PlutoBaseField::ZERO));
 
     Self::new(res)
   }
@@ -251,10 +252,10 @@ mod tests {
 
   #[test]
   fn add_sub_neg_mul() {
-    let mut rng = rand::thread_rng();
-    let x = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
-    let y = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
-    let z = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+    let mut rng = rand::rng();
+    let x = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
+    let y = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
+    let z = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
     assert_eq!(x + (-x), <PlutoBaseFieldExtension>::ZERO);
     assert_eq!(-x, <PlutoBaseFieldExtension>::ZERO - x);
     assert_eq!(
@@ -268,13 +269,13 @@ mod tests {
     assert_eq!(x - (y + z), (x - y) - z);
     assert_eq!((x + y) - z, x + (y - z));
     assert_eq!(x * (y + z), x * y + x * z);
-    assert_eq!(x + y + z + x + y + z, [x, x, y, y, z, z].iter().cloned().sum());
+    assert_eq!(x + y + z + x + y + z, [x, x, y, y, z, z].iter().copied().sum());
   }
 
   #[test]
   fn pow() {
-    let mut rng = rand::thread_rng();
-    let x = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+    let mut rng = rand::rng();
+    let x = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
 
     assert_eq!(x, x.pow(1));
 
@@ -284,24 +285,24 @@ mod tests {
 
   #[test]
   fn inv_div() {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     // Loop rng's until we get something with inverse.
     let mut x = <PlutoBaseFieldExtension>::ZERO;
     let mut x_inv = None;
     while x_inv.is_none() {
-      x = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+      x = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
       x_inv = x.inverse();
     }
     let mut y = <PlutoBaseFieldExtension>::ZERO;
     let mut y_inv = None;
     while y_inv.is_none() {
-      y = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+      y = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
       y_inv = y.inverse();
     }
     let mut z = <PlutoBaseFieldExtension>::ZERO;
     let mut z_inv = None;
     while z_inv.is_none() {
-      z = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+      z = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
       z_inv = z.inverse();
     }
     assert_eq!(x * x.inverse().unwrap(), <PlutoBaseFieldExtension>::ONE);
@@ -329,12 +330,12 @@ mod tests {
 
   #[test]
   fn add_sub_mul_subfield() {
-    let mut rng = rand::thread_rng();
-    let x = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+    let mut rng = rand::rng();
+    let x = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
     let mut y = <PlutoBaseFieldExtension>::ZERO;
     let mut y_inv = None;
     while y_inv.is_none() {
-      y = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+      y = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
       y_inv = y.inverse();
     }
 
@@ -362,17 +363,17 @@ mod tests {
 
   #[test]
   fn sqrt() {
-    let mut rng = rand::thread_rng();
-    let x = <PlutoBaseFieldExtension>::from(rng.gen::<PlutoBaseField>());
+    let mut rng = rand::rng();
+    let x = <PlutoBaseFieldExtension>::from(rng.random::<PlutoBaseField>());
     let x_sq = x.pow(2);
 
     let res = x_sq.sqrt();
     assert!(res.is_some());
 
     assert_eq!(res.unwrap().0 * res.unwrap().0, x * x);
 
-    let x_0 = rng.gen::<PlutoBaseField>();
-    let x_1 = rng.gen::<PlutoBaseField>();
+    let x_0 = rng.random::<PlutoBaseField>();
+    let x_1 = rng.random::<PlutoBaseField>();
     let x = <PlutoBaseFieldExtension>::new([x_0, x_1]);
 
     let x_sq = x.pow(2);

src/algebra/field/mod.rs

@@ -13,7 +13,6 @@ use super::Finite;
 
 /// A field is a set of elements on which addition, subtraction, multiplication, and division are
 /// defined.
-
 #[const_trait]
 pub trait Field:
   std::fmt::Debug

src/algebra/field/prime/arithmetic.rs

@@ -134,10 +134,10 @@ mod tests {
   }
 
   fn combined_arithmetic_check<const P: usize>() {
-    let mut rng = rand::thread_rng();
-    let x = rng.gen::<PrimeField<P>>();
-    let y = rng.gen::<PrimeField<P>>();
-    let z = rng.gen::<PrimeField<P>>();
+    let mut rng = rand::rng();
+    let x = rng.random::<PrimeField<P>>();
+    let y = rng.random::<PrimeField<P>>();
+    let z = rng.random::<PrimeField<P>>();
     assert_eq!(x + (-x), <PrimeField<P>>::ZERO);
     assert_eq!(-x, <PrimeField<P>>::ZERO - x);
     assert_eq!(x + x, x * <PrimeField<P>>::new(2));
@@ -148,7 +148,7 @@ mod tests {
     assert_eq!(x - (y + z), (x - y) - z);
     assert_eq!((x + y) - z, x + (y - z));
     assert_eq!(x * (y + z), x * y + x * z);
-    assert_eq!(x + y + z + x + y + z, [x, x, y, y, z, z].iter().cloned().sum());
+    assert_eq!(x + y + z + x + y + z, [x, x, y, y, z, z].iter().copied().sum());
   }
 
   #[rstest]

src/algebra/field/prime/mod.rs

@@ -5,7 +5,7 @@
 
 use std::{fmt, str::FromStr};
 
-use rand::{distributions::Standard, prelude::Distribution, Rng};
+use rand::{distr::StandardUniform, prelude::Distribution, Rng};
 
 use super::*;
 use crate::algebra::Finite;
@@ -210,7 +210,7 @@ impl<const P: usize> fmt::Display for PrimeField<P> {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.value) }
 }
 
-impl<const P: usize> Distribution<PrimeField<P>> for Standard {
+impl<const P: usize> Distribution<PrimeField<P>> for StandardUniform {
   #[inline]
   fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> PrimeField<P> {
     loop {

src/curve/pairing.rs

@@ -197,7 +197,7 @@ pub fn tangent_line<C: EllipticCurve>(a: AffinePoint<C>, input: AffinePoint<C>)
   line_function::<C>(a, a, input)
 }
 
-impl Distribution<AffinePoint<PlutoBaseCurve>> for Standard {
+impl Distribution<AffinePoint<PlutoBaseCurve>> for StandardUniform {
   #[inline]
   fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> AffinePoint<PlutoBaseCurve> {
     loop {
@@ -214,12 +214,14 @@ impl Distribution<AffinePoint<PlutoBaseCurve>> for Standard {
   }
 }
 
-impl Distribution<AffinePoint<PlutoExtendedCurve>> for Standard {
+impl Distribution<AffinePoint<PlutoExtendedCurve>> for StandardUniform {
   #[inline]
   fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> AffinePoint<PlutoExtendedCurve> {
     loop {
-      let x =
-        PlutoBaseFieldExtension::new([rng.gen::<PlutoBaseField>(), rng.gen::<PlutoBaseField>()]);
+      let x = PlutoBaseFieldExtension::new([
+        rng.random::<PlutoBaseField>(),
+        rng.random::<PlutoBaseField>(),
+      ]);
       let rhs: PlutoBaseFieldExtension =
         x.pow(3) + x * PlutoExtendedCurve::EQUATION_A + PlutoExtendedCurve::EQUATION_B;
       if rhs.euler_criterion() {
@@ -257,10 +259,10 @@ mod tests {
 
     // to keep the support disjoint, a random element `S` on extended curve is used, which shouldn't
     // be equal to P, -Q, P-Q
-    let mut rng = rand::thread_rng();
-    let mut s = rng.gen::<AffinePoint<PlutoExtendedCurve>>();
+    let mut rng = rand::rng();
+    let mut s = rng.random::<AffinePoint<PlutoExtendedCurve>>();
     while s == p || s == -q || s == p - q {
-      s = rng.gen::<AffinePoint<PlutoExtendedCurve>>();
+      s = rng.random::<AffinePoint<PlutoExtendedCurve>>();
     }
 
     // (D_Q) ~ (Q+S) - (S) (equivalent divisors)
@@ -278,11 +280,11 @@ mod tests {
 
   #[test]
   fn random_point() {
-    let mut rng = rand::thread_rng();
-    let point = rng.gen::<AffinePoint<PlutoBaseCurve>>();
+    let mut rng = rand::rng();
+    let point = rng.random::<AffinePoint<PlutoBaseCurve>>();
     println!("Random point: {point:?}");
 
-    let ext_point = rng.gen::<AffinePoint<PlutoExtendedCurve>>();
+    let ext_point = rng.random::<AffinePoint<PlutoExtendedCurve>>();
     println!("Random extended point: {ext_point:?}");
   }
 

src/diffie_hellman/ecdh.rs

@@ -25,10 +25,10 @@ mod tests {
 
   #[test]
   fn test_compute_shared_secret() {
-    let mut rng = rand::rngs::OsRng;
+    let mut rng = rand::rng();
 
-    let d_a = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..=PlutoScalarField::ORDER));
-    let d_b = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..=PlutoScalarField::ORDER));
+    let d_a = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..=PlutoScalarField::ORDER));
+    let d_b = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..=PlutoScalarField::ORDER));
 
     let q_a = AffinePoint::<PlutoBaseCurve>::GENERATOR * d_a;
     let q_b = AffinePoint::<PlutoBaseCurve>::GENERATOR * d_b;

src/diffie_hellman/tp_ecdh.rs

@@ -69,13 +69,13 @@ pub fn compute_shared_secret(
 
   let pairing = pairing::<_, { PlutoBaseCurve::ORDER }>(p_b, q_c);
 
-  let shared_secret = pairing.pow(d_a.value);
-
-  shared_secret
+  pairing.pow(d_a.value)
 }
 
 #[cfg(test)]
 mod tests {
+  use rand::rng;
+
   use super::*;
   use crate::{
     algebra::{field::prime::PlutoScalarField, group::FiniteCyclicGroup, Finite},
@@ -84,9 +84,9 @@ mod tests {
 
   #[test]
   fn test_compute_local_pair() {
-    let mut rng = rand::rngs::OsRng;
+    let mut rng = rng();
 
-    let d_a = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..=PlutoScalarField::ORDER));
+    let d_a = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..=PlutoScalarField::ORDER));
 
     let (p_a, q_a) = compute_local_pair(d_a);
 
@@ -96,14 +96,14 @@ mod tests {
 
   #[test]
   fn test_compute_tripartite_shared_secret() {
-    let mut rng = rand::rngs::OsRng;
+    let mut rng = rng();
 
     let p = AffinePoint::<PlutoBaseCurve>::GENERATOR;
     let q = AffinePoint::<PlutoExtendedCurve>::GENERATOR;
 
-    let d_a = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..PlutoScalarField::ORDER));
-    let d_b = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..PlutoScalarField::ORDER));
-    let d_c = PlutoScalarField::new(rand::Rng::gen_range(&mut rng, 1..PlutoScalarField::ORDER));
+    let d_a = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..PlutoScalarField::ORDER));
+    let d_b = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..PlutoScalarField::ORDER));
+    let d_c = PlutoScalarField::new(rand::Rng::random_range(&mut rng, 1..PlutoScalarField::ORDER));
 
     let p_a = p * d_a;
     let p_b = p * d_b;