libmongocrypt-helper 1.12.0.0.1001 → 1.13.2.0.1001

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

@@ -22,7 +22,7 @@
     F(value)                                                                                                           \
     F(collectionsLevel1Token)                                                                                          \
     F(serverDataEncryptionLevel1Token)                                                                                 \
-    F(serverTokenDerivationLevel1Token)                                                                                \
+    F(ServerTokenDerivationLevel1Token)                                                                                \
     F(EDCToken)                                                                                                        \
     F(ESCToken)                                                                                                        \
     F(ECCToken)                                                                                                        \
@@ -39,7 +39,33 @@
     F(ESCTwiceDerivedValueToken)                                                                                       \
     F(serverCountAndContentionFactorEncryptionToken)                                                                   \
     F(serverZerosEncryptionToken)                                                                                      \
-    F(AnchorPaddingTokenRoot)
+    F(AnchorPaddingTokenRoot)                                                                                          \
+    F(AnchorPaddingKeyToken)                                                                                           \
+    F(AnchorPaddingValueToken)                                                                                         \
+    F(EDCTextExactToken)                                                                                               \
+    F(EDCTextSubstringToken)                                                                                           \
+    F(EDCTextSuffixToken)                                                                                              \
+    F(EDCTextPrefixToken)                                                                                              \
+    F(ESCTextExactToken)                                                                                               \
+    F(ESCTextSubstringToken)                                                                                           \
+    F(ESCTextSuffixToken)                                                                                              \
+    F(ESCTextPrefixToken)                                                                                              \
+    F(ServerTextExactToken)                                                                                            \
+    F(ServerTextSubstringToken)                                                                                        \
+    F(ServerTextSuffixToken)                                                                                           \
+    F(ServerTextPrefixToken)                                                                                           \
+    F(EDCTextExactDerivedFromDataTokenAndContentionFactorToken)                                                        \
+    F(EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken)                                                    \
+    F(EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ESCTextExactDerivedFromDataTokenAndContentionFactorToken)                                                        \
+    F(ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken)                                                    \
+    F(ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ServerTextExactDerivedFromDataToken)                                                                             \
+    F(ServerTextSubstringDerivedFromDataToken)                                                                         \
+    F(ServerTextSuffixDerivedFromDataToken)                                                                            \
+    F(ServerTextPrefixDerivedFromDataToken)
 
 typedef struct {
 #define DECLARE_FIELD(f) _mongocrypt_buffer_t f;
@@ -55,7 +81,7 @@ static void _mc_token_test_cleanup(_mc_token_test *test) {
 }
 
 static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
-    printf("Loading test from %s...\n", path);
+    TEST_PRINTF("Loading test from %s...\n", path);
 
     mongocrypt_binary_t *test_bin = TEST_FILE(path);
     if (!test_bin) {
@@ -121,11 +147,11 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
                   test.serverDataEncryptionLevel1Token);
 
     // ServerTokenDerivationLevel1Token
-    mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token =
+    mc_ServerTokenDerivationLevel1Token_t *ServerTokenDerivationLevel1Token =
         mc_ServerTokenDerivationLevel1Token_new(crypt->crypto, &test.root, status);
-    ASSERT_OR_PRINT(serverTokenDerivationLevel1Token, status);
-    ASSERT_CMPBUF(*mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
-                  test.serverTokenDerivationLevel1Token);
+    ASSERT_OR_PRINT(ServerTokenDerivationLevel1Token, status);
+    ASSERT_CMPBUF(*mc_ServerTokenDerivationLevel1Token_get(ServerTokenDerivationLevel1Token),
+                  test.ServerTokenDerivationLevel1Token);
 
 // (EDC|ESC|ECC|ECOC)Token
 #define TEST_COLL_TOKEN(Name)                                                                                          \
@@ -138,32 +164,25 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     TEST_COLL_TOKEN(ECOC)
 #undef TEST_COLL_TOKEN
 
+#define TEST_HELPER(Base, BaseSuffix, TokenSuffix, ExtraArgsToNew)                                                     \
+    mc_##Base##TokenSuffix##_t *Base##TokenSuffix =                                                                    \
+        mc_##Base##TokenSuffix##_new(crypt->crypto, Base##BaseSuffix, ExtraArgsToNew status);                          \
+    ASSERT_OR_PRINT(Base##TokenSuffix, status);                                                                        \
+    ASSERT_CMPBUF(*mc_##Base##TokenSuffix##_get(Base##TokenSuffix), test.Base##TokenSuffix)
+
+#define COMMA ,
+
 // (EDC|ESC|ECC)DerivedFromDataToken(AndContentionFactor)?
 #define TEST_DERIVED(Name)                                                                                             \
-    mc_##Name##DerivedFromDataToken_t *Name##DerivedFromDataToken =                                                    \
-        mc_##Name##DerivedFromDataToken_new(crypt->crypto, Name##Token, &test.value, status);                          \
-    ASSERT_OR_PRINT(Name##DerivedFromDataToken, status);                                                               \
-    ASSERT_CMPBUF(*mc_##Name##DerivedFromDataToken_get(Name##DerivedFromDataToken), test.Name##DerivedFromDataToken);  \
-    mc_##Name##DerivedFromDataTokenAndContentionFactor_t *Name##DerivedFromDataTokenAndContentionFactor =              \
-        mc_##Name##DerivedFromDataTokenAndContentionFactor_new(crypt->crypto,                                          \
-                                                               Name##DerivedFromDataToken,                             \
-                                                               test.contentionFactor,                                  \
-                                                               status);                                                \
-    ASSERT_OR_PRINT(Name##DerivedFromDataTokenAndContentionFactor, status);                                            \
-    ASSERT_CMPBUF(                                                                                                     \
-        *mc_##Name##DerivedFromDataTokenAndContentionFactor_get(Name##DerivedFromDataTokenAndContentionFactor),        \
-        test.Name##DerivedFromDataTokenAndContentionFactor);
-    TEST_DERIVED(EDC)
-    TEST_DERIVED(ESC)
-    TEST_DERIVED(ECC)
-#undef TEST_DERIVED_FROM_DATA_TOKEN
+    TEST_HELPER(Name, Token, DerivedFromDataToken, &test.value COMMA);                                                 \
+    TEST_HELPER(Name, DerivedFromDataToken, DerivedFromDataTokenAndContentionFactor, test.contentionFactor COMMA)
+    TEST_DERIVED(EDC);
+    TEST_DERIVED(ESC);
+    TEST_DERIVED(ECC);
+#undef TEST_DERIVED
 
 // (EDC|ESC)TwiceDerivedToken(Tag|Value)?
-#define TEST_TWICE(Name, Suffix)                                                                                       \
-    mc_##Name##TwiceDerived##Suffix##_t *Name##TwiceDerived##Suffix =                                                  \
-        mc_##Name##TwiceDerived##Suffix##_new(crypt->crypto, Name##DerivedFromDataTokenAndContentionFactor, status);   \
-    ASSERT_OR_PRINT(Name##TwiceDerived##Suffix, status);                                                               \
-    ASSERT_CMPBUF(*mc_##Name##TwiceDerived##Suffix##_get(Name##TwiceDerived##Suffix), test.Name##TwiceDerived##Suffix);
+#define TEST_TWICE(Name, Suffix) TEST_HELPER(Name, DerivedFromDataTokenAndContentionFactor, TwiceDerived##Suffix, )
     TEST_TWICE(EDC, Token);
     TEST_TWICE(ESC, TagToken);
     TEST_TWICE(ESC, ValueToken);
@@ -171,7 +190,7 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
 
     // ServerDerivedFromDataToken
     mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken =
-        mc_ServerDerivedFromDataToken_new(crypt->crypto, serverTokenDerivationLevel1Token, &test.value, status);
+        mc_ServerDerivedFromDataToken_new(crypt->crypto, ServerTokenDerivationLevel1Token, &test.value, status);
     ASSERT_OR_PRINT(serverDerivedFromDataToken, status);
     ASSERT_CMPBUF(*mc_ServerDerivedFromDataToken_get(serverDerivedFromDataToken), test.serverDerivedFromDataToken);
 
@@ -193,7 +212,88 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     ASSERT_OR_PRINT(padding, status);
     ASSERT_CMPBUF(*mc_AnchorPaddingTokenRoot_get(padding), test.AnchorPaddingTokenRoot);
 
+    mc_AnchorPaddingKeyToken_t *paddingKey = mc_AnchorPaddingKeyToken_new(crypt->crypto, padding, status);
+    ASSERT_OR_PRINT(paddingKey, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingKeyToken_get(paddingKey), test.AnchorPaddingKeyToken);
+
+    mc_AnchorPaddingValueToken_t *paddingValue = mc_AnchorPaddingValueToken_new(crypt->crypto, padding, status);
+    ASSERT_OR_PRINT(paddingValue, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingValueToken_get(paddingValue), test.AnchorPaddingValueToken);
+
+#define TEST_TEXT(Name, Suffix) TEST_HELPER(Name, Token, Text##Suffix##Token, )
+#define TEST_TEXT_EXTRA(Name, Suffix, BaseSuffix) TEST_HELPER(Name, BaseSuffix##Token, Text##Suffix##Token, )
+#define TEST_TEXT_DERIVED_FROM_BOTH(Name)                                                                              \
+    TEST_HELPER(Name,                                                                                                  \
+                Token,                                                                                                 \
+                DerivedFromDataTokenAndContentionFactorToken,                                                          \
+                &test.value COMMA test.contentionFactor COMMA)
+#define TEST_TEXT_DERIVED_FROM_DATA(Name) TEST_HELPER(Name, Token, DerivedFromDataToken, &test.value COMMA)
+
+    TEST_TEXT(EDC, Exact);
+    TEST_TEXT(EDC, Substring);
+    TEST_TEXT(EDC, Suffix);
+    TEST_TEXT(EDC, Prefix);
+
+    TEST_TEXT(ESC, Exact);
+    TEST_TEXT(ESC, Substring);
+    TEST_TEXT(ESC, Suffix);
+    TEST_TEXT(ESC, Prefix);
+
+    TEST_TEXT_EXTRA(Server, Exact, TokenDerivationLevel1);
+    TEST_TEXT_EXTRA(Server, Substring, TokenDerivationLevel1);
+    TEST_TEXT_EXTRA(Server, Suffix, TokenDerivationLevel1);
+    TEST_TEXT_EXTRA(Server, Prefix, TokenDerivationLevel1);
+
+    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextExact);
+    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextSubstring);
+    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextPrefix);
+    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextSuffix);
+
+    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextExact);
+    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextSubstring);
+    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextPrefix);
+    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextSuffix);
+
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextExact);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextSubstring);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextPrefix);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextSuffix);
+
     // Done.
