libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/src/crypto/none.c

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2019-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.
+ */
+
+/* everything is a no-op */
+
+#include "../mongocrypt-crypto-private.h"
+#include "../mongocrypt-private.h"
+
+#ifndef MONGOCRYPT_ENABLE_CRYPTO
+
+bool _native_crypto_initialized = false;
+
+void
+_native_crypto_init (void)
+{
+   _native_crypto_initialized = true;
+}
+
+
+bool
+_native_crypto_aes_256_cbc_encrypt (aes_256_args_t args)
+{
+   mongocrypt_status_t *status = args.status;
+   CLIENT_ERR ("hook not set for aes_256_cbc_encrypt");
+   return false;
+}
+
+
+bool
+_native_crypto_aes_256_cbc_decrypt (aes_256_args_t args)
+{
+   mongocrypt_status_t *status = args.status;
+   CLIENT_ERR ("hook not set for aes_256_cbc_decrypt");
+   return false;
+}
+
+
+bool
+_native_crypto_hmac_sha_512 (const _mongocrypt_buffer_t *key,
+                             const _mongocrypt_buffer_t *in,
+                             _mongocrypt_buffer_t *out,
+                             mongocrypt_status_t *status)
+{
+   CLIENT_ERR ("hook not set for hmac_sha_512");
+   return false;
+}
+
+
+bool
+_native_crypto_random (_mongocrypt_buffer_t *out,
+                       uint32_t count,
+                       mongocrypt_status_t *status)
+{
+   CLIENT_ERR ("hook not set for random");
+   return false;
+}
+
+bool
+_native_crypto_aes_256_ctr_encrypt (aes_256_args_t args)
+{
+   mongocrypt_status_t *status = args.status;
+   CLIENT_ERR ("hook not set for _native_crypto_aes_256_ctr_encrypt");
+   return false;
+}
+
+bool
+_native_crypto_aes_256_ctr_decrypt (aes_256_args_t args)
+{
+   mongocrypt_status_t *status = args.status;
+   CLIENT_ERR ("hook not set for _native_crypto_aes_256_ctr_decrypt");
+   return false;
+}
+
+bool
+_native_crypto_hmac_sha_256 (const _mongocrypt_buffer_t *key,
+                             const _mongocrypt_buffer_t *in,
+                             _mongocrypt_buffer_t *out,
+                             mongocrypt_status_t *status)
+{
+   CLIENT_ERR ("hook not set for _native_crypto_hmac_sha_256");
+   return false;
+}
+
+#endif /* MONGOCRYPT_ENABLE_CRYPTO */

data/ext/libmongocrypt/libmongocrypt/src/csfle-markup.cpp

@@ -0,0 +1,237 @@
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <bson/bson.h>
+
+extern "C" {
+#include "./mongocrypt-dll-private.h"
+}
+
+#include <sstream>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cstdint>
+
+#include <mongo_crypt-v1.h>
+
+namespace
+{
+void
+print_usage ()
+{
+   std::cout << "Usage:\n"
+             << "  csfle-markup <csfle-dll-path> [doc-namespace]\n"
+             << "\n"
+             << "Write a JSON document to stdin, and the resulting marked-up\n"
+             << "document will be written to stdout.\n\n"
+             << "Hint: Pipe through \"jq .\" for prettier output.\n";
+}
+
+template <typename Fn> struct deferred_fn {
+   Fn fn;
+
+   ~deferred_fn ()
+   {
+      fn ();
+   }
+};
+
+template <typename F>
+deferred_fn<F>
+make_deferred (F fn)
+{
+   return deferred_fn<F>{fn};
+}
+
+#define DEFER(...) make_deferred ([&] __VA_ARGS__)
+
+void
+bson_child (bson_t *out, bson_iter_t *it)
+{
+   uint32_t len;
+   const uint8_t *data;
+   if (BSON_ITER_HOLDS_DOCUMENT (it)) {
+      bson_iter_document (it, &len, &data);
+   }
+   if (BSON_ITER_HOLDS_ARRAY (it)) {
+      bson_iter_array (it, &len, &data);
+   }
+   bool okay = bson_init_static (out, data, len);
+   assert (okay);
+}
+
+void
+print_field_info (bson_t *bson, std::string path)
+{
+   bson_iter_t iter;
+   for (bson_iter_init (&iter, bson); bson_iter_next (&iter);) {
+      auto key = bson_iter_key (&iter);
+      auto child_path = path + "/" + key;
+      if (BSON_ITER_HOLDS_ARRAY (&iter) || BSON_ITER_HOLDS_DOCUMENT (&iter)) {
+         bson_t child;
+         bson_child (&child, &iter);
+         print_field_info (&child, child_path);
+      }
+      if (BSON_ITER_HOLDS_BINARY (&iter)) {
+         bson_subtype_t subtype;
+         uint32_t len;
+         const uint8_t *data;
+         bson_iter_binary (&iter, &subtype, &len, &data);
+         if (subtype == BSON_SUBTYPE_ENCRYPTED && len) {
+            bson_t encoded;
+            uint8_t subsubtype = data[0];
+            if (subsubtype == 0) {
+               // Intent-to-encrypt
+               BSON_ASSERT (len > 0);
+               bson_init_static (&encoded, data + 1, len - 1);
+               auto s = bson_as_canonical_extended_json (&encoded, nullptr);
+               fprintf (stderr,
+                        "BSON binary at [%s] has encoded intent-to-encrypt "
+                        "content: %s\n",
+                        child_path.data (),
+                        s);
+               bson_free (s);
+            }
+         }
+      }
+   }
+}
+
+int
+do_main (int argc, const char *const *argv)
+{
+   if (argc < 2 || argc > 3) {
+      print_usage ();
+      return 2;
+   }
+   if (argv[1] == std::string ("--help")) {
+      print_usage ();
+      return 0;
+   }
+   const auto csfle_path = argv[1];
+   const auto doc_ns = argc > 2 ? argv[2] : "";
+
+   mcr_dll csfle = mcr_dll_open (argv[1]);
+   auto close_csfle = DEFER ({ mcr_dll_close (csfle); });
+   if (csfle.error_string.data) {
+      std::cerr << "Failed to open [" << argv[1]
+                << "] as a dynamic library: " << csfle.error_string.data
+                << '\n';
+      return 3;
+   }
+
+#define LOAD_SYM(Name)                                                       \
+   auto Name =                                                               \
+      reinterpret_cast<decltype (&(::Name))> (mcr_dll_sym (csfle, #Name));   \
+   if (!Name) {                                                              \
+      fprintf (                                                              \
+         stderr,                                                             \
+         "Failed to load required symbol [%s] from the given csfle library", \
+         #Name);                                                             \
+      return 4;                                                              \
+   }                                                                         \
+   static_assert (true, "")
+
+   LOAD_SYM (mongo_crypt_v1_status_create);
+   LOAD_SYM (mongo_crypt_v1_status_destroy);
+   LOAD_SYM (mongo_crypt_v1_status_get_explanation);
+   LOAD_SYM (mongo_crypt_v1_lib_create);
+   LOAD_SYM (mongo_crypt_v1_lib_destroy);
+   LOAD_SYM (mongo_crypt_v1_get_version_str);
+   LOAD_SYM (mongo_crypt_v1_query_analyzer_create);
+   LOAD_SYM (mongo_crypt_v1_query_analyzer_destroy);
+   LOAD_SYM (mongo_crypt_v1_analyze_query);
+   LOAD_SYM (mongo_crypt_v1_bson_free);
+
+   fprintf (stderr,
+            "Loaded csfle library [%s]: %s\n",
+            csfle_path,
+            mongo_crypt_v1_get_version_str ());
+
+   // Read from stdin
+   std::stringstream strm;
+   strm << std::cin.rdbuf ();
+   std::string input_json = strm.str ();
+
+   bson_error_t error;
+   bson_t *input = bson_new_from_json (
+      reinterpret_cast<const uint8_t *> (input_json.c_str ()),
+      static_cast<ssize_t> (input_json.size ()),
+      &error);
+   if (!input) {
+      std::cerr << "Failed to read JSON data: " << error.message << '\n';
+      return 5;
+   }
+   auto del_bson = DEFER ({ bson_destroy (input); });
+
+   bson_iter_t find_db;
+   if (!bson_iter_init_find (&find_db, input, "$db")) {
+      fputs ("Note: Added a {\"$db\": \"unspecified\"} field to the document "
+             "root. This field is required for csfle.\n",
+             stderr);
+      BSON_APPEND_UTF8 (input, "$db", "unspecified");
+   }
+
+   auto status = mongo_crypt_v1_status_create ();
+   auto del_status = DEFER ({ mongo_crypt_v1_status_destroy (status); });
+
+   auto lib = mongo_crypt_v1_lib_create (status);
+   if (!lib) {
+      fprintf (stderr,
+               "Failed to lib_create for csfle: %s\n",
+               mongo_crypt_v1_status_get_explanation (status));
+      return 6;
+   }
+   auto del_lib = DEFER ({ mongo_crypt_v1_lib_destroy (lib, nullptr); });
+
+   auto qa = mongo_crypt_v1_query_analyzer_create (lib, status);
+   if (!qa) {
+      fprintf (stderr,
+               "Failed to create a query analyzer for csfle: %s\n",
+               mongo_crypt_v1_status_get_explanation (status));
+      return 7;
+   }
+   auto del_qa = DEFER ({ mongo_crypt_v1_query_analyzer_destroy (qa); });
+
+   uint32_t data_len = input->len;
+   uint8_t *data_ptr = mongo_crypt_v1_analyze_query (
+      qa,
+      bson_get_data (input),
+      doc_ns,
+      static_cast<std::uint32_t> (strlen (doc_ns)),
+      &data_len,
+      status);
+   if (!data_ptr) {
+      fprintf (stderr,
+               "Failed to analyze the given query: %s\n",
+               mongo_crypt_v1_status_get_explanation (status));
+      return 8;
+   }
+   auto del_data = DEFER ({ mongo_crypt_v1_bson_free (data_ptr); });
+
+   bson_t *output = bson_new_from_data (data_ptr, data_len);
+   assert (output);
+   auto del_output = DEFER ({ bson_destroy (output); });
+
+   auto s = bson_as_canonical_extended_json (output, nullptr);
+   fputs (s, stdout);
+   bson_free (s);
+
+   print_field_info (output, "");
+
+   return 0;
+}
+} // namespace
+
+int
+main (int argc, const char **argv)
+{
+   try {
+      return do_main (argc, argv);
+   } catch (const std::exception &e) {
+      std::cerr << "Unhandled exception: " << e.what () << '\n';
+      return 2;
+   }
+}

data/ext/libmongocrypt/libmongocrypt/src/mc-array-private.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022-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 MC_ARRAY_PRIVATE_H
+#define MC_ARRAY_PRIVATE_H
+
+/* This file is copied from mongoc-array-private.h in libmongoc version 1.17.7
+ * at commit 200a01bb208633fe3cf395d81acc1e19492d9de4 */
+
+#include <bson/bson.h>
+
+
+typedef struct _mc_array_t mc_array_t;
+
+
+struct _mc_array_t {
+   size_t len;
+   size_t element_size;
+   size_t allocated;
+   void *data;
+};
+
+
+#define _mc_array_append_val(a, v) _mc_array_append_vals (a, &v, 1)
+#define _mc_array_index(a, t, i) (((t *) (a)->data)[i])
+#define _mc_array_clear(a) (a)->len = 0
+
+
+void
+_mc_array_init (mc_array_t *array, size_t element_size);
+void
+_mc_array_copy (mc_array_t *dst, const mc_array_t *src);
+void
+_mc_array_append_vals (mc_array_t *array,
+                       const void *data,
+                       uint32_t n_elements);
+void
+_mc_array_destroy (mc_array_t *array);
+
+
+#endif /* MC_ARRAY_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-array.c

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2022-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.
+ */
+
+/* This file is copied from mongoc-array.c in libmongoc version 1.17.7 at commit
+ * 200a01bb208633fe3cf395d81acc1e19492d9de4 */
+
+#include "mc-array-private.h"
+
+
+void
+_mc_array_init (mc_array_t *array, size_t element_size)
+{
+   BSON_ASSERT_PARAM (array);
+   BSON_ASSERT (element_size);
+
+   array->len = 0;
+   array->element_size = element_size;
+   array->allocated = 128;
+   array->data = (void *) bson_malloc0 (array->allocated);
+}
+
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * _mc_array_copy --
+ *
+ *       Destroy dst and copy src into it. Both arrays must be initialized.
+ *
+ * Returns:
+ *       None.
+ *
+ * Side effects:
+ *       None.
+ *
+ *--------------------------------------------------------------------------
+ */
+
+void
+_mc_array_copy (mc_array_t *dst, const mc_array_t *src)
+{
+   BSON_ASSERT_PARAM (dst);
+   BSON_ASSERT_PARAM (src);
+
+   _mc_array_destroy (dst);
+
+   dst->len = src->len;
+   dst->element_size = src->element_size;
+   dst->allocated = src->allocated;
+   dst->data = (void *) bson_malloc (dst->allocated);
+   memcpy (dst->data, src->data, dst->allocated);
+}
+
+
+void
+_mc_array_destroy (mc_array_t *array)
+{
+   if (array && array->data) {
+      bson_free (array->data);
+   }
+}
+
+
+void
+_mc_array_append_vals (mc_array_t *array, const void *data, uint32_t n_elements)
+{
+   size_t len;
+   size_t off;
+   size_t next_size;
+
+   BSON_ASSERT_PARAM (array);
+   BSON_ASSERT_PARAM (data);
+
+   BSON_ASSERT (array->len <= SIZE_MAX / array->element_size);
+   off = array->element_size * array->len;
+   BSON_ASSERT (n_elements <= SIZE_MAX / array->element_size);
+   len = (size_t) n_elements * array->element_size;
+   BSON_ASSERT (len <= SIZE_MAX - off);
+   if ((off + len) > array->allocated) {
+      next_size = bson_next_power_of_two (off + len);
+      array->data = (void *) bson_realloc (array->data, next_size);
+      array->allocated = next_size;
+   }
+
+   memcpy ((uint8_t *) array->data + off, data, len);
+
+   BSON_ASSERT (array->len <= SIZE_MAX - n_elements);
+   array->len += n_elements;
+}

data/ext/libmongocrypt/libmongocrypt/src/mc-check-conversions-private.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022-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 MC_CHECK_CONVERSIONS_PRIVATE
+#define MC_CHECK_CONVERSIONS_PRIVATE
+
+// gcc 4.6 added support for "diagnostic push".
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#define MC_BEGIN_CONVERSION_IGNORE \
+   _Pragma ("GCC diagnostic push") \
+      _Pragma ("GCC diagnostic ignored \"-Wconversion\"")
+#define MC_END_CONVERSION_IGNORE _Pragma ("GCC diagnostic pop")
+#elif defined(__clang__)
+#define MC_BEGIN_CONVERSION_IGNORE   \
+   _Pragma ("clang diagnostic push") \
+      _Pragma ("clang diagnostic ignored \"-Wconversion\"")
+#define MC_END_CONVERSION_IGNORE _Pragma ("clang diagnostic pop")
+#else
+#define MC_BEGIN_CONVERSION_IGNORE
+#define MC_END_CONVERSION_IGNORE
+#endif
+
+#endif /* MC_CHECK_CONVERSIONS_PRIVATE */