elliptic-curve: add Reduce trait

elliptic-curve/src/arithmetic.rs

@@ -1,6 +1,6 @@
 //! Elliptic curve arithmetic traits.
 
-use crate::{Curve, FieldBytes, PrimeCurve, ScalarCore};
+use crate::{ops::Reduce, Curve, FieldBytes, PrimeCurve, ScalarCore};
 use core::fmt::Debug;
 use subtle::{ConditionallySelectable, ConstantTimeEq};
 use zeroize::DefaultIsZeroes;
@@ -73,8 +73,9 @@ pub trait ScalarArithmetic: Curve {
     /// - [`Sync`]
     type Scalar: DefaultIsZeroes
         + From<ScalarCore<Self>>
-        + Into<Self::UInt>
         + Into<FieldBytes<Self>>
+        + Into<Self::UInt>
+        + Reduce<Self::UInt>
         + ff::Field
         + ff::PrimeField<Repr = FieldBytes<Self>>;
 }

elliptic-curve/src/dev.rs

@@ -4,6 +4,7 @@
 use crate::{
     bigint::U256,
     error::{Error, Result},
+    ops::Reduce,
     rand_core::RngCore,
     sec1::{FromEncodedPoint, ToEncodedPoint},
     subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption},
@@ -310,6 +311,12 @@ impl Neg for Scalar {
     }
 }
 
+impl Reduce<U256> for Scalar {
+    fn from_uint_reduced(_: U256) -> Self {
+        unimplemented!();
+    }
+}
+
 impl From<u64> for Scalar {
     fn from(n: u64) -> Scalar {
         Self(n.into())

elliptic-curve/src/ops.rs

@@ -2,6 +2,7 @@
 
 pub use core::ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign};
 
+use crypto_bigint::{ArrayEncoding, ByteArray, Integer};
 use subtle::CtOption;
 
 /// Perform an inversion on a field element (i.e. base field element or scalar)
@@ -21,3 +22,21 @@ impl<F: ff::Field> Invert for F {
         ff::Field::invert(self)
     }
 }
+
+/// Modular reduction.
+pub trait Reduce<UInt: Integer + ArrayEncoding>: Sized {
+    /// Perform a modular reduction, returning a field element.
+    fn from_uint_reduced(n: UInt) -> Self;
+
+    /// Interpret the given byte array as a big endian integer and perform a
+    /// modular reduction.
+    fn from_be_bytes_reduced(bytes: ByteArray<UInt>) -> Self {
+        Self::from_uint_reduced(UInt::from_be_byte_array(bytes))
+    }
+
+    /// Interpret the given byte array as a big endian integer and perform a
+    /// modular reduction.
+    fn from_le_bytes_reduced(bytes: ByteArray<UInt>) -> Self {
+        Self::from_uint_reduced(UInt::from_le_byte_array(bytes))
+    }
+}