Add Resize trait instead of BoxedUint::shorten()/widen()

Author: fjarri

src/modular/boxed_monty_form.rs

@@ -11,7 +11,7 @@ mod sub;
 use super::{ConstMontyParams, Retrieve, div_by_2};
 use mul::BoxedMontyMultiplier;
 
-use crate::{BoxedUint, Limb, Monty, Odd, Word};
+use crate::{BoxedUint, Limb, Monty, Odd, Resize, Word};
 use alloc::sync::Arc;
 use subtle::Choice;
 

src/modular/safegcd/boxed.rs

@@ -4,7 +4,7 @@
 //! See parent module for more information.
 
 use super::{Matrix, inv_mod2_62, iterations, jump};
-use crate::{BoxedUint, Inverter, Limb, Odd, Word};
+use crate::{BoxedUint, Inverter, Limb, Odd, Resize, Word};
 use alloc::boxed::Box;
 use core::{
     cmp::max,

src/traits.rs

@@ -851,6 +851,43 @@ pub trait ShrVartime: Sized {
     fn wrapping_shr_vartime(&self, shift: u32) -> Self;
 }
 
+/// Methods for resizing the allocated storage.
+pub trait Resize: Sized {
+    /// The result of the resizing.
+    type Output;
+
+    /// Resizes to the minimum storage that fits `at_least_bits_precision`
+    /// without checking if the discarded limbs (if any) are non-zero.
+    fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output;
+
+    /// Resizes to the minimum storage that fits `at_least_bits_precision`
+    /// returning `None` if resizing would result in a truncation of non-zero limbs.
+    fn try_resize(self, at_least_bits_precision: u32) -> Option<Self::Output>;
+
+    /// Resizes to the minimum storage that fits `at_least_bits_precision`
+    /// panicking if resizing would result in a truncation of non-zero limbs.
+    fn resize(self, at_least_bits_precision: u32) -> Self::Output {
+        self.try_resize(at_least_bits_precision)
+            .unwrap_or_else(|| panic!("Cannot resize without truncation"))
+    }
+
+    /// Widens this type's precision to the given number of bits.
+    ///
+    /// Panics if `at_least_bits_precision` is smaller than the current precision.
+    fn widen(self, at_least_bits_precision: u32) -> Self::Output {
+        //assert!(at_least_bits_precision >= self.bits_precision());
+        self.resize_unchecked(at_least_bits_precision)
+    }
+
+    /// Shortens this type's precision to the given number of bits.
+    ///
+    /// Panics if `at_least_bits_precision` is larger than the current precision.
+    fn shorten(self, at_least_bits_precision: u32) -> Self::Output {
+        //assert!(at_least_bits_precision <= self.bits_precision());
+        self.resize_unchecked(at_least_bits_precision)
+    }
+}
+
 /// A representation of an integer optimized for the performance of modular operations.
 pub trait Monty:
     'static

src/uint/boxed.rs

@@ -28,7 +28,7 @@ mod sub_mod;
 #[cfg(feature = "rand_core")]
 mod rand;
 
-use crate::{Integer, Limb, NonZero, Odd, UintRef, Word, Zero, modular::BoxedMontyForm};
+use crate::{Integer, Limb, NonZero, Odd, Resize, UintRef, Word, Zero, modular::BoxedMontyForm};
 use alloc::{boxed::Box, vec, vec::Vec};
 use core::fmt;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
@@ -195,30 +195,6 @@ impl BoxedUint {
         CtOption::new(Odd(self.clone()), is_odd)
     }
 
-    /// Widen this type's precision to the given number of bits.
-    ///
-    /// Panics if `at_least_bits_precision` is smaller than the current precision.
-    #[must_use]
-    pub fn widen(&self, at_least_bits_precision: u32) -> BoxedUint {
-        assert!(at_least_bits_precision >= self.bits_precision());
-
-        let mut ret = BoxedUint::zero_with_precision(at_least_bits_precision);
-        ret.limbs[..self.nlimbs()].copy_from_slice(&self.limbs);
-        ret
-    }
-
-    /// Shortens this type's precision to the given number of bits.
-    ///
-    /// Panics if `at_least_bits_precision` is larger than the current precision.
-    #[must_use]
-    pub fn shorten(&self, at_least_bits_precision: u32) -> BoxedUint {
-        assert!(at_least_bits_precision <= self.bits_precision());
-        let mut ret = BoxedUint::zero_with_precision(at_least_bits_precision);
-        let nlimbs = ret.nlimbs();
-        ret.limbs.copy_from_slice(&self.limbs[..nlimbs]);
-        ret
-    }
-
     /// Perform a carry chain-like operation over the limbs of the inputs,
     /// constructing a result from the returned limbs and carry which is
     /// widened to the same width as the widest input.
@@ -271,14 +247,86 @@ impl BoxedUint {
             limbs[i] = Limb::conditional_select(&limbs[i], &Limb::ZERO, choice);
         }
     }
+
+    fn truncation_needed(&self, at_least_bits_precision: u32) -> bool {
+        let new_len = Self::limbs_for_precision(at_least_bits_precision);
+        // TODO: technically we just need to know the number of leading zero limbs,
+        // so this can be done faster. Is the difference worth it?
+        new_len < self.limbs.len() && self.bits() > at_least_bits_precision
+    }
 }
 
