libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-payload-uev.c

@@ -14,256 +14,129 @@
  * limitations under the License.
  */
 
+#include "mc-fle2-payload-uev-common-private.h"
 #include "mc-fle2-payload-uev-private.h"
 #include "mongocrypt-private.h"
-#include "mc-fle-blob-subtype-private.h"
 
 struct _mc_FLE2UnindexedEncryptedValue_t {
-   _mongocrypt_buffer_t key_uuid;
-   uint8_t original_bson_type;
-   _mongocrypt_buffer_t ciphertext;
-   _mongocrypt_buffer_t plaintext;
-   bool parsed;
+    _mongocrypt_buffer_t key_uuid;
+    uint8_t original_bson_type;
+    _mongocrypt_buffer_t ciphertext;
+    _mongocrypt_buffer_t plaintext;
+    bool parsed;
 };
 
-mc_FLE2UnindexedEncryptedValue_t *
-mc_FLE2UnindexedEncryptedValue_new (void)
-{
-   mc_FLE2UnindexedEncryptedValue_t *uev =
-      bson_malloc0 (sizeof (mc_FLE2UnindexedEncryptedValue_t));
-   return uev;
+mc_FLE2UnindexedEncryptedValue_t *mc_FLE2UnindexedEncryptedValue_new(void) {
+    mc_FLE2UnindexedEncryptedValue_t *uev = bson_malloc0(sizeof(mc_FLE2UnindexedEncryptedValue_t));
+    return uev;
 }
 
-bool
-mc_FLE2UnindexedEncryptedValue_parse (mc_FLE2UnindexedEncryptedValue_t *uev,
-                                      const _mongocrypt_buffer_t *buf,
-                                      mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (uev);
-   BSON_ASSERT_PARAM (buf);
-
-   if (uev->parsed) {
-      CLIENT_ERR (
-         "mc_FLE2UnindexedEncryptedValue_parse must not be called twice");
-      return false;
-   }
-
-   uint32_t offset = 0;
-   /* Read fle_blob_subtype. */
-   if (offset + 1 > buf->len) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse expected byte "
-                  "length >= %" PRIu32 " got: %" PRIu32,
-                  offset + 1,
-                  buf->len);
-      return false;
-   }
-
-   uint8_t fle_blob_subtype = buf->data[offset];
-   if (fle_blob_subtype != MC_SUBTYPE_FLE2UnindexedEncryptedValue) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse expected "
-                  "fle_blob_subtype=%d got: %" PRIu8,
-                  MC_SUBTYPE_FLE2UnindexedEncryptedValue,
-                  fle_blob_subtype);
-      return false;
-   }
-   offset += 1;
-
-   /* Read key_uuid. */
-   if (offset + 16 > buf->len) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse expected byte "
-                  "length >= %" PRIu32 " got: %" PRIu32,
-                  offset + 16,
-                  buf->len);
-      return false;
-   }
-   if (!_mongocrypt_buffer_copy_from_data_and_size (
-          &uev->key_uuid, buf->data + offset, 16)) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse failed to copy "
-                  "data for key_uuid");
-      return false;
-   }
-   uev->key_uuid.subtype = BSON_SUBTYPE_UUID;
-   offset += 16;
-
-   /* Read original_bson_type. */
-   if (offset + 1 > buf->len) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse expected byte "
-                  "length >= %" PRIu32 " got: %" PRIu32,
-                  offset + 1,
-                  buf->len);
-      return false;
-   }
-   uev->original_bson_type = buf->data[offset];
-   offset += 1;
-
-   /* Read ciphertext. */
-   if (!_mongocrypt_buffer_copy_from_data_and_size (
-          &uev->ciphertext, buf->data + offset, (size_t) (buf->len - offset))) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_parse failed to copy "
-                  "data for ciphertext");
-      return false;
-   }
-
-   uev->parsed = true;
-   return true;
+bool mc_FLE2UnindexedEncryptedValue_parse(mc_FLE2UnindexedEncryptedValue_t *uev,
+                                          const _mongocrypt_buffer_t *buf,
+                                          mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(uev);
+    BSON_ASSERT_PARAM(buf);
+
+    if (uev->parsed) {
+        CLIENT_ERR("mc_FLE2UnindexedEncryptedValue_parse must not be called twice");
+        return false;
+    }
+
+    uint8_t fle_blob_subtype;
+
+    if (!_mc_FLE2UnindexedEncryptedValueCommon_parse(buf,
+                                                     &fle_blob_subtype,
+                                                     &uev->original_bson_type,
+                                                     &uev->key_uuid,
+                                                     &uev->ciphertext,
+                                                     status)) {
+        return false;
+    }
+
+    if (fle_blob_subtype != MC_SUBTYPE_FLE2UnindexedEncryptedValue) {
+        CLIENT_ERR("mc_FLE2UnindexedEncryptedValue_parse expected "
+                   "fle_blob_subtype=%d got: %" PRIu8,
+                   MC_SUBTYPE_FLE2UnindexedEncryptedValue,
+                   fle_blob_subtype);
+        return false;
+    }
+
+    uev->parsed = true;
+    return true;
 }
 
