libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

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

@@ -34,9 +34,11 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     _mongocrypt_buffer_copy_from_hex(&expect_keyId1, "12345678123498761234123456789012");
     _mongocrypt_buffer_copy_from_hex(&expect_keyId2, "abcdefab123498761234123456789012");
 
+    const bool use_range_v2 = false;
+
     {
         _load_test_file(tester, "./test/data/efc/efc-oneField.json", &efc_bson);
-        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status), status);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -47,7 +49,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), status);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -58,7 +60,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), status);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "lastName");
@@ -73,7 +75,7 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
 
     {
         _load_test_file(tester, "./test/data/efc/efc-missingKeyId.json", &efc_bson);
-        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status),
+        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2),
                             status,
                             "unable to find 'keyId' in 'field' document");
         mc_EncryptedFieldConfig_cleanup(&efc);

data/ext/libmongocrypt/libmongocrypt/test/test-mc-fle2-find-range-payload-v2.c

@@ -17,6 +17,7 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-find-range-payload-private-v2.h"
+#include "test-mongocrypt-assert-match-bson.h"
 #include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
@@ -62,7 +63,7 @@ static void _test_FLE2FindRangePayloadV2_roundtrip(_mongocrypt_tester_t *tester)
         tokenSet.escDerivedToken = expect_escDerivedToken;
         tokenSet.serverDerivedFromDataToken = expect_serverDerivedFromDataToken;
         _mc_array_append_val(&payload.payload.value.edgeFindTokenSetArray, tokenSet);
-        payload.payload.value.maxContentionCounter = (uint64_t)4;
+        payload.payload.value.maxContentionFactor = (uint64_t)4;
     }
 
     payload.payload.set = true;
@@ -72,7 +73,8 @@ static void _test_FLE2FindRangePayloadV2_roundtrip(_mongocrypt_tester_t *tester)
     payload.secondOperator = expect_secondOperator;
 
     bson_init(&out_bson);
-    mc_FLE2FindRangePayloadV2_serialize(&payload, &out_bson);
+    const bool use_range_v2 = false;
+    mc_FLE2FindRangePayloadV2_serialize(&payload, &out_bson, use_range_v2);
 
     ASSERT_EQUAL_BSON(&in_bson, &out_bson);
 
@@ -84,6 +86,44 @@ static void _test_FLE2FindRangePayloadV2_roundtrip(_mongocrypt_tester_t *tester)
 
 #undef TEST_FIND_RANGE_PAYLOAD_HEX_V2
 
+static void _test_FLE2FindRangePayloadV2_includes_crypto_params(_mongocrypt_tester_t *tester) {
+    mc_FLE2FindRangePayloadV2_t payload;
+    mc_FLE2FindRangePayloadV2_init(&payload);
+    payload.sparsity = OPT_I64(1);
+    payload.precision = OPT_I32(2);
+    payload.trimFactor = OPT_I32(3);
+    bson_value_t indexMin = {.value.v_int32 = 4, .value_type = BSON_TYPE_INT32};
+    bson_value_copy(&indexMin, &payload.indexMin);
+    bson_value_t indexMax = {.value.v_int32 = 5, .value_type = BSON_TYPE_INT32};
+    bson_value_copy(&indexMax, &payload.indexMax);
+
+    // Test crypto params from SERVER-91889 are included in "range" payload.
+    {
+        bson_t got = BSON_INITIALIZER;
+        const bool use_range_v2 = true;
+        ASSERT(mc_FLE2FindRangePayloadV2_serialize(&payload, &got, use_range_v2));
+        _assert_match_bson(&got, TMP_BSON(BSON_STR({"sp" : 1, "pn" : 2, "tf" : 3, "mn" : 4, "mx" : 5})));
+        bson_destroy(&got);
+    }
+
+    // Test crypto params from SERVER-91889 are excluded in "rangePreview" payload.
+    {
+        bson_t got = BSON_INITIALIZER;
+        const bool use_range_v2 = false;
+        ASSERT(mc_FLE2FindRangePayloadV2_serialize(&payload, &got, use_range_v2));
+        _assert_match_bson(&got, TMP_BSON(BSON_STR({
+            "sp" : {"$exists" : false},
+            "pn" : {"$exists" : false},
+            "tf" : {"$exists" : false},
+            "mn" : {"$exists" : false},
+            "mx" : {"$exists" : false}
+        })));
+        bson_destroy(&got);
+    }
+    mc_FLE2FindRangePayloadV2_cleanup(&payload);
+}
+
 void _mongocrypt_tester_install_fle2_payload_find_range_v2(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_FLE2FindRangePayloadV2_roundtrip);
