libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-tokens-private.h

@@ -73,6 +73,47 @@
  * Server-side:
  *      AnchorPaddingTokenKey    = HMAC(AnchorPaddingTokenRoot, 1)
  *      AnchorPaddingTokenValue  = HMAC(AnchorPaddingTokenRoot, 2)
+ * ----------------------------------------------------------------------------
+ * Added in Text Search:
+ *
+ * EDCTextExactToken = HMAC(EDCToken, 1)
+ * EDCTextSubstringToken = HMAC(EDCToken, 2)
+ * EDCTextSuffixToken = HMAC(EDCToken, 3)
+ * EDCTextPrefixToken = HMAC(EDCToken, 4)
+ *
+ * ESCTextExactToken = HMAC(ESCToken, 1)
+ * ESCTextSubstringToken = HMAC(ESCToken, 2)
+ * ESCTextSuffixToken = HMAC(ESCToken, 3)
+ * ESCTextPrefixToken = HMAC(ESCToken, 4)
+ *
+ * ServerTextExactToken = HMAC(ServerTokenDerivationLevel1Token, 1)
+ * ServerTextSubstringToken = HMAC(ServerTokenDerivationLevel1Token, 2)
+ * ServerTextSuffixToken = HMAC(ServerTokenDerivationLevel1Token, 3)
+ * ServerTextPrefixToken = HMAC(ServerTokenDerivationLevel1Token, 4)
+ *
+ * EDCTextExactDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(EDCTextExactToken, v), u)
+ * EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(EDCTextSubstringToken, v), u)
+ * EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(EDCTextSuffixToken, v), u)
+ * EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(EDCTextPrefixToken, v), u)
+ *
+ * ESCTextExactDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(ESCTextExactToken, v), u)
+ * ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(ESCTextSubstringToken, v), u)
+ * ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(ESCTextSuffixToken, v), u)
+ * ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken =
+ *     HMAC(HMAC(ESCTextPrefixToken, v), u)
+ *
+ * ServerTextExactDerivedFromDataToken = HMAC(ServerTextExactToken, v)
+ * ServerTextSubstringDerivedFromDataToken = HMAC(ServerTextSubstringToken, v)
+ * ServerTextSuffixDerivedFromDataToken = HMAC(ServerTextSuffixToken, v)
+ * ServerTextPrefixDerivedFromDataToken = HMAC(ServerTextPrefixToken, v)
+ *
  * ======================== End: FLE 2 Token Reference ========================
  */
 
@@ -89,8 +130,10 @@
     extern const _mongocrypt_buffer_t *BSON_CONCAT(Prefix, _get)(const T *t);                                          \
     /* Destructor */                                                                                                   \
     extern void BSON_CONCAT(Prefix, _destroy)(T * t);                                                                  \
-    /* Constructor for server to create tokens from raw buffer */                                                      \
-    extern T *BSON_CONCAT(Prefix, _new_from_buffer)(_mongocrypt_buffer_t * buf);                                       \
+    /* Constructor for server to shallow copy tokens from raw buffer */                                                \
+    extern T *BSON_CONCAT(Prefix, _new_from_buffer)(const _mongocrypt_buffer_t *buf);                                  \
+    /* Constructor for server to deep copy tokens from raw buffer */                                                   \
+    extern T *BSON_CONCAT(Prefix, _new_from_buffer_copy)(const _mongocrypt_buffer_t *buf);                             \
     /* Constructor. Parameter list given as variadic args */                                                           \
     extern T *BSON_CONCAT(Prefix, _new)(_mongocrypt_crypto_t * crypto, __VA_ARGS__, mongocrypt_status_t * status)
 
@@ -133,6 +176,73 @@ DECL_TOKEN_TYPE(mc_ServerCountAndContentionFactorEncryptionToken,
 DECL_TOKEN_TYPE(mc_ServerZerosEncryptionToken, const mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken);
 
 DECL_TOKEN_TYPE(mc_AnchorPaddingTokenRoot, const mc_ESCToken_t *ESCToken);
+DECL_TOKEN_TYPE(mc_AnchorPaddingKeyToken, const mc_AnchorPaddingTokenRoot_t *anchorPaddingToken);
+DECL_TOKEN_TYPE(mc_AnchorPaddingValueToken, const mc_AnchorPaddingTokenRoot_t *anchorPaddingToken);
+
+DECL_TOKEN_TYPE(mc_EDCTextExactToken, const mc_EDCToken_t *edcToken);
+DECL_TOKEN_TYPE(mc_EDCTextSubstringToken, const mc_EDCToken_t *edcToken);
+DECL_TOKEN_TYPE(mc_EDCTextSuffixToken, const mc_EDCToken_t *edcToken);
+DECL_TOKEN_TYPE(mc_EDCTextPrefixToken, const mc_EDCToken_t *edcToken);
+
+DECL_TOKEN_TYPE(mc_ESCTextExactToken, const mc_ESCToken_t *escToken);
+DECL_TOKEN_TYPE(mc_ESCTextSubstringToken, const mc_ESCToken_t *escToken);
+DECL_TOKEN_TYPE(mc_ESCTextSuffixToken, const mc_ESCToken_t *escToken);
+DECL_TOKEN_TYPE(mc_ESCTextPrefixToken, const mc_ESCToken_t *escToken);
+
+DECL_TOKEN_TYPE(mc_ServerTextExactToken, const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token);
+DECL_TOKEN_TYPE(mc_ServerTextSubstringToken,
+                const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token);
+DECL_TOKEN_TYPE(mc_ServerTextSuffixToken,
+                const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token);
+DECL_TOKEN_TYPE(mc_ServerTextPrefixToken,
+                const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token);
+
+DECL_TOKEN_TYPE(mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken,
+                const mc_EDCTextExactToken_t *edcTextExactToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+                const mc_EDCTextSubstringToken_t *edcTextSubstringToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+                const mc_EDCTextSuffixToken_t *edcTextSuffixToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+                const mc_EDCTextPrefixToken_t *edcTextPrefixToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+
+DECL_TOKEN_TYPE(mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken,
+                const mc_ESCTextExactToken_t *escTextExactToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+                const mc_ESCTextSubstringToken_t *escTextSubstringToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+                const mc_ESCTextSuffixToken_t *escTextSuffixToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+DECL_TOKEN_TYPE(mc_ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+                const mc_ESCTextPrefixToken_t *escTextPrefixToken,
+                const _mongocrypt_buffer_t *v,
+                uint64_t u);
+
+DECL_TOKEN_TYPE(mc_ServerTextExactDerivedFromDataToken,
+                const mc_ServerTextExactToken_t *serverTextExactToken,
+                const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE(mc_ServerTextSubstringDerivedFromDataToken,
+                const mc_ServerTextSubstringToken_t *serverTextSubstringToken,
+                const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE(mc_ServerTextSuffixDerivedFromDataToken,
+                const mc_ServerTextSuffixToken_t *serverTextSuffixToken,
+                const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE(mc_ServerTextPrefixDerivedFromDataToken,
+                const mc_ServerTextPrefixToken_t *serverTextPrefixToken,
+                const _mongocrypt_buffer_t *v);
 
 #undef DECL_TOKEN_TYPE
 #undef DECL_TOKEN_TYPE_1

data/ext/libmongocrypt/libmongocrypt/src/mc-tokens.c

@@ -38,13 +38,21 @@
         _mongocrypt_buffer_cleanup(&self->data);                                                                       \
         bson_free(self);                                                                                               \
     }                                                                                                                  \
-    /* Constructor. From raw buffer */                                                                                 \
-    T *BSON_CONCAT(Prefix, _new_from_buffer)(_mongocrypt_buffer_t * buf) {                                             \
+    /* Constructor. Shallow copy from raw buffer */                                                                    \
+    T *BSON_CONCAT(Prefix, _new_from_buffer)(const _mongocrypt_buffer_t *buf) {                                        \
         BSON_ASSERT(buf->len == MONGOCRYPT_HMAC_SHA256_LEN);                                                           \
         T *t = bson_malloc(sizeof(T));                                                                                 \
         _mongocrypt_buffer_set_to(buf, &t->data);                                                                      \
         return t;                                                                                                      \
     }                                                                                                                  \
+    /* Constructor. Deep copy from raw buffer */                                                                       \
+    T *BSON_CONCAT(Prefix, _new_from_buffer_copy)(const _mongocrypt_buffer_t *buf) {                                   \
+        BSON_ASSERT(buf->len == MONGOCRYPT_HMAC_SHA256_LEN);                                                           \
+        T *t = bson_malloc(sizeof(T));                                                                                 \
+        _mongocrypt_buffer_init(&t->data);                                                                             \
+        _mongocrypt_buffer_copy_to(buf, &t->data);                                                                     \
+        return t;                                                                                                      \
+    }                                                                                                                  \
     /* Constructor. Parameter list given as variadic args. */                                                          \
     T *BSON_CONCAT(Prefix, _new)(_mongocrypt_crypto_t * crypto, __VA_ARGS__, mongocrypt_status_t * status)
 
@@ -177,3 +185,159 @@ DEF_TOKEN_TYPE(mc_AnchorPaddingTokenRoot, const mc_ESCToken_t *ESCToken) {
 }
 
 #undef ANCHOR_PADDING_TOKEN_D_LENGTH
+
+DEF_TOKEN_TYPE(mc_AnchorPaddingKeyToken, const mc_AnchorPaddingTokenRoot_t *anchorPaddingToken)
+IMPL_TOKEN_NEW_CONST(mc_AnchorPaddingKeyToken, mc_AnchorPaddingTokenRoot_get(anchorPaddingToken), 1)
+
+DEF_TOKEN_TYPE(mc_AnchorPaddingValueToken, const mc_AnchorPaddingTokenRoot_t *anchorPaddingToken)
+IMPL_TOKEN_NEW_CONST(mc_AnchorPaddingValueToken, mc_AnchorPaddingTokenRoot_get(anchorPaddingToken), 2)
+
+#define TEXT_EXACT_ID 1
+#define TEXT_SUBSTRING_ID 2
+#define TEXT_SUFFIX_ID 3
+#define TEXT_PREFIX_ID 4
+
+DEF_TOKEN_TYPE(mc_EDCTextExactToken, const mc_EDCToken_t *edcToken)
+IMPL_TOKEN_NEW_CONST(mc_EDCTextExactToken, mc_EDCToken_get(edcToken), TEXT_EXACT_ID)
+DEF_TOKEN_TYPE(mc_EDCTextSubstringToken, const mc_EDCToken_t *edcToken)
+IMPL_TOKEN_NEW_CONST(mc_EDCTextSubstringToken, mc_EDCToken_get(edcToken), TEXT_SUBSTRING_ID)
+DEF_TOKEN_TYPE(mc_EDCTextSuffixToken, const mc_EDCToken_t *edcToken)
+IMPL_TOKEN_NEW_CONST(mc_EDCTextSuffixToken, mc_EDCToken_get(edcToken), TEXT_SUFFIX_ID)
+DEF_TOKEN_TYPE(mc_EDCTextPrefixToken, const mc_EDCToken_t *edcToken)
+IMPL_TOKEN_NEW_CONST(mc_EDCTextPrefixToken, mc_EDCToken_get(edcToken), TEXT_PREFIX_ID)
+
+DEF_TOKEN_TYPE(mc_ESCTextExactToken, const mc_ESCToken_t *escToken)
+IMPL_TOKEN_NEW_CONST(mc_ESCTextExactToken, mc_ESCToken_get(escToken), TEXT_EXACT_ID)
+DEF_TOKEN_TYPE(mc_ESCTextSubstringToken, const mc_ESCToken_t *escToken)
+IMPL_TOKEN_NEW_CONST(mc_ESCTextSubstringToken, mc_ESCToken_get(escToken), TEXT_SUBSTRING_ID)
+DEF_TOKEN_TYPE(mc_ESCTextSuffixToken, const mc_ESCToken_t *escToken)
+IMPL_TOKEN_NEW_CONST(mc_ESCTextSuffixToken, mc_ESCToken_get(escToken), TEXT_SUFFIX_ID)
+DEF_TOKEN_TYPE(mc_ESCTextPrefixToken, const mc_ESCToken_t *escToken)
+IMPL_TOKEN_NEW_CONST(mc_ESCTextPrefixToken, mc_ESCToken_get(escToken), TEXT_PREFIX_ID)
+
+DEF_TOKEN_TYPE(mc_ServerTextExactToken, const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ServerTextExactToken,
+                     mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
+                     TEXT_EXACT_ID)
+DEF_TOKEN_TYPE(mc_ServerTextSubstringToken,
+               const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ServerTextSubstringToken,
+                     mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
+                     TEXT_SUBSTRING_ID)
+DEF_TOKEN_TYPE(mc_ServerTextSuffixToken, const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ServerTextSuffixToken,
+                     mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
+                     TEXT_SUFFIX_ID)
+DEF_TOKEN_TYPE(mc_ServerTextPrefixToken, const mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ServerTextPrefixToken,
+                     mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
+                     TEXT_PREFIX_ID)
+
+#define IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(Name, Key, BufferArg, UintArg)                                         \
+    {                                                                                                                  \
+        BSON_CONCAT(Name, _t) *t = bson_malloc(sizeof(BSON_CONCAT(Name, _t)));                                         \
+        _mongocrypt_buffer_t tmp;                                                                                      \
+        _mongocrypt_buffer_init(&tmp);                                                                                 \
+        _mongocrypt_buffer_resize(&tmp, MONGOCRYPT_HMAC_SHA256_LEN);                                                   \
+        _mongocrypt_buffer_init(&t->data);                                                                             \
+        _mongocrypt_buffer_resize(&t->data, MONGOCRYPT_HMAC_SHA256_LEN);                                               \
+        if (!_mongocrypt_hmac_sha_256(crypto, Key, BufferArg, &tmp, status)) {                                         \
+            BSON_CONCAT(Name, _destroy)(t);                                                                            \
+            _mongocrypt_buffer_cleanup(&tmp);                                                                          \
+            return NULL;                                                                                               \
+        }                                                                                                              \
+        _mongocrypt_buffer_t uint_arg;                                                                                 \
+        _mongocrypt_buffer_copy_from_uint64_le(&uint_arg, UintArg);                                                    \
+        if (!_mongocrypt_hmac_sha_256(crypto, &tmp, &uint_arg, &t->data, status)) {                                    \
+            BSON_CONCAT(Name, _destroy)(t);                                                                            \
+            _mongocrypt_buffer_cleanup(&tmp);                                                                          \
+            _mongocrypt_buffer_cleanup(&uint_arg);                                                                     \
+            return NULL;                                                                                               \
+        }                                                                                                              \
+        _mongocrypt_buffer_cleanup(&tmp);                                                                              \
+        _mongocrypt_buffer_cleanup(&uint_arg);                                                                         \
+        return t;                                                                                                      \
+    }
+
+DEF_TOKEN_TYPE(mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken,
+               const mc_EDCTextExactToken_t *edcTextExactToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_EDCTextExactToken_get(edcTextExactToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+               const mc_EDCTextSubstringToken_t *edcTextSubstringToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_EDCTextSubstringToken_get(edcTextSubstringToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+               const mc_EDCTextSuffixToken_t *edcTextSuffixToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_EDCTextSuffixToken_get(edcTextSuffixToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+               const mc_EDCTextPrefixToken_t *edcTextPrefixToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_EDCTextPrefixToken_get(edcTextPrefixToken),
+                                        v,
+                                        u)
+
+DEF_TOKEN_TYPE(mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken,
+               const mc_ESCTextExactToken_t *escTextExactToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_ESCTextExactToken_get(escTextExactToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+               const mc_ESCTextSubstringToken_t *escTextSubstringToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_ESCTextSubstringToken_get(escTextSubstringToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+               const mc_ESCTextSuffixToken_t *escTextSuffixToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_ESCTextSuffixToken_get(escTextSuffixToken),
+                                        v,
+                                        u)
+DEF_TOKEN_TYPE(mc_ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+               const mc_ESCTextPrefixToken_t *escTextPrefixToken,
+               const _mongocrypt_buffer_t *v,
+               uint64_t u)
+IMPL_TOKEN_NEW_FROM_DATA_AND_CONTENTION(mc_ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken,
+                                        mc_ESCTextPrefixToken_get(escTextPrefixToken),
+                                        v,
+                                        u)
+
+DEF_TOKEN_TYPE(mc_ServerTextExactDerivedFromDataToken,
+               const mc_ServerTextExactToken_t *serverTextExactToken,
+               const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ServerTextExactDerivedFromDataToken, mc_ServerTextExactToken_get(serverTextExactToken), v)
+DEF_TOKEN_TYPE(mc_ServerTextSubstringDerivedFromDataToken,
+               const mc_ServerTextSubstringToken_t *serverTextSubstringToken,
+               const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ServerTextSubstringDerivedFromDataToken, mc_ServerTextSubstringToken_get(serverTextSubstringToken), v)
+DEF_TOKEN_TYPE(mc_ServerTextSuffixDerivedFromDataToken,
+               const mc_ServerTextSuffixToken_t *serverTextSuffixToken,
+               const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ServerTextSuffixDerivedFromDataToken, mc_ServerTextSuffixToken_get(serverTextSuffixToken), v)
+DEF_TOKEN_TYPE(mc_ServerTextPrefixDerivedFromDataToken,
+               const mc_ServerTextPrefixToken_t *serverTextPrefixToken,
+               const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ServerTextPrefixDerivedFromDataToken, mc_ServerTextPrefixToken_get(serverTextPrefixToken), v)

data/ext/libmongocrypt/libmongocrypt/src/mlib/windows-lean.h

@@ -12,6 +12,8 @@
 #endif
 
 #pragma push_macro("WIN32_LEAN_AND_MEAN")
+// Disable macro redefinition warning
+#undef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
 #pragma pop_macro("WIN32_LEAN_AND_MEAN")

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-buffer-private.h

@@ -142,6 +142,11 @@ bool _mongocrypt_buffer_steal_from_string(_mongocrypt_buffer_t *buf, char *str)
  * - Caller must call _mongocrypt_buffer_cleanup. */
 bool _mongocrypt_buffer_from_string(_mongocrypt_buffer_t *buf, const char *str) MONGOCRYPT_WARN_UNUSED_RESULT;
 
+/* _mongocrypt_buffer_from_ initializes @buf from @data with length @len.
+ * @buf retains a pointer to @data.
+ * @data must outlive @buf. */
+void _mongocrypt_buffer_from_data(_mongocrypt_buffer_t *buf, const uint8_t *data, uint32_t len);
+
 /* _mongocrypt_buffer_copy_from_uint64_le initializes @buf from the
  * little-endian byte representation of @value. Caller must call
  * _mongocrypt_buffer_cleanup.
@@ -157,4 +162,10 @@ bool _mongocrypt_buffer_from_subrange(_mongocrypt_buffer_t *out,
                                       uint32_t offset,
                                       uint32_t len) MONGOCRYPT_WARN_UNUSED_RESULT;
 
+/* _mongocrypt_buffer_copy_from_string_as_bson_value initializes @out, wraps the provided string
+ * into a BSON value, and copies the BSON value to @out. No BSON validation is performed on @str.
+ * Caller must call _mongocrypt_buffer_cleanup.
+ */
+void _mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_buffer_t *out, const char *str, int len);
+
 #endif /* MONGOCRYPT_BUFFER_H */

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

@@ -317,7 +317,10 @@ fail:
     return ret;
 }
 
-void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *iter) {
+static void _mongocrypt_buffer_copy_as_bson_value(_mongocrypt_buffer_t *plaintext,
+                                                  bool (*append_func)(bson_t *bson, const void *data, int len),
+                                                  const void *data,
+                                                  int len) {
     bson_t wrapper = BSON_INITIALIZER;
     int32_t offset = INT32_LEN      /* skips document size */
                    + TYPE_LEN       /* element type */
@@ -326,13 +329,14 @@ void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *
     uint8_t *wrapper_data;
 
     BSON_ASSERT_PARAM(plaintext);
-    BSON_ASSERT_PARAM(iter);
+    BSON_ASSERT_PARAM(append_func);
 
     /* It is not straightforward to transform a bson_value_t to a string of
      * bytes. As a workaround, we wrap the value in a bson document with an empty
      * key, then use the raw buffer from inside the new bson_t, skipping the
      * length and type header information and the key name. */
-    bson_append_iter(&wrapper, "", 0, iter);
+    append_func(&wrapper, data, len);
+
     wrapper_data = ((uint8_t *)bson_get_data(&wrapper));
     BSON_ASSERT(wrapper.len >= (uint32_t)offset + NULL_BYTE_LEN);
     plaintext->len = wrapper.len - (uint32_t)offset - NULL_BYTE_LEN; /* the final null byte */
@@ -345,6 +349,25 @@ void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *
     bson_destroy(&wrapper);
 }
 
+static bool _append_iter(bson_t *bson, const void *iter, int len) {
+    return bson_append_iter(bson, "", 0, (const bson_iter_t *)iter);
+}
+
+static bool _append_utf8(bson_t *bson, const void *str, int len) {
+    return bson_append_utf8(bson, "", 0, (const char *)str, len);
+}
+
+void _mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_buffer_t *plaintext, const char *str, int len) {
+    BSON_ASSERT_PARAM(str);
+    BSON_ASSERT(len >= 0);
+    _mongocrypt_buffer_copy_as_bson_value(plaintext, _append_utf8, str, len);
+}
+
+void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(iter);
+    _mongocrypt_buffer_copy_as_bson_value(plaintext, _append_iter, iter, 0);
+}
+
 bool _mongocrypt_buffer_from_uuid_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
     const uint8_t *data;
     bson_subtype_t subtype;
@@ -540,6 +563,16 @@ bool _mongocrypt_buffer_from_string(_mongocrypt_buffer_t *buf, const char *str)
     return true;
 }
 
+void _mongocrypt_buffer_from_data(_mongocrypt_buffer_t *buf, const uint8_t *data, uint32_t len) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(data);
+
+    _mongocrypt_buffer_init(buf);
+    buf->data = (uint8_t *)data;
+    buf->len = len;
+    buf->owned = false;
+}
+
 void _mongocrypt_buffer_copy_from_uint64_le(_mongocrypt_buffer_t *buf, uint64_t value) {
     uint64_t value_le = MONGOCRYPT_UINT64_TO_LE(value);
 

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-collinfo.c

@@ -61,5 +61,5 @@ void _mongocrypt_cache_collinfo_init(_mongocrypt_cache_t *cache) {
     cache->destroy_value = _destroy_value;
     _mongocrypt_mutex_init(&cache->mutex);
     cache->pair = NULL;
-    cache->expiration = CACHE_EXPIRATION_MS;
+    cache->expiration = CACHE_EXPIRATION_MS_DEFAULT;
 }

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-key.c

@@ -129,7 +129,7 @@ void _mongocrypt_cache_key_init(_mongocrypt_cache_t *cache) {
     cache->dump_attr = _dump_attr;
     _mongocrypt_mutex_init(&cache->mutex);
     cache->pair = NULL;
-    cache->expiration = CACHE_EXPIRATION_MS;
+    cache->expiration = CACHE_EXPIRATION_MS_DEFAULT;
 }
 
 /* Since key cache may be looked up by either _id or keyAltName,

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-private.h

@@ -20,7 +20,7 @@
 #include "mongocrypt-mutex-private.h"
 #include "mongocrypt-status-private.h"
 
-#define CACHE_EXPIRATION_MS 60000
+#define CACHE_EXPIRATION_MS_DEFAULT 60000
 
 /* A generic simple cache.
  * To avoid overusing the names "key" or "id", the cache contains
@@ -74,4 +74,4 @@ void _mongocrypt_cache_set_expiration(_mongocrypt_cache_t *cache, uint64_t milli
 
 uint32_t _mongocrypt_cache_num_entries(_mongocrypt_cache_t *cache);
 
-#endif /* MONGOCRYPT_CACHE_PRIVATE */
+#endif /* MONGOCRYPT_CACHE_PRIVATE */

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

@@ -28,7 +28,7 @@ static bool _pair_expired(_mongocrypt_cache_t *cache, _mongocrypt_cache_pair_t *
     current = bson_get_monotonic_time() / 1000;
     BSON_ASSERT(current >= INT64_MIN + pair->last_updated);
     BSON_ASSERT(cache->expiration <= INT64_MAX);
-    return (current - pair->last_updated) > (int64_t)cache->expiration;
+    return cache->expiration > 0 && (current - pair->last_updated) > (int64_t)cache->expiration;
 }
 
 /* Return the pair after the one being destroyed. */

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

@@ -92,7 +92,7 @@ bool _mongocrypt_ciphertext_parse_unowned(_mongocrypt_buffer_t *in,
     ciphertext->original_bson_type = in->data[offset];
     offset += 1;
 
-    memset(&ciphertext->data, 0, sizeof(ciphertext->data));
+    _mongocrypt_buffer_init(&ciphertext->data);
     ciphertext->data.data = in->data + offset;
     ciphertext->data.len = in->len - offset;
 

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-ctx-datakey.c

@@ -40,9 +40,10 @@ static mongocrypt_kms_ctx_t *_next_kms_ctx(mongocrypt_ctx_t *ctx) {
     BSON_ASSERT_PARAM(ctx);
 
     dkctx = (_mongocrypt_ctx_datakey_t *)ctx;
-    if (dkctx->kms_returned) {
+    if (!dkctx->kms.should_retry && dkctx->kms_returned) {
         return NULL;
     }
+    dkctx->kms.should_retry = false; // Reset retry state.
     dkctx->kms_returned = true;
     return &dkctx->kms;
 }

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-ctx-decrypt.c

@@ -381,7 +381,8 @@ static bool _replace_ciphertext_with_plaintext(void *ctx,
     BSON_ASSERT(in->data);
 
     switch (in->data[0]) {
-    // FLE2v2
+    // FLE2v2 / Text Search
+    case MC_SUBTYPE_FLE2IndexedTextEncryptedValue:
     case MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2:
     case MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2:
         return _replace_FLE2IndexedEncryptedValueV2_with_plaintext(ctx, in, out, status);
@@ -501,7 +502,8 @@ static bool _collect_K_KeyID_from_FLE2IndexedEncryptedValueV2(void *ctx,
     bool ret = false;
 
     BSON_ASSERT((in->data[0] == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2)
-                || (in->data[0] == MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2));
+                || (in->data[0] == MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2)
+                || (in->data[0] == MC_SUBTYPE_FLE2IndexedTextEncryptedValue));
 
     mc_FLE2IndexedEncryptedValueV2_t *iev = mc_FLE2IndexedEncryptedValueV2_new();
     _mongocrypt_buffer_t S_Key = {0};
@@ -573,7 +575,8 @@ static bool _collect_K_KeyIDs(void *ctx, _mongocrypt_buffer_t *in, mongocrypt_st
     BSON_ASSERT(in->data);
 
     switch (in->data[0]) {
-    // FLE2v2
+    // FLE2v2 / Text Search
+    case MC_SUBTYPE_FLE2IndexedTextEncryptedValue:
     case MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2:
     case MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2:
         return _collect_K_KeyID_from_FLE2IndexedEncryptedValueV2(ctx, in, status);
@@ -727,7 +730,8 @@ static bool _collect_key_from_ciphertext(void *ctx, _mongocrypt_buffer_t *in, mo
     BSON_ASSERT(in->data);
 
     switch (in->data[0]) {
-    // FLE2v2
+    // FLE2v2 / Text Search
+    case MC_SUBTYPE_FLE2IndexedTextEncryptedValue:
     case MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2:
     case MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2:
         return _collect_S_KeyID_from_FLE2IndexedEncryptedValueV2(ctx, in, status);