-bson_type_t
-mc_FLE2UnindexedEncryptedValue_get_original_bson_type (
-   const mc_FLE2UnindexedEncryptedValue_t *uev, mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (uev);
+bson_type_t mc_FLE2UnindexedEncryptedValue_get_original_bson_type(const mc_FLE2UnindexedEncryptedValue_t *uev,
+                                                                  mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(uev);
 
-   if (!uev->parsed) {
-      CLIENT_ERR (
-         "mc_FLE2UnindexedEncryptedValue_get_original_bson_type must be "
-         "called after mc_FLE2UnindexedEncryptedValue_parse");
-      return 0;
-   }
-   return uev->original_bson_type;
+    if (!uev->parsed) {
+        CLIENT_ERR("mc_FLE2UnindexedEncryptedValue_get_original_bson_type must be "
+                   "called after mc_FLE2UnindexedEncryptedValue_parse");
+        return 0;
+    }
+    return uev->original_bson_type;
 }
 
-const _mongocrypt_buffer_t *
-mc_FLE2UnindexedEncryptedValue_get_key_uuid (
-   const mc_FLE2UnindexedEncryptedValue_t *uev, mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (uev);
+const _mongocrypt_buffer_t *mc_FLE2UnindexedEncryptedValue_get_key_uuid(const mc_FLE2UnindexedEncryptedValue_t *uev,
+                                                                        mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(uev);
 
-   if (!uev->parsed) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_get_key_uuid must be "
-                  "called after mc_FLE2UnindexedEncryptedValue_parse");
-      return NULL;
-   }
-   return &uev->key_uuid;
+    if (!uev->parsed) {
+        CLIENT_ERR("mc_FLE2UnindexedEncryptedValue_get_key_uuid must be "
+                   "called after mc_FLE2UnindexedEncryptedValue_parse");
+        return NULL;
+    }
+    return &uev->key_uuid;
 }
 
