summaryrefslogtreecommitdiffstats
path: root/vendor/commoncrypto-sys
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/commoncrypto-sys')
-rw-r--r--vendor/commoncrypto-sys/.cargo-checksum.json1
-rw-r--r--vendor/commoncrypto-sys/Cargo.toml15
-rw-r--r--vendor/commoncrypto-sys/debian/patches/no-clippy.patch16
-rw-r--r--vendor/commoncrypto-sys/debian/patches/series1
-rw-r--r--vendor/commoncrypto-sys/src/lib.rs237
-rw-r--r--vendor/commoncrypto-sys/tests/hash.rs138
-rw-r--r--vendor/commoncrypto-sys/tests/pbkdf2.rs48
7 files changed, 456 insertions, 0 deletions
diff --git a/vendor/commoncrypto-sys/.cargo-checksum.json b/vendor/commoncrypto-sys/.cargo-checksum.json
new file mode 100644
index 0000000..6ad6734
--- /dev/null
+++ b/vendor/commoncrypto-sys/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{},"package":"1fed34f46747aa73dfaa578069fd8279d2818ade2b55f38f22a9401c7f4083e2"} \ No newline at end of file
diff --git a/vendor/commoncrypto-sys/Cargo.toml b/vendor/commoncrypto-sys/Cargo.toml
new file mode 100644
index 0000000..84ecf03
--- /dev/null
+++ b/vendor/commoncrypto-sys/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "commoncrypto-sys"
+version = "0.2.0"
+authors = ["Mark Lee"]
+description = "FFI bindings to Mac OS X's CommonCrypto library"
+documentation = "https://docs.rs/commoncrypto-sys"
+repository = "https://github.com/malept/rust-commoncrypto"
+keywords = ["crypto", "hash", "digest", "osx", "commoncrypto"]
+license = "MIT"
+
+[dependencies]
+libc = "0.2"
+
+[dev-dependencies]
+hex = "0.2"
diff --git a/vendor/commoncrypto-sys/debian/patches/no-clippy.patch b/vendor/commoncrypto-sys/debian/patches/no-clippy.patch
new file mode 100644
index 0000000..93789f3
--- /dev/null
+++ b/vendor/commoncrypto-sys/debian/patches/no-clippy.patch
@@ -0,0 +1,16 @@
+--- a/Cargo.toml
++++ b/Cargo.toml
+@@ -8,13 +8,8 @@
+ keywords = ["crypto", "hash", "digest", "osx", "commoncrypto"]
+ license = "MIT"
+
+-[features]
+-lint = ["clippy"]
+-
+ [dependencies]
+ libc = "0.2"
+
+-clippy = { version = "0.0", optional = true }
+-
+ [dev-dependencies]
+ hex = "0.2"
diff --git a/vendor/commoncrypto-sys/debian/patches/series b/vendor/commoncrypto-sys/debian/patches/series
new file mode 100644
index 0000000..bce9063
--- /dev/null
+++ b/vendor/commoncrypto-sys/debian/patches/series
@@ -0,0 +1 @@
+no-clippy.patch
diff --git a/vendor/commoncrypto-sys/src/lib.rs b/vendor/commoncrypto-sys/src/lib.rs
new file mode 100644
index 0000000..dce335a
--- /dev/null
+++ b/vendor/commoncrypto-sys/src/lib.rs
@@ -0,0 +1,237 @@
+// 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.
+
+//! Low-level bindings to OSX/macOS/iOS's `CommonCrypto` library.
+
+#![warn(missing_docs)]
+
+extern crate libc;
+
+use libc::{c_int, c_uint};
+
+/// Total number of operations.
+const MD5_CBLOCK: usize = 64;
+/// Number of operations per round.
+const MD5_LBLOCK: usize = MD5_CBLOCK / 4;
+/// Number of bytes for an MD5 hash.
+pub const MD5_DIGEST_LENGTH: usize = 16;
+
+const SHA_LBLOCK: usize = 16;
+/// Number of bytes for an SHA1 hash.
+pub const SHA1_DIGEST_LENGTH: usize = 20;
+/// Number of bytes for an SHA256 hash.
+pub const SHA256_DIGEST_LENGTH: usize = 32;
+/// Number of bytes for an SHA384 hash.
+pub const SHA384_DIGEST_LENGTH: usize = 48;
+/// Number of bytes for an SHA512 hash.
+pub const SHA512_DIGEST_LENGTH: usize = 64;
+
+/// Struct used to generate MD5 hashes.
+#[allow(non_camel_case_types, non_snake_case)]
+#[derive(Clone, Debug, Default, PartialEq)]
+#[repr(C)]
+pub struct CC_MD5_CTX {
+ A: c_uint,
+ B: c_uint,
+ C: c_uint,
+ D: c_uint,
+ Nl: c_uint,
+ Nh: c_uint,
+ data: [c_uint; MD5_LBLOCK],
+ num: c_uint,
+}
+
+/// Struct used to generate SHA1 hashes.
+#[allow(non_camel_case_types, non_snake_case)]
+#[derive(Clone, Debug, Default, PartialEq)]
+#[repr(C)]
+pub struct CC_SHA_CTX {
+ h0: c_uint,
+ h1: c_uint,
+ h2: c_uint,
+ h3: c_uint,
+ h4: c_uint,
+ Nl: c_uint,
+ Nh: c_uint,
+ data: [c_uint; SHA_LBLOCK],
+ num: c_uint,
+}
+
+macro_rules! cc_sha2_struct {
+ ($ctx_name: ident, $ty: ty) => {
+ /// Struct used to generate SHA2 hashes with the given bits.
+ #[allow(non_camel_case_types, non_snake_case)]
+ #[derive(Clone, Debug, Default, PartialEq)]
+ #[repr(C)]
+ pub struct $ctx_name {
+ count: [$ty; 2],
+ hash: [$ty; 8],
+ wbuf: [$ty; 16],
+ }
+ }
+}
+
+cc_sha2_struct!(CC_SHA256_CTX, u32);
+cc_sha2_struct!(CC_SHA512_CTX, u64);
+
+/// Digest algorithm used in `CCDigest*()` functions.
+#[repr(C)]
+pub enum CCDigestAlgorithm {
+ /// No digest algorithm
+ kCCDigestNone = 0,
+ /// MD2
+ kCCDigestMD2 = 1,
+ /// MD4
+ kCCDigestMD4 = 2,
+ /// MD5
+ kCCDigestMD5 = 3,
+ /// RIPEMD-128
+ kCCDigestRMD128 = 4,
+ /// RIPEMD-160
+ kCCDigestRMD160 = 5,
+ /// RIPEMD-256
+ kCCDigestRMD256 = 6,
+ /// RIPEMD-320
+ kCCDigestRMD320 = 7,
+ /// SHA1
+ kCCDigestSHA1 = 8,
+ /// SHA224
+ kCCDigestSHA224 = 9,
+ /// SHA256
+ kCCDigestSHA256 = 10,
+ /// SHA384
+ kCCDigestSHA384 = 11,
+ /// SHA512
+ kCCDigestSHA512 = 12,
+ /// Skein, 128 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein128 = 13,
+ /// Skein, 160 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein160 = 14,
+ /// Skein, 224 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein224 = 16,
+ /// Skein, 256 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein256 = 17,
+ /// Skein, 384 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein384 = 18,
+ /// Skein, 512 bit (Deprecated in iPhoneOS 6.0 and MacOSX10.9)
+ kCCDigestSkein512 = 19,
+}
+
+const CC_DIGEST_SIZE: usize = 1032;
+
+/// Context used in `CCDigest*()` functions.
+#[allow(non_camel_case_types, non_snake_case)]
+#[repr(C)]
+pub struct CCDigestCtx {
+ context: [u8; CC_DIGEST_SIZE],
+}
+
+/// Algorithm for use with `CCKeyDerivationPBKDF()`.
+#[repr(C)]
+pub enum CCPBKDFAlgorithm {
+ /// PBKDF2
+ kCCPBKDF2 = 2,
+}
+
+/// Pseudo-random algorithm to use with `CCKeyDerivationPBKDF()`.
+#[repr(C)]
+pub enum CCPseudoRandomAlgorithm {
+ /// SHA-1
+ kCCPRFHmacAlgSHA1 = 1,
+ /// SHA-224
+ kCCPRFHmacAlgSHA224 = 2,
+ /// SHA-256
+ kCCPRFHmacAlgSHA256 = 3,
+ /// SHA-384
+ kCCPRFHmacAlgSHA384 = 4,
+ /// SHA-512
+ kCCPRFHmacAlgSHA512 = 5,
+}
+
+extern "C" {
+ /// Initializes MD5 hasher. See `man 3cc CC_MD5` for details.
+ pub fn CC_MD5_Init(ctx: *mut CC_MD5_CTX) -> c_int;
+ /// Appends data to be hashed. See `man 3cc CC_MD5` for details.
+ pub fn CC_MD5_Update(ctx: *mut CC_MD5_CTX, data: *const u8, n: usize) -> c_int;
+ /// Generates MD5 hash. See `man 3cc CC_MD5` for details.
+ pub fn CC_MD5_Final(md: *mut u8, ctx: *mut CC_MD5_CTX) -> c_int;
+ /// Initializes SHA1 hasher. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA1_Init(ctx: *mut CC_SHA_CTX) -> c_int;
+ /// Appends data to be hashed. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA1_Update(ctx: *mut CC_SHA_CTX, data: *const u8, n: usize) -> c_int;
+ /// Generates SHA1 hash. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA1_Final(md: *mut u8, ctx: *mut CC_SHA_CTX) -> c_int;
+ /// Initializes SHA256 hasher. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA256_Init(ctx: *mut CC_SHA256_CTX) -> c_int;
+ /// Appends data to be hashed. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA256_Update(ctx: *mut CC_SHA256_CTX, data: *const u8, n: usize) -> c_int;
+ /// Generates SHA256 hash. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA256_Final(md: *mut u8, ctx: *mut CC_SHA256_CTX) -> c_int;
+ /// Initializes SHA384 hasher. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA384_Init(ctx: *mut CC_SHA512_CTX) -> c_int;
+ /// Appends data to be hashed. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA384_Update(ctx: *mut CC_SHA512_CTX, data: *const u8, n: usize) -> c_int;
+ /// Generates SHA384 hash. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA384_Final(md: *mut u8, ctx: *mut CC_SHA512_CTX) -> c_int;
+ /// Initializes SHA512 hasher. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA512_Init(ctx: *mut CC_SHA512_CTX) -> c_int;
+ /// Appends data to be hashed. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA512_Update(ctx: *mut CC_SHA512_CTX, data: *const u8, n: usize) -> c_int;
+ /// Generates SHA512 hash. See `man 3cc CC_SHA` for details.
+ pub fn CC_SHA512_Final(md: *mut u8, ctx: *mut CC_SHA512_CTX) -> c_int;
+ /// Generic digest hasher.
+ pub fn CCDigest(algorithm: CCDigestAlgorithm,
+ data: *const u8,
+ length: usize,
+ output: *mut u8)
+ -> c_int;
+ /// Allocate and initialize a `CCDigestCtx` for a digest.
+ pub fn CCDigestCreate(algorithm: CCDigestAlgorithm) -> *mut CCDigestCtx;
+ /// Continue to digest data. Returns `0` on success.
+ pub fn CCDigestUpdate(ctx: *mut CCDigestCtx, data: *const u8, length: usize) -> c_int;
+ /// Conclude digest operations and produce the digest output. Returns `0` on success.
+ pub fn CCDigestFinal(ctx: *mut CCDigestCtx, output: *mut u8) -> c_int;
+ /// Clear and free a `CCDigestCtx`.
+ pub fn CCDigestDestroy(ctx: *mut CCDigestCtx);
+ /// Clear and re-initialize a `CCDigestCtx` for the same algorithm.
+ pub fn CCDigestReset(ctx: *mut CCDigestCtx);
+ /// Produce the digest output result for the bytes currently processed. Returns `0` on success.
+ pub fn CCDigestGetDigest(ctx: *mut CCDigestCtx, output: *mut u8) -> c_int;
+ /// Provides the block size of the digest algorithm. Returns `0` on failure.
+ pub fn CCDigestGetBlockSize(algorithm: CCDigestAlgorithm) -> usize;
+ /// Provides the digest output size of the digest algorithm. Returns `0` on failure.
+ pub fn CCDigestGetOutputSize(algorithm: CCDigestAlgorithm) -> usize;
+ /// Provides the block size of the digest algorithm. Returns `0` on failure.
+ pub fn CCDigestGetBlockSizeFromRef(ctx: *mut CCDigestCtx) -> usize;
+ /// Provides the digest output size of the digest algorithm. Returns `0` on failure.
+ pub fn CCDigestGetOutputSizeFromRef(ctx: *mut CCDigestCtx) -> usize;
+
+ /// Derive a key from a user-supplied password via PBKDF2.
+ pub fn CCKeyDerivationPBKDF(algorithm: CCPBKDFAlgorithm,
+ password: *const u8,
+ passwordLen: usize,
+ salt: *const u8,
+ saltLen: usize,
+ prf: CCPseudoRandomAlgorithm,
+ rounds: u32,
+ derivedKey: *mut u8,
+ derivedKeyLen: usize)
+ -> c_int;
+}
diff --git a/vendor/commoncrypto-sys/tests/hash.rs b/vendor/commoncrypto-sys/tests/hash.rs
new file mode 100644
index 0000000..b41ea54
--- /dev/null
+++ b/vendor/commoncrypto-sys/tests/hash.rs
@@ -0,0 +1,138 @@
+extern crate commoncrypto_sys;
+extern crate hex;
+
+use hex::ToHex;
+
+const TO_HASH: &'static str = "The quick brown fox jumps over the lazy dog";
+const TO_HASH_MD5: &'static str = "9e107d9d372bb6826bd81d3542a419d6";
+const TO_HASH_SHA1: &'static str = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12";
+const TO_HASH_SHA256: &'static str = "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592";
+const TO_HASH_SHA384: &'static str = "ca737f1014a48f4c0b6dd43cb177b0afd9e5169367544c494011e3317dbf9a509cb1e5dc1e85a941bbee3d7f2afbc9b1";
+const TO_HASH_SHA512: &'static str = "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6";
+
+macro_rules! test_cc_hash {
+ (
+ $test_name: ident,
+ $ctx_ty: ident,
+ $digest_len: ident,
+ $init_func: ident,
+ $update_func: ident,
+ $final_func: ident,
+ $expected_hash: ident
+ ) => {
+ #[test]
+ fn $test_name() {
+ let mut ctx = commoncrypto_sys::$ctx_ty::default();
+ let mut md = [0u8; commoncrypto_sys::$digest_len];
+ unsafe {
+ assert_eq!(commoncrypto_sys::$init_func(&mut ctx), 1);
+ assert_eq!(commoncrypto_sys::$update_func(&mut ctx, TO_HASH.as_ptr(), TO_HASH.len()), 1);
+ assert_eq!(commoncrypto_sys::$final_func(md.as_mut_ptr(), &mut ctx), 1);
+ }
+ assert_eq!(md.to_vec().to_hex(), $expected_hash);
+ }
+ }
+}
+
+macro_rules! test_ccdigest {
+ (
+ $test_name: ident,
+ $algorithm: ident,
+ $digest_len: ident,
+ $expected_hash: ident
+ ) => {
+ #[test]
+ fn $test_name() {
+ let mut md = [0u8; commoncrypto_sys::$digest_len];
+ unsafe {
+ assert_eq!(commoncrypto_sys::CCDigest(commoncrypto_sys::CCDigestAlgorithm::$algorithm,
+ TO_HASH.as_ptr(),
+ TO_HASH.len(),
+ md.as_mut_ptr()), 0)
+ }
+ assert_eq!(md.to_vec().to_hex(), $expected_hash);
+ }
+ }
+}
+
+macro_rules! test_ccdigestgetoutputsize {
+ (
+ $test_name: ident,
+ $algorithm: ident,
+ $expected_digest_len: ident
+ ) => {
+ #[test]
+ fn $test_name() {
+ unsafe {
+ assert_eq!(commoncrypto_sys::CCDigestGetOutputSize(commoncrypto_sys::CCDigestAlgorithm::$algorithm),
+ commoncrypto_sys::$expected_digest_len);
+ }
+ }
+ }
+}
+
+test_cc_hash!(md5_hash,
+ CC_MD5_CTX,
+ MD5_DIGEST_LENGTH,
+ CC_MD5_Init,
+ CC_MD5_Update,
+ CC_MD5_Final,
+ TO_HASH_MD5);
+test_cc_hash!(sha1_hash,
+ CC_SHA_CTX,
+ SHA1_DIGEST_LENGTH,
+ CC_SHA1_Init,
+ CC_SHA1_Update,
+ CC_SHA1_Final,
+ TO_HASH_SHA1);
+test_cc_hash!(sha256_hash,
+ CC_SHA256_CTX,
+ SHA256_DIGEST_LENGTH,
+ CC_SHA256_Init,
+ CC_SHA256_Update,
+ CC_SHA256_Final,
+ TO_HASH_SHA256);
+test_cc_hash!(sha384_hash,
+ CC_SHA512_CTX,
+ SHA384_DIGEST_LENGTH,
+ CC_SHA384_Init,
+ CC_SHA384_Update,
+ CC_SHA384_Final,
+ TO_HASH_SHA384);
+test_cc_hash!(sha512_hash,
+ CC_SHA512_CTX,
+ SHA512_DIGEST_LENGTH,
+ CC_SHA512_Init,
+ CC_SHA512_Update,
+ CC_SHA512_Final,
+ TO_HASH_SHA512);
+
+test_ccdigest!(md5_ccdigest, kCCDigestMD5, MD5_DIGEST_LENGTH, TO_HASH_MD5);
+test_ccdigest!(sha1_ccdigest,
+ kCCDigestSHA1,
+ SHA1_DIGEST_LENGTH,
+ TO_HASH_SHA1);
+test_ccdigest!(sha256_ccdigest,
+ kCCDigestSHA256,
+ SHA256_DIGEST_LENGTH,
+ TO_HASH_SHA256);
+test_ccdigest!(sha384_ccdigest,
+ kCCDigestSHA384,
+ SHA384_DIGEST_LENGTH,
+ TO_HASH_SHA384);
+test_ccdigest!(sha512_ccdigest,
+ kCCDigestSHA512,
+ SHA512_DIGEST_LENGTH,
+ TO_HASH_SHA512);
+
+test_ccdigestgetoutputsize!(md5_ccdigestoutputsize, kCCDigestMD5, MD5_DIGEST_LENGTH);
+test_ccdigestgetoutputsize!(sha1_ccdigestoutputsize, kCCDigestSHA1, SHA1_DIGEST_LENGTH);
+test_ccdigestgetoutputsize!(sha256_ccdigestoutputsize,
+ kCCDigestSHA256,
+ SHA256_DIGEST_LENGTH);
+test_ccdigestgetoutputsize!(sha384_ccdigestoutputsize,
+ kCCDigestSHA384,
+ SHA384_DIGEST_LENGTH);
+test_ccdigestgetoutputsize!(sha512_ccdigestoutputsize,
+ kCCDigestSHA512,
+ SHA512_DIGEST_LENGTH);
diff --git a/vendor/commoncrypto-sys/tests/pbkdf2.rs b/vendor/commoncrypto-sys/tests/pbkdf2.rs
new file mode 100644
index 0000000..743a49a
--- /dev/null
+++ b/vendor/commoncrypto-sys/tests/pbkdf2.rs
@@ -0,0 +1,48 @@
+extern crate commoncrypto_sys;
+extern crate hex;
+
+use hex::{ToHex, FromHex};
+
+// These password, salts, rounds and derived key values come from the test
+// vectors stated in RFC 6070
+const PASSWORD: &'static str = "password";
+const SALT: &'static str = "salt";
+
+const DERIVED1: &'static str = "0c60c80f961f0e71f3a9b524af6012062fe037a6";
+const DERIVED4096: &'static str = "4b007901b765489abead49d926f721d065a429c1";
+
+macro_rules! test_pbkdf2 {
+ (
+ $test_name: ident,
+ $prf_algorithm: ident,
+ $pw: ident,
+ $salt: ident,
+ $rounds: expr,
+ $expected_dkey: ident
+ ) => {
+ #[test]
+ fn $test_name() {
+ let derived_len = Vec::<u8>::from_hex($expected_dkey).expect("dkey from hex").len();
+ let mut pw_derived = vec![0u8; derived_len];
+ unsafe {
+ assert_eq!(0, commoncrypto_sys::CCKeyDerivationPBKDF(
+ commoncrypto_sys::CCPBKDFAlgorithm::kCCPBKDF2,
+ $pw.as_ptr(), $pw.len(),
+ $salt.as_ptr(), $salt.len(),
+ commoncrypto_sys::CCPseudoRandomAlgorithm::$prf_algorithm,
+ $rounds,
+ pw_derived.as_mut_ptr(), pw_derived.len()
+ ));
+ }
+ assert_eq!($expected_dkey, pw_derived.to_hex());
+ }
+ }
+}
+
+test_pbkdf2!(pbkdf2_1, kCCPRFHmacAlgSHA1, PASSWORD, SALT, 1, DERIVED1);
+test_pbkdf2!(pbkdf2_4096,
+ kCCPRFHmacAlgSHA1,
+ PASSWORD,
+ SALT,
+ 4096,
+ DERIVED4096);
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-29 23:44:16 +0000