libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-status-private.h

@@ -0,0 +1,39 @@
+/*
+ * 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 MONGOCRYPT_STATUS_PRIVATE_H
+#define MONGOCRYPT_STATUS_PRIVATE_H
+
+#include "mongocrypt.h"
+
+void
+_mongocrypt_status_copy_to (mongocrypt_status_t *src, mongocrypt_status_t *dst);
+
+
+void
+_mongocrypt_status_reset (mongocrypt_status_t *status);
+
+/* Append the message of @to_append in @status.
+ * Example:
+ * - @status has the message "status error"
+ * - @to_append has the message "append error"
+ * After calling, @status will have the message: "status error: append error"
+ */
+void
+_mongocrypt_status_append (mongocrypt_status_t *status,
+                           mongocrypt_status_t *to_append);
+
+#endif /* MONGOCRYPT_STATUS_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-status.c

@@ -0,0 +1,169 @@
+/*
+ * 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 <bson/bson.h>
+
+#include "mongocrypt-status-private.h"
+
+
+struct _mongocrypt_status_t {
+   mongocrypt_status_type_t type;
+   uint32_t code;
+   char *message;
+   uint32_t len;
+};
+
+mongocrypt_status_t *
+mongocrypt_status_new (void)
+{
+   return bson_malloc0 (sizeof (mongocrypt_status_t));
+}
+
+
+void
+mongocrypt_status_set (mongocrypt_status_t *status,
+                       mongocrypt_status_type_t type,
+                       uint32_t code,
+                       const char *message,
+                       int32_t message_len)
+{
+   if (!status) {
+      return;
+   }
+
+   if (message_len < 0) {
+      message_len = (int32_t) strlen (message) + 1;
+   } else if (message_len == 0) {
+      /* This is really an error, since message_len should be one more than the
+       * string length. But interpret as the empty string */
+      message_len = 1;
+   }
+
+   bson_free (status->message);
+   status->message = bson_malloc ((size_t) message_len);
+   BSON_ASSERT (status->message);
+   status->message[message_len - 1] = '\0';
+   memcpy (status->message, message, (size_t) message_len - 1);
+   status->len = (uint32_t) message_len - 1;
+   status->type = type;
+   status->code = code;
+}
+
+const char *
+mongocrypt_status_message (mongocrypt_status_t *status, uint32_t *len)
+{
+   BSON_ASSERT_PARAM (status);
+
+   if (mongocrypt_status_ok (status)) {
+      return NULL;
+   }
+   if (len) {
+      *len = status->len;
+   }
+   return status->message;
+}
+
+
+uint32_t
+mongocrypt_status_code (mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (status);
+
+   return status->code;
+}
+
+
+mongocrypt_status_type_t
+mongocrypt_status_type (mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (status);
+
+   return status->type;
+}
+
+
+bool
+mongocrypt_status_ok (mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (status);
+
+   return (status->type == MONGOCRYPT_STATUS_OK);
+}
+
+void
+_mongocrypt_status_copy_to (mongocrypt_status_t *src, mongocrypt_status_t *dst)
+{
+   BSON_ASSERT_PARAM (dst);
+   BSON_ASSERT_PARAM (src);
+
+   if (dst == src) {
+      return;
+   }
+
+   dst->type = src->type;
+   dst->code = src->code;
+   dst->len = src->len;
+   if (dst->message) {
+      bson_free (dst->message);
+      dst->message = NULL;
+   }
+
+   if (src->message) {
+      dst->message = bson_strdup (src->message);
+   }
+}
+
+void
+_mongocrypt_status_reset (mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (status);
+
+   status->type = MONGOCRYPT_STATUS_OK;
+   status->code = 0;
+   status->len = 0;
+   bson_free (status->message);
+   status->message = NULL;
+}
+
+void
+mongocrypt_status_destroy (mongocrypt_status_t *status)
+{
+   if (!status) {
+      return;
+   }
+
+   bson_free (status->message);
+   bson_free (status);
+}
+
+
+void
+_mongocrypt_status_append (mongocrypt_status_t *status,
+                           mongocrypt_status_t *to_append)
+{
+   char *orig;
+
+   BSON_ASSERT_PARAM (status);
+   BSON_ASSERT_PARAM (to_append);
+
+   orig = status->message;
+
+   if (mongocrypt_status_ok (to_append)) {
+      return;
+   }
+   status->message = bson_strdup_printf ("%s: %s", orig, to_append->message);
+   bson_free (orig);
+}

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-traverse-util-private.h

