[][src]Struct openssl::bn::BigNum

pub struct BigNum(_);

Dynamically sized large number impelementation

Perform large number mathematics. Create a new BigNum with new. Perform standard mathematics on large numbers using methods from Dref<Target = BigNumRef>

OpenSSL documenation at BN_new.

Examples

use openssl::bn::BigNum;
let little_big = BigNum::from_u32(std::u32::MAX)?;
assert_eq!(*&little_big.num_bytes(), 4);

Methods

impl BigNum[src]

pub fn new() -> Result<BigNum, ErrorStack>[src]

Creates a new BigNum with the value 0.

pub fn from_u32(n: u32) -> Result<BigNum, ErrorStack>[src]

Creates a new BigNum with the given value.

OpenSSL documentation at BN_set_word

pub fn from_dec_str(s: &str) -> Result<BigNum, ErrorStack>[src]

Creates a BigNum from a decimal string.

OpenSSL documentation at BN_dec2bn

pub fn from_hex_str(s: &str) -> Result<BigNum, ErrorStack>[src]

Creates a BigNum from a hexadecimal string.

OpenSSL documentation at BN_hex2bn

pub fn get_rfc2409_prime_768() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 2409. This prime number is in the order of magnitude of 2 ^ 768. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled Oakley group id 1.

OpenSSL documentation at BN_get_rfc2409_prime_768

pub fn get_rfc2409_prime_1024() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 2409. This prime number is in the order of magnitude of 2 ^ 1024. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled Oakly group 2.

OpenSSL documentation at BN_get_rfc2409_prime_1024

pub fn get_rfc3526_prime_1536() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 1536. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 5.

OpenSSL documentation at BN_get_rfc3526_prime_1536

pub fn get_rfc3526_prime_2048() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 2048. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 14.

OpenSSL documentation at BN_get_rfc3526_prime_2048

pub fn get_rfc3526_prime_3072() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 3072. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 15.

OpenSSL documentation at BN_get_rfc3526_prime_3072

pub fn get_rfc3526_prime_4096() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 4096. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 16.

OpenSSL documentation at BN_get_rfc3526_prime_4096

pub fn get_rfc3526_prime_6144() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 6144. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 17.

OpenSSL documentation at BN_get_rfc3526_prime_6144

pub fn get_rfc3526_prime_8192() -> Result<BigNum, ErrorStack>[src]

Returns a constant used in IKE as defined in RFC 3526. The prime is in the order of magnitude of 2 ^ 8192. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 18.

OpenSSL documentation at BN_get_rfc3526_prime_8192

pub fn from_slice(n: &[u8]) -> Result<BigNum, ErrorStack>[src]

Creates a new BigNum from an unsigned, big-endian encoded number of arbitrary length.

OpenSSL documentation at BN_bin2bn

let bignum = BigNum::from_slice(&[0x12, 0x00, 0x34]).unwrap();

assert_eq!(bignum, BigNum::from_u32(0x120034).unwrap());

Methods from Deref<Target = BigNumRef>

pub fn clear(&mut self)[src]

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

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

Adds a u32 to self.

OpenSSL documentation at BN_add_word

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

Subtracts a u32 from self.

OpenSSL documentation at BN_sub_word

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

Multiplies a u32 by self.

OpenSSL documentation at BN_mul_word

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

Divides self by a u32, returning the remainder.

OpenSSL documentation at BN_div_word

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

Returns the result of self modulo w.

OpenSSL documentation at BN_mod_word

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

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

OpenSSL documentation at BN_rand_range

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

The cryptographically weak counterpart to rand_in_range.

OpenSSL documentation at BN_pseudo_rand_range

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

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

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

OpenSSL documentation at BN_set_bit

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

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

pub fn is_bit_set(&self, n: i32) -> bool[src]

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

OpenSSL documentation at BN_is_bit_set

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

Truncates self to the lowest n bits.

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

OpenSSL documentation at BN_mask_bits

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

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

OpenSSL documentation at BN_lshift1

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

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

OpenSSL documentation at BN_rshift1

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

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

OpenSSL documentation at BN_add

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

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

OpenSSL documentation at BN_sub

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

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

OpenSSL documentation at BN_lshift

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

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

OpenSSL documentation at BN_rshift

pub fn to_owned(&self) -> Result<BigNum, ErrorStack>[src]