+    mc_ServerTextPrefixDerivedFromDataToken_destroy(ServerTextPrefixDerivedFromDataToken);
+    mc_ServerTextSuffixDerivedFromDataToken_destroy(ServerTextSuffixDerivedFromDataToken);
+    mc_ServerTextSubstringDerivedFromDataToken_destroy(ServerTextSubstringDerivedFromDataToken);
+    mc_ServerTextExactDerivedFromDataToken_destroy(ServerTextExactDerivedFromDataToken);
+    mc_ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_ServerTextPrefixToken_destroy(ServerTextPrefixToken);
+    mc_ServerTextSuffixToken_destroy(ServerTextSuffixToken);
+    mc_ServerTextSubstringToken_destroy(ServerTextSubstringToken);
+    mc_ServerTextExactToken_destroy(ServerTextExactToken);
+    mc_ESCTextPrefixToken_destroy(ESCTextPrefixToken);
+    mc_ESCTextSuffixToken_destroy(ESCTextSuffixToken);
+    mc_ESCTextSubstringToken_destroy(ESCTextSubstringToken);
+    mc_ESCTextExactToken_destroy(ESCTextExactToken);
+    mc_EDCTextPrefixToken_destroy(EDCTextPrefixToken);
+    mc_EDCTextSuffixToken_destroy(EDCTextSuffixToken);
+    mc_EDCTextSubstringToken_destroy(EDCTextSubstringToken);
+    mc_EDCTextExactToken_destroy(EDCTextExactToken);
+    mc_AnchorPaddingValueToken_destroy(paddingValue);
+    mc_AnchorPaddingKeyToken_destroy(paddingKey);
     mc_AnchorPaddingTokenRoot_destroy(padding);
     mc_ServerZerosEncryptionToken_destroy(serverZeros);
     mc_ServerCountAndContentionFactorEncryptionToken_destroy(serverCACFET);
