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

Update to rust master

This commit is contained in:
Alex Crichton 2015-01-09 08:07:39 -08:00
parent 8b67adfc90
commit 9dfeea6ca9
14 changed files with 102 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
openssl-sys/src/build.rs
View File

@ -1,3 +1,5 @@
#![allow(unstable)]
extern crate "pkg-config" as pkg_config; extern crate "pkg-config" as pkg_config;
use std::os; use std::os;

12
openssl-sys/src/lib.rs
View File

@ -1,5 +1,5 @@
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(dead_code)] #![allow(dead_code, unstable)]
extern crate libc; extern crate libc;
@ -197,12 +197,12 @@ static mut GUARDS: *mut Vec<Option<MutexGuard<'static, ()>>> = 0 as *mut Vec<Opt
extern fn locking_function(mode: c_int, n: c_int, _file: *const c_char, extern fn locking_function(mode: c_int, n: c_int, _file: *const c_char,
_line: c_int) { _line: c_int) {
unsafe { unsafe {
let mutex = &(*MUTEXES)[n as uint]; let mutex = &(*MUTEXES)[n as usize];
if mode & CRYPTO_LOCK != 0 { if mode & CRYPTO_LOCK != 0 {
(*GUARDS)[n as uint] = Some(mutex.lock().unwrap()); (*GUARDS)[n as usize] = Some(mutex.lock().unwrap());
} else { } else {
&(*GUARDS)[n as uint].take(); &(*GUARDS)[n as usize].take();
} }
} }
} }
@ -216,10 +216,10 @@ pub fn init() {
SSL_load_error_strings(); SSL_load_error_strings();
let num_locks = CRYPTO_num_locks(); let num_locks = CRYPTO_num_locks();
let mutexes = box range(0, num_locks).map(|_| MUTEX_INIT).collect::<Vec<_>>(); let mutexes = Box::new(range(0, num_locks).map(|_| MUTEX_INIT).collect::<Vec<_>>());
MUTEXES = mem::transmute(mutexes); MUTEXES = mem::transmute(mutexes);
let guards: Box<Vec<Option<MutexGuard<()>>>> = let guards: Box<Vec<Option<MutexGuard<()>>>> =
box range(0, num_locks).map(|_| None).collect(); Box::new(range(0, num_locks).map(|_| None).collect());
GUARDS = mem::transmute(guards); GUARDS = mem::transmute(guards);
CRYPTO_set_locking_callback(locking_function); CRYPTO_set_locking_callback(locking_function);

2
src/asn1/mod.rs
View File

@ -30,7 +30,7 @@ impl Asn1Time {
} }
/// Creates a new time on specified interval in days from now /// Creates a new time on specified interval in days from now
pub fn days_from_now(days: uint) -> Result<Asn1Time, SslError> { pub fn days_from_now(days: u32) -> Result<Asn1Time, SslError> {
Asn1Time::new_with_period(days as u64 * 60 * 60 * 24) Asn1Time::new_with_period(days as u64 * 60 * 60 * 24)
} }

6
src/bio/mod.rs
View File

