arithmetic: Rename Modulus to Mont.

Author: briansmith

src/arithmetic/bigint.rs

@@ -53,7 +53,7 @@ pub(crate) use {
             elem_sub, elem_verify_equal_consttime, elem_widen, verify_inverses_consttime, Elem,
         },
         exp::elem_exp_consttime,
-        modulus::{IntoMont, Modulus, One},
+        modulus::{IntoMont, Mont, One},
         private_exponent::PrivateExponent,
     },
     super::exp_vartime::elem_exp_vartime,
@@ -71,7 +71,7 @@ impl<M> Uninit<M> {
     pub fn into_elem_from_be_bytes_padded(
         self,
         input: untrusted::Input<'_>,
-        m: &Modulus<M>,
+        m: &Mont<M>,
     ) -> Result<Elem<M>, error::Unspecified> {
         self.write_from_be_byes_padded(input)
             .map_err(error::erase::<LenMismatchError>)
@@ -82,7 +82,7 @@ impl<M> Uninit<M> {
 impl<M> Elem<M, Unencoded> {
     fn from_limbs(
         out: BoxedLimbs<M>,
-        m: &Modulus<M>,
+        m: &Mont<M>,
     ) -> Result<Elem<M, Unencoded>, error::Unspecified> {
         limb::verify_limbs_less_than_limbs_leak_bit(out.as_ref(), m.limbs())?;
         Ok(Elem::assume_in_range_and_encoded_less_safe(out))

src/arithmetic/bigint/elem.rs

@@ -18,7 +18,7 @@ use crate::polyfill::prelude::*;
 use super::{
     super::{montgomery::*, MAX_LIMBS},
     boxed_limbs::BoxedLimbs,
-    unwrap_impossible_len_mismatch_error, unwrap_impossible_limb_slice_error, Modulus, Uninit,
+    unwrap_impossible_len_mismatch_error, unwrap_impossible_limb_slice_error, Mont, Uninit,
 };
 use crate::{
     bits::BitLength,
@@ -98,10 +98,7 @@ impl<M, E> Elem<M, E> {
 /// fully reduced mod `m`.
 ///
 /// WARNING: Takes a `Storage` as an in/out value.
-pub(super) fn from_montgomery_amm<M>(
-    mut in_out: BoxedLimbs<M>,
-    m: &Modulus<M>,
-) -> Elem<M, Unencoded> {
+pub(super) fn from_montgomery_amm<M>(mut in_out: BoxedLimbs<M>, m: &Mont<M>) -> Elem<M, Unencoded> {
     let mut one = [0; MAX_LIMBS];
     one[0] = 1;
     let one = &one[..m.limbs().len()];
@@ -118,7 +115,7 @@ pub(super) fn from_montgomery_amm<M>(
 #[cfg(any(test, not(target_arch = "x86_64")))]
 impl<M> Elem<M, R> {
     #[inline]
-    pub fn into_unencoded(self, m: &Modulus<M>) -> Elem<M, Unencoded> {
+    pub fn into_unencoded(self, m: &Mont<M>) -> Elem<M, Unencoded> {
         from_montgomery_amm(self.limbs, m)
     }
 }
@@ -135,7 +132,7 @@ pub fn elem_mul_into<M, AF, BF>(
     out: Uninit<M>,
     a: &Elem<M, AF>,
     b: &Elem<M, BF>,
-    m: &Modulus<M>,
+    m: &Mont<M>,
 ) -> Result<Elem<M, <(AF, BF) as ProductEncoding>::Output>, LenMismatchError>
 where
     (AF, BF): ProductEncoding,
@@ -156,7 +153,7 @@ where
 pub fn elem_mul<M, AF, BF>(
     a: &Elem<M, AF>,
     b: Elem<M, BF>,
-    m: &Modulus<M>,
+    m: &Mont<M>,
 ) -> Elem<M, <(AF, BF) as ProductEncoding>::Output>
 where
     (AF, BF): ProductEncoding,
@@ -173,7 +170,7 @@ where
 }
 
 // r *= 2.
-pub fn elem_double<M, AF>(r: &mut Elem<M, AF>, m: &Modulus<M>) {
+pub fn elem_double<M, AF>(r: &mut Elem<M, AF>, m: &Mont<M>) {
     limb::limbs_double_mod(r.limbs.as_mut(), m.limbs())
         .unwrap_or_else(unwrap_impossible_len_mismatch_error)
 }
@@ -185,7 +182,7 @@ pub fn elem_double<M, AF>(r: &mut Elem<M, AF>, m: &Modulus<M>) {
 pub fn elem_reduced_once<A, M>(
     r: Uninit<M>,
     a: &Elem<A, Unencoded>,
-    m: &Modulus<M>,
+    m: &Mont<M>,
     other_modulus_len_bits: BitLength,
 ) -> Elem<M, Unencoded> {
     assert_eq!(m.len_bits(), other_modulus_len_bits);
@@ -203,7 +200,7 @@ pub fn elem_reduced_once<A, M>(
 pub fn elem_reduced<Larger, Smaller>(
     r: Uninit<Smaller>,
     a: &Elem<Larger, Unencoded>,
-    m: &Modulus<Smaller>,
+    m: &Mont<Smaller>,
     other_prime_len_bits: BitLength,
 ) -> Elem<Smaller, RInverse> {
     // This is stricter than required mathematically but this is what we
@@ -227,7 +224,7 @@ pub fn elem_reduced<Larger, Smaller>(
 #[inline]
 pub fn elem_squared<M, E>(
     a: Elem<M, E>,
-    m: &Modulus<M>,
+    m: &Mont<M>,
 ) -> Elem<M, <(E, E) as ProductEncoding>::Output>
 where
     (E, E): ProductEncoding,
@@ -241,7 +238,7 @@ where
 pub fn elem_widen<Larger, Smaller>(
     r: Uninit<Larger>,
     a: Elem<Smaller, Unencoded>,
-    m: &Modulus<Larger>,
+    m: &Mont<Larger>,
     smaller_modulus_bits: BitLength,
 ) -> Result<Elem<Larger, Unencoded>, error::Unspecified> {
     if smaller_modulus_bits >= m.len_bits() {
@@ -254,14 +251,14 @@ pub fn elem_widen<Larger, Smaller>(
 }
 
 // TODO: Document why this works for all Montgomery factors.
-pub fn elem_add<M, E>(mut a: Elem<M, E>, b: Elem<M, E>, m: &Modulus<M>) -> Elem<M, E> {
+pub fn elem_add<M, E>(mut a: Elem<M, E>, b: Elem<M, E>, m: &Mont<M>) -> Elem<M, E> {
     limb::limbs_add_assign_mod(a.limbs.as_mut(), b.limbs.as_ref(), m.limbs())
         .unwrap_or_else(unwrap_impossible_len_mismatch_error);
     a
 }
 
 // TODO: Document why this works for all Montgomery factors.
-pub fn elem_sub<M, E>(mut a: Elem<M, E>, b: &Elem<M, E>, m: &Modulus<M>) -> Elem<M, E> {
+pub fn elem_sub<M, E>(mut a: Elem<M, E>, b: &Elem<M, E>, m: &Mont<M>) -> Elem<M, E> {
     prefixed_extern! {
         // `r` and `a` may alias.
         fn LIMBS_sub_mod(
@@ -289,7 +286,7 @@ pub fn elem_sub<M, E>(mut a: Elem<M, E>, b: &Elem<M, E>, m: &Modulus<M>) -> Elem
 pub fn verify_inverses_consttime<M>(
     a: &Elem<M, R>,
     b: Elem<M, Unencoded>,
-    m: &Modulus<M>,
+    m: &Mont<M>,
 ) -> Result<(), error::Unspecified> {
     let r = elem_mul(a, b, m);
     limb::verify_limbs_equal_1_leak_bit(r.limbs.as_ref())
@@ -317,7 +314,7 @@ pub mod testutil {
     pub fn consume_elem<M>(
         test_case: &mut crate::testutil::TestCase,
         name: &str,
-        m: &Modulus<M>,
+        m: &Mont<M>,
     ) -> Elem<M, Unencoded> {
         let value = test_case.consume_bytes(name);
         m.alloc_uninit()

src/arithmetic/bigint/exp.rs

@@ -45,7 +45,7 @@ use super::{
         montgomery::{RInverse, Unencoded, RRR},
         LimbSliceError,
     },
-    elem_reduced, Elem, IntoMont, Modulus, One, PrivateExponent, Uninit,
+    elem_reduced, Elem, IntoMont, Mont, One, PrivateExponent, Uninit,
 };
 use crate::{
     bits::BitLength,
@@ -94,7 +94,7 @@ fn elem_exp_consttime_inner<N, M, const STORAGE_LIMBS: usize>(
     base_mod_n: &Elem<N>,
     oneRRR: &One<M, RRR>,
     exponent: &PrivateExponent,
-    m: &Modulus<M>,
+    m: &Mont<M>,
     other_prime_len_bits: BitLength,
 ) -> Result<Elem<M, Unencoded>, LimbSliceError> {
     use super::{
@@ -131,7 +131,7 @@ fn elem_exp_consttime_inner<N, M, const STORAGE_LIMBS: usize>(
     fn power<M>(
         table: &[Limb],
         mut acc: Elem<M, R>,
-        m: &Modulus<M>,
+        m: &Mont<M>,
         i: Window5,
         mut tmp: Elem<M, R>,
     ) -> Result<(Elem<M, R>, Elem<M, R>), LenMismatchError> {
@@ -211,7 +211,7 @@ fn elem_exp_consttime_inner<N, M, const STORAGE_LIMBS: usize>(
     base_mod_n: &Elem<N>,
     oneRRR: &One<M, RRR>,
     exponent: &PrivateExponent,
-    m: &Modulus<M>,
+    m: &Mont<M>,
     other_prime_len_bits: BitLength,
 ) -> Result<Elem<M, Unencoded>, LimbSliceError> {
     use super::{

src/arithmetic/bigint/modulus/mod.rs

@@ -5,7 +5,7 @@ pub(super) mod testutil;
 mod value;
 
 pub(crate) use self::{
-    mont::{IntoMont, Modulus},
+    mont::{IntoMont, Mont},
     one::One,
     value::{ValidatedInput, Value},
 };

src/arithmetic/bigint/modulus/mont.rs

@@ -82,15 +82,15 @@ impl<M, E> IntoMont<M, E> {
     pub fn to_elem<L>(
         &self,
         out: Uninit<L>,
-        l: &Modulus<L>,
+        l: &Mont<L>,
     ) -> Result<Elem<L, Unencoded>, error::Unspecified> {
         out.write_copy_of_slice_padded(self.value.limbs())
             .map_err(error::erase::<LenMismatchError>)
             .and_then(|out| Elem::from_limbs(out, l))
     }
 
-    pub(crate) fn modulus(&self, cpu_features: cpu::Features) -> Modulus<'_, M> {
-        Modulus::from_parts_unchecked_less_safe(&self.value, self.one.n0(), cpu_features)
+    pub(crate) fn modulus(&self, cpu_features: cpu::Features) -> Mont<'_, M> {
+        Mont::from_parts_unchecked_less_safe(&self.value, self.one.n0(), cpu_features)
     }
 
     pub(crate) fn one(&self) -> &One<M, E> {
@@ -116,21 +116,21 @@ impl<M: PublicModulus, E> IntoMont<M, E> {
     }
 }
 
-pub struct Modulus<'a, M> {
+pub struct Mont<'a, M> {
     limbs: &'a [Limb],
     n0: &'a N0,
     len_bits: BitLength,
     m: PhantomData<M>,
     cpu_features: cpu::Features,
 }
 
-impl<'a, M> Modulus<'a, M> {
+impl<'a, M> Mont<'a, M> {
     pub(super) fn from_parts_unchecked_less_safe(
         value: &'a Value<M>,
         n0: &'a N0,
         cpu: cpu::Features,
     ) -> Self {
-        Modulus {
+        Mont {
             limbs: value.limbs(),
             n0,
             len_bits: value.len_bits(),
@@ -140,7 +140,7 @@ impl<'a, M> Modulus<'a, M> {
     }
 }
 
-impl<M> Modulus<'_, M> {
+impl<M> Mont<'_, M> {
     pub fn alloc_uninit(&self) -> Uninit<M> {
         Uninit::new_less_safe(self.limbs.len())
     }

src/arithmetic/bigint/modulus/one.rs

@@ -18,7 +18,7 @@ use crate::polyfill::prelude::*;
 use super::super::{
     super::montgomery::{N0, R, RR, RRR},
     elem::{elem_double, elem_squared},
-    modulus, Elem, Limb, Modulus, PublicModulus, Uninit,
+    modulus, Elem, Limb, Mont, PublicModulus, Uninit,
 };
 use crate::{
     cpu,
@@ -43,7 +43,7 @@ impl<M, E> One<M, E> {
 impl<M> One<M, R> {
     pub(in super::super) fn fillR<'r>(
         out: polyfill::slice::Uninit<'r, Limb>,
-        m: &Modulus<'_, M>,
+        m: &Mont<'_, M>,
     ) -> Result<&'r mut [Limb], LenMismatchError> {
         let r = m.limbs().len() * LIMB_BITS;
 
@@ -94,7 +94,7 @@ impl<M> One<M, RR> {
         let r = w * LIMB_BITS;
 
         let n0 = N0::calculate_from(m);
-        let m = &Modulus::from_parts_unchecked_less_safe(m, &n0, cpu);
+        let m = &Mont::from_parts_unchecked_less_safe(m, &n0, cpu);
 
         let mut acc = out
             .write_fully_with(|out| One::fillR(out, m))
@@ -166,7 +166,7 @@ impl<M> One<M, RRR> {
         m: &modulus::Value<M>,
         cpu: cpu::Features,
     ) -> Self {
-        let m = &Modulus::from_parts_unchecked_less_safe(m, &n0, cpu);
+        let m = &Mont::from_parts_unchecked_less_safe(m, &n0, cpu);
         let value = elem_squared(value, m);
         Self { value, n0 }
     }

src/arithmetic/bigint/private_exponent.rs

@@ -12,7 +12,7 @@
 // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-use super::{limb, Limb, Modulus};
+use super::{limb, Limb, Mont};
 use crate::error;
 use alloc::boxed::Box;
 
@@ -26,7 +26,7 @@ impl PrivateExponent {
     // `p` is the modulus for which the exponent is in the interval [1, `p` - 1).
     pub fn from_be_bytes_padded<M>(
         input: untrusted::Input,
-        p: &Modulus<M>,
+        p: &Mont<M>,
     ) -> Result<Self, error::Unspecified> {
         let mut dP = p
             .alloc_uninit()
@@ -54,7 +54,7 @@ impl PrivateExponent {
     #[cfg(test)]
     pub fn from_be_bytes_for_test_only<M>(
         input: untrusted::Input,
-        p: &Modulus<M>,
+        p: &Mont<M>,
     ) -> Result<Self, error::Unspecified> {
         use super::boxed_limbs::Uninit;
         use crate::{error::LenMismatchError, limb::LIMB_BYTES};

src/arithmetic/exp_vartime.rs

@@ -13,7 +13,7 @@
 // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 use super::{
-    bigint::{elem_mul, elem_squared, Elem, Modulus, Uninit},
+    bigint::{elem_mul, elem_squared, Elem, Mont, Uninit},
     montgomery::R,
 };
 use core::num::NonZeroU64;
@@ -31,7 +31,7 @@ pub(crate) fn elem_exp_vartime<M>(
     out: Uninit<M>,
     base: Elem<M, R>,
     exponent: NonZeroU64,
-    m: &Modulus<M>,
+    m: &Mont<M>,
 ) -> Elem<M, R> {
     // Use what [Knuth] calls the "S-and-X binary method", i.e. variable-time
     // square-and-multiply that scans the exponent from the most significant