Reduce after calling from_bytes_wide

Restores bound of `3` for 32-bit platforms.

Author: kayabaNerve

curve25519-dalek/src/backend/serial/fiat_u32/field.rs

@@ -272,5 +272,5 @@ impl FieldElement2625 {
 
 #[cfg(feature = "hazmat")]
 impl crate::hazmat::UnderlyingCapacity for FieldElement2625 {
-    type Capacity = typenum::U2;
+    type Capacity = typenum::U3;
 }

curve25519-dalek/src/backend/serial/u32/field.rs

@@ -608,5 +608,5 @@ impl FieldElement2625 {
 
 #[cfg(feature = "hazmat")]
 impl crate::hazmat::UnderlyingCapacity for FieldElement2625 {
-    type Capacity = typenum::U2;
+    type Capacity = typenum::U3;
 }

curve25519-dalek/src/hazmat.rs

@@ -34,7 +34,7 @@ pub struct OpaqueFieldElement(Underlying);
 /// implementations. Its size and internals are not guaranteed to have
 /// any specific properties and are not covered by semver.
 ///
-/// Usage is recommended to be done via `LazyFieldWithCapacity<U2>` which is
+/// Usage is recommended to be done via `LazyFieldWithCapacity<U3>` which is
 /// comprehensive to all backends.
 #[derive(Copy)]
 pub struct FieldElement<U: Unsigned = U1>(pub(crate) OpaqueFieldElement, pub(crate) PhantomData<U>);
@@ -217,7 +217,7 @@ impl Field for FieldElement {
     fn try_from_rng<R: rand_core::TryRngCore + ?Sized>(rng: &mut R) -> Result<Self, R::Error> {
         let mut bytes = [0; 64];
         rng.try_fill_bytes(&mut bytes)?;
-        Ok(Self::from(Underlying::from_bytes_wide(&bytes)))
+        Ok(Self::from_uniform_bytes(&bytes))
     }
 
     fn square(&self) -> Self {
@@ -315,7 +315,9 @@ impl From<u64> for FieldElement {
 
 impl FromUniformBytes<64> for FieldElement {
     fn from_uniform_bytes(bytes: &[u8; 64]) -> Self {
-        Self::from(Underlying::from_bytes_wide(bytes))
+        Self::from(Underlying::from_bytes(
+            &Underlying::from_bytes_wide(bytes).to_bytes(),
+        ))
     }
 }
 

curve25519-dalek/src/hazmat/lazy_field25519.rs

@@ -65,20 +65,25 @@ impl<CapacityUsed: Unsigned> LazyField<CapacityUsed> for FieldElement<CapacityUs
 #[cfg(test)]
 mod tests {
     use crate::hazmat::lazy_field::{EagerField, LazyField, LazyFieldWithCapacity, Reducible};
-    use typenum::{B1, U2, type_operators::IsLessOrEqual};
+    use typenum::{B1, U2, U3, type_operators::IsLessOrEqual};
 
-    fn add_pair_then_mul<F: LazyFieldWithCapacity<U2>>(
+    fn add_triple_then_mul<F: LazyFieldWithCapacity<U3>>(
         a: F,
         b: F,
         c: F,
         d: F,
+        e: F,
+        f: F,
     ) -> <F as Reducible>::Output
     where
         U2: IsLessOrEqual<F::Capacity, Output = B1>,
+        U3: IsLessOrEqual<F::Capacity, Output = B1>,
     {
         let ab = a.add(&b);
-        let cd = c.add(&d);
-        ab.mul(&cd)
+        let abc = ab.add(&c);
+        let de = d.add(&e);
+        let def = de.add(&f);
+        abc.mul(&def)
     }
 
     #[test]
@@ -95,21 +100,33 @@ mod tests {
             let b = FieldElement::random(&mut rng);
             let c = FieldElement::random(&mut rng);
             let d = FieldElement::random(&mut rng);
-            let expected = (a + b) * (c + d);
+            let e = FieldElement::random(&mut rng);
+            let f = FieldElement::random(&mut rng);
+            let expected = (a + b + c) * (d + e + f);
 
-            assert_eq!(LazyField::add(a, &b).mul(&LazyField::add(c, &d)), expected);
-            assert_eq!(add_pair_then_mul(a, b, c, d), expected);
+            assert_eq!(
+                LazyField::add(a, &b)
+                    .add(&c)
+                    .mul(&LazyField::add(d, &e).add(&f)),
+                expected
+            );
+            assert_eq!(add_triple_then_mul(a, b, c, d, e, f), expected);
 
             let a = EagerField(a, PhantomData::<typenum::U1>);
             let b = EagerField(b, PhantomData::<typenum::U1>);
             let c = EagerField(c, PhantomData::<typenum::U1>);
             let d = EagerField(d, PhantomData::<typenum::U1>);
+            let e = EagerField(e, PhantomData::<typenum::U1>);
+            let f = EagerField(f, PhantomData::<typenum::U1>);
 
             assert_eq!(
-                LazyField::add(a, &b).mul(&LazyField::add(c, &d)).0,
+                LazyField::add(a, &b)
+                    .add(&c)
+                    .mul(&LazyField::add(d, &e).add(&f))
+                    .0,
                 expected
             );
-            assert_eq!(add_pair_then_mul(a, b, c, d).0, expected);
+            assert_eq!(add_triple_then_mul(a, b, c, d, e, f).0, expected);
         }
     }
 }