-const _mongocrypt_buffer_t *
-mc_FLE2UnindexedEncryptedValue_decrypt (_mongocrypt_crypto_t *crypto,
-                                        mc_FLE2UnindexedEncryptedValue_t *uev,
-                                        const _mongocrypt_buffer_t *key,
-                                        mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (crypto);
-   BSON_ASSERT_PARAM (uev);
-   BSON_ASSERT_PARAM (key);
-
-   if (!uev->parsed) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_decrypt must be "
-                  "called after mc_FLE2UnindexedEncryptedValue_parse");
-      return NULL;
-   }
-
-   /* Serialize associated data: fle_blob_subtype || key_uuid ||
-    * original_bson_type */
-   _mongocrypt_buffer_t AD;
-   _mongocrypt_buffer_init (&AD);
-   if (uev->key_uuid.len > UINT32_MAX - 2) {
-      CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_decrypt expected "
-                  "key UUID length <= %" PRIu32 " got: %" PRIu32,
-                  UINT32_MAX - 2u,
-                  uev->key_uuid.len);
-      return NULL;
-   }
-   _mongocrypt_buffer_resize (&AD, 1 + uev->key_uuid.len + 1);
-
-   AD.data[0] = MC_SUBTYPE_FLE2UnindexedEncryptedValue;
-   memcpy (AD.data + 1, uev->key_uuid.data, uev->key_uuid.len);
-   AD.data[1 + uev->key_uuid.len] = uev->original_bson_type;
-   const uint32_t plaintext_len = _mongocrypt_fle2aead_calculate_plaintext_len (
-      uev->ciphertext.len, status);
-   if (plaintext_len == 0) {
-      return NULL;
-   }
-   _mongocrypt_buffer_resize (&uev->plaintext, plaintext_len);
-
-   uint32_t bytes_written;
-
-   if (!_mongocrypt_fle2aead_do_decryption (crypto,
-                                            &AD,
-                                            key,
-                                            &uev->ciphertext,
-                                            &uev->plaintext,
-                                            &bytes_written,
-                                            status)) {
-      _mongocrypt_buffer_cleanup (&AD);
-      return NULL;
-   }
-
-   _mongocrypt_buffer_cleanup (&AD);
-   return &uev->plaintext;
+const _mongocrypt_buffer_t *mc_FLE2UnindexedEncryptedValue_decrypt(_mongocrypt_crypto_t *crypto,
+                                                                   mc_FLE2UnindexedEncryptedValue_t *uev,
+                                                                   const _mongocrypt_buffer_t *key,
+                                                                   mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(crypto);
+    BSON_ASSERT_PARAM(uev);
+    BSON_ASSERT_PARAM(key);
+
+    if (!uev->parsed) {
+        CLIENT_ERR("mc_FLE2UnindexedEncryptedValue_decrypt must be "
+                   "called after mc_FLE2UnindexedEncryptedValue_parse");
+        return NULL;
+    }
+
+    return _mc_FLE2UnindexedEncryptedValueCommon_decrypt(crypto,
+                                                         MC_SUBTYPE_FLE2UnindexedEncryptedValue,
+                                                         &uev->key_uuid,
+                                                         uev->original_bson_type,
+                                                         &uev->ciphertext,
+                                                         key,
+                                                         &uev->plaintext,
+                                                         status);
 }
 