-}
+    INSTALL_TEST(_test_FLE2FindRangePayloadV2_includes_crypto_params);
+}

data/ext/libmongocrypt/libmongocrypt/test/test-mc-fle2-payload-iup-v2.c

@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+#include "mc-fle-blob-subtype-private.h"
 #include "mc-fle2-insert-update-payload-private-v2.h"
+#include "test-mongocrypt-assert-match-bson.h"
 #include "test-mongocrypt.h"
 
 #define TEST_IUP_HEX_V2                                                                                                \
@@ -166,7 +168,81 @@ static void _test_mc_FLE2InsertUpdatePayloadV2_decrypt(_mongocrypt_tester_t *tes
 
 #undef TEST_IUP_HEX_V2
 
+static void _test_mc_FLE2InsertUpdatePayloadV2_includes_crypto_params(_mongocrypt_tester_t *tester) {
+    mc_FLE2InsertUpdatePayloadV2_t payload;
+    mc_FLE2InsertUpdatePayloadV2_init(&payload);
+    payload.sparsity = OPT_I64(1);
+    payload.precision = OPT_I32(2);
+    payload.trimFactor = OPT_I32(3);
+    bson_value_t indexMin = {.value.v_int32 = 4, .value_type = BSON_TYPE_INT32};
+    bson_value_copy(&indexMin, &payload.indexMin);
+    bson_value_t indexMax = {.value.v_int32 = 5, .value_type = BSON_TYPE_INT32};
+    bson_value_copy(&indexMax, &payload.indexMax);
+
+    // Test crypto params from SERVER-91889 are included in "range" payload.
+    {
+        bson_t got = BSON_INITIALIZER;
+        const bool use_range_v2 = true;
+        ASSERT(mc_FLE2InsertUpdatePayloadV2_serializeForRange(&payload, &got, use_range_v2));
+        _assert_match_bson(&got, TMP_BSON(BSON_STR({"sp" : 1, "pn" : 2, "tf" : 3, "mn" : 4, "mx" : 5})));
+        bson_destroy(&got);
+    }
+
+    // Test crypto params from SERVER-91889 are excluded in "rangePreview" payload.
+    {
+        bson_t got = BSON_INITIALIZER;
+        const bool use_range_v2 = false;
+        ASSERT(mc_FLE2InsertUpdatePayloadV2_serializeForRange(&payload, &got, use_range_v2));
+        _assert_match_bson(&got, TMP_BSON(BSON_STR({
+            "sp" : {"$exists" : false},
+            "pn" : {"$exists" : false},
+            "tf" : {"$exists" : false},
+            "mn" : {"$exists" : false},
+            "mx" : {"$exists" : false}
+        })));
+        bson_destroy(&got);
+    }
+    mc_FLE2InsertUpdatePayloadV2_cleanup(&payload);
+}
+
+static void _test_mc_FLE2InsertUpdatePayloadV2_parses_crypto_params(_mongocrypt_tester_t *tester) {
+    mongocrypt_binary_t *payload = TEST_FILE("test/data/range-sends-cryptoParams/explicit-insert-int32/expected.json");
+
+    _mongocrypt_buffer_t payload_buf;
+    // Unwrap the { "v": <BSON binary> } into a `_mongocrypt_buffer_t`.
+    {
+        bson_t payload_bson;
+        ASSERT(_mongocrypt_binary_to_bson(payload, &payload_bson));
+        bson_iter_t iter;
+        ASSERT(bson_iter_init_find(&iter, &payload_bson, "v"));
+        ASSERT(_mongocrypt_buffer_from_binary_iter(&payload_buf, &iter));
+    }
+
+    mc_FLE2InsertUpdatePayloadV2_t got;
+    mc_FLE2InsertUpdatePayloadV2_init(&got);
+
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    ASSERT_OK_STATUS(mc_FLE2InsertUpdatePayloadV2_parse(&got, &payload_buf, status), status);
+    mongocrypt_status_destroy(status);
+
+    ASSERT(got.sparsity.set);
+    ASSERT_CMPINT64(got.sparsity.value, ==, 3);
+
+    ASSERT(!got.precision.set); // Payload does not include precision.
+
+    ASSERT(got.trimFactor.set);
+    ASSERT_CMPINT32(got.trimFactor.value, ==, 4);
+
+    ASSERT(got.indexMin.value_type == BSON_TYPE_INT32);
+    ASSERT_CMPINT32(got.indexMin.value.v_int32, ==, 0);
+
+    ASSERT(got.indexMax.value_type == BSON_TYPE_INT32);
+    ASSERT_CMPINT32(got.indexMax.value.v_int32, ==, 1234567);
+}
+
 void _mongocrypt_tester_install_fle2_payload_iup_v2(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_FLE2InsertUpdatePayloadV2_parse);
     INSTALL_TEST(_test_mc_FLE2InsertUpdatePayloadV2_decrypt);
+    INSTALL_TEST(_test_mc_FLE2InsertUpdatePayloadV2_includes_crypto_params);
+    INSTALL_TEST(_test_mc_FLE2InsertUpdatePayloadV2_parses_crypto_params);
 }

