min
/
boring2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix resource leak, correct interface inaccuracies.

This commit is contained in:
Sam Thomas 2014-07-24 09:27:22 +01:00
parent 7d1dfe33e6
commit d9992ca79e
1 changed files with 44 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
bn/mod.rs
View File

@ -1,5 +1,5 @@
use libc::{c_void, c_int, c_uint}; use libc::{c_void, c_int, c_ulong};
use std::ptr; use std::ptr;
use ssl::error::SslError; use ssl::error::SslError;
@ -24,9 +24,9 @@ extern {
fn BN_CTX_new() -> *mut BN_CTX; fn BN_CTX_new() -> *mut BN_CTX;
fn BN_CTX_free(ctx: *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_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 */ /* Arithmetic operations on BIGNUMs */
fn BN_add(r: *mut BIGNUM, a: *mut BIGNUM, b: *mut BIGNUM) -> c_int; 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_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_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_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_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; fn BN_rshift1(r: *mut BIGNUM, a: *mut BIGNUM) -> c_int;
/* Comparisons on BIGNUMs */ /* Comparisons on BIGNUMs */
@ -122,11 +122,14 @@ macro_rules! with_bn_in_ctx(
if ($ctx_name).is_null() { if ($ctx_name).is_null() {
Err(SslError::get()) Err(SslError::get())
} else { } else {
let r =
if $action { if $action {
Ok($name) Ok($name)
} else { } else {
Err(SslError::get()) Err(SslError::get())
} };
BN_CTX_free($ctx_name);
r
} }
}, },
Err(err) => Err(err), 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 { unsafe {
let bn = BN_new(); 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()) Err(SslError::get())
} else { } else {
Ok(BigNum(bn)) Ok(BigNum(bn))
@ -160,7 +163,7 @@ impl BigNum {
pub fn new_from_slice(n: &[u8]) -> Result<BigNum, SslError> { pub fn new_from_slice(n: &[u8]) -> Result<BigNum, SslError> {
unsafe { unsafe {
let bn = BN_new(); 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()) Err(SslError::get())
} else { } else {
Ok(BigNum(bn)) 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 { unsafe {
with_bn_in_ctx!(r, ctx, { with_bn_in_ctx!(r, ctx, {
let add_arg = add.map(|a| a.raw()).unwrap_or(ptr::mut_null()); 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 { unsafe {
with_ctx!(ctx, { with_ctx!(ctx, {
Ok(BN_is_prime_ex(self.raw(), checks as c_int, ctx, ptr::null()) == 1) 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 { unsafe {
with_ctx!(ctx, { 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) 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 { unsafe {
with_bn_in_ctx!(r, ctx, { BN_rand(r.raw(), bits as c_int, prop as c_int, odd as c_int) == 1 }) 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 { 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 }) 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 { unsafe {
if BN_set_bit(self.raw(), n as c_int) == 1 { if BN_set_bit(self.raw(), n as c_int) == 1 {
Ok(()) 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 { unsafe {
if BN_clear_bit(self.raw(), n as c_int) == 1 { if BN_clear_bit(self.raw(), n as c_int) == 1 {
Ok(()) 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 { unsafe {
BN_is_bit_set(self.raw(), n as c_int) == 1 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 { unsafe {
if BN_mask_bits(self.raw(), n as c_int) == 1 { if BN_mask_bits(self.raw(), n as c_int) == 1 {
Ok(()) 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 { 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 { 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 { pub fn abs_cmp(&self, oth: BigNum) -> Ordering {
unsafe { unsafe {
let res = BN_ucmp(self.raw(), oth.raw()) as int; let res = BN_ucmp(self.raw(), oth.raw()) as i32;
if res < 0 { if res < 0 {
Less Less
} else if res > 0 { } else if res > 0 {
@ -394,13 +397,13 @@ impl BigNum {
} }
} }
pub fn num_bits(&self) -> uint { pub fn num_bits(&self) -> i32 {
unsafe { 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 (self.num_bits() + 7) / 8
} }
@ -410,7 +413,7 @@ impl BigNum {
} }
pub fn to_vec(&self) -> Vec<u8> { 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); let mut v = Vec::with_capacity(size);
unsafe { unsafe {
BN_bn2bin(self.raw(), v.as_mut_ptr()); BN_bn2bin(self.raw(), v.as_mut_ptr());
@ -499,14 +502,14 @@ pub mod unchecked {
} }
} }
impl Shl<uint, BigNum> for BigNum { impl Shl<i32, BigNum> for BigNum {
fn shl(&self, n: &uint) -> BigNum { fn shl(&self, n: &i32) -> BigNum {
self.checked_shl(n).unwrap() self.checked_shl(n).unwrap()
} }
} }
impl Shr<uint, BigNum> for BigNum { impl Shr<i32, BigNum> for BigNum {
fn shr(&self, n: &uint) -> BigNum { fn shr(&self, n: &i32) -> BigNum {
self.checked_shr(n).unwrap() self.checked_shr(n).unwrap()
} }
} }
@ -539,7 +542,7 @@ mod tests {
#[test] #[test]
fn test_to_from_slice() { 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 vec = v0.to_vec();
let v1 = BigNum::new_from_slice(vec.as_slice()).unwrap(); let v1 = BigNum::new_from_slice(vec.as_slice()).unwrap();
@ -548,7 +551,7 @@ mod tests {
#[test] #[test]
fn test_negation() { 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());
assert!((-a).is_negative()); assert!((-a).is_negative());
@ -557,10 +560,10 @@ mod tests {
#[test] #[test]
fn test_prime_numbers() { fn test_prime_numbers() {
let a = BigNum::new_from(19029017u).unwrap(); let a = BigNum::new_from(19029017_u64).unwrap();
let p = BigNum::checked_generate_prime(128u, true, None, Some(&a)).unwrap(); let p = BigNum::checked_generate_prime(128, true, None, Some(&a)).unwrap();
assert!(p.is_prime(100u).unwrap()); assert!(p.is_prime(100).unwrap());
assert!(p.is_prime_fast(100u, true).unwrap()); assert!(p.is_prime_fast(100, true).unwrap());
} }
} }