Struct BoxedUint

Source

pub struct BoxedUint { /* private fields */ }

Available on crate feature alloc only.

Expand description

Fixed-precision heap-allocated big unsigned integer.

Alternative to the stack-allocated Uint but with a fixed precision chosen at runtime instead of compile time.

Unlike many other heap-allocated big integer libraries, this type is not arbitrary precision and will wrap at its fixed-precision rather than automatically growing.

Implementations§

Source §

impl BoxedUint

Source

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

👎Deprecated since 0.7.0: please use carrying_add instead

Computes self + rhs + carry, returning the result along with the new carry.

Source

pub fn carrying_add( &self, rhs: impl AsRef<UintRef>, carry: Limb, ) -> (Self, Limb)

Computes self + rhs + carry, returning the result along with the new carry.

The result is widened to the same width as the widest input.

Source

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

👎Deprecated since 0.7.0: please use carrying_add_assign instead

Computes self + rhs + carry in-place, returning the new carry.

§Panics

if rhs has a larger precision than self.

Source

Perform wrapping addition, discarding overflow.

Source

pub fn wrapping_add_assign(&mut self, rhs: impl AsRef<UintRef>)

Perform wrapping addition of rhs to self, discarding overflow.

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

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

Source

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

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

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

Source

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

Perform checked bitwise OR, returning a CtOption which is_some always

Source §

impl BoxedUint

Source

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

Computes bitwise a ^ b.

Source

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

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

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

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

Source

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

Computes self % rhs using a pre-made reciprocal.

Source

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

Computes self % rhs.

Source

pub fn div_rem<Rhs: ToUnsigned + ?Sized>( &self, rhs: &NonZero<Rhs>, ) -> (Self, Rhs::Unsigned)

Computes self / rhs, returns the quotient, remainder.

Source

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.

Source

pub fn wrapping_div_vartime<Rhs: ToUnsigned + ?Sized>( &self, rhs: &NonZero<Rhs>, ) -> Self

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

Source

pub fn checked_div(&self, rhs: impl AsRef<UintRef>) -> CtOption<Self>

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

Source §

impl BoxedUint

Source

pub fn from_be_slice( bytes: &[u8], bits_precision: u32, ) -> Result<Self, DecodeError>

Create a new BoxedUint from the provided big endian bytes.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

§Errors

Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

Source

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

Create a new BoxedUint from the provided big endian bytes, automatically selecting its precision based on the size of the input.

This method is variable-time with respect to all subsequent operations since it chooses the limb count based on the input size, and is therefore only suitable for public inputs.

When working with secret values, use BoxedUint::from_be_slice.

Source

pub fn from_le_slice( bytes: &[u8], bits_precision: u32, ) -> Result<Self, DecodeError>

Create a new BoxedUint from the provided little endian bytes.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

§Errors

Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

Source

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

Create a new BoxedUint from the provided little endian bytes, automatically selecting its precision based on the size of the input.

This method is variable-time with respect to all subsequent operations since it chooses the limb count based on the input size, and is therefore only suitable for public inputs.

When working with secret values, use BoxedUint::from_le_slice.

Source

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

Serialize this BoxedUint as big-endian.

Source

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

Serialize this BoxedUint as big-endian without leading zeroes.

Source

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

Serialize this BoxedUint as little-endian.

Source

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

Serialize this BoxedUint as little-endian without trailing zeroes.

Source

pub fn from_be_hex(hex: &str, bits_precision: u32) -> CtOption<Self>

Create a new BoxedUint from the provided big endian hex string.

§Panics

if hex string is not the expected size

Source

pub fn from_str_radix_vartime( src: &str, radix: u32, ) -> Result<Self, DecodeError>

Create a new BoxedUint from a big-endian string in a given base.

The string may begin with a + character, and may use underscore characters to separate digits.

§Errors

Returns DecodeError::InvalidDigit if the input value contains non-digit characters or digits outside of the range 0..radix.

§Panics

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

Source

