libmongocrypt-helper 1.12.0.0.1001 → 1.13.2.0.1001

data/ext/libmongocrypt/libmongocrypt/test/data/tokens/mc.json

@@ -4,7 +4,7 @@
    "contentionFactor": 1234567890,
    "collectionsLevel1Token": "ff2103ff205a36f39704f643c270c129919f008c391d9589a6d2c86a7429d0d3",
    "serverDataEncryptionLevel1Token": "d915ccc1eb81687fb5fc5b799f48c99fbe17e7a011a46a48901b9ae3d790656b",
-   "serverTokenDerivationLevel1Token": "1adc114b462741e6ac9f52eacf3dcb8cbca19827693c571d9418fda570c29d82",
+   "ServerTokenDerivationLevel1Token": "1adc114b462741e6ac9f52eacf3dcb8cbca19827693c571d9418fda570c29d82",
    "EDCToken": "167d2d2ff8e4144df37ff759db593fde0ecc7d9636f96d62dacad672eccad349",
    "ESCToken": "bfd480f1658f49f48985734737bc07d0bc36b88210277605c55ff3c9c3ef50b0",
    "ECCToken": "9d34f9c182d75a5a3347c2f903e3e647105c651d52cf9555c9420ba07ddd3aa2",
@@ -21,5 +21,31 @@
    "ESCTwiceDerivedValueToken": "34150c6f5ab56dc39ddb935accb7f53e5276322fa937650b76a4dda9723d6fba",
    "serverCountAndContentionFactorEncryptionToken": "a8c4a477e5518a527f718a5a1530919f2dad13b1f3559833e17b479711cbdbb9",
    "serverZerosEncryptionToken": "95fda1e139ef1dc84260d4d3ebaab7627a9676f4af7aeb1b596c7c14a0b3a2ea",
-   "AnchorPaddingTokenRoot": "d5072cc56d9241470b9771292c3f75d950cba1cf842ca6707d1adfec5ec6f3e7"
+   "AnchorPaddingTokenRoot": "d5072cc56d9241470b9771292c3f75d950cba1cf842ca6707d1adfec5ec6f3e7",
+   "AnchorPaddingKeyToken": "4665ff3ea2d8268d3e6c5d85ddbe6a79d74c45898012afdd4f5d2afb4472957e",
+   "AnchorPaddingValueToken": "38cba0ac9914890d646387c9796edbba771b039ce9615457d7cc169df502f78f",
+   "EDCTextExactToken": "be75dff4bbe8671213ea36fcb716f783af51fa00477fdea2558284b8b6d6b290",
+   "EDCTextSubstringToken": "7eff82fa8a912a3cc60be036b0fddbbbcac45366e4cdf41090d49d770d2b28ef",
+   "EDCTextSuffixToken": "d72607e0c681b39af3769ea93fc7c6b533c8963669a2f5f3d4205469d8e2977a",
+   "EDCTextPrefixToken": "26c020f4bb3e50cb094f29da9e40b99fa9a862ea6df9e14a4838d22089f5e48c",
+   "ESCTextExactToken": "591d0e6c50f38bbac01ebbff96b2f602eefbbb138c674fcf1261dcb26508ac36",
+   "ESCTextSubstringToken": "38511f2fc6a90259b1d66f161f4f01893437703b8e07be7013ab2ebe1a5199fd",
+   "ESCTextSuffixToken": "574e5d597c469798871e349e3f4151a9a75aa4fca438e6ffa19020a9a4d239df",
+   "ESCTextPrefixToken": "700b0a35a12f36b5511ed3ea2ca8f7fd41386a6d6d45e5c028edca240ba617d6",
+   "ServerTextExactToken": "1b0b904479d408fe805b14cd8f269b7aa9f022128816da09bc94ddd7021aa2ee",
+   "ServerTextSubstringToken": "dc79b64dab53c09dcbcc2c203e1ed5d88e0fed75b1e3a3a3f192ead85d762e6a",
+   "ServerTextSuffixToken": "a69ea838e79f9c11e2d6bd54e665bf0eee4864d5e517a7c9e9fb763e1a187cbe",
+   "ServerTextPrefixToken": "b89b65fc9274678e1fe107ff8ae485f6ba46400870f87ba08c710bd605792cfc",
+   "EDCTextExactDerivedFromDataTokenAndContentionFactorToken": "5f073c558114c2ff39a56e837d64f64c68328b14ebe2f6f142304e966cb618c4",
+   "EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "ac333c5086216d14bcbe9996dc7c9c815625aeef47e6c08d83b348dd6bb62834",
+   "EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "bd9a705c59a292635101523014ae997f2f56b8ba2ab4df3573c8f2524f5a9e50",
+   "EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "06c4e44724305bb706e404c1caae6fff604c2b0c6809c3bcf79658ff3c93b951",
+   "ESCTextExactDerivedFromDataTokenAndContentionFactorToken": "680b35d73a3f778792b8a03df267aa945cb9718ed4e6925c9da069d354032b7a",
+   "ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "380c456ea3c2b9d80324556931764ea22c5e097b2702e658dfe81254b1ec9688",
+   "ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "db3418028ec9079fe27643071d575e9f6e0607bdfee185d1380a68921ce58ff6",
+   "ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "263cd30dbdce8a4d00bcd24b45b2d40058646f1aa9fb38313c3162b1a455889b",
+   "ServerTextExactDerivedFromDataToken": "42dde13769bb2f18d35654fc673172b82db7fdcc62fb3ddf0767953bddc7e981",
+   "ServerTextSubstringDerivedFromDataToken": "7d474158a817b9c6d45c497d591d6bc1d1f4f40066c40eaaf7e7f3c3ce4e11f0",
+   "ServerTextSuffixDerivedFromDataToken": "3523904f3d15e552cea7c8643396b8090ba591a394eb91921c8b33e6fe07b0a1",
+   "ServerTextPrefixDerivedFromDataToken": "854a5420921027c2a96415191a122d82a6f90d21ecef070e44174527eb4d7f2b"
 }

