libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

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

@@ -0,0 +1,137 @@
+/*
+ * 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.
+ */
+
+// `cmp.h` is a modified copy of `bson-cmp.h` from libbson 1.28.0.
+#ifndef MC_CMP_H
+#define MC_CMP_H
+
+#include <bson/bson.h> /* ssize_t + BSON_CONCAT */
+
+#include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Sanity check: ensure ssize_t limits are as expected relative to size_t. */
+BSON_STATIC_ASSERT2(ssize_t_size_min_check, SSIZE_MIN + 1 == -SSIZE_MAX);
+BSON_STATIC_ASSERT2(ssize_t_size_max_check, (size_t)SSIZE_MAX <= SIZE_MAX);
+
+/* Based on the "Safe Integral Comparisons" proposal merged in C++20:
+ * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0586r2.html
+ *
+ * Due to lack of type deduction in C, relational comparison functions (e.g.
+ * `cmp_less`) are defined in sets of four "functions" according to the
+ * signedness of each value argument, e.g.:
+ *  - mc_cmp_less_ss (signed-value, signed-value)
+ *  - mc_cmp_less_uu (unsigned-value, unsigned-value)
+ *  - mc_cmp_less_su (signed-value, unsigned-value)
+ *  - mc_cmp_less_us (unsigned-value, signed-value)
+ *
+ * Similarly, the `in_range` function is defined as a set of two "functions"
+ * according to the signedness of the value argument:
+ *  - mc_in_range_signed (Type, signed-value)
+ *  - mc_in_range_unsigned (Type, unsigned-value)
+ *
+ * The user must take care to use the correct signedness for the provided
+ * argument(s). Enabling compiler warnings for implicit sign conversions is
+ * recommended.
+ */
+
+#define MC_CMP_SET(op, ss, uu, su, us)                                                                                 \
+    static BSON_INLINE bool BSON_CONCAT3(mc_cmp_, op, _ss)(int64_t t, int64_t u) { return (ss); }                      \
+                                                                                                                       \
+    static BSON_INLINE bool BSON_CONCAT3(mc_cmp_, op, _uu)(uint64_t t, uint64_t u) { return (uu); }                    \
+                                                                                                                       \
+    static BSON_INLINE bool BSON_CONCAT3(mc_cmp_, op, _su)(int64_t t, uint64_t u) { return (su); }                     \
+                                                                                                                       \
+    static BSON_INLINE bool BSON_CONCAT3(mc_cmp_, op, _us)(uint64_t t, int64_t u) { return (us); }
+
+MC_CMP_SET(equal, t == u, t == u, t < 0 ? false : (uint64_t)(t) == u, u < 0 ? false : t == (uint64_t)(u))
+
+MC_CMP_SET(not_equal, !mc_cmp_equal_ss(t, u), !mc_cmp_equal_uu(t, u), !mc_cmp_equal_su(t, u), !mc_cmp_equal_us(t, u))
+
+MC_CMP_SET(less, t < u, t < u, t < 0 ? true : (uint64_t)(t) < u, u < 0 ? false : t < (uint64_t)(u))
+
+MC_CMP_SET(greater, mc_cmp_less_ss(u, t), mc_cmp_less_uu(u, t), mc_cmp_less_us(u, t), mc_cmp_less_su(u, t))
+
+MC_CMP_SET(less_equal,
+           !mc_cmp_greater_ss(t, u),
+           !mc_cmp_greater_uu(t, u),
+           !mc_cmp_greater_su(t, u),
+           !mc_cmp_greater_us(t, u))
+
+MC_CMP_SET(greater_equal, !mc_cmp_less_ss(t, u), !mc_cmp_less_uu(t, u), !mc_cmp_less_su(t, u), !mc_cmp_less_us(t, u))
+
+#undef MC_CMP_SET
+
+/* Return true if the given value is within the range of the corresponding
+ * signed type. The suffix must match the signedness of the given value. */
+#define MC_IN_RANGE_SET_SIGNED(Type, min, max)                                                                         \
+    static BSON_INLINE bool BSON_CONCAT3(mc_in_range, _##Type, _signed)(int64_t value) {                               \
+        return mc_cmp_greater_equal_ss(value, min) && mc_cmp_less_equal_ss(value, max);                                \
+    }                                                                                                                  \
+                                                                                                                       \
+    static BSON_INLINE bool BSON_CONCAT3(mc_in_range, _##Type, _unsigned)(uint64_t value) {                            \
+        return mc_cmp_greater_equal_us(value, min) && mc_cmp_less_equal_us(value, max);                                \
+    }
+
+/* Return true if the given value is within the range of the corresponding
+ * unsigned type. The suffix must match the signedness of the given value. */
+#define MC_IN_RANGE_SET_UNSIGNED(Type, max)                                                                            \
+    static BSON_INLINE bool BSON_CONCAT3(mc_in_range, _##Type, _signed)(int64_t value) {                               \
+        return mc_cmp_greater_equal_su(value, 0u) && mc_cmp_less_equal_su(value, max);                                 \
+    }                                                                                                                  \
+                                                                                                                       \
+    static BSON_INLINE bool BSON_CONCAT3(mc_in_range, _##Type, _unsigned)(uint64_t value) {                            \
+        return mc_cmp_less_equal_uu(value, max);                                                                       \
+    }
+
+MC_IN_RANGE_SET_SIGNED(signed_char, SCHAR_MIN, SCHAR_MAX)
+MC_IN_RANGE_SET_SIGNED(short, SHRT_MIN, SHRT_MAX)
+MC_IN_RANGE_SET_SIGNED(int, INT_MIN, INT_MAX)
+MC_IN_RANGE_SET_SIGNED(long, LONG_MIN, LONG_MAX)
+MC_IN_RANGE_SET_SIGNED(long_long, LLONG_MIN, LLONG_MAX)
+
+MC_IN_RANGE_SET_UNSIGNED(unsigned_char, UCHAR_MAX)
+MC_IN_RANGE_SET_UNSIGNED(unsigned_short, USHRT_MAX)
+MC_IN_RANGE_SET_UNSIGNED(unsigned_int, UINT_MAX)
+MC_IN_RANGE_SET_UNSIGNED(unsigned_long, ULONG_MAX)
+MC_IN_RANGE_SET_UNSIGNED(unsigned_long_long, ULLONG_MAX)
+
+MC_IN_RANGE_SET_SIGNED(int8_t, INT8_MIN, INT8_MAX)
+MC_IN_RANGE_SET_SIGNED(int16_t, INT16_MIN, INT16_MAX)
+MC_IN_RANGE_SET_SIGNED(int32_t, INT32_MIN, INT32_MAX)
+MC_IN_RANGE_SET_SIGNED(int64_t, INT64_MIN, INT64_MAX)
+
+MC_IN_RANGE_SET_UNSIGNED(uint8_t, UINT8_MAX)
+MC_IN_RANGE_SET_UNSIGNED(uint16_t, UINT16_MAX)
+MC_IN_RANGE_SET_UNSIGNED(uint32_t, UINT32_MAX)
+MC_IN_RANGE_SET_UNSIGNED(uint64_t, UINT64_MAX)
+
+MC_IN_RANGE_SET_SIGNED(ssize_t, SSIZE_MIN, SSIZE_MAX)
+MC_IN_RANGE_SET_UNSIGNED(size_t, SIZE_MAX)
+
+#undef MC_IN_RANGE_SET_SIGNED
+#undef MC_IN_RANGE_SET_UNSIGNED
+
+/* Return true if the value with *signed* type is in the representable range of
+ * Type and false otherwise. */
+#define mc_in_range_signed(Type, value) BSON_CONCAT3(mc_in_range, _##Type, _signed)(value)
+
+/* Return true if the value with *unsigned* type is in the representable range
+ * of Type and false otherwise. */
+#define mc_in_range_unsigned(Type, value) BSON_CONCAT3(mc_in_range, _##Type, _unsigned)(value)
+
+#endif /* MC_CMP_H */

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

