libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

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

@@ -22,11 +22,14 @@
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt.h"
 
+#define CLIENT_ERR_PREFIXED_HELPER(Prefix, ErrorString, ...) CLIENT_ERR(Prefix ": " ErrorString, ##__VA_ARGS__)
+#define CLIENT_ERR_PREFIXED(ErrorString, ...) CLIENT_ERR_PREFIXED_HELPER(ERROR_PREFIX, ErrorString, ##__VA_ARGS__)
+
 // Common logic for testing field name, tracking duplication, and presence.
 #define IF_FIELD(Name)                                                                                                 \
     if (0 == strcmp(field, #Name)) {                                                                                   \
         if (has_##Name) {                                                                                              \
-            CLIENT_ERR("Duplicate field '" #Name "' in placeholder bson");                                             \
+            CLIENT_ERR_PREFIXED("Duplicate field '" #Name "' in placeholder bson");                                    \
             goto fail;                                                                                                 \
         }                                                                                                              \
         has_##Name = true;
@@ -37,7 +40,7 @@
 
 #define CHECK_HAS(Name)                                                                                                \
     if (!has_##Name) {                                                                                                 \
-        CLIENT_ERR("Missing field '" #Name "' in placeholder");                                                        \
+        CLIENT_ERR_PREFIXED("Missing field '" #Name "' in placeholder");                                               \
         goto fail;                                                                                                     \
     }
 
@@ -45,10 +48,12 @@ void mc_FLE2EncryptionPlaceholder_init(mc_FLE2EncryptionPlaceholder_t *placehold
     memset(placeholder, 0, sizeof(mc_FLE2EncryptionPlaceholder_t));
 }
 
+#define ERROR_PREFIX "Error parsing FLE2EncryptionPlaceholder"
+
 bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
                                         const bson_t *in,
                                         mongocrypt_status_t *status) {
-    bson_iter_t iter;
+    bson_iter_t iter = {0};
     bool has_t = false, has_a = false, has_v = false, has_cm = false;
     bool has_ki = false, has_ku = false;
     bool has_s = false;
@@ -58,7 +63,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
     mc_FLE2EncryptionPlaceholder_init(out);
     if (!bson_validate(in, BSON_VALIDATE_NONE, NULL) || !bson_iter_init(&iter, in)) {
-        CLIENT_ERR("invalid BSON");
+        CLIENT_ERR_PREFIXED("invalid BSON");
         return false;
     }
 
@@ -69,12 +74,12 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
         IF_FIELD(t) {
             int32_t type;
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid marking, 't' must be an int32");
+                CLIENT_ERR_PREFIXED("invalid marking, 't' must be an int32");
                 goto fail;
             }
             type = bson_iter_int32(&iter);
             if ((type != MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT) && (type != MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND)) {
-                CLIENT_ERR("invalid placeholder type value: %d", type);
+                CLIENT_ERR_PREFIXED("invalid placeholder type value: %d", type);
                 goto fail;
             }
             out->type = (mongocrypt_fle2_placeholder_type_t)type;
@@ -84,13 +89,13 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
         IF_FIELD(a) {
             int32_t algorithm;
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid marking, 'a' must be an int32");
+                CLIENT_ERR_PREFIXED("invalid marking, 'a' must be an int32");
                 goto fail;
             }
             algorithm = bson_iter_int32(&iter);
             if (algorithm != MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED && algorithm != MONGOCRYPT_FLE2_ALGORITHM_EQUALITY
                 && algorithm != MONGOCRYPT_FLE2_ALGORITHM_RANGE) {
-                CLIENT_ERR("invalid algorithm value: %d", algorithm);
+                CLIENT_ERR_PREFIXED("invalid algorithm value: %d", algorithm);
                 goto fail;
             }
             out->algorithm = (mongocrypt_fle2_encryption_algorithm_t)algorithm;
@@ -99,7 +104,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
         IF_FIELD(ki) {
             if (!_mongocrypt_buffer_from_uuid_iter(&out->index_key_id, &iter)) {
-                CLIENT_ERR("index key id must be a UUID");
+                CLIENT_ERR_PREFIXED("index key id must be a UUID");
                 goto fail;
             }
         }
@@ -107,7 +112,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
         IF_FIELD(ku) {
             if (!_mongocrypt_buffer_from_uuid_iter(&out->user_key_id, &iter)) {
-                CLIENT_ERR("user key id must be a UUID");
+                CLIENT_ERR_PREFIXED("user key id must be a UUID");
                 goto fail;
             }
         }
@@ -120,11 +125,11 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
         IF_FIELD(cm) {
             if (!BSON_ITER_HOLDS_INT64(&iter)) {
-                CLIENT_ERR("invalid marking, 'cm' must be an int64");
+                CLIENT_ERR_PREFIXED("invalid marking, 'cm' must be an int64");
                 goto fail;
             }
-            out->maxContentionCounter = bson_iter_int64(&iter);
-            if (!mc_validate_contention(out->maxContentionCounter, status)) {
+            out->maxContentionFactor = bson_iter_int64(&iter);
+            if (!mc_validate_contention(out->maxContentionFactor, status)) {
                 goto fail;
             }
         }
@@ -132,7 +137,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
         IF_FIELD(s) {
             if (!BSON_ITER_HOLDS_INT64(&iter)) {
-                CLIENT_ERR("invalid marking, 's' must be an int64");
+                CLIENT_ERR_PREFIXED("invalid marking, 's' must be an int64");
                 goto fail;
             }
             out->sparsity = bson_iter_int64(&iter);
@@ -168,37 +173,47 @@ void mc_FLE2EncryptionPlaceholder_cleanup(mc_FLE2EncryptionPlaceholder_t *placeh
     mc_FLE2EncryptionPlaceholder_init(placeholder);
 }
 
+#undef ERROR_PREFIX
+#define ERROR_PREFIX "Error validating contention"
+
 bool mc_validate_contention(int64_t contention, mongocrypt_status_t *status) {
     if (contention < 0) {
-        CLIENT_ERR("contention must be non-negative, got: %" PRId64, contention);
+        CLIENT_ERR_PREFIXED("contention must be non-negative, got: %" PRId64, contention);
         return false;
     }
     if (contention == INT64_MAX) {
-        CLIENT_ERR("contention must be < INT64_MAX, got: %" PRId64, contention);
+        CLIENT_ERR_PREFIXED("contention must be < INT64_MAX, got: %" PRId64, contention);
         return false;
     }
     return true;
 }
 
+#undef ERROR_PREFIX
+#define ERROR_PREFIX "Error validating sparsity"
+
 bool mc_validate_sparsity(int64_t sparsity, mongocrypt_status_t *status) {
     if (sparsity < 0) {
-        CLIENT_ERR("sparsity must be non-negative, got: %" PRId64, sparsity);
+        CLIENT_ERR_PREFIXED("sparsity must be non-negative, got: %" PRId64, sparsity);
         return false;
     }
     // mc_getEdgesInt expects a size_t sparsity.
-    if (sparsity >= SIZE_MAX) {
-        CLIENT_ERR("sparsity must be < %zu, got: %" PRId64, SIZE_MAX, sparsity);
+    if ((uint64_t)sparsity >= SIZE_MAX) {
+        CLIENT_ERR_PREFIXED("sparsity must be < %zu, got: %" PRId64, SIZE_MAX, sparsity);
         return false;
     }
     return true;
 }
 
+#undef ERROR_PREFIX
+#define ERROR_PREFIX "Error parsing FLE2RangeFindSpecEdgesInfo"
+
 static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t *out,
                                                 const bson_iter_t *in,
+                                                bool use_range_v2,
                                                 mongocrypt_status_t *status) {
     bson_iter_t iter;
     bool has_lowerBound = false, has_lbIncluded = false, has_upperBound = false, has_ubIncluded = false,
-         has_indexMin = false, has_indexMax = false, has_precision = false;
+         has_indexMin = false, has_indexMax = false, has_precision = false, has_trimFactor = false;
 
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(in);
@@ -206,8 +221,7 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
     iter = *in;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: must be an iterator to "
-                   "a document");
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -223,8 +237,7 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
 
         IF_FIELD(lbIncluded) {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'lbIncluded' must "
-                           "be a bool");
+                CLIENT_ERR_PREFIXED("'lbIncluded' must be a bool");
                 goto fail;
             }
             out->lbIncluded = bson_iter_bool(&iter);
@@ -238,8 +251,7 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
 
         IF_FIELD(ubIncluded) {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'ubIncluded' must "
-                           "be a bool");
+                CLIENT_ERR_PREFIXED("'ubIncluded' must be a bool");
                 goto fail;
             }
             out->ubIncluded = bson_iter_bool(&iter);
@@ -258,18 +270,31 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
 
         IF_FIELD(precision) {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'precision' must "
-                           "be an int32");
+                CLIENT_ERR_PREFIXED("'precision' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'precision' must be"
-                           "non-negative");
+                CLIENT_ERR_PREFIXED("'precision' must be non-negative");
                 goto fail;
             }
 
-            out->precision = OPT_U32((uint32_t)val);
+            out->precision = OPT_I32(val);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(trimFactor) {
+            if (!BSON_ITER_HOLDS_INT32(&iter)) {
+                CLIENT_ERR_PREFIXED("'trimFactor' must be an int32");
+                goto fail;
+            }
+            int32_t val = bson_iter_int32(&iter);
+            if (val < 0) {
+                CLIENT_ERR_PREFIXED("'trimFactor' must be non-negative");
+                goto fail;
+            }
+
+            out->trimFactor = OPT_I32(val);
         }
         END_IF_FIELD
     }
@@ -282,13 +307,25 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
     CHECK_HAS(indexMax)
     // Do not error if precision is not present. Precision optional and only
     // applies to double/decimal128.
+
+    if (!use_range_v2 && out->trimFactor.set) {
+        CLIENT_ERR_PREFIXED("'trimFactor' is not supported for QE range v1");
+        return false;
+    }
+
     return true;
 
 fail:
     return false;
 }
 
-bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+#undef ERROR_PREFIX
+#define ERROR_PREFIX "Error parsing FLE2RangeFindSpec"
+
+bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out,
+                                const bson_iter_t *in,
+                                bool use_range_v2,
+                                mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(in);
 
@@ -298,7 +335,7 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *
     *out = (mc_FLE2RangeFindSpec_t){{{{0}}}};
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR("invalid FLE2RangeFindSpec: must be an iterator to a document");
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -308,7 +345,7 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *
         BSON_ASSERT(field);
 
         IF_FIELD(edgesInfo) {
-            if (!mc_FLE2RangeFindSpecEdgesInfo_parse(&out->edgesInfo.value, &iter, status)) {
+            if (!mc_FLE2RangeFindSpecEdgesInfo_parse(&out->edgesInfo.value, &iter, use_range_v2, status)) {
                 goto fail;
             }
             out->edgesInfo.set = true;
@@ -317,7 +354,7 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *
 
         IF_FIELD(payloadId) {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpec: 'payloadId' must be an int32");
+                CLIENT_ERR_PREFIXED("'payloadId' must be an int32");
                 goto fail;
             }
             out->payloadId = bson_iter_int32(&iter);
@@ -326,15 +363,14 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *
 
         IF_FIELD(firstOperator) {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpec: 'firstOperator' must be an int32");
+                CLIENT_ERR_PREFIXED("'firstOperator' must be an int32");
                 goto fail;
             }
             const int32_t first_op = bson_iter_int32(&iter);
             if (first_op < FLE2RangeOperator_min_val || first_op > FLE2RangeOperator_max_val) {
-                CLIENT_ERR("invalid FLE2RangeFindSpec: 'firstOperator' must be "
-                           "between %d and %d",
-                           FLE2RangeOperator_min_val,
-                           FLE2RangeOperator_max_val);
+                CLIENT_ERR_PREFIXED("'firstOperator' must be between %d and %d",
+                                    FLE2RangeOperator_min_val,
+                                    FLE2RangeOperator_max_val);
                 goto fail;
             }
             out->firstOperator = (mc_FLE2RangeOperator_t)first_op;
@@ -343,15 +379,14 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *
 
         IF_FIELD(secondOperator) {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpec: 'secondOperator' must be an int32");
+                CLIENT_ERR_PREFIXED("'secondOperator' must be an int32");
                 goto fail;
             }
             const int32_t second_op = bson_iter_int32(&iter);
             if (second_op < FLE2RangeOperator_min_val || second_op > FLE2RangeOperator_max_val) {
-                CLIENT_ERR("invalid FLE2RangeFindSpec: 'secondOperator' must be "
-                           "between %d and %d",
-                           FLE2RangeOperator_min_val,
-                           FLE2RangeOperator_max_val);
+                CLIENT_ERR_PREFIXED("'secondOperator' must be between %d and %d",
+                                    FLE2RangeOperator_min_val,
+                                    FLE2RangeOperator_max_val);
                 goto fail;
             }
             out->secondOperator = (mc_FLE2RangeOperator_t)second_op;
@@ -369,17 +404,23 @@ fail:
     return false;
 }
 
-bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+#undef ERROR_PREFIX
+#define ERROR_PREFIX "Error parsing FLE2RangeInsertSpec"
+
+bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
+                                  const bson_iter_t *in,
+                                  bool use_range_v2,
+                                  mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(in);
 
     *out = (mc_FLE2RangeInsertSpec_t){{0}};
 
     bson_iter_t iter = *in;
-    bool has_v = false, has_min = false, has_max = false, has_precision = false;
+    bool has_v = false, has_min = false, has_max = false, has_precision = false, has_trimFactor = false;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR("invalid FLE2RangeInsertSpec: must be an iterator to a document");
+        CLIENT_ERR_PREFIXED("must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -405,17 +446,29 @@ bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out, const bson_iter
 
         IF_FIELD(precision) {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'precision' must "
-                           "be an int32");
+                CLIENT_ERR_PREFIXED("'precision' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR("invalid FLE2RangeFindSpecEdgesInfo: 'precision' must be"
-                           "non-negative");
+                CLIENT_ERR_PREFIXED("'precision' must be non-negative");
                 goto fail;
             }
-            out->precision = OPT_U32((uint32_t)val);
+            out->precision = OPT_I32(val);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(trimFactor) {
+            if (!BSON_ITER_HOLDS_INT32(&iter)) {
+                CLIENT_ERR_PREFIXED("'trimFactor' must be an int32");
+                goto fail;
+            }
+            int32_t val = bson_iter_int32(&iter);
+            if (val < 0) {
+                CLIENT_ERR_PREFIXED("'trimFactor' must be non-negative");
+                goto fail;
+            }
+            out->trimFactor = OPT_I32(val);
         }
         END_IF_FIELD
     }
@@ -425,8 +478,16 @@ bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out, const bson_iter
     CHECK_HAS(max)
     // Do not error if precision is not present. Precision optional and only
     // applies to double/decimal128.
+
+    if (!use_range_v2 && out->trimFactor.set) {
+        CLIENT_ERR_PREFIXED("'trimFactor' is not supported for QE range v1");
+        return false;
+    }
+
     return true;
 
 fail:
     return false;
 }
+
+#undef ERROR_PREFIX

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

@@ -25,7 +25,7 @@ typedef struct {
     _mongocrypt_buffer_t edcDerivedToken;            // d
     _mongocrypt_buffer_t escDerivedToken;            // s
     _mongocrypt_buffer_t serverDerivedFromDataToken; // l
-    int64_t maxContentionCounter;                    // cm
+    int64_t maxContentionFactor;                     // cm
 } mc_FLE2FindEqualityPayloadV2_t;
 
 void mc_FLE2FindEqualityPayloadV2_init(mc_FLE2FindEqualityPayloadV2_t *payload);

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

@@ -26,7 +26,7 @@ typedef struct {
     _mongocrypt_buffer_t escDerivedToken;       // s
     _mongocrypt_buffer_t eccDerivedToken;       // c
     _mongocrypt_buffer_t serverEncryptionToken; // e
-    int64_t maxContentionCounter;               // cm
+    int64_t maxContentionFactor;                // cm
 } mc_FLE2FindEqualityPayload_t;
 
 void mc_FLE2FindEqualityPayload_init(mc_FLE2FindEqualityPayload_t *payload);

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

@@ -99,7 +99,7 @@ bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
                 CLIENT_ERR("Field 'cm' expected to hold an int64");
                 goto fail;
             }
-            out->maxContentionCounter = bson_iter_int64(&iter);
+            out->maxContentionFactor = bson_iter_int64(&iter);
         }
         END_IF_FIELD
     }
@@ -126,7 +126,7 @@ bool mc_FLE2FindEqualityPayloadV2_serialize(const mc_FLE2FindEqualityPayloadV2_t
     APPEND_BINDATA("d", payload->edcDerivedToken);
     APPEND_BINDATA("s", payload->escDerivedToken);
     APPEND_BINDATA("l", payload->serverDerivedFromDataToken);
-    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionCounter)) {
+    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionFactor)) {
         return false;
     }
     return true;

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

@@ -101,7 +101,7 @@ bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out,
                 CLIENT_ERR("Field 'cm' expected to hold an int64");
                 goto fail;
             }
-            out->maxContentionCounter = bson_iter_int64(&iter);
+            out->maxContentionFactor = bson_iter_int64(&iter);
         }
         END_IF_FIELD
     }
@@ -130,7 +130,7 @@ bool mc_FLE2FindEqualityPayload_serialize(const mc_FLE2FindEqualityPayload_t *pa
     PAYLOAD_APPEND_BINDATA("s", payload->escDerivedToken);
     PAYLOAD_APPEND_BINDATA("c", payload->eccDerivedToken);
     PAYLOAD_APPEND_BINDATA("e", payload->serverEncryptionToken);
-    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionCounter)) {
+    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionFactor)) {
         return false;
     }
     return true;

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

@@ -23,13 +23,14 @@
 
 #include "mc-array-private.h"
 #include "mc-fle2-range-operator-private.h"
+#include "mc-optional-private.h"
 
 /** FLE2FindRangePayloadEdgesInfoV2 represents the token information for a range
  * find query. It is encoded inside an FLE2FindRangePayloadV2.
  */
 typedef struct {
     mc_array_t edgeFindTokenSetArray; // g
-    int64_t maxContentionCounter;     // cm
+    int64_t maxContentionFactor;      // cm
 } mc_FLE2FindRangePayloadEdgesInfoV2_t;
 
 /**
@@ -44,8 +45,17 @@ typedef struct {
  * } FLE2FindRangePayloadV2;
  *
  * bson is a BSON document of this form:
- * g: array<EdgeFindTokenSetV2> // Array of Edges
- * cm: <int64> // Queryable Encryption max counter
+ * payload: <document>
+ *  g: array<EdgeFindTokenSetV2> // Array of Edges
+ *  cm: <int64> // Queryable Encryption max counter
+ * payloadId: <int32> // Payload ID.
+ * firstOperator: <int32>
+ * secondOperator: <int32>
+ * sp: optional<int64> // Sparsity.
+ * pn: optional<int32> // Precision.
+ * tf: optional<int32> // Trim Factor.
+ * mn: optional<any> // Index Min.
+ * mx: optional<any> // Index Max.
  */
 typedef struct {
     struct {
@@ -61,12 +71,17 @@ typedef struct {
     // secondOperator represents the second query operator for which this payload
     // was generated. Only populated for two-sided ranges. It is 0 if unset.
     mc_FLE2RangeOperator_t secondOperator;
+    mc_optional_int64_t sparsity;   // sp
+    mc_optional_int32_t precision;  // pn
+    mc_optional_int32_t trimFactor; // tf
+    bson_value_t indexMin;          // mn
+    bson_value_t indexMax;          // mx
 } mc_FLE2FindRangePayloadV2_t;
 
 /**
  * EdgeFindTokenSetV2 is the following BSON document:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
  * l: <binary> // ServerDerivedFromDataToken
  *
  * Instances of mc_EdgeFindTokenSetV2_t are expected to be owned by
@@ -81,7 +96,7 @@ typedef struct {
 
 void mc_FLE2FindRangePayloadV2_init(mc_FLE2FindRangePayloadV2_t *payload);
 
-bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out);
+bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out, bool use_range_v2);
 
 void mc_FLE2FindRangePayloadV2_cleanup(mc_FLE2FindRangePayloadV2_t *payload);
 

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

@@ -32,7 +32,7 @@
 typedef struct {
     mc_array_t edgeFindTokenSetArray;           // g
     _mongocrypt_buffer_t serverEncryptionToken; // e
-    int64_t maxContentionCounter;               // cm
+    int64_t maxContentionFactor;                // cm
 } mc_FLE2FindRangePayloadEdgesInfo_t;
 
 /**
@@ -49,7 +49,7 @@ typedef struct {
  * bson is a BSON document of this form:
  * g: array<EdgeFindTokenSet> // Array of Edges
  * e: <binary> // ServerDataEncryptionLevel1Token
- * cm: <int64> // Queryable Encryption max counter
+ * cm: <int64> // Queryable Encryption max contentionFactor
  */
 typedef struct {
     struct {
@@ -69,9 +69,9 @@ typedef struct {
 
 /**
  * EdgeFindTokenSet is the following BSON document:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
- * c: <binary> // ECCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
+ * c: <binary> // ECCDerivedFromDataTokenAndContentionFactor
  *
  * Instances of mc_EdgeFindTokenSet_t are expected to be owned by
  * mc_FLE2FindRangePayload_t and are freed in

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

@@ -53,7 +53,7 @@ void mc_FLE2FindRangePayloadV2_cleanup(mc_FLE2FindRangePayloadV2_t *payload) {
         return false;                                                                                                  \
     }
 
-bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out) {
+bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out, bool use_range_v2) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(payload);
 
@@ -106,7 +106,7 @@ bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payl
         }
 
         // Append "payload.cm".
-        if (!BSON_APPEND_INT64(&payload_bson, "cm", payload->payload.value.maxContentionCounter)) {
+        if (!BSON_APPEND_INT64(&payload_bson, "cm", payload->payload.value.maxContentionFactor)) {
             return false;
         }
 
@@ -131,6 +131,42 @@ bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payl
         return false;
     }
 
+    if (use_range_v2) {
+        // Encode parameters that were used to generate the mincover.
+        // The crypto parameters are all optionally set. Find payloads may come in pairs (a lower and upper bound).
+        // One of the pair includes the mincover. The other payload was not generated with crypto parameters.
+
+        if (payload->sparsity.set) {
+            if (!BSON_APPEND_INT64(out, "sp", payload->sparsity.value)) {
+                return false;
+            }
+        }
+
+        if (payload->precision.set) {
+            if (!BSON_APPEND_INT32(out, "pn", payload->precision.value)) {
+                return false;
+            }
+        }
+
+        if (payload->trimFactor.set) {
+            if (!BSON_APPEND_INT32(out, "tf", payload->trimFactor.value)) {
+                return false;
+            }
+        }
+
+        if (payload->indexMin.value_type != BSON_TYPE_EOD) {
+            if (!BSON_APPEND_VALUE(out, "mn", &payload->indexMin)) {
+                return false;
+            }
+        }
+
+        if (payload->indexMax.value_type != BSON_TYPE_EOD) {
+            if (!BSON_APPEND_VALUE(out, "mx", &payload->indexMax)) {
+                return false;
+            }
+        }
+    }
+
     return true;
 }
 

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

@@ -108,7 +108,7 @@ bool mc_FLE2FindRangePayload_serialize(const mc_FLE2FindRangePayload_t *payload,
 
         // Append "payload.e" and "payload.cm".
         APPEND_BINDATA(&payload_bson, "e", payload->payload.value.serverEncryptionToken);
-        if (!BSON_APPEND_INT64(&payload_bson, "cm", payload->payload.value.maxContentionCounter)) {
+        if (!BSON_APPEND_INT64(&payload_bson, "cm", payload->payload.value.maxContentionFactor)) {
             return false;
         }