arithmetic: Simplify construction of IntoMont.

Don't require the caller to construct a `Value` first.

Author: briansmith

src/arithmetic/bigint/exp.rs

@@ -398,8 +398,7 @@ mod tests {
                     modulus::ValidatedInput::try_from_be_bytes(untrusted::Input::from(&m_input))
                         .unwrap();
                 let im = m_input
-                    .build_value::<M>()
-                    .into_into_mont(cpu_features)
+                    .build_into_mont::<M>(cpu_features)
                     .intoRRR(cpu_features);
                 let m = im.modulus(cpu_features);
                 let expected_result = consume_elem(test_case, "ModExp", &m);

src/arithmetic/bigint/modulus/mont.rs

@@ -14,7 +14,7 @@
 
 use super::super::{
     super::montgomery::{Unencoded, RR, RRR},
-    modulus::value::Value,
+    modulus::{value::Value, ValidatedInput},
     Elem, One, PublicModulus, Uninit, N0,
 };
 use crate::{
@@ -45,8 +45,14 @@ impl<M: PublicModulus, E> Clone for IntoMont<M, E> {
     }
 }
 
+impl ValidatedInput<'_> {
+    pub(crate) fn build_into_mont<M>(&self, cpu: cpu::Features) -> IntoMont<M, RR> {
+        self.build_value().into_into_mont(cpu)
+    }
+}
+
 impl<M> Value<M> {
-    pub fn into_into_mont(self, cpu: cpu::Features) -> IntoMont<M, RR> {
+    pub(super) fn into_into_mont(self, cpu: cpu::Features) -> IntoMont<M, RR> {
         let out = self.alloc_uninit();
         let one =
             One::newRR(out, &self, cpu).unwrap_or_else(|LenMismatchError { .. }| unreachable!());

src/arithmetic/bigint/modulus/testutil.rs

@@ -11,6 +11,5 @@ pub fn consume_modulus<M>(
     ValidatedInput::try_from_be_bytes(value.as_slice().into())
         .map_err(error::erase::<KeyRejected>)
         .unwrap()
-        .build_value()
-        .into_into_mont(cpu::features())
+        .build_into_mont(cpu::features())
 }

src/arithmetic/bigint/modulus/value.rs

@@ -112,7 +112,7 @@ impl<'a> ValidatedInput<'a> {
         self.input
     }
 
-    pub(crate) fn build_value<M>(&self) -> Value<M> {
+    pub(super) fn build_value<M>(&self) -> Value<M> {
         let limbs = Uninit::new_less_safe(self.num_limbs)
             .write_from_be_bytes_padded(self.input)
             .unwrap_or_else(|LenMismatchError { .. }| unreachable!());

src/rsa/keypair.rs

@@ -462,7 +462,7 @@ impl ValidatedPrivatePrimeInput<'_> {
 
         // Steps 5.e and 5.f are omitted as explained above.
         PrivatePrime {
-            modulus: self.inner.build_value().into_into_mont(cpu_features),
+            modulus: self.inner.build_into_mont(cpu_features),
         }
     }
 }

src/rsa/public_modulus.rs

@@ -69,8 +69,9 @@ impl<'a> ValidatedInput<'a> {
     }
 
     pub(super) fn build(&self, cpu_features: cpu::Features) -> PublicModulus {
-        let value = self.input.build_value().into_into_mont(cpu_features);
-        PublicModulus { value }
+        PublicModulus {
+            value: self.input.build_into_mont(cpu_features),
+        }
     }
 }