data/ext/libmongocrypt/libmongocrypt/test/data/tokens/server.json

@@ -3,7 +3,7 @@
    "value": "c07c0df51257948e1a0fc70dd4568e3af99b23b3434c9858237ca7db62db9766",
    "contentionFactor": 1234567890,
    "collectionsLevel1Token": "BD53ACAC665EDD01E0CA30CB648B2B8F4967544047FD4E7D12B1A9BF07339928",
-   "serverTokenDerivationLevel1Token": "C17FDF249DE234F9AB15CD95137EA7EC82AE4E5B51F6BFB0FC1B8FEB6800F74C",
+   "ServerTokenDerivationLevel1Token": "C17FDF249DE234F9AB15CD95137EA7EC82AE4E5B51F6BFB0FC1B8FEB6800F74C",
    "serverDataEncryptionLevel1Token": "EB9A73F7912D86A4297E81D2F675AF742874E4057E3A890FEC651A23EEE3F3EC",
    "EDCToken": "82B0AB0F8F1D31AEB6F4DBC915EF17CBA2FE21E36EC436984EB63BECEC173831",
    "ESCToken": "279C575B52B73677EEF07D9C1126EBDF08C35369570A9B75E44A9AFDCCA96B6D",
@@ -21,5 +21,31 @@
    "ESCTwiceDerivedValueToken": "53F0A51A43447B9881D5E79BA4C5F78E80BC2BC6AA42B00C81079EBF4C9D5A7C",
    "serverCountAndContentionFactorEncryptionToken": "2F30DBCC06B722B60BC1FF018FC28D5FAEE2F222496BE34A264EF3267E811DA0",
    "serverZerosEncryptionToken": "986F23F132FF7F14F748AC69373CFC982AD0AD4BAD25BE92008B83AB43E96029",
