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

Update for current incoming

This commit is contained in:
Kevin Ballard 2013-05-23 23:46:45 -07:00
parent 4e79896c96
commit 08cdf5fde4
8 changed files with 123 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crypto.rc
View File

@ -20,8 +20,6 @@
uuid = "38297409-b4c2-4499-8131-a99a7e44dad3")]; uuid = "38297409-b4c2-4499-8131-a99a7e44dad3")];
#[crate_type = "lib"]; #[crate_type = "lib"];
extern mod std; // FIXME https://github.com/mozilla/rust/issues/1127
pub mod hex; pub mod hex;
pub mod hash; pub mod hash;
pub mod hmac; pub mod hmac;

26
hash.rs
View File

@ -1,4 +1,4 @@
use core::libc::c_uint; use std::libc::c_uint;
pub enum HashType { pub enum HashType {
MD5, MD5,
@ -15,9 +15,9 @@ pub type EVP_MD_CTX = *libc::c_void;
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
pub type EVP_MD = *libc::c_void; pub type EVP_MD = *libc::c_void;
#[link_name = "crypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { #[link_args = "-lcrypto"]
extern {
fn EVP_MD_CTX_create() -> EVP_MD_CTX; fn EVP_MD_CTX_create() -> EVP_MD_CTX;
fn EVP_md5() -> EVP_MD; fn EVP_md5() -> EVP_MD;
@ -35,12 +35,12 @@ extern mod libcrypto {
pub fn evpmd(t: HashType) -> (EVP_MD, uint) { pub fn evpmd(t: HashType) -> (EVP_MD, uint) {
unsafe { unsafe {
match t { match t {
MD5 => (libcrypto::EVP_md5(), 16u), MD5 => (EVP_md5(), 16u),
SHA1 => (libcrypto::EVP_sha1(), 20u), SHA1 => (EVP_sha1(), 20u),
SHA224 => (libcrypto::EVP_sha224(), 28u), SHA224 => (EVP_sha224(), 28u),
SHA256 => (libcrypto::EVP_sha256(), 32u), SHA256 => (EVP_sha256(), 32u),
SHA384 => (libcrypto::EVP_sha384(), 48u), SHA384 => (EVP_sha384(), 48u),
SHA512 => (libcrypto::EVP_sha512(), 64u), SHA512 => (EVP_sha512(), 64u),
} }
} }
} }
@ -53,7 +53,7 @@ pub struct Hasher {
pub fn Hasher(ht: HashType) -> Hasher { pub fn Hasher(ht: HashType) -> Hasher {
unsafe { unsafe {
let ctx = libcrypto::EVP_MD_CTX_create(); let ctx = EVP_MD_CTX_create();
let (evp, mdlen) = evpmd(ht); let (evp, mdlen) = evpmd(ht);
let h = Hasher { evp: evp, ctx: ctx, len: mdlen }; let h = Hasher { evp: evp, ctx: ctx, len: mdlen };
h.init(); h.init();
@ -65,7 +65,7 @@ pub impl Hasher {
/// Initializes this hasher /// Initializes this hasher
fn init(&self) { fn init(&self) {
unsafe { unsafe {
libcrypto::EVP_DigestInit(self.ctx, self.evp); EVP_DigestInit(self.ctx, self.evp);
} }
} }
@ -73,7 +73,7 @@ pub impl Hasher {
fn update(&self, data: &[u8]) { fn update(&self, data: &[u8]) {
unsafe { unsafe {
do vec::as_imm_buf(data) |pdata, len| { do vec::as_imm_buf(data) |pdata, len| {
libcrypto::EVP_DigestUpdate(self.ctx, pdata, len as c_uint) EVP_DigestUpdate(self.ctx, pdata, len as c_uint)
} }
} }
} }
@ -86,7 +86,7 @@ pub impl Hasher {
unsafe { unsafe {
let mut res = vec::from_elem(self.len, 0u8); let mut res = vec::from_elem(self.len, 0u8);
do vec::as_mut_buf(res) |pres, _len| { do vec::as_mut_buf(res) |pres, _len| {
libcrypto::EVP_DigestFinal(self.ctx, pres, ptr::null()); EVP_DigestFinal(self.ctx, pres, ptr::null());
} }
res res
} }

2
hex.rs
View File

@ -23,7 +23,7 @@ pub trait ToHex {
impl<'self> ToHex for &'self [u8] { impl<'self> ToHex for &'self [u8] {
fn to_hex(&self) -> ~str { fn to_hex(&self) -> ~str {
let chars = str::to_chars(~"0123456789ABCDEF"); let chars = str::to_chars("0123456789ABCDEF");
let mut s = ~""; let mut s = ~"";

13
hmac.rs
View File

@ -26,10 +26,9 @@ pub struct HMAC_CTX {
key: [libc::c_uchar, ..128] key: [libc::c_uchar, ..128]
} }
#[link_name = "crypto"] #[link_args = "-lcrypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { 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);
fn HMAC_Update(ctx: *mut HMAC_CTX, input: *u8, len: libc::c_uint); fn HMAC_Update(ctx: *mut HMAC_CTX, input: *u8, len: libc::c_uint);
@ -56,7 +55,7 @@ pub fn HMAC(ht: HashType, key: ~[u8]) -> HMAC {
mut key: [0u8, .. 128] mut key: [0u8, .. 128]
}; };
libcrypto::HMAC_CTX_init(&mut ctx, HMAC_CTX_init(&mut ctx,
vec::raw::to_ptr(key), vec::raw::to_ptr(key),
key.len() as libc::c_int, key.len() as libc::c_int,
evp); evp);
@ -69,7 +68,7 @@ pub impl HMAC {
fn update(&mut self, data: &[u8]) { fn update(&mut self, data: &[u8]) {
unsafe { unsafe {
do vec::as_imm_buf(data) |pdata, len| { do vec::as_imm_buf(data) |pdata, len| {
libcrypto::HMAC_Update(&mut self.ctx, pdata, len as libc::c_uint) HMAC_Update(&mut self.ctx, pdata, len as libc::c_uint)
} }
} }
} }
@ -79,7 +78,7 @@ pub impl HMAC {
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 vec::as_mut_buf(res) |pres, _len| { do vec::as_mut_buf(res) |pres, _len| {
libcrypto::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
@ -90,7 +89,7 @@ pub impl HMAC {
fn main() { fn main() {
let mut h = HMAC(SHA512, ~[00u8]); let mut h = HMAC(SHA512, ~[00u8]);
h.update(~[00u8]); h.update([00u8]);
io::println(fmt!("%?", h.final())) io::println(fmt!("%?", h.final()))
} }

14
pkcs5.rs
View File

@ -1,12 +1,12 @@
use core::libc::c_int; use std::libc::c_int;
#[link_name = "crypto"] #[link_args = "-lcrypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { extern {
fn PKCS5_PBKDF2_HMAC_SHA1(pass: *u8, passlen: c_int, 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 = " #[doc = "
@ -23,7 +23,7 @@ pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint,
do vec::as_mut_buf(out) |out_buf, _out_len| { do vec::as_mut_buf(out) |out_buf, _out_len| {
unsafe { unsafe {
let r = libcrypto::PKCS5_PBKDF2_HMAC_SHA1( let r = PKCS5_PBKDF2_HMAC_SHA1(
pass_buf, pass_len as c_int, pass_buf, pass_len as c_int,
salt_buf, salt_len as c_int, salt_buf, salt_len as c_int,
iter as c_int, keylen as c_int, iter as c_int, keylen as c_int,

145
pkey.rs
View File

@ -1,4 +1,4 @@
use core::libc::{c_int, c_uint}; use std::libc::{c_int, c_uint};
use hash::{HashType, MD5, SHA1, SHA224, SHA256, SHA384, SHA512}; use hash::{HashType, MD5, SHA1, SHA224, SHA256, SHA384, SHA512};
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
@ -10,9 +10,9 @@ type ANYKEY = *libc::c_void;
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
type RSA = *libc::c_void; type RSA = *libc::c_void;
#[link_name = "crypto"] #[link_args = "-lcrypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { extern {
fn EVP_PKEY_new() -> *EVP_PKEY; fn EVP_PKEY_new() -> *EVP_PKEY;
fn EVP_PKEY_free(k: *EVP_PKEY); fn EVP_PKEY_free(k: *EVP_PKEY);
fn EVP_PKEY_assign(k: *EVP_PKEY, t: c_int, inner: *ANYKEY); fn EVP_PKEY_assign(k: *EVP_PKEY, t: c_int, inner: *ANYKEY);
@ -27,13 +27,13 @@ extern mod libcrypto {
fn RSA_size(k: *RSA) -> c_uint; fn RSA_size(k: *RSA) -> c_uint;
fn RSA_public_encrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA, 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, 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: *c_uint, fn RSA_sign(t: c_int, m: *u8, mlen: c_uint, sig: *mut u8, siglen: *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, fn RSA_verify(t: c_int, m: *u8, mlen: c_uint, sig: *u8, siglen: c_uint,
k: *RSA) -> c_int; k: *RSA) -> c_int;
} }
enum Parts { enum Parts {
@ -93,13 +93,13 @@ pub struct PKey {
pub fn PKey() -> PKey { pub fn PKey() -> PKey {
unsafe { unsafe {
PKey { evp: libcrypto::EVP_PKEY_new(), parts: Neither } PKey { evp: EVP_PKEY_new(), parts: Neither }
} }
} }
///Represents a public key, optionally with a private key attached. ///Represents a public key, optionally with a private key attached.
priv impl PKey { priv impl PKey {
priv fn _tostr(&self, f: @fn(*EVP_PKEY, &*mut u8) -> c_int) -> ~[u8] { priv fn _tostr(&self, f: extern "C" unsafe fn(*EVP_PKEY, &*mut u8) -> c_int) -> ~[u8] {
let buf = ptr::mut_null(); let buf = ptr::mut_null();
let len = f(self.evp, &buf); let len = f(self.evp, &buf);
if len < 0 as c_int { return ~[]; } if len < 0 as c_int { return ~[]; }
@ -115,7 +115,7 @@ priv impl PKey {
priv fn _fromstr( priv fn _fromstr(
&mut self, &mut self,
s: &[u8], s: &[u8],
f: @fn(c_int, &*EVP_PKEY, &*u8, c_uint) -> *EVP_PKEY f: extern "C" unsafe fn(c_int, &*EVP_PKEY, &*u8, c_uint) -> *EVP_PKEY
) { ) {
do vec::as_imm_buf(s) |ps, len| { do vec::as_imm_buf(s) |ps, len| {
let evp = ptr::null(); let evp = ptr::null();
@ -128,7 +128,7 @@ priv impl PKey {
pub impl PKey { pub impl PKey {
fn gen(&mut self, keysz: uint) { fn gen(&mut self, keysz: uint) {
unsafe { unsafe {
let rsa = libcrypto::RSA_generate_key( let rsa = RSA_generate_key(
keysz as c_uint, keysz as c_uint,
65537u as c_uint, 65537u as c_uint,
ptr::null(), ptr::null(),
@ -137,7 +137,7 @@ pub impl PKey {
let rsa_ = rsa_to_any(rsa); let rsa_ = rsa_to_any(rsa);
// XXX: 6 == NID_rsaEncryption // XXX: 6 == NID_rsaEncryption
libcrypto::EVP_PKEY_assign(self.evp, 6 as c_int, rsa_); EVP_PKEY_assign(self.evp, 6 as c_int, rsa_);
self.parts = Both; self.parts = Both;
} }
} }
@ -147,7 +147,7 @@ pub impl PKey {
*/ */
fn save_pub(&self) -> ~[u8] { fn save_pub(&self) -> ~[u8] {
unsafe { unsafe {
self._tostr(libcrypto::i2d_PublicKey) self._tostr(i2d_PublicKey)
} }
} }
@ -156,7 +156,7 @@ pub impl PKey {
*/ */
fn load_pub(&mut self, s: &[u8]) { fn load_pub(&mut self, s: &[u8]) {
unsafe { unsafe {
self._fromstr(s, libcrypto::d2i_PublicKey); self._fromstr(s, d2i_PublicKey);
self.parts = Public; self.parts = Public;
} }
} }
@ -167,7 +167,7 @@ pub impl PKey {
*/ */
fn save_priv(&self, ) -> ~[u8] { fn save_priv(&self, ) -> ~[u8] {
unsafe { unsafe {
self._tostr(libcrypto::i2d_PrivateKey) self._tostr(i2d_PrivateKey)
} }
} }
/** /**
@ -176,7 +176,7 @@ pub impl PKey {
*/ */
fn load_priv(&mut self, s: &[u8]) { fn load_priv(&mut self, s: &[u8]) {
unsafe { unsafe {
self._fromstr(s, libcrypto::d2i_PrivateKey); self._fromstr(s, d2i_PrivateKey);
self.parts = Both; self.parts = Both;
} }
} }
@ -186,7 +186,7 @@ pub impl PKey {
*/ */
fn size(&self) -> uint { fn size(&self) -> uint {
unsafe { unsafe {
libcrypto::RSA_size(libcrypto::EVP_PKEY_get1_RSA(self.evp)) as uint RSA_size(EVP_PKEY_get1_RSA(self.evp)) as uint
} }
} }
@ -224,8 +224,8 @@ pub impl PKey {
*/ */
fn max_data(&self) -> uint { fn max_data(&self) -> uint {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = EVP_PKEY_get1_RSA(self.evp);
let len = libcrypto::RSA_size(rsa); let len = 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 uint - 41u
@ -234,58 +234,57 @@ pub impl PKey {
fn encrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> ~[u8] { fn encrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> ~[u8] {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = EVP_PKEY_get1_RSA(self.evp);
let len = libcrypto::RSA_size(rsa); let len = RSA_size(rsa);
assert!(s.len() < self.max_data()); assert!(s.len() < self.max_data());
let mut r = vec::from_elem(len as uint + 1u, 0u8); let mut r = vec::from_elem(len as uint + 1u, 0u8);
do vec::as_mut_buf(r) |pr, _len| { let rv = do vec::as_mut_buf(r) |pr, _len| {
do vec::as_imm_buf(s) |ps, s_len| { do vec::as_imm_buf(s) |ps, s_len| {
let rv = libcrypto::RSA_public_encrypt( RSA_public_encrypt(
s_len as c_uint, s_len as c_uint,
ps, ps,
pr, pr,
rsa, rsa,
openssl_padding_code(padding) openssl_padding_code(padding)
); )
}
if rv < 0 as c_int { };
~[] if rv < 0 as c_int {
} else { ~[]
vec::const_slice(r, 0u, rv as uint).to_owned() } else {
} vec::slice(r, 0u, rv as uint).to_owned()
}
} }
} }
} }
fn decrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> ~[u8] { fn decrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> ~[u8] {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = EVP_PKEY_get1_RSA(self.evp);
let len = libcrypto::RSA_size(rsa); let len = RSA_size(rsa);
assert!(s.len() as c_uint == libcrypto::RSA_size(rsa)); assert!(s.len() as c_uint == 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);
do vec::as_mut_buf(r) |pr, _len| { let rv = do vec::as_mut_buf(r) |pr, _len| {
do vec::as_imm_buf(s) |ps, s_len| { do vec::as_imm_buf(s) |ps, s_len| {
let rv = libcrypto::RSA_private_decrypt( RSA_private_decrypt(
s_len as c_uint, s_len as c_uint,
ps, ps,
pr, pr,
rsa, rsa,
openssl_padding_code(padding) openssl_padding_code(padding)
); )
}
};
if rv < 0 as c_int { if rv < 0 as c_int {
~[] ~[]
} else { } else {
vec::const_slice(r, 0u, rv as uint).to_owned() vec::slice(r, 0u, rv as uint).to_owned()
}
}
} }
} }
} }
@ -315,37 +314,37 @@ pub impl PKey {
fn sign_with_hash(&self, s: &[u8], hash: HashType) -> ~[u8] { fn sign_with_hash(&self, s: &[u8], hash: HashType) -> ~[u8] {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = EVP_PKEY_get1_RSA(self.evp);
let len = libcrypto::RSA_size(rsa); let len = 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);
do vec::as_mut_buf(r) |pr, _len| { let rv = do vec::as_mut_buf(r) |pr, _len| {
do vec::as_imm_buf(s) |ps, s_len| { do vec::as_imm_buf(s) |ps, s_len| {
let rv = libcrypto::RSA_sign( RSA_sign(
openssl_hash_nid(hash), openssl_hash_nid(hash),
ps, ps,
s_len as c_uint, s_len as c_uint,
pr, pr,
&len, &len,
rsa); rsa)
}
};
if rv < 0 as c_int { if rv < 0 as c_int {
~[] ~[]
} else { } else {
vec::const_slice(r, 0u, len as uint).to_owned() vec::slice(r, 0u, len as uint).to_owned()
}
}
} }
} }
} }
fn verify_with_hash(&self, m: &[u8], s: &[u8], hash: HashType) -> bool { fn verify_with_hash(&self, m: &[u8], s: &[u8], hash: HashType) -> bool {
unsafe { unsafe {
let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp); let rsa = EVP_PKEY_get1_RSA(self.evp);
do vec::as_imm_buf(m) |pm, m_len| { do vec::as_imm_buf(m) |pm, m_len| {
do vec::as_imm_buf(s) |ps, s_len| { do vec::as_imm_buf(s) |ps, s_len| {
let rv = libcrypto::RSA_verify( let rv = RSA_verify(
openssl_hash_nid(hash), openssl_hash_nid(hash),
pm, pm,
m_len as c_uint, m_len as c_uint,

8
rand.rs
View File

@ -1,8 +1,8 @@
use core::libc::c_int; use std::libc::c_int;
#[link_name = "crypto"] #[link_args = "-lcrypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { extern {
fn RAND_bytes(buf: *mut u8, num: c_int) -> c_int; fn RAND_bytes(buf: *mut u8, num: c_int) -> c_int;
} }
@ -11,7 +11,7 @@ pub fn rand_bytes(len: uint) -> ~[u8] {
do vec::as_mut_buf(out) |out_buf, len| { do vec::as_mut_buf(out) |out_buf, len| {
unsafe { unsafe {
let r = libcrypto::RAND_bytes(out_buf, len as c_int); let r = RAND_bytes(out_buf, len as c_int);
if r != 1 as c_int { fail!() } if r != 1 as c_int { fail!() }
} }
} }

40
symm.rs
View File

@ -1,4 +1,4 @@
use core::libc::{c_int, c_uint}; use std::libc::{c_int, c_uint};
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
type EVP_CIPHER_CTX = *libc::c_void; type EVP_CIPHER_CTX = *libc::c_void;
@ -6,9 +6,9 @@ type EVP_CIPHER_CTX = *libc::c_void;
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
type EVP_CIPHER = *libc::c_void; type EVP_CIPHER = *libc::c_void;
#[link_name = "crypto"] #[link_args = "-lcrypto"]
#[abi = "cdecl"] #[abi = "cdecl"]
extern mod libcrypto { extern {
fn EVP_CIPHER_CTX_new() -> EVP_CIPHER_CTX; fn EVP_CIPHER_CTX_new() -> EVP_CIPHER_CTX;
fn EVP_CIPHER_CTX_set_padding(ctx: EVP_CIPHER_CTX, padding: c_int); fn EVP_CIPHER_CTX_set_padding(ctx: EVP_CIPHER_CTX, padding: c_int);
@ -25,7 +25,7 @@ extern mod libcrypto {
fn EVP_rc4() -> EVP_CIPHER; fn EVP_rc4() -> EVP_CIPHER;
fn EVP_CipherInit(ctx: EVP_CIPHER_CTX, evp: EVP_CIPHER, 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, 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); fn EVP_CipherFinal(ctx: EVP_CIPHER_CTX, res: *mut u8, len: &mut c_int);
@ -54,17 +54,17 @@ pub enum Type {
fn evpc(t: Type) -> (EVP_CIPHER, uint, uint) { fn evpc(t: Type) -> (EVP_CIPHER, uint, uint) {
unsafe { unsafe {
match t { match t {
AES_128_ECB => (libcrypto::EVP_aes_128_ecb(), 16u, 16u), AES_128_ECB => (EVP_aes_128_ecb(), 16u, 16u),
AES_128_CBC => (libcrypto::EVP_aes_128_cbc(), 16u, 16u), AES_128_CBC => (EVP_aes_128_cbc(), 16u, 16u),
// AES_128_CTR => (libcrypto::EVP_aes_128_ctr(), 16u, 0u), // AES_128_CTR => (EVP_aes_128_ctr(), 16u, 0u),
//AES_128_GCM => (libcrypto::EVP_aes_128_gcm(), 16u, 16u), //AES_128_GCM => (EVP_aes_128_gcm(), 16u, 16u),
AES_256_ECB => (libcrypto::EVP_aes_256_ecb(), 32u, 16u), AES_256_ECB => (EVP_aes_256_ecb(), 32u, 16u),
AES_256_CBC => (libcrypto::EVP_aes_256_cbc(), 32u, 16u), AES_256_CBC => (EVP_aes_256_cbc(), 32u, 16u),
// AES_256_CTR => (libcrypto::EVP_aes_256_ctr(), 32u, 0u), // AES_256_CTR => (EVP_aes_256_ctr(), 32u, 0u),
//AES_256_GCM => (libcrypto::EVP_aes_256_gcm(), 32u, 16u), //AES_256_GCM => (EVP_aes_256_gcm(), 32u, 16u),
RC4_128 => (libcrypto::EVP_rc4(), 16u, 0u), RC4_128 => (EVP_rc4(), 16u, 0u),
} }
} }
} }
@ -79,7 +79,7 @@ pub struct Crypter {
pub fn Crypter(t: Type) -> Crypter { pub fn Crypter(t: Type) -> Crypter {
unsafe { unsafe {
let ctx = libcrypto::EVP_CIPHER_CTX_new(); let ctx = EVP_CIPHER_CTX_new();
let (evp, keylen, blocksz) = evpc(t); let (evp, keylen, blocksz) = evpc(t);
Crypter { evp: evp, ctx: ctx, keylen: keylen, blocksize: blocksz } Crypter { evp: evp, ctx: ctx, keylen: keylen, blocksize: blocksz }
} }
@ -94,7 +94,7 @@ pub impl Crypter {
if self.blocksize > 0 { if self.blocksize > 0 {
unsafe { unsafe {
let v = if padding { 1 } else { 0 } as c_int; let v = if padding { 1 } else { 0 } as c_int;
libcrypto::EVP_CIPHER_CTX_set_padding(self.ctx, v); EVP_CIPHER_CTX_set_padding(self.ctx, v);
} }
} }
} }
@ -112,7 +112,7 @@ pub impl Crypter {
do vec::as_imm_buf(key) |pkey, _len| { do vec::as_imm_buf(key) |pkey, _len| {
do vec::as_imm_buf(iv) |piv, _len| { do vec::as_imm_buf(iv) |piv, _len| {
libcrypto::EVP_CipherInit( EVP_CipherInit(
self.ctx, self.ctx,
self.evp, self.evp,
pkey, pkey,
@ -136,7 +136,7 @@ pub impl Crypter {
let reslen = do vec::as_mut_buf(res) |pres, _len| { let reslen = do vec::as_mut_buf(res) |pres, _len| {
let mut reslen = (len + self.blocksize) as u32; let mut reslen = (len + self.blocksize) as u32;
libcrypto::EVP_CipherUpdate( EVP_CipherUpdate(
self.ctx, self.ctx,
pres, pres,
&mut reslen, &mut reslen,
@ -161,7 +161,7 @@ pub impl Crypter {
let reslen = do vec::as_mut_buf(res) |pres, _len| { let reslen = do vec::as_mut_buf(res) |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); EVP_CipherFinal(self.ctx, pres, &mut reslen);
reslen reslen
}; };
@ -216,11 +216,11 @@ mod tests {
~[ 0x8eu8, 0xa2u8, 0xb7u8, 0xcau8, 0x51u8, 0x67u8, 0x45u8, 0xbfu8, ~[ 0x8eu8, 0xa2u8, 0xb7u8, 0xcau8, 0x51u8, 0x67u8, 0x45u8, 0xbfu8,
0xeau8, 0xfcu8, 0x49u8, 0x90u8, 0x4bu8, 0x49u8, 0x60u8, 0x89u8 ]; 0xeau8, 0xfcu8, 0x49u8, 0x90u8, 0x4bu8, 0x49u8, 0x60u8, 0x89u8 ];
let c = Crypter(AES_256_ECB); let c = Crypter(AES_256_ECB);
c.init(Encrypt, k0, ~[]); c.init(Encrypt, k0, []);
c.pad(false); c.pad(false);
let r0 = c.update(p0) + c.final(); let r0 = c.update(p0) + c.final();
assert!(r0 == c0); assert!(r0 == c0);
c.init(Decrypt, k0, ~[]); c.init(Decrypt, k0, []);
c.pad(false); c.pad(false);
let p1 = c.update(r0) + c.final(); let p1 = c.update(r0) + c.final();
assert!(p1 == p0); assert!(p1 == p0);