Fix resource leak, correct interface inaccuracies. (d9992ca7) · Commits · Public Repositories / Rust Openssl

bn/mod.rs

+44 −41

Original line number	Diff line number	Diff line

		use libc::{c_void, c_int, c_uint};
		use libc::{c_void, c_int, c_ulong};
		use std::ptr;

		use ssl::error::SslError;
		@@ -24,9 +24,9 @@ extern {
		fn BN_CTX_new() -> *mut BN_CTX;
		fn BN_CTX_free(ctx: *mut BN_CTX);

		fn BN_set_word(bn: *mut BIGNUM, n: c_uint) -> c_int;
		fn BN_set_word(bn: *mut BIGNUM, n: c_ulong) -> c_int;
		fn BN_set_negative(bn: *mut BIGNUM, n: c_int);
		fn BN_num_bits(bn: *mut BIGNUM) -> c_uint;
		fn BN_num_bits(bn: *mut BIGNUM) -> c_int;

		/* Arithmetic operations on BIGNUMs */
		fn BN_add(r: mut BIGNUM, a: mut BIGNUM, b: *mut BIGNUM) -> c_int;
		@@ -50,9 +50,9 @@ extern {
		fn BN_clear_bit(a: *mut BIGNUM, n: c_int) -> c_int;
		fn BN_is_bit_set(a: *mut BIGNUM, n: c_int) -> c_int;
		fn BN_mask_bits(a: *mut BIGNUM, n: c_int) -> c_int;
		fn BN_lshift(r: mut BIGNUM, a: mut BIGNUM, n: c_uint) -> c_int;
		fn BN_lshift(r: mut BIGNUM, a: mut BIGNUM, n: c_int) -> c_int;
		fn BN_lshift1(r: mut BIGNUM, a: mut BIGNUM) -> c_int;
		fn BN_rshift(r: mut BIGNUM, a: mut BIGNUM, n: c_uint) -> c_int;
		fn BN_rshift(r: mut BIGNUM, a: mut BIGNUM, n: c_int) -> c_int;
		fn BN_rshift1(r: mut BIGNUM, a: mut BIGNUM) -> c_int;

		/* Comparisons on BIGNUMs */
		@@ -122,11 +122,14 @@ macro_rules! with_bn_in_ctx(
		if ($ctx_name).is_null() {
		Err(SslError::get())
		} else {
		let r =
		if $action {
		Ok($name)
		} else {
		Err(SslError::get())
		}
		};
		BN_CTX_free($ctx_name);
		r
		}
		},
		Err(err) => Err(err),
		@@ -146,10 +149,10 @@ impl BigNum {
		}
		}

		pub fn new_from(n: uint) -> Result<BigNum, SslError> {
		pub fn new_from(n: u64) -> Result<BigNum, SslError> {
		unsafe {
		let bn = BN_new();
		if bn.is_null() \|\| BN_set_word(bn, n as c_uint) == 0 {
		if bn.is_null() \|\| BN_set_word(bn, n as c_ulong) == 0 {
		Err(SslError::get())
		} else {
		Ok(BigNum(bn))
		@@ -160,7 +163,7 @@ impl BigNum {
		pub fn new_from_slice(n: &[u8]) -> Result<BigNum, SslError> {
		unsafe {
		let bn = BN_new();
		if bn.is_null() \|\| BN_bin2bn(n.as_ptr(), n.len() as i32, bn).is_null() {
		if bn.is_null() \|\| BN_bin2bn(n.as_ptr(), n.len() as c_int, bn).is_null() {
		Err(SslError::get())
		} else {
		Ok(BigNum(bn))
		@@ -228,7 +231,7 @@ impl BigNum {
		}
		}

		pub fn checked_generate_prime(bits: uint, safe: bool, add: Option<&BigNum>, rem: Option<&BigNum>) -> Result<BigNum, SslError> {
		pub fn checked_generate_prime(bits: i32, safe: bool, add: Option<&BigNum>, rem: Option<&BigNum>) -> Result<BigNum, SslError> {
		unsafe {
		with_bn_in_ctx!(r, ctx, {
		let add_arg = add.map(\|a\| a.raw()).unwrap_or(ptr::mut_null());
		@@ -239,7 +242,7 @@ impl BigNum {
		}
		}

		pub fn is_prime(&self, checks: uint) -> Result<bool, SslError> {
		pub fn is_prime(&self, checks: i32) -> Result<bool, SslError> {
		unsafe {
		with_ctx!(ctx, {
		Ok(BN_is_prime_ex(self.raw(), checks as c_int, ctx, ptr::null()) == 1)
		@@ -247,7 +250,7 @@ impl BigNum {
		}
		}

		pub fn is_prime_fast(&self, checks: uint, do_trial_division: bool) -> Result<bool, SslError> {
		pub fn is_prime_fast(&self, checks: i32, do_trial_division: bool) -> Result<bool, SslError> {
		unsafe {
		with_ctx!(ctx, {
		Ok(BN_is_prime_fasttest_ex(self.raw(), checks as c_int, ctx, do_trial_division as c_int, ptr::null()) == 1)
		@@ -255,13 +258,13 @@ impl BigNum {
		}
		}

		pub fn checked_new_random(bits: uint, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError> {
		pub fn checked_new_random(bits: i32, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError> {
		unsafe {
		with_bn_in_ctx!(r, ctx, { BN_rand(r.raw(), bits as c_int, prop as c_int, odd as c_int) == 1 })
		}
		}

		pub fn checked_new_pseudo_random(bits: uint, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError> {
		pub fn checked_new_pseudo_random(bits: i32, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError> {
		unsafe {
		with_bn_in_ctx!(r, ctx, { BN_pseudo_rand(r.raw(), bits as c_int, prop as c_int, odd as c_int) == 1 })
		}
		@@ -279,7 +282,7 @@ impl BigNum {
		}
		}

		pub fn set_bit(&mut self, n: uint) -> Result<(), SslError> {
		pub fn set_bit(&mut self, n: i32) -> Result<(), SslError> {
		unsafe {
		if BN_set_bit(self.raw(), n as c_int) == 1 {
		Ok(())
		@@ -289,7 +292,7 @@ impl BigNum {
		}
		}

		pub fn clear_bit(&mut self, n: uint) -> Result<(), SslError> {
		pub fn clear_bit(&mut self, n: i32) -> Result<(), SslError> {
		unsafe {
		if BN_clear_bit(self.raw(), n as c_int) == 1 {
		Ok(())
		@@ -299,13 +302,13 @@ impl BigNum {
		}
		}

		pub fn is_bit_set(&self, n: uint) -> bool {
		pub fn is_bit_set(&self, n: i32) -> bool {
		unsafe {
		BN_is_bit_set(self.raw(), n as c_int) == 1
		}
		}

		pub fn mask_bits(&mut self, n: uint) -> Result<(), SslError> {
		pub fn mask_bits(&mut self, n: i32) -> Result<(), SslError> {
		unsafe {
		if BN_mask_bits(self.raw(), n as c_int) == 1 {
		Ok(())
		@@ -357,15 +360,15 @@ impl BigNum {
		}
		}

		pub fn checked_shl(&self, a: &uint) -> Result<BigNum, SslError> {
		pub fn checked_shl(&self, a: &i32) -> Result<BigNum, SslError> {
		unsafe {
		with_bn!(r, { BN_lshift(r.raw(), self.raw(), *a as c_uint) == 1 })
		with_bn!(r, { BN_lshift(r.raw(), self.raw(), *a as c_int) == 1 })
		}
		}

		pub fn checked_shr(&self, a: &uint) -> Result<BigNum, SslError> {
		pub fn checked_shr(&self, a: &i32) -> Result<BigNum, SslError> {
		unsafe {
		with_bn!(r, { BN_rshift(r.raw(), self.raw(), *a as c_uint) == 1 })
		with_bn!(r, { BN_rshift(r.raw(), self.raw(), *a as c_int) == 1 })
		}
		}

		@@ -377,7 +380,7 @@ impl BigNum {

		pub fn abs_cmp(&self, oth: BigNum) -> Ordering {
		unsafe {
		let res = BN_ucmp(self.raw(), oth.raw()) as int;
		let res = BN_ucmp(self.raw(), oth.raw()) as i32;
		if res < 0 {
		Less
		} else if res > 0 {
		@@ -394,13 +397,13 @@ impl BigNum {
		}
		}

		pub fn num_bits(&self) -> uint {
		pub fn num_bits(&self) -> i32 {
		unsafe {
		BN_num_bits(self.raw()) as uint
		BN_num_bits(self.raw()) as i32
		}
		}

		pub fn num_bytes(&self) -> uint {
		pub fn num_bytes(&self) -> i32 {
		(self.num_bits() + 7) / 8
		}

		@@ -410,7 +413,7 @@ impl BigNum {
		}

		pub fn to_vec(&self) -> Vec<u8> {
		let size = self.num_bytes();
		let size = self.num_bytes() as uint;
		let mut v = Vec::with_capacity(size);
		unsafe {
		BN_bn2bin(self.raw(), v.as_mut_ptr());
		@@ -499,14 +502,14 @@ pub mod unchecked {
		}
		}

		impl Shl<uint, BigNum> for BigNum {
		fn shl(&self, n: &uint) -> BigNum {
		impl Shl<i32, BigNum> for BigNum {
		fn shl(&self, n: &i32) -> BigNum {
		self.checked_shl(n).unwrap()
		}
		}

		impl Shr<uint, BigNum> for BigNum {
		fn shr(&self, n: &uint) -> BigNum {
		impl Shr<i32, BigNum> for BigNum {
		fn shr(&self, n: &i32) -> BigNum {
		self.checked_shr(n).unwrap()
		}
		}
		@@ -539,7 +542,7 @@ mod tests {

		#[test]
		fn test_to_from_slice() {
		let v0 = BigNum::new_from(10203004u).unwrap();
		let v0 = BigNum::new_from(10203004_u64).unwrap();
		let vec = v0.to_vec();
		let v1 = BigNum::new_from_slice(vec.as_slice()).unwrap();

		@@ -548,7 +551,7 @@ mod tests {

		#[test]
		fn test_negation() {
		let a = BigNum::new_from(909829283u).unwrap();
		let a = BigNum::new_from(909829283_u64).unwrap();

		assert!(!a.is_negative());
		assert!((-a).is_negative());
		@@ -557,10 +560,10 @@ mod tests {

		#[test]
		fn test_prime_numbers() {
		let a = BigNum::new_from(19029017u).unwrap();
		let p = BigNum::checked_generate_prime(128u, true, None, Some(&a)).unwrap();
		let a = BigNum::new_from(19029017_u64).unwrap();
		let p = BigNum::checked_generate_prime(128, true, None, Some(&a)).unwrap();

		assert!(p.is_prime(100u).unwrap());
		assert!(p.is_prime_fast(100u, true).unwrap());
		assert!(p.is_prime(100).unwrap());
		assert!(p.is_prime_fast(100, true).unwrap());
		}
		}