-   "AnchorPaddingTokenRoot": "4312890F621FE3CA7497C3405DFD8AAF46A578C77F7404D28C12BA853A4D3327"
+   "AnchorPaddingTokenRoot": "4312890F621FE3CA7497C3405DFD8AAF46A578C77F7404D28C12BA853A4D3327",
+   "AnchorPaddingKeyToken": "EF6D80379C462FC724CE8C245DC177ED507154B4EBB04DED780FA0DDAF1A2247",
+   "AnchorPaddingValueToken": "A3308597F3C5271D5BAB640F749E619E9272A2C33F4CD372680F55F84CC4DF7F",
+   "EDCTextExactToken": "17dde6bd0c0d783aa2bf84e255b162b9362032e5ebd6d655d6b478c4d77dc077",
+   "EDCTextSubstringToken": "4dde679aa0568701a0fda6b1cae21e99da32500541e4ad832ea83db94497478f",
+   "EDCTextSuffixToken": "61fa8b8f02a5e7f3cfd2c3e58d3fb8c2d1bfe8a1acc32e43f26478a52944af78",
+   "EDCTextPrefixToken": "926e96d7142b2d187d10579a26a11499d6c30aac2e3fdd56eb1cd536875decfd",
+   "ESCTextExactToken": "2fea10a92e84cce913ea0ffd7fd59964507e9e96cdffa4f1b861521f3e653260",
+   "ESCTextSubstringToken": "d6a94cacc9f5dd10b2b980bd4c4044e16ff1b29ad50c692e603487c46cbe610e",
+   "ESCTextSuffixToken": "336f39da6fa984a3477261ea19147b77f02e843f82511c94a91ec77bd72dca68",
+   "ESCTextPrefixToken": "2575c2a275e8135ec73093ae2edc793f6a3a0b8ed89767c3a8695ad93f1c6e9e",
+   "ServerTextExactToken": "2ae33773be27c9fe3522ff0459f621670e93a7423166e63e9a43687a503c7438",
+   "ServerTextSubstringToken": "183ff338509675d5377d09978e9becd31b197458e2c8cd45b670c672ceb6dc53",
+   "ServerTextSuffixToken": "baf7c9392bb37607c6aa1f04163f4db8628872e7e7122e754bcd72771934ccbd",
+   "ServerTextPrefixToken": "52387ea6942d9299a89f70a2a4d8a4209ea1dfe56e29f6c0e3182ca7818b5c9c",
+   "EDCTextExactDerivedFromDataTokenAndContentionFactorToken": "3551507189d32cc7768390cdd83071deeb3055ca86c4756b16bb740024b23610",
+   "EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "4b52f6daf3b688971eb5819820c3468b3c79ba45fd3e86134351f9baf203e0d1",
+   "EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "c1f273913631a9a1b36fea884b3c8a3a141c9e21556981094ba15f262e540ac7",
+   "EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "a8d68ebdb0e2d31754f693c56071b0b1d225e6ec5568aff875bd4f7c48c24f66",
+   "ESCTextExactDerivedFromDataTokenAndContentionFactorToken": "4cd82a4883ab0a6224a24937066f94827f5107e8bb2f0fa841e10aff8d49e8e4",
+   "ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "94f116183f14442e335902756e5b730683cd998c683b90d04dc9e8f48684bdb2",
+   "ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "13390024c674c2d131771cf95af9787c8c7ef76b5d63078b3dc482cb4075a634",
+   "ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "9d0d5f84de779360c43be8e61710deb4b2705b6bf1e11ee41fba09fd4486b7c6",
+   "ServerTextExactDerivedFromDataToken": "ae210cd90c230bb8cb96a4e840c9cf88740ae156f3514260d3f1ce94b0bf941e",
+   "ServerTextSubstringDerivedFromDataToken": "7b514ede2cd6d364f2da2580bf173a4e68f9e0617c123aee8b9dda4d8d4b47d7",
+   "ServerTextSuffixDerivedFromDataToken": "3e242be8d4c8a5894e81aa5fe0729cf48355dbe219c5c6b5ceb8b0eef124ba40",
+   "ServerTextPrefixDerivedFromDataToken": "8d8d41ac0618b0e98b086d662a2466f4aa1527d6536acdbcf220c724073331eb"
 }

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

@@ -39,6 +39,19 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-oneField.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-oneField-goodVersionSet.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 1);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -50,6 +63,7 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-extraField.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -61,6 +75,7 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-twoFields.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "lastName");
@@ -79,6 +94,61 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
                             status,
                             "unable to find 'keyId' in 'field' document");
         mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-oneField-badVersionSet.json", &efc_bson);
