Struct openssl::bn::BigNumRef

pub struct BigNumRef(_);

Reference to a BigNum

Methods

impl BigNumRef

fn clear(&mut self)

Erases the memory used by this BigNum, resetting its value to 0.

This can be used to destroy sensitive data such as keys when they are no longer needed.

OpenSSL documentation at BN_clear

fn add_word(&mut self, w: u32) -> Result<(), ErrorStack>

Adds a u32 to self.

OpenSSL documentation at BN_add_word

fn sub_word(&mut self, w: u32) -> Result<(), ErrorStack>

Subtracts a u32 from self.

OpenSSL documentation at BN_sub_word

fn mul_word(&mut self, w: u32) -> Result<(), ErrorStack>

Multiplies a u32 by self.

OpenSSL documentation at BN_mul_word

fn div_word(&mut self, w: u32) -> Result<u64, ErrorStack>

Divides self by a u32, returning the remainder.

OpenSSL documentation at BN_div_word

fn mod_word(&self, w: u32) -> Result<u64, ErrorStack>

Returns the result of self modulo w.

OpenSSL documentation at BN_mod_word

fn rand_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack>

Places a cryptographically-secure pseudo-random nonnegative number less than self in rnd.

OpenSSL documentation at BN_rand_range

fn pseudo_rand_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack>

The cryptographically weak counterpart to rand_in_range.

OpenSSL documentation at BN_pseudo_rand_range

fn set_bit(&mut self, n: i32) -> Result<(), ErrorStack>

Sets bit n. Equivalent to self |= (1 << n).

When setting a bit outside of self, it is expanded.

OpenSSL documentation at BN_set_bit

fn clear_bit(&mut self, n: i32) -> Result<(), ErrorStack>

Clears bit n, setting it to 0. Equivalent to self &= ~(1 << n).

When clearing a bit outside of self, an error is returned.

OpenSSL documentation at BN_clear_bit

fn is_bit_set(&self, n: i32) -> bool

Returns true if the nth bit of self is set to 1, false otherwise.

OpenSSL documentation at BN_is_bit_set

fn mask_bits(&mut self, n: i32) -> Result<(), ErrorStack>

Truncates self to the lowest n bits.

An error occurs if self is already shorter than n bits.

OpenSSL documentation at BN_mask_bits

fn lshift1(&mut self, a: &BigNumRef) -> Result<(), ErrorStack>

Places a << 1 in self. Equivalent to self * 2.

OpenSSL documentation at BN_lshift1

fn rshift1(&mut self, a: &BigNumRef) -> Result<(), ErrorStack>

Places a >> 1 in self. Equivalent to self / 2.

OpenSSL documentation at BN_rshift1

fn checked_add(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef
) -> Result<(), ErrorStack>

Places a + b in self. core::ops::Add is also implemented for BigNumRef.

OpenSSL documentation at BN_add

fn checked_sub(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef
) -> Result<(), ErrorStack>

Places a - b in self. core::ops::Sub is also implemented for BigNumRef.

OpenSSL documentation at BN_sub

fn lshift(&mut self, a: &BigNumRef, n: i32) -> Result<(), ErrorStack>

Places a << n in self. Equivalent to a * 2 ^ n.

OpenSSL documentation at BN_lshift

fn rshift(&mut self, a: &BigNumRef, n: i32) -> Result<(), ErrorStack>

Places a >> n in self. Equivalent to a / 2 ^ n.

OpenSSL documentation at BN_rshift

fn to_owned(&self) -> Result<BigNum, ErrorStack>

Creates a new BigNum with the same value.

OpenSSL documentation at BN_dup

fn set_negative(&mut self, negative: bool)

Sets the sign of self. Pass true to set self to a negative. False sets self positive.

fn ucmp(&self, oth: &BigNumRef) -> Ordering

Compare the absolute values of self and oth.

OpenSSL documentation at BN_ucmp

Examples

let s = -BigNum::from_u32(8).unwrap();
let o = BigNum::from_u32(8).unwrap();

assert_eq!(s.ucmp(&o), Ordering::Equal);

fn is_negative(&self) -> bool

Returns true if self is negative.

fn num_bits(&self) -> i32

Returns the number of significant bits in self.

OpenSSL documentation at BN_num_bits

fn num_bytes(&self) -> i32

Returns the size of self in bytes. Implemented natively.

fn rand(
    &mut self,
    bits: i32,
    msb: MsbOption,
    odd: bool
) -> Result<(), ErrorStack>

Generates a cryptographically strong pseudo-random BigNum, placing it in self.

Parameters

• bits: Length of the number in bits.
• msb: The desired properties of the most significant bit. See constants.
• odd: If true, the generated number will be odd.

Examples

use openssl::bn::{BigNum,MSB_MAYBE_ZERO};
use openssl::error::ErrorStack;

fn generate_random() -> Result< BigNum, ErrorStack > {
   let mut big = BigNum::new()?;

   // Generates a 128-bit odd random number
   big.rand(128, MSB_MAYBE_ZERO, true);
   Ok((big))
}

OpenSSL documentation at BN_rand

fn pseudo_rand(
    &mut self,
    bits: i32,
    msb: MsbOption,
    odd: bool
) -> Result<(), ErrorStack>

The cryptographically weak counterpart to rand. Not suitable for key generation.

OpenSSL documentation at BN_psuedo_rand

fn generate_prime(
    &mut self,
    bits: i32,
    safe: bool,
    add: Option<&BigNumRef>,
    rem: Option<&BigNumRef>
) -> Result<(), ErrorStack>

Generates a prime number, placing it in self.

Parameters

• bits: The length of the prime in bits (lower bound).
• safe: If true, returns a "safe" prime p so that (p-1)/2 is also prime.
• add/rem: If add is set to Some(add), p % add == rem will hold, where p is the generated prime and rem is 1 if not specified (None).

Examples

use openssl::bn::BigNum;
use openssl::error::ErrorStack;

fn generate_weak_prime() -> Result< BigNum, ErrorStack > {
   let mut big = BigNum::new()?;

   // Generates a 128-bit simple prime number
   big.generate_prime(128, false, None, None);
   Ok((big))
}

OpenSSL documentation at BN_generate_prime_ex

