Auto merge of #2945 - QuiltOS:openssl, r=alexcrichton

Use openssl on Unix rather than C functions directly for SHA256

Takes on an extra dependency, but removes unsafe code in the process.

@alexcrichton I was a little confused by what you were saying on IRC, so I went ahead and just speculatively made this. No worries if it is no good.

Author: bors

Cargo.lock

@@ -45,6 +45,9 @@ toml = "0.1.29"
 url = "1.1"
 winapi = "0.2"
 
+[target.'cfg(unix)'.dependencies]
+openssl = "0.7"
+
 [dev-dependencies]
 hamcrest = "0.1"
 bufstream = "0.1"

Cargo.toml

@@ -6,63 +6,26 @@ pub use self::imp::Sha256;
 // allow improper ctypes because size_t falls under that in old compilers
 #[allow(bad_style, improper_ctypes)]
 mod imp {
-    use libc;
+    extern crate openssl;
 
-    enum EVP_MD_CTX {}
-    enum EVP_MD {}
-    enum ENGINE {}
+    use std::io::Write;
+    use self::openssl::crypto::hash::{Hasher, Type};
 
-    extern {
-        fn EVP_DigestInit_ex(ctx: *mut EVP_MD_CTX,
-                             kind: *const EVP_MD,
-                             imp: *mut ENGINE) -> libc::c_int;
-        fn EVP_DigestUpdate(ctx: *mut EVP_MD_CTX,
-                            d: *const libc::c_void,
-                            cnt: libc::size_t) -> libc::c_int;
-        fn EVP_DigestFinal_ex(ctx: *mut EVP_MD_CTX, md: *mut libc::c_uchar,
-                              s: *mut libc::c_uint) -> libc::c_int;
-        fn EVP_MD_CTX_create() -> *mut EVP_MD_CTX;
-        fn EVP_MD_CTX_destroy(ctx: *mut EVP_MD_CTX);
-        fn EVP_sha256() -> *const EVP_MD;
-    }
-
-    pub struct Sha256 { ctx: *mut EVP_MD_CTX }
+    pub struct Sha256(Hasher);
 
     impl Sha256 {
         pub fn new() -> Sha256 {
-            unsafe {
-                let ctx = EVP_MD_CTX_create();
-                assert!(!ctx.is_null());
-                let ret = Sha256 { ctx: ctx };
-                let n = EVP_DigestInit_ex(ret.ctx, EVP_sha256(), 0 as *mut _);
-                assert_eq!(n, 1);
-                ret
-            }
+            Sha256(Hasher::new(Type::SHA256))
         }
 
         pub fn update(&mut self, bytes: &[u8]) {
-            unsafe {
-                let n = EVP_DigestUpdate(self.ctx, bytes.as_ptr() as *const _,
-                                         bytes.len() as libc::size_t);
-                assert_eq!(n, 1);
-            }
+            let _ = self.0.write_all(bytes);
         }
 
         pub fn finish(&mut self) -> [u8; 32] {
-            unsafe {
-                let mut ret = [0u8; 32];
-                let mut out = 0;
-                let n = EVP_DigestFinal_ex(self.ctx, ret.as_mut_ptr(), &mut out);
-                assert_eq!(n, 1);
-                assert_eq!(out, 32);
-                ret
-            }
-        }
-    }
-
-    impl Drop for Sha256 {
-        fn drop(&mut self) {
-            unsafe { EVP_MD_CTX_destroy(self.ctx) }
+            let mut ret = [0u8; 32];
+            ret.copy_from_slice(&self.0.finish()[..]);
+            ret
         }
     }
 }