+        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2),
+                            status,
+                            "'strEncodeVersion' of 99 is not supported");
+        mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, LATEST_STR_ENCODE_VERSION);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "lastName");
+        ASSERT_CMPBUF(expect_keyId2, ptr->keyId);
+        ASSERT(ptr->supported_queries == (SUPPORTS_SUFFIX_PREVIEW_QUERIES | SUPPORTS_PREFIX_PREVIEW_QUERIES));
+        ASSERT(ptr->next != NULL);
+        ptr = ptr->next;
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->supported_queries == SUPPORTS_SUBSTRING_PREVIEW_QUERIES);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields-goodVersionSet.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 1);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "lastName");
+        ASSERT_CMPBUF(expect_keyId2, ptr->keyId);
+        ASSERT(ptr->supported_queries == (SUPPORTS_SUFFIX_PREVIEW_QUERIES | SUPPORTS_PREFIX_PREVIEW_QUERIES));
+        ASSERT(ptr->next != NULL);
+        ptr = ptr->next;
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->supported_queries == SUPPORTS_SUBSTRING_PREVIEW_QUERIES);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields-badVersionSet.json", &efc_bson);
+        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2),
+                            status,
+                            "'strEncodeVersion' of 99 is not supported");
+        mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
     }
 
     _mongocrypt_buffer_cleanup(&expect_keyId2);

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