fn checked_mul(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a * b in self. core::ops::Mul is also implemented for BigNumRef.

OpenSSL documentation at BN_mul

fn checked_div(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a / b in self. The remainder is discarded. core::ops::Div is also implemented for BigNumRef.

OpenSSL documentation at BN_div

fn checked_rem(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a % b in self.

OpenSSL documentation at BN_div

fn div_rem(
    &mut self,
    rem: &mut BigNumRef,
    a: &BigNumRef,
    b: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a / b in self and a % b in rem.

OpenSSL documentation at BN_div

fn sqr(
    &mut self,
    a: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a² in self.

OpenSSL documentation at BN_sqr

fn nnmod(
    &mut self,
    a: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a mod m in self. As opposed to div_rem the result is non-negative.

OpenSSL documentation at BN_nnmod

fn mod_add(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of (a + b) mod m in self.

OpenSSL documentation at BN_mod_add

fn mod_sub(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of (a - b) mod m in self.

OpenSSL documentation at BN_mod_sub

fn mod_mul(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of (a * b) mod m in self.

OpenSSL documentation at BN_mod_mul

fn mod_sqr(
    &mut self,
    a: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a² mod m in self.

OpenSSL documentation at BN_mod_sqr

fn exp(
    &mut self,
    a: &BigNumRef,
    p: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a^p in self.

OpenSSL documentation at BN_exp

fn mod_exp(
    &mut self,
    a: &BigNumRef,
    p: &BigNumRef,
    m: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the result of a^p mod m in self.

OpenSSL documentation at BN_mod_exp

fn mod_inverse(
    &mut self,
    a: &BigNumRef,
    n: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the inverse of a modulo n in self.

fn gcd(
    &mut self,
    a: &BigNumRef,
    b: &BigNumRef,
    ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>

Places the greatest common denominator of a and b in self.

OpenSSL documentation at BN_gcd

fn is_prime(
    &self,
    checks: i32,
    ctx: &mut BigNumContextRef
) -> Result<bool, ErrorStack>

Checks whether self is prime.

Performs a Miller-Rabin probabilistic primality test with checks iterations.

OpenSSL documentation at BN_is_prime_ex

Return Value

Returns true if self is prime with an error probability of less than 0.25 ^ checks.

fn is_prime_fasttest(
    &self,
    checks: i32,
    ctx: &mut BigNumContextRef,
    do_trial_division: bool
) -> Result<bool, ErrorStack>

Checks whether self is prime with optional trial division.

If do_trial_division is true, first performs trial division by a number of small primes. Then, like is_prime, performs a Miller-Rabin probabilistic primality test with checks iterations.

OpenSSL documentation at BN_is_prime_fasttest_ex

Return Value

Returns true if self is prime with an error probability of less than 0.25 ^ checks.

fn to_vec(&self) -> Vec<u8>

Returns a big-endian byte vector representation of the absolute value of self.

self can be recreated by using from_slice.

let s = -BigNum::from_u32(4543).unwrap();
let r = BigNum::from_u32(4543).unwrap();

let s_vec = s.to_vec();
assert_eq!(BigNum::from_slice(&s_vec).unwrap(), r);

fn to_dec_str(&self) -> Result<OpensslString, ErrorStack>

Returns a decimal string representation of self.

let s = -BigNum::from_u32(12345).unwrap();

assert_eq!(&**s.to_dec_str().unwrap(), "-12345");

fn to_hex_str(&self) -> Result<OpensslString, ErrorStack>

Returns a hexadecimal string representation of self.

let s = -BigNum::from_u32(0x99ff).unwrap();

assert_eq!(&**s.to_hex_str().unwrap(), "-99FF");

fn to_asn1_integer(&self) -> Result<Asn1Integer, ErrorStack>

Returns an Asn1Integer containing the value of self.

Trait Implementations

impl ForeignTypeRef for BigNumRef

type CType = BIGNUM

The raw C type.

unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self

Constructs a shared instance of this type from its raw type.

unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self

Constructs a mutable reference of this type from its raw type.

fn as_ptr(&self) -> *mut Self::CType

Returns a raw pointer to the wrapped value.

impl Send for BigNumRef

impl Sync for BigNumRef

impl Debug for BigNumRef

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

Formats the value using the given formatter.

impl Display for BigNumRef

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

Formats the value using the given formatter.

impl PartialEq<BigNumRef> for BigNumRef

fn eq(&self, oth: &BigNumRef) -> bool

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

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

This method tests for !=.

impl PartialEq<BigNum> for BigNumRef

fn eq(&self, oth: &BigNum) -> bool

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

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

This method tests for !=.

impl Eq for BigNumRef

impl PartialOrd<BigNumRef> for BigNumRef

fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

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

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

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

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

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 PartialOrd<BigNum> for BigNumRef

fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

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

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

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

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

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 Ord for BigNumRef

fn cmp(&self, oth: &BigNumRef) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the + operator.

fn add(self, oth: &BigNumRef) -> BigNum

Performs the + operation.

impl<'a, 'b> Add<&'b BigNum> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the + operator.

fn add(self, oth: &BigNum) -> BigNum

Performs the + operation.

impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the - operator.

fn sub(self, oth: &BigNumRef) -> BigNum

Performs the - operation.

impl<'a, 'b> Sub<&'b BigNum> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the - operator.

fn sub(self, oth: &BigNum) -> BigNum

Performs the - operation.

impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the * operator.

fn mul(self, oth: &BigNumRef) -> BigNum

Performs the * operation.

impl<'a, 'b> Mul<&'b BigNum> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the * operator.

fn mul(self, oth: &BigNum) -> BigNum

Performs the * operation.

impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the / operator.

fn div(self, oth: &'b BigNumRef) -> BigNum

Performs the / operation.

impl<'a, 'b> Div<&'b BigNum> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the / operator.

fn div(self, oth: &BigNum) -> BigNum

Performs the / operation.

impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the % operator.

fn rem(self, oth: &'b BigNumRef) -> BigNum

Performs the % operation.

impl<'a, 'b> Rem<&'b BigNum> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the % operator.

fn rem(self, oth: &BigNum) -> BigNum

Performs the % operation.

impl<'a> Shl<i32> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the << operator.

fn shl(self, n: i32) -> BigNum

Performs the << operation.

impl<'a> Shr<i32> for &'a BigNumRef

type Output = BigNum

The resulting type after applying the >> operator.

fn shr(self, n: i32) -> BigNum

Performs the >> operation.

impl<'a> Neg for &'a BigNumRef

type Output = BigNum

The resulting type after applying the - operator.

fn neg(self) -> BigNum

Performs the unary - operation.