pub fn from_str_radix_with_precision_vartime( src: &str, radix: u32, bits_precision: u32, ) -> Result<Self, DecodeError>

Create a new BoxedUint from a big-endian string in a given base, with a given precision.

The string may begin with a + character, and may use underscore characters to separate digits.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

§Errors

Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
Returns DecodeError::InvalidDigit if the input value contains non-digit characters or digits are outside the range 0..radix.
Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

§Panics

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

Source

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.

Source §

impl BoxedUint

Source

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

👎Deprecated since 0.7.0: please use invert_odd_mod instead

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

Source

pub fn invert_odd_mod(&self, modulus: &Odd<Self>) -> CtOption<Self>

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

Source

pub fn invert_odd_mod_vartime(&self, modulus: &Odd<Self>) -> CtOption<Self>

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

Source

pub fn inv_mod2k_vartime(&self, k: u32) -> (Self, Choice)

👎Deprecated since 0.7.0: please use invert_mod2k_vartime instead

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

Source

pub fn invert_mod2k_vartime(&self, k: u32) -> (Self, Choice)

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

Source

pub fn inv_mod2k(&self, k: u32) -> (Self, Choice)

👎Deprecated since 0.7.0: please use invert_mod2k instead

Computes 1/self mod 2^k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

Source

pub fn invert_mod2k(&self, k: u32) -> (Self, Choice)

Computes 1/self mod 2^k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

Source

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

👎Deprecated since 0.7.0: please use invert_mod instead

Computes the multiplicative 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

Source

pub fn invert_mod(&self, modulus: &NonZero<Self>) -> CtOption<Self>

Computes the multiplicative inverse of self mod modulus

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

pub fn saturating_mul(&self, rhs: impl AsRef<UintRef>) -> Self

Perform saturating multiplication, returning MAX on overflow.

Source

pub fn square(&self) -> Self

👎Deprecated since 0.7.0: please use concatenating_square

Multiply self by itself.

Source

pub fn wrapping_square(&self) -> Self

Multiply self by itself, wrapping to the width of self.

Source

pub fn checked_square(&self) -> CtOption<Self>

Multiply self by itself, wrapping to the width of self. Returns CtOption::None if the result overflowed the precision of self.

Source

pub fn saturating_square(&self) -> Self

Perform saturating squaring, returning MAX on overflow.

Source §

impl BoxedUint

Source

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

Computes self * rhs mod p for non-zero p.

Source

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

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.

Source

pub fn square_mod(&self, p: &NonZero<BoxedUint>) -> Self

Computes self * self mod p.

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

Source §

impl BoxedUint

Source

pub fn checked_pow(&self, exp: impl AsRef<UintRef>) -> CtOption<Self>

Computes self^exp, returning a CtOption which is none in the case of overflow.

Source

pub fn checked_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> CtOption<Self>

Computes self^exp, returning a CtOption which is none in the case of overflow.

NOTE: exp_bits may be leaked in the time pattern.

§Panics

if exp_bits exceeds the capacity of rhs

Source

pub fn checked_pow_vartime(&self, exp: impl AsRef<UintRef>) -> CtOption<Self>

Computes self^exp, returning a CtOption which is none in the case of overflow.

This method is variable time in the exponent exp only.

Source

pub fn saturating_pow(&self, exp: impl AsRef<UintRef>) -> Self

Computes self^exp, returning a Self::MAX in the case of overflow.

Source

pub fn saturating_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> Self

Computes self^exp, returning a Self::MAX in the case of overflow.

NOTE: exp_bits may be leaked in the time pattern.

§Panics

if exp_bits exceeds the capacity of rhs

Source

pub fn saturating_pow_vartime(&self, exp: impl AsRef<UintRef>) -> Self

Computes self^exp, returning a Self::MAX in the case of overflow.

This method is variable time in the exponent exp.

Source

pub fn wrapping_pow(&self, exp: impl AsRef<UintRef>) -> Self

Computes self^exp, discarding overflow.

Source

pub fn wrapping_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> Self

Computes self^exp, discarding overflow.

NOTE: exp_bits may be leaked in the time pattern.

§Panics

if exp_bits exceeds the capacity of rhs

Source

pub fn wrapping_pow_vartime(&self, exp: impl AsRef<UintRef>) -> Self

Computes self^exp, discarding overflow.

This method is variable time in the exponent exp only.

Source §

impl BoxedUint

Source

pub fn pow_mod(&self, rhs: &BoxedUint, p: &Odd<BoxedUint>) -> BoxedUint

Computes self ^ rhs mod p for odd p.

Source §

impl BoxedUint

Source

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

Computes self << shift.

§Panics

if shift >= self.bits_precision().

Source

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

Computes self <<= shift.

§Panics

if shift >= self.bits_precision().

Source

pub fn overflowing_shl(&self, shift: u32) -> CtOption<Self>

Computes self << shift.

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

Source

pub fn overflowing_shl_vartime(&self, shift: u32) -> Option<Self>

Computes self << shift in variable-time.

Returns None if shift >= self.bits_precision(), otherwise the shifted result.

Source

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.

Source

pub fn overflowing_shl_assign_vartime(&mut self, shift: u32) -> bool

Computes self <<= shift in variable-time.

Source §

impl BoxedUint

Source

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

Computes self >> shift.

§Panics

if shift >= self.bits_precision().

Source

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

Computes self >>= shift.

§Panics

if shift >= self.bits_precision().

Source

pub fn overflowing_shr(&self, shift: u32) -> CtOption<Self>

Computes self >> shift.

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

Source

pub fn overflowing_shr_vartime(&self, shift: u32) -> Option<Self>

Computes self >> shift in variable-time.

Returns None if shift >= self.bits_precision(), otherwise the shifted result.

Source

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.

Source

pub fn overflowing_shr_assign_vartime(&mut self, shift: u32) -> bool

Computes self >>= shift in variable-time.

If shift >= self.bits_precision(), shifts self in place and returns false. Otherwise returns true and leaves self unmodified.

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.

Source

