libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

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

@@ -17,6 +17,7 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-find-equality-payload-private-v2.h"
+#include "mc-parse-utils-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt.h"
 
@@ -46,21 +47,7 @@ void mc_FLE2FindEqualityPayloadV2_cleanup(mc_FLE2FindEqualityPayloadV2_t *payloa
 
 #define PARSE_BINARY(Name, Dest)                                                                                       \
     IF_FIELD(Name) {                                                                                                   \
-        bson_subtype_t subtype;                                                                                        \
-        uint32_t len;                                                                                                  \
-        const uint8_t *data;                                                                                           \
-        if (bson_iter_type(&iter) != BSON_TYPE_BINARY) {                                                               \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata, got: %d", bson_iter_type(&iter));                    \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        bson_iter_binary(&iter, &subtype, &len, &data);                                                                \
-        if (subtype != BSON_SUBTYPE_BINARY) {                                                                          \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", BSON_SUBTYPE_BINARY, subtype);  \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        if (!_mongocrypt_buffer_copy_from_binary_iter(&out->Dest, &iter)) {                                            \
-            CLIENT_ERR("Unable to create mongocrypt buffer for BSON binary "                                           \
-                       "field in '" #Name "'");                                                                        \
+        if (!parse_bindata(BSON_SUBTYPE_BINARY, &iter, &out->Dest, status)) {                                          \
             goto fail;                                                                                                 \
         }                                                                                                              \
     }                                                                                                                  \
@@ -70,7 +57,8 @@ void mc_FLE2FindEqualityPayloadV2_cleanup(mc_FLE2FindEqualityPayloadV2_t *payloa
     if (!has_##Name) {                                                                                                 \
         CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
                                         const bson_t *in,
@@ -111,14 +99,14 @@ bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
 
     return true;
 fail:
-    mc_FLE2FindEqualityPayloadV2_cleanup(out);
     return false;
 }
 
 #define APPEND_BINDATA(name, value)                                                                                    \
     if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2FindEqualityPayloadV2_serialize(const mc_FLE2FindEqualityPayloadV2_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(payload);

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

@@ -17,6 +17,7 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-find-equality-payload-private.h"
+#include "mc-parse-utils-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt.h"
 
@@ -47,21 +48,7 @@ void mc_FLE2FindEqualityPayload_cleanup(mc_FLE2FindEqualityPayload_t *payload) {
 
 #define PARSE_BINARY(Name, Dest)                                                                                       \
     IF_FIELD(Name) {                                                                                                   \
-        bson_subtype_t subtype;                                                                                        \
-        uint32_t len;                                                                                                  \
-        const uint8_t *data;                                                                                           \
-        if (bson_iter_type(&iter) != BSON_TYPE_BINARY) {                                                               \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata, got: %d", bson_iter_type(&iter));                    \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        bson_iter_binary(&iter, &subtype, &len, &data);                                                                \
-        if (subtype != BSON_SUBTYPE_BINARY) {                                                                          \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", BSON_SUBTYPE_BINARY, subtype);  \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        if (!_mongocrypt_buffer_copy_from_binary_iter(&out->Dest, &iter)) {                                            \
-            CLIENT_ERR("Unable to create mongocrypt buffer for BSON binary "                                           \
-                       "field in '" #Name "'");                                                                        \
+        if (!parse_bindata(BSON_SUBTYPE_BINARY, &iter, &out->Dest, status)) {                                          \
             goto fail;                                                                                                 \
         }                                                                                                              \
     }                                                                                                                  \
@@ -71,7 +58,8 @@ void mc_FLE2FindEqualityPayload_cleanup(mc_FLE2FindEqualityPayload_t *payload) {
     if (!has_##Name) {                                                                                                 \
         CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out,
                                       const bson_t *in,
@@ -114,14 +102,14 @@ bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out,
 
     return true;
 fail:
-    mc_FLE2FindEqualityPayload_cleanup(out);
     return false;
 }
 
 #define PAYLOAD_APPEND_BINDATA(name, value)                                                                            \
     if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2FindEqualityPayload_serialize(const mc_FLE2FindEqualityPayload_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(payload);

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

@@ -101,7 +101,7 @@ typedef struct {
 
 void mc_FLE2FindRangePayloadV2_init(mc_FLE2FindRangePayloadV2_t *payload);
 
-bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out, bool use_range_v2);
+bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out);
 
 void mc_FLE2FindRangePayloadV2_cleanup(mc_FLE2FindRangePayloadV2_t *payload);
 

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

@@ -51,9 +51,10 @@ void mc_FLE2FindRangePayloadV2_cleanup(mc_FLE2FindRangePayloadV2_t *payload) {
 #define APPEND_BINDATA(out, name, value)                                                                               \
     if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
-bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out, bool use_range_v2) {
+bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(payload);
 
@@ -131,39 +132,37 @@ 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.
+    // 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->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->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->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->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;
-            }
+    if (payload->indexMax.value_type != BSON_TYPE_EOD) {
+        if (!BSON_APPEND_VALUE(out, "mx", &payload->indexMax)) {
+            return false;
         }
     }
 

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

@@ -52,7 +52,8 @@ void mc_FLE2FindRangePayload_cleanup(mc_FLE2FindRangePayload_t *payload) {
 #define APPEND_BINDATA(out, name, value)                                                                               \
     if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2FindRangePayload_serialize(const mc_FLE2FindRangePayload_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(out);

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2025-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.
+ */
+
+#ifndef MC_FLE2_FIND_TEXT_PAYLOAD_PRIVATE_H
+#define MC_FLE2_FIND_TEXT_PAYLOAD_PRIVATE_H
+
+#include "mc-fle2-encryption-placeholder-private.h"
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt.h"
+
+#define DEF_TEXT_SEARCH_FIND_TOKEN_SET(Type)                                                                           \
+    typedef struct {                                                                                                   \
+        _mongocrypt_buffer_t edcDerivedToken;                                                                          \
+        _mongocrypt_buffer_t escDerivedToken;                                                                          \
+        _mongocrypt_buffer_t serverDerivedFromDataToken;                                                               \
+    } mc_Text##Type##FindTokenSet_t;
+
+DEF_TEXT_SEARCH_FIND_TOKEN_SET(Exact);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET(Substring);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET(Suffix);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET(Prefix);
+
+typedef struct {
+    struct {
+        mc_TextExactFindTokenSet_t value;
+        bool set;
+    } exact; // e
+
+    struct {
+        mc_TextSubstringFindTokenSet_t value;
+        bool set;
+    } substring; // s
+
+    struct {
+        mc_TextSuffixFindTokenSet_t value;
+        bool set;
+    } suffix; // u
+
+    struct {
+        mc_TextPrefixFindTokenSet_t value;
+        bool set;
+    } prefix; // p
+} mc_TextSearchFindTokenSets_t;
+
+/**
+ * FLE2FindTextPayload represents an FLE2 payload of a substring/suffix/prefix indexed field to
+ * query. It is created client side.
+ *
+ * FLE2FindTextPayload has the following data layout:
+ *
+ * struct {
+ *   uint8_t fle_blob_subtype = 18;
+ *   uint8_t bson[];
+ * } FLE2FindTextPayload;
+ *
+ * bson is a BSON document of this form:
+ * {
+ *   ts: {
+ *      e: optional<TextExactFindTokenSet>      // required tokens if doing full string match
+ *      s: optional<TextSubstringFindTokenSet>  // required tokens if doing substring match
+ *      u: optional<TextSuffixFindTokenSet>     // required tokens if doing suffix match
+ *      p: optional<TextPrefixFindTokenSet>     // required tokens if doing prefix match
+ *   }
+ *   cm: <int64>                                // Queryable Encryption max contentionFactor
+ *   cf: <bool>                                 // case folding parameter
+ *   df: <bool>                                 // diacritic folding parameter
+ *   ss: optional<FLE2SubstringInsertSpec>      // substring-indexing parameters (if applicable)
+ *   fs: optional<FLE2SuffixInsertSpec>         // suffix-indexing parameters (if applicable)
+ *   ps: optional<FLE2PrefixInsertSpec>         // prefix-indexing parameters (if applicable)
+ * }
+ * where for each of T in [Exact, Substring, Suffix, Prefix], Text<T>FindTokenSet is a document of form:
+ * {
+ *    d: <binary>                               // EDCText<T>DerivedFromDataToken
+ *    s: <binary>                               // ESCText<T>DerivedFromDataToken
+ *    l: <binary>                               // ServerText<T>DerivedFromDataToken
+ * }
+ */
+typedef struct {
+    mc_TextSearchFindTokenSets_t tokenSets; // ts
+    int64_t maxContentionFactor;            // cm
+    bool caseFold;                          // cf
+    bool diacriticFold;                     // df
+
+    struct {
+        mc_FLE2SubstringInsertSpec_t value;
+        bool set;
+    } substringSpec; // ss
+
+    struct {
+        mc_FLE2SuffixInsertSpec_t value;
+        bool set;
+    } suffixSpec; // fs
+
+    struct {
+        mc_FLE2PrefixInsertSpec_t value;
+        bool set;
+    } prefixSpec; // ps
+} mc_FLE2FindTextPayload_t;
+
+void mc_FLE2FindTextPayload_init(mc_FLE2FindTextPayload_t *payload);
+
+bool mc_FLE2FindTextPayload_parse(mc_FLE2FindTextPayload_t *out, const bson_t *in, mongocrypt_status_t *status);
+
+bool mc_FLE2FindTextPayload_serialize(const mc_FLE2FindTextPayload_t *payload, bson_t *out);
+
+void mc_FLE2FindTextPayload_cleanup(mc_FLE2FindTextPayload_t *payload);
+
+#endif /* MC_FLE2_FIND_TEXT_PAYLOAD_PRIVATE_H */