libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

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

@@ -14,232 +14,268 @@
  * limitations under the License.
  */
 #include "mc-tokens-private.h"
+#include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
-static void
-_test_mc_tokens (_mongocrypt_tester_t *tester)
-{
-   mongocrypt_status_t *status;
-   mongocrypt_t *crypt;
-   _mongocrypt_buffer_t RootKey;
-   _mongocrypt_buffer_t expected;
-   _mongocrypt_buffer_t v;
-   uint64_t u = 1234567890;
-
-   status = mongocrypt_status_new ();
-   crypt = _mongocrypt_tester_mongocrypt (TESTER_MONGOCRYPT_DEFAULT);
-   _mongocrypt_buffer_copy_from_hex (
-      &RootKey,
-      "6eda88c8496ec990f5d5518dd2ad6f3d9c33b6055904b120f12de82911fbd933");
-   _mongocrypt_buffer_copy_from_hex (
-      &v, "c07c0df51257948e1a0fc70dd4568e3af99b23b3434c9858237ca7db62db9766");
-
-   mc_CollectionsLevel1Token_t *CollectionsLevel1Token =
-      mc_CollectionsLevel1Token_new (crypt->crypto, &RootKey, status);
-   ASSERT_OR_PRINT (CollectionsLevel1Token, status);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "ff2103ff205a36f39704f643c270c129919f008c391d9589a6d2c86a7429d0d3");
-   ASSERT_CMPBUF (*mc_CollectionsLevel1Token_get (CollectionsLevel1Token),
-                  expected);
-
-   mc_ServerDataEncryptionLevel1Token_t *ServerDataEncryptionLevel1Token =
-      mc_ServerDataEncryptionLevel1Token_new (crypt->crypto, &RootKey, status);
-   ASSERT_OR_PRINT (ServerDataEncryptionLevel1Token, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "d915ccc1eb81687fb5fc5b799f48c99fbe17e7a011a46a48901b9ae3d790656b");
-   ASSERT_CMPBUF (
-      *mc_ServerDataEncryptionLevel1Token_get (ServerDataEncryptionLevel1Token),
-      expected);
-
-   mc_EDCToken_t *EDCToken =
-      mc_EDCToken_new (crypt->crypto, CollectionsLevel1Token, status);
-   ASSERT_OR_PRINT (EDCToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "167d2d2ff8e4144df37ff759db593fde0ecc7d9636f96d62dacad672eccad349");
-   ASSERT_CMPBUF (*mc_EDCToken_get (EDCToken), expected);
-
-   mc_ESCToken_t *ESCToken =
-      mc_ESCToken_new (crypt->crypto, CollectionsLevel1Token, status);
-   ASSERT_OR_PRINT (ESCToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "bfd480f1658f49f48985734737bc07d0bc36b88210277605c55ff3c9c3ef50b0");
-   ASSERT_CMPBUF (*mc_ESCToken_get (ESCToken), expected);
-
-   mc_ECCToken_t *ECCToken =
-      mc_ECCToken_new (crypt->crypto, CollectionsLevel1Token, status);
-   ASSERT_OR_PRINT (ECCToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "9d34f9c182d75a5a3347c2f903e3e647105c651d52cf9555c9420ba07ddd3aa2");
-   ASSERT_CMPBUF (*mc_ECCToken_get (ECCToken), expected);
-
-   mc_ECOCToken_t *ECOCToken =
-      mc_ECOCToken_new (crypt->crypto, CollectionsLevel1Token, status);
-   ASSERT_OR_PRINT (ECOCToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "e354e3b05e81e08b970ca061cb365163fd33dec2f982ddf9440e742ed288a8f8");
-   ASSERT_CMPBUF (*mc_ECOCToken_get (ECOCToken), expected);
-
-   mc_EDCDerivedFromDataToken_t *EDCDerivedFromDataToken =
-      mc_EDCDerivedFromDataToken_new (crypt->crypto, EDCToken, &v, status);
-   ASSERT_OR_PRINT (EDCDerivedFromDataToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "53eaa4c23a3ff65e6b7c7dbc4b1389cf0a6151b1ede5383a0673ff9c67855ff9");
-   ASSERT_CMPBUF (*mc_EDCDerivedFromDataToken_get (EDCDerivedFromDataToken),
-                  expected);
-
-   mc_ESCDerivedFromDataToken_t *ESCDerivedFromDataToken =
-      mc_ESCDerivedFromDataToken_new (crypt->crypto, ESCToken, &v, status);
-   ASSERT_OR_PRINT (ESCDerivedFromDataToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "acb3fab332131bbeaf112814f29ae0f2b10e97dc94b62db56c594661248e7467");
-   ASSERT_CMPBUF (*mc_ESCDerivedFromDataToken_get (ESCDerivedFromDataToken),
-                  expected);
-
-   mc_ECCDerivedFromDataToken_t *ECCDerivedFromDataToken =
-      mc_ECCDerivedFromDataToken_new (crypt->crypto, ECCToken, &v, status);
-   ASSERT_OR_PRINT (ECCDerivedFromDataToken, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "826cfd35c35dcc7d4fbe13f33a3520749853bd1ea4c47919482252fba3a70cec");
-   ASSERT_CMPBUF (*mc_ECCDerivedFromDataToken_get (ECCDerivedFromDataToken),
-                  expected);
-
-   mc_EDCDerivedFromDataTokenAndCounter_t *EDCDerivedFromDataTokenAndCounter =
-      mc_EDCDerivedFromDataTokenAndCounter_new (
-         crypt->crypto, EDCDerivedFromDataToken, u, status);
-   ASSERT_OR_PRINT (EDCDerivedFromDataTokenAndCounter, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "70fb9a3f760996f2f1438c5bf2a4d52bcba01b0badc3596276f49ffb2f0b136e");
-   ASSERT_CMPBUF (*mc_EDCDerivedFromDataTokenAndCounter_get (
-                     EDCDerivedFromDataTokenAndCounter),
-                  expected);
-
-   mc_ESCDerivedFromDataTokenAndCounter_t *ESCDerivedFromDataTokenAndCounter =
-      mc_ESCDerivedFromDataTokenAndCounter_new (
-         crypt->crypto, ESCDerivedFromDataToken, u, status);
-   ASSERT_OR_PRINT (ESCDerivedFromDataTokenAndCounter, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "7076c7b05fb4be4fe585eed930b852a6d088a0c55f3c96b50069e8a26ebfb347");
-   ASSERT_CMPBUF (*mc_ESCDerivedFromDataTokenAndCounter_get (
-                     ESCDerivedFromDataTokenAndCounter),
-                  expected);
-
-   mc_ECCDerivedFromDataTokenAndCounter_t *ECCDerivedFromDataTokenAndCounter =
-      mc_ECCDerivedFromDataTokenAndCounter_new (
-         crypt->crypto, ECCDerivedFromDataToken, u, status);
-   ASSERT_OR_PRINT (ECCDerivedFromDataTokenAndCounter, status);
-   _mongocrypt_buffer_cleanup (&expected);
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
-   ASSERT_CMPBUF (*mc_ECCDerivedFromDataTokenAndCounter_get (
-                     ECCDerivedFromDataTokenAndCounter),
-                  expected);
-
-   _mongocrypt_buffer_cleanup (&expected);
-   mc_ECCDerivedFromDataTokenAndCounter_destroy (
-      ECCDerivedFromDataTokenAndCounter);
-   mc_ESCDerivedFromDataTokenAndCounter_destroy (
-      ESCDerivedFromDataTokenAndCounter);
-   mc_EDCDerivedFromDataTokenAndCounter_destroy (
-      EDCDerivedFromDataTokenAndCounter);
-   mc_ECCDerivedFromDataToken_destroy (ECCDerivedFromDataToken);
-   mc_ESCDerivedFromDataToken_destroy (ESCDerivedFromDataToken);
-   mc_EDCDerivedFromDataToken_destroy (EDCDerivedFromDataToken);
-   mc_ECOCToken_destroy (ECOCToken);
-   mc_ECCToken_destroy (ECCToken);
-   mc_ESCToken_destroy (ESCToken);
-   mc_EDCToken_destroy (EDCToken);
-   mc_ServerDataEncryptionLevel1Token_destroy (ServerDataEncryptionLevel1Token);
-   mc_CollectionsLevel1Token_destroy (CollectionsLevel1Token);
-   _mongocrypt_buffer_cleanup (&v);
-   _mongocrypt_buffer_cleanup (&RootKey);
-   mongocrypt_destroy (crypt);
-   mongocrypt_status_destroy (status);
+#define FOREACH_FIELD(F)                                                                                               \
+    F(root)                                                                                                            \
+    F(value)                                                                                                           \
+    F(collectionsLevel1Token)                                                                                          \
+    F(serverDataEncryptionLevel1Token)                                                                                 \
+    F(serverTokenDerivationLevel1Token)                                                                                \
+    F(EDCToken)                                                                                                        \
+    F(ESCToken)                                                                                                        \
+    F(ECCToken)                                                                                                        \
+    F(ECOCToken)                                                                                                       \
+    F(EDCDerivedFromDataToken)                                                                                         \
+    F(ESCDerivedFromDataToken)                                                                                         \
+    F(ECCDerivedFromDataToken)                                                                                         \
+    F(serverDerivedFromDataToken)                                                                                      \
+    F(EDCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(ESCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(ECCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(EDCTwiceDerivedToken)                                                                                            \
+    F(ESCTwiceDerivedTagToken)                                                                                         \
+    F(ESCTwiceDerivedValueToken)                                                                                       \
+    F(serverCountAndContentionFactorEncryptionToken)                                                                   \
+    F(serverZerosEncryptionToken)                                                                                      \
+    F(AnchorPaddingTokenRoot)
+
+typedef struct {
+#define DECLARE_FIELD(f) _mongocrypt_buffer_t f;
+    FOREACH_FIELD(DECLARE_FIELD)
+#undef DECLARE_FIELD
+    uint64_t contentionFactor;
+} _mc_token_test;
+
+static void _mc_token_test_cleanup(_mc_token_test *test) {
+#define CLEANUP_FIELD(f) _mongocrypt_buffer_cleanup(&test->f);
+    FOREACH_FIELD(CLEANUP_FIELD)
+#undef CLEANUP_FIELD
 }
 
-static void
-_test_mc_tokens_error (_mongocrypt_tester_t *tester)
-{
-   mongocrypt_status_t *status;
-   mongocrypt_t *crypt;
-   _mongocrypt_buffer_t RootKey;
-
-   status = mongocrypt_status_new ();
-   crypt = _mongocrypt_tester_mongocrypt (TESTER_MONGOCRYPT_DEFAULT);
-   /* RootKey is incorrect length. */
-   _mongocrypt_buffer_copy_from_hex (&RootKey, "AAAA");
-
-   mc_CollectionsLevel1Token_t *CollectionsLevel1Token =
-      mc_CollectionsLevel1Token_new (crypt->crypto, &RootKey, status);
-   ASSERT_FAILS_STATUS (CollectionsLevel1Token != NULL,
-                        status,
-                        "invalid hmac_sha_256 key length");
-
-   mc_CollectionsLevel1Token_destroy (CollectionsLevel1Token);
-   _mongocrypt_buffer_cleanup (&RootKey);
-   mongocrypt_destroy (crypt);
-   mongocrypt_status_destroy (status);
+static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
+    printf("Loading test from %s...\n", path);
+
+    mongocrypt_binary_t *test_bin = TEST_FILE(path);
+    if (!test_bin) {
+        TEST_ERROR("Failed loading test data file '%s'\n", path);
+    }
+    if (test_bin->len == 5) {
+        TEST_ERROR("Invalid JSON in file '%s'\n", path);
+    }
+
+    bson_t test_bson;
+    ASSERT(bson_init_static(&test_bson, test_bin->data, test_bin->len));
+    ASSERT(bson_validate(&test_bson, BSON_VALIDATE_NONE, NULL));
+
+    bool hasContentionFactor = false;
+    _mc_token_test test = {{0}};
+    bson_iter_t it;
+    ASSERT(bson_iter_init(&it, &test_bson));
+    while (bson_iter_next(&it)) {
+        const char *field = bson_iter_key(&it);
+        ASSERT(field);
+
+#define PARSE_FIELD(f)                                                                                                 \
+    if (!strcmp(field, #f)) {                                                                                          \
+        ASSERT_OR_PRINT_MSG(!test.f.data, "Duplicate field '" #f "' in test");                                         \
+        ASSERT(BSON_ITER_HOLDS_UTF8(&it));                                                                             \
+        const char *value = bson_iter_utf8(&it, NULL);                                                                 \
+        _mongocrypt_buffer_copy_from_hex(&test.f, value);                                                              \
+        ASSERT(strlen(value) == (test.f.len * 2));                                                                     \
+    } else
+        FOREACH_FIELD(PARSE_FIELD)
+#undef PARSE_FIELD
+        /* else */
+        if (!strcmp(field, "contentionFactor")) {
+            ASSERT_OR_PRINT_MSG(!hasContentionFactor, "Duplicate field 'contentionFactor' in test");
+            ASSERT(BSON_ITER_HOLDS_INT32(&it) || BSON_ITER_HOLDS_INT64(&it));
+            test.contentionFactor = bson_iter_as_int64(&it);
+            hasContentionFactor = true;
+        } else {
+            TEST_ERROR("Unknown field '%s'", field);
+        }
+    }
+
+#define CHECK_FIELD(f) ASSERT_OR_PRINT_MSG(test.f.data, "Missing field '" #f "' in test");
+    FOREACH_FIELD(CHECK_FIELD)
+#undef CHECK_FIELD
+    ASSERT_OR_PRINT_MSG(hasContentionFactor, "Missing field 'contentionFactor' in test");
+
+    // Run the actual test.
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    mongocrypt_t *crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
+
+    // collectionsLevel1Token
+    mc_CollectionsLevel1Token_t *collectionsLevel1Token =
+        mc_CollectionsLevel1Token_new(crypt->crypto, &test.root, status);
+    ASSERT_OR_PRINT(collectionsLevel1Token, status);
+    ASSERT_CMPBUF(*mc_CollectionsLevel1Token_get(collectionsLevel1Token), test.collectionsLevel1Token);
+
+    // ServerDataEncryptionLevel1Token
+    mc_ServerDataEncryptionLevel1Token_t *serverDataEncryptionLevel1Token =
+        mc_ServerDataEncryptionLevel1Token_new(crypt->crypto, &test.root, status);
+    ASSERT_OR_PRINT(serverDataEncryptionLevel1Token, status);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(serverDataEncryptionLevel1Token),
+                  test.serverDataEncryptionLevel1Token);
+
+    // 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);
+
+// (EDC|ESC|ECC|ECOC)Token
+#define TEST_COLL_TOKEN(Name)                                                                                          \
+    mc_##Name##Token_t *Name##Token = mc_##Name##Token_new(crypt->crypto, collectionsLevel1Token, status);             \
+    ASSERT_OR_PRINT(Name##Token, status);                                                                              \
+    ASSERT_CMPBUF(*mc_##Name##Token_get(Name##Token), test.Name##Token);
+    TEST_COLL_TOKEN(EDC)
+    TEST_COLL_TOKEN(ESC)
+    TEST_COLL_TOKEN(ECC)
+    TEST_COLL_TOKEN(ECOC)
+#undef TEST_COLL_TOKEN
+
+// (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
+
+// (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);
+    TEST_TWICE(EDC, Token);
+    TEST_TWICE(ESC, TagToken);
+    TEST_TWICE(ESC, ValueToken);
+#undef TEST_TWICE
+
+    // ServerDerivedFromDataToken
+    mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken =
+        mc_ServerDerivedFromDataToken_new(crypt->crypto, serverTokenDerivationLevel1Token, &test.value, status);
+    ASSERT_OR_PRINT(serverDerivedFromDataToken, status);
+    ASSERT_CMPBUF(*mc_ServerDerivedFromDataToken_get(serverDerivedFromDataToken), test.serverDerivedFromDataToken);
+
+    // ServerCountAndContentionFactorEncryptionToken
+    mc_ServerCountAndContentionFactorEncryptionToken_t *serverCACFET =
+        mc_ServerCountAndContentionFactorEncryptionToken_new(crypt->crypto, serverDerivedFromDataToken, status);
+    ASSERT_OR_PRINT(serverCACFET, status);
+    ASSERT_CMPBUF(*mc_ServerCountAndContentionFactorEncryptionToken_get(serverCACFET),
+                  test.serverCountAndContentionFactorEncryptionToken);
+
+    // ServerZerosEncryptionToken
+    mc_ServerZerosEncryptionToken_t *serverZeros =
+        mc_ServerZerosEncryptionToken_new(crypt->crypto, serverDerivedFromDataToken, status);
+    ASSERT_OR_PRINT(serverZeros, status);
+    ASSERT_CMPBUF(*mc_ServerZerosEncryptionToken_get(serverZeros), test.serverZerosEncryptionToken);
+
+    // AnchorPaddingTokenRoot
+    mc_AnchorPaddingTokenRoot_t *padding = mc_AnchorPaddingTokenRoot_new(crypt->crypto, ESCToken, status);
+    ASSERT_OR_PRINT(padding, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingTokenRoot_get(padding), test.AnchorPaddingTokenRoot);
+
+    // Done.
+    mc_AnchorPaddingTokenRoot_destroy(padding);
+    mc_ServerZerosEncryptionToken_destroy(serverZeros);
+    mc_ServerCountAndContentionFactorEncryptionToken_destroy(serverCACFET);
+    mc_ServerDerivedFromDataToken_destroy(serverDerivedFromDataToken);
+    mc_ESCTwiceDerivedValueToken_destroy(ESCTwiceDerivedValueToken);
+    mc_ESCTwiceDerivedTagToken_destroy(ESCTwiceDerivedTagToken);
+    mc_EDCTwiceDerivedToken_destroy(EDCTwiceDerivedToken);
+    mc_ECCDerivedFromDataTokenAndContentionFactor_destroy(ECCDerivedFromDataTokenAndContentionFactor);
+    mc_ESCDerivedFromDataTokenAndContentionFactor_destroy(ESCDerivedFromDataTokenAndContentionFactor);
+    mc_EDCDerivedFromDataTokenAndContentionFactor_destroy(EDCDerivedFromDataTokenAndContentionFactor);
+    mc_ECCDerivedFromDataToken_destroy(ECCDerivedFromDataToken);
+    mc_ESCDerivedFromDataToken_destroy(ESCDerivedFromDataToken);
+    mc_EDCDerivedFromDataToken_destroy(EDCDerivedFromDataToken);
+    mc_ECOCToken_destroy(ECOCToken);
+    mc_ECCToken_destroy(ECCToken);
+    mc_ESCToken_destroy(ESCToken);
+    mc_EDCToken_destroy(EDCToken);
+    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);
+}
+
+static void _test_mc_tokens(_mongocrypt_tester_t *tester) {
+    _mc_token_test_run(tester, "test/data/tokens/mc.json");
+    _mc_token_test_run(tester, "test/data/tokens/server.json");
+}
+
+static void _test_mc_tokens_error(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status;
+    mongocrypt_t *crypt;
+    _mongocrypt_buffer_t RootKey;
+
+    status = mongocrypt_status_new();
+    crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
+    /* RootKey is incorrect length. */
+    _mongocrypt_buffer_copy_from_hex(&RootKey, "AAAA");
+
+    mc_CollectionsLevel1Token_t *CollectionsLevel1Token =
+        mc_CollectionsLevel1Token_new(crypt->crypto, &RootKey, status);
+    ASSERT_FAILS_STATUS(CollectionsLevel1Token != NULL, status, "invalid hmac_sha_256 key length");
+
+    mc_CollectionsLevel1Token_destroy(CollectionsLevel1Token);
+    _mongocrypt_buffer_cleanup(&RootKey);
+    mongocrypt_destroy(crypt);
+    mongocrypt_status_destroy(status);
 }
 
-static void
-_test_mc_tokens_raw_buffer (_mongocrypt_tester_t *tester)
-{
-   mc_ServerDataEncryptionLevel1Token_t *token;
-   _mongocrypt_buffer_t test_input;
-   _mongocrypt_buffer_t expected;
+static void _test_mc_tokens_raw_buffer(_mongocrypt_tester_t *tester) {
+    mc_ServerDataEncryptionLevel1Token_t *token;
+    _mongocrypt_buffer_t test_input;
+    _mongocrypt_buffer_t expected;
 
-   _mongocrypt_buffer_copy_from_hex (
-      &test_input,
-      "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
+    _mongocrypt_buffer_copy_from_hex(&test_input, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
-   /* Make a token from a raw buffer */
-   token = mc_ServerDataEncryptionLevel1Token_new_from_buffer (&test_input);
+    /* Make a token from a raw buffer */
+    token = mc_ServerDataEncryptionLevel1Token_new_from_buffer(&test_input);
 
-   /* Assert new_from_buffer did not steal ownership. */
-   ASSERT (test_input.owned);
-   ASSERT (test_input.len == MONGOCRYPT_HMAC_SHA256_LEN);
+    /* Assert new_from_buffer did not steal ownership. */
+    ASSERT(test_input.owned);
+    ASSERT(test_input.len == MONGOCRYPT_HMAC_SHA256_LEN);
 
-   _mongocrypt_buffer_copy_from_hex (
-      &expected,
-      "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
+    _mongocrypt_buffer_copy_from_hex(&expected, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
-   ASSERT_CMPBUF (*mc_ServerDataEncryptionLevel1Token_get (token), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token), 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 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);
 
-   _mongocrypt_buffer_cleanup (&test_input);
-   _mongocrypt_buffer_cleanup (&expected);
-   mc_ServerDataEncryptionLevel1Token_destroy (token);
+    _mongocrypt_buffer_cleanup(&test_input);
+    _mongocrypt_buffer_cleanup(&expected);
+    mc_ServerDataEncryptionLevel1Token_destroy(token);
 }
 
-void
-_mongocrypt_tester_install_mc_tokens (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_mc_tokens);
-   INSTALL_TEST (_test_mc_tokens_error);
-   INSTALL_TEST (_test_mc_tokens_raw_buffer);
+void _mongocrypt_tester_install_mc_tokens(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_mc_tokens);
+    INSTALL_TEST(_test_mc_tokens_error);
+    INSTALL_TEST(_test_mc_tokens_raw_buffer);
 }

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

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2022-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.
+ */
+
+#include "mc-reader-private.h"
+#include "mc-writer-private.h"
+#include "test-mongocrypt-assert.h"
+#include "test-mongocrypt.h"
+
+static void _test_mc_writer_ints(_mongocrypt_tester_t *tester) {
+    {
+        mongocrypt_status_t *status;
+        status = mongocrypt_status_new();
+
+        _mongocrypt_buffer_t write_buffer;
+        _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint8_t));
+
+        mc_writer_t writer;
+        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+        uint8_t num = 4;
+        ASSERT_OK_STATUS(mc_writer_write_u8(&writer, num, status), status);
+
+        mc_reader_t reader;
+        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+
+        uint8_t out;
+        ASSERT_OK_STATUS(mc_reader_read_u8(&reader, &out, status), status);
+
+        ASSERT_CMPUINT8(out, ==, num);
+
+        _mongocrypt_buffer_cleanup(&write_buffer);
+        mongocrypt_status_destroy(status);
+    }
+
+    {
+        mongocrypt_status_t *status;
+        status = mongocrypt_status_new();
+
+        _mongocrypt_buffer_t write_buffer;
+        _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint32_t));
+
+        mc_writer_t writer;
+        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+        uint32_t num = 23832405;
+        ASSERT_OK_STATUS(mc_writer_write_u32(&writer, num, status), status);
+
+        mc_reader_t reader;
+        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+
+        uint32_t out;
+        ASSERT_OK_STATUS(mc_reader_read_u32(&reader, &out, status), status);
+
+        ASSERT_CMPUINT32(out, ==, num);
+
+        _mongocrypt_buffer_cleanup(&write_buffer);
+        mongocrypt_status_destroy(status);
+    }
+
+    {
+        mongocrypt_status_t *status;
+        status = mongocrypt_status_new();
+
+        _mongocrypt_buffer_t write_buffer;
+        _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint64_t));
+
+        mc_writer_t writer;
+        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+        uint64_t num = 23832405;
+        ASSERT_OK_STATUS(mc_writer_write_u64(&writer, num, status), status);
+
+        mc_reader_t reader;
+        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+
+        uint64_t out;
+        ASSERT_OK_STATUS(mc_reader_read_u64(&reader, &out, status), status);
+
+        ASSERT_CMPUINT64(out, ==, num);
+
+        _mongocrypt_buffer_cleanup(&write_buffer);
+        mongocrypt_status_destroy(status);
+    }
+}
+
+static void _test_mc_writer_buffer(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    _mongocrypt_buffer_t input_buffer;
+
+    _mongocrypt_buffer_copy_from_hex(&input_buffer,
+                                     "07123456781234987612341234567890120243bba14ddf42da823c33569f4689f465a");
+
+    _mongocrypt_buffer_t write_buffer;
+    _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
+
+    mc_writer_t writer;
+    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+    ASSERT_OK_STATUS(mc_writer_write_buffer(&writer, &input_buffer, input_buffer.len, status), status);
+
+    _mongocrypt_buffer_t read_buffer;
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+    ASSERT_OK_STATUS(mc_reader_read_buffer(&reader, &read_buffer, write_buffer.len, status), status);
+
+    ASSERT_CMPBUF(input_buffer, read_buffer);
+
+    _mongocrypt_buffer_cleanup(&input_buffer);
+    _mongocrypt_buffer_cleanup(&write_buffer);
+    _mongocrypt_buffer_cleanup(&read_buffer);
+    mongocrypt_status_destroy(status);
+}
+
+static void _test_mc_writer_prf(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    _mongocrypt_buffer_t input_buffer;
+    _mongocrypt_buffer_copy_from_hex(&input_buffer, "c03cd1d0536aa07d4ffaa0301656222fc03cd1d0536aa07d4ffaa0301656222f");
+
+    _mongocrypt_buffer_t write_buffer;
+    _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
+
+    mc_writer_t writer;
+    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+    ASSERT_OK_STATUS(mc_writer_write_prfblock_buffer(&writer, &input_buffer, status), status);
+    ASSERT_CMPBUF(input_buffer, write_buffer);
+
+    _mongocrypt_buffer_cleanup(&input_buffer);
+    _mongocrypt_buffer_cleanup(&write_buffer);
+    mongocrypt_status_destroy(status);
+}
+
+static void _test_mc_writer_uuid(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    _mongocrypt_buffer_t input_buffer;
+    _mongocrypt_buffer_copy_from_hex(&input_buffer, "c03cd1d0536aa07d4ffaa0301656222f");
+
+    _mongocrypt_buffer_t write_buffer;
+    _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
+
+    mc_writer_t writer;
+    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+
+    ASSERT_OK_STATUS(mc_writer_write_uuid_buffer(&writer, &input_buffer, status), status);
+    ASSERT_CMPBUF(input_buffer, write_buffer);
+
+    _mongocrypt_buffer_cleanup(&input_buffer);
+    _mongocrypt_buffer_cleanup(&write_buffer);
+    mongocrypt_status_destroy(status);
+}
+
+void _mongocrypt_tester_install_mc_writer(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_mc_writer_ints);
+    INSTALL_TEST(_test_mc_writer_buffer);
+    INSTALL_TEST(_test_mc_writer_prf);
+    INSTALL_TEST(_test_mc_writer_uuid);
+}