data/ext/libmongocrypt/libmongocrypt/test/test-mc-fle2-rfds.c

@@ -197,7 +197,7 @@ static void test_mc_FLE2RangeFindDriverSpec_to_placeholders(_mongocrypt_tester_t
     user_key_id.subtype = BSON_SUBTYPE_UUID;
     index_key_id.subtype = BSON_SUBTYPE_UUID;
 
-    int64_t maxContentionCounter = 4;
+    int64_t maxContentionFactor = 4;
     int64_t sparsity = 1;
     int32_t indexMin = 5;
     int32_t indexMax = 200;
@@ -325,7 +325,7 @@ static void test_mc_FLE2RangeFindDriverSpec_to_placeholders(_mongocrypt_tester_t
     bson_t *range_opts_bson =
         TMP_BSON("{'min': %d, 'max': %d, 'sparsity': {'$numberLong': '%d'}}", indexMin, indexMax, sparsity);
 
-    ASSERT_OK_STATUS(mc_RangeOpts_parse(&range_opts, range_opts_bson, status), status);
+    ASSERT_OK_STATUS(mc_RangeOpts_parse(&range_opts, range_opts_bson, true /* use_range_v2 */, status), status);
 
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
         testcase_t *test = tests + i;
@@ -354,7 +354,7 @@ static void test_mc_FLE2RangeFindDriverSpec_to_placeholders(_mongocrypt_tester_t
                                                                    .secondOp = test->p1.secondOp,
                                                                    .indexMin = TMP_ITER(indexMin),
                                                                    .indexMax = TMP_ITER(indexMax),
-                                                                   .maxContentionCounter = maxContentionCounter,
+                                                                   .maxContentionFactor = maxContentionFactor,
                                                                    .sparsity = sparsity};
 
                 ASSERT_OK_STATUS(mc_makeRangeFindPlaceholder(&p1_args_full, &p1, status), status);
@@ -373,7 +373,7 @@ static void test_mc_FLE2RangeFindDriverSpec_to_placeholders(_mongocrypt_tester_t
                                                                    .secondOp = test->p2.secondOp,
                                                                    .indexMin = TMP_ITER(indexMin),
                                                                    .indexMax = TMP_ITER(indexMax),
-                                                                   .maxContentionCounter = maxContentionCounter,
+                                                                   .maxContentionFactor = maxContentionFactor,
                                                                    .sparsity = sparsity};
 
                 ASSERT_OK_STATUS(mc_makeRangeFindPlaceholder(&p2_args_full, &p2, status), status);
@@ -386,7 +386,7 @@ static void test_mc_FLE2RangeFindDriverSpec_to_placeholders(_mongocrypt_tester_t
         bson_t out = BSON_INITIALIZER;
         bool ok = mc_FLE2RangeFindDriverSpec_to_placeholders(&spec,
                                                              &range_opts,
-                                                             maxContentionCounter,
+                                                             maxContentionFactor,
                                                              &user_key_id,
                                                              &index_key_id,
                                                              payloadId,

data/ext/libmongocrypt/libmongocrypt/test/test-mc-range-edge-generation.c

@@ -32,6 +32,7 @@ typedef struct {
     // expectEdges includes a trailing NULL pointer.
     const char *expectEdges[MAX_INT32_EDGES + 1];
     const char *expectError;
+    int32_t trimFactor;
 } Int32Test;
 
 #undef MAX_INT32_EDGES
@@ -62,6 +63,49 @@ static void _test_getEdgesInt32(_mongocrypt_tester_t *tester) {
          .expectEdges = {"root", "010", "0", "01"}},
         {.value = 2, .min = OPT_I32_C(0), .max = OPT_I32_C(7), .sparsity = 2, .expectEdges = {"root", "010", "01"}},
         {.value = 1, .sparsity = 0, .expectError = "sparsity must be 1 or larger"},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 1,
+         .expectEdges = {"010", "0", "01"}},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 2,
+         .expectEdges = {"010", "01"}},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 3,
+         .expectError =
+             "trimFactor must be less than the number of bits (3) used to represent an element of the domain"},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = -1,
+         .expectError = "trimFactor must be >= 0"},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 2,
+         .trimFactor = 0,
+         .expectEdges = {"root", "010", "01"}},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 2,
+         .trimFactor = 1,
+         .expectEdges = {"010", "01"}},
+        {.value = 2,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 2,
+         .trimFactor = 2,
+         .expectEdges = {"010", "01"}},
 #include "data/range-edge-generation/edges_int32.cstruct"
     };
 
@@ -71,8 +115,10 @@ static void _test_getEdgesInt32(_mongocrypt_tester_t *tester) {
         mc_getEdgesInt32_args_t args = {.value = test->value,
                                         .min = test->min,
                                         .max = test->max,
-                                        .sparsity = test->sparsity};
-        mc_edges_t *got = mc_getEdgesInt32(args, status);
+                                        .sparsity = test->sparsity,
+                                        .trimFactor = OPT_I32(test->trimFactor)};
+        const bool use_range_v2 = true;
+        mc_edges_t *got = mc_getEdgesInt32(args, status, use_range_v2);
         if (test->expectError != NULL) {
             ASSERT_OR_PRINT_MSG(NULL == got, "expected error, got success");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -116,6 +162,7 @@ typedef struct {
     // expectEdges includes a trailing NULL pointer.
     const char *expectEdges[MAX_INT64_EDGES + 1];
     const char *expectError;
+    uint32_t trimFactor;
 } Int64Test;
 
 #undef MAX_INT64_EDGES
@@ -132,6 +179,25 @@ static void _test_getEdgesInt64(_mongocrypt_tester_t *tester) {
          .max = OPT_I64_C(7),
          .sparsity = 2,
          .expectEdges = {"root", "010", "01"}},
+        {.value = INT64_C(2),
+         .min = OPT_I64_C(0),
+         .max = OPT_I64_C(7),
+         .sparsity = 1,
+         .trimFactor = 1,
+         .expectEdges = {"010", "0", "01"}},
+        {.value = INT64_C(2),
+         .min = OPT_I64_C(0),
+         .max = OPT_I64_C(7),
+         .sparsity = 1,
+         .trimFactor = 2,
+         .expectEdges = {"010", "01"}},
+        {.value = INT64_C(2),
+         .min = OPT_I64_C(0),
+         .max = OPT_I64_C(7),
+         .sparsity = 1,
+         .trimFactor = 3,
+         .expectError =
+             "trimFactor must be less than the number of bits (3) used to represent an element of the domain"},
         {.value = 1, .sparsity = 0, .expectError = "sparsity must be 1 or larger"},
 #include "data/range-edge-generation/edges_int64.cstruct"
     };
@@ -142,8 +208,10 @@ static void _test_getEdgesInt64(_mongocrypt_tester_t *tester) {
         mc_getEdgesInt64_args_t args = {.value = test->value,
                                         .min = test->min,
                                         .max = test->max,
-                                        .sparsity = test->sparsity};
-        mc_edges_t *got = mc_getEdgesInt64(args, status);
+                                        .sparsity = test->sparsity,
+                                        .trimFactor = OPT_I32(test->trimFactor)};
+        const bool use_range_v2 = true;
+        mc_edges_t *got = mc_getEdgesInt64(args, status, use_range_v2);
         if (test->expectError != NULL) {
             ASSERT_OR_PRINT_MSG(NULL == got, "expected error, got success");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -181,6 +249,8 @@ static void _test_getEdgesInt64(_mongocrypt_tester_t *tester) {
 
 typedef struct {
     double value;
+    mc_optional_double_t min; // Unused. Kept for consistency with server test data.
+    mc_optional_double_t max; // Unused. Kept for consistency with server test data.
     size_t sparsity;
     // expectEdges includes a trailing NULL pointer.
     const char *expectEdges[MAX_DOUBLE_EDGES + 1];
@@ -197,8 +267,12 @@ static void _test_getEdgesDouble(_mongocrypt_tester_t *tester) {
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
         mongocrypt_status_t *const status = mongocrypt_status_new();
         const DoubleTest *test = tests + i;
-        mc_getEdgesDouble_args_t args = {.value = test->value, .sparsity = test->sparsity};
-        mc_edges_t *got = mc_getEdgesDouble(args, status);
+        const uint32_t trimFactor = 0; // At present, all test cases expect trimFactor=0.
+        mc_getEdgesDouble_args_t args = {.value = test->value,
+                                         .sparsity = test->sparsity,
+                                         .trimFactor = OPT_I32(trimFactor)};
+        const bool use_range_v2 = true;
+        mc_edges_t *got = mc_getEdgesDouble(args, status, use_range_v2);
 
         if (test->expectError != NULL) {
             if (NULL != got) {
@@ -258,14 +332,15 @@ static void _test_getEdgesDecimal128(_mongocrypt_tester_t *tester) {
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
         const Decimal128Test *test = tests + i;
         mongocrypt_status_t *const status = mongocrypt_status_new();
-        mc_getEdgesDecimal128_args_t args = {
-            .value = test->value,
-            // Some edges specify min/max values, but we don't use them (yet)
-            //  .min = test->min,
-            //  .max = test->max,
-            .sparsity = (size_t)test->sparsity,
-        };
-        mc_edges_t *got = mc_getEdgesDecimal128(args, status);
+        const uint32_t trimFactor = 0; // At present, all test cases expect trimFactor=0.
+        mc_getEdgesDecimal128_args_t args = {.value = test->value,
+                                             // Some edges specify min/max values, but we don't use them (yet)
+                                             //  .min = test->min,
+                                             //  .max = test->max,
+                                             .sparsity = (size_t)test->sparsity,
+                                             .trimFactor = OPT_I32(trimFactor)};
+        const bool use_range_v2 = true;
+        mc_edges_t *got = mc_getEdgesDecimal128(args, status, use_range_v2);
 
         if (test->expectError != NULL) {
             if (NULL != got) {