@@ -211,14 +311,14 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     mc_ECCToken_destroy(ECCToken);
     mc_ESCToken_destroy(ESCToken);
     mc_EDCToken_destroy(EDCToken);
-    mc_ServerTokenDerivationLevel1Token_destroy(serverTokenDerivationLevel1Token);
+    mc_ServerTokenDerivationLevel1Token_destroy(ServerTokenDerivationLevel1Token);
     mc_ServerDataEncryptionLevel1Token_destroy(serverDataEncryptionLevel1Token);
     mc_CollectionsLevel1Token_destroy(collectionsLevel1Token);
     _mc_token_test_cleanup(&test);
     mongocrypt_destroy(crypt);
     mongocrypt_status_destroy(status);
 
-    printf("Finished tests in %s\n", path);
+    TEST_PRINTF("Finished tests in %s\n", path);
 }
 
 static void _test_mc_tokens(_mongocrypt_tester_t *tester) {
@@ -247,14 +347,16 @@ static void _test_mc_tokens_error(_mongocrypt_tester_t *tester) {
 }
 
 static void _test_mc_tokens_raw_buffer(_mongocrypt_tester_t *tester) {
-    mc_ServerDataEncryptionLevel1Token_t *token;
+    mc_ServerDataEncryptionLevel1Token_t *token1;
+    mc_ServerDataEncryptionLevel1Token_t *token2;
     _mongocrypt_buffer_t test_input;
     _mongocrypt_buffer_t expected;
 
     _mongocrypt_buffer_copy_from_hex(&test_input, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
     /* Make a token from a raw buffer */
-    token = mc_ServerDataEncryptionLevel1Token_new_from_buffer(&test_input);
+    token1 = mc_ServerDataEncryptionLevel1Token_new_from_buffer(&test_input);
+    token2 = mc_ServerDataEncryptionLevel1Token_new_from_buffer_copy(&test_input);
 
     /* Assert new_from_buffer did not steal ownership. */
     ASSERT(test_input.owned);
@@ -262,16 +364,21 @@ static void _test_mc_tokens_raw_buffer(_mongocrypt_tester_t *tester) {
 
     _mongocrypt_buffer_copy_from_hex(&expected, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
-    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token1), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token2), expected);
 
     /* Assert new_from_buffer references original buffer instead of a copy. */
     test_input.data[0] = '0';
     expected.data[0] = '0';
-    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token1), expected);
+
+    // Assert new_from_buffer_copy references a new buffer.
+    ASSERT_CMPUINT8(mc_ServerDataEncryptionLevel1Token_get(token2)->data[0], !=, expected.data[0]);
 
     _mongocrypt_buffer_cleanup(&test_input);
     _mongocrypt_buffer_cleanup(&expected);
-    mc_ServerDataEncryptionLevel1Token_destroy(token);
+    mc_ServerDataEncryptionLevel1Token_destroy(token1);
+    mc_ServerDataEncryptionLevel1Token_destroy(token2);
 }
 
 void _mongocrypt_tester_install_mc_tokens(_mongocrypt_tester_t *tester) {

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-assert-match-bson.c

@@ -167,7 +167,7 @@ bool match_json(const bson_t *doc,
     pattern = bson_new_from_json((const uint8_t *)double_quoted, -1, &error);
 
     if (!pattern) {
-        fprintf(stderr, "couldn't parse JSON: %s\n", error.message);
+        TEST_STDERR_PRINTF("couldn't parse JSON: %s\n", error.message);
         abort();
     }
 
@@ -176,18 +176,17 @@ bool match_json(const bson_t *doc,
 
     if (!matches) {
         char *as_string = doc ? bson_as_canonical_extended_json(doc, NULL) : NULL;
-        fprintf(stderr,
-                "ASSERT_MATCH failed with document:\n\n"
-                "%s\n"
-                "pattern:\n%s\n"
-                "%s\n"
-                "%s:%d %s()\n",
-                as_string ? as_string : "{}",
-                double_quoted,
-                ctx.errmsg,
-                filename,
-                lineno,
-                funcname);
+        TEST_STDERR_PRINTF("ASSERT_MATCH failed with document:\n\n"
+                           "%s\n"
+                           "pattern:\n%s\n"
+                           "%s\n"
+                           "%s:%d %s()\n",
+                           as_string ? as_string : "{}",
+                           double_quoted,
+                           ctx.errmsg,
+                           filename,
+                           lineno,
+                           funcname);
         bson_free(as_string);
     }
 
@@ -580,7 +579,7 @@ static bool get_type_operator(const bson_value_t *value, bson_type_t *out) {
         } else if (0 == strcasecmp("maxKey", value_string)) {
             *out = BSON_TYPE_MAXKEY;
         } else {
-            fprintf(stderr, "unrecognized $$type value: %s\n", value_string);
+            TEST_STDERR_PRINTF("unrecognized $$type value: %s\n", value_string);
             abort();
         }
         return true;

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-assert.h

@@ -25,12 +25,29 @@
 
 #include <stdio.h>
 
-#define TEST_ERROR(...)                                                                                                \
-    do {                                                                                                               \
-        fprintf(stderr, "test error %s:%d %s(): ", __FILE__, __LINE__, __FUNCTION__);                                  \
+// TEST_PRINTF ensures stdout and stderr are flushed.
+#define TEST_PRINTF(...)                                                                                               \
+    if (1) {                                                                                                           \
+        fflush(stderr);                                                                                                \
+        fprintf(stdout, __VA_ARGS__);                                                                                  \
+        fflush(stdout);                                                                                                \
+    } else                                                                                                             \
+        ((void)0)
+
+// TEST_STDERR_PRINTF ensures stdout and stderr are flushed.
+#define TEST_STDERR_PRINTF(...)                                                                                        \
+    if (1) {                                                                                                           \
+        fflush(stdout);                                                                                                \
         fprintf(stderr, __VA_ARGS__);                                                                                  \
-        fprintf(stderr, "\n");                                                                                         \
         fflush(stderr);                                                                                                \
+    } else                                                                                                             \
+        ((void)0)
+
+#define TEST_ERROR(...)                                                                                                \
+    do {                                                                                                               \
+        TEST_STDERR_PRINTF("test error %s:%d %s(): ", __FILE__, __LINE__, __FUNCTION__);                               \
+        TEST_STDERR_PRINTF(__VA_ARGS__);                                                                               \
+        TEST_STDERR_PRINTF("\n");                                                                                      \
         abort();                                                                                                       \
     } while (0)
 

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

@@ -16,6 +16,7 @@
 
 #include <mongocrypt-marking-private.h>
 
+#include "mongocrypt-buffer-private.h"
 #include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
@@ -232,6 +233,29 @@ static void _test_mongocrypt_buffer_from_subrange(_mongocrypt_tester_t *tester)
     _mongocrypt_buffer_cleanup(&input);
 }
 
+static void _test_mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t buf;
+    _mongocrypt_buffer_t expectedLenBuf;
+    const char *data = "foobar";
+
+    // expect output to contain 4-byte length + data + null string terminator
+    size_t expectedLen = sizeof(int32_t) + strlen(data) + sizeof(uint8_t);
+    _mongocrypt_buffer_copy_from_hex(&expectedLenBuf, "07000000");
+
+    _mongocrypt_buffer_copy_from_string_as_bson_value(&buf, data, (int)strlen(data));
+    ASSERT(buf.len == expectedLen);
+
+    // check 4-byte length
+    ASSERT_CMPBYTES(expectedLenBuf.data, expectedLenBuf.len, buf.data, expectedLenBuf.len);
+    // check data + null byte
+    ASSERT_CMPBYTES((const uint8_t *)data,
+                    strlen(data) + 1,
+                    buf.data + expectedLenBuf.len,
+                    buf.len - expectedLenBuf.len);
+    _mongocrypt_buffer_cleanup(&buf);
+    _mongocrypt_buffer_cleanup(&expectedLenBuf);
+}
+
 void _mongocrypt_tester_install_buffer(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_mongocrypt_buffer_from_iter);
     INSTALL_TEST(_test_mongocrypt_buffer_copy_from_data_and_size);
@@ -239,4 +263,5 @@ void _mongocrypt_tester_install_buffer(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_mongocrypt_buffer_steal_from_string);
     INSTALL_TEST(_test_mongocrypt_buffer_copy_from_uint64_le);
     INSTALL_TEST(_test_mongocrypt_buffer_from_subrange);
+    INSTALL_TEST(_test_mongocrypt_buffer_copy_from_string_as_bson_value);
 }

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

@@ -86,8 +86,9 @@ static void _test_cache_expiration(_mongocrypt_tester_t *tester) {
     BSON_ASSERT(bson_equal(entry, tmp));
     bson_destroy(tmp);
 
-    /* Sleep for 100 milliseconds */
-    _usleep(1000 * 100);
+    // Sleep to trigger cache expiration.
+    // Cache entries expire after 1ms, but use 20ms to avoid timing errors observed on Windows distros: CDRIVER-4526
+    _usleep(20 * 1000);
 
     BSON_ASSERT(_mongocrypt_cache_get(&cache, "1", (void **)&tmp));
     BSON_ASSERT(!tmp);

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-crypto-hooks.c

@@ -813,7 +813,7 @@ static void test_setting_only_ctr_hook(_mongocrypt_tester_t *tester) {
     // macOS <= 10.14 does not support native CTR encryption.
 
     if (!_aes_ctr_is_supported_by_os) {
-        printf("Common Crypto with no CTR support detected. Skipping.");
+        TEST_PRINTF("Common Crypto with no CTR support detected. Skipping.");
         return;
     }
 

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-crypto.c

@@ -17,6 +17,7 @@
 #include <mongocrypt-crypto-private.h>
 #include <mongocrypt.h>
 
+#include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
 typedef struct {
@@ -49,11 +50,11 @@ static bool _test_uses_ctr(const _test_mc_crypto_roundtrip_t *test) {
 
 static void _test_roundtrip_single(const _test_mc_crypto_roundtrip_t *test) {
     if (!_aes_ctr_is_supported_by_os && _test_uses_ctr(test)) {
-        printf("Common Crypto with no CTR support detected. Skipping %s", test->name);
+        TEST_PRINTF("Common Crypto with no CTR support detected. Skipping %s", test->name);
         return;
     }
 
-    printf("Begin %s...\n", test->name);
+    TEST_PRINTF("Begin %s...\n", test->name);
 
     mongocrypt_t *crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
     mongocrypt_status_t *const status = mongocrypt_status_new();
@@ -125,7 +126,7 @@ done:
     mongocrypt_status_destroy(status);
     mongocrypt_destroy(crypt);
 
-    printf("End %s...\n", test->name);
+    TEST_PRINTF("End %s...\n", test->name);
 }
 
 static const _mongocrypt_value_encryption_algorithm_t *get_algo_by_name(const char *name) {
@@ -233,7 +234,7 @@ static void _test_mc_crypto_roundtrip_destroy(_test_mc_crypto_roundtrip_t *test)
 }
 
 static void _test_roundtrip_set(_mongocrypt_tester_t *tester, const char *path) {
-    printf("Loading tests from %s...\n", path);
+    TEST_PRINTF("Loading tests from %s...\n", path);
 
     mongocrypt_binary_t *test_bin = TEST_FILE(path);
     if (!test_bin) {
@@ -259,7 +260,7 @@ static void _test_roundtrip_set(_mongocrypt_tester_t *tester, const char *path)
         _test_mc_crypto_roundtrip_destroy(&test);
     }
 
-    printf("Finished tests in %s\n", path);
+    TEST_PRINTF("Finished tests in %s\n", path);
 }
 
 static void _test_roundtrip(_mongocrypt_tester_t *tester) {
@@ -324,7 +325,7 @@ void _test_native_crypto_hmac_sha_256(_mongocrypt_tester_t *tester) {
         _mongocrypt_buffer_t got;
         mongocrypt_status_t *status;
 
-        printf("Begin test '%s'.\n", test->testname);
+        TEST_PRINTF("Begin test '%s'.\n", test->testname);
 
         _mongocrypt_buffer_copy_from_hex(&key, test->key);
         _mongocrypt_buffer_copy_from_hex(&input, test->input);
@@ -347,7 +348,7 @@ void _test_native_crypto_hmac_sha_256(_mongocrypt_tester_t *tester) {
         _mongocrypt_buffer_cleanup(&input);
         _mongocrypt_buffer_cleanup(&key);
 
-        printf("End test '%s'.\n", test->testname);
+        TEST_PRINTF("End test '%s'.\n", test->testname);
     }
 
     mongocrypt_destroy(crypt);
@@ -432,9 +433,38 @@ static void _test_random_int64(_mongocrypt_tester_t *tester) {
     mongocrypt_destroy(crypt);
 }
 
+static void _test_aes_256_aead_steps_consistent(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    // Tests a key assumption we make that if 16k <= a <= b <= 16k + 15 (a, b, k integers), a plaintext of length a and
+    // a plaintext of length b produce a ciphertext of the same length, and a plaintext of length 16k produces a
+    // ciphertext 16 bytes longer than one of length 16(k-1). This is very important for the leakage profile of QE text
+    // search.
+    const _mongocrypt_value_encryption_algorithm_t *alg = _mcFLE2v2AEADAlgorithm();
+    size_t ciphertext_len = 0;
+    for (int i = 0; i <= 16; i++) {
+        size_t new_ct_len = alg->get_ciphertext_len(i * 16, status);
+        if (new_ct_len == 0) {
+            TEST_ERROR("get_ciphertext_len failed");
+        }
+        if (i != 0) {
+            ASSERT_CMPSIZE_T(new_ct_len, ==, ciphertext_len + 16);
+        }
+        ciphertext_len = new_ct_len;
+        for (int j = 1; j < 16; j++) {
+            size_t ct_len = alg->get_ciphertext_len(i * 16 + j, status);
+            if (ct_len == 0) {
+                TEST_ERROR("get_ciphertext_len failed");
+            }
+            ASSERT_CMPSIZE_T(ct_len, ==, ciphertext_len);
+        }
+    }
+    mongocrypt_status_destroy(status);
+}
+
 void _mongocrypt_tester_install_crypto(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_roundtrip);
     INSTALL_TEST(_test_native_crypto_hmac_sha_256);
     INSTALL_TEST_CRYPTO(_test_mongocrypt_hmac_sha_256_hook, CRYPTO_OPTIONAL);
     INSTALL_TEST(_test_random_int64);
+    INSTALL_TEST(_test_aes_256_aead_steps_consistent);
 }

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-csfle-lib.c

@@ -170,6 +170,26 @@ static void _test_override_error_includes_reason(_mongocrypt_tester_t *tester) {
     mongocrypt_destroy(crypt);
 }
 
+static void _test_lookup_version_check(_mongocrypt_tester_t *tester) {
+    if (!TEST_MONGOCRYPT_HAVE_REAL_CRYPT_SHARED_LIB) {
+        TEST_STDERR_PRINTF("No 'real' csfle library is available. The %s test is a no-op.\n", BSON_FUNC);
+        return;
+    }
+
+#define CRYPT_SHARED_8_1 0x0008000100000000ull
+    mongocrypt_t *crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB);
+    uint64_t version = crypt->csfle.get_version();
+    mongocrypt_ctx_t *ctx = mongocrypt_ctx_new(crypt);
+    mongocrypt_binary_t *cmd = TEST_FILE("./test/data/lookup/csfle/01-cmd.json");
+    if (version >= CRYPT_SHARED_8_1) {
+        ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, "db", -1, cmd), ctx);
+    } else {
+        ASSERT_FAILS(mongocrypt_ctx_encrypt_init(ctx, "db", -1, cmd), ctx, "Upgrade crypt_shared");
+    }
+    mongocrypt_ctx_destroy(ctx);
+    mongocrypt_destroy(crypt);
+}
+
 void _mongocrypt_tester_install_csfle_lib(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_csfle_no_paths);
     INSTALL_TEST(_test_csfle_not_found);
@@ -181,4 +201,5 @@ void _mongocrypt_tester_install_csfle_lib(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_cur_exe_path);
     INSTALL_TEST(_test_csfle_not_loaded_with_bypassqueryanalysis);
     INSTALL_TEST(_test_override_error_includes_reason);
+    INSTALL_TEST(_test_lookup_version_check);
 }