Struct rsa_cortex_m4::numbers::Unsigned

#[repr(C)]pub struct Unsigned<const D: usize, const E: usize> { /* fields omitted */ }

Multi-precision unsigned integer with at most $D + E$ digits (places) – two Limbs.

Workaround type for limitations of const generics on stable; the interesting cases are:

• Short, where $E = 0$, and
• Long, where $D = E$.

The former is used for RSA prime pairs $(P, Q)$, the latter for RSA public keys $N = PQ$.

Mnemonics: D for digits, E for "extra" digits.

Implementations

impl<const D: usize, const E: usize> Unsigned<D, E>

pub fn checked_add(&self, summand: &Self) -> Option<Self>

pub fn wrapping_add_assign(&mut self, summand: &Self)

pub fn wrapping_add(&self, summand: &Self) -> Self

impl<const D: usize, const E: usize> Unsigned<D, E>

pub fn wrapping_neg(&self) -> Self

pub fn checked_sub(&self, subtrahend: &Self) -> Option<Self>

pub fn wrapping_sub_assign<T: Number>(&mut self, subtrahend: &T)

pub fn wrapping_sub(&self, subtrahend: &Self) -> Self

impl<const D: usize, const E: usize> Unsigned<D, E>

pub fn wrapping_mul(&self, factor: &Self) -> Self

impl<const D: usize, const E: usize> Unsigned<D, E>

pub fn wrapping_inv(&self) -> Result<Self>

The wrapping inverse, i.e., the exact inverse w.r.t wrapping multiplication.

Exists if and only if the number is odd.

This uses $\mathcal{O}(\log n)$ loops in Self::BITS, very efficient (!)

Source: Fig. 1 from GCD-Free Algorithms for Computing Modular Inverses (2003)

Note that this source is highly confusing! What they mean to say is to iterate $y \leftarrow y(2 - ey)$ in $\mathbb{Z}/2^{|f|}$, where the output is an inverse of $e$ modulo $2^{2i}$. In other words, the $\text{mod }2^i$ is a typo, and should be $\text{mod }2^{|f|}$.

cf. also Crypto StackExchange.

impl<const D: usize, const E: usize> Unsigned<D, E>

Reduction of unsigned integers

pub fn modulo<'n, const F: usize, const G: usize>(
    &self,
    n: &'n Convenient<F, G>
) -> Modular<'n, F, G>

The associated residue class modulo n.

Note that storage requirements of the residue class are the same as the modulus (+ reference to it), not the original integer.

This uses incomplete reduction ([Self::partially_reduce]) for efficiency.

pub fn modulo_prime<'p, const F: usize, const G: usize>(
    &self,
    p: &'p Prime<F, G>
) -> PrimeModular<'p, F, G>

pub fn reduce<const F: usize, const G: usize>(
    &self,
    n: &Unsigned<F, G>
) -> Unsigned<F, G>

The canonical (completely) reduced representative of the associated residue class modulo $n$.

Cf. Modular.

impl Unsigned<D, 0_usize>

pub const fn from_digit(digit: Digit) -> Self

const implementation

pub const fn digit(&self) -> Digit

impl<const D: usize, const E: usize> Unsigned<D, E>

pub fn to_bytes(&self) -> BigEndian<D, E, 1>

Return buffer that dereferences as big-endian bytes.

impl<const D: usize, const E: usize> Unsigned<D, E>

Trait methods as inherent methods, for convenience.

pub fn from_slice(slice: &[Digit]) -> Self

pub fn try_from_slice(slice: &[Digit]) -> Result<Self>

pub fn leading_digit(&self) -> Option<Digit>

pub fn significant_digits(&self) -> &[Digit]

pub fn to_unsigned<const M: usize, const N: usize>(
    &self
) -> Result<Unsigned<M, N>>

Trait Implementations

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> Add<&'b Unsigned<F, G>> for Modular<'a, D, E>

type Output = Self

The resulting type after applying the + operator.