@@ -0,0 +1,468 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <mc-fle2-encryption-placeholder-private.h>
+
+#include "mongocrypt-private.h"
+#include "test-mongocrypt-assert.h"
+#include "test-mongocrypt.h"
+
+#define RAW_STRING(...) #__VA_ARGS__
+
+static void _test_FLE2EncryptionPlaceholder_parse(_mongocrypt_tester_t *tester) {
+    mc_FLE2EncryptionPlaceholder_t placeholder;
+    bson_t as_bson;
+    mongocrypt_status_t *status;
+    _mongocrypt_buffer_t buf;
+
+    status = mongocrypt_status_new();
+    _mongocrypt_buffer_copy_from_hex(&buf,
+                                     "03610000001074000100000010610002000000056b690010000000041234567812349876"
+                                     "1234123456789012056b75001000000004abcdefab123498761234123456789012027600"
+                                     "0900000076616c75653132330012636d00000000000000000000");
+    ASSERT(bson_init_static(&as_bson, buf.data + 1, buf.len - 1));
+    mc_FLE2EncryptionPlaceholder_init(&placeholder);
+    ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, &as_bson, status), status);
+
+    ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT);
+    ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_EQUALITY);
+    ASSERT(BSON_ITER_HOLDS_UTF8(&placeholder.v_iter));
+    ASSERT_STREQUAL(bson_iter_utf8(&placeholder.v_iter, NULL), "value123");
+
+    _mongocrypt_buffer_t expect_index_key_id;
+    _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+    ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+    _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+    _mongocrypt_buffer_t expect_user_key_id;
+    _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+    ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+    _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+    ASSERT(placeholder.maxContentionFactor == 0);
+
+    mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+    _mongocrypt_buffer_cleanup(&buf);
+    mongocrypt_status_destroy(status);
+}
+
+static void _test_FLE2EncryptionPlaceholder_range_parse(_mongocrypt_tester_t *tester) {
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT.
+    {
+        mc_FLE2EncryptionPlaceholder_t placeholder;
+        bson_t as_bson;
+        mongocrypt_status_t *status;
+        _mongocrypt_buffer_t buf;
+
+        status = mongocrypt_status_new();
+        _mongocrypt_buffer_copy_from_hex(&buf,
+                                         "037d0000001074000100000010610003000000056b690010000000041234567812349"
+                                         "8761234123456789012056b75001000000004abcdefab123498761234123456789012"
+                                         "0376001e00000010760040e20100106d696e0000000000106d61780087d6120000126"
+                                         "36d000000000000000000127300010000000000000000");
+        ASSERT(bson_init_static(&as_bson, buf.data + 1, buf.len - 1));
+        mc_FLE2EncryptionPlaceholder_init(&placeholder);
+        ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, &as_bson, status), status);
+
+        ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT);
+        ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_RANGE);
+
+        _mongocrypt_buffer_t expect_index_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+        _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+        _mongocrypt_buffer_t expect_user_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+        _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+        ASSERT_CMPINT64(placeholder.sparsity, ==, 1);
+
+        // Parse FLE2RangeInsertSpec.
+        {
+            mc_FLE2RangeInsertSpec_t spec;
+
+            ASSERT_OK_STATUS(mc_FLE2RangeInsertSpec_parse(&spec, &placeholder.v_iter, false /* use_range_v2 */, status),
+                             status);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.v));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.v), ==, 123456);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.min));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.min), ==, 0);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.max));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.max), ==, 1234567);
+        }
+
+        mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+        _mongocrypt_buffer_cleanup(&buf);
+        mongocrypt_status_destroy(status);
+    }
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND.
+    {
+        mc_FLE2EncryptionPlaceholder_t placeholder;
+        bson_t as_bson;
+        mongocrypt_status_t *status;
+        _mongocrypt_buffer_t buf;
+
+        status = mongocrypt_status_new();
+        _mongocrypt_buffer_copy_from_hex(&buf,
+                                         "03ec0000001074000200000010610003000000056b690010000000041234567812349"
+                                         "8761234123456789012056b75001000000004abcdefab123498761234123456789012"
+                                         "0376008d000000036564676573496e666f005b000000106c6f776572426f756e64000"
+                                         "0000000086c62496e636c756465640001107570706572426f756e640087d612000875"
+                                         "62496e636c75646564000110696e6465784d696e000000000010696e6465784d61780"
+                                         "087d6120000107061796c6f6164496400d20400001066697273744f70657261746f72"
+                                         "00010000000012636d000000000000000000127300010000000000000000");
+        ASSERT(bson_init_static(&as_bson, buf.data + 1, buf.len - 1));
+        mc_FLE2EncryptionPlaceholder_init(&placeholder);
+        ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, &as_bson, status), status);
+
+        ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND);
+        ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_RANGE);
+
+        _mongocrypt_buffer_t expect_index_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+        _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+        _mongocrypt_buffer_t expect_user_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+        _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+        ASSERT_CMPINT64(placeholder.sparsity, ==, 1);
+
+        // Parse FLE2RangeFindSpec.
+        {
+            mc_FLE2RangeFindSpec_t spec;
+
+            ASSERT_OK_STATUS(mc_FLE2RangeFindSpec_parse(&spec, &placeholder.v_iter, false /* use_range_v2 */, status),
+                             status);
+
+            ASSERT(spec.edgesInfo.set);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.edgesInfo.value.lowerBound));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.edgesInfo.value.lowerBound), ==, 0);
+            ASSERT(spec.edgesInfo.value.lbIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.edgesInfo.value.upperBound));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.edgesInfo.value.upperBound), ==, 1234567);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.edgesInfo.value.indexMin));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.edgesInfo.value.indexMin), ==, 0);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_INT32(&spec.edgesInfo.value.indexMax));
+            ASSERT_CMPINT32(bson_iter_int32(&spec.edgesInfo.value.indexMax), ==, 1234567);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT_CMPINT32(spec.payloadId, ==, 1234);
+
+            ASSERT_CMPINT(spec.firstOperator, ==, FLE2RangeOperator_kGt);
+            ASSERT_CMPINT(spec.secondOperator, ==, FLE2RangeOperator_kNone);
+        }
+
+        mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+        _mongocrypt_buffer_cleanup(&buf);
+        mongocrypt_status_destroy(status);
+    }
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND with precision.
+    {
+        mc_FLE2EncryptionPlaceholder_t placeholder;
+        bson_t as_bson;
+        mongocrypt_status_t *status;
+        _mongocrypt_buffer_t buf;
+
+        status = mongocrypt_status_new();
+        _mongocrypt_buffer_copy_from_hex(&buf,
+                                         "030b0100001074000200000010610003000000056b690010000000041234567812349"
+                                         "8761234123456789012056b75001000000004abcdefab123498761234123456789012"
+                                         "037600ac000000036564676573496e666f007a000000016c6f776572426f756e64000"
+                                         "000000000000000086c62496e636c756465640001017570706572426f756e64000000"
+                                         "000000006940087562496e636c75646564000110707265636973696f6e00020000000"
+                                         "1696e6465784d696e00000000000000000001696e6465784d61780000000000000069"
+                                         "4000107061796c6f6164496400d20400001066697273744f70657261746f720001000"
+                                         "0000012636d000000000000000000127300010000000000000000");
+        ASSERT(bson_init_static(&as_bson, buf.data + 1, buf.len - 1));
+        mc_FLE2EncryptionPlaceholder_init(&placeholder);
+        ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, &as_bson, status), status);
+
+        ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND);
+        ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_RANGE);
+
+        _mongocrypt_buffer_t expect_index_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+        _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+        _mongocrypt_buffer_t expect_user_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+        _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+        ASSERT_CMPINT64(placeholder.sparsity, ==, 1);
+
+        // Parse FLE2RangeFindSpec.
+        {
+            mc_FLE2RangeFindSpec_t spec;
+
+            ASSERT_OK_STATUS(mc_FLE2RangeFindSpec_parse(&spec, &placeholder.v_iter, false /* use_range_v2 */, status),
+                             status);
+
+            ASSERT(spec.edgesInfo.set);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.edgesInfo.value.lowerBound));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.edgesInfo.value.lowerBound), ==, 0.0);
+            ASSERT(spec.edgesInfo.value.lbIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.edgesInfo.value.upperBound));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.edgesInfo.value.upperBound), ==, 200.0);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.edgesInfo.value.indexMin));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.edgesInfo.value.indexMin), ==, 0);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.edgesInfo.value.indexMax));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.edgesInfo.value.indexMax), ==, 200.0);
+            ASSERT(spec.edgesInfo.value.ubIncluded);
+
+            ASSERT_CMPDOUBLE(spec.payloadId, ==, 1234);
+
+            ASSERT_CMPINT(spec.firstOperator, ==, FLE2RangeOperator_kGt);
+            ASSERT(spec.edgesInfo.value.precision.set);
+            ASSERT_CMPUINT32(spec.edgesInfo.value.precision.value, ==, 2);
+        }
+
+        mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+        _mongocrypt_buffer_cleanup(&buf);
+        mongocrypt_status_destroy(status);
+    }
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT with precision.
+    {
+        mc_FLE2EncryptionPlaceholder_t placeholder;
+        bson_t as_bson;
+        mongocrypt_status_t *status;
+        _mongocrypt_buffer_t buf;
+
+        status = mongocrypt_status_new();
+        _mongocrypt_buffer_copy_from_hex(&buf,
+                                         "03980000001074000100000010610003000000056b690010000000041234567812349"
+                                         "8761234123456789012056b75001000000004abcdefab123498761234123456789012"
+                                         "0376003900000001760077be9f1a2fdd5e40016d696e000000000000000000016d617"
+                                         "800000000000000694010707265636973696f6e00020000000012636d000000000000"
+                                         "000000127300010000000000000000");
+        ASSERT(bson_init_static(&as_bson, buf.data + 1, buf.len - 1));
+        mc_FLE2EncryptionPlaceholder_init(&placeholder);
+        ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, &as_bson, status), status);
+
+        ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT);
+        ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_RANGE);
+
+        _mongocrypt_buffer_t expect_index_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+        _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+        _mongocrypt_buffer_t expect_user_key_id;
+        _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+        ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+        _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+        ASSERT_CMPINT64(placeholder.sparsity, ==, 1);
+
+        // Parse FLE2RangeInsertSpec.
+        {
+            mc_FLE2RangeInsertSpec_t spec;
+
+            ASSERT_OK_STATUS(mc_FLE2RangeInsertSpec_parse(&spec, &placeholder.v_iter, false /* use_range_v2 */, status),
+                             status);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.v));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.v), ==, 123.456);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.min));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.min), ==, 0.0);
+
+            ASSERT(BSON_ITER_HOLDS_DOUBLE(&spec.max));
+            ASSERT_CMPDOUBLE(bson_iter_double(&spec.max), ==, 200.0);
+
+            ASSERT(spec.precision.set);
+            ASSERT_CMPUINT32(spec.precision.value, ==, 2);
+        }
+
+        mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+        _mongocrypt_buffer_cleanup(&buf);
+        mongocrypt_status_destroy(status);
+    }
+}
+
+static bool _parse_text_search_spec_from_placeholder(_mongocrypt_tester_t *tester,
+                                                     const char *spec_json_in,
+                                                     mc_FLE2TextSearchInsertSpec_t *spec_out,
+                                                     mongocrypt_status_t *status_out) {
+    const char *template = RAW_STRING({
+        "t" : {"$numberInt" : "1"},
+        "a" : {"$numberInt" : "4"},
+        "ki" : {"$binary" : {"base64" : "EjRWeBI0mHYSNBI0VniQEg==", "subType" : "04"}},
+        "ku" : {"$binary" : {"base64" : "q83vqxI0mHYSNBI0VniQEg==", "subType" : "04"}},
+        "v" : % s,
+        "cm" : {"$numberLong" : "7"}
+    });
+    bson_t *const as_bson = TMP_BSON(template, spec_json_in);
+
+    mc_FLE2EncryptionPlaceholder_t placeholder;
+    mc_FLE2EncryptionPlaceholder_init(&placeholder);
+    ASSERT_OK_STATUS(mc_FLE2EncryptionPlaceholder_parse(&placeholder, as_bson, status_out), status_out);
+
+    ASSERT(placeholder.type == MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT);
+    ASSERT(placeholder.algorithm == MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH);
+
+    _mongocrypt_buffer_t expect_index_key_id;
+    _mongocrypt_buffer_copy_from_hex(&expect_index_key_id, "12345678123498761234123456789012");
+    ASSERT_CMPBUF(placeholder.index_key_id, expect_index_key_id);
+    _mongocrypt_buffer_cleanup(&expect_index_key_id);
+
+    _mongocrypt_buffer_t expect_user_key_id;
+    _mongocrypt_buffer_copy_from_hex(&expect_user_key_id, "abcdefab123498761234123456789012");
+    ASSERT_CMPBUF(placeholder.user_key_id, expect_user_key_id);
+    _mongocrypt_buffer_cleanup(&expect_user_key_id);
+
+    ASSERT_CMPINT64(placeholder.sparsity, ==, 0);
+    ASSERT(placeholder.maxContentionFactor == 7);
+
+    bool res = mc_FLE2TextSearchInsertSpec_parse(spec_out, &placeholder.v_iter, status_out);
+
+    mc_FLE2EncryptionPlaceholder_cleanup(&placeholder);
+    return res;
+}
+
+static void _test_FLE2EncryptionPlaceholder_textSearch_parse(_mongocrypt_tester_t *tester) {
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT with substr + suffix + prefix specs
+    {
+        const char *input = RAW_STRING({
+            "v" : "foobar",
+            "casef" : false,
+            "diacf" : true,
+            "substr" : {"ub" : {"$numberInt" : "200"}, "lb" : {"$numberInt" : "20"}, "mlen" : {"$numberInt" : "2000"}},
+            "suffix" : {"ub" : {"$numberInt" : "300"}, "lb" : {"$numberInt" : "30"}},
+            "prefix" : {"ub" : {"$numberInt" : "400"}, "lb" : {"$numberInt" : "400"}}
+        });
+        mongocrypt_status_t *status = mongocrypt_status_new();
+        mc_FLE2TextSearchInsertSpec_t spec;
+        ASSERT_OK_STATUS(_parse_text_search_spec_from_placeholder(tester, input, &spec, status), status);
+        ASSERT(BSON_ITER_HOLDS_UTF8(&spec.v_iter));
+        ASSERT(bson_iter_utf8(&spec.v_iter, NULL) == spec.v);
+        ASSERT(strlen("foobar") == spec.len);
+        ASSERT(0 == strncmp("foobar", spec.v, spec.len));
+        ASSERT(spec.diacf == true);
+        ASSERT(spec.casef == false);
+        ASSERT(spec.substr.set == true);
+        ASSERT(spec.substr.value.lb == 20);
+        ASSERT(spec.substr.value.ub == 200);
+        ASSERT(spec.substr.value.mlen == 2000);
+        ASSERT(spec.suffix.set == true);
+        ASSERT(spec.suffix.value.lb == 30);
+        ASSERT(spec.suffix.value.ub == 300);
+        ASSERT(spec.prefix.set == true);
+        ASSERT(spec.prefix.value.lb == 400);
+        ASSERT(spec.prefix.value.ub == 400);
+        mongocrypt_status_destroy(status);
+    }
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT without substring, suffix, or prefix specs
+    {
+        const char *input = RAW_STRING({"v" : "foobar", "casef" : false, "diacf" : true});
+        mongocrypt_status_t *status = mongocrypt_status_new();
+        mc_FLE2TextSearchInsertSpec_t spec;
+        ASSERT_FAILS_STATUS(_parse_text_search_spec_from_placeholder(tester, input, &spec, status),
+                            status,
+                            "Must have a substring, suffix, or prefix index specification");
+        mongocrypt_status_destroy(status);
+    }
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT with lb > ub
+#define LB_GT_UB_TEST(Type)                                                                                            \
+    do {                                                                                                               \
+        const char *input = RAW_STRING({                                                                               \
+            "v" : "foobar",                                                                                            \
+            "casef" : false,                                                                                           \
+            "diacf" : true,                                                                                            \
+            Type : {"ub" : {"$numberInt" : "30"}, "lb" : {"$numberInt" : "40"}, "mlen" : {"$numberInt" : "400"}}       \
+        });                                                                                                            \
+        mongocrypt_status_t *status = mongocrypt_status_new();                                                         \
+        mc_FLE2TextSearchInsertSpec_t spec;                                                                            \
+        ASSERT_FAILS_STATUS(_parse_text_search_spec_from_placeholder(tester, input, &spec, status),                    \
+                            status,                                                                                    \
+                            "upper bound cannot be less than the lower bound");                                        \
+        mongocrypt_status_destroy(status);                                                                             \
+    } while (0)
+    LB_GT_UB_TEST("substr");
+    LB_GT_UB_TEST("suffix");
+    LB_GT_UB_TEST("prefix");
+#undef LB_GT_UB_TEST
+
+    // Test type=MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT with mlen < ub
+    {
+        const char *input = RAW_STRING({
+            "v" : "foobar",
+            "casef" : false,
+            "diacf" : true,
+            "substr" :
+                {"ub" : {"$numberInt" : "2000"}, "lb" : {"$numberInt" : "20"}, "mlen" : {"$numberInt" : "200"}}
+        });
+        mongocrypt_status_t *status = mongocrypt_status_new();
+        mc_FLE2TextSearchInsertSpec_t spec;
+        ASSERT_FAILS_STATUS(_parse_text_search_spec_from_placeholder(tester, input, &spec, status),
+                            status,
+                            "maximum indexed length cannot be less than the upper bound");
+        mongocrypt_status_destroy(status);
+    }
+}
+
+static void _test_FLE2EncryptionPlaceholder_parse_errors(_mongocrypt_tester_t *tester) {
+    bson_t *input_bson = TMP_BSON(BSON_STR({
+        "t" : {"$numberInt" : "1"},
+        "a" : {"$numberInt" : "1"},
+        "ki" : {"$binary" : {"base64" : "EjRWeBI0mHYSNBI0VniQEg==", "subType" : "04"}},
+        "ku" : {"$binary" : {"base64" : "q83vqxI0mHYSNBI0VniQEg==", "subType" : "04"}},
+        "v" : "foobar",
+        "cm" : "wrong type!"
+    }));
+
+    mc_FLE2EncryptionPlaceholder_t payload;
+    mc_FLE2EncryptionPlaceholder_init(&payload);
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    ASSERT_FAILS_STATUS(mc_FLE2EncryptionPlaceholder_parse(&payload, input_bson, status),
+                        status,
+                        "'cm' must be an int64");
+    mc_FLE2EncryptionPlaceholder_cleanup(&payload);
+    mongocrypt_status_destroy(status);
+}
+
+void _mongocrypt_tester_install_fle2_encryption_placeholder(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_FLE2EncryptionPlaceholder_parse);
+    INSTALL_TEST(_test_FLE2EncryptionPlaceholder_range_parse);
+    INSTALL_TEST(_test_FLE2EncryptionPlaceholder_textSearch_parse);
+    INSTALL_TEST(_test_FLE2EncryptionPlaceholder_parse_errors);
+}