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

Update for 0.2

This commit is contained in:
Brian Anderson 2012-03-28 11:43:56 -07:00
parent ee4c285a79
commit c978e357d4
4 changed files with 75 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crypto.rc
View File

@ -19,6 +19,8 @@
uuid = "38297409-b4c2-4499-8131-a99a7e44dad3")];
#[crate_type = "lib"];
use std; // FIXME https://github.com/mozilla/rust/issues/1127
mod hash;
mod pkey;
mod symm;

42
hash.rs
View File

@ -4,7 +4,7 @@ import core::ptr;
import core::str;
import core::vec;
import ctypes::c_uint;
import libc::c_uint;
export hasher;
export hashtype;
@ -38,21 +38,21 @@ iface hasher {
fn final() -> [u8];
}
tag hashtype {
md5;
sha1;
sha224;
sha256;
sha384;
sha512;
enum hashtype {
md5,
sha1,
sha224,
sha256,
sha384,
sha512
}
type EVP_MD_CTX = *libc::c_void;
type EVP_MD = *libc::c_void;
#[link_name = "crypto"]
#[abi = "cdecl"]
native mod _native {
type EVP_MD_CTX;
type EVP_MD;
fn EVP_MD_CTX_create() -> EVP_MD_CTX;
fn EVP_md5() -> EVP_MD;
@ -67,21 +67,21 @@ native mod _native {
fn EVP_DigestFinal(ctx: EVP_MD_CTX, res: *u8, n: *u32);
}
fn evpmd(t: hashtype) -> (_native::EVP_MD, uint) {
fn evpmd(t: hashtype) -> (EVP_MD, uint) {
alt t {
md5. { (_native::EVP_md5(), 16u) }
sha1. { (_native::EVP_sha1(), 20u) }
sha224. { (_native::EVP_sha224(), 28u) }
sha256. { (_native::EVP_sha256(), 32u) }
sha384. { (_native::EVP_sha384(), 48u) }
sha512. { (_native::EVP_sha512(), 64u) }
md5 { (_native::EVP_md5(), 16u) }
sha1 { (_native::EVP_sha1(), 20u) }
sha224 { (_native::EVP_sha224(), 28u) }
sha256 { (_native::EVP_sha256(), 32u) }
sha384 { (_native::EVP_sha384(), 48u) }
sha512 { (_native::EVP_sha512(), 64u) }
}
}
fn mk_hasher(ht: hashtype) -> hasher {
type hasherstate = {
evp: _native::EVP_MD,
ctx: _native::EVP_MD_CTX,
evp: EVP_MD,
ctx: EVP_MD_CTX,
len: uint
};
@ -96,7 +96,7 @@ fn mk_hasher(ht: hashtype) -> hasher {
}
fn final() -> [u8] unsafe {
let res: [mutable u8] = vec::init_elt_mut::<u8>(0u8, self.len);
let res: [mut u8] = vec::to_mut(vec::from_elem::<u8>(self.len, 0u8));
let pres: *u8 = vec::unsafe::to_ptr::<u8>(res);
_native::EVP_DigestFinal(self.ctx, pres, ptr::null::<u32>());
vec::from_mut::<u8>(res)

68
pkey.rs
View File

@ -1,23 +1,21 @@
use std; // FIXME https://github.com/graydon/rust/issues/1127
import core::ptr;
import core::str;
import core::unsafe;
import core::vec;
import ctypes::{c_int, c_uint};
import libc::{c_int, c_uint};
export pkeyrole, encrypt, decrypt, sign, verify;
export pkey, mk_pkey;
export _native;
type EVP_PKEY = *libc::c_void;
type ANYKEY = *libc::c_void;
type RSA = *libc::c_void;
#[link_name = "crypto"]
#[abi = "cdecl"]
native mod _native {
type EVP_PKEY;
type ANYKEY;
type RSA;
fn EVP_PKEY_new() -> *EVP_PKEY;
fn EVP_PKEY_free(k: *EVP_PKEY);
fn EVP_PKEY_assign(k: *EVP_PKEY, t: c_int, inner: *ANYKEY);
@ -41,10 +39,10 @@ native mod _native {
k: *RSA) -> c_int;
}
tag pkeyparts {
neither;
public;
both;
enum pkeyparts {
neither,
public,
both
}
/*
@ -52,11 +50,11 @@ Tag: pkeyrole
Represents a role an asymmetric key might be appropriate for.
*/
tag pkeyrole {
encrypt;
decrypt;
sign;
verify;
enum pkeyrole {
encrypt,
decrypt,
sign,
verify
}
/*
@ -156,25 +154,25 @@ iface pkey {
fn verify(m: [u8], s: [u8]) -> bool;
}
fn rsa_to_any(rsa: *_native::RSA) -> *_native::ANYKEY unsafe {
unsafe::reinterpret_cast::<*_native::RSA, *_native::ANYKEY>(rsa)
fn rsa_to_any(rsa: *RSA) -> *ANYKEY unsafe {
unsafe::reinterpret_cast::<*RSA, *ANYKEY>(rsa)
}
fn any_to_rsa(anykey: *_native::ANYKEY) -> *_native::RSA unsafe {
unsafe::reinterpret_cast::<*_native::ANYKEY, *_native::RSA>(anykey)
fn any_to_rsa(anykey: *ANYKEY) -> *RSA unsafe {
unsafe::reinterpret_cast::<*ANYKEY, *RSA>(anykey)
}
fn mk_pkey() -> pkey {
type pkeystate = {
mutable evp: *_native::EVP_PKEY,
mutable parts: pkeyparts
mut evp: *EVP_PKEY,
mut parts: pkeyparts
};
fn _tostr(st: pkeystate,
f: fn@(*_native::EVP_PKEY, **u8) -> c_int) -> [u8] unsafe {
f: fn@(*EVP_PKEY, **u8) -> c_int) -> [u8] unsafe {
let len = f(st.evp, ptr::null());
if len < 0 as c_int { ret []; }
let s: [mutable u8] = vec::init_elt_mut::<u8>(0u8, len as uint);
let s: [mut u8] = vec::to_mut(vec::from_elem::<u8>(len as uint, 0u8));
let ps: *u8 = vec::unsafe::to_ptr::<u8>(s);
let pps: **u8 = ptr::addr_of(ps);
let r = f(st.evp, pps);
@ -183,12 +181,12 @@ fn mk_pkey() -> pkey {
}
fn _fromstr(st: pkeystate,
f: fn@(c_int, **_native::EVP_PKEY, **u8, c_uint) -> *_native::EVP_PKEY,
f: fn@(c_int, **EVP_PKEY, **u8, c_uint) -> *EVP_PKEY,
s: [u8]) unsafe {
let ps: *u8 = vec::unsafe::to_ptr::<u8>(s);
let pps: **u8 = ptr::addr_of(ps);
let evp: *_native::EVP_PKEY = ptr::null();
let pevp: **_native::EVP_PKEY = ptr::addr_of(evp);
let evp: *EVP_PKEY = ptr::null();
let pevp: **EVP_PKEY = ptr::addr_of(evp);
f(6 as c_int, pevp, pps, vec::len(s) as c_uint);
st.evp = *pevp;
}
@ -230,10 +228,10 @@ fn mk_pkey() -> pkey {
}
fn can(r: pkeyrole) -> bool {
alt r {
encrypt. { self.parts != neither }
verify. { self.parts != neither }
decrypt. { self.parts == both }
sign. { self.parts == both }
encrypt { self.parts != neither }
verify { self.parts != neither }
decrypt { self.parts == both }
sign { self.parts == both }
}
}
fn max_data() -> uint unsafe {
@ -247,7 +245,7 @@ fn mk_pkey() -> pkey {
let len = _native::RSA_size(rsa);
// 41 comes from RSA_public_encrypt(3) for OAEP
assert(vec::len(s) < _native::RSA_size(rsa) as uint - 41u);
let r: [mutable u8] = vec::init_elt_mut::<u8>(0u8, len as uint + 1u);
let r: [mut u8] = vec::to_mut(vec::from_elem::<u8>(len as uint + 1u, 0u8));
let pr: *u8 = vec::unsafe::to_ptr::<u8>(r);
let ps: *u8 = vec::unsafe::to_ptr::<u8>(s);
// XXX: 4 == RSA_PKCS1_OAEP_PADDING
@ -260,7 +258,7 @@ fn mk_pkey() -> pkey {
let rsa = _native::EVP_PKEY_get1_RSA(self.evp);
let len = _native::RSA_size(rsa);
assert(vec::len(s) as c_uint == _native::RSA_size(rsa));
let r: [mutable u8] = vec::init_elt_mut::<u8>(0u8, len as uint + 1u);
let r: [mut u8] = vec::to_mut(vec::from_elem::<u8>(len as uint + 1u, 0u8));
let pr: *u8 = vec::unsafe::to_ptr::<u8>(r);
let ps: *u8 = vec::unsafe::to_ptr::<u8>(s);
// XXX: 4 == RSA_PKCS1_OAEP_PADDING
@ -272,7 +270,7 @@ fn mk_pkey() -> pkey {
fn sign(s: [u8]) -> [u8] unsafe {
let rsa = _native::EVP_PKEY_get1_RSA(self.evp);
let len = _native::RSA_size(rsa);
let r: [mutable u8] = vec::init_elt_mut::<u8>(0u8, len as uint + 1u);
let r: [mut u8] = vec::to_mut(vec::from_elem::<u8>(len as uint + 1u, 0u8));
let pr: *u8 = vec::unsafe::to_ptr::<u8>(r);
let ps: *u8 = vec::unsafe::to_ptr::<u8>(s);
let plen: *c_uint = ptr::addr_of(len);
@ -295,7 +293,7 @@ fn mk_pkey() -> pkey {
}
}
let st = { mutable evp: _native::EVP_PKEY_new(), mutable parts: neither };
let st = { mut evp: _native::EVP_PKEY_new(), mut parts: neither };
let p = st as pkey;
ret p;
}

38
symm.rs
View File

@ -4,7 +4,7 @@ import core::ptr;
import core::str;
import core::vec;
import ctypes::c_int;
import libc::c_int;
export crypter;
export cryptermode;
@ -15,12 +15,12 @@ export mk_crypter;
export encrypt, decrypt;
export _native;
type EVP_CIPHER_CTX = *libc::c_void;
type EVP_CIPHER = *libc::c_void;
#[link_name = "crypto"]
#[abi = "cdecl"]
native mod _native {
type EVP_CIPHER_CTX;
type EVP_CIPHER;
fn EVP_CIPHER_CTX_new() -> EVP_CIPHER_CTX;
fn EVP_CIPHER_CTX_set_padding(ctx: EVP_CIPHER_CTX, padding: c_int);
@ -75,39 +75,39 @@ iface crypter {
fn final() -> [u8];
}
tag cryptermode {
encryptmode;
decryptmode;
enum cryptermode {
encryptmode,
decryptmode
}
tag cryptertype {
aes_256_ecb;
aes_256_cbc;
enum cryptertype {
aes_256_ecb,
aes_256_cbc
}
fn evpc(t: cryptertype) -> (_native::EVP_CIPHER, uint, uint) {
fn evpc(t: cryptertype) -> (EVP_CIPHER, uint, uint) {
alt t {
aes_256_ecb. { (_native::EVP_aes_256_ecb(), 32u, 16u) }
aes_256_cbc. { (_native::EVP_aes_256_cbc(), 32u, 16u) }
aes_256_ecb { (_native::EVP_aes_256_ecb(), 32u, 16u) }
aes_256_cbc { (_native::EVP_aes_256_cbc(), 32u, 16u) }
}
}
fn mk_crypter(t: cryptertype) -> crypter {
type crypterstate = {
evp: _native::EVP_CIPHER,
ctx: _native::EVP_CIPHER_CTX,
evp: EVP_CIPHER,
ctx: EVP_CIPHER_CTX,
keylen: uint,
blocksize: uint
};
impl of crypter for crypterstate {
fn pad(padding: bool) {
let v = (padding ? 1 : 0) as c_int;
let v = if padding { 1 } else { 0} as c_int;
_native::EVP_CIPHER_CTX_set_padding(self.ctx, v);
}
fn init (mode: cryptermode, key: [u8], iv: [u8]) unsafe {
let m = alt mode { encryptmode. { 1 } decryptmode. { 0 } } as c_int;
let m = alt mode { encryptmode { 1 } decryptmode { 0 } } as c_int;
assert(vec::len(key) == self.keylen);
let pkey: *u8 = vec::unsafe::to_ptr::<u8>(key);
let piv: *u8 = vec::unsafe::to_ptr::<u8>(iv);
@ -119,7 +119,7 @@ fn mk_crypter(t: cryptertype) -> crypter {
let datalen: u32 = vec::len(data) as u32;
let reslen: u32 = datalen + (self.blocksize as u32);
let preslen: *u32 = ptr::addr_of(reslen);
let res: [mutable u8] = vec::init_elt_mut::<u8>(0u8, reslen as uint);
let res: [mut u8] = vec::to_mut(vec::from_elem::<u8>(reslen as uint, 0u8));
let pres: *u8 = vec::unsafe::to_ptr::<u8>(res);
_native::EVP_CipherUpdate(self.ctx, pres, preslen, pdata, datalen);
ret vec::slice::<u8>(res, 0u, *preslen as uint);
@ -128,7 +128,7 @@ fn mk_crypter(t: cryptertype) -> crypter {
fn final() -> [u8] unsafe {
let reslen: u32 = self.blocksize as u32;
let preslen: *u32 = ptr::addr_of(reslen);
let res: [mutable u8] = vec::init_elt_mut::<u8>(0u8, reslen as uint);
let res: [mut u8] = vec::to_mut(vec::from_elem::<u8>(reslen as uint, 0u8));
let pres: *u8 = vec::unsafe::to_ptr::<u8>(res);
_native::EVP_CipherFinal(self.ctx, pres, preslen);
ret vec::slice::<u8>(res, 0u, *preslen as uint);