use num_traits::{WrappingSub, Zero};
use tc_bigint::{PaddedBigUint, Word};
use tc_zeroize::Zeroize;
use crate::Odd;
use crate::monty::{double_mod_assign, neg_inverse};
use tc_zeroize::Zeroizing;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PaddedMontyParams {
pub(crate) modulus: PaddedBigUint,
pub(crate) inverse: Word,
pub(crate) one: PaddedBigUint,
pub(crate) r2: PaddedBigUint,
}
impl PaddedMontyParams {
pub fn new(modulus: Odd<PaddedBigUint>) -> Self {
let modulus = modulus.into_inner();
let inverse = neg_inverse(modulus.as_limbs()[0].to_word());
let negated = Zeroizing::new(PaddedBigUint::zero().wrapping_sub(&modulus));
let one = &*negated % &modulus;
let mut r2 = one.clone().into_limbs();
for _ in 0..modulus.as_limbs().len() as u32 * Word::BITS {
double_mod_assign(&mut r2, modulus.as_limbs());
}
Self {
modulus,
inverse,
one,
r2: PaddedBigUint::new(r2),
}
}
pub fn modulus(&self) -> &PaddedBigUint {
&self.modulus
}
}
impl Zeroize for PaddedMontyParams {
fn zeroize(&mut self) {
self.modulus.zeroize();
self.inverse.zeroize();
self.one.zeroize();
self.r2.zeroize();
}
}
#[cfg(test)]
mod tests {
use num_traits::Zero;
use tc_bigint::{PaddedBigUint, Word};
use tc_zeroize::Zeroize;
use super::PaddedMontyParams;
use crate::Odd;
const MODULI: [u64; 7] = [
1,
3,
255,
u32::MAX as u64,
i64::MAX as u64,
0xffff_ffff_ffff_ffc5,
u64::MAX,
];
#[test]
fn the_parameters_hold_r_and_r_squared_reduced_by_the_modulus() {
for m in MODULI {
let params = PaddedMontyParams::new(Odd::new(PaddedBigUint::from(m)).unwrap());
let r = (1u128 << 64) % u128::from(m);
let r2 = r * r % u128::from(m);
assert_eq!(params.modulus, PaddedBigUint::from(m), "{m}");
assert_eq!(params.one, PaddedBigUint::from(r as u64), "{m}");
assert_eq!(params.r2, PaddedBigUint::from(r2 as u64), "{m}");
}
}
#[test]
fn the_inverse_negates_the_low_limb_of_the_modulus() {
for m in MODULI {
let params = PaddedMontyParams::new(Odd::new(PaddedBigUint::from(m)).unwrap());
let low = params.modulus.as_limbs()[0].to_word();
assert_eq!(low.wrapping_mul(params.inverse), Word::MAX, "{m}");
}
}
#[test]
fn the_radix_and_every_value_take_the_width_of_the_modulus() {
let wide = (u128::BITS / Word::BITS) as usize;
let params = PaddedMontyParams::new(Odd::new(PaddedBigUint::from(255u128)).unwrap());
assert_eq!(
(params.one.as_limbs().len(), ¶ms.one),
(wide, &PaddedBigUint::from(1u8))
);
assert_eq!(
(params.r2.as_limbs().len(), ¶ms.r2),
(wide, &PaddedBigUint::from(1u8))
);
let modulus = PaddedBigUint::from(i128::MAX as u128);
let params = PaddedMontyParams::new(Odd::new(modulus).unwrap());
assert_eq!(
(params.one, params.r2),
(PaddedBigUint::from(2u8), PaddedBigUint::from(4u8))
);
}
#[test]
fn zeroizing_clears_every_parameter() {
let mut params = PaddedMontyParams::new(Odd::new(PaddedBigUint::from(255u8)).unwrap());
params.zeroize();
assert!(params.modulus.is_zero() && params.one.is_zero() && params.r2.is_zero());
assert_eq!(params.inverse, 0);
}
}