libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_crypto.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KMS_MESSAGE_KMS_CRYPTO_H
+#define KMS_MESSAGE_KMS_CRYPTO_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct {
+   bool (*sha256) (void *ctx,
+                   const char *input,
+                   size_t len,
+                   unsigned char *hash_out);
+   bool (*sha256_hmac) (void *ctx,
+                        const char *key_input,
+                        size_t key_len,
+                        const char *input,
+                        size_t len,
+                        unsigned char *hash_out);
+   bool (*sign_rsaes_pkcs1_v1_5) (void *sign_ctx,
+                                  const char *private_key,
+                                  size_t private_key_len,
+                                  const char *input,
+                                  size_t input_len,
+                                  unsigned char *signature_out);
+   void *ctx;
+   void *sign_ctx;
+} _kms_crypto_t;
+
+int
+kms_crypto_init (void);
+
+void
+kms_crypto_cleanup (void);
+
+bool
+kms_sha256 (void *ctx, const char *input, size_t len, unsigned char *hash_out);
+
+bool
+kms_sha256_hmac (void *ctx,
+                 const char *key_input,
+                 size_t key_len,
+                 const char *input,
+                 size_t len,
+                 unsigned char *hash_out);
+
+/* signature_out must be a preallocated buffer of 256 bytes (or greater). */
+bool
+kms_sign_rsaes_pkcs1_v1_5 (void *sign_ctx,
+                           const char *private_key,
+                           size_t private_key_len,
+                           const char *input,
+                           size_t input_len,
+                           unsigned char *signature_out);
+
+#endif /* KMS_MESSAGE_KMS_CRYPTO_H */

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_crypto_apple.c

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kms_crypto.h"
+#include "kms_message_private.h" /* KMS_ASSERT */
+
+#ifdef KMS_MESSAGE_ENABLE_CRYPTO_COMMON_CRYPTO
+
+#include <CommonCrypto/CommonDigest.h>
+#include <CommonCrypto/CommonHMAC.h>
+#include <CoreFoundation/CFArray.h>
+#include <Security/SecKey.h>
+#include <Security/SecItem.h>
+#include <Security/SecImportExport.h>
+
+int
+kms_crypto_init (void)
+{
+   return 0;
+}
+
+void
+kms_crypto_cleanup (void)
+{
+}
+
+bool
+kms_sha256 (void *unused_ctx,
+            const char *input,
+            size_t len,
+            unsigned char *hash_out)
+{
+   CC_SHA256_CTX ctx;
+   CC_SHA256_Init (&ctx);
+   KMS_ASSERT (len <= (size_t) UINT32_MAX);
+   CC_SHA256_Update (&ctx, input, (uint32_t) len);
+   CC_SHA256_Final (hash_out, &ctx);
+   return true;
+}
+
+bool
+kms_sha256_hmac (void *unused_ctx,
+                 const char *key_input,
+                 size_t key_len,
+                 const char *input,
+                 size_t len,
+                 unsigned char *hash_out)
+{
+   CCHmac (kCCHmacAlgSHA256, key_input, key_len, input, len, hash_out);
+   return true;
+}
+
+static void
+safe_CFRelease (CFTypeRef ptr)
+{
+   if (ptr) {
+      CFRelease (ptr);
+   }
+}
+
+bool
+kms_sign_rsaes_pkcs1_v1_5 (void *unused_ctx,
+                           const char *private_key,
+                           size_t private_key_len,
+                           const char *input,
+                           size_t input_len,
+                           unsigned char *signature_out)
+{
+   CFDataRef key_data_ref = NULL;
+   CFDataRef pass_ref = NULL;
+   SecItemImportExportKeyParameters import_params;
+   OSStatus status;
+   /* TODO: I think the expected format should be kSecFormatWrappedPKCS8, but
+    * GCP keys appear to only load for kSecFormatBSAFE. */
+   SecExternalFormat format = kSecFormatUnknown;
+   SecExternalItemType type = kSecItemTypePrivateKey;
+   CFArrayRef out_ref = NULL;
+   SecKeyRef key_ref = NULL;
+   CFDataRef data_to_sign_ref = NULL;
+   CFErrorRef error_ref;
+   CFDataRef signature_ref = NULL;
+   bool ret = false;
+
+   key_data_ref = CFDataCreate (NULL /* default allocator */,
+                                (const uint8_t *) private_key,
+                                (CFIndex) private_key_len);
+   if (!key_data_ref) {
+      goto cleanup;
+   }
+   memset (&import_params, 0, sizeof (SecItemImportExportKeyParameters));
+   import_params.version = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION;
+
+   /* Give an empty password. SecItemImport returns an error expecting a
+    * password. */
+   pass_ref = CFDataCreate (NULL, NULL, 0);
+   if (!pass_ref) {
+      goto cleanup;
+   }
+   import_params.passphrase = (CFTypeRef) pass_ref;
+
+   status = SecItemImport (key_data_ref,
+                           NULL /* extension. */,
+                           &format,
+                           &type,
+                           0,
+                           &import_params,
+                           NULL /* keychain */,
+                           &out_ref);
+   if (status != errSecSuccess) {
+      goto cleanup;
+   }
+   if (1 != CFArrayGetCount (out_ref)) {
+      goto cleanup;
+   }
+
+   key_ref = (SecKeyRef) CFArrayGetValueAtIndex (out_ref, 0);
+   KMS_ASSERT (input_len <= (size_t) LONG_MAX);
+   data_to_sign_ref =
+      CFDataCreate (NULL, (const uint8_t *) input, (long) input_len);
+   if (!data_to_sign_ref) {
+      goto cleanup;
+   }
+   error_ref = NULL;
+   signature_ref =
+      SecKeyCreateSignature (key_ref,
+                             kSecKeyAlgorithmRSASignatureMessagePKCS1v15SHA256,
+                             data_to_sign_ref,
+                             &error_ref);
+   if (!signature_ref) {
+      goto cleanup;
+   }
+   memcpy (signature_out,
+           CFDataGetBytePtr (signature_ref),
+           (size_t) CFDataGetLength (signature_ref));
+
+   ret = true;
+cleanup:
+   safe_CFRelease (key_data_ref);
+   safe_CFRelease (pass_ref);
+   safe_CFRelease (out_ref);
+   safe_CFRelease (data_to_sign_ref);
+   safe_CFRelease (signature_ref);
+   return ret;
+}
+
+#endif /* KMS_MESSAGE_ENABLE_CRYPTO_COMMON_CRYPTO */

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_crypto_libcrypto.c

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kms_crypto.h"
+#include "kms_message_private.h"
+
+#ifdef KMS_MESSAGE_ENABLE_CRYPTO_LIBCRYPTO
+
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <limits.h> /* INT_MAX, LONG_MAX */
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+   (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
+static EVP_MD_CTX *
+EVP_MD_CTX_new (void)
+{
+   return calloc (sizeof (EVP_MD_CTX), 1);
+}
+
+static void
+EVP_MD_CTX_free (EVP_MD_CTX *ctx)
+{
+   EVP_MD_CTX_cleanup (ctx);
+   free (ctx);
+}
+#endif
+
+int
+kms_crypto_init (void)
+{
+   return 0;
+}
+
+void
+kms_crypto_cleanup (void)
+{
+}
+
+bool
+kms_sha256 (void *unused_ctx,
+            const char *input,
+            size_t len,
+            unsigned char *hash_out)
+{
+   EVP_MD_CTX *digest_ctxp = EVP_MD_CTX_new ();
+   bool rval = false;
+
+   if (1 != EVP_DigestInit_ex (digest_ctxp, EVP_sha256 (), NULL)) {
+      goto cleanup;
+   }
+
+   if (1 != EVP_DigestUpdate (digest_ctxp, input, len)) {
+      goto cleanup;
+   }
+
+   rval = (1 == EVP_DigestFinal_ex (digest_ctxp, hash_out, NULL));
+
+cleanup:
+   EVP_MD_CTX_free (digest_ctxp);
+
+   return rval;
+}
+
+bool
+kms_sha256_hmac (void *unused_ctx,
+                 const char *key_input,
+                 size_t key_len,
+                 const char *input,
+                 size_t len,
+                 unsigned char *hash_out)
+{
+   KMS_ASSERT (key_len <= INT_MAX);
+   return HMAC (EVP_sha256 (),
+                key_input,
+                (int) key_len,
+                (unsigned char *) input,
+                len,
+                hash_out,
+                NULL) != NULL;
+}
+
+bool
+kms_sign_rsaes_pkcs1_v1_5 (void *unused_ctx,
+                           const char *private_key,
+                           size_t private_key_len,
+                           const char *input,
+                           size_t input_len,
+                           unsigned char *signature_out)
+{
+   EVP_MD_CTX *ctx;
+   EVP_PKEY *pkey = NULL;
+   bool ret = false;
+   size_t signature_out_len = 256;
+
+   ctx = EVP_MD_CTX_new ();
+   KMS_ASSERT (private_key_len <= LONG_MAX);
+   pkey = d2i_PrivateKey (EVP_PKEY_RSA,
+                          NULL,
+                          (const unsigned char **) &private_key,
+                          (long) private_key_len);
+   if (!pkey) {
+      goto cleanup;
+   }
+
+   ret = EVP_DigestSignInit (ctx, NULL, EVP_sha256 (), NULL /* engine */, pkey);
+   if (ret != 1) {
+      goto cleanup;
+   }
+
+   ret = EVP_DigestSignUpdate (ctx, input, input_len);
+   if (ret != 1) {
+      goto cleanup;
+   }
+
+   ret = EVP_DigestSignFinal (ctx, signature_out, &signature_out_len);
+   if (ret != 1) {
+      goto cleanup;
+   }
+
+   ret = true;
+cleanup:
+   EVP_MD_CTX_free (ctx);
+   EVP_PKEY_free (pkey);
+   return ret;
+}
+
+#endif /* KMS_MESSAGE_ENABLE_CRYPTO_LIBCRYPTO */

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_crypto_none.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kms_crypto.h"
+
+#ifndef KMS_MESSAGE_ENABLE_CRYPTO
+
+int
+kms_crypto_init (void)
+{
+   return 0;
+}
+
+void
+kms_crypto_cleanup (void)
+{
+}
+
+bool
+kms_sha256 (void *unused_ctx,
+            const char *input,
+            size_t len,
+            unsigned char *hash_out)
+{
+   /* only gets called if hooks were mistakenly not set */
+   return false;
+}
+
+bool
+kms_sha256_hmac (void *unused_ctx,
+                 const char *key_input,
+                 size_t key_len,
+                 const char *input,
+                 size_t len,
+                 unsigned char *hash_out)
+{
+   /* only gets called if hooks were mistakenly not set */
+   return false;
+}
+
+bool
+kms_sign_rsaes_pkcs1_v1_5 (void *unused_ctx,
+                           const char *private_key,
+                           size_t private_key_len,
+                           const char *input,
+                           size_t input_len,
+                           unsigned char *signature_out) {
+   /* only gets called if hooks were mistakenly not set */
+   return false;
+}
+
+#endif /* KMS_MESSAGE_ENABLE_CRYPTO */

data/ext/libmongocrypt/libmongocrypt/kms-message/src/kms_crypto_windows.c

@@ -0,0 +1,268 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kms_crypto.h"
+
+#ifdef KMS_MESSAGE_ENABLE_CRYPTO_CNG
+
+// tell windows.h not to include a bunch of headers we don't need:
+#define WIN32_LEAN_AND_MEAN
+
+// Tell windows.h not to define any NT status codes, so that we can
+// get the definitions from ntstatus.h, which has a more complete list.
+#define WIN32_NO_STATUS
+
+#include <windows.h>
+
+#undef WIN32_NO_STATUS
+
+// Obtain a definition for the ntstatus type.
+#include <winternl.h>
+
+// Add back in the status definitions so that macro expansions for
+// things like STILL_ACTIVE and WAIT_OBJECT_O can be resolved (they
+// expand to STATUS_ codes).
+#include <ntstatus.h>
+
+#include <bcrypt.h>
+#include <wincrypt.h>
+
+static BCRYPT_ALG_HANDLE _algoSHA256 = 0;
+static BCRYPT_ALG_HANDLE _algoSHA256Hmac = 0;
+static BCRYPT_ALG_HANDLE _algoRSA = 0;
+
+#define SHA_256_HASH_LEN 32
+
+int
+kms_crypto_init (void)
+{
+   if (BCryptOpenAlgorithmProvider (
+          &_algoSHA256, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0) !=
+       STATUS_SUCCESS) {
+      return 1;
+   }
+
+   if (BCryptOpenAlgorithmProvider (&_algoSHA256Hmac,
+                                    BCRYPT_SHA256_ALGORITHM,
+                                    MS_PRIMITIVE_PROVIDER,
+                                    BCRYPT_ALG_HANDLE_HMAC_FLAG) !=
+       STATUS_SUCCESS) {
+      return 2;
+   }
+
+   if (BCryptOpenAlgorithmProvider (
+          &_algoRSA, BCRYPT_RSA_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0) !=
+       STATUS_SUCCESS) {
+      return 3;
+   }
+
+   return 0;
+}
+
+void
+kms_crypto_cleanup (void)
+{
+   (void) BCryptCloseAlgorithmProvider (_algoSHA256, 0);
+   (void) BCryptCloseAlgorithmProvider (_algoSHA256Hmac, 0);
+   (void) BCryptCloseAlgorithmProvider (_algoRSA, 0);
+}
+
+bool
+kms_sha256 (void *unused_ctx,
+            const char *input,
+            size_t len,
+            unsigned char *hash_out)
+{
+   BCRYPT_HASH_HANDLE hHash;
+
+   NTSTATUS status =
+      BCryptCreateHash (_algoSHA256, &hHash, NULL, 0, NULL, 0, 0);
+   if (status != STATUS_SUCCESS) {
+      return 0;
+   }
+
+   status = BCryptHashData (hHash, (PUCHAR) (input), (ULONG) len, 0);
+   if (status != STATUS_SUCCESS) {
+      goto cleanup;
+   }
+
+   // Hardcode output length
+   status = BCryptFinishHash (hHash, hash_out, 256 / 8, 0);
+   if (status != STATUS_SUCCESS) {
+      goto cleanup;
+   }
+
+cleanup:
+   (void) BCryptDestroyHash (hHash);
+
+   return status == STATUS_SUCCESS ? 1 : 0;
+}
+
+bool
+kms_sha256_hmac (void *unused_ctx,
+                 const char *key_input,
+                 size_t key_len,
+                 const char *input,
+                 size_t len,
+                 unsigned char *hash_out)
+{
+   BCRYPT_HASH_HANDLE hHash;
+
+   NTSTATUS status = BCryptCreateHash (
+      _algoSHA256Hmac, &hHash, NULL, 0, (PUCHAR) key_input, (ULONG) key_len, 0);
+   if (status != STATUS_SUCCESS) {
+      return 0;
+   }
+
+   status = BCryptHashData (hHash, (PUCHAR) input, (ULONG) len, 0);
+   if (status != STATUS_SUCCESS) {
+      goto cleanup;
+   }
+
+   // Hardcode output length
+   status = BCryptFinishHash (hHash, hash_out, 256 / 8, 0);
+   if (status != STATUS_SUCCESS) {
+      goto cleanup;
+   }
+
+cleanup:
+   (void) BCryptDestroyHash (hHash);
+
+   return status == STATUS_SUCCESS ? 1 : 0;
+}
+
+bool
+kms_sign_rsaes_pkcs1_v1_5 (void *unused_ctx,
+                           const char *private_key,
+                           size_t private_key_len,
+                           const char *input,
+                           size_t input_len,
+                           unsigned char *signature_out)
+{
+   bool success = false;
+   bool ret = false;
+   LPBYTE blob_private = NULL;
+   DWORD blob_private_len = 0;
+   LPBYTE raw_private = NULL;
+   DWORD raw_private_len = 0;
+
+   NTSTATUS status;
+   BCRYPT_KEY_HANDLE hKey = NULL;
+   BCRYPT_PKCS1_PADDING_INFO padding_PKCS1;
+
+   unsigned char *hash_value = NULL;
+   DWORD hash_length = 256;
+
+   success = CryptDecodeObjectEx (X509_ASN_ENCODING,
+                                  PKCS_PRIVATE_KEY_INFO,
+                                  private_key,
+                                  (DWORD) private_key_len,
+                                  0,
+                                  NULL,
+                                  NULL,
+                                  &blob_private_len);
+   if (!success) {
+      goto cleanup;
+   }
+
+   blob_private = (LPBYTE) calloc (1, blob_private_len);
+
+   success = CryptDecodeObjectEx (X509_ASN_ENCODING,
+                                  PKCS_PRIVATE_KEY_INFO,
+                                  private_key,
+                                  (DWORD) private_key_len,
+                                  0,
+                                  NULL,
+                                  blob_private,
+                                  &blob_private_len);
+   if (!success) {
+      goto cleanup;
+   }
+
+   CRYPT_PRIVATE_KEY_INFO *privateKeyInfo =
+      (CRYPT_PRIVATE_KEY_INFO *) blob_private;
+
+   success = CryptDecodeObjectEx (X509_ASN_ENCODING,
+                                  PKCS_RSA_PRIVATE_KEY,
+                                  privateKeyInfo->PrivateKey.pbData,
+                                  (DWORD) privateKeyInfo->PrivateKey.cbData,
+                                  0,
+                                  NULL,
+                                  NULL,
+                                  &raw_private_len);
+   if (!success) {
+      goto cleanup;
+   }
+
+   raw_private = (LPBYTE) calloc (1, raw_private_len);
+
+   success = CryptDecodeObjectEx (X509_ASN_ENCODING,
+                                  PKCS_RSA_PRIVATE_KEY,
+                                  privateKeyInfo->PrivateKey.pbData,
+                                  (DWORD) privateKeyInfo->PrivateKey.cbData,
+                                  0,
+                                  NULL,
+                                  raw_private,
+                                  &raw_private_len);
+   if (!success) {
+      goto cleanup;
+   }
+
+   status = BCryptImportKeyPair (
+      _algoRSA,                
+      NULL,                   
+      LEGACY_RSAPRIVATE_BLOB, 
+      &hKey,            
+      raw_private,            
+      raw_private_len,       
+      0);                     
+   if (!NT_SUCCESS (status)) {
+      goto cleanup;
+   }
+
+   hash_value = calloc (1, SHA_256_HASH_LEN);
+
+   if(!kms_sha256 (NULL, input, input_len, hash_value)) {
+      goto cleanup;
+   }
+
+   padding_PKCS1.pszAlgId = BCRYPT_SHA256_ALGORITHM;
+
+   status =
+      BCryptSignHash (hKey,
+                      &padding_PKCS1,
+                      hash_value,        
+                      SHA_256_HASH_LEN,            
+                      signature_out,
+                      hash_length, 
+                      &hash_length, 
+                      BCRYPT_PAD_PKCS1); 
+   if (!NT_SUCCESS (status)) {
+      goto cleanup;
+   }
+
+   ret = true;
+
+cleanup:
+   BCryptDestroyKey(hKey);
+   free (blob_private);
+   free (raw_private);
+   free (hash_value);
+
+   return ret;
+}
+
+#endif /* KMS_MESSAGE_ENABLE_CRYPTO_CNG */