Struct rsa_cortex_m4::numbers::Prime

#[repr(transparent)]pub struct Prime<const D: usize, const E: usize>(_);

Prime number (passing primality tests); convenient by definition.

Implementations

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

pub fn as_convenient(&self) -> &Convenient<D, E>

pub fn into_convenient(self) -> Convenient<D, E>

pub fn as_odd(&self) -> &Odd<D, E>

pub fn into_odd(self) -> Odd<D, E>

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

pub fn into_unsigned(self) -> Unsigned<D, E>

Methods from Deref<Target = Convenient<D, E>>

pub fn as_odd(&self) -> &Odd<D, E>

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

Methods from Deref<Target = 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

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

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

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.

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.

pub const fn digit(&self) -> Digit

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

Return buffer that dereferences as big-endian bytes.

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<const D: usize, const E: usize> AsRef<Convenient<D, E>> for Prime<D, E>

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

Performs the conversion.

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

fn clone(&self) -> Prime<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 Prime<D, E>

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

Formats the value using the given formatter.

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

type Target = Convenient<D, E>

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

impl<const D: usize, const E: usize> RefCast for Prime<D, E>

type From = Convenient<D, E>

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self