Modernize crypto with new rust style and rustdoc support

3 files changed, 58 insertions, 143 deletions

diff --git a/hash.rs b/hash.rs
index 4ba64e0b..a68347c7 100644
--- a/hash.rs
+++ b/hash.rs
@@ -1,40 +1,23 @@
-use std;
-
-import core::ptr;
-import core::str;
-import core::vec;
-
 import libc::c_uint;
 
 export hasher;
 export hashtype;
-export mk_hasher;
 export hash;
 export _native;
 
 export md5, sha1, sha224, sha256, sha384, sha512;
 
 iface hasher {
-    /*
-    Method: init
-
-    Initializes this hasher
-    */
+    #[doc = "Initializes this hasher"]
     fn init();
 
-    /*
-    Method: update
-
-    Update this hasher with more input bytes
-    */
+    #[doc = "Update this hasher with more input bytes"]
     fn update([u8]);
 
-    /*
-    Method: final
-
+    #[doc = "
     Return the digest of all bytes added to this hasher since its last
     initialization
-    */
+    "]
     fn final() -> [u8];
 }
 
@@ -78,7 +61,7 @@ fn evpmd(t: hashtype) -> (EVP_MD, uint) {
     }
 }
 
-fn mk_hasher(ht: hashtype) -> hasher {
+fn hasher(ht: hashtype) -> hasher {
     type hasherstate = {
         evp: EVP_MD,
         ctx: EVP_MD_CTX,
@@ -111,13 +94,11 @@ fn mk_hasher(ht: hashtype) -> hasher {
     ret h;
 }
 
-/*
-Function: hash
-
+#[doc = "
 Hashes the supplied input data using hash t, returning the resulting hash value
-*/
+"]
 fn hash(t: hashtype, data: [u8]) -> [u8] unsafe {
-    let h = mk_hasher(t);
+    let h = hasher(t);
     h.init();
     h.update(data);
     ret h.final();
diff --git a/pkey.rs b/pkey.rs
index 24ed4826..040e4aa4 100644
--- a/pkey.rs
+++ b/pkey.rs
@@ -1,12 +1,7 @@
-import core::ptr;
-import core::str;
-import core::unsafe;
-import core::vec;
-
 import libc::{c_int, c_uint};
 
 export pkeyrole, encrypt, decrypt, sign, verify;
-export pkey, mk_pkey;
+export pkey;
 export _native;
 
 type EVP_PKEY = *libc::c_void;
@@ -45,11 +40,7 @@ enum pkeyparts {
     both
 }
 
-/*
-Tag: pkeyrole
-
-Represents a role an asymmetric key might be appropriate for.
-*/
+#[doc = "Represents a role an asymmetric key might be appropriate for."]
 enum pkeyrole {
     encrypt,
     decrypt,
@@ -57,100 +48,68 @@ enum pkeyrole {
     verify
 }
 
-/*
-Object: pkey
-
-Represents a public key, optionally with a private key attached.
-*/
+#[doc = "Represents a public key, optionally with a private key attached."]
 iface pkey {
-    /*
-    Method: save_pub
-
+    #[doc = "
     Returns a serialized form of the public key, suitable for load_pub().
-    */
+    "]
     fn save_pub() -> [u8];
 
-    /*
-    Method: load_pub
-
+    #[doc = "
     Loads a serialized form of the public key, as produced by save_pub().
-    */
+    "]
     fn load_pub(s: [u8]);
 
-    /*
-    Method: save_priv
-
+    #[doc = "
     Returns a serialized form of the public and private keys, suitable for
     load_priv().
-    */
+    "]
     fn save_priv() -> [u8];
 
-    /*
-    Method: load_priv
-
+    #[doc = "
     Loads a serialized form of the public and private keys, as produced by
     save_priv().
-    */
+    "]
     fn load_priv(s: [u8]);
 
-    /*
-    Method: size()
-
-    Returns the size of the public key modulus.
-    */
+    #[doc = "Returns the size of the public key modulus."]
     fn size() -> uint;
 
-    /*
-    Method: gen()
-
-    Generates a public/private keypair of the specified size.
-    */
+    #[doc = "Generates a public/private keypair of the specified size."]
     fn gen(keysz: uint);
 
-    /*
-    Method: can()
-
+    #[doc = "
     Returns whether this pkey object can perform the specified role.
-    */
+    "]
     fn can(role: pkeyrole) -> bool;
 
-    /*
-    Method: max_data()
-
+    #[doc = "
     Returns the maximum amount of data that can be encrypted by an encrypt()
     call.
-    */
+    "]
     fn max_data() -> uint;
 
-    /*
-    Method: encrypt()
-
+    #[doc = "
     Encrypts data using OAEP padding, returning the encrypted data. The supplied
     data must not be larger than max_data().
-    */
+    "]
     fn encrypt(s: [u8]) -> [u8];
 
-    /*
-    Method: decrypt()
-
+    #[doc = "
     Decrypts data, expecting OAEP padding, returning the decrypted data.
-    */
+    "]
     fn decrypt(s: [u8]) -> [u8];
 
-    /*
-    Method: sign()
-
+    #[doc = "
     Signs data, using OpenSSL's default scheme and sha256. Unlike encrypt(), can
     process an arbitrary amount of data; returns the signature.
-    */
+    "]
     fn sign(s: [u8]) -> [u8];
 
-    /*
-    Method: verify()
-
+    #[doc = "
     Verifies a signature s (using OpenSSL's default scheme and sha256) on a
     message m. Returns true if the signature is valid, and false otherwise.
-    */
+    "]
     fn verify(m: [u8], s: [u8]) -> bool;
 }
 
@@ -162,7 +121,7 @@ fn any_to_rsa(anykey: *ANYKEY) -> *RSA unsafe {
     unsafe::reinterpret_cast::<*ANYKEY, *RSA>(anykey)
 }
 
-fn mk_pkey() -> pkey {
+fn pkey() -> pkey {
     type pkeystate = {
         mut evp: *EVP_PKEY,
         mut parts: pkeyparts
@@ -302,8 +261,8 @@ fn mk_pkey() -> pkey {
 mod tests {
     #[test]
     fn test_gen_pub() {
-        let k0 = mk_pkey();
-        let k1 = mk_pkey();
+        let k0 = pkey();
+        let k1 = pkey();
         k0.gen(512u);
         k1.load_pub(k0.save_pub());
         assert(k0.save_pub() == k1.save_pub());
@@ -320,8 +279,8 @@ mod tests {
 
     #[test]
     fn test_gen_priv() {
-        let k0 = mk_pkey();
-        let k1 = mk_pkey();
+        let k0 = pkey();
+        let k1 = pkey();
         k0.gen(512u);
         k1.load_priv(k0.save_priv());
         assert(k0.save_priv() == k1.save_priv());
@@ -338,8 +297,8 @@ mod tests {
 
     #[test]
     fn test_encrypt() {
-        let k0 = mk_pkey();
-        let k1 = mk_pkey();
+        let k0 = pkey();
+        let k1 = pkey();
         let msg: [u8] = [0xdeu8, 0xadu8, 0xd0u8, 0x0du8];
         k0.gen(512u);
         k1.load_pub(k0.save_pub());
@@ -350,8 +309,8 @@ mod tests {
 
     #[test]
     fn test_sign() {
-        let k0 = mk_pkey();
-        let k1 = mk_pkey();
+        let k0 = pkey();
+        let k1 = pkey();
         let msg: [u8] = [0xdeu8, 0xadu8, 0xd0u8, 0x0du8];
         k0.gen(512u);
         k1.load_pub(k0.save_pub());
diff --git a/symm.rs b/symm.rs
index 1e0c6cd1..819c8d1f 100644
--- a/symm.rs
+++ b/symm.rs
@@ -1,9 +1,3 @@
-use std;
-
-import core::ptr;
-import core::str;
-import core::vec;
-
 import libc::c_int;
 
 export crypter;
@@ -11,7 +5,6 @@ export cryptermode;
 export encryptmode, decryptmode;
 export cryptertype;
 export aes_256_ecb, aes_256_cbc;
-export mk_crypter;
 export encrypt, decrypt;
 export _native;
 
@@ -38,40 +31,26 @@ native mod _native {
     fn EVP_CipherFinal(ctx: EVP_CIPHER_CTX, res: *u8, len: *u32);
 }
 
-/*
-Object: crypter
-
-Represents a symmetric cipher context.
-*/
+#[doc = "Represents a symmetric cipher context."]
 iface crypter {
-    /*
-    Method: pad
-
+    #[doc = "
     Enables or disables padding. If padding is disabled, total amount of data
     encrypted must be a multiple of block size.
-    */
+    "]
     fn pad(padding: bool);
 
-    /*
-    Method: init
-
-    Initializes this crypter.
-    */
+    #[doc = "Initializes this crypter."]
     fn init(mode: cryptermode, key: [u8], iv: [u8]);
 
-    /*
-    Method: update
-
+    #[doc = "
     Update this crypter with more data to encrypt or decrypt. Returns encrypted
     or decrypted bytes.
-    */
+    "]
     fn update(data: [u8]) -> [u8];
 
-    /*
-    Method: final
-
+    #[doc = "
     Finish crypting. Returns the remaining partial block of output, if any.
-    */
+    "]
     fn final() -> [u8];
 }
 
@@ -92,7 +71,7 @@ fn evpc(t: cryptertype) -> (EVP_CIPHER, uint, uint) {
     }
 }
 
-fn mk_crypter(t: cryptertype) -> crypter {
+fn crypter(t: cryptertype) -> crypter {
     type crypterstate = {
         evp: EVP_CIPHER,
         ctx: EVP_CIPHER_CTX,
@@ -142,28 +121,24 @@ fn mk_crypter(t: cryptertype) -> crypter {
     ret h;
 }
 
-/*
-Function: encrypt
-
+#[doc = "
 Encrypts data, using the specified crypter type in encrypt mode with the
 specified key and iv; returns the resulting (encrypted) data.
-*/
+"]
 fn encrypt(t: cryptertype, key: [u8], iv: [u8], data: [u8]) -> [u8] {
-    let c = mk_crypter(t);
+    let c = crypter(t);
     c.init(encryptmode, key, iv);
     let r = c.update(data);
     let rest = c.final();
     ret r + rest;
 }
 
-/*
-Function: decrypt
-
+#[doc = "
 Decrypts data, using the specified crypter type in decrypt mode with the
 specified key and iv; returns the resulting (decrypted) data.
-*/
+"]
 fn decrypt(t: cryptertype, key: [u8], iv: [u8], data: [u8]) -> [u8] {
-    let c = mk_crypter(t);
+    let c = crypter(t);
     c.init(decryptmode, key, iv);
     let r = c.update(data);
     let rest = c.final();
@@ -187,7 +162,7 @@ mod tests {
         let c0 =
             [ 0x8eu8, 0xa2u8, 0xb7u8, 0xcau8, 0x51u8, 0x67u8, 0x45u8, 0xbfu8,
               0xeau8, 0xfcu8, 0x49u8, 0x90u8, 0x4bu8, 0x49u8, 0x60u8, 0x89u8 ];
-        let c = mk_crypter(aes_256_ecb);
+        let c = crypter(aes_256_ecb);
         c.init(encryptmode, k0, []);
         c.pad(false);
         let r0 = c.update(p0) + c.final();