fn add(self, summand: &'b Unsigned<F, G>) -> Self::Output

Performs the + operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> AddAssign<&'b Unsigned<F, G>> for Modular<'a, D, E>

fn add_assign(&mut self, summand: &'b Unsigned<F, G>)

Performs the += operation.

impl<const D: usize, const E: usize> AsRef<Unsigned<D, E>> for Convenient<D, E>

fn as_ref(&self) -> &Unsigned<D, E>

Performs the conversion.

impl<const D: usize, const E: usize> Clone for Unsigned<D, E>

fn clone(&self) -> Unsigned<D, E>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const D: usize, const E: usize> Debug for Unsigned<D, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

TODO: Do we want debug output to be big-endian bytes (as currently implemented)? Or stick with internal representation?

impl<const D: usize, const E: usize> Default for Unsigned<D, E>

fn default() -> Self

Returns the "default value" for a type.

impl<const D: usize, const E: usize> Deref for Unsigned<D, E>

type Target = [Digit]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const D: usize, const E: usize> DerefMut for Unsigned<D, E>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Div<&'a Unsigned<F, G>> for &'a Unsigned<D, E>

type Output = Unsigned<D, E>

The resulting type after applying the / operator.

fn div(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the / operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Div<&'a Unsigned<F, G>> for Unsigned<D, E>

type Output = Unsigned<D, E>

The resulting type after applying the / operator.

fn div(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the / operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Div<Unsigned<F, G>> for &'a Unsigned<D, E>

type Output = Unsigned<D, E>

The resulting type after applying the / operator.

fn div(self, modulus: Unsigned<F, G>) -> Self::Output

Performs the / operation.

impl<const D: usize, const E: usize, const F: usize, const G: usize> Div<Unsigned<F, G>> for Unsigned<D, E>

type Output = Unsigned<D, E>

The resulting type after applying the / operator.

fn div(self, modulus: Unsigned<F, G>) -> Self::Output

Performs the / operation.

impl<const D: usize, const E: usize> Eq for Unsigned<D, E>

impl<const D: usize, const E: usize> From<[u64; D]> for Unsigned<D, E>

fn from(unsigned: [Digit; D]) -> Self

Performs the conversion.

impl<const D: usize, const E: usize> From<Convenient<D, E>> for Unsigned<D, E>

fn from(convenient: Convenient<D, E>) -> Self

Performs the conversion.

impl<const D: usize, const E: usize> From<Modular<'_, D, E>> for Unsigned<D, E>

fn from(class: Modular<'_, D, E>) -> Self

Performs the conversion.

impl<const D: usize, const E: usize> From<Odd<D, E>> for Unsigned<D, E>

fn from(odd: Odd<D, E>) -> Self

Performs the conversion.

impl<const D: usize, const E: usize> From<u64> for Unsigned<D, E>

Fails for D + E = 0, bound not expressable.

fn from(digit: Digit) -> Self

Performs the conversion.

impl<const D: usize, const E: usize> Mul<&'_ Unsigned<D, E>> for &Unsigned<D, E>

type Output = Product<D, E>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

not product-scanning implementation of multiplication, that overflowed

impl<const D: usize, const E: usize> Number for Unsigned<D, E>

const BITS: usize

The number of bits that fit in this number.

const DIGITS: usize

The number of digits that fit in this number.

fn significant_digits(&self) -> &[Digit]

The significant digits of the number (little-endian).

fn leading_digit(&self) -> Option<Digit>

The last non-zero digit of the number.

fn to_unsigned<const D: usize, const E: usize>(&self) -> Result<Unsigned<D, E>>

Embed in number with D + E digits, if possible.

fn zero() -> Self

fn is_zero(&self) -> bool

fn is_one(&self) -> bool

fn is_digit(&self) -> bool

fn is_odd(&self) -> bool

fn cmp(&self, other: &impl Number) -> Ordering

This is little endian ordering, as opposed to the default ordering on arrays and slices!

fn eq(&self, other: &impl Number) -> bool

fn deref(&self) -> &[Digit]

fn deref_mut(&mut self) -> &mut Self::Target

impl<const D: usize, const E: usize> NumberMut for Unsigned<D, E>

fn from_slice(slice: &[Digit]) -> Self

fn try_from_slice(slice: &[Digit]) -> Result<Self>

fn from_bytes(bytes: &[u8]) -> Self

fn set_zero(&mut self)

fn one() -> Self

fn swap_order(self) -> Self

Swap endianness of digits in Self and, if the platform is little-endian, endianness of bytes within digits.

fn random(rng: impl CryptoRng + RngCore) -> Self

impl<const D: usize, const E: usize> Ord for Unsigned<D, E>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, const D: usize, const E: usize> PartialEq<T> for Unsigned<D, E> where
    T: Number, 

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, const D: usize, const E: usize> PartialOrd<T> for Unsigned<D, E> where
    T: Number, 

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This is little endian ordering, as opposed to the default ordering on arrays and slices!

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Rem<&'a Unsigned<F, G>> for &'a Unsigned<D, E>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Rem<&'a Unsigned<F, G>> for Unsigned<D, E>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize, const L: usize> Rem<&'a Unsigned<F, G>> for &'a Array<D, E, L>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Rem<Unsigned<F, G>> for &'a Unsigned<D, E>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize> Rem<Unsigned<F, G>> for Unsigned<D, E>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<const D: usize, const E: usize> Shl<usize> for &Unsigned<D, E>

type Output = Unsigned<D, E>

The resulting type after applying the << operator.

fn shl(self, bits: usize) -> Self::Output

Performs the << operation.

impl<const D: usize, const E: usize> ShlAssign<usize> for Unsigned<D, E>

fn shl_assign(&mut self, bits: usize)

Performs the <<= operation.

impl<const D: usize, const E: usize> ShrAssign<usize> for Unsigned<D, E>

fn shr_assign(&mut self, bits: usize)

Performs the >>= operation.

impl<const D: usize, const E: usize> StructuralEq for Unsigned<D, E>

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> Sub<&'b Unsigned<F, G>> for Modular<'a, D, E>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, subtrahend: &'b Unsigned<F, G>) -> Self::Output

Performs the - operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> SubAssign<&'b Unsigned<F, G>> for Modular<'a, D, E>

fn sub_assign(&mut self, subtrahend: &'b Unsigned<F, G>)

Performs the -= operation.

impl<'a, const D: usize, const E: usize> TryFrom<&'a Unsigned<D, E>> for &'a Odd<D, E>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(unsigned: &'a Unsigned<D, E>) -> Result<Self>

Enforces odd parity.

impl<const D: usize, const E: usize> TryFrom<Unsigned<D, E>> for Odd<D, E>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(unsigned: Unsigned<D, E>) -> Result<Self>

Enforces odd parity.

impl<const D: usize, const E: usize> TryFrom<Unsigned<D, E>> for Convenient<D, E>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(unsigned: Unsigned<D, E>) -> Result<Self>

Enforces odd parity.

impl<const D: usize, const E: usize> Zeroize for Unsigned<D, E>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not "optimized away" by the compiler.