pub fn unbounded_shr(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner, producing zero in the case of overflow.

Computes self >> shift in a panic-free manner, reducing shift modulo the type’s width.

pub fn sqrt_vartime(&self) -> Self

👎Deprecated since 0.7.0: please use floor_sqrt_vartime instead

Computes floor(√(self)).

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

Variable time with respect to self.

Source

pub fn floor_sqrt_vartime(&self) -> Self

Computes √(self).

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

Variable time with respect to self.

Source

pub fn wrapping_sqrt(&self) -> Self

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

Source

pub fn wrapping_sqrt_vartime(&self) -> Self

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

Variable time with respect to self.

Source

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

Perform checked sqrt, returning a CtOption which is_some only if the square root is exact.

Source

pub fn checked_sqrt_vartime(&self) -> Option<Self>

Perform checked sqrt, returning an Option which is_some only if the square root is exact.

Variable time with respect to self.

👎Deprecated since 0.7.0: please use borrowing_sub_assign instead

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

§Panics

if rhs has a larger precision than self.

Source

pub fn underflowing_sub(&self, rhs: impl AsRef<UintRef>) -> (Self, Choice)

Computes self - rhs, returning a tuple of the difference along with a Choice which indicates whether an underflow occurred.

If an underflow occurred, then the wrapped value is returned.

Source

pub fn underflowing_sub_assign(&mut self, rhs: impl AsRef<UintRef>) -> Choice

Subtracts rhs from self, returning a Choice which indicates whether an underflow occurred.

If an underflow occurred, then the wrapped value is returned.

Source

pub fn wrapping_sub(&self, rhs: impl AsRef<UintRef>) -> Self

Perform wrapping subtraction, discarding underflow.

Source

pub fn wrapping_sub_assign(&mut self, rhs: impl AsRef<UintRef>)

Perform wrapping subtraction of rhs from self, discarding underflow.

pub fn zero_with_precision(at_least_bits_precision: u32) -> Self

Get the value 0 with the given number of bits of precision.

at_least_bits_precision is rounded up to a multiple of Limb::BITS.

Source

pub fn one() -> Self

Get the value 1, represented as succinctly as possible.

Source

pub fn one_with_precision(at_least_bits_precision: u32) -> Self

Get the value 1 with the given number of bits of precision.

at_least_bits_precision is rounded up to a multiple of Limb::BITS.

Source

pub fn is_zero(&self) -> Choice

Is this BoxedUint equal to zero?

Source

pub fn is_nonzero(&self) -> Choice

Is this BoxedUint NOT equal to zero?

Source

pub fn is_one(&self) -> Choice

Is this BoxedUint equal to one?

Source

pub fn max(at_least_bits_precision: u32) -> Self

Get the maximum value for a BoxedUint created with at_least_bits_precision precision bits requested.

👎Deprecated since 0.7.0: please use as_mut_words instead

Borrow the inner limbs as a mutable slice of Words.

Source

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

Borrow the limbs of this BoxedUint.

Source

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

Borrow the limbs of this BoxedUint mutably.

Source

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

👎Deprecated since 0.7.0: please use as_mut_limbs instead

👎Deprecated since 0.7.0: please use resize instead

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

§Panics

if at_least_bits_precision is smaller than the current precision.

Source

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

👎Deprecated since 0.7.0: please use resize instead

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

§Panics

if at_least_bits_precision is larger than the current precision.

impl BitOrAssign<&BoxedUint> for BoxedUint

Source §

fn bitor_assign(&mut self, other: &Self)

Performs the |= operation. Read more

Source §

Source §

impl<Rhs: AsRef<UintRef>> ConcatenatingMul<Rhs> for BoxedUint

Source §

type Output = BoxedUint

Output of the widening multiplication.

Source §

fn concatenating_mul(&self, rhs: Rhs) -> Self

Perform widening multiplication.

Source §

Determine if self is NOT equal to other in constant-time.

Source §

impl CtEqSlice for BoxedUint

Source §

fn ct_eq_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is equal to b in constant-time.

Conditionally negate self in-place, replacing it with -self if choice is Choice::TRUE.

Source §

impl CtSelect for BoxedUint

Source §

fn ct_select(&self, other: &Self, choice: Choice) -> Self

Select between self and other based on choice, returning a copy of the value. Read more

Source §

fn ct_swap(&mut self, other: &mut Self, choice: Choice)

Conditionally swap self and other if choice is Choice::TRUE.

Source §

impl Debug for BoxedUint

Source §

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

Formats the value using the given formatter. Read more

Source §

impl<'a> DecodeValue<'a> for BoxedUint

Available on crate features der and hybrid-array only.

Source §

type Error = Error

Type returned in the event of a decoding error.

Source §

fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>

Attempt to decode this value using the provided Reader. Read more

Source §

impl Default for BoxedUint

Source §

fn default() -> Self

Returns the “default value” for a type. Read more

Source §

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

Available on crate feature serde only.

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

Source §

impl DivVartime for BoxedUint

Source §

fn div_vartime(&self, rhs: &NonZero<BoxedUint>) -> Self

Source §

fn floor_sqrt(&self) -> Self

Computes floor(sqrt(self)).

Source §

type Output = BoxedUint

Output type.

Performs the * operation. Read more

Source §

impl<Rhs: AsRef<UintRef>> Mul<Rhs> for BoxedUint

Source §

type Output = BoxedUint

The resulting type after applying the * operator.

fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision. Read more

Source §

fn resize(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision panicking if the bit size of self is larger than at_least_bits_precision. Read more

Source §

impl Resize for BoxedUint

Source §

type Output = BoxedUint

The result of the resizing.

Source §

fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision without checking if the bit size of self is larger than at_least_bits_precision. Read more

Source §

fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision. Read more

Source §