@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+#ifndef MONGOCRYPT_TRAVERSE_UTIL_H
+#define MONGOCRYPT_TRAVERSE_UTIL_H
+
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-status-private.h"
+
+typedef enum {
+   TRAVERSE_MATCH_CIPHERTEXT,
+   TRAVERSE_MATCH_MARKING,
+   TRAVERSE_MATCH_SUBTYPE6,
+} traversal_match_t;
+
+typedef bool (*_mongocrypt_traverse_callback_t) (void *ctx,
+                                                 _mongocrypt_buffer_t *in,
+                                                 mongocrypt_status_t *status);
+
+
+typedef bool (*_mongocrypt_transform_callback_t) (void *ctx,
+                                                  _mongocrypt_buffer_t *in,
+                                                  bson_value_t *out,
+                                                  mongocrypt_status_t *status);
+
+
+bool
+_mongocrypt_traverse_binary_in_bson (_mongocrypt_traverse_callback_t cb,
+                                     void *ctx,
+                                     traversal_match_t match,
+                                     bson_iter_t *iter,
+                                     mongocrypt_status_t *status)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+
+
+bool
+_mongocrypt_transform_binary_in_bson (_mongocrypt_transform_callback_t cb,
+                                      void *ctx,
+                                      traversal_match_t match,
+                                      bson_iter_t *iter,
+                                      bson_t *out,
+                                      mongocrypt_status_t *status)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+
+
+#endif /* MONGOCRYPT_TRAVERSE_UTIL_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-traverse-util.c

