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

Merge branch 'master' of https://github.com/kballard/rustcrypto

This commit is contained in:
Erick Tryzelaar 2013-12-18 07:30:16 -08:00
parent 5bd84e633f bcdc23c359
commit 4e0257ab59
8 changed files with 121 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
crypto.rs
View File

@ -16,10 +16,13 @@
*/ */
#[link(name = "crypto", #[link(name = "crypto",
package_id = "crypto",
vers = "0.3", vers = "0.3",
uuid = "38297409-b4c2-4499-8131-a99a7e44dad3")]; uuid = "38297409-b4c2-4499-8131-a99a7e44dad3")];
#[crate_type = "lib"]; #[crate_type = "lib"];
#[feature(globs)];
pub mod hash; pub mod hash;
pub mod hex; pub mod hex;
pub mod hmac; pub mod hmac;

36
hash.rs
View File

@ -22,21 +22,21 @@ mod libcrypto {
use super::*; use super::*;
use std::libc::c_uint; use std::libc::c_uint;
#[link_args = "-lcrypto"] #[link(name = "crypto")]
extern { extern {
fn EVP_MD_CTX_create() -> EVP_MD_CTX; pub fn EVP_MD_CTX_create() -> EVP_MD_CTX;
fn EVP_MD_CTX_destroy(ctx: EVP_MD_CTX); pub fn EVP_MD_CTX_destroy(ctx: EVP_MD_CTX);
fn EVP_md5() -> EVP_MD; pub fn EVP_md5() -> EVP_MD;
fn EVP_sha1() -> EVP_MD; pub fn EVP_sha1() -> EVP_MD;
fn EVP_sha224() -> EVP_MD; pub fn EVP_sha224() -> EVP_MD;
fn EVP_sha256() -> EVP_MD; pub fn EVP_sha256() -> EVP_MD;
fn EVP_sha384() -> EVP_MD; pub fn EVP_sha384() -> EVP_MD;
fn EVP_sha512() -> EVP_MD; pub fn EVP_sha512() -> EVP_MD;
fn EVP_DigestInit(ctx: EVP_MD_CTX, typ: EVP_MD); pub fn EVP_DigestInit(ctx: EVP_MD_CTX, typ: EVP_MD);
fn EVP_DigestUpdate(ctx: EVP_MD_CTX, data: *u8, n: c_uint); pub fn EVP_DigestUpdate(ctx: EVP_MD_CTX, data: *u8, n: c_uint);
fn EVP_DigestFinal(ctx: EVP_MD_CTX, res: *mut u8, n: *u32); pub fn EVP_DigestFinal(ctx: EVP_MD_CTX, res: *mut u8, n: *u32);
} }
} }
@ -72,11 +72,11 @@ impl Hasher {
/// Update this hasher with more input bytes /// Update this hasher with more input bytes
pub fn update(&self, data: &[u8]) { pub fn update(&self, data: &[u8]) {
do data.as_imm_buf |pdata, len| { data.as_imm_buf(|pdata, len| {
unsafe { unsafe {
libcrypto::EVP_DigestUpdate(self.ctx, pdata, len as c_uint) libcrypto::EVP_DigestUpdate(self.ctx, pdata, len as c_uint)
} }
} });
} }
/** /**
@ -85,17 +85,17 @@ impl Hasher {
*/ */
pub fn final(&self) -> ~[u8] { pub fn final(&self) -> ~[u8] {
let mut res = vec::from_elem(self.len, 0u8); let mut res = vec::from_elem(self.len, 0u8);
do res.as_mut_buf |pres, _len| { res.as_mut_buf(|pres, _len| {
unsafe { unsafe {
libcrypto::EVP_DigestFinal(self.ctx, pres, ptr::null()); libcrypto::EVP_DigestFinal(self.ctx, pres, ptr::null());
} }
} });
res res
} }
} }
impl Drop for Hasher { impl Drop for Hasher {
fn drop(&self) { fn drop(&mut self) {
unsafe { unsafe {
libcrypto::EVP_MD_CTX_destroy(self.ctx); libcrypto::EVP_MD_CTX_destroy(self.ctx);
} }
@ -134,7 +134,7 @@ mod tests {
let calced = calced_raw.to_hex(); let calced = calced_raw.to_hex();
if calced != hashtest.expected_output { if calced != hashtest.expected_output {
println(fmt!("Test failed - %s != %s", calced, hashtest.expected_output)); println!("Test failed - {} != {}", calced, hashtest.expected_output);
} }
assert!(calced == hashtest.expected_output); assert!(calced == hashtest.expected_output);

8
hex.rs
View File

@ -20,10 +20,10 @@ pub trait ToHex {
fn to_hex(&self) -> ~str; fn to_hex(&self) -> ~str;
} }
impl<'self> ToHex for &'self [u8] { impl<'a> ToHex for &'a [u8] {
fn to_hex(&self) -> ~str { fn to_hex(&self) -> ~str {
let chars = "0123456789ABCDEF".iter().collect::<~[char]>(); let chars = "0123456789ABCDEF".chars().collect::<~[char]>();
let mut s = ~""; let mut s = ~"";
@ -46,11 +46,11 @@ pub trait FromHex {
fn from_hex(&self) -> ~[u8]; fn from_hex(&self) -> ~[u8];
} }
impl<'self> FromHex for &'self str { impl<'a> FromHex for &'a str {
fn from_hex(&self) -> ~[u8] { fn from_hex(&self) -> ~[u8] {
let mut vec = vec::with_capacity(self.len() / 2); let mut vec = vec::with_capacity(self.len() / 2);
for (i,c) in self.iter().enumerate() { for (i,c) in self.chars().enumerate() {
let nibble = let nibble =
if c >= '0' && c <= '9' { (c as u8) - 0x30 } if c >= '0' && c <= '9' { (c as u8) - 0x30 }
else if c >= 'a' && c <= 'f' { (c as u8) - (0x61 - 10) } else if c >= 'a' && c <= 'f' { (c as u8) - (0x61 - 10) }

19
hmac.rs
View File

@ -27,8 +27,7 @@ pub struct HMAC_CTX {
key: [libc::c_uchar, ..128] key: [libc::c_uchar, ..128]
} }
#[link_args = "-lcrypto"] #[link(name = "crypto")]
#[abi = "cdecl"]
extern { extern {
fn HMAC_CTX_init(ctx: *mut HMAC_CTX, key: *u8, keylen: libc::c_int, md: EVP_MD); fn HMAC_CTX_init(ctx: *mut HMAC_CTX, key: *u8, keylen: libc::c_int, md: EVP_MD);
@ -68,9 +67,9 @@ pub fn HMAC(ht: HashType, key: ~[u8]) -> HMAC {
impl HMAC { impl HMAC {
pub fn update(&mut self, data: &[u8]) { pub fn update(&mut self, data: &[u8]) {
unsafe { unsafe {
do data.as_imm_buf |pdata, len| { data.as_imm_buf(|pdata, len| {
HMAC_Update(&mut self.ctx, pdata, len as libc::c_uint) HMAC_Update(&mut self.ctx, pdata, len as libc::c_uint)
} });
} }
} }
@ -78,19 +77,11 @@ impl HMAC {
unsafe { unsafe {
let mut res = vec::from_elem(self.len, 0u8); let mut res = vec::from_elem(self.len, 0u8);
let mut outlen: libc::c_uint = 0; let mut outlen: libc::c_uint = 0;
do res.as_mut_buf |pres, _len| { res.as_mut_buf(|pres, _len| {
HMAC_Final(&mut self.ctx, pres, &mut outlen); HMAC_Final(&mut self.ctx, pres, &mut outlen);
assert!(self.len == outlen as uint) assert!(self.len == outlen as uint)
} });
res res
} }
} }
} }
fn main() {
let mut h = HMAC(SHA512, ~[00u8]);
h.update([00u8]);
println(fmt!("%?", h.final()))
}

26
pkcs5.rs
View File

@ -4,28 +4,26 @@ use std::vec;
mod libcrypto { mod libcrypto {
use std::libc::c_int; use std::libc::c_int;
#[link_args = "-lcrypto"] #[link(name = "crypto")]
extern { extern {
fn PKCS5_PBKDF2_HMAC_SHA1(pass: *u8, passlen: c_int, pub fn PKCS5_PBKDF2_HMAC_SHA1(pass: *u8, passlen: c_int,
salt: *u8, saltlen: c_int, salt: *u8, saltlen: c_int,
iter: c_int, keylen: c_int, iter: c_int, keylen: c_int,
out: *mut u8) -> c_int; out: *mut u8) -> c_int;
} }
} }
#[doc = " /// 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, pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint,
keylen: uint) -> ~[u8] { keylen: uint) -> ~[u8] {
assert!(iter >= 1u); assert!(iter >= 1u);
assert!(keylen >= 1u); assert!(keylen >= 1u);
do pass.as_imm_buf |pass_buf, pass_len| { pass.as_imm_buf(|pass_buf, pass_len| {
do salt.as_imm_buf |salt_buf, salt_len| { salt.as_imm_buf(|salt_buf, salt_len| {
let mut out = vec::with_capacity(keylen); let mut out = vec::with_capacity(keylen);
do out.as_mut_buf |out_buf, _out_len| { out.as_mut_buf(|out_buf, _out_len| {
let r = unsafe { let r = unsafe {
libcrypto::PKCS5_PBKDF2_HMAC_SHA1( libcrypto::PKCS5_PBKDF2_HMAC_SHA1(
pass_buf, pass_len as c_int, pass_buf, pass_len as c_int,
@ -35,13 +33,13 @@ pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint,
}; };
if r != 1 as c_int { fail!(); } if r != 1 as c_int { fail!(); }
} });
unsafe { vec::raw::set_len(&mut out, keylen); } unsafe { vec::raw::set_len(&mut out, keylen); }
out out
} })
} })
} }
#[cfg(test)] #[cfg(test)]

86
pkey.rs
View File

@ -15,29 +15,29 @@ mod libcrypto {
use super::*; use super::*;
use std::libc::{c_char, c_int, c_uint}; use std::libc::{c_char, c_int, c_uint};
#[link_args = "-lcrypto"] #[link(name = "crypto")]
extern { extern {
fn EVP_PKEY_new() -> *EVP_PKEY; pub fn EVP_PKEY_new() -> *EVP_PKEY;
fn EVP_PKEY_free(k: *EVP_PKEY); pub fn EVP_PKEY_free(k: *EVP_PKEY);
fn EVP_PKEY_assign(pkey: *EVP_PKEY, typ: c_int, key: *c_char) -> c_int; pub fn EVP_PKEY_assign(pkey: *EVP_PKEY, typ: c_int, key: *c_char) -> c_int;
fn EVP_PKEY_get1_RSA(k: *EVP_PKEY) -> *RSA; pub fn EVP_PKEY_get1_RSA(k: *EVP_PKEY) -> *RSA;
fn i2d_PublicKey(k: *EVP_PKEY, buf: **mut u8) -> c_int; pub fn i2d_PublicKey(k: *EVP_PKEY, buf: **mut u8) -> c_int;
fn d2i_PublicKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY; pub fn d2i_PublicKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY;
fn i2d_PrivateKey(k: *EVP_PKEY, buf: **mut u8) -> c_int; pub fn i2d_PrivateKey(k: *EVP_PKEY, buf: **mut u8) -> c_int;
fn d2i_PrivateKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY; pub fn d2i_PrivateKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY;
fn RSA_generate_key(modsz: c_uint, e: c_uint, cb: *u8, cbarg: *u8) -> *RSA; pub fn RSA_generate_key(modsz: c_uint, e: c_uint, cb: *u8, cbarg: *u8) -> *RSA;
fn RSA_size(k: *RSA) -> c_uint; pub fn RSA_size(k: *RSA) -> c_uint;
fn RSA_public_encrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA, pub fn RSA_public_encrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA,
pad: c_int) -> c_int; pad: c_int) -> c_int;
fn RSA_private_decrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA, pub fn RSA_private_decrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA,
pad: c_int) -> c_int; pad: c_int) -> c_int;
fn RSA_sign(t: c_int, m: *u8, mlen: c_uint, sig: *mut u8, siglen: *mut c_uint, pub fn RSA_sign(t: c_int, m: *u8, mlen: c_uint, sig: *mut u8, siglen: *mut c_uint,
k: *RSA) -> c_int; k: *RSA) -> c_int;
fn RSA_verify(t: c_int, m: *u8, mlen: c_uint, sig: *u8, siglen: c_uint, pub fn RSA_verify(t: c_int, m: *u8, mlen: c_uint, sig: *u8, siglen: c_uint,
k: *RSA) -> c_int; k: *RSA) -> c_int;
} }
} }
@ -47,7 +47,7 @@ enum Parts {
Both Both
} }
#[doc = "Represents a role an asymmetric key might be appropriate for."] /// Represents a role an asymmetric key might be appropriate for.
pub enum Role { pub enum Role {
Encrypt, Encrypt,
Decrypt, Decrypt,
@ -55,7 +55,7 @@ pub enum Role {
Verify Verify
} }
#[doc = "Type of encryption padding to use."] /// Type of encryption padding to use.
pub enum EncryptionPadding { pub enum EncryptionPadding {
OAEP, OAEP,
PKCS1v15 PKCS1v15
@ -84,7 +84,7 @@ pub struct PKey {
priv parts: Parts, priv parts: Parts,
} }
///Represents a public key, optionally with a private key attached. /// Represents a public key, optionally with a private key attached.
impl PKey { impl PKey {
pub fn new() -> PKey { pub fn new() -> PKey {
PKey { PKey {
@ -99,9 +99,9 @@ impl PKey {
if len < 0 as c_int { return ~[]; } if len < 0 as c_int { return ~[]; }
let mut s = vec::from_elem(len as uint, 0u8); let mut s = vec::from_elem(len as uint, 0u8);
let r = do s.as_mut_buf |buf, _| { let r = s.as_mut_buf(|buf, _| {
f(self.evp, &buf) f(self.evp, &buf)
}; });
s.truncate(r as uint); s.truncate(r as uint);
s s
@ -109,13 +109,13 @@ impl PKey {
} }
fn _fromstr(&mut self, s: &[u8], f: extern "C" unsafe fn(c_int, **EVP_PKEY, **u8, c_uint) -> *EVP_PKEY) { fn _fromstr(&mut self, s: &[u8], f: extern "C" unsafe fn(c_int, **EVP_PKEY, **u8, c_uint) -> *EVP_PKEY) {
do s.as_imm_buf |ps, len| { s.as_imm_buf(|ps, len| {
let evp = ptr::null(); let evp = ptr::null();
unsafe { unsafe {
f(6 as c_int, &evp, &ps, len as c_uint); f(6 as c_int, &evp, &ps, len as c_uint);
} }
self.evp = evp; self.evp = evp;
} });
} }
pub fn gen(&mut self, keysz: uint) { pub fn gen(&mut self, keysz: uint) {
@ -228,8 +228,8 @@ impl PKey {
let mut r = vec::from_elem(len as uint + 1u, 0u8); let mut r = vec::from_elem(len as uint + 1u, 0u8);
let rv = do r.as_mut_buf |pr, _len| { let rv = r.as_mut_buf(|pr, _len| {
do s.as_imm_buf |ps, s_len| { s.as_imm_buf(|ps, s_len| {
libcrypto::RSA_public_encrypt( libcrypto::RSA_public_encrypt(
s_len as c_uint, s_len as c_uint,
ps, ps,
@ -237,8 +237,8 @@ impl PKey {
rsa, rsa,
openssl_padding_code(padding) openssl_padding_code(padding)
) )
} })
}; });
if rv < 0 as c_int { if rv < 0 as c_int {
~[] ~[]
} else { } else {
@ -257,8 +257,8 @@ impl PKey {
let mut r = vec::from_elem(len as uint + 1u, 0u8); let mut r = vec::from_elem(len as uint + 1u, 0u8);
let rv = do r.as_mut_buf |pr, _len| { let rv = r.as_mut_buf(|pr, _len| {
do s.as_imm_buf |ps, s_len| { s.as_imm_buf(|ps, s_len| {
libcrypto::RSA_private_decrypt( libcrypto::RSA_private_decrypt(
s_len as c_uint, s_len as c_uint,
ps, ps,
@ -266,8 +266,8 @@ impl PKey {
rsa, rsa,
openssl_padding_code(padding) openssl_padding_code(padding)
) )
} })
}; });
if rv < 0 as c_int { if rv < 0 as c_int {
~[] ~[]
@ -307,8 +307,8 @@ impl PKey {
let mut len = libcrypto::RSA_size(rsa); let mut len = libcrypto::RSA_size(rsa);
let mut r = vec::from_elem(len as uint + 1u, 0u8); let mut r = vec::from_elem(len as uint + 1u, 0u8);
let rv = do r.as_mut_buf |pr, _len| { let rv = r.as_mut_buf(|pr, _len| {
do s.as_imm_buf |ps, s_len| { s.as_imm_buf(|ps, s_len| {
libcrypto::RSA_sign( libcrypto::RSA_sign(
openssl_hash_nid(hash), openssl_hash_nid(hash),
ps, ps,
@ -316,8 +316,8 @@ impl PKey {
pr, pr,
&mut len, &mut len,
rsa) rsa)
} })
}; });
if rv < 0 as c_int { if rv < 0 as c_int {
~[] ~[]
@ -332,8 +332,8 @@ impl PKey {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp);
do m.as_imm_buf |pm, m_len| { m.as_imm_buf(|pm, m_len| {
do s.as_imm_buf |ps, s_len| { s.as_imm_buf(|ps, s_len| {
let rv = libcrypto::RSA_verify( let rv = libcrypto::RSA_verify(
openssl_hash_nid(hash), openssl_hash_nid(hash),
pm, pm,
@ -344,14 +344,14 @@ impl PKey {
); );
rv == 1 as c_int rv == 1 as c_int
} })
} })
} }
} }
} }
impl Drop for PKey { impl Drop for PKey {
fn drop(&self) { fn drop(&mut self) {
unsafe { unsafe {
libcrypto::EVP_PKEY_free(self.evp); libcrypto::EVP_PKEY_free(self.evp);
} }

10
rand.rs
View File

@ -4,19 +4,19 @@ use std::vec;
mod libcrypto { mod libcrypto {
use std::libc::c_int; use std::libc::c_int;
#[link_args = "-lcrypto"] #[link(name = "crypto")]
extern { extern {
fn RAND_bytes(buf: *mut u8, num: c_int) -> c_int; pub fn RAND_bytes(buf: *mut u8, num: c_int) -> c_int;
} }
} }
pub fn rand_bytes(len: uint) -> ~[u8] { pub fn rand_bytes(len: uint) -> ~[u8] {
let mut out = vec::with_capacity(len); let mut out = vec::with_capacity(len);
do out.as_mut_buf |out_buf, len| { out.as_mut_buf(|out_buf, len| {
let r = unsafe { libcrypto::RAND_bytes(out_buf, len as c_int) }; let r = unsafe { libcrypto::RAND_bytes(out_buf, len as c_int) };
if r != 1 as c_int { fail!() } if r != 1 as c_int { fail!() }
} });
unsafe { vec::raw::set_len(&mut out, len); } unsafe { vec::raw::set_len(&mut out, len); }
@ -30,6 +30,6 @@ mod tests {
#[test] #[test]
fn test_rand_bytes() { fn test_rand_bytes() {
let bytes = rand_bytes(32u); let bytes = rand_bytes(32u);
println(fmt!("%?", bytes)); println!("{:?}", bytes);
} }
} }

62
symm.rs
View File

@ -14,27 +14,27 @@ mod libcrypto {
extern { extern {
#[link_args = "-lcrypto"] #[link_args = "-lcrypto"]
fn EVP_CIPHER_CTX_new() -> EVP_CIPHER_CTX; pub fn EVP_CIPHER_CTX_new() -> EVP_CIPHER_CTX;
fn EVP_CIPHER_CTX_set_padding(ctx: EVP_CIPHER_CTX, padding: c_int); pub fn EVP_CIPHER_CTX_set_padding(ctx: EVP_CIPHER_CTX, padding: c_int);
fn EVP_CIPHER_CTX_free(ctx: EVP_CIPHER_CTX); pub fn EVP_CIPHER_CTX_free(ctx: EVP_CIPHER_CTX);
fn EVP_aes_128_ecb() -> EVP_CIPHER; pub fn EVP_aes_128_ecb() -> EVP_CIPHER;
fn EVP_aes_128_cbc() -> EVP_CIPHER; pub fn EVP_aes_128_cbc() -> EVP_CIPHER;
// fn EVP_aes_128_ctr() -> EVP_CIPHER; // pub fn EVP_aes_128_ctr() -> EVP_CIPHER;
// fn EVP_aes_128_gcm() -> EVP_CIPHER; // pub fn EVP_aes_128_gcm() -> EVP_CIPHER;
fn EVP_aes_256_ecb() -> EVP_CIPHER; pub fn EVP_aes_256_ecb() -> EVP_CIPHER;
fn EVP_aes_256_cbc() -> EVP_CIPHER; pub fn EVP_aes_256_cbc() -> EVP_CIPHER;
// fn EVP_aes_256_ctr() -> EVP_CIPHER; // pub fn EVP_aes_256_ctr() -> EVP_CIPHER;
// fn EVP_aes_256_gcm() -> EVP_CIPHER; // pub fn EVP_aes_256_gcm() -> EVP_CIPHER;
fn EVP_rc4() -> EVP_CIPHER; pub fn EVP_rc4() -> EVP_CIPHER;
fn EVP_CipherInit(ctx: EVP_CIPHER_CTX, evp: EVP_CIPHER, pub fn EVP_CipherInit(ctx: EVP_CIPHER_CTX, evp: EVP_CIPHER,
key: *u8, iv: *u8, mode: c_int); key: *u8, iv: *u8, mode: c_int);
fn EVP_CipherUpdate(ctx: EVP_CIPHER_CTX, outbuf: *mut u8, pub fn EVP_CipherUpdate(ctx: EVP_CIPHER_CTX, outbuf: *mut u8,
outlen: &mut c_uint, inbuf: *u8, inlen: c_int); outlen: &mut c_uint, inbuf: *u8, inlen: c_int);
fn EVP_CipherFinal(ctx: EVP_CIPHER_CTX, res: *mut u8, len: &mut c_int); pub fn EVP_CipherFinal(ctx: EVP_CIPHER_CTX, res: *mut u8, len: &mut c_int);
} }
} }
@ -115,8 +115,8 @@ impl Crypter {
}; };
assert_eq!(key.len(), self.keylen); assert_eq!(key.len(), self.keylen);
do key.as_imm_buf |pkey, _len| { key.as_imm_buf(|pkey, _len| {
do iv.as_imm_buf |piv, _len| { iv.as_imm_buf(|piv, _len| {
libcrypto::EVP_CipherInit( libcrypto::EVP_CipherInit(
self.ctx, self.ctx,
self.evp, self.evp,
@ -124,8 +124,8 @@ impl Crypter {
piv, piv,
mode mode
) )
} });
} });
} }
} }
@ -135,10 +135,10 @@ impl Crypter {
*/ */
pub fn update(&self, data: &[u8]) -> ~[u8] { pub fn update(&self, data: &[u8]) -> ~[u8] {
unsafe { unsafe {
do data.as_imm_buf |pdata, len| { data.as_imm_buf(|pdata, len| {
let mut res = vec::from_elem(len + self.blocksize, 0u8); let mut res = vec::from_elem(len + self.blocksize, 0u8);
let reslen = do res.as_mut_buf |pres, _len| { let reslen = res.as_mut_buf(|pres, _len| {
let mut reslen = (len + self.blocksize) as u32; let mut reslen = (len + self.blocksize) as u32;
libcrypto::EVP_CipherUpdate( libcrypto::EVP_CipherUpdate(
@ -150,11 +150,11 @@ impl Crypter {
); );
reslen reslen
}; });
res.truncate(reslen as uint); res.truncate(reslen as uint);
res res
} })
} }
} }
@ -165,11 +165,11 @@ impl Crypter {
unsafe { unsafe {
let mut res = vec::from_elem(self.blocksize, 0u8); let mut res = vec::from_elem(self.blocksize, 0u8);
let reslen = do res.as_mut_buf |pres, _len| { let reslen = res.as_mut_buf(|pres, _len| {
let mut reslen = self.blocksize as c_int; let mut reslen = self.blocksize as c_int;
libcrypto::EVP_CipherFinal(self.ctx, pres, &mut reslen); libcrypto::EVP_CipherFinal(self.ctx, pres, &mut reslen);
reslen reslen
}; });
res.truncate(reslen as uint); res.truncate(reslen as uint);
res res
@ -178,7 +178,7 @@ impl Crypter {
} }
impl Drop for Crypter { impl Drop for Crypter {
fn drop(&self) { fn drop(&mut self) {
unsafe { unsafe {
libcrypto::EVP_CIPHER_CTX_free(self.ctx); libcrypto::EVP_CIPHER_CTX_free(self.ctx);
} }
@ -251,13 +251,13 @@ mod tests {
let computed = cipher.update(pt.from_hex()) + cipher.final(); let computed = cipher.update(pt.from_hex()) + cipher.final();
if computed != expected { if computed != expected {
println(fmt!("Computed: %s", computed.to_hex())); println!("Computed: {}", computed.to_hex());
println(fmt!("Expected: %s", expected.to_hex())); println!("Expected: {}", expected.to_hex());
if computed.len() != expected.len() { if computed.len() != expected.len() {
println(fmt!("Lengths differ: %u in computed vs %u expected", println!("Lengths differ: {} in computed vs {} expected",
computed.len(), expected.len())); computed.len(), expected.len());
} }
fail!(~"test failure"); fail!("test failure");
} }
} }