5 files changed, 537 insertions, 0 deletions
diff --git a/vendor/crypto-hash/src/imp/commoncrypto.rs b/vendor/crypto-hash/src/imp/commoncrypto.rs
new file mode 100644
index 0000000..99f4766
--- /dev/null
+++ b/vendor/crypto-hash/src/imp/commoncrypto.rs
@@ -0,0 +1,81 @@
+// Copyright (c) 2016 Mark Lee
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! A cryptographic hash generator dependent upon OSX's `CommonCrypto`.
+
+use super::Algorithm;
+use commoncrypto::hash;
+use std::io;
+
+/// Generator of digests using a cryptographic hash function.
+///
+/// # Examples
+///
+/// ```rust
+/// use crypto_hash::{Algorithm, Hasher};
+/// use std::io::Write;
+///
+/// let mut hasher = Hasher::new(Algorithm::SHA256);
+/// hasher.write_all(b"crypto");
+/// hasher.write_all(b"-");
+/// hasher.write_all(b"hash");
+/// let result = hasher.finish();
+/// let expected =
+///     b"\xfd\x1a\xfb`\"\xcdMG\xc8\x90\x96\x1cS9(\xea\xcf\xe8!\x9f\x1b%$\xf7\xfb*a\x84}\xdf\x8c'"
+///     .to_vec();
+/// assert_eq!(expected, result)
+/// ```
+#[derive(Debug)]
+pub struct Hasher(hash::Hasher);
+
+impl Hasher {
+    /// Create a new `Hasher` for the given `Algorithm`.
+    pub fn new(algorithm: Algorithm) -> Hasher {
+        let cc_algorithm = match algorithm {
+            Algorithm::MD5 => hash::CCDigestAlgorithm::kCCDigestMD5,
+            Algorithm::SHA1 => hash::CCDigestAlgorithm::kCCDigestSHA1,
+            Algorithm::SHA256 => hash::CCDigestAlgorithm::kCCDigestSHA256,
+            Algorithm::SHA512 => hash::CCDigestAlgorithm::kCCDigestSHA512,
+        };
+
+        Hasher(hash::Hasher::new(cc_algorithm))
+    }
+
+    /// Generate a digest from the data written to the `Hasher`.
+    pub fn finish(&mut self) -> Vec<u8> {
+        let Hasher(ref mut hasher) = *self;
+        match hasher.finish() {
+            Ok(digest) => digest,
+            Err(error) => panic!("CommonCrypto error: {}", error),
+        }
+    }
+}
+
+impl io::Write for Hasher {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let Hasher(ref mut hasher) = *self;
+        hasher.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        let Hasher(ref mut hasher) = *self;
+        hasher.flush()
+    }
+}
diff --git a/vendor/crypto-hash/src/imp/cryptoapi.rs b/vendor/crypto-hash/src/imp/cryptoapi.rs
new file mode 100644
index 0000000..160b38e
--- /dev/null
+++ b/vendor/crypto-hash/src/imp/cryptoapi.rs
@@ -0,0 +1,169 @@
+// Copyright (c) 2016 Mark Lee
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! A cryptographic hash generator dependent upon Windows's `CryptoAPI`.
+//!
+//! Originally based on:
+//! https://github.com/rust-lang/cargo/blob/0.10.0/src/cargo/util/sha256.rs
+//! which is copyright (c) 2014 The Rust Project Developers under the MIT license.
+
+use super::Algorithm;
+use std::io;
+use std::ptr;
+use winapi::shared::minwindef::DWORD;
+use winapi::um::wincrypt::{
+    CryptAcquireContextW, CryptCreateHash, CryptDestroyHash, CryptGetHashParam, CryptHashData,
+    CryptReleaseContext, ALG_ID, CALG_MD5, CALG_SHA1, CALG_SHA_256, CALG_SHA_512, CRYPT_SILENT,
+    CRYPT_VERIFYCONTEXT, HCRYPTHASH, HCRYPTPROV, HP_HASHVAL, PROV_RSA_AES,
+};
+
+macro_rules! call {
+    ($e:expr) => {{
+        if $e == 0 {
+            panic!("failed {}: {}", stringify!($e), io::Error::last_os_error())
+        }
+    }};
+}
+
+macro_rules! finish_algorithm {
+    ($func_name: ident, $size: ident) => {
+        fn $func_name(&mut self) -> Vec<u8> {
+            let mut len = $size as u32;
+            let mut hash = [0u8; $size];
+            call!(unsafe {
+                CryptGetHashParam(self.hcrypthash, HP_HASHVAL, hash.as_mut_ptr(), &mut len, 0)
+            });
+            assert_eq!(len as usize, hash.len());
+            hash.to_vec()
+        }
+    }
+}
+
+const MD5_LENGTH: usize = 16;
+const SHA1_LENGTH: usize = 20;
+const SHA256_LENGTH: usize = 32;
+const SHA512_LENGTH: usize = 64;
+
+/// Generator of digests using a cryptographic hash function.
+///
+/// # Examples
+///
+/// ```rust
+/// use crypto_hash::{Algorithm, Hasher};
+/// use std::io::Write;
+///
+/// let mut hasher = Hasher::new(Algorithm::SHA256);
+/// hasher.write_all(b"crypto");
+/// hasher.write_all(b"-");
+/// hasher.write_all(b"hash");
+/// let result = hasher.finish();
+/// let expected =
+///     b"\xfd\x1a\xfb`\"\xcdMG\xc8\x90\x96\x1cS9(\xea\xcf\xe8!\x9f\x1b%$\xf7\xfb*a\x84}\xdf\x8c'"
+///     .to_vec();
+/// assert_eq!(expected, result)
+/// ```
+pub struct Hasher {
+    alg_id: ALG_ID,
+    hcryptprov: HCRYPTPROV,
+    hcrypthash: HCRYPTHASH,
+}
+
+impl Hasher {
+    /// Create a new `Hasher` for the given `Algorithm`.
+    pub fn new(algorithm: Algorithm) -> Hasher {
+        let mut hcp = 0;
+        call!(unsafe {
+            CryptAcquireContextW(
+                &mut hcp,
+                ptr::null(),
+                ptr::null(),
+                PROV_RSA_AES,
+                CRYPT_VERIFYCONTEXT | CRYPT_SILENT,
+            )
+        });
+
+        let alg_id = match algorithm {
+            Algorithm::MD5 => CALG_MD5,
+            Algorithm::SHA1 => CALG_SHA1,
+            Algorithm::SHA256 => CALG_SHA_256,
+            Algorithm::SHA512 => CALG_SHA_512,
+        };
+
+        let mut hasher = Hasher {
+            alg_id,
+            hcryptprov: hcp,
+            hcrypthash: 0,
+        };
+
+        call!(unsafe {
+            CryptCreateHash(
+                hasher.hcryptprov,
+                hasher.alg_id,
+                0,
+                0,
+                &mut hasher.hcrypthash,
+            )
+        });
+        hasher
+    }
+
+    /// Generate a digest from the data written to the `Hasher`.
+    pub fn finish(&mut self) -> Vec<u8> {
+        match self.alg_id {
+            CALG_MD5 => self.finish_md5(),
+            CALG_SHA1 => self.finish_sha1(),
+            CALG_SHA_256 => self.finish_sha256(),
+            CALG_SHA_512 => self.finish_sha512(),
+            _ => panic!("Unknown algorithm {}", self.alg_id),
+        }
+    }
+
+    finish_algorithm!(finish_md5, MD5_LENGTH);
+    finish_algorithm!(finish_sha1, SHA1_LENGTH);
+    finish_algorithm!(finish_sha256, SHA256_LENGTH);
+    finish_algorithm!(finish_sha512, SHA512_LENGTH);
+}
+
+impl io::Write for Hasher {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        call!(unsafe {
+            CryptHashData(
+                self.hcrypthash,
+                buf.as_ptr() as *mut _,
+                buf.len() as DWORD,
+                0,
+            )
+        });
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Drop for Hasher {
+    fn drop(&mut self) {
+        if self.hcrypthash != 0 {
+            call!(unsafe { CryptDestroyHash(self.hcrypthash) });
+        }
+        call!(unsafe { CryptReleaseContext(self.hcryptprov, 0) });
+    }
+}
diff --git a/vendor/crypto-hash/src/imp/openssl.rs b/vendor/crypto-hash/src/imp/openssl.rs
new file mode 100644
index 0000000..d58726b
--- /dev/null
+++ b/vendor/crypto-hash/src/imp/openssl.rs
@@ -0,0 +1,85 @@
+// Copyright (c) 2015, 2016 Mark Lee
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! A cryptographic hash digest generator dependent upon `OpenSSL`.
+
+#![warn(missing_docs)]
+
+use super::Algorithm;
+use openssl::hash;
+use std::io;
+
+/// Generator of digests using a cryptographic hash function.
+///
+/// # Examples
+///
+/// ```rust
+/// use crypto_hash::{Algorithm, Hasher};
+/// use std::io::Write;
+///
+/// let mut hasher = Hasher::new(Algorithm::SHA256);
+/// hasher.write_all(b"crypto");
+/// hasher.write_all(b"-");
+/// hasher.write_all(b"hash");
+/// let result = hasher.finish();
+/// let expected =
+///     b"\xfd\x1a\xfb`\"\xcdMG\xc8\x90\x96\x1cS9(\xea\xcf\xe8!\x9f\x1b%$\xf7\xfb*a\x84}\xdf\x8c'"
+///     .to_vec();
+/// assert_eq!(expected, result)
+/// ```
+pub struct Hasher(hash::Hasher);
+
+impl Hasher {
+    /// Create a new `Hasher` for the given `Algorithm`.
+    pub fn new(algorithm: Algorithm) -> Hasher {
+        let hash_type = match algorithm {
+            Algorithm::MD5 => hash::MessageDigest::md5(),
+            Algorithm::SHA1 => hash::MessageDigest::sha1(),
+            Algorithm::SHA256 => hash::MessageDigest::sha256(),
+            Algorithm::SHA512 => hash::MessageDigest::sha512(),
+        };
+
+        match hash::Hasher::new(hash_type) {
+            Ok(hasher) => Hasher(hasher),
+            Err(error_stack) => panic!("OpenSSL error(s): {}", error_stack),
+        }
+    }
+
+    /// Generate a digest from the data written to the `Hasher`.
+    pub fn finish(&mut self) -> Vec<u8> {
+        let Hasher(ref mut hasher) = *self;
+        match hasher.finish() {
+            Ok(digest) => digest.to_vec(),
+            Err(error_stack) => panic!("OpenSSL error(s): {}", error_stack),
+        }
+    }
+}
+
+impl io::Write for Hasher {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let Hasher(ref mut hasher) = *self;
+        hasher.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        let Hasher(ref mut hasher) = *self;
+        hasher.flush()
+    }
+}
diff --git a/vendor/crypto-hash/src/lib.rs b/vendor/crypto-hash/src/lib.rs
new file mode 100644
index 0000000..fd553ba
--- /dev/null
+++ b/vendor/crypto-hash/src/lib.rs
@@ -0,0 +1,119 @@
+// Copyright (c) 2015, 2016, 2017 Mark Lee
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! A set of [cryptographic hash
+//! functions](https://en.wikipedia.org/wiki/Cryptographic_hash_function) provided by the operating
+//! system, when available.
+//!
+//! The purpose of this crate is to provide access to hash algorithms with as few dependencies as
+//! possible. This means that when possible, the library uses the hashing functions that are
+//! provided by the given operating system's bundled cryptographic libraries.
+//!
+//! # Supported Implementations
+//!
+//! By operating system:
+//!
+//! * Windows: `CryptoAPI`
+//! * Mac OS X: `CommonCrypto`
+//! * Linux/BSD/etc.: `OpenSSL`
+//!
+//! # Supported Algorithms
+//!
+//! * MD5
+//! * SHA1
+//! * SHA256
+//! * SHA512
+
+#![warn(missing_docs)]
+
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+extern crate commoncrypto;
+extern crate hex;
+#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "windows")))]
+extern crate openssl;
+#[cfg(target_os = "windows")]
+extern crate winapi;
+
+use std::io::Write;
+
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+#[path = "imp/commoncrypto.rs"]
+mod imp;
+#[cfg(target_os = "windows")]
+#[path = "imp/cryptoapi.rs"]
+mod imp;
+#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "windows")))]
+#[path = "imp/openssl.rs"]
+mod imp;
+
+mod test;
+
+pub use imp::Hasher;
+
+/// Available cryptographic hash functions.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum Algorithm {
+    /// Popular message digest algorithm, only available for backwards compatibility purposes.
+    MD5,
+    /// SHA-1 algorithm from NIST FIPS, only available for backwards compatibility purposes.
+    SHA1,
+    /// SHA-2 family algorithm (256 bits).
+    SHA256,
+    /// SHA-2 family algorithm (512 bits).
+    SHA512,
+}
+
+/// Helper function for `Hasher` which generates a cryptographic digest from the given
+/// data and algorithm.
+///
+/// # Examples
+///
+/// ```rust
+/// use crypto_hash::{Algorithm, digest};
+///
+/// let data = b"crypto-hash";
+/// let result = digest(Algorithm::SHA256, data);
+/// let expected =
+///     b"\xfd\x1a\xfb`\"\xcdMG\xc8\x90\x96\x1cS9(\xea\xcf\xe8!\x9f\x1b%$\xf7\xfb*a\x84}\xdf\x8c'"
+///     .to_vec();
+/// assert_eq!(expected, result)
+/// ```
+pub fn digest(algorithm: Algorithm, data: &[u8]) -> Vec<u8> {
+    let mut hasher = imp::Hasher::new(algorithm);
+    hasher.write_all(data).expect("Could not write hash data");
+    hasher.finish()
+}
+
+/// Helper function for `Hasher` which generates a cryptographic digest serialized in
+/// hexadecimal from the given data and algorithm.
+///
+/// # Examples
+///
+/// ```rust
+/// use crypto_hash::{Algorithm, hex_digest};
+///
+/// let data = b"crypto-hash";
+/// let result = hex_digest(Algorithm::SHA256, data);
+/// let expected = "fd1afb6022cd4d47c890961c533928eacfe8219f1b2524f7fb2a61847ddf8c27";
+/// assert_eq!(expected, result)
+/// ```
+pub fn hex_digest(algorithm: Algorithm, data: &[u8]) -> String {
+    hex::encode(digest(algorithm, data))
+}
diff --git a/vendor/crypto-hash/src/test.rs b/vendor/crypto-hash/src/test.rs
new file mode 100644
index 0000000..91ededb
--- /dev/null
+++ b/vendor/crypto-hash/src/test.rs
@@ -0,0 +1,83 @@
+// Copyright (c) 2016, 2017 Mark Lee
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#![cfg(test)]
+
+use super::{hex_digest, Algorithm, Hasher};
+use hex;
+use std::io::Write;
+
+// From Wikipedia
+const MD5_EMPTY_STRING: &'static str = "d41d8cd98f00b204e9800998ecf8427e";
+const SHA1_EMPTY_STRING: &'static str = "da39a3ee5e6b4b0d3255bfef95601890afd80709";
+const SHA256_EMPTY_STRING: &'static str = concat!(
+    "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649",
+    "b934ca495991b7852b855"
+);
+const SHA512_EMPTY_STRING: &'static str = concat!(
+    "cf83e1357eefb8bdf1542850d66d8007d620e4050b5",
+    "715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318",
+    "d2877eec2f63b931bd47417a81a538327af927da3e"
+);
+const TO_HASH: &'static str = "The quick brown fox jumps over the lazy dog";
+const TO_HASH_MD5: &'static str = "9e107d9d372bb6826bd81d3542a419d6";
+
+#[test]
+fn md5_empty_string() {
+    assert_hex_hashed_empty_string(Algorithm::MD5, MD5_EMPTY_STRING)
+}
+
+#[test]
+fn sha1_empty_string() {
+    assert_hex_hashed_empty_string(Algorithm::SHA1, SHA1_EMPTY_STRING)
+}
+
+#[test]
+fn sha256_empty_string() {
+    // From Wikipedia
+    assert_hex_hashed_empty_string(Algorithm::SHA256, SHA256_EMPTY_STRING)
+}
+
+#[test]
+fn sha512_empty_string() {
+    assert_hex_hashed_empty_string(Algorithm::SHA512, SHA512_EMPTY_STRING)
+}
+
+#[test]
+fn hasher_sans_write() {
+    let mut hasher = Hasher::new(Algorithm::MD5);
+    let actual = hex::encode(hasher.finish());
+    assert_eq!(MD5_EMPTY_STRING, actual)
+}
+
+#[test]
+fn hasher_with_write() {
+    let mut hasher = Hasher::new(Algorithm::MD5);
+    hasher
+        .write_all(TO_HASH.as_bytes())
+        .expect("Could not write to hasher");
+    let actual = hex::encode(hasher.finish());
+    assert_eq!(TO_HASH_MD5, actual)
+}
+
+fn assert_hex_hashed_empty_string(algorithm: Algorithm, expected: &str) {
+    let vec = vec![];
+    assert_eq!(expected, hex_digest(algorithm, vec.as_slice()).as_str())
+}