Creates a new BigNum with the same value.

OpenSSL documentation at BN_dup

pub fn set_negative(&mut self, negative: bool)[src]

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

pub fn ucmp(&self, oth: &BigNumRef) -> Ordering[src]

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);

pub fn is_negative(&self) -> bool[src]

Returns true if self is negative.

pub fn num_bits(&self) -> i32[src]

Returns the number of significant bits in self.

OpenSSL documentation at BN_num_bits

pub fn num_bytes(&self) -> i32[src]

Returns the size of self in bytes. Implemented natively.

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

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, MsbOption};
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, MsbOption::MAYBE_ZERO, true);
   Ok((big))
}

OpenSSL documentation at BN_rand

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

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

OpenSSL documentation at BN_psuedo_rand

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

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

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

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

OpenSSL documentation at BN_mul

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

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

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

Places the result of a % b in self.

OpenSSL documentation at BN_div

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

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

OpenSSL documentation at BN_div

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

Places the result of in self.

OpenSSL documentation at BN_sqr

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

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

OpenSSL documentation at BN_nnmod

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

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

OpenSSL documentation at BN_mod_add

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

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

OpenSSL documentation at BN_mod_sub

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

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

OpenSSL documentation at BN_mod_mul

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

Places the result of a² mod m in self.

OpenSSL documentation at BN_mod_sqr

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

Places the result of a^p in self.

OpenSSL documentation at BN_exp

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

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

OpenSSL documentation at BN_mod_exp

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

Places the inverse of a modulo n in self.

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

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

OpenSSL documentation at BN_gcd

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

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.

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

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.

pub fn to_vec(&self) -> Vec<u8>[src]

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);

pub fn to_dec_str(&self) -> Result<OpensslString, ErrorStack>[src]

Returns a decimal string representation of self.

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

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

pub fn to_hex_str(&self) -> Result<OpensslString, ErrorStack>[src]

Returns a hexadecimal string representation of self.

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

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

pub fn to_asn1_integer(&self) -> Result<Asn1Integer, ErrorStack>[src]

Returns an Asn1Integer containing the value of self.

Trait Implementations

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

type Output = BigNum

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b BigNum> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the + operator.

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

type Output = BigNum

The resulting type after applying the + operator.

impl AsRef<BigNumRef> for BigNum[src]

impl Borrow<BigNumRef> for BigNum[src]

impl Debug for BigNum[src]

impl Deref for BigNum[src]

type Target = BigNumRef

The resulting type after dereferencing.

impl DerefMut for BigNum[src]

impl Display for BigNum[src]

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

type Output = BigNum

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b BigNum> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the / operator.

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

type Output = BigNum

The resulting type after applying the / operator.

impl Drop for BigNum[src]

impl Eq for BigNum[src]

impl ForeignType for BigNum[src]

type CType = BIGNUM

The raw C type.

type Ref = BigNumRef

The type representing a reference to this type.

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

type Output = BigNum

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b BigNum> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the * operator.

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

type Output = BigNum

The resulting type after applying the * operator.

impl<'a> Neg for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the - operator.

impl Neg for BigNum[src]

type Output = BigNum

The resulting type after applying the - operator.

impl Ord for BigNum[src]

impl PartialEq<BigNum> for BigNumRef[src]

impl PartialEq<BigNum> for BigNum[src]

impl PartialEq<BigNumRef> for BigNum[src]

impl PartialOrd<BigNum> for BigNumRef[src]

impl PartialOrd<BigNum> for BigNum[src]

impl PartialOrd<BigNumRef> for BigNum[src]

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

type Output = BigNum

The resulting type after applying the % operator.

impl<'a, 'b> Rem<&'b BigNum> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the % operator.

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

type Output = BigNum

The resulting type after applying the % operator.

impl Send for BigNum[src]

impl<'a> Shl<i32> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the << operator.

impl<'a> Shr<i32> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the >> operator.

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

type Output = BigNum

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b BigNum> for &'a BigNum[src]

type Output = BigNum

The resulting type after applying the - operator.

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

type Output = BigNum

The resulting type after applying the - operator.

impl Sync for BigNum[src]

Auto Trait Implementations

impl RefUnwindSafe for BigNum

impl Unpin for BigNum

impl UnwindSafe for BigNum

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.