Struct BoxedUint 

pub struct BoxedUint(/* private fields */);

A wrapper around crypto_bigint::BoxedUint that implements Serialize and Deserialize.

Methods from Deref<Target = BoxedUint>

pub fn adc(&self, rhs: &BoxedUint, carry: Limb) -> (BoxedUint, Limb)

Computes a + b + carry, returning the result along with the new carry.

pub fn adc_assign(&mut self, rhs: impl AsRef<[Limb]>, carry: Limb) -> Limb

Computes a + b + carry in-place, returning the new carry.

Panics if rhs has a larger precision than self.

pub fn wrapping_add(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping addition, discarding overflow.

pub fn add_mod(&self, rhs: &BoxedUint, p: &BoxedUint) -> BoxedUint

Computes self + rhs mod p.

Assumes self + rhs as unbounded integer is < 2p.

pub fn double_mod(&self, p: &BoxedUint) -> BoxedUint

Computes self + self mod p.

Assumes self as unbounded integer is < p.

pub fn bitand(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a & b.

pub fn bitand_limb(&self, rhs: Limb) -> BoxedUint

Perform bitwise AND between self and the given Limb, performing the AND operation on every limb of self.

pub fn wrapping_and(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping bitwise AND.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_and(&self, rhs: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise AND, returning a CtOption which is_some always

pub fn not(&self) -> BoxedUint

Computes bitwise !a.

pub fn bitor(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a & b.

pub fn wrapping_or(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping bitwise OR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_or(&self, rhs: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise OR, returning a CtOption which is_some always

pub fn bitxor(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a ^ b.

pub fn wrapping_xor(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping bitwise `XOR``.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_xor(&self, rhs: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise XOR, returning a CtOption which is_some always

pub fn bit(&self, index: u32) -> Choice

Get the value of the bit at position index, as a truthy or falsy Choice. Returns the falsy value for indices out of range.

pub fn bit_vartime(&self, index: u32) -> bool

Returns true if the bit at position index is set, false otherwise.

Remarks

This operation is variable time with respect to index only.

pub fn bits(&self) -> u32

Calculate the number of bits needed to represent this number, i.e. the index of the highest set bit.

Use BoxedUint::bits_precision to get the total capacity of this integer.

pub fn bits_vartime(&self) -> u32

Calculate the number of bits needed to represent this number in variable-time with respect to self.

pub fn leading_zeros(&self) -> u32

Calculate the number of leading zeros in the binary representation of this number.

pub fn bits_precision(&self) -> u32

Get the precision of this BoxedUint in bits.

pub fn trailing_zeros(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number.

pub fn trailing_ones(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number.

pub fn trailing_zeros_vartime(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number in variable-time with respect to self.

pub fn trailing_ones_vartime(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number, variable time in self.

pub fn cmp_vartime(&self, rhs: &BoxedUint) -> Ordering

Returns the Ordering between self and rhs in variable time.

pub fn div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal, ) -> (BoxedUint, Limb)

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

pub fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (BoxedUint, Limb)

Computes self / rhs, returns the quotient (q) and remainder (r).

pub fn rem_limb_with_reciprocal(&self, reciprocal: &Reciprocal) -> Limb

Computes self % rhs using a pre-made reciprocal.

pub fn rem_limb(&self, rhs: NonZero<Limb>) -> Limb

Computes self % rhs.

pub fn div_rem(&self, rhs: &NonZero<BoxedUint>) -> (BoxedUint, BoxedUint)

Computes self / rhs, returns the quotient, remainder.

pub fn rem(&self, rhs: &NonZero<BoxedUint>) -> BoxedUint

Computes self % rhs, returns the remainder.

pub fn div_rem_vartime( &self, rhs: &NonZero<BoxedUint>, ) -> (BoxedUint, BoxedUint)

Computes self / rhs, returns the quotient, remainder.

Variable-time with respect to rhs

pub fn rem_vartime(&self, rhs: &NonZero<BoxedUint>) -> BoxedUint

Computes self % rhs, returns the remainder.

Variable-time with respect to rhs.

pub fn wrapping_div(&self, rhs: &NonZero<BoxedUint>) -> BoxedUint

Wrapped division is just normal division i.e. self / rhs There’s no way wrapping could ever happen.

This function exists, so that all operations are accounted for in the wrapping operations.

Panics if rhs == 0.

pub fn wrapping_div_vartime(&self, rhs: &NonZero<BoxedUint>) -> BoxedUint

Wrapped division is just normal division i.e. self / rhs

There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations

pub fn checked_div(&self, rhs: &BoxedUint) -> CtOption<BoxedUint>

Perform checked division, returning a CtOption which is_some only if the rhs != 0

pub fn to_be_bytes(&self) -> Box<[u8]>

Serialize this BoxedUint as big-endian.

pub fn to_le_bytes(&self) -> Box<[u8]>

Serialize this BoxedUint as little-endian.

pub fn to_string_radix_vartime(&self, radix: u32) -> String

Format a BoxedUint as a string in a given base.

Panics if radix is not in the range from 2 to 36.

pub fn inv_odd_mod(&self, modulus: &Odd<BoxedUint>) -> CtOption<BoxedUint>

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

pub fn inv_mod(&self, modulus: &BoxedUint) -> CtOption<BoxedUint>

Computes the multiplicaitve inverse of self mod modulus

self and modulus must have the same number of limbs, or the function will panic

TODO: maybe some better documentation is needed

pub fn mul(&self, rhs: &BoxedUint) -> BoxedUint

Multiply self by rhs.

Returns a widened output with a limb count equal to the sums of the input limb counts.

pub fn wrapping_mul(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping multiplication, wrapping to the width of self.

pub fn square(&self) -> BoxedUint

Multiply self by itself.

pub fn mul_mod(&self, rhs: &BoxedUint, p: &BoxedUint) -> BoxedUint

Computes self * rhs mod p for odd p.

Panics if p is even.

pub fn mul_mod_special(&self, rhs: &BoxedUint, c: Limb) -> BoxedUint

Computes self * rhs mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

For the modulus reduction, this function implements Algorithm 14.47 from the “Handbook of Applied Cryptography”, by A. Menezes, P. van Oorschot, and S. Vanstone, CRC Press, 1996.

pub fn wrapping_neg(&self) -> BoxedUint

Perform wrapping negation.

pub fn neg_mod(&self, p: &BoxedUint) -> BoxedUint

Computes -a mod p. Assumes self is in [0, p).

pub fn neg_mod_special(&self, c: Limb) -> BoxedUint

Computes -a mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

pub fn shl(&self, shift: u32) -> BoxedUint

Computes self << shift.

Panics if shift >= Self::BITS.

pub fn shl_assign(&mut self, shift: u32)

Computes self <<= shift.

Panics if shift >= Self::BITS.

pub fn overflowing_shl(&self, shift: u32) -> (BoxedUint, Choice)

Computes self << shift.

Returns a zero and a truthy Choice if shift >= self.bits_precision(), or the result and a falsy Choice otherwise.

pub fn overflowing_shl_assign(&mut self, shift: u32) -> Choice

Computes self <<= shift.

Returns a truthy Choice if shift >= self.bits_precision() or a falsy Choice otherwise.

pub fn wrapping_shl(&self, shift: u32) -> BoxedUint

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn wrapping_shl_vartime(&self, shift: u32) -> BoxedUint

Computes self << shift in variable-time in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn shl_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self << shift. Returns None if shift >= self.bits_precision().

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub fn shr(&self, shift: u32) -> BoxedUint

Computes self >> shift.

Panics if shift >= Self::BITS.

pub fn shr_assign(&mut self, shift: u32)

Computes self >>= shift.

Panics if shift >= Self::BITS.

pub fn overflowing_shr(&self, shift: u32) -> (BoxedUint, Choice)

Computes self >> shift.

Returns a zero and a truthy Choice if shift >= self.bits_precision(), or the result and a falsy Choice otherwise.

pub fn overflowing_shr_assign(&mut self, shift: u32) -> Choice

Computes self >>= shift.

Returns a truthy Choice if shift >= self.bits_precision() or a falsy Choice otherwise.

pub fn wrapping_shr(&self, shift: u32) -> BoxedUint

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn wrapping_shr_vartime(&self, shift: u32) -> BoxedUint

Computes self >> shift in variable-time in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn shr_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self >> shift. Returns None if shift >= self.bits_precision().

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub fn sqrt(&self) -> BoxedUint

Computes √(self) in constant time.

Callers can check if self is a square by squaring the result

pub fn sqrt_vartime(&self) -> BoxedUint

Computes √(self)

Callers can check if self is a square by squaring the result

pub fn wrapping_sqrt(&self) -> BoxedUint

Wrapped sqrt is just normal √(self) There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations.

pub fn wrapping_sqrt_vartime(&self) -> BoxedUint

Wrapped sqrt is just normal √(self) There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations.

pub fn checked_sqrt(&self) -> CtOption<BoxedUint>

Perform checked sqrt, returning a CtOption which is_some only if the √(self)² == self

pub fn checked_sqrt_vartime(&self) -> CtOption<BoxedUint>

Perform checked sqrt, returning a CtOption which is_some only if the √(self)² == self

pub fn sbb(&self, rhs: &BoxedUint, borrow: Limb) -> (BoxedUint, Limb)

Computes a - (b + borrow), returning the result along with the new borrow.

pub fn sbb_assign(&mut self, rhs: impl AsRef<[Limb]>, borrow: Limb) -> Limb

Computes a - (b + borrow) in-place, returning the new borrow.

Panics if rhs has a larger precision than self.

pub fn wrapping_sub(&self, rhs: &BoxedUint) -> BoxedUint

Perform wrapping subtraction, discarding overflow.

pub fn sub_mod(&self, rhs: &BoxedUint, p: &BoxedUint) -> BoxedUint

Computes self - rhs mod p.

Assumes self - rhs as unbounded signed integer is in [-p, p).

pub fn sub_mod_special(&self, rhs: &BoxedUint, c: Limb) -> BoxedUint

Computes self - rhs mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self - rhs as unbounded signed integer is in [-p, p).

pub fn is_zero(&self) -> Choice

Is this BoxedUint equal to zero?

pub fn is_nonzero(&self) -> Choice

Is this BoxedUint NOT equal to zero?

pub fn is_one(&self) -> Choice

Is this BoxedUint equal to one?

pub fn to_words(&self) -> Box<[u64]>

Create a boxed slice of Words (i.e. word-sized unsigned integers) from a BoxedUint.

pub fn as_words(&self) -> &[u64]

Borrow the inner limbs as a slice of Words.

pub fn as_words_mut(&mut self) -> &mut [u64]

Borrow the inner limbs as a mutable slice of Words.

pub fn as_limbs(&self) -> &[Limb]

Borrow the limbs of this BoxedUint.

pub fn as_limbs_mut(&mut self) -> &mut [Limb]

Borrow the limbs of this BoxedUint mutably.

pub fn to_limbs(&self) -> Box<[Limb]>

Convert this BoxedUint into its inner limbs.

pub fn nlimbs(&self) -> usize

Get the number of limbs in this BoxedUint.

pub fn to_odd(&self) -> CtOption<Odd<BoxedUint>>

Convert into an Odd.

pub fn widen(&self, at_least_bits_precision: u32) -> BoxedUint

Widen this type’s precision to the given number of bits.

Panics if at_least_bits_precision is smaller than the current precision.

pub fn shorten(&self, at_least_bits_precision: u32) -> BoxedUint

Shortens this type’s precision to the given number of bits.

Panics if at_least_bits_precision is larger than the current precision.

Trait Implementations

impl AsMut<BoxedUint> for BoxedUint

fn as_mut(&mut self) -> &mut BoxedUint

Converts this type into a mutable reference of the (usually inferred) input type.

impl<__AsT: ?Sized> AsRef<__AsT> for BoxedUint

where BoxedUint: AsRef<__AsT>,

fn as_ref(&self) -> &__AsT

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for BoxedUint

fn clone(&self) -> BoxedUint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoxedUint

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

Formats the value using the given formatter.

impl Deref for BoxedUint

type Target = BoxedUint

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for BoxedUint

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

Mutably dereferences the value.

impl<'de> Deserialize<'de> for BoxedUint

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__FromT0> From<__FromT0> for BoxedUint

where BoxedUint: From<__FromT0>,

fn from(value: __FromT0) -> Self

Converts to this type from the input type.

impl Hash for BoxedUint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BoxedUint

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BoxedUint

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BoxedUint

impl StructuralPartialEq for BoxedUint