@@ -28,6 +28,10 @@ typedef enum _supported_query_type_flags {
     SUPPORTS_RANGE_QUERIES = 1 << 1,
     // Range preview query supported
     SUPPORTS_RANGE_PREVIEW_DEPRECATED_QUERIES = 1 << 2,
+    // Text search preview query supported
+    SUPPORTS_SUBSTRING_PREVIEW_QUERIES = 1 << 3,
+    SUPPORTS_SUFFIX_PREVIEW_QUERIES = 1 << 4,
+    SUPPORTS_PREFIX_PREVIEW_QUERIES = 1 << 5,
 } supported_query_type_flags;
 
 typedef struct _mc_EncryptedField_t {
@@ -42,6 +46,7 @@ typedef struct _mc_EncryptedField_t {
  * for the server IDL definition of EncryptedFieldConfig. */
 typedef struct {
     mc_EncryptedField_t *fields;
+    uint8_t str_encode_version;
 } mc_EncryptedFieldConfig_t;
 
 /* mc_EncryptedFieldConfig_parse parses a subset of the fields from @efc_bson

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

@@ -19,6 +19,7 @@
 #include "mlib/str.h"
 #include "mongocrypt-private.h"
 #include "mongocrypt-util-private.h" // mc_iter_document_as_bson
+#include <stdint.h>
 
 static bool _parse_query_type_string(const char *queryType, supported_query_type_flags *out) {
     BSON_ASSERT_PARAM(queryType);
@@ -32,6 +33,12 @@ static bool _parse_query_type_string(const char *queryType, supported_query_type
         *out = SUPPORTS_RANGE_QUERIES;
     } else if (mstr_eq_ignore_case(mstrv_lit(MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR), qtv)) {
         *out = SUPPORTS_RANGE_PREVIEW_DEPRECATED_QUERIES;
+    } else if (mstr_eq_ignore_case(mstrv_lit(MONGOCRYPT_QUERY_TYPE_SUBSTRINGPREVIEW_STR), qtv)) {
+        *out = SUPPORTS_SUBSTRING_PREVIEW_QUERIES;
+    } else if (mstr_eq_ignore_case(mstrv_lit(MONGOCRYPT_QUERY_TYPE_SUFFIXPREVIEW_STR), qtv)) {
+        *out = SUPPORTS_SUFFIX_PREVIEW_QUERIES;
+    } else if (mstr_eq_ignore_case(mstrv_lit(MONGOCRYPT_QUERY_TYPE_PREFIXPREVIEW_STR), qtv)) {
+        *out = SUPPORTS_PREFIX_PREVIEW_QUERIES;
     } else {
         return false;
     }
@@ -169,13 +176,14 @@ bool mc_EncryptedFieldConfig_parse(mc_EncryptedFieldConfig_t *efc,
         return false;
     }
     if (!BSON_ITER_HOLDS_ARRAY(&iter)) {
-        CLIENT_ERR("expected 'fields' to be type array, got: %d", bson_iter_type(&iter));
+        CLIENT_ERR("expected 'fields' to be type array, got: %s", mc_bson_type_to_string(bson_iter_type(&iter)));
         return false;
     }
     if (!bson_iter_recurse(&iter, &iter)) {
         CLIENT_ERR("unable to recurse into encrypted_field_config 'fields'");
         return false;
     }
+    supported_query_type_flags all_supported_queries = SUPPORTS_NO_QUERIES;
     while (bson_iter_next(&iter)) {
         bson_t field;
         if (!mc_iter_document_as_bson(&iter, &field, status)) {
@@ -184,6 +192,32 @@ bool mc_EncryptedFieldConfig_parse(mc_EncryptedFieldConfig_t *efc,
         if (!_parse_field(efc, &field, status, use_range_v2)) {
             return false;
         }
+        // The first element of efc->fields contains the newly parsed field.
+        all_supported_queries |= efc->fields->supported_queries;
+    }
+
+    if (!bson_iter_init_find(&iter, efc_bson, "strEncodeVersion")) {
+        if (all_supported_queries
+            & (SUPPORTS_SUBSTRING_PREVIEW_QUERIES | SUPPORTS_SUFFIX_PREVIEW_QUERIES
+               | SUPPORTS_PREFIX_PREVIEW_QUERIES)) {
+            // Has at least one text search query type, set to latest by default.
+            efc->str_encode_version = LATEST_STR_ENCODE_VERSION;
+        } else {
+            // Set to 0 to indicate no text search, and thus no strEncodeVersion needed.
+            efc->str_encode_version = 0;
+        }
+    } else {
+        if (!BSON_ITER_HOLDS_INT32(&iter)) {
+            CLIENT_ERR("expected 'strEncodeVersion' to be type int32, got: %s",
+                       mc_bson_type_to_string(bson_iter_type(&iter)));
+            return false;
+        }
+        int32_t version = bson_iter_int32(&iter);
+        if (version > LATEST_STR_ENCODE_VERSION || version < MIN_STR_ENCODE_VERSION) {
+            CLIENT_ERR("'strEncodeVersion' of %" PRId32 " is not supported", version);
+            return false;
+        }
+        efc->str_encode_version = (uint8_t)version;
     }
     return true;
 }

data/ext/libmongocrypt/libmongocrypt/src/mc-fle-blob-subtype-private.h

@@ -19,7 +19,7 @@
 
 /* FLE Blob Subtype is the first byte of a BSON Binary Subtype 6.
  * FLE1 Blob Subtypes are defined in:
- * https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/subtype6.rst
+ * https://github.com/mongodb/specifications/blob/master/source/bson-binary-encrypted/binary-encrypted.md
  * FLE2 Blob Subtypes are currently defined in:
  * https://github.com/markbenvenuto/mongo-enterprise-modules/blob/fle2/fle_protocol.md#reference-bindata-6-subtypes.
  */
@@ -42,7 +42,10 @@ typedef enum {
     MC_SUBTYPE_FLE2FindRangePayloadV2 = 13,
     MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2 = 14,
     MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2 = 15,
-    MC_SUBTYPE_FLE2UnindexedEncryptedValueV2 = 16
+    MC_SUBTYPE_FLE2UnindexedEncryptedValueV2 = 16,
+
+    /* Text Search Subtypes */
+    MC_SUBTYPE_FLE2IndexedTextEncryptedValue = 17,
 } mc_fle_blob_subtype_t;
 
 #endif /* MC_FLE_BLOB_SUBTYPE_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-encryption-placeholder-private.h

@@ -54,6 +54,11 @@ typedef struct {
     mc_optional_int32_t trimFactor;
 } mc_FLE2RangeFindSpecEdgesInfo_t;
 
+// `mc_FLE2RangeFindSpecEdgesInfo_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2RangeFindSpecEdgesInfo_t,
+                    BSON_ALIGNOF(mc_FLE2RangeFindSpecEdgesInfo_t) >= BSON_ALIGNOF(bson_iter_t));
+
 /** FLE2RangeFindSpec represents the range find specification that is encoded
  * inside of a FLE2EncryptionPlaceholder. See
  * https://github.com/mongodb/mongo/blob/master/src/mongo/crypto/fle_field_schema.idl
@@ -76,6 +81,11 @@ typedef struct {
     mc_FLE2RangeOperator_t secondOperator;
 } mc_FLE2RangeFindSpec_t;
 
+// `mc_FLE2RangeFindSpec_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2RangeFindSpec_t,
+                    BSON_ALIGNOF(mc_FLE2RangeFindSpec_t) >= BSON_ALIGNOF(mc_FLE2RangeFindSpecEdgesInfo_t));
+
 bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out,
                                 const bson_iter_t *in,
                                 bool use_range_v2,
@@ -99,11 +109,95 @@ typedef struct {
     mc_optional_int32_t trimFactor;
 } mc_FLE2RangeInsertSpec_t;
 
+// `mc_FLE2RangeInsertSpec_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2RangeInsertSpec_t,
+                    BSON_ALIGNOF(mc_FLE2RangeInsertSpec_t) >= BSON_ALIGNOF(bson_iter_t));
+
 bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
                                   const bson_iter_t *in,
                                   bool use_range_v2,
                                   mongocrypt_status_t *status);
 
+// Note: For the substring/suffix/prefix insert specs, all lengths are in terms of number of UTF-8 codepoints, not
+// number of bytes.
+/* mc_FLE2SubstringInsertSpec_t holds the parameters used to encode for substring search. */
+typedef struct {
+    // mlen is the max string length that can be indexed.
+    uint32_t mlen;
+    // lb is the lower bound on the length of substrings to be indexed.
+    uint32_t lb;
+    // ub is the upper bound on the length of substrings to be indexed.
+    uint32_t ub;
+} mc_FLE2SubstringInsertSpec_t;
+
+/* mc_FLE2SuffixInsertSpec_t holds the parameters used to encode for suffix search. */
+typedef struct {
+    // lb is the lower bound on the length of suffixes to be indexed.
+    uint32_t lb;
+    // ub is the upper bound on the length of suffixes to be indexed.
+    uint32_t ub;
+} mc_FLE2SuffixInsertSpec_t;
+
+/* mc_FLE2PrefixInsertSpec_t holds the parameters used to encode for prefix search. */
+typedef struct {
+    // lb is the lower bound on the length of prefixes to be indexed.
+    uint32_t lb;
+    // ub is the upper bound on the length of prefixes to be indexed.
+    uint32_t ub;
+} mc_FLE2PrefixInsertSpec_t;
+
+/** mc_FLE2TextSearchInsertSpec_t represents the text search insert specification that is
+ * encoded inside of a FLE2EncryptionPlaceholder. See
+ * https://github.com/mongodb/mongo/blob/master/src/mongo/crypto/fle_field_schema.idl
+ * for the representation in the MongoDB server. */
+typedef struct {
+    // v_iter points to the value to encrypt.
+    bson_iter_t v_iter;
+
+    // v is the value to encrypt, pointing to the value at v_iter.
+    const char *v;
+    // len is the byte length of v.
+    uint32_t len;
+
+    // substr is the spec for substring indexing.
+    struct {
+        mc_FLE2SubstringInsertSpec_t value;
+        bool set;
+    } substr;
+
+    // suffix is the spec for suffix indexing.
+    struct {
+        mc_FLE2SuffixInsertSpec_t value;
+        bool set;
+    } suffix;
+
+    // prefix is the spec for prefix indexing.
+    struct {
+        mc_FLE2PrefixInsertSpec_t value;
+        bool set;
+    } prefix;
+
+    // casef indicates if case folding is enabled.
+    bool casef;
+    // diacf indicates if diacritic folding is enabled.
+    bool diacf;
+} mc_FLE2TextSearchInsertSpec_t;
+
+// `mc_FLE2TextSearchInsertSpec_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2TextSearchInsertSpec_t,
+                    BSON_ALIGNOF(mc_FLE2TextSearchInsertSpec_t) >= BSON_ALIGNOF(bson_iter_t));
+
+/** mc_FLE2TextSearchInsertSpec_parse parses a BSON document into a mc_FLE2TextSearchInsertSpec_t.
+ * @in must point to a BSON document.
+ * @out must outlive the BSON object @in is iterating on.
+ * - Returns false on error.
+ * - No cleanup needed for @out. */
+bool mc_FLE2TextSearchInsertSpec_parse(mc_FLE2TextSearchInsertSpec_t *out,
+                                       const bson_iter_t *in,
+                                       mongocrypt_status_t *status);
+
 /** FLE2EncryptionPlaceholder implements Encryption BinData (subtype 6)
  * sub-subtype 0, the intent-to-encrypt mapping. Contains a value to encrypt and
  * a description of how it should be encrypted.
@@ -131,6 +225,11 @@ typedef struct {
     int64_t sparsity;
 } mc_FLE2EncryptionPlaceholder_t;
 
+// `mc_FLE2EncryptionPlaceholder_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2EncryptionPlaceholder_t,
+                    BSON_ALIGNOF(mc_FLE2EncryptionPlaceholder_t) >= BSON_ALIGNOF(bson_iter_t));
+
 void mc_FLE2EncryptionPlaceholder_init(mc_FLE2EncryptionPlaceholder_t *placeholder);
 
 bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-encryption-placeholder.c

@@ -20,6 +20,8 @@
 
 #include "mc-fle2-encryption-placeholder-private.h"
 #include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt-util-private.h" // mc_bson_type_to_string
 #include "mongocrypt.h"
 
 #define CLIENT_ERR_PREFIXED_HELPER(Prefix, ErrorString, ...) CLIENT_ERR(Prefix ": " ErrorString, ##__VA_ARGS__)
@@ -44,6 +46,22 @@
         goto fail;                                                                                                     \
     }
 
+// Common logic for parsing int32 greater than zero
+#define IF_FIELD_INT32_GT0_PARSE(Name, Dest, Iter)                                                                     \
+    IF_FIELD(Name) {                                                                                                   \
+        if (!BSON_ITER_HOLDS_INT32(&Iter)) {                                                                           \
+            CLIENT_ERR_PREFIXED("'" #Name "' must be an int32");                                                       \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+        int32_t val = bson_iter_int32(&Iter);                                                                          \
+        if (val <= 0) {                                                                                                \
+            CLIENT_ERR_PREFIXED("'" #Name "' must be greater than zero");                                              \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+        Dest = (uint32_t)val;                                                                                          \
+    }                                                                                                                  \
+    END_IF_FIELD
+
 void mc_FLE2EncryptionPlaceholder_init(mc_FLE2EncryptionPlaceholder_t *placeholder) {
     memset(placeholder, 0, sizeof(mc_FLE2EncryptionPlaceholder_t));
 }
@@ -94,7 +112,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
             }
             algorithm = bson_iter_int32(&iter);
             if (algorithm != MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED && algorithm != MONGOCRYPT_FLE2_ALGORITHM_EQUALITY
-                && algorithm != MONGOCRYPT_FLE2_ALGORITHM_RANGE) {
+                && algorithm != MONGOCRYPT_FLE2_ALGORITHM_RANGE && algorithm != MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH) {
                 CLIENT_ERR_PREFIXED("invalid algorithm value: %d", algorithm);
                 goto fail;
             }
@@ -161,7 +179,6 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
     return true;
 
 fail:
-    mc_FLE2EncryptionPlaceholder_cleanup(out);
     return false;
 }
 
@@ -491,3 +508,210 @@ fail:
 }
 
 #undef ERROR_PREFIX
+
+#define ERROR_PREFIX "Error parsing FLE2SubstringInsertSpec"
+
+static bool mc_FLE2SubstringInsertSpec_parse(mc_FLE2SubstringInsertSpec_t *out,
+                                             const bson_iter_t *in,
+                                             mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    bool has_mlen = false, has_ub = false, has_lb = false;
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    iter = *in;
+
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+        IF_FIELD_INT32_GT0_PARSE(mlen, out->mlen, iter);
+        IF_FIELD_INT32_GT0_PARSE(ub, out->ub, iter);
+        IF_FIELD_INT32_GT0_PARSE(lb, out->lb, iter);
+    }
+    CHECK_HAS(mlen)
+    CHECK_HAS(ub)
+    CHECK_HAS(lb)
+    if (out->ub < out->lb) {
+        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        goto fail;
+    }
+    if (out->mlen < out->ub) {
+        CLIENT_ERR_PREFIXED("maximum indexed length cannot be less than the upper bound");
+        goto fail;
+    }
+    return true;
+fail:
+    return false;
+}
+
+#undef ERROR_PREFIX
+
+#define ERROR_PREFIX "Error parsing FLE2SuffixInsertSpec"
+
+static bool
+mc_FLE2SuffixInsertSpec_parse(mc_FLE2SuffixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    bool has_ub = false, has_lb = false;
+
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    iter = *in;
+
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+        IF_FIELD_INT32_GT0_PARSE(ub, out->ub, iter);
+        IF_FIELD_INT32_GT0_PARSE(lb, out->lb, iter);
+    }
+    CHECK_HAS(ub)
+    CHECK_HAS(lb)
+    if (out->ub < out->lb) {
+        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        goto fail;
+    }
+    return true;
+fail:
+    return false;
+}
+
+#undef ERROR_PREFIX
+
+#define ERROR_PREFIX "Error parsing FLE2PrefixInsertSpec"
+
+static bool
+mc_FLE2PrefixInsertSpec_parse(mc_FLE2PrefixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    bool has_ub = false, has_lb = false;
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    iter = *in;
+
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+        IF_FIELD_INT32_GT0_PARSE(ub, out->ub, iter);
+        IF_FIELD_INT32_GT0_PARSE(lb, out->lb, iter);
+    }
+    CHECK_HAS(ub)
+    CHECK_HAS(lb)
+    if (out->ub < out->lb) {
+        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        goto fail;
+    }
+    return true;
+fail:
+    return false;
+}
+
+#undef ERROR_PREFIX
+
+#define ERROR_PREFIX "Error parsing FLE2TextSearchInsertSpec"
+
+bool mc_FLE2TextSearchInsertSpec_parse(mc_FLE2TextSearchInsertSpec_t *out,
+                                       const bson_iter_t *in,
+                                       mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    *out = (mc_FLE2TextSearchInsertSpec_t){{0}};
+
+    bson_iter_t iter = *in;
+    bool has_v = false, has_casef = false, has_diacf = false;
+    bool has_substr = false, has_suffix = false, has_prefix = false;
+
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+
+        IF_FIELD(v) {
+            out->v = bson_iter_utf8(&iter, &out->len);
+            if (!out->v) {
+                CLIENT_ERR_PREFIXED("unsupported BSON type: %s for text search",
+                                    mc_bson_type_to_string(bson_iter_type(&iter)));
+                goto fail;
+            }
+            out->v_iter = iter;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(casef) {
+            if (!BSON_ITER_HOLDS_BOOL(&iter)) {
+                CLIENT_ERR_PREFIXED("'casef' must be a bool");
+                goto fail;
+            }
+            out->casef = bson_iter_bool(&iter);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(diacf) {
+            if (!BSON_ITER_HOLDS_BOOL(&iter)) {
+                CLIENT_ERR_PREFIXED("'diacf' must be a bool");
+                goto fail;
+            }
+            out->diacf = bson_iter_bool(&iter);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(substr) {
+            if (!mc_FLE2SubstringInsertSpec_parse(&out->substr.value, &iter, status)) {
+                goto fail;
+            }
+            out->substr.set = true;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(suffix) {
+            if (!mc_FLE2SuffixInsertSpec_parse(&out->suffix.value, &iter, status)) {
+                goto fail;
+            }
+            out->suffix.set = true;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(prefix) {
+            if (!mc_FLE2PrefixInsertSpec_parse(&out->prefix.value, &iter, status)) {
+                goto fail;
+            }
+            out->prefix.set = true;
+        }
+        END_IF_FIELD
+    }
+
+    CHECK_HAS(v)
+    CHECK_HAS(casef)
+    CHECK_HAS(diacf)
+    // one of substr/suffix/prefix must be set
+    if (!(has_substr || has_suffix || has_prefix)) {
+        CLIENT_ERR_PREFIXED("Must have a substring, suffix, or prefix index specification");
+        goto fail;
+    }
+    return true;
+
+fail:
+    return false;
+}
+
+#undef ERROR_PREFIX

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-equality-payload-v2.c

@@ -111,7 +111,6 @@ bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
 
     return true;
 fail:
-    mc_FLE2FindEqualityPayloadV2_cleanup(out);
     return false;
 }
 

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-equality-payload.c

@@ -114,7 +114,6 @@ bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out,
 
     return true;
 fail:
-    mc_FLE2FindEqualityPayload_cleanup(out);
     return false;
 }
 

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-range-payload-private-v2.h

@@ -78,6 +78,11 @@ typedef struct {
     bson_value_t indexMax;          // mx
 } mc_FLE2FindRangePayloadV2_t;
 
+// `mc_FLE2FindRangePayloadV2_t` inherits extended alignment from libbson. To dynamically allocate, use aligned
+// allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mc_FLE2FindRangePayloadV2_t,
+                    BSON_ALIGNOF(mc_FLE2FindRangePayloadV2_t) >= BSON_ALIGNOF(bson_value_t));
+
 /**
  * EdgeFindTokenSetV2 is the following BSON document:
  * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor