libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

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

@@ -21,6 +21,7 @@
 #include "mc-fle2-find-equality-payload-private.h"
 #include "mc-fle2-find-range-payload-private-v2.h"
 #include "mc-fle2-find-range-payload-private.h"
+#include "mc-fle2-find-text-payload-private.h"
 #include "mc-fle2-insert-update-payload-private-v2.h"
 #include "mc-fle2-insert-update-payload-private.h"
 #include "mc-fle2-payload-uev-private.h"
@@ -65,7 +66,7 @@ _mongocrypt_marking_parse_fle1_placeholder(const bson_t *in, _mongocrypt_marking
         BSON_ASSERT(field);
         if (0 == strcmp("ki", field)) {
             has_ki = true;
-            if (!_mongocrypt_buffer_from_uuid_iter(&out->key_id, &iter)) {
+            if (!_mongocrypt_buffer_from_uuid_iter(&out->u.fle1.key_id, &iter)) {
                 CLIENT_ERR("key id must be a UUID");
                 return false;
             }
@@ -85,14 +86,14 @@ _mongocrypt_marking_parse_fle1_placeholder(const bson_t *in, _mongocrypt_marking
             }
             /* CDRIVER-3100 We must make a copy of this value; the result of
              * bson_iter_value is ephemeral. */
-            bson_value_copy(value, &out->key_alt_name);
+            bson_value_copy(value, &out->u.fle1.key_alt_name);
             out->type = MONGOCRYPT_MARKING_FLE1_BY_ALTNAME;
             continue;
         }
 
         if (0 == strcmp("v", field)) {
             has_v = true;
-            memcpy(&out->v_iter, &iter, sizeof(bson_iter_t));
+            memcpy(&out->u.fle1.v_iter, &iter, sizeof(bson_iter_t));
             continue;
         }
 
@@ -110,7 +111,7 @@ _mongocrypt_marking_parse_fle1_placeholder(const bson_t *in, _mongocrypt_marking
                 CLIENT_ERR("invalid algorithm value: %d", algorithm);
                 return false;
             }
-            out->algorithm = (mongocrypt_encryption_algorithm_t)algorithm;
+            out->u.fle1.algorithm = (mongocrypt_encryption_algorithm_t)algorithm;
             continue;
         }
 
@@ -147,7 +148,7 @@ _mongocrypt_marking_parse_fle2_placeholder(const bson_t *in, _mongocrypt_marking
     BSON_ASSERT_PARAM(out);
 
     out->type = MONGOCRYPT_MARKING_FLE2_ENCRYPTION;
-    return mc_FLE2EncryptionPlaceholder_parse(&out->fle2, in, status);
+    return mc_FLE2EncryptionPlaceholder_parse(&out->u.fle2, in, status);
 }
 
 bool _mongocrypt_marking_parse_unowned(const _mongocrypt_buffer_t *in,
@@ -191,13 +192,13 @@ void _mongocrypt_marking_cleanup(_mongocrypt_marking_t *marking) {
         return;
     }
     if (marking->type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION) {
-        mc_FLE2EncryptionPlaceholder_cleanup(&marking->fle2);
+        mc_FLE2EncryptionPlaceholder_cleanup(&marking->u.fle2);
         return;
     }
 
     // else FLE1
-    _mongocrypt_buffer_cleanup(&marking->key_id);
-    bson_value_destroy(&marking->key_alt_name);
+    _mongocrypt_buffer_cleanup(&marking->u.fle1.key_id);
+    bson_value_destroy(&marking->u.fle1.key_alt_name);
 }
 
 /**
@@ -278,7 +279,8 @@ DERIVE_TOKEN_IMPL(ESC)
  * Calculates:
  * E?CToken = HMAC(collectionLevel1Token, n)
  * E?CText<T>Token = HMAC(E?CToken, t)
- * E?CText<T>DerivedFromDataTokenAndContentionFactorToken = HMAC(HMAC(E?CText<T>Token, v) cf)
+ * E?CText<T>DerivedFromDataToken = HMAC(E?CText<T>Token, v)
+ * E?CText<T>DerivedFromDataTokenAndContentionFactorToken = HMAC(E?CText<T>DerivedFromDataToken, cf)
  *
  * E?C = EDC|ESC
  * n = 1 for EDC, 2 for ESC
@@ -286,7 +288,9 @@ DERIVE_TOKEN_IMPL(ESC)
  * t = 1 for Exact, 2 for Substring, 3 for Suffix, 4 for Prefix
  * cf = contentionFactor
  *
- * E?CText<T>DerivedFromDataTokenAndContentionFactorToken is saved to out.
+ * If {useContentionFactor} is False, E?CText<T>DerivedFromDataToken is saved to out, and
+ * {contentionFactor} is ignored.
+ * Otherwise, E?CText<T>DerivedFromDataTokenAndContentionFactorToken is saved to out.
  * Note that {out} is initialized even on failure.
  */
 #define DERIVE_TEXT_SEARCH_TOKEN_IMPL(Name, Type)                                                                      \
@@ -294,13 +298,13 @@ DERIVE_TOKEN_IMPL(ESC)
                                                         _mongocrypt_buffer_t *out,                                     \
                                                         const mc_CollectionsLevel1Token_t *level1Token,                \
                                                         const _mongocrypt_buffer_t *value,                             \
+                                                        bool useContentionFactor,                                      \
                                                         int64_t contentionFactor,                                      \
                                                         mongocrypt_status_t *status) {                                 \
         BSON_ASSERT_PARAM(crypto);                                                                                     \
         BSON_ASSERT_PARAM(out);                                                                                        \
         BSON_ASSERT_PARAM(level1Token);                                                                                \
         BSON_ASSERT_PARAM(value);                                                                                      \
-        BSON_ASSERT(contentionFactor >= 0);                                                                            \
                                                                                                                        \
         _mongocrypt_buffer_init(out);                                                                                  \
                                                                                                                        \
@@ -313,13 +317,28 @@ DERIVE_TOKEN_IMPL(ESC)
         if (!textToken) {                                                                                              \
             return false;                                                                                              \
         }                                                                                                              \
+        mc_##Name##Text##Type##DerivedFromDataToken_t *fromDataToken =                                                 \
+            mc_##Name##Text##Type##DerivedFromDataToken_new(crypto, textToken, value, status);                         \
+        mc_##Name##Text##Type##Token_destroy(textToken);                                                               \
+        if (!fromDataToken) {                                                                                          \
+            return false;                                                                                              \
+        }                                                                                                              \
+                                                                                                                       \
+        if (!useContentionFactor) {                                                                                    \
+            /* FindTextPayload uses *fromDataToken */                                                                  \
+            _mongocrypt_buffer_copy_to(mc_##Name##Text##Type##DerivedFromDataToken_get(fromDataToken), out);           \
+            mc_##Name##Text##Type##DerivedFromDataToken_destroy(fromDataToken);                                        \
+            return true;                                                                                               \
+        }                                                                                                              \
+                                                                                                                       \
+        BSON_ASSERT(contentionFactor >= 0);                                                                            \
+        /* InsertUpdatePayload continues through *fromDataTokenAndContentionFactor */                                  \
         mc_##Name##Text##Type##DerivedFromDataTokenAndContentionFactorToken_t *fromDataAndContentionFactor =           \
             mc_##Name##Text##Type##DerivedFromDataTokenAndContentionFactorToken_new(crypto,                            \
-                                                                                    textToken,                         \
-                                                                                    value,                             \
+                                                                                    fromDataToken,                     \
                                                                                     (uint64_t)contentionFactor,        \
                                                                                     status);                           \
-        mc_##Name##Text##Type##Token_destroy(textToken);                                                               \
+        mc_##Name##Text##Type##DerivedFromDataToken_destroy(fromDataToken);                                            \
         if (!fromDataAndContentionFactor) {                                                                            \
             return false;                                                                                              \
         }                                                                                                              \
@@ -495,7 +514,7 @@ static bool _fle2_placeholder_aes_aead_encrypt(_mongocrypt_key_broker_t *kb,
 // Range V2: p := EncryptCTR(ECOCToken, ESCDerivedFromDataTokenAndContentionFactor || isLeaf)
 static bool _fle2_derive_encrypted_token(_mongocrypt_crypto_t *crypto,
                                          _mongocrypt_buffer_t *out,
-                                         bool use_range_v2,
+                                         bool concatentate_leaf,
                                          const mc_CollectionsLevel1Token_t *collectionsLevel1Token,
                                          const _mongocrypt_buffer_t *escDerivedToken,
                                          const _mongocrypt_buffer_t *eccDerivedToken,
@@ -512,7 +531,7 @@ static bool _fle2_derive_encrypted_token(_mongocrypt_crypto_t *crypto,
     const _mongocrypt_buffer_t *p = &tmp;
     if (!eccDerivedToken) {
         // FLE2v2
-        if (use_range_v2 && is_leaf.set) {
+        if (concatentate_leaf && is_leaf.set) {
             // Range V2; concat isLeaf
             _mongocrypt_buffer_t isLeafBuf;
             if (!_mongocrypt_buffer_copy_from_data_and_size(&isLeafBuf, (uint8_t[]){is_leaf.value}, 1)) {
@@ -597,7 +616,7 @@ static bool _get_tokenKey(_mongocrypt_key_broker_t *kb,
     }
 
     if (indexKey.len != MONGOCRYPT_KEY_LEN) {
-        CLIENT_ERR("invalid indexKey, expected len=%" PRIu32 ", got len=%" PRIu32, MONGOCRYPT_KEY_LEN, indexKey.len);
+        CLIENT_ERR("invalid indexKey, expected len=%d, got len=%" PRIu32, MONGOCRYPT_KEY_LEN, indexKey.len);
         _mongocrypt_buffer_cleanup(&indexKey);
         return false;
     }
@@ -737,7 +756,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_common(_mongocrypt_key
     if (!_fle2_derive_encrypted_token(
             crypto,
             &out->encryptedTokens,
-            kb->crypt->opts.use_range_v2,
+            true,
             common->collectionsLevel1Token,
             &out->escDerivedToken,
             NULL, // unused in v2
@@ -801,7 +820,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertext(_mongocrypt
     BSON_ASSERT(kb->crypt);
     BSON_ASSERT(marking->type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION);
 
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     _FLE2EncryptedPayloadCommon_t common = {{0}};
     mc_FLE2InsertUpdatePayloadV2_t payload;
     mc_FLE2InsertUpdatePayloadV2_init(&payload);
@@ -837,8 +856,7 @@ fail:
 
 // get_edges creates and returns edges from an FLE2RangeInsertSpec. Returns NULL
 // on error.
-static mc_edges_t *
-get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_status_t *status, bool use_range_v2) {
+static mc_edges_t *get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(insertSpec);
 
     bson_type_t value_type = bson_iter_type(&insertSpec->v);
@@ -849,8 +867,7 @@ get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_stat
                                                           .max = OPT_I32(bson_iter_int32(&insertSpec->max)),
                                                           .sparsity = sparsity,
                                                           .trimFactor = insertSpec->trimFactor},
-                                status,
-                                use_range_v2);
+                                status);
     }
 
     else if (value_type == BSON_TYPE_INT64) {
@@ -859,8 +876,7 @@ get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_stat
                                                           .max = OPT_I64(bson_iter_int64(&insertSpec->max)),
                                                           .sparsity = sparsity,
                                                           .trimFactor = insertSpec->trimFactor},
-                                status,
-                                use_range_v2);
+                                status);
     }
 
     else if (value_type == BSON_TYPE_DATE_TIME) {
@@ -869,8 +885,7 @@ get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_stat
                                                           .max = OPT_I64(bson_iter_date_time(&insertSpec->max)),
                                                           .sparsity = sparsity,
                                                           .trimFactor = insertSpec->trimFactor},
-                                status,
-                                use_range_v2);
+                                status);
     }
 
     else if (value_type == BSON_TYPE_DOUBLE) {
@@ -886,11 +901,11 @@ get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_stat
             args.precision = insertSpec->precision;
         }
 
-        return mc_getEdgesDouble(args, status, use_range_v2);
+        return mc_getEdgesDouble(args, status);
     }
 
     else if (value_type == BSON_TYPE_DECIMAL128) {
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
         const mc_dec128 value = mc_dec128_from_bson_iter(&insertSpec->v);
         mc_getEdgesDecimal128_args_t args = {
             .value = value,
@@ -904,7 +919,7 @@ get_edges(mc_FLE2RangeInsertSpec_t *insertSpec, size_t sparsity, mongocrypt_stat
             args.max = OPT_MC_DEC128(max);
             args.precision = insertSpec->precision;
         }
-        return mc_getEdgesDecimal128(args, status, use_range_v2);
+        return mc_getEdgesDecimal128(args, status);
 #else // ↑↑↑↑↑↑↑↑ With Decimal128 / Without ↓↓↓↓↓↓↓↓↓↓
         CLIENT_ERR("unsupported BSON type (Decimal128) for range: libmongocrypt "
                    "was built without extended Decimal128 support");
@@ -936,9 +951,8 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(_mo
     BSON_ASSERT_PARAM(ciphertext);
     BSON_ASSERT(kb->crypt);
     BSON_ASSERT(marking->type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION);
-    const bool use_range_v2 = kb->crypt->opts.use_range_v2;
 
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     _FLE2EncryptedPayloadCommon_t common = {{0}};
     mc_FLE2InsertUpdatePayloadV2_t payload;
     mc_FLE2InsertUpdatePayloadV2_init(&payload);
@@ -948,14 +962,14 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(_mo
     // Parse the value ("v"), min ("min"), and max ("max") from
     // FLE2EncryptionPlaceholder for range insert.
     mc_FLE2RangeInsertSpec_t insertSpec;
-    if (!mc_FLE2RangeInsertSpec_parse(&insertSpec, &placeholder->v_iter, use_range_v2, status)) {
+    if (!mc_FLE2RangeInsertSpec_parse(&insertSpec, &placeholder->v_iter, status)) {
         goto fail;
     }
 
     if (!_mongocrypt_fle2_placeholder_to_insert_update_common(kb,
                                                               &payload,
                                                               &common,
-                                                              &marking->fle2,
+                                                              &marking->u.fle2,
                                                               &insertSpec.v,
                                                               status)) {
         goto fail;
@@ -964,7 +978,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(_mo
     // g:= array<EdgeTokenSetV2>
     {
         BSON_ASSERT(placeholder->sparsity >= 0 && (uint64_t)placeholder->sparsity <= (uint64_t)SIZE_MAX);
-        edges = get_edges(&insertSpec, (size_t)placeholder->sparsity, status, kb->crypt->opts.use_range_v2);
+        edges = get_edges(&insertSpec, (size_t)placeholder->sparsity, status);
         if (!edges) {
             goto fail;
         }
@@ -1007,7 +1021,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(_mo
             // Or in Range V2: p := EncryptCTR(ECOCToken, ESCDerivedFromDataTokenAndContentionFactor || isLeaf)
             if (!_fle2_derive_encrypted_token(kb->crypt->crypto,
                                               &etc.encryptedTokens,
-                                              kb->crypt->opts.use_range_v2,
+                                              true,
                                               edge_tokens.collectionsLevel1Token,
                                               &etc.escDerivedToken,
                                               NULL, // ecc unsed in FLE2v2
@@ -1039,7 +1053,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(_mo
     {
         bson_t out;
         bson_init(&out);
-        mc_FLE2InsertUpdatePayloadV2_serializeForRange(&payload, &out, use_range_v2);
+        mc_FLE2InsertUpdatePayloadV2_serializeForRange(&payload, &out);
         _mongocrypt_buffer_steal_from_bson(&ciphertext->data, &out);
     }
     // Do not set ciphertext->original_bson_type and ciphertext->key_id. They are
@@ -1087,6 +1101,7 @@ fail:
                                                 &out->edcDerivedToken,                                                 \
                                                 collLevel1Token,                                                       \
                                                 value,                                                                 \
+                                                true,                                                                  \
                                                 contentionFactor,                                                      \
                                                 status)) {                                                             \
             return false;                                                                                              \
@@ -1095,6 +1110,7 @@ fail:
                                                 &out->escDerivedToken,                                                 \
                                                 collLevel1Token,                                                       \
                                                 value,                                                                 \
+                                                true,                                                                  \
                                                 contentionFactor,                                                      \
                                                 status)) {                                                             \
             return false;                                                                                              \
@@ -1117,8 +1133,48 @@ fail:
             return false;                                                                                              \
         }                                                                                                              \
         return true;                                                                                                   \
+    }                                                                                                                  \
+    static bool _fle2_generate_Text##Type##FindTokenSet(                                                               \
+        _mongocrypt_key_broker_t *kb,                                                                                  \
+        mc_Text##Type##FindTokenSet_t *out,                                                                            \
+        const _mongocrypt_buffer_t *value,                                                                             \
+        const mc_CollectionsLevel1Token_t *collLevel1Token,                                                            \
+        const mc_ServerTokenDerivationLevel1Token_t *serverLevel1Token,                                                \
+        mongocrypt_status_t *status) {                                                                                 \
+        BSON_ASSERT_PARAM(kb);                                                                                         \
+        BSON_ASSERT_PARAM(kb->crypt);                                                                                  \
+        BSON_ASSERT_PARAM(out);                                                                                        \
+        BSON_ASSERT_PARAM(value);                                                                                      \
+        BSON_ASSERT_PARAM(collLevel1Token);                                                                            \
+        BSON_ASSERT_PARAM(serverLevel1Token);                                                                          \
+        if (!_fle2_derive_EDCText##Type##_token(kb->crypt->crypto,                                                     \
+                                                &out->edcDerivedToken,                                                 \
+                                                collLevel1Token,                                                       \
+                                                value,                                                                 \
+                                                false,                                                                 \
+                                                0,                                                                     \
+                                                status)) {                                                             \
+            return false;                                                                                              \
+        }                                                                                                              \
+        if (!_fle2_derive_ESCText##Type##_token(kb->crypt->crypto,                                                     \
+                                                &out->escDerivedToken,                                                 \
+                                                collLevel1Token,                                                       \
+                                                value,                                                                 \
+                                                false,                                                                 \
+                                                0,                                                                     \
+                                                status)) {                                                             \
+            return false;                                                                                              \
+        }                                                                                                              \
+        if (!_fle2_derive_serverText##Type##DerivedFromDataToken(kb->crypt->crypto,                                    \
+                                                                 &out->serverDerivedFromDataToken,                     \
+                                                                 serverLevel1Token,                                    \
+                                                                 value,                                                \
+                                                                 status)) {                                            \
+            return false;                                                                                              \
+        }                                                                                                              \
+        return true;                                                                                                   \
     }
-GENERATE_TEXT_SEARCH_TOKEN_SET_FOR_TYPE_IMPL(Exact);
+GENERATE_TEXT_SEARCH_TOKEN_SET_FOR_TYPE_IMPL(Exact)
 GENERATE_TEXT_SEARCH_TOKEN_SET_FOR_TYPE_IMPL(Substring)
 GENERATE_TEXT_SEARCH_TOKEN_SET_FOR_TYPE_IMPL(Suffix)
 GENERATE_TEXT_SEARCH_TOKEN_SET_FOR_TYPE_IMPL(Prefix)
@@ -1313,6 +1369,98 @@ fail:
     return res;
 }
 
+static bool _fle2_generate_TextSearchFindTokenSets(_mongocrypt_key_broker_t *kb,
+                                                   mc_TextSearchFindTokenSets_t *out,
+                                                   const _mongocrypt_buffer_t *indexKeyId,
+                                                   const mc_FLE2TextSearchInsertSpec_t *spec,
+                                                   mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(kb);
+    BSON_ASSERT_PARAM(kb->crypt);
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(indexKeyId);
+    BSON_ASSERT_PARAM(spec);
+
+    _mongocrypt_crypto_t *crypto = kb->crypt->crypto;
+    _FLE2EncryptedPayloadCommon_t common = {{0}};
+    _mongocrypt_buffer_t asBsonValue = {0};
+    bool res = false;
+
+    int operator_count = (int)spec->substr.set + (int)spec->suffix.set + (int)spec->prefix.set;
+    if (operator_count > 1) {
+        CLIENT_ERR("Text search query specification cannot contain multiple query type specifications");
+        goto fail;
+    }
+
+    if (!mc_text_search_str_query(spec, &asBsonValue, status)) {
+        goto fail;
+    }
+
+    // Start the token derivations
+    if (!_get_tokenKey(kb, indexKeyId, &common.tokenKey, status)) {
+        goto fail;
+    }
+
+    common.collectionsLevel1Token = mc_CollectionsLevel1Token_new(crypto, &common.tokenKey, status);
+    if (!common.collectionsLevel1Token) {
+        CLIENT_ERR("unable to derive collectionLevel1Token");
+        goto fail;
+    }
+
+    common.serverTokenDerivationLevel1Token = mc_ServerTokenDerivationLevel1Token_new(crypto, &common.tokenKey, status);
+    if (!common.serverTokenDerivationLevel1Token) {
+        CLIENT_ERR("unable to derive serverTokenDerivationLevel1Token");
+        goto fail;
+    }
+
+    if (spec->substr.set) {
+        if (!_fle2_generate_TextSubstringFindTokenSet(kb,
+                                                      &out->substring.value,
+                                                      &asBsonValue,
+                                                      common.collectionsLevel1Token,
+                                                      common.serverTokenDerivationLevel1Token,
+                                                      status)) {
+            goto fail;
+        }
+        out->substring.set = true;
+    } else if (spec->suffix.set) {
+        if (!_fle2_generate_TextSuffixFindTokenSet(kb,
+                                                   &out->suffix.value,
+                                                   &asBsonValue,
+                                                   common.collectionsLevel1Token,
+                                                   common.serverTokenDerivationLevel1Token,
+                                                   status)) {
+            goto fail;
+        }
+        out->suffix.set = true;
+
+    } else if (spec->prefix.set) {
+        if (!_fle2_generate_TextPrefixFindTokenSet(kb,
+                                                   &out->prefix.value,
+                                                   &asBsonValue,
+                                                   common.collectionsLevel1Token,
+                                                   common.serverTokenDerivationLevel1Token,
+                                                   status)) {
+            goto fail;
+        }
+        out->prefix.set = true;
+    } else {
+        if (!_fle2_generate_TextExactFindTokenSet(kb,
+                                                  &out->exact.value,
+                                                  &asBsonValue,
+                                                  common.collectionsLevel1Token,
+                                                  common.serverTokenDerivationLevel1Token,
+                                                  status)) {
+            goto fail;
+        }
+        out->exact.set = true;
+    }
+    res = true;
+fail:
+    _mongocrypt_buffer_cleanup(&asBsonValue);
+    _FLE2EncryptedPayloadCommon_cleanup(&common);
+    return res;
+}
+
 /**
  * Payload subtype 11: FLE2InsertUpdatePayloadV2 for text search inserts/updates
  *
@@ -1335,7 +1483,7 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForTextSearc
     BSON_ASSERT(kb->crypt);
     BSON_ASSERT(marking->type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION);
 
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     BSON_ASSERT(placeholder->type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT);
     BSON_ASSERT(placeholder->algorithm == MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH);
 
@@ -1351,6 +1499,12 @@ static bool _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForTextSearc
         goto fail;
     }
 
+    // One of substr/suffix/prefix must be set for inserts
+    if (!(insertSpec.substr.set || insertSpec.suffix.set || insertSpec.prefix.set)) {
+        CLIENT_ERR("FLE2TextSearchInsertSpec is missing a substring, suffix, or prefix index specification");
+        goto fail;
+    }
+
     // t
     payload.valueType = BSON_TYPE_UTF8;
 
@@ -1468,7 +1622,7 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertext(_mongocrypt_key_brok
 
     _FLE2EncryptedPayloadCommon_t common = {{0}};
     _mongocrypt_buffer_t value = {0};
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     mc_FLE2FindEqualityPayloadV2_t payload;
     bool res = false;
 
@@ -1526,10 +1680,8 @@ static bool isInfinite(bson_iter_t *iter) {
 
 // mc_get_mincover_from_FLE2RangeFindSpec creates and returns a mincover from an
 // FLE2RangeFindSpec. Returns NULL on error.
-mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *findSpec,
-                                                      size_t sparsity,
-                                                      mongocrypt_status_t *status,
-                                                      bool use_range_v2) {
+mc_mincover_t *
+mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *findSpec, size_t sparsity, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(findSpec);
     BSON_ASSERT(findSpec->edgesInfo.set);
 
@@ -1590,8 +1742,7 @@ mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *fi
                                          .max = OPT_I32(bson_iter_int32(&findSpec->edgesInfo.value.indexMax)),
                                          .sparsity = sparsity,
                                          .trimFactor = findSpec->edgesInfo.value.trimFactor},
-            status,
-            use_range_v2);
+            status);
 
     case BSON_TYPE_INT64:
         BSON_ASSERT(bson_iter_type(&lowerBound) == BSON_TYPE_INT64);
@@ -1607,8 +1758,7 @@ mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *fi
                                          .max = OPT_I64(bson_iter_int64(&findSpec->edgesInfo.value.indexMax)),
                                          .sparsity = sparsity,
                                          .trimFactor = findSpec->edgesInfo.value.trimFactor},
-            status,
-            use_range_v2);
+            status);
     case BSON_TYPE_DATE_TIME:
         BSON_ASSERT(bson_iter_type(&lowerBound) == BSON_TYPE_DATE_TIME);
         BSON_ASSERT(bson_iter_type(&upperBound) == BSON_TYPE_DATE_TIME);
@@ -1623,8 +1773,7 @@ mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *fi
                                          .max = OPT_I64(bson_iter_date_time(&findSpec->edgesInfo.value.indexMax)),
                                          .sparsity = sparsity,
                                          .trimFactor = findSpec->edgesInfo.value.trimFactor},
-            status,
-            use_range_v2);
+            status);
     case BSON_TYPE_DOUBLE: {
         BSON_ASSERT(bson_iter_type(&lowerBound) == BSON_TYPE_DOUBLE);
         BSON_ASSERT(bson_iter_type(&upperBound) == BSON_TYPE_DOUBLE);
@@ -1645,10 +1794,10 @@ mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *fi
             args.max = OPT_DOUBLE(bson_iter_double(&findSpec->edgesInfo.value.indexMax));
             args.precision = findSpec->edgesInfo.value.precision;
         }
-        return mc_getMincoverDouble(args, status, use_range_v2);
+        return mc_getMincoverDouble(args, status);
     }
     case BSON_TYPE_DECIMAL128: {
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
         BSON_ASSERT(bson_iter_type(&lowerBound) == BSON_TYPE_DECIMAL128);
         BSON_ASSERT(bson_iter_type(&upperBound) == BSON_TYPE_DECIMAL128);
         BSON_ASSERT(bson_iter_type(&findSpec->edgesInfo.value.indexMin) == BSON_TYPE_DECIMAL128);
@@ -1665,7 +1814,7 @@ mc_mincover_t *mc_get_mincover_from_FLE2RangeFindSpec(mc_FLE2RangeFindSpec_t *fi
             args.max = OPT_MC_DEC128(mc_dec128_from_bson_iter(&findSpec->edgesInfo.value.indexMax));
             args.precision = findSpec->edgesInfo.value.precision;
         }
-        return mc_getMincoverDecimal128(args, status, use_range_v2);
+        return mc_getMincoverDecimal128(args, status);
 #else // ↑↑↑↑↑↑↑↑ With Decimal128 / Without ↓↓↓↓↓↓↓↓↓↓
         CLIENT_ERR("FLE2 find is not supported for Decimal128: libmongocrypt "
                    "was built without Decimal128 support");
@@ -1708,8 +1857,7 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(_mongocrypt_
     BSON_ASSERT_PARAM(marking);
     BSON_ASSERT_PARAM(ciphertext);
 
-    const bool use_range_v2 = kb->crypt->opts.use_range_v2;
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     mc_FLE2FindRangePayloadV2_t payload;
     bool res = false;
     mc_mincover_t *mincover = NULL;
@@ -1724,7 +1872,7 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(_mongocrypt_
     // Parse the query bounds and index bounds from FLE2EncryptionPlaceholder for
     // range find.
     mc_FLE2RangeFindSpec_t findSpec;
-    if (!mc_FLE2RangeFindSpec_parse(&findSpec, &placeholder->v_iter, use_range_v2, status)) {
+    if (!mc_FLE2RangeFindSpec_parse(&findSpec, &placeholder->v_iter, status)) {
         goto fail;
     }
 
@@ -1735,8 +1883,7 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(_mongocrypt_
         // g:= array<EdgeFindTokenSet>
         {
             BSON_ASSERT(placeholder->sparsity >= 0 && (uint64_t)placeholder->sparsity <= (uint64_t)SIZE_MAX);
-            mincover =
-                mc_get_mincover_from_FLE2RangeFindSpec(&findSpec, (size_t)placeholder->sparsity, status, use_range_v2);
+            mincover = mc_get_mincover_from_FLE2RangeFindSpec(&findSpec, (size_t)placeholder->sparsity, status);
             if (!mincover) {
                 goto fail;
             }
@@ -1785,14 +1932,12 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(_mongocrypt_
         }
         payload.payload.set = true;
 
-        if (use_range_v2) {
-            // Include "range" payload fields introduced in SERVER-91889.
-            payload.sparsity = OPT_I64(placeholder->sparsity);
-            payload.precision = findSpec.edgesInfo.value.precision;
-            payload.trimFactor = OPT_I32(mc_mincover_get_used_trimFactor(mincover));
-            bson_value_copy(bson_iter_value(&findSpec.edgesInfo.value.indexMin), &payload.indexMin);
-            bson_value_copy(bson_iter_value(&findSpec.edgesInfo.value.indexMax), &payload.indexMax);
-        }
+        // Include "range" payload fields introduced in SERVER-91889.
+        payload.sparsity = OPT_I64(placeholder->sparsity);
+        payload.precision = findSpec.edgesInfo.value.precision;
+        payload.trimFactor = OPT_I32(mc_mincover_get_used_trimFactor(mincover));
+        bson_value_copy(bson_iter_value(&findSpec.edgesInfo.value.indexMin), &payload.indexMin);
+        bson_value_copy(bson_iter_value(&findSpec.edgesInfo.value.indexMax), &payload.indexMax);
     }
 
     payload.payloadId = findSpec.payloadId;
@@ -1802,7 +1947,7 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(_mongocrypt_
     // Serialize.
     {
         bson_t out = BSON_INITIALIZER;
-        mc_FLE2FindRangePayloadV2_serialize(&payload, &out, use_range_v2);
+        mc_FLE2FindRangePayloadV2_serialize(&payload, &out);
         _mongocrypt_buffer_steal_from_bson(&ciphertext->data, &out);
     }
     _mongocrypt_buffer_steal(&ciphertext->key_id, &placeholder->index_key_id);
@@ -1824,9 +1969,59 @@ static bool _mongocrypt_fle2_placeholder_to_find_ciphertextForTextSearch(_mongoc
                                                                          _mongocrypt_marking_t *marking,
                                                                          _mongocrypt_ciphertext_t *ciphertext,
                                                                          mongocrypt_status_t *status) {
-    // TODO MONGOCRYPT-761 implement find support for text search fields
-    CLIENT_ERR("Text search find is not yet supported");
-    return false;
+    BSON_ASSERT_PARAM(kb);
+    BSON_ASSERT_PARAM(marking);
+    BSON_ASSERT_PARAM(ciphertext);
+    BSON_ASSERT(kb->crypt);
+    BSON_ASSERT(marking->type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION);
+
+    bool res = false;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
+    BSON_ASSERT(placeholder->type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND);
+    BSON_ASSERT(placeholder->algorithm == MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH);
+
+    mc_FLE2FindTextPayload_t payload;
+    mc_FLE2FindTextPayload_init(&payload);
+
+    mc_FLE2TextSearchInsertSpec_t spec;
+    if (!mc_FLE2TextSearchInsertSpec_parse(&spec, &placeholder->v_iter, status)) {
+        goto fail;
+    }
+
+    if (!_fle2_generate_TextSearchFindTokenSets(kb, &payload.tokenSets, &placeholder->index_key_id, &spec, status)) {
+        goto fail;
+    }
+
+    payload.caseFold = spec.casef;
+    payload.diacriticFold = spec.diacf;
+    payload.maxContentionFactor = placeholder->maxContentionFactor;
+    if (spec.substr.set) {
+        payload.substringSpec.set = true;
+        payload.substringSpec.value = spec.substr.value;
+    } else if (spec.suffix.set) {
+        payload.suffixSpec.set = true;
+        payload.suffixSpec.value = spec.suffix.value;
+    } else if (spec.prefix.set) {
+        payload.prefixSpec.set = true;
+        payload.prefixSpec.value = spec.prefix.value;
+    }
+
+    // Serialize.
+    {
+        bson_t out = BSON_INITIALIZER;
+        mc_FLE2FindTextPayload_serialize(&payload, &out);
+        _mongocrypt_buffer_steal_from_bson(&ciphertext->data, &out);
+    }
+
+    // Do not set ciphertext->original_bson_type and ciphertext->key_id. They are
+    // not used for FLE2FindTextPayload.
+    ciphertext->blob_subtype = MC_SUBTYPE_FLE2FindTextPayload;
+
+    res = true;
+
+fail:
+    mc_FLE2FindTextPayload_cleanup(&payload);
+    return res;
 }
 
 static bool _mongocrypt_fle2_placeholder_to_FLE2UnindexedEncryptedValue(_mongocrypt_key_broker_t *kb,
@@ -1838,7 +2033,7 @@ static bool _mongocrypt_fle2_placeholder_to_FLE2UnindexedEncryptedValue(_mongocr
     BSON_ASSERT_PARAM(ciphertext);
 
     _mongocrypt_buffer_t plaintext = {0};
-    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->fle2;
+    mc_FLE2EncryptionPlaceholder_t *placeholder = &marking->u.fle2;
     _mongocrypt_buffer_t user_key = {0};
     bool res = false;
 
@@ -1904,12 +2099,13 @@ static bool _mongocrypt_fle1_marking_to_ciphertext(_mongocrypt_key_broker_t *kb,
     _mongocrypt_buffer_init(&key_id);
     _mongocrypt_buffer_init(&key_material);
 
-    /* Get the decrypted key for this marking. */
+    /* Get the decrypted key for this marking.u.fle1. */
     if (marking->type == MONGOCRYPT_MARKING_FLE1_BY_ALTNAME) {
-        key_found = _mongocrypt_key_broker_decrypted_key_by_name(kb, &marking->key_alt_name, &key_material, &key_id);
-    } else if (!_mongocrypt_buffer_empty(&marking->key_id)) {
-        key_found = _mongocrypt_key_broker_decrypted_key_by_id(kb, &marking->key_id, &key_material);
-        _mongocrypt_buffer_copy_to(&marking->key_id, &key_id);
+        key_found =
+            _mongocrypt_key_broker_decrypted_key_by_name(kb, &marking->u.fle1.key_alt_name, &key_material, &key_id);
+    } else if (!_mongocrypt_buffer_empty(&marking->u.fle1.key_id)) {
+        key_found = _mongocrypt_key_broker_decrypted_key_by_id(kb, &marking->u.fle1.key_id, &key_material);
+        _mongocrypt_buffer_copy_to(&marking->u.fle1.key_id, &key_id);
     } else {
         CLIENT_ERR("marking must have either key_id or key_alt_name");
         goto fail;
@@ -1920,11 +2116,11 @@ static bool _mongocrypt_fle1_marking_to_ciphertext(_mongocrypt_key_broker_t *kb,
         goto fail;
     }
 
-    ciphertext->original_bson_type = (uint8_t)bson_iter_type(&marking->v_iter);
-    if (marking->algorithm == MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC) {
+    ciphertext->original_bson_type = (uint8_t)bson_iter_type(&marking->u.fle1.v_iter);
+    if (marking->u.fle1.algorithm == MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC) {
         ciphertext->blob_subtype = MC_SUBTYPE_FLE1DeterministicEncryptedValue;
     } else {
-        BSON_ASSERT(marking->algorithm == MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM);
+        BSON_ASSERT(marking->u.fle1.algorithm == MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM);
         ciphertext->blob_subtype = MC_SUBTYPE_FLE1RandomEncryptedValue;
     }
     _mongocrypt_buffer_copy_to(&key_id, &ciphertext->key_id);
@@ -1933,7 +2129,7 @@ static bool _mongocrypt_fle1_marking_to_ciphertext(_mongocrypt_key_broker_t *kb,
         goto fail;
     }
 
-    _mongocrypt_buffer_from_iter(&plaintext, &marking->v_iter);
+    _mongocrypt_buffer_from_iter(&plaintext, &marking->u.fle1.v_iter);
     ciphertext->data.len = fle1->get_ciphertext_len(plaintext.len, status);
     if (ciphertext->data.len == 0) {
         goto fail;
@@ -1944,7 +2140,7 @@ static bool _mongocrypt_fle1_marking_to_ciphertext(_mongocrypt_key_broker_t *kb,
     ciphertext->data.owned = true;
 
     BSON_ASSERT(kb->crypt);
-    switch (marking->algorithm) {
+    switch (marking->u.fle1.algorithm) {
     case MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC:
         /* Use deterministic encryption. */
         _mongocrypt_buffer_resize(&iv, MONGOCRYPT_IV_LEN);
@@ -2019,11 +2215,11 @@ bool _mongocrypt_marking_to_ciphertext(void *ctx,
 
     switch (marking->type) {
     case MONGOCRYPT_MARKING_FLE2_ENCRYPTION:
-        switch (marking->fle2.algorithm) {
+        switch (marking->u.fle2.algorithm) {
         case MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED:
             return _mongocrypt_fle2_placeholder_to_FLE2UnindexedEncryptedValue(kb, marking, ciphertext, status);
         case MONGOCRYPT_FLE2_ALGORITHM_RANGE:
-            switch (marking->fle2.type) {
+            switch (marking->u.fle2.type) {
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT:
                 return _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForRange(kb,
                                                                                         marking,
@@ -2031,18 +2227,18 @@ bool _mongocrypt_marking_to_ciphertext(void *ctx,
                                                                                         status);
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND:
                 return _mongocrypt_fle2_placeholder_to_find_ciphertextForRange(kb, marking, ciphertext, status);
-            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->fle2.type); return false;
+            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->u.fle2.type); return false;
             }
         case MONGOCRYPT_FLE2_ALGORITHM_EQUALITY:
-            switch (marking->fle2.type) {
+            switch (marking->u.fle2.type) {
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT:
                 return _mongocrypt_fle2_placeholder_to_insert_update_ciphertext(kb, marking, ciphertext, status);
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND:
                 return _mongocrypt_fle2_placeholder_to_find_ciphertext(kb, marking, ciphertext, status);
-            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->fle2.type); return false;
+            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->u.fle2.type); return false;
             }
         case MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH:
-            switch (marking->fle2.type) {
+            switch (marking->u.fle2.type) {
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT:
                 return _mongocrypt_fle2_placeholder_to_insert_update_ciphertextForTextSearch(kb,
                                                                                              marking,
@@ -2050,9 +2246,9 @@ bool _mongocrypt_marking_to_ciphertext(void *ctx,
                                                                                              status);
             case MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND:
                 return _mongocrypt_fle2_placeholder_to_find_ciphertextForTextSearch(kb, marking, ciphertext, status);
-            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->fle2.type); return false;
+            default: CLIENT_ERR("unexpected fle2 type: %d", (int)marking->u.fle2.type); return false;
             }
-        default: CLIENT_ERR("unexpected algorithm: %d", (int)marking->algorithm); return false;
+        default: CLIENT_ERR("unexpected algorithm: %d", (int)marking->u.fle1.algorithm); return false;
         }
     case MONGOCRYPT_MARKING_FLE1_BY_ID:
     case MONGOCRYPT_MARKING_FLE1_BY_ALTNAME: