libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

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

@@ -15,137 +15,165 @@
  */
 
 #include "mc-tokens-private.h"
+#include "mongocrypt-buffer-private.h"
 
 /// Define a token type of the given name, with constructor parameters given as
 /// the remaining arguments. This macro usage should be followed by the
 /// constructor body, with the implicit first argument '_mongocrypt_crypto_t*
 /// crypto' and final argument 'mongocrypt_status_t* status'
-#define DEF_TOKEN_TYPE(Name, ...) \
-   DEF_TOKEN_TYPE_1 (Name, CONCAT (Name, _t), __VA_ARGS__)
-
-#define DEF_TOKEN_TYPE_1(Prefix, T, ...)                             \
-   /* Define the struct for the token */                             \
-   struct T {                                                        \
-      _mongocrypt_buffer_t data;                                     \
-   };                                                                \
-   /* Data-getter */                                                 \
-   const _mongocrypt_buffer_t *CONCAT (Prefix, _get) (const T *self) \
-   {                                                                 \
-      return &self->data;                                            \
-   }                                                                 \
-   /* Destructor */                                                  \
-   void CONCAT (Prefix, _destroy) (T * self)                         \
-   {                                                                 \
-      if (!self) {                                                   \
-         return;                                                     \
-      }                                                              \
-      _mongocrypt_buffer_cleanup (&self->data);                      \
-      bson_free (self);                                              \
-   }                                                                 \
-   /* Constructor. From raw buffer */                                \
-   T *CONCAT (Prefix, _new_from_buffer) (_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. Parameter list given as variadic args. */         \
-   T *CONCAT (Prefix, _new) (_mongocrypt_crypto_t * crypto,          \
-                             __VA_ARGS__,                            \
-                             mongocrypt_status_t * status)
-
-#define IMPL_TOKEN_NEW_1(Name, Key, Arg, Clean)                             \
-   {                                                                        \
-      CONCAT (Name, _t) *t = bson_malloc (sizeof (CONCAT (Name, _t)));      \
-      _mongocrypt_buffer_init (&t->data);                                   \
-      _mongocrypt_buffer_resize (&t->data, MONGOCRYPT_HMAC_SHA256_LEN);     \
-                                                                            \
-      if (!_mongocrypt_hmac_sha_256 (crypto, Key, Arg, &t->data, status)) { \
-         CONCAT (Name, _destroy) (t);                                       \
-         Clean;                                                             \
-         return NULL;                                                       \
-      }                                                                     \
-      Clean;                                                                \
-      return t;                                                             \
-   }
+#define DEF_TOKEN_TYPE(Name, ...) DEF_TOKEN_TYPE_1(Name, BSON_CONCAT(Name, _t), __VA_ARGS__)
+
+#define DEF_TOKEN_TYPE_1(Prefix, T, ...)                                                                               \
+    /* Define the struct for the token */                                                                              \
+    struct T {                                                                                                         \
+        _mongocrypt_buffer_t data;                                                                                     \
+    };                                                                                                                 \
+    /* Data-getter */                                                                                                  \
+    const _mongocrypt_buffer_t *BSON_CONCAT(Prefix, _get)(const T *self) { return &self->data; }                       \
+    /* Destructor */                                                                                                   \
+    void BSON_CONCAT(Prefix, _destroy)(T * self) {                                                                     \
+        if (!self) {                                                                                                   \
+            return;                                                                                                    \
+        }                                                                                                              \
+        _mongocrypt_buffer_cleanup(&self->data);                                                                       \
+        bson_free(self);                                                                                               \
+    }                                                                                                                  \
+    /* Constructor. From raw buffer */                                                                                 \
+    T *BSON_CONCAT(Prefix, _new_from_buffer)(_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. Parameter list given as variadic args. */                                                          \
+    T *BSON_CONCAT(Prefix, _new)(_mongocrypt_crypto_t * crypto, __VA_ARGS__, mongocrypt_status_t * status)
+
+#define IMPL_TOKEN_NEW_1(Name, Key, Arg, Clean)                                                                        \
+    {                                                                                                                  \
+        BSON_CONCAT(Name, _t) *t = bson_malloc(sizeof(BSON_CONCAT(Name, _t)));                                         \
+        _mongocrypt_buffer_init(&t->data);                                                                             \
+        _mongocrypt_buffer_resize(&t->data, MONGOCRYPT_HMAC_SHA256_LEN);                                               \
+                                                                                                                       \
+        if (!_mongocrypt_hmac_sha_256(crypto, Key, Arg, &t->data, status)) {                                           \
+            BSON_CONCAT(Name, _destroy)(t);                                                                            \
+            Clean;                                                                                                     \
+            return NULL;                                                                                               \
+        }                                                                                                              \
+        Clean;                                                                                                         \
+        return t;                                                                                                      \
+    }
 
 // Define the implementation of a token where Arg is a _mongocrypt_buffer_t.
-#define IMPL_TOKEN_NEW(Name, Key, Arg) \
-   IMPL_TOKEN_NEW_1 (Name, Key, Arg, (void) 0)
+#define IMPL_TOKEN_NEW(Name, Key, Arg) IMPL_TOKEN_NEW_1(Name, Key, Arg, (void)0)
 
 // Define the implementation of a token where Arg is a uint64_t.
-#define IMPL_TOKEN_NEW_CONST(Name, Key, Arg)                         \
-   {                                                                 \
-      _mongocrypt_buffer_t to_hash;                                  \
-      _mongocrypt_buffer_copy_from_uint64_le (&to_hash, Arg);        \
-      IMPL_TOKEN_NEW_1 (                                             \
-         Name, Key, &to_hash, _mongocrypt_buffer_cleanup (&to_hash)) \
-   }
-
-DEF_TOKEN_TYPE (mc_CollectionsLevel1Token, const _mongocrypt_buffer_t *RootKey)
-IMPL_TOKEN_NEW_CONST (mc_CollectionsLevel1Token, RootKey, 1)
-
-DEF_TOKEN_TYPE (mc_ServerDataEncryptionLevel1Token,
-                const _mongocrypt_buffer_t *RootKey)
-IMPL_TOKEN_NEW_CONST (mc_ServerDataEncryptionLevel1Token, RootKey, 3)
-
-DEF_TOKEN_TYPE (mc_EDCToken,
-                const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
-IMPL_TOKEN_NEW_CONST (mc_EDCToken,
-                      mc_CollectionsLevel1Token_get (CollectionsLevel1Token),
-                      1)
-
-DEF_TOKEN_TYPE (mc_ESCToken,
-                const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
-IMPL_TOKEN_NEW_CONST (mc_ESCToken,
-                      mc_CollectionsLevel1Token_get (CollectionsLevel1Token),
-                      2)
-
-DEF_TOKEN_TYPE (mc_ECCToken,
-                const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
-IMPL_TOKEN_NEW_CONST (mc_ECCToken,
-                      mc_CollectionsLevel1Token_get (CollectionsLevel1Token),
-                      3)
-
-DEF_TOKEN_TYPE (mc_ECOCToken,
-                const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
-IMPL_TOKEN_NEW_CONST (mc_ECOCToken,
-                      mc_CollectionsLevel1Token_get (CollectionsLevel1Token),
-                      4)
-
-DEF_TOKEN_TYPE (mc_EDCDerivedFromDataToken,
-                const mc_EDCToken_t *EDCToken,
-                const _mongocrypt_buffer_t *v)
-IMPL_TOKEN_NEW (mc_EDCDerivedFromDataToken, mc_EDCToken_get (EDCToken), v)
-
-DEF_TOKEN_TYPE (mc_ESCDerivedFromDataToken,
-                const mc_ESCToken_t *ESCToken,
-                const _mongocrypt_buffer_t *v)
-IMPL_TOKEN_NEW (mc_ESCDerivedFromDataToken, mc_ESCToken_get (ESCToken), v)
-
-DEF_TOKEN_TYPE (mc_ECCDerivedFromDataToken,
-                const mc_ECCToken_t *ECCToken,
-                const _mongocrypt_buffer_t *v)
-IMPL_TOKEN_NEW (mc_ECCDerivedFromDataToken, mc_ECCToken_get (ECCToken), v)
-
-DEF_TOKEN_TYPE (mc_EDCDerivedFromDataTokenAndCounter,
-                const mc_EDCDerivedFromDataToken_t *EDCDerivedFromDataToken,
-                uint64_t u)
-IMPL_TOKEN_NEW_CONST (mc_EDCDerivedFromDataTokenAndCounter,
-                      mc_EDCDerivedFromDataToken_get (EDCDerivedFromDataToken),
-                      u)
-
-DEF_TOKEN_TYPE (mc_ESCDerivedFromDataTokenAndCounter,
-                const mc_ESCDerivedFromDataToken_t *ESCDerivedFromDataToken,
-                uint64_t u)
-IMPL_TOKEN_NEW_CONST (mc_ESCDerivedFromDataTokenAndCounter,
-                      mc_ESCDerivedFromDataToken_get (ESCDerivedFromDataToken),
-                      u)
-
-DEF_TOKEN_TYPE (mc_ECCDerivedFromDataTokenAndCounter,
-                const mc_ECCDerivedFromDataToken_t *ECCDerivedFromDataToken,
-                uint64_t u)
-IMPL_TOKEN_NEW_CONST (mc_ECCDerivedFromDataTokenAndCounter,
-                      mc_ECCDerivedFromDataToken_get (ECCDerivedFromDataToken),
-                      u)
+#define IMPL_TOKEN_NEW_CONST(Name, Key, Arg)                                                                           \
+    {                                                                                                                  \
+        _mongocrypt_buffer_t to_hash;                                                                                  \
+        _mongocrypt_buffer_copy_from_uint64_le(&to_hash, Arg);                                                         \
+        IMPL_TOKEN_NEW_1(Name, Key, &to_hash, _mongocrypt_buffer_cleanup(&to_hash))                                    \
+    }
+
+DEF_TOKEN_TYPE(mc_CollectionsLevel1Token, const _mongocrypt_buffer_t *RootKey)
+IMPL_TOKEN_NEW_CONST(mc_CollectionsLevel1Token, RootKey, 1)
+
+DEF_TOKEN_TYPE(mc_EDCToken, const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_EDCToken, mc_CollectionsLevel1Token_get(CollectionsLevel1Token), 1)
+
+DEF_TOKEN_TYPE(mc_ESCToken, const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ESCToken, mc_CollectionsLevel1Token_get(CollectionsLevel1Token), 2)
+
+DEF_TOKEN_TYPE(mc_ECCToken, const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ECCToken, mc_CollectionsLevel1Token_get(CollectionsLevel1Token), 3)
+
+DEF_TOKEN_TYPE(mc_ECOCToken, const mc_CollectionsLevel1Token_t *CollectionsLevel1Token)
+IMPL_TOKEN_NEW_CONST(mc_ECOCToken, mc_CollectionsLevel1Token_get(CollectionsLevel1Token), 4)
+
+DEF_TOKEN_TYPE(mc_EDCDerivedFromDataToken, const mc_EDCToken_t *EDCToken, const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_EDCDerivedFromDataToken, mc_EDCToken_get(EDCToken), v)
+
+DEF_TOKEN_TYPE(mc_ESCDerivedFromDataToken, const mc_ESCToken_t *ESCToken, const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ESCDerivedFromDataToken, mc_ESCToken_get(ESCToken), v)
+
+DEF_TOKEN_TYPE(mc_ECCDerivedFromDataToken, const mc_ECCToken_t *ECCToken, const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ECCDerivedFromDataToken, mc_ECCToken_get(ECCToken), v)
+
+DEF_TOKEN_TYPE(mc_EDCTwiceDerivedToken,
+               const mc_EDCDerivedFromDataTokenAndContentionFactor_t *EDCDerivedFromDataTokenAndContentionFactor)
+IMPL_TOKEN_NEW_CONST(mc_EDCTwiceDerivedToken,
+                     mc_EDCDerivedFromDataTokenAndContentionFactor_get(EDCDerivedFromDataTokenAndContentionFactor),
+                     1)
+
+DEF_TOKEN_TYPE(mc_ESCTwiceDerivedTagToken,
+               const mc_ESCDerivedFromDataTokenAndContentionFactor_t *ESCDerivedFromDataTokenAndContentionFactor)
+IMPL_TOKEN_NEW_CONST(mc_ESCTwiceDerivedTagToken,
+                     mc_ESCDerivedFromDataTokenAndContentionFactor_get(ESCDerivedFromDataTokenAndContentionFactor),
+                     1)
+DEF_TOKEN_TYPE(mc_ESCTwiceDerivedValueToken,
+               const mc_ESCDerivedFromDataTokenAndContentionFactor_t *ESCDerivedFromDataTokenAndContentionFactor)
+IMPL_TOKEN_NEW_CONST(mc_ESCTwiceDerivedValueToken,
+                     mc_ESCDerivedFromDataTokenAndContentionFactor_get(ESCDerivedFromDataTokenAndContentionFactor),
+                     2)
+
+DEF_TOKEN_TYPE(mc_ServerDataEncryptionLevel1Token, const _mongocrypt_buffer_t *RootKey)
+IMPL_TOKEN_NEW_CONST(mc_ServerDataEncryptionLevel1Token, RootKey, 3)
+
+DEF_TOKEN_TYPE(mc_EDCDerivedFromDataTokenAndContentionFactor,
+               const mc_EDCDerivedFromDataToken_t *EDCDerivedFromDataToken,
+               uint64_t u)
+IMPL_TOKEN_NEW_CONST(mc_EDCDerivedFromDataTokenAndContentionFactor,
+                     mc_EDCDerivedFromDataToken_get(EDCDerivedFromDataToken),
+                     u)
+
+DEF_TOKEN_TYPE(mc_ESCDerivedFromDataTokenAndContentionFactor,
+               const mc_ESCDerivedFromDataToken_t *ESCDerivedFromDataToken,
+               uint64_t u)
+IMPL_TOKEN_NEW_CONST(mc_ESCDerivedFromDataTokenAndContentionFactor,
+                     mc_ESCDerivedFromDataToken_get(ESCDerivedFromDataToken),
+                     u)
+
+DEF_TOKEN_TYPE(mc_ECCDerivedFromDataTokenAndContentionFactor,
+               const mc_ECCDerivedFromDataToken_t *ECCDerivedFromDataToken,
+               uint64_t u)
+IMPL_TOKEN_NEW_CONST(mc_ECCDerivedFromDataTokenAndContentionFactor,
+                     mc_ECCDerivedFromDataToken_get(ECCDerivedFromDataToken),
+                     u)
+
+/* FLE2v2 */
+
+DEF_TOKEN_TYPE(mc_ServerTokenDerivationLevel1Token, const _mongocrypt_buffer_t *RootKey)
+IMPL_TOKEN_NEW_CONST(mc_ServerTokenDerivationLevel1Token, RootKey, 2)
+
+DEF_TOKEN_TYPE(mc_ServerDerivedFromDataToken,
+               const mc_ServerTokenDerivationLevel1Token_t *ServerTokenDerivationToken,
+               const _mongocrypt_buffer_t *v)
+IMPL_TOKEN_NEW(mc_ServerDerivedFromDataToken, mc_ServerTokenDerivationLevel1Token_get(ServerTokenDerivationToken), v)
+
+DEF_TOKEN_TYPE(mc_ServerCountAndContentionFactorEncryptionToken,
+               const mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken)
+IMPL_TOKEN_NEW_CONST(mc_ServerCountAndContentionFactorEncryptionToken,
+                     mc_ServerDerivedFromDataToken_get(serverDerivedFromDataToken),
+                     1)
+
+DEF_TOKEN_TYPE(mc_ServerZerosEncryptionToken, const mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken)
+IMPL_TOKEN_NEW_CONST(mc_ServerZerosEncryptionToken, mc_ServerDerivedFromDataToken_get(serverDerivedFromDataToken), 2)
+
+// d = 17 bytes of 0, AnchorPaddingTokenRoot = HMAC(ESCToken, d)
+#define ANCHOR_PADDING_TOKEN_D_LENGTH 17
+const uint8_t mc_AnchorPaddingTokenDValue[ANCHOR_PADDING_TOKEN_D_LENGTH] =
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+DEF_TOKEN_TYPE(mc_AnchorPaddingTokenRoot, const mc_ESCToken_t *ESCToken) {
+    _mongocrypt_buffer_t to_hash;
+    if (!_mongocrypt_buffer_copy_from_data_and_size(&to_hash,
+                                                    mc_AnchorPaddingTokenDValue,
+                                                    ANCHOR_PADDING_TOKEN_D_LENGTH)) {
+        return NULL;
+    }
+    IMPL_TOKEN_NEW_1(mc_AnchorPaddingTokenRoot,
+                     mc_ESCToken_get(ESCToken),
+                     &to_hash,
+                     _mongocrypt_buffer_cleanup(&to_hash))
+}
+
+#undef ANCHOR_PADDING_TOKEN_D_LENGTH

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

@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+#ifndef MONGOCRYPT_WRITER_PRIVATE_H
+#define MONGOCRYPT_WRITER_PRIVATE_H
+
+#include "mongocrypt-buffer-private.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * A non-owning forward-only cursor api to write to a buffer.
+ *
+ * Tracks length of buffer and current position of buffer. parser_name is
+ * typically __FUNCTION__ to provide useful error messages automatically.
+ *
+ * All numbers are written as little endian.
+ */
+
+struct _mc_writer_t {
+    uint8_t *ptr;
+    uint64_t pos;
+    uint64_t len;
+
+    const char *parser_name;
+};
+
+typedef struct _mc_writer_t mc_writer_t;
+
+void mc_writer_init(mc_writer_t *writer, uint8_t *ptr, uint64_t len, const char *parser_name);
+
+void mc_writer_init_from_buffer(mc_writer_t *writer, _mongocrypt_buffer_t *buf, const char *parser_name);
+
+mc_writer_t *mc_writer_new(uint8_t *ptr, uint64_t len, const char *parser_name);
+
+void mc_writer_destroy(mc_writer_t *writer);
+
+bool mc_writer_write_u8(mc_writer_t *writer, const uint8_t value, mongocrypt_status_t *status);
+
+bool mc_writer_write_u32(mc_writer_t *writer, const uint32_t value, mongocrypt_status_t *status);
+
+bool mc_writer_write_u64(mc_writer_t *writer, const uint64_t value, mongocrypt_status_t *status);
+
+bool mc_writer_write_buffer(mc_writer_t *writer,
+                            const _mongocrypt_buffer_t *buf,
+                            uint64_t length,
+                            mongocrypt_status_t *status);
+
+bool mc_writer_write_uuid_buffer(mc_writer_t *writer, const _mongocrypt_buffer_t *buf, mongocrypt_status_t *status);
+
+bool mc_writer_write_prfblock_buffer(mc_writer_t *writer, const _mongocrypt_buffer_t *buf, mongocrypt_status_t *status);
+
+#endif /* MONGOCRYPT_READER_PRIVATE_H */

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

@@ -0,0 +1,141 @@
+/*
+ * 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 "mongocrypt-private.h"
+
+#include "mc-writer-private.h"
+
+#define CHECK_AND_RETURN(x)                                                                                            \
+    if (!(x)) {                                                                                                        \
+        return false;                                                                                                  \
+    }
+
+#define CHECK_REMAINING_BUFFER_AND_RET(write_size)                                                                     \
+    if ((write_size) > writer->len - writer->pos) {                                                                    \
+        CLIENT_ERR("%s expected at most %" PRIu64 " bytes, got: %" PRIu64,                                             \
+                   writer->parser_name,                                                                                \
+                   (writer->len - writer->pos),                                                                        \
+                   (uint64_t)(write_size));                                                                            \
+        return false;                                                                                                  \
+    }
+
+void mc_writer_init(mc_writer_t *writer, uint8_t *ptr, uint64_t len, const char *parser_name) {
+    BSON_ASSERT_PARAM(writer);
+    BSON_ASSERT_PARAM(ptr);
+    BSON_ASSERT_PARAM(parser_name);
+
+    *writer = (mc_writer_t){.pos = 0u, .ptr = ptr, .len = len, .parser_name = parser_name};
+}
+
+void mc_writer_init_from_buffer(mc_writer_t *writer, _mongocrypt_buffer_t *buf, const char *parser_name) {
+    BSON_ASSERT_PARAM(writer);
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(parser_name);
+
+    mc_writer_init(writer, buf->data, buf->len, parser_name);
+}
+
+mc_writer_t *mc_writer_new(uint8_t *ptr, uint64_t len, const char *parser_name) {
+    BSON_ASSERT_PARAM(ptr);
+    BSON_ASSERT_PARAM(parser_name);
+
+    mc_writer_t *writer = bson_malloc(sizeof(mc_writer_t));
+    mc_writer_init(writer, ptr, len, parser_name);
+    return writer;
+}
+
+void mc_writer_destroy(mc_writer_t *writer) {
+    bson_free(writer);
+}
+
+bool mc_writer_write_u8(mc_writer_t *writer, const uint8_t value, mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(writer);
+    CHECK_REMAINING_BUFFER_AND_RET(sizeof(uint8_t));
+    memcpy(writer->ptr + writer->pos, &value, sizeof(uint8_t));
+
+    writer->pos += sizeof(uint8_t);
+    return true;
+}
+
+bool mc_writer_write_u32(mc_writer_t *writer, const uint32_t value, mongocrypt_status_t *status) {
+    CHECK_REMAINING_BUFFER_AND_RET(sizeof(uint32_t));
+
+    uint32_t temp = BSON_UINT32_TO_LE(value);
+    memcpy(writer->ptr + writer->pos, &temp, sizeof(uint32_t));
+    writer->pos += sizeof(uint32_t);
+
+    return true;
+}
+
+bool mc_writer_write_u64(mc_writer_t *writer, const uint64_t value, mongocrypt_status_t *status) {
+    CHECK_REMAINING_BUFFER_AND_RET(sizeof(uint64_t));
+
+    uint64_t temp = BSON_UINT64_TO_LE(value);
+    memcpy(writer->ptr + writer->pos, &temp, sizeof(uint64_t));
+    writer->pos += sizeof(uint64_t);
+
+    return true;
+}
+
+bool mc_writer_write_buffer(mc_writer_t *writer,
+                            const _mongocrypt_buffer_t *buf,
+                            uint64_t length,
+                            mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(writer);
+    BSON_ASSERT_PARAM(buf);
+
+    if (length > buf->len) {
+        CLIENT_ERR("%s cannot write %" PRIu64 " bytes from buffer with length %" PRIu32,
+                   writer->parser_name,
+                   length,
+                   buf->len);
+
+        return false;
+    }
+
+    CHECK_REMAINING_BUFFER_AND_RET(length);
+
+    if (length > SIZE_MAX) {
+        CLIENT_ERR("%s failed to copy "
+                   "data of length %" PRIu64,
+                   writer->parser_name,
+                   length);
+        return false;
+    }
+
+    memcpy(writer->ptr + writer->pos, buf->data, (size_t)length);
+    writer->pos += length;
+
+    return true;
+}
+
+bool mc_writer_write_uuid_buffer(mc_writer_t *writer, const _mongocrypt_buffer_t *buf, mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(writer);
+    BSON_ASSERT_PARAM(buf);
+
+    CHECK_AND_RETURN(mc_writer_write_buffer(writer, buf, UUID_LEN, status));
+    return true;
+}
+
+bool mc_writer_write_prfblock_buffer(mc_writer_t *writer,
+                                     const _mongocrypt_buffer_t *buf,
+                                     mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(writer);
+    BSON_ASSERT_PARAM(buf);
+
+    CHECK_AND_RETURN(mc_writer_write_buffer(writer, buf, PRF_LEN, status));
+    return true;
+}

data/ext/libmongocrypt/libmongocrypt/src/mlib/check.hpp

@@ -1,74 +1,58 @@
 #ifndef MLIB_CHECK_HPP_INCLUDED
 #define MLIB_CHECK_HPP_INCLUDED
 
-#include <iostream>
 #include <cstdio>
+#include <iostream>
 #include <string>
 
-namespace mlib
-{
-namespace detail
-{
+namespace mlib {
+namespace detail {
 struct check_info {
-   const char *filename;
-   int line;
-   const char *expr;
+    const char *filename;
+    int line;
+    const char *expr;
 };
 
-struct nil {
-};
+struct nil {};
 
 template <typename Left> struct bound_lhs {
-   check_info info;
-   Left value;
+    check_info info;
+    Left value;
 
-#define DEFOP(Oper)                                                         \
-   template <typename Rhs> nil operator Oper (Rhs rhs) const noexcept       \
-   {                                                                        \
-      if (value Oper rhs) {                                                 \
-         return {};                                                         \
-      }                                                                     \
-      std::fprintf (stderr,                                                 \
-                    "%s:%d: CHECK( %s ) failed!\n",                         \
-                    info.filename,                                          \
-                    info.line,                                              \
-                    info.expr);                                             \
-      std::cerr << "Expanded expression: " << value << " " #Oper " " << rhs \
-                << '\n';                                                    \
-      std::exit (2);                                                        \
-   }
-   DEFOP (==)
-   DEFOP (!=)
-   DEFOP (<)
-   DEFOP (<=)
-   DEFOP (>)
-   DEFOP (>=)
+#define DEFOP(Oper)                                                                                                    \
+    template <typename Rhs> nil operator Oper(Rhs rhs) const noexcept {                                                \
+        if (value Oper rhs) {                                                                                          \
+            return {};                                                                                                 \
+        }                                                                                                              \
+        std::fprintf(stderr, "%s:%d: CHECK( %s ) failed!\n", info.filename, info.line, info.expr);                     \
+        std::cerr << "Expanded expression: " << value << " " #Oper " " << rhs << '\n';                                 \
+        std::exit(2);                                                                                                  \
+    }
+    DEFOP(==)
+    DEFOP(!=)
+    DEFOP(<)
+    DEFOP(<=)
+    DEFOP(>)
+    DEFOP(>=)
 #undef DEFOP
 };
 
 struct check_magic {
-   check_info info;
+    check_info info;
 
-   template <typename Oper>
-   bound_lhs<Oper>
-   operator->*(Oper op)
-   {
-      return bound_lhs<Oper>{info, op};
-   }
+    template <typename Oper> bound_lhs<Oper> operator->*(Oper op) {
+        return bound_lhs<Oper>{info, op};
+    }
 };
 
 struct check_consume {
-   void
-   operator= (nil)
-   {
-   }
+    void operator=(nil) {
+    }
 
-   void
-   operator= (bound_lhs<bool> const &l)
-   {
-      // Invoke the test for truthiness:
-      (void) (l == true);
-   }
+    void operator=(const bound_lhs<bool> &l) {
+        // Invoke the test for truthiness:
+        (void)(l == true);
+    }
 };
 
 /**
@@ -77,11 +61,9 @@ struct check_consume {
  * Only supports simple comparison binary expressions, and plain boolean
  * expressions
  */
-#define MLIB_CHECK(Cond)                                        \
-   ::mlib::detail::check_consume{} =                            \
-      ::mlib::detail::check_magic{                              \
-         ::mlib::detail::check_info{__FILE__, __LINE__, #Cond}} \
-         ->*Cond
+#define MLIB_CHECK(Cond)                                                                                               \
+    ::mlib::detail::check_consume{} =                                                                                  \
+        ::mlib::detail::check_magic{::mlib::detail::check_info{__FILE__, __LINE__, #Cond}}->*Cond
 
 } // namespace detail
 } // namespace mlib