-impl NonZero<BoxedUint> {
-    /// Widen this type's precision to the given number of bits.
-    ///
-    /// See [`BoxedUint::widen`] for more information, including panic conditions.
-    pub fn widen(&self, bits_precision: u32) -> Self {
-        NonZero(self.0.widen(bits_precision))
+impl Resize for BoxedUint {
+    type Output = BoxedUint;
+
+    fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output {
+        let new_len = Self::limbs_for_precision(at_least_bits_precision);
+        if new_len == self.limbs.len() {
+            self
+        } else {
+            let mut limbs = self.limbs.into_vec();
+            limbs.resize(new_len, Limb::ZERO);
+            Self::from(limbs)
+        }
+    }
+
+    fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint> {
+        if self.truncation_needed(at_least_bits_precision) {
+            None
+        } else {
+            Some(self.resize_unchecked(at_least_bits_precision))
+        }
+    }
+}
+
+impl Resize for &BoxedUint {
+    type Output = BoxedUint;
+
+    fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output {
+        let mut ret = BoxedUint::zero_with_precision(at_least_bits_precision);
+        let num_limbs_to_copy = core::cmp::min(ret.limbs.len(), self.limbs.len());
+        ret.limbs[..num_limbs_to_copy].copy_from_slice(&self.limbs[..num_limbs_to_copy]);
+        ret
+    }
+
+    fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint> {
+        if self.truncation_needed(at_least_bits_precision) {
+            None
+        } else {
+            Some(self.resize_unchecked(at_least_bits_precision))
+        }
+    }
+}
+
+impl Resize for NonZero<BoxedUint> {
+    type Output = Self;
+
+    fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output {
+        NonZero(self.0.widen(at_least_bits_precision))
+    }
+
+    fn try_resize(self, at_least_bits_precision: u32) -> Option<Self::Output> {
+        if self.0.truncation_needed(at_least_bits_precision) {
+            None
+        } else {
+            Some(self.resize_unchecked(at_least_bits_precision))
+        }
+    }
+}
+
+impl Resize for &NonZero<BoxedUint> {
+    type Output = NonZero<BoxedUint>;
+
+    fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output {
+        NonZero((&self.0).widen(at_least_bits_precision))
+    }
+
+    fn try_resize(self, at_least_bits_precision: u32) -> Option<Self::Output> {
+        if self.0.truncation_needed(at_least_bits_precision) {
+            None
+        } else {
+            Some(self.resize_unchecked(at_least_bits_precision))
+        }
     }
 }
 

src/uint/boxed/add.rs

@@ -231,6 +231,7 @@ impl AddAssign<u128> for BoxedUint {
 #[allow(clippy::unwrap_used)]
 mod tests {
     use super::{BoxedUint, CheckedAdd, Limb};
+    use crate::Resize;
 
     #[test]
     fn adc_no_carry() {

src/uint/boxed/gcd.rs

@@ -46,7 +46,7 @@ impl Gcd<BoxedUint> for Odd<BoxedUint> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{BoxedUint, Gcd};
+    use crate::{BoxedUint, Gcd, Resize};
 
     #[test]
     fn gcd_relatively_prime() {

src/uint/boxed/mul.rs

@@ -1,7 +1,7 @@
 //! [`BoxedUint`] multiplication operations.
 
 use crate::{
-    BoxedUint, CheckedMul, Limb, WideningMul, Wrapping, WrappingMul, Zero,
+    BoxedUint, CheckedMul, Limb, Resize, WideningMul, Wrapping, WrappingMul, Zero,
     uint::mul::{
         karatsuba::{KARATSUBA_MIN_STARTING_LIMBS, karatsuba_mul_limbs, karatsuba_square_limbs},
         mul_limbs, square_limbs,

src/uint/boxed/sub.rs

@@ -236,6 +236,7 @@ impl SubAssign<u128> for BoxedUint {
 #[allow(clippy::unwrap_used)]
 mod tests {
     use super::{BoxedUint, CheckedSub, Limb};
+    use crate::Resize;
 
     #[test]
     fn sbb_no_borrow() {

tests/boxed_monty_form.rs

@@ -6,7 +6,7 @@ mod common;
 
 use common::to_biguint;
 use crypto_bigint::{
-    BoxedUint, Integer, Inverter, Limb, Odd, PrecomputeInverter,
+    BoxedUint, Integer, Inverter, Limb, Odd, PrecomputeInverter, Resize,
     modular::{BoxedMontyForm, BoxedMontyParams},
 };
 use num_bigint::BigUint;

tests/boxed_uint.rs

@@ -6,7 +6,7 @@ mod common;
 
 use common::to_biguint;
 use core::cmp::Ordering;
-use crypto_bigint::{BitOps, BoxedUint, CheckedAdd, Gcd, Integer, Limb, NonZero};
+use crypto_bigint::{BitOps, BoxedUint, CheckedAdd, Gcd, Integer, Limb, NonZero, Resize};
 use num_bigint::BigUint;
 use num_integer::Integer as _;
 use num_modular::ModularUnaryOps;

tests/safegcd.rs

@@ -10,7 +10,7 @@ use num_traits::One;
 use proptest::prelude::*;
 
 #[cfg(feature = "alloc")]
-use crypto_bigint::BoxedUint;
+use crypto_bigint::{BoxedUint, Resize};
 
 /// Example prime number (NIST P-256 curve order)
 const P: Odd<U256> =