@ -58,7 +58,7 @@ impl MemBio {
} }
impl Reader for MemBio { impl Reader for MemBio {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let ret = unsafe { let ret = unsafe {
ffi::BIO_read(self.bio, buf.as_ptr() as *mut c_void, ffi::BIO_read(self.bio, buf.as_ptr() as *mut c_void,
buf.len() as c_int) buf.len() as c_int)
@ -81,7 +81,7 @@ impl Reader for MemBio {
}; };
Err(err) Err(err)
} else { } else {
Ok(ret as uint) Ok(ret as usize)
} }
} }
} }
@ -92,7 +92,7 @@ impl Writer for MemBio {
ffi::BIO_write(self.bio, buf.as_ptr() as *const c_void, ffi::BIO_write(self.bio, buf.as_ptr() as *const c_void,
buf.len() as c_int) buf.len() as c_int)
}; };
if buf.len() != ret as uint { if buf.len() != ret as usize {
Err(IoError { Err(IoError {
kind: OtherIoError, kind: OtherIoError,
desc: "MemBio write error", desc: "MemBio write error",

2
src/bn/mod.rs
View File

@ -408,7 +408,7 @@ impl BigNum {
} }
pub fn to_vec(&self) -> Vec<u8> { pub fn to_vec(&self) -> Vec<u8> {
let size = self.num_bytes() as uint; let size = self.num_bytes() as usize;
let mut v = Vec::with_capacity(size); let mut v = Vec::with_capacity(size);
unsafe { unsafe {
ffi::BN_bn2bin(self.raw(), v.as_mut_ptr()); ffi::BN_bn2bin(self.raw(), v.as_mut_ptr());

20
src/crypto/hash.rs
View File

@ -16,16 +16,16 @@ pub enum HashType {
RIPEMD160 RIPEMD160
} }
pub fn evpmd(t: HashType) -> (*const ffi::EVP_MD, uint) { pub fn evpmd(t: HashType) -> (*const ffi::EVP_MD, u32) {
unsafe { unsafe {
match t { match t {
HashType::MD5 => (ffi::EVP_md5(), 16u), HashType::MD5 => (ffi::EVP_md5(), 16),
HashType::SHA1 => (ffi::EVP_sha1(), 20u), HashType::SHA1 => (ffi::EVP_sha1(), 20),
HashType::SHA224 => (ffi::EVP_sha224(), 28u), HashType::SHA224 => (ffi::EVP_sha224(), 28),
HashType::SHA256 => (ffi::EVP_sha256(), 32u), HashType::SHA256 => (ffi::EVP_sha256(), 32),
HashType::SHA384 => (ffi::EVP_sha384(), 48u), HashType::SHA384 => (ffi::EVP_sha384(), 48),
HashType::SHA512 => (ffi::EVP_sha512(), 64u), HashType::SHA512 => (ffi::EVP_sha512(), 64),
HashType::RIPEMD160 => (ffi::EVP_ripemd160(), 20u), HashType::RIPEMD160 => (ffi::EVP_ripemd160(), 20),
} }
} }
} }
@ -56,7 +56,7 @@ impl Drop for HasherContext {
pub struct Hasher { pub struct Hasher {
evp: *const ffi::EVP_MD, evp: *const ffi::EVP_MD,
ctx: HasherContext, ctx: HasherContext,
len: uint, len: u32,
} }
impl io::Writer for Hasher { impl io::Writer for Hasher {
@ -102,7 +102,7 @@ impl Hasher {
* initialization and its context for reuse * initialization and its context for reuse
*/ */
pub fn finalize_reuse(self) -> (Vec<u8>, HasherContext) { pub fn finalize_reuse(self) -> (Vec<u8>, HasherContext) {
let mut res = repeat(0u8).take(self.len).collect::<Vec<_>>(); let mut res = repeat(0u8).take(self.len as usize).collect::<Vec<_>>();
unsafe { unsafe {
ffi::EVP_DigestFinal_ex(self.ctx.ptr, res.as_mut_ptr(), ptr::null_mut()) ffi::EVP_DigestFinal_ex(self.ctx.ptr, res.as_mut_ptr(), ptr::null_mut())
}; };

6
src/crypto/hmac.rs
View File

@ -22,7 +22,7 @@ use ffi;
pub struct HMAC { pub struct HMAC {
ctx: ffi::HMAC_CTX, ctx: ffi::HMAC_CTX,
len: uint, len: u32,
} }
#[allow(non_snake_case)] #[allow(non_snake_case)]
@ -53,10 +53,10 @@ impl HMAC {
pub fn finalize(&mut self) -> Vec<u8> { pub fn finalize(&mut self) -> Vec<u8> {
unsafe { unsafe {
let mut res: Vec<u8> = repeat(0).take(self.len).collect(); let mut res: Vec<u8> = repeat(0).take(self.len as usize).collect();
let mut outlen = 0; let mut outlen = 0;
ffi::HMAC_Final(&mut self.ctx, res.as_mut_ptr(), &mut outlen); ffi::HMAC_Final(&mut self.ctx, res.as_mut_ptr(), &mut outlen);
assert!(self.len == outlen as uint); assert!(self.len == outlen as u32);
res res
} }
} }

26
src/crypto/pkcs5.rs
View File

@ -2,7 +2,7 @@ use libc::c_int;
use ffi; use ffi;
/// Derives a key from a password and salt using the PBKDF2-HMAC-SHA1 algorithm. /// Derives a key from a password and salt using the PBKDF2-HMAC-SHA1 algorithm.
pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint, keylen: uint) -> Vec<u8> { pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: usize, keylen: usize) -> Vec<u8> {
unsafe { unsafe {
assert!(iter >= 1); assert!(iter >= 1);
assert!(keylen >= 1); assert!(keylen >= 1);
@ -35,8 +35,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"password", "password",
"salt".as_bytes(), "salt".as_bytes(),
1u, 1,
20u 20
), ),
vec!( vec!(
0x0c_u8, 0x60_u8, 0xc8_u8, 0x0f_u8, 0x96_u8, 0x1f_u8, 0x0e_u8, 0x0c_u8, 0x60_u8, 0xc8_u8, 0x0f_u8, 0x96_u8, 0x1f_u8, 0x0e_u8,
@ -49,8 +49,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"password", "password",
"salt".as_bytes(), "salt".as_bytes(),
2u, 2,
20u 20
), ),
vec!( vec!(
0xea_u8, 0x6c_u8, 0x01_u8, 0x4d_u8, 0xc7_u8, 0x2d_u8, 0x6f_u8, 0xea_u8, 0x6c_u8, 0x01_u8, 0x4d_u8, 0xc7_u8, 0x2d_u8, 0x6f_u8,
@ -63,8 +63,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"password", "password",
"salt".as_bytes(), "salt".as_bytes(),
4096u, 4096,
20u 20
), ),
vec!( vec!(
0x4b_u8, 0x00_u8, 0x79_u8, 0x01_u8, 0xb7_u8, 0x65_u8, 0x48_u8, 0x4b_u8, 0x00_u8, 0x79_u8, 0x01_u8, 0xb7_u8, 0x65_u8, 0x48_u8,
@ -77,8 +77,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"password", "password",
"salt".as_bytes(), "salt".as_bytes(),
16777216u, 16777216,
20u 20
), ),
vec!( vec!(
0xee_u8, 0xfe_u8, 0x3d_u8, 0x61_u8, 0xcd_u8, 0x4d_u8, 0xa4_u8, 0xee_u8, 0xfe_u8, 0x3d_u8, 0x61_u8, 0xcd_u8, 0x4d_u8, 0xa4_u8,
@ -91,8 +91,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"passwordPASSWORDpassword", "passwordPASSWORDpassword",
"saltSALTsaltSALTsaltSALTsaltSALTsalt".as_bytes(), "saltSALTsaltSALTsaltSALTsaltSALTsalt".as_bytes(),
4096u, 4096,
25u 25
), ),
vec!( vec!(
0x3d_u8, 0x2e_u8, 0xec_u8, 0x4f_u8, 0xe4_u8, 0x1c_u8, 0x84_u8, 0x3d_u8, 0x2e_u8, 0xec_u8, 0x4f_u8, 0xe4_u8, 0x1c_u8, 0x84_u8,
@ -106,8 +106,8 @@ mod tests {
super::pbkdf2_hmac_sha1( super::pbkdf2_hmac_sha1(
"pass\x00word", "pass\x00word",
"sa\x00lt".as_bytes(), "sa\x00lt".as_bytes(),
4096u, 4096,
16u 16
), ),
vec!( vec!(
0x56_u8, 0xfa_u8, 0x6a_u8, 0xa7_u8, 0x55_u8, 0x48_u8, 0x09_u8, 0x56_u8, 0xfa_u8, 0x6a_u8, 0xa7_u8, 0x55_u8, 0x48_u8, 0x09_u8,

40
src/crypto/pkey.rs
View File

@ -72,11 +72,11 @@ impl PKey {
let rsa = ffi::EVP_PKEY_get1_RSA(self.evp); let rsa = ffi::EVP_PKEY_get1_RSA(self.evp);
let len = f(rsa, ptr::null()); let len = f(rsa, ptr::null());
if len < 0 as c_int { return vec!(); } if len < 0 as c_int { return vec!(); }
let mut s = repeat(0u8).take(len as uint).collect::<Vec<_>>(); let mut s = repeat(0u8).take(len as usize).collect::<Vec<_>>();
let r = f(rsa, &s.as_mut_ptr()); let r = f(rsa, &s.as_mut_ptr());
s.truncate(r as uint); s.truncate(r as usize);
s s
} }
} }
@ -89,11 +89,11 @@ impl PKey {
} }
} }
pub fn gen(&mut self, keysz: uint) { pub fn gen(&mut self, keysz: usize) {
unsafe { unsafe {
let rsa = ffi::RSA_generate_key( let rsa = ffi::RSA_generate_key(
keysz as c_uint, keysz as c_uint,
65537u as c_uint, 65537 as c_uint,
ptr::null(), ptr::null(),
ptr::null() ptr::null()
); );
@ -155,9 +155,9 @@ impl PKey {
/** /**
* Returns the size of the public key modulus. * Returns the size of the public key modulus.
*/ */
pub fn size(&self) -> uint { pub fn size(&self) -> usize {
unsafe { unsafe {
ffi::RSA_size(ffi::EVP_PKEY_get1_RSA(self.evp)) as uint ffi::RSA_size(ffi::EVP_PKEY_get1_RSA(self.evp)) as usize
} }
} }
@ -193,13 +193,13 @@ impl PKey {
* Returns the maximum amount of data that can be encrypted by an encrypt() * Returns the maximum amount of data that can be encrypted by an encrypt()
* call. * call.
*/ */
pub fn max_data(&self) -> uint { pub fn max_data(&self) -> usize {
unsafe { unsafe {
let rsa = ffi::EVP_PKEY_get1_RSA(self.evp); let rsa = ffi::EVP_PKEY_get1_RSA(self.evp);
let len = ffi::RSA_size(rsa); let len = ffi::RSA_size(rsa);
// 41 comes from RSA_public_encrypt(3) for OAEP // 41 comes from RSA_public_encrypt(3) for OAEP
len as uint - 41u len as usize - 41
} }
} }
@ -210,7 +210,7 @@ impl PKey {
assert!(s.len() < self.max_data()); assert!(s.len() < self.max_data());
let mut r = repeat(0u8).take(len as uint + 1).collect::<Vec<_>>(); let mut r = repeat(0u8).take(len as usize + 1).collect::<Vec<_>>();
let rv = ffi::RSA_public_encrypt( let rv = ffi::RSA_public_encrypt(
s.len() as c_uint, s.len() as c_uint,
@ -222,7 +222,7 @@ impl PKey {
if rv < 0 as c_int { if rv < 0 as c_int {
vec!() vec!()
} else { } else {
r.truncate(rv as uint); r.truncate(rv as usize);
r r
} }
} }
@ -235,7 +235,7 @@ impl PKey {
assert_eq!(s.len() as c_uint, ffi::RSA_size(rsa)); assert_eq!(s.len() as c_uint, ffi::RSA_size(rsa));
let mut r = repeat(0u8).take(len as uint + 1).collect::<Vec<_>>(); let mut r = repeat(0u8).take(len as usize + 1).collect::<Vec<_>>();
let rv = ffi::RSA_private_decrypt( let rv = ffi::RSA_private_decrypt(
s.len() as c_uint, s.len() as c_uint,
@ -247,7 +247,7 @@ impl PKey {
if rv < 0 as c_int { if rv < 0 as c_int {
vec!() vec!()
} else { } else {
r.truncate(rv as uint); r.truncate(rv as usize);
r r
} }
} }
@ -280,7 +280,7 @@ impl PKey {
unsafe { unsafe {
let rsa = ffi::EVP_PKEY_get1_RSA(self.evp); let rsa = ffi::EVP_PKEY_get1_RSA(self.evp);
let mut len = ffi::RSA_size(rsa); let mut len = ffi::RSA_size(rsa);
let mut r = repeat(0u8).take(len as uint + 1).collect::<Vec<_>>(); let mut r = repeat(0u8).take(len as usize + 1).collect::<Vec<_>>();
let rv = ffi::RSA_sign( let rv = ffi::RSA_sign(
openssl_hash_nid(hash), openssl_hash_nid(hash),
@ -293,7 +293,7 @@ impl PKey {
if rv < 0 as c_int { if rv < 0 as c_int {
vec!() vec!()
} else { } else {
r.truncate(len as uint); r.truncate(len as usize);
r r
} }
} }
@ -337,7 +337,7 @@ mod tests {
fn test_gen_pub() { fn test_gen_pub() {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
k0.gen(512u); k0.gen(512);
k1.load_pub(k0.save_pub().as_slice()); k1.load_pub(k0.save_pub().as_slice());
assert_eq!(k0.save_pub(), k1.save_pub()); assert_eq!(k0.save_pub(), k1.save_pub());
assert_eq!(k0.size(), k1.size()); assert_eq!(k0.size(), k1.size());
@ -355,7 +355,7 @@ mod tests {
fn test_gen_priv() { fn test_gen_priv() {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
k0.gen(512u); k0.gen(512);
k1.load_priv(k0.save_priv().as_slice()); k1.load_priv(k0.save_priv().as_slice());
assert_eq!(k0.save_priv(), k1.save_priv()); assert_eq!(k0.save_priv(), k1.save_priv());
assert_eq!(k0.size(), k1.size()); assert_eq!(k0.size(), k1.size());
@ -374,7 +374,7 @@ mod tests {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8); let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
k0.gen(512u); k0.gen(512);
k1.load_pub(k0.save_pub().as_slice()); k1.load_pub(k0.save_pub().as_slice());
let emsg = k1.encrypt(msg.as_slice()); let emsg = k1.encrypt(msg.as_slice());
let dmsg = k0.decrypt(emsg.as_slice()); let dmsg = k0.decrypt(emsg.as_slice());
@ -386,7 +386,7 @@ mod tests {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8); let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
k0.gen(512u); k0.gen(512);
k1.load_pub(k0.save_pub().as_slice()); k1.load_pub(k0.save_pub().as_slice());
let emsg = k1.encrypt_with_padding(msg.as_slice(), super::EncryptionPadding::PKCS1v15); let emsg = k1.encrypt_with_padding(msg.as_slice(), super::EncryptionPadding::PKCS1v15);
let dmsg = k0.decrypt_with_padding(emsg.as_slice(), super::EncryptionPadding::PKCS1v15); let dmsg = k0.decrypt_with_padding(emsg.as_slice(), super::EncryptionPadding::PKCS1v15);
@ -398,7 +398,7 @@ mod tests {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8); let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
k0.gen(512u); k0.gen(512);
k1.load_pub(k0.save_pub().as_slice()); k1.load_pub(k0.save_pub().as_slice());
let sig = k0.sign(msg.as_slice()); let sig = k0.sign(msg.as_slice());
let rv = k1.verify(msg.as_slice(), sig.as_slice()); let rv = k1.verify(msg.as_slice(), sig.as_slice());
@ -410,7 +410,7 @@ mod tests {
let mut k0 = super::PKey::new(); let mut k0 = super::PKey::new();
let mut k1 = super::PKey::new(); let mut k1 = super::PKey::new();
let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8); let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
k0.gen(512u); k0.gen(512);
k1.load_pub(k0.save_pub().as_slice()); k1.load_pub(k0.save_pub().as_slice());
let sig = k0.sign_with_hash(msg.as_slice(), MD5); let sig = k0.sign_with_hash(msg.as_slice(), MD5);

6
src/crypto/rand.rs
View File

@ -1,7 +1,7 @@
use libc::c_int; use libc::c_int;
use ffi; use ffi;
pub fn rand_bytes(len: uint) -> Vec<u8> { pub fn rand_bytes(len: usize) -> Vec<u8> {
unsafe { unsafe {
let mut out = Vec::with_capacity(len); let mut out = Vec::with_capacity(len);
@ -21,7 +21,7 @@ mod tests {
#[test] #[test]
fn test_rand_bytes() { fn test_rand_bytes() {
let bytes = rand_bytes(32u); let bytes = rand_bytes(32);
println!("{}", bytes); println!("{:?}", bytes);
} }
} }

41
src/crypto/symm.rs
View File

@ -31,24 +31,24 @@ pub enum Type {
RC4_128, RC4_128,
} }
fn evpc(t: Type) -> (*const ffi::EVP_CIPHER, uint, uint) { fn evpc(t: Type) -> (*const ffi::EVP_CIPHER, u32, u32) {
unsafe { unsafe {
match t { match t {
Type::AES_128_ECB => (ffi::EVP_aes_128_ecb(), 16u, 16u), Type::AES_128_ECB => (ffi::EVP_aes_128_ecb(), 16, 16),
Type::AES_128_CBC => (ffi::EVP_aes_128_cbc(), 16u, 16u), Type::AES_128_CBC => (ffi::EVP_aes_128_cbc(), 16, 16),
#[cfg(feature = "aes_xts")] #[cfg(feature = "aes_xts")]
Type::AES_128_XTS => (ffi::EVP_aes_128_xts(), 32u, 16u), Type::AES_128_XTS => (ffi::EVP_aes_128_xts(), 32, 16),
// AES_128_CTR => (EVP_aes_128_ctr(), 16u, 0u), // AES_128_CTR => (EVP_aes_128_ctr(), 16, 0),
//AES_128_GCM => (EVP_aes_128_gcm(), 16u, 16u), //AES_128_GCM => (EVP_aes_128_gcm(), 16, 16),
Type::AES_256_ECB => (ffi::EVP_aes_256_ecb(), 32u, 16u), Type::AES_256_ECB => (ffi::EVP_aes_256_ecb(), 32, 16),
Type::AES_256_CBC => (ffi::EVP_aes_256_cbc(), 32u, 16u), Type::AES_256_CBC => (ffi::EVP_aes_256_cbc(), 32, 16),
#[cfg(feature = "aes_xts")] #[cfg(feature = "aes_xts")]
Type::AES_256_XTS => (ffi::EVP_aes_256_xts(), 64u, 16u), Type::AES_256_XTS => (ffi::EVP_aes_256_xts(), 64, 16),
// AES_256_CTR => (EVP_aes_256_ctr(), 32u, 0u), // AES_256_CTR => (EVP_aes_256_ctr(), 32, 0),
//AES_256_GCM => (EVP_aes_256_gcm(), 32u, 16u), //AES_256_GCM => (EVP_aes_256_gcm(), 32, 16),
Type::RC4_128 => (ffi::EVP_rc4(), 16u, 0u), Type::RC4_128 => (ffi::EVP_rc4(), 16, 0),
} }
} }
} }
@ -57,8 +57,8 @@ fn evpc(t: Type) -> (*const ffi::EVP_CIPHER, uint, uint) {
pub struct Crypter { pub struct Crypter {
evp: *const ffi::EVP_CIPHER, evp: *const ffi::EVP_CIPHER,
ctx: *mut ffi::EVP_CIPHER_CTX, ctx: *mut ffi::EVP_CIPHER_CTX,
keylen: uint, keylen: u32,
blocksize: uint blocksize: u32,
} }
impl Crypter { impl Crypter {
@ -92,7 +92,7 @@ impl Crypter {
Mode::Encrypt => 1 as c_int, Mode::Encrypt => 1 as c_int,
Mode::Decrypt => 0 as c_int, Mode::Decrypt => 0 as c_int,
}; };
assert_eq!(key.len(), self.keylen); assert_eq!(key.len(), self.keylen as usize);
ffi::EVP_CipherInit( ffi::EVP_CipherInit(
self.ctx, self.ctx,
@ -110,8 +110,9 @@ impl Crypter {
*/ */
pub fn update(&self, data: &[u8]) -> Vec<u8> { pub fn update(&self, data: &[u8]) -> Vec<u8> {
unsafe { unsafe {
let mut res = repeat(0u8).take(data.len() + self.blocksize).collect::<Vec<_>>(); let sum = data.len() + (self.blocksize as usize);
let mut reslen = (data.len() + self.blocksize) as u32; let mut res = repeat(0u8).take(sum).collect::<Vec<_>>();
let mut reslen = sum as u32;
ffi::EVP_CipherUpdate( ffi::EVP_CipherUpdate(
self.ctx, self.ctx,
@ -121,7 +122,7 @@ impl Crypter {
data.len() as c_int data.len() as c_int
); );
res.truncate(reslen as uint); res.truncate(reslen as usize);
res res
} }
} }
@ -131,14 +132,14 @@ impl Crypter {
*/ */
pub fn finalize(&self) -> Vec<u8> { pub fn finalize(&self) -> Vec<u8> {
unsafe { unsafe {
let mut res = repeat(0u8).take(self.blocksize).collect::<Vec<_>>(); let mut res = repeat(0u8).take(self.blocksize as usize).collect::<Vec<_>>();
let mut reslen = self.blocksize as c_int; let mut reslen = self.blocksize as c_int;
ffi::EVP_CipherFinal(self.ctx, ffi::EVP_CipherFinal(self.ctx,
res.as_mut_ptr(), res.as_mut_ptr(),
&mut reslen); &mut reslen);
res.truncate(reslen as uint); res.truncate(reslen as usize);
res res
} }
} }

3
src/lib.rs
View File

@ -1,4 +1,5 @@
#![feature(unsafe_destructor, old_orphan_check)] #![feature(unsafe_destructor)]
#![allow(unstable)]
#![crate_name="openssl"] #![crate_name="openssl"]
#![crate_type="rlib"] #![crate_type="rlib"]
#![crate_type="dylib"] #![crate_type="dylib"]

18
src/ssl/mod.rs
View File

@ -215,7 +215,7 @@ impl SslContext {
pub fn set_verify_with_data<T>(&mut self, mode: SslVerifyMode, pub fn set_verify_with_data<T>(&mut self, mode: SslVerifyMode,
verify: VerifyCallbackData<T>, verify: VerifyCallbackData<T>,
data: T) { data: T) {
let data = box data; let data = Box::new(data);
unsafe { unsafe {
ffi::SSL_CTX_set_ex_data(self.ctx.0, VERIFY_IDX, ffi::SSL_CTX_set_ex_data(self.ctx.0, VERIFY_IDX,
mem::transmute(Some(verify))); mem::transmute(Some(verify)));
@ -228,7 +228,7 @@ impl SslContext {
} }
/// Sets verification depth /// Sets verification depth
pub fn set_verify_depth(&mut self, depth: uint) { pub fn set_verify_depth(&mut self, depth: u32) {
unsafe { unsafe {
ffi::SSL_CTX_set_verify_depth(self.ctx.0, depth as c_int); ffi::SSL_CTX_set_verify_depth(self.ctx.0, depth as c_int);
} }
@ -280,7 +280,7 @@ struct MemBioRef<'ssl> {
} }
impl<'ssl> MemBioRef<'ssl> { impl<'ssl> MemBioRef<'ssl> {
fn read(&mut self, buf: &mut [u8]) -> Option<uint> { fn read(&mut self, buf: &mut [u8]) -> Option<usize> {
(&mut self.bio as &mut Reader).read(buf).ok() (&mut self.bio as &mut Reader).read(buf).ok()
} }
@ -350,7 +350,7 @@ impl Ssl {
fn get_error(&self, ret: c_int) -> LibSslError { fn get_error(&self, ret: c_int) -> LibSslError {
let err = unsafe { ffi::SSL_get_error(self.ssl.0, ret) }; let err = unsafe { ffi::SSL_get_error(self.ssl.0, ret) };
match FromPrimitive::from_int(err as int) { match FromPrimitive::from_int(err as isize) {
Some(err) => err, Some(err) => err,
None => unreachable!() None => unreachable!()
} }
@ -421,7 +421,7 @@ impl<S: Stream> SslStream<S> {
// We're just using this as a buffer, so there's no reason to pay // We're just using this as a buffer, so there's no reason to pay
// to memset it // to memset it
buf: { buf: {
const CAP: uint = 16 * 1024; const CAP: usize = 16 * 1024;
let mut v = Vec::with_capacity(CAP); let mut v = Vec::with_capacity(CAP);
unsafe { v.set_len(CAP); } unsafe { v.set_len(CAP); }
v v
@ -529,9 +529,9 @@ impl<S: Stream> SslStream<S> {
} }
impl<S: Stream> Reader for SslStream<S> { impl<S: Stream> Reader for SslStream<S> {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match self.in_retry_wrapper(|ssl| { ssl.read(buf) }) { match self.in_retry_wrapper(|ssl| { ssl.read(buf) }) {
Ok(len) => Ok(len as uint), Ok(len) => Ok(len as usize),
Err(SslSessionClosed) => Err(SslSessionClosed) =>
Err(IoError { Err(IoError {
kind: EndOfFile, kind: EndOfFile,
@ -552,7 +552,7 @@ impl<S: Stream> Writer for SslStream<S> {
ssl.write(buf.split_at(start).1) ssl.write(buf.split_at(start).1)
}); });
match ret { match ret {
Ok(len) => start += len as uint, Ok(len) => start += len as usize,
_ => unreachable!() _ => unreachable!()
} }
try!(self.write_through()); try!(self.write_through());
@ -575,7 +575,7 @@ pub enum MaybeSslStream<S> where S: Stream {
} }
impl<S> Reader for MaybeSslStream<S> where S: Stream { impl<S> Reader for MaybeSslStream<S> where S: Stream {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match *self { match *self {
MaybeSslStream::Ssl(ref mut s) => s.read(buf), MaybeSslStream::Ssl(ref mut s) => s.read(buf),
MaybeSslStream::Normal(ref mut s) => s.read(buf), MaybeSslStream::Normal(ref mut s) => s.read(buf),

16
src/x509/mod.rs
View File

@ -173,8 +173,8 @@ impl<'a, T: AsStr<'a>> ToStr for Vec<T> {
/// # let _ = fs::unlink(&pkey_path); /// # let _ = fs::unlink(&pkey_path);
/// ``` /// ```
pub struct X509Generator { pub struct X509Generator {
bits: uint, bits: u32,
days: uint, days: u32,
CN: String, CN: String,
key_usage: Vec<KeyUsage>, key_usage: Vec<KeyUsage>,
ext_key_usage: Vec<ExtKeyUsage>, ext_key_usage: Vec<ExtKeyUsage>,
@ -203,13 +203,13 @@ impl X509Generator {
} }
/// Sets desired bit length /// Sets desired bit length
pub fn set_bitlength(mut self, bits: uint) -> X509Generator { pub fn set_bitlength(mut self, bits: u32) -> X509Generator {
self.bits = bits; self.bits = bits;
self self
} }
/// Sets certificate validity period in days since today /// Sets certificate validity period in days since today
pub fn set_valid_period(mut self, days: uint) -> X509Generator { pub fn set_valid_period(mut self, days: u32) -> X509Generator {
self.days = days; self.days = days;
self self
} }
@ -288,7 +288,7 @@ impl X509Generator {
ffi::init(); ffi::init();
let mut p_key = PKey::new(); let mut p_key = PKey::new();
p_key.gen(self.bits); p_key.gen(self.bits as usize);
unsafe { unsafe {
let x509 = ffi::X509_new(); let x509 = ffi::X509_new();
@ -386,7 +386,7 @@ impl<'ctx> X509<'ctx> {
/// Returns certificate fingerprint calculated using provided hash /// Returns certificate fingerprint calculated using provided hash
pub fn fingerprint(&self, hash_type: HashType) -> Option<Vec<u8>> { pub fn fingerprint(&self, hash_type: HashType) -> Option<Vec<u8>> {
let (evp, len) = evpmd(hash_type); let (evp, len) = evpmd(hash_type);
let v: Vec<u8> = repeat(0).take(len).collect(); let v: Vec<u8> = repeat(0).take(len as usize).collect();
let act_len: c_uint = 0; let act_len: c_uint = 0;
let res = unsafe { let res = unsafe {
ffi::X509_digest(self.handle, evp, mem::transmute(v.as_ptr()), ffi::X509_digest(self.handle, evp, mem::transmute(v.as_ptr()),
@ -396,7 +396,7 @@ impl<'ctx> X509<'ctx> {
match res { match res {
0 => None, 0 => None,
_ => { _ => {
let act_len = act_len as uint; let act_len = act_len as u32;
match len.cmp(&act_len) { match len.cmp(&act_len) {
Ordering::Greater => None, Ordering::Greater => None,
Ordering::Equal => Some(v), Ordering::Equal => Some(v),
@ -514,7 +514,7 @@ make_validation_error!(X509_V_OK,
#[test] #[test]
fn test_negative_serial() { fn test_negative_serial() {
// I guess that's enough to get a random negative number // I guess that's enough to get a random negative number
for _ in range(0u, 1000) { for _ in range(0, 1000) {
assert!(X509Generator::random_serial() > 0, "All serials should be positive"); assert!(X509Generator::random_serial() > 0, "All serials should be positive");
} }
} }