-bool
-mc_FLE2UnindexedEncryptedValue_encrypt (_mongocrypt_crypto_t *crypto,
-                                        const _mongocrypt_buffer_t *key_uuid,
-                                        bson_type_t original_bson_type,
-                                        const _mongocrypt_buffer_t *plaintext,
-                                        const _mongocrypt_buffer_t *key,
-                                        _mongocrypt_buffer_t *out,
-                                        mongocrypt_status_t *status)
-{
-   _mongocrypt_buffer_t iv = {0};
-   _mongocrypt_buffer_t AD = {0};
-   bool res = false;
-
-   BSON_ASSERT_PARAM (crypto);
-   BSON_ASSERT_PARAM (key_uuid);
-   BSON_ASSERT_PARAM (plaintext);
-   BSON_ASSERT_PARAM (key);
-   BSON_ASSERT_PARAM (out);
-
-   _mongocrypt_buffer_resize (&iv, MONGOCRYPT_IV_LEN);
-   if (!_mongocrypt_random (crypto, &iv, MONGOCRYPT_IV_LEN, status)) {
-      goto fail;
-   }
-
-   /* Serialize associated data: fle_blob_subtype || key_uuid ||
-    * original_bson_type */
-   {
-      if (key_uuid->len > UINT32_MAX - 2) {
-         CLIENT_ERR ("mc_FLE2UnindexedEncryptedValue_encrypt expected "
-                     "key UUID length <= %" PRIu32 " got: %" PRIu32,
-                     UINT32_MAX - 2u,
-                     key_uuid->len);
-         goto fail;
-      }
-      _mongocrypt_buffer_resize (&AD, 1 + key_uuid->len + 1);
-      AD.data[0] = MC_SUBTYPE_FLE2UnindexedEncryptedValue;
-      memcpy (AD.data + 1, key_uuid->data, key_uuid->len);
-      AD.data[1 + key_uuid->len] = (uint8_t) original_bson_type;
-   }
-
-   /* Encrypt. */
-   {
-      const uint32_t cipherlen =
-         _mongocrypt_fle2aead_calculate_ciphertext_len (plaintext->len, status);
-      if (cipherlen == 0) {
-         goto fail;
-      }
-      _mongocrypt_buffer_resize (out, cipherlen);
-      uint32_t bytes_written; /* unused. */
-      if (!_mongocrypt_fle2aead_do_encryption (
-             crypto, &iv, &AD, key, plaintext, out, &bytes_written, status)) {
-         goto fail;
-      }
-   }
-
-   res = true;
-fail:
-   _mongocrypt_buffer_cleanup (&AD);
-   _mongocrypt_buffer_cleanup (&iv);
-   return res;
+bool mc_FLE2UnindexedEncryptedValue_encrypt(_mongocrypt_crypto_t *crypto,
+                                            const _mongocrypt_buffer_t *key_uuid,
+                                            bson_type_t original_bson_type,
+                                            const _mongocrypt_buffer_t *plaintext,
+                                            const _mongocrypt_buffer_t *key,
+                                            _mongocrypt_buffer_t *out,
+                                            mongocrypt_status_t *status) {
+    return _mc_FLE2UnindexedEncryptedValueCommon_encrypt(crypto,
+                                                         MC_SUBTYPE_FLE2UnindexedEncryptedValue,
+                                                         key_uuid,
+                                                         original_bson_type,
+                                                         plaintext,
+                                                         key,
+                                                         out,
+                                                         status);
 }
 
-void
-mc_FLE2UnindexedEncryptedValue_destroy (mc_FLE2UnindexedEncryptedValue_t *uev)
-{
-   if (NULL == uev) {
-      return;
-   }
-   _mongocrypt_buffer_cleanup (&uev->key_uuid);
-   _mongocrypt_buffer_cleanup (&uev->ciphertext);
-   _mongocrypt_buffer_cleanup (&uev->plaintext);
+void mc_FLE2UnindexedEncryptedValue_destroy(mc_FLE2UnindexedEncryptedValue_t *uev) {
+    if (NULL == uev) {
+        return;
+    }
+    _mongocrypt_buffer_cleanup(&uev->key_uuid);
+    _mongocrypt_buffer_cleanup(&uev->ciphertext);
+    _mongocrypt_buffer_cleanup(&uev->plaintext);
 
-   bson_free (uev);
+    bson_free(uev);
 }

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-range-operator-private.h

@@ -16,14 +16,15 @@
 
 #ifndef MC_FLE2_RANGE_OPERATOR_PRIVATE_H
 #define MC_FLE2_RANGE_OPERATOR_PRIVATE_H
+
 typedef enum {
-   FLE2RangeOperator_kNone = 0,
-   FLE2RangeOperator_kGt = 1,
-   FLE2RangeOperator_kGte = 2,
-   FLE2RangeOperator_kLt = 3,
-   FLE2RangeOperator_kLte = 4,
-   FLE2RangeOperator_min_val = FLE2RangeOperator_kNone,
-   FLE2RangeOperator_max_val = FLE2RangeOperator_kLte
+    FLE2RangeOperator_kNone = 0,
+    FLE2RangeOperator_kGt = 1,
+    FLE2RangeOperator_kGte = 2,
+    FLE2RangeOperator_kLt = 3,
+    FLE2RangeOperator_kLte = 4,
+    FLE2RangeOperator_min_val = FLE2RangeOperator_kNone,
+    FLE2RangeOperator_max_val = FLE2RangeOperator_kLte
 } mc_FLE2RangeOperator_t;
 
 #endif // MC_FLE2_RANGE_OPERATOR_PRIVATE_H

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-rfds-private.h

@@ -14,78 +14,77 @@
  * limitations under the License.
  */
 
-#include <mongocrypt.h>
-#include <bson/bson.h>
-#include "mongocrypt-buffer-private.h"
-#include "mc-rangeopts-private.h"
 #include "mc-fle2-range-operator-private.h"
+#include "mc-rangeopts-private.h"
+#include "mongocrypt-buffer-private.h"
+#include <bson/bson.h>
+#include <mongocrypt.h>
 
 typedef struct {
-   const char *field;
-   struct {
-      bool set;
-      bson_iter_t value;
-      bool included;
-   } lower;
-   struct {
-      bool set;
-      bson_iter_t value;
-      bool included;
-   } upper;
-   bool isAggregateExpression;
-   int nOps;
-   mc_FLE2RangeOperator_t firstOp;
-   mc_FLE2RangeOperator_t secondOp;
+    const char *field;
+
+    struct {
+        bool set;
+        bson_iter_t value;
+        bool included;
+    } lower;
+
+    struct {
+        bool set;
+        bson_iter_t value;
+        bool included;
+    } upper;
+
+    bool isAggregateExpression;
+    int nOps;
+    mc_FLE2RangeOperator_t firstOp;
+    mc_FLE2RangeOperator_t secondOp;
 } mc_FLE2RangeFindDriverSpec_t;
 
 // mc_FLE2RangeFindDriverSpec_parse parses a FLE2RangeFindDriverSpec document.
-bool
-mc_FLE2RangeFindDriverSpec_parse (mc_FLE2RangeFindDriverSpec_t *spec,
-                                  const bson_t *in,
-                                  mongocrypt_status_t *status);
+bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
+                                      const bson_t *in,
+                                      mongocrypt_status_t *status);
 
 // mc_FLE2RangeFindDriverSpec_to_placeholders creates a new document with
 // placeholders to encrypt.
-bool
-mc_FLE2RangeFindDriverSpec_to_placeholders (
-   mc_FLE2RangeFindDriverSpec_t *spec,
-   const mc_RangeOpts_t *range_opts,
-   int64_t maxContentionCounter,
-   const _mongocrypt_buffer_t *user_key_id,
-   const _mongocrypt_buffer_t *index_key_id,
-   int32_t payloadId,
-   bson_t *out,
-   mongocrypt_status_t *status);
+//
+// `out` must be initialized by caller.
+bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *spec,
+                                                const mc_RangeOpts_t *range_opts,
+                                                int64_t maxContentionCounter,
+                                                const _mongocrypt_buffer_t *user_key_id,
+                                                const _mongocrypt_buffer_t *index_key_id,
+                                                int32_t payloadId,
+                                                bson_t *out,
+                                                mongocrypt_status_t *status);
 
 typedef struct {
-   // isStub is true when edgesInfo is not appended.
-   bool isStub;
-   const _mongocrypt_buffer_t *user_key_id;
-   const _mongocrypt_buffer_t *index_key_id;
-   bson_iter_t lowerBound;
-   bool lbIncluded;
-   bson_iter_t upperBound;
-   bool ubIncluded;
-   int32_t payloadId;
-   mc_FLE2RangeOperator_t firstOp;
-   mc_FLE2RangeOperator_t secondOp;
-   bson_iter_t indexMin;
-   bson_iter_t indexMax;
-   int64_t maxContentionCounter;
-   int64_t sparsity;
-   mc_optional_uint32_t precision;
+    // isStub is true when edgesInfo is not appended.
+    bool isStub;
+    const _mongocrypt_buffer_t *user_key_id;
+    const _mongocrypt_buffer_t *index_key_id;
+    bson_iter_t lowerBound;
+    bool lbIncluded;
+    bson_iter_t upperBound;
+    bool ubIncluded;
+    int32_t payloadId;
+    mc_FLE2RangeOperator_t firstOp;
+    mc_FLE2RangeOperator_t secondOp;
+    bson_iter_t indexMin;
+    bson_iter_t indexMax;
+    int64_t maxContentionCounter;
+    int64_t sparsity;
+    mc_optional_uint32_t precision;
 } mc_makeRangeFindPlaceholder_args_t;
 
 // mc_makeRangeFindPlaceholder creates a placeholder to be consumed by
 // libmongocrypt to encrypt a range find query. It is included in the header to
 // be used by tests.
-bool
-mc_makeRangeFindPlaceholder (mc_makeRangeFindPlaceholder_args_t *args,
-                             _mongocrypt_buffer_t *out,
-                             mongocrypt_status_t *status);
-
+bool mc_makeRangeFindPlaceholder(mc_makeRangeFindPlaceholder_args_t *args,
+                                 _mongocrypt_buffer_t *out,
+                                 mongocrypt_status_t *status);
 
 // mc_getNextPayloadId returns a payload ID. It is thread safe. It resets to 0
 // after reaching INT32_MAX.
-int32_t
-mc_getNextPayloadId (void);
+int32_t mc_getNextPayloadId(void);