libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

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

@@ -0,0 +1,341 @@
+/*
+ * 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.
+ */
+
+#include "mongocrypt-cache-private.h"
+
+#include "mongocrypt-private.h"
+
+
+/* Did the cache pair expire? Caller must hold lock. */
+static bool
+_pair_expired (_mongocrypt_cache_t *cache, _mongocrypt_cache_pair_t *pair)
+{
+   int64_t current;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (pair);
+
+   current = bson_get_monotonic_time () / 1000;
+   BSON_ASSERT (current >= INT64_MIN + pair->last_updated);
+   BSON_ASSERT (cache->expiration <= INT64_MAX);
+   return (current - pair->last_updated) > (int64_t) cache->expiration;
+}
+
+
+/* Return the pair after the one being destroyed. */
+static _mongocrypt_cache_pair_t *
+_destroy_pair (_mongocrypt_cache_t *cache,
+               _mongocrypt_cache_pair_t *prev,
+               _mongocrypt_cache_pair_t *pair)
+{
+   _mongocrypt_cache_pair_t *tmp;
+
+   BSON_ASSERT_PARAM (cache);
+   /* prev is checked before being used, so it can be NULL */
+   BSON_ASSERT_PARAM (pair);
+
+   tmp = pair->next;
+
+   /* Unlink */
+   if (!prev) {
+      cache->pair = cache->pair->next;
+   } else {
+      prev->next = pair->next;
+   }
+
+   /* Destroy pair */
+   cache->destroy_attr (pair->attr);
+   cache->destroy_value (pair->value);
+   bson_free (pair);
+
+   return tmp;
+}
+
+/* Caller must hold mutex. */
+static void
+_mongocrypt_cache_evict (_mongocrypt_cache_t *cache)
+{
+   _mongocrypt_cache_pair_t *pair, *prev;
+
+   BSON_ASSERT_PARAM (cache);
+
+   prev = NULL;
+   pair = cache->pair;
+   while (pair) {
+      if (_pair_expired (cache, pair)) {
+         pair = _destroy_pair (cache, prev, pair);
+         continue;
+      }
+      prev = pair;
+      pair = pair->next;
+   }
+}
+
+/* Caller must hold mutex. */
+static bool
+_mongocrypt_remove_matches (_mongocrypt_cache_t *cache, void *attr)
+{
+   _mongocrypt_cache_pair_t *pair, *prev;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+
+   prev = NULL;
+   pair = cache->pair;
+   while (pair) {
+      int res;
+
+      if (!cache->cmp_attr (pair->attr, attr, &res)) {
+         return false;
+      }
+
+      if (0 == res) {
+         pair = _destroy_pair (cache, prev, pair);
+         continue;
+      }
+      prev = pair;
+      pair = pair->next;
+   }
+
+   return true;
+}
+
+
+void
+_mongocrypt_cache_set_expiration (_mongocrypt_cache_t *cache, uint64_t milli)
+{
+   BSON_ASSERT_PARAM (cache);
+
+   cache->expiration = milli;
+}
+
+
+/* caller must hold lock. */
+static bool
+_find_pair (_mongocrypt_cache_t *cache,
+            void *attr,
+            _mongocrypt_cache_pair_t **out)
+{
+   _mongocrypt_cache_pair_t *pair;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+   BSON_ASSERT_PARAM (out);
+
+   *out = NULL;
+
+   pair = cache->pair;
+   while (pair) {
+      int res;
+      /* TODO: this is a naive O(n) lookup. Consider optimizing
+         with a hash map (possibly vendor one). */
+      if (!cache->cmp_attr (pair->attr, attr, &res)) {
+         return false;
+      }
+
+      if (res == 0) {
+         *out = pair;
+         return true;
+      }
+      pair = pair->next;
+   }
+   return true;
+}
+
+
+/* Create a new pair on linked list. Caller must hold lock. */
+static _mongocrypt_cache_pair_t *
+_pair_new (_mongocrypt_cache_t *cache, void *attr)
+{
+   _mongocrypt_cache_pair_t *pair;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+
+   pair = bson_malloc0 (sizeof (_mongocrypt_cache_pair_t));
+   BSON_ASSERT (pair);
+
+   pair->attr = cache->copy_attr (attr);
+   /* add rest of values. */
+   pair->next = cache->pair;
+   pair->last_updated = bson_get_monotonic_time () / 1000;
+   cache->pair = pair;
+   return pair;
+}
+
+
+/* Caller must hold lock. */
+static void
+_cache_pair_destroy (_mongocrypt_cache_t *cache, _mongocrypt_cache_pair_t *pair)
+{
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (pair);
+
+   cache->destroy_attr (pair->attr);
+   cache->destroy_value (pair->value);
+   bson_free (pair);
+}
+
+
+bool
+_mongocrypt_cache_get (_mongocrypt_cache_t *cache,
+                       void *attr, /* attr of cache item */
+                       void **value /* copied to. */)
+{
+   _mongocrypt_cache_pair_t *match;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+   BSON_ASSERT_PARAM (value);
+
+   *value = NULL;
+
+   _mongocrypt_mutex_lock (&cache->mutex);
+   /* TODO CDRIVER-3120: optimize the eviction algorithm to avoid unnecessary
+    * O(n) traversal */
+   _mongocrypt_cache_evict (cache);
+   if (!_find_pair (cache, attr, &match)) {
+      _mongocrypt_mutex_unlock (&cache->mutex);
+      return false;
+   }
+
+   if (match) {
+      *value = cache->copy_value (match->value);
+   }
+   _mongocrypt_mutex_unlock (&cache->mutex);
+   return true;
+}
+
+
+static bool
+_cache_add (_mongocrypt_cache_t *cache,
+            void *attr,
+            void *value,
+            mongocrypt_status_t *status,
+            bool steal_value)
+{
+   _mongocrypt_cache_pair_t *pair;
+
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+   BSON_ASSERT_PARAM (value);
+
+   _mongocrypt_mutex_lock (&cache->mutex);
+   _mongocrypt_cache_evict (cache);
+   if (!_mongocrypt_remove_matches (cache, attr)) {
+      CLIENT_ERR ("error removing from cache");
+      _mongocrypt_mutex_unlock (&cache->mutex);
+      return false;
+   }
+
+   pair = _pair_new (cache, attr);
+
+   if (steal_value) {
+      pair->value = value;
+   } else {
+      pair->value = cache->copy_value (value);
+   }
+   _mongocrypt_mutex_unlock (&cache->mutex);
+   return true;
+}
+
+
+bool
+_mongocrypt_cache_add_copy (_mongocrypt_cache_t *cache,
+                            void *attr,
+                            void *value,
+                            mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+   BSON_ASSERT_PARAM (value);
+
+   return _cache_add (cache, attr, value, status, false);
+}
+
+
+bool
+_mongocrypt_cache_add_stolen (_mongocrypt_cache_t *cache,
+                              void *attr,
+                              void *value,
+                              mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (cache);
+   BSON_ASSERT_PARAM (attr);
+   BSON_ASSERT_PARAM (value);
+
+   return _cache_add (cache, attr, value, status, true);
+}
+
+void
+_mongocrypt_cache_cleanup (_mongocrypt_cache_t *cache)
+{
+   _mongocrypt_cache_pair_t *pair, *tmp;
+
+   if (!cache) {
+      return;
+   }
+
+   pair = cache->pair;
+   while (pair) {
+      tmp = pair->next;
+      _cache_pair_destroy (cache, pair);
+      pair = tmp;
+   }
+}
+
+/* Print the contents of the cache (for debugging purposes) */
+void
+_mongocrypt_cache_dump (_mongocrypt_cache_t *cache)
+{
+   _mongocrypt_cache_pair_t *pair;
+   int count;
+
+   BSON_ASSERT_PARAM (cache);
+
+   _mongocrypt_mutex_lock (&cache->mutex);
+   count = 0;
+   for (pair = cache->pair; pair != NULL; pair = pair->next) {
+      /* don't check that int64_t fits in int, since this is only diagnostic */
+      printf ("entry:%d last_updated:%d\n", count, (int) pair->last_updated);
+      if (cache->dump_attr) {
+         printf ("- attr:");
+         cache->dump_attr (pair->attr);
+      }
+      count++;
+   }
+
+   _mongocrypt_mutex_unlock (&cache->mutex);
+}
+
+
+uint32_t
+_mongocrypt_cache_num_entries (_mongocrypt_cache_t *cache)
+{
+   _mongocrypt_cache_pair_t *pair;
+   uint32_t count;
+
+   BSON_ASSERT_PARAM (cache);
+
+   _mongocrypt_mutex_lock (&cache->mutex);
+   count = 0;
+   for (pair = cache->pair; pair != NULL; pair = pair->next) {
+      count++;
+   }
+
+   _mongocrypt_mutex_unlock (&cache->mutex);
+   return count;
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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_CIPHERTEXT_PRIVATE_H
+#define MONGOCRYPT_CIPHERTEXT_PRIVATE_H
+
+#include "mc-fle-blob-subtype-private.h"
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt.h"
+
+/**
+ * Produced by mongocrypt-marking.c from _mongocrypt_marking_t
+ * as encrypted payloads for blob_subtypes:
+ *   FLE1DeterministicEncryptedValue(1)
+ *   FLE1RandomEncryptedValue(2)
+ *   FLE2InsertUpdatePayload(4)
+ */
+typedef struct {
+   _mongocrypt_buffer_t key_id;
+   mc_fle_blob_subtype_t blob_subtype;
+   uint8_t original_bson_type;
+   _mongocrypt_buffer_t data;
+} _mongocrypt_ciphertext_t;
+
+
+void
+_mongocrypt_ciphertext_init (_mongocrypt_ciphertext_t *ciphertext);
+
+
+void
+_mongocrypt_ciphertext_cleanup (_mongocrypt_ciphertext_t *ciphertext);
+
+
+bool
+_mongocrypt_ciphertext_parse_unowned (_mongocrypt_buffer_t *in,
+                                      _mongocrypt_ciphertext_t *ciphertext,
+                                      mongocrypt_status_t *status)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+
+bool
+_mongocrypt_serialize_ciphertext (_mongocrypt_ciphertext_t *ciphertext,
+                                  _mongocrypt_buffer_t *out)
+   MONGOCRYPT_WARN_UNUSED_RESULT;
+
+bool
+_mongocrypt_ciphertext_serialize_associated_data (
+   _mongocrypt_ciphertext_t *ciphertext,
+   _mongocrypt_buffer_t *out) MONGOCRYPT_WARN_UNUSED_RESULT;
+
+
+#endif /* MONGOCRYPT_CIPHERTEXT_PRIVATE_H */

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

@@ -0,0 +1,212 @@
+/*
+ * 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.
+ */
+
+#include "mongocrypt-private.h"
+#include "mongocrypt-ciphertext-private.h"
+
+void
+_mongocrypt_ciphertext_init (_mongocrypt_ciphertext_t *ciphertext)
+{
+   BSON_ASSERT_PARAM (ciphertext);
+
+   memset (ciphertext, 0, sizeof (*ciphertext));
+}
+
+
+void
+_mongocrypt_ciphertext_cleanup (_mongocrypt_ciphertext_t *ciphertext)
+{
+   if (!ciphertext) {
+      return;
+   }
+
+   _mongocrypt_buffer_cleanup (&ciphertext->key_id);
+   _mongocrypt_buffer_cleanup (&ciphertext->data);
+}
+
+
+bool
+_mongocrypt_ciphertext_parse_unowned (_mongocrypt_buffer_t *in,
+                                      _mongocrypt_ciphertext_t *ciphertext,
+                                      mongocrypt_status_t *status)
+{
+   uint32_t offset;
+
+   /* From BSON Binary subtype 6 specification:
+      struct fle_blob {
+      uint8  fle_blob_subtype = (1 or 2);
+      uint8  key_uuid[16];
+      uint8  original_bson_type;
+      uint8  ciphertext[ciphertext_length];
+      }
+   */
+
+
+   if (!ciphertext) {
+      CLIENT_ERR ("ciphertext cannot be null");
+      return false;
+   }
+
+   if (!in) {
+      CLIENT_ERR ("in parameter cannot be null");
+      return false;
+   }
+
+   if (!status) {
+      CLIENT_ERR ("status cannot be null");
+      return false;
+   }
+
+   offset = 0;
+
+   /* At a minimum, a ciphertext must be 19 bytes:
+    * fle_blob_subtype (1) +
+    * key_uuid (16) +
+    * original_bson_type (1) +
+    * ciphertext (> 0)
+    */
+   if (in->len < 19) {
+      CLIENT_ERR ("malformed ciphertext, too small");
+      return false;
+   }
+
+   ciphertext->blob_subtype = in->data[0];
+   offset += 1;
+
+   /* TODO: merge new changes. */
+   if (ciphertext->blob_subtype != 1 && ciphertext->blob_subtype != 2) {
+      CLIENT_ERR ("malformed ciphertext, expected blob subtype of 1 or 2");
+      return false;
+   }
+
+   _mongocrypt_buffer_init (&ciphertext->key_id);
+   ciphertext->key_id.data = in->data + offset;
+   ciphertext->key_id.len = 16;
+   ciphertext->key_id.subtype = BSON_SUBTYPE_UUID;
+   offset += 16;
+
+   ciphertext->original_bson_type = in->data[offset];
+   offset += 1;
+
+   memset (&ciphertext->data, 0, sizeof (ciphertext->data));
+   ciphertext->data.data = in->data + offset;
+   ciphertext->data.len = in->len - offset;
+
+   return true;
+}
+
+bool
+_mongocrypt_serialize_ciphertext (_mongocrypt_ciphertext_t *ciphertext,
+                                  _mongocrypt_buffer_t *out)
+{
+   uint32_t offset;
+
+   /* From BSON Binary subtype 6 specification:
+      struct fle_blob {
+      uint8  fle_blob_subtype = (1 or 2);
+      uint8  key_uuid[16];
+      uint8  original_bson_type;
+      uint8  ciphertext[ciphertext_length];
+      }
+   */
+
+   if (!ciphertext || !out) {
+      return false;
+   }
+
+   if (ciphertext->key_id.len != 16) {
+      return false;
+   }
+   if (ciphertext->key_id.len > (UINT32_MAX - ciphertext->data.len - 1) ||
+       ciphertext->key_id.len > (SIZE_MAX - ciphertext->data.len - 1)) {
+      return false;
+   }
+
+   _mongocrypt_buffer_init (out);
+   offset = 0;
+   out->len = 1 + ciphertext->key_id.len + 1 + ciphertext->data.len;
+   out->data = bson_malloc0 (out->len);
+   BSON_ASSERT (out->data);
+
+   out->owned = true;
+
+   /* ciphertext->blob_subtype is an enum and easily fits in uint8_t */
+   out->data[offset] = (uint8_t) ciphertext->blob_subtype;
+   offset += 1;
+
+   memcpy (out->data + offset, ciphertext->key_id.data, ciphertext->key_id.len);
+   offset += ciphertext->key_id.len;
+
+   out->data[offset] = ciphertext->original_bson_type;
+   offset += 1;
+
+   memcpy (out->data + offset, ciphertext->data.data, ciphertext->data.len);
+
+   return true;
+}
+
+
+/*
+From "FLE and AEAD" doc:
+A = Associated Data = fle_blob_subtype + key_uuid[16] + original_bson_type
+*/
+
+bool
+_mongocrypt_ciphertext_serialize_associated_data (
+   _mongocrypt_ciphertext_t *ciphertext, _mongocrypt_buffer_t *out)
+{
+   BSON_ASSERT_PARAM (ciphertext);
+
+   uint32_t bytes_written = 0;
+
+   if (!out) {
+      return false;
+   }
+
+   _mongocrypt_buffer_init (out);
+
+   if (!ciphertext->original_bson_type) {
+      return false;
+   }
+
+   if (!_mongocrypt_buffer_is_uuid (&ciphertext->key_id)) {
+      return false;
+   }
+
+   if ((ciphertext->blob_subtype !=
+        MC_SUBTYPE_FLE1DeterministicEncryptedValue) &&
+       (ciphertext->blob_subtype != MC_SUBTYPE_FLE1RandomEncryptedValue)) {
+      return false;
+   }
+
+   if (ciphertext->key_id.len > (UINT32_MAX - 2)) {
+      return false;
+   }
+
+   out->len = 1 + ciphertext->key_id.len + 1;
+   out->data = bson_malloc (out->len);
+   BSON_ASSERT (out->data);
+   out->owned = true;
+
+   out->data[bytes_written++] = (uint8_t) ciphertext->blob_subtype;
+   memcpy (out->data + bytes_written,
+           ciphertext->key_id.data,
+           ciphertext->key_id.len);
+   bytes_written += ciphertext->key_id.len;
+   out->data[bytes_written++] = (uint8_t) ciphertext->original_bson_type;
+
+   return true;
+}

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-compat.h

@@ -0,0 +1,44 @@
+/*
+ * 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_COMPAT_H
+#define MONGOCRYPT_COMPAT_H
+
+/* Utilities for cross-platform and C89 compatibility */
+
+/* Copied from bson-compat.h from the C driver. */
+#include <stdint.h>
+#include <stdbool.h>
+#ifdef MONGOCRYPT_HAVE_STDBOOL_H
+/*
+ TODO - check for stdbool.h if we need to support older compilers and reconile
+ with kms-message's rules for including stdbool.h
+*/
+#elif !defined(__bool_true_false_are_defined)
+#ifndef __cplusplus
+typedef signed char bool;
+#define false 0
+#define true 1
+#endif
+#define __bool_true_false_are_defined 1
+#endif
+
+#ifdef __GNUC__
+#define MONGOCRYPT_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
+#else
+#define MONGOCRYPT_WARN_UNUSED_RESULT
+#endif
+
+#endif /* MONGOCRYPT_COMPAT_H */