@@ -0,0 +1,234 @@
+/*
+ * 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 <bson/bson.h>
+
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-log-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt-status-private.h"
+#include "mongocrypt-traverse-util-private.h"
+#include "mc-fle-blob-subtype-private.h"
+
+typedef struct {
+   void *ctx;
+   bson_iter_t iter;
+   bson_t *copy; /* implies transform */
+   char *path;   /* only enabled during tracing. */
+   _mongocrypt_traverse_callback_t traverse_cb;
+   _mongocrypt_transform_callback_t transform_cb;
+   mongocrypt_status_t *status;
+   traversal_match_t match;
+   bson_t child;
+} _recurse_state_t;
+
+static bool
+_check_first_byte (uint8_t byte, traversal_match_t match)
+{
+   switch (match) {
+   case TRAVERSE_MATCH_MARKING:
+      return byte == MC_SUBTYPE_FLE1EncryptionPlaceholder ||
+             byte == MC_SUBTYPE_FLE2EncryptionPlaceholder;
+   case TRAVERSE_MATCH_CIPHERTEXT:
+      return byte == MC_SUBTYPE_FLE1DeterministicEncryptedValue ||
+             byte == MC_SUBTYPE_FLE1RandomEncryptedValue ||
+             byte == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValue ||
+             byte == MC_SUBTYPE_FLE2UnindexedEncryptedValue ||
+             byte == MC_SUBTYPE_FLE2InsertUpdatePayload ||
+             byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValue;
+   case TRAVERSE_MATCH_SUBTYPE6:
+      return true;
+   default:
+      break;
+   }
+   return false;
+}
+
+static bool
+_recurse (_recurse_state_t *state)
+{
+   mongocrypt_status_t *status;
+
+   BSON_ASSERT_PARAM (state);
+
+   status = state->status;
+   while (bson_iter_next (&state->iter)) {
+      if (BSON_ITER_HOLDS_BINARY (&state->iter)) {
+         _mongocrypt_buffer_t value;
+
+         BSON_ASSERT (
+            _mongocrypt_buffer_from_binary_iter (&value, &state->iter));
+
+         if (value.subtype == BSON_SUBTYPE_ENCRYPTED && value.len > 0 &&
+             _check_first_byte (value.data[0], state->match)) {
+            bool ret;
+            /* call the right callback. */
+            if (state->copy) {
+               bson_value_t value_out;
+               ret =
+                  state->transform_cb (state->ctx, &value, &value_out, status);
+               if (ret) {
+                  const uint32_t key_len = bson_iter_key_len (&state->iter);
+                  BSON_ASSERT (key_len <= INT_MAX);
+                  bson_append_value (state->copy,
+                                     bson_iter_key (&state->iter),
+                                     (int) key_len,
+                                     &value_out);
+                  bson_value_destroy (&value_out);
+               }
+            } else {
+               ret = state->traverse_cb (state->ctx, &value, status);
+            }
+
+            if (!ret) {
+               return false;
+            }
+            continue;
+         }
+         /* fall through and copy */
+      }
+
+      if (BSON_ITER_HOLDS_ARRAY (&state->iter)) {
+         _recurse_state_t child_state;
+         bool ret;
+
+         memcpy (&child_state, state, sizeof (_recurse_state_t));
+         if (!bson_iter_recurse (&state->iter, &child_state.iter)) {
+            CLIENT_ERR ("error recursing into array");
+            return false;
+         }
+
+         if (state->copy) {
+            const uint32_t key_len = bson_iter_key_len (&state->iter);
+            BSON_ASSERT (key_len <= INT_MAX);
+            bson_append_array_begin (state->copy,
+                                     bson_iter_key (&state->iter),
+                                     (int) key_len,
+                                     &state->child);
+            child_state.copy = &state->child;
+         }
+         ret = _recurse (&child_state);
+
+         if (state->copy) {
+            bson_append_array_end (state->copy, &state->child);
+         }
+         if (!ret) {
+            return false;
+         }
+         continue;
+      }
+
+      if (BSON_ITER_HOLDS_DOCUMENT (&state->iter)) {
+         _recurse_state_t child_state;
+         bool ret;
+
+         memcpy (&child_state, state, sizeof (_recurse_state_t));
+         if (!bson_iter_recurse (&state->iter, &child_state.iter)) {
+            CLIENT_ERR ("error recursing into document");
+            return false;
+         }
+         /* TODO: check for errors everywhere. */
+         if (state->copy) {
+            const uint32_t key_len = bson_iter_key_len (&state->iter);
+            BSON_ASSERT (key_len <= INT_MAX);
+            bson_append_document_begin (state->copy,
+                                        bson_iter_key (&state->iter),
+                                        (int) key_len,
+                                        &state->child);
+            child_state.copy = &state->child;
+         }
+
+         ret = _recurse (&child_state);
+
+         if (state->copy) {
+            if (!bson_append_document_end (state->copy, &state->child)) {
+               CLIENT_ERR ("error appending document");
+               return false;
+            }
+         }
+
+         if (!ret) {
+            return false;
+         }
+         continue;
+      }
+
+      if (state->copy) {
+         const uint32_t key_len = bson_iter_key_len (&state->iter);
+         BSON_ASSERT (key_len <= INT_MAX);
+         bson_append_value (state->copy,
+                            bson_iter_key (&state->iter),
+                            (int) key_len,
+                            bson_iter_value (&state->iter));
+      }
+   }
+   return true;
+}
+
+bool
+_mongocrypt_transform_binary_in_bson (_mongocrypt_transform_callback_t cb,
+                                      void *ctx,
+                                      traversal_match_t match,
+                                      bson_iter_t *iter,
+                                      bson_t *out,
+                                      mongocrypt_status_t *status)
+{
+   _recurse_state_t starting_state = {ctx,
+                                      *iter,
+                                      out /* copy */,
+                                      NULL /* path */,
+                                      NULL /* traverse callback */,
+                                      cb,
+                                      status,
+                                      match,
+                                      {0}};
+
+   return _recurse (&starting_state);
+}
+
+
+/*-----------------------------------------------------------------------------
+ *
+ * _mongocrypt_traverse_binary_in_bson
+ *
+ *    Traverse the BSON being iterated with iter, and call cb for every binary
+ *    subtype 06 (BSON_SUBTYPE_ENCRYPTED) value where the first byte corresponds
+ *    to 'match'.
+ *
+ * Return:
+ *    True on success. Returns false on failure and sets error.
+ *
+ *-----------------------------------------------------------------------------
+ */
+bool
+_mongocrypt_traverse_binary_in_bson (_mongocrypt_traverse_callback_t cb,
+                                     void *ctx,
+                                     traversal_match_t match,
+                                     bson_iter_t *iter,
+                                     mongocrypt_status_t *status)
+{
+   _recurse_state_t starting_state = {ctx,
+                                      *iter,
+                                      NULL /* copy */,
+                                      NULL /* path */,
+                                      cb,
+                                      NULL /* transform callback */,
+                                      status,
+                                      match,
+                                      {0}};
+
+   return _recurse (&starting_state);
+}

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-util-private.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2021-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 MONGOCRYPT_UTIL_PRIVATE_H
+#define MONGOCRYPT_UTIL_PRIVATE_H
+
+#include "mongocrypt-status-private.h"
+
+#include "mlib/str.h"
+
+#include <bson/bson.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* A utility for safely casting from size_t to uint32_t.
+ * Returns false if @in exceeds the maximum value of a uint32_t. */
+bool
+size_to_uint32 (size_t in, uint32_t *out);
+
+
+/**
+ * @brief The result type of mpath_current_exe_path()
+ *
+ * The @ref current_module_result::path member must be freed with mstr_free()
+ */
+typedef struct current_module_result {
+   /// The resulting executable path
+   mstr path;
+   /// An error, if the path could not be obtained
+   int error;
+} current_module_result;
+
+/**
+ * @brief Obtain the path to the calling executable module
+ *
+ * If this function is contained in a dynamic library, this will return the path
+ * to that library file, otherwise it will return the path to the running
+ * executable.
+ *
+ * @return current_module_result A result object of the operation. Check the
+ * `.error` member for non-zero. The `.path` member must be freed with
+ * mtsr_free()
+ */
+current_module_result
+current_module_path (void);
+
+/* mc_bson_type_to_string returns the string representation of a BSON type. */
+const char *
+mc_bson_type_to_string (bson_type_t bson_type);
+
+/* mc_iter_document_as_bson attempts to read the document from @iter into
+ * @bson. */
+bool
+mc_iter_document_as_bson (const bson_iter_t *iter,
+                          bson_t *bson,
+                          mongocrypt_status_t *status);
+
+// mc_isnan is a wrapper around isnan. It avoids a conversion warning on glibc.
+bool
+mc_isnan (double d);
+// mc_isinf is a wrapper around isinf. It avoids a conversion warning on glibc.
+bool
+mc_isinf (double d);
+// mc_isfinite is a wrapper around isfinite. It avoids a conversion warning on
+// glibc.
+bool
+mc_isfinite (double d);
+
+#endif /* MONGOCRYPT_UTIL_PRIVATE_H */