libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

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

@@ -0,0 +1,235 @@
+/*
+ * 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-reader-private.h"
+
+#define CHECK_AND_RETURN(x) \
+   if (!(x)) {              \
+      return false;         \
+   }
+
+#define CHECK_REMAINING_BUFFER_AND_RET(read_size)        \
+   if ((reader->pos + (read_size)) > reader->len) {      \
+      CLIENT_ERR ("%s expected byte "                    \
+                  "length >= %" PRIu64 " got: %" PRIu64, \
+                  reader->parser_name,                   \
+                  reader->pos + (read_size),             \
+                  reader->len);                          \
+      return false;                                      \
+   }
+
+void
+mc_reader_init (mc_reader_t *reader,
+                const uint8_t *ptr,
+                uint64_t len,
+                const char *parser_name)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (ptr);
+   BSON_ASSERT_PARAM (parser_name);
+
+   *reader = (mc_reader_t){
+      .pos = 0u, .ptr = ptr, .len = len, .parser_name = parser_name};
+}
+
+void
+mc_reader_init_from_buffer (mc_reader_t *reader,
+                            const _mongocrypt_buffer_t *buf,
+                            const char *parser_name)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (buf);
+   BSON_ASSERT_PARAM (parser_name);
+
+   mc_reader_init (reader, buf->data, buf->len, parser_name);
+}
+
+mc_reader_t *
+mc_reader_new (const uint8_t *ptr, uint64_t len, const char *parser_name)
+{
+   BSON_ASSERT_PARAM (ptr);
+   BSON_ASSERT_PARAM (parser_name);
+
+   mc_reader_t *reader = bson_malloc (sizeof (mc_reader_t));
+   mc_reader_init (reader, ptr, len, parser_name);
+   return reader;
+}
+
+void
+mc_reader_destroy (mc_reader_t *reader)
+{
+   bson_free (reader);
+}
+
+bool
+mc_reader_has_data (const mc_reader_t *reader)
+{
+   BSON_ASSERT_PARAM (reader);
+
+   return reader->pos < reader->len;
+}
+
+uint64_t
+mc_reader_get_remaining_length (const mc_reader_t *reader)
+{
+   BSON_ASSERT_PARAM (reader);
+
+   return reader->len - reader->pos;
+}
+
+uint64_t
+mc_reader_get_consumed_length (const mc_reader_t *reader)
+{
+   BSON_ASSERT_PARAM (reader);
+
+   return reader->pos;
+}
+
+bool
+mc_reader_read_u8 (mc_reader_t *reader,
+                   uint8_t *value,
+                   mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (value);
+
+   CHECK_REMAINING_BUFFER_AND_RET (sizeof (uint8_t));
+
+   *value = *(reader->ptr + reader->pos);
+   reader->pos += sizeof (uint8_t);
+
+   return true;
+}
+
+bool
+mc_reader_read_u32 (mc_reader_t *reader,
+                    uint32_t *value,
+                    mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (value);
+
+   CHECK_REMAINING_BUFFER_AND_RET (sizeof (uint32_t));
+
+   uint32_t temp;
+   memcpy (&temp, reader->ptr + reader->pos, sizeof (uint32_t));
+   *value = BSON_UINT32_FROM_LE (temp);
+   reader->pos += sizeof (uint32_t);
+
+   return true;
+}
+
+bool
+mc_reader_read_u64 (mc_reader_t *reader,
+                    uint64_t *value,
+                    mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (value);
+
+   CHECK_REMAINING_BUFFER_AND_RET (sizeof (uint64_t));
+
+   uint64_t temp;
+   memcpy (&temp, reader->ptr + reader->pos, sizeof (uint64_t));
+   *value = BSON_UINT64_FROM_LE (temp);
+   reader->pos += sizeof (uint64_t);
+
+   return true;
+}
+
+bool
+mc_reader_read_bytes (mc_reader_t *reader,
+                      const uint8_t **ptr,
+                      uint64_t length,
+                      mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (ptr);
+
+   CHECK_REMAINING_BUFFER_AND_RET (length);
+
+   *ptr = reader->ptr + reader->pos;
+   reader->pos += length;
+
+   return true;
+}
+
+bool
+mc_reader_read_buffer (mc_reader_t *reader,
+                       _mongocrypt_buffer_t *buf,
+                       uint64_t length,
+                       mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (buf);
+
+   const uint8_t *ptr;
+   CHECK_AND_RETURN (mc_reader_read_bytes (reader, &ptr, length, status));
+
+   if (length > SIZE_MAX || !_mongocrypt_buffer_copy_from_data_and_size (
+                               buf, ptr, (size_t) length)) {
+      CLIENT_ERR ("%s failed to copy "
+                  "data of length %" PRIu64,
+                  reader->parser_name,
+                  length);
+      return false;
+   }
+
+   return true;
+}
+
+
+bool
+mc_reader_read_uuid_buffer (mc_reader_t *reader,
+                            _mongocrypt_buffer_t *buf,
+                            mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (buf);
+
+   CHECK_AND_RETURN (mc_reader_read_buffer (reader, buf, 16, status));
+   buf->subtype = BSON_SUBTYPE_UUID;
+
+   return true;
+}
+
+bool
+mc_reader_read_prfblock_buffer (mc_reader_t *reader,
+                                _mongocrypt_buffer_t *buf,
+                                mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (buf);
+
+   CHECK_AND_RETURN (mc_reader_read_buffer (reader, buf, 32, status));
+   buf->subtype = BSON_SUBTYPE_ENCRYPTED;
+
+   return true;
+}
+
+bool
+mc_reader_read_buffer_to_end (mc_reader_t *reader,
+                              _mongocrypt_buffer_t *buf,
+                              mongocrypt_status_t *status)
+{
+   BSON_ASSERT_PARAM (reader);
+   BSON_ASSERT_PARAM (buf);
+
+   uint64_t length = reader->len - reader->pos;
+   return mc_reader_read_buffer (reader, buf, length, status);
+}

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

@@ -0,0 +1,118 @@
+/*
+ * 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_TOKENS_PRIVATE_H
+#define MONGOCRYPT_TOKENS_PRIVATE_H
+
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-crypto-private.h"
+
+/*
+ * ======================= Begin: FLE 2 Token Reference =======================
+ *
+ * v is a BSON value. It is the bytes after "e_name" in "element" in
+ * https://bsonspec.org/spec.html.
+ * u is a "contention factor" counter. It is a uint64_t.
+ * HMAC is the HMAC-SHA-256 function.
+ * Integers are represented as uint64_t in little-endian.
+ *
+ * CollectionsLevel1Token = HMAC(RootKey, 1)
+ * ServerDataEncryptionLevel1Token = HMAC(RootKey, 3)
+ *
+ * EDCToken = HMAC(CollectionsLevel1Token, 1)
+ * ESCToken = HMAC(CollectionsLevel1Token, 2)
+ * ECCToken = HMAC(CollectionsLevel1Token, 3)
+ * ECOCToken = HMAC(CollectionsLevel1Token, 4)
+ *
+ * EDCDerivedFromDataToken = HMAC(EDCToken, v)
+ * ESCDerivedFromDataToken = HMAC(ESCToken, v)
+ * ECCDerivedFromDataToken = HMAC(ECCToken, v)
+ *
+ * EDCDerivedFromDataTokenAndCounter = HMAC(EDCDerivedFromDataToken, u)
+ * ESCDerivedFromDataTokenAndCounter = HMAC(ESCDerivedFromDataToken, u)
+ * ECCDerivedFromDataTokenAndCounter = HMAC(ECCDerivedFromDataToken, u)
+ * ======================== End: FLE 2 Token Reference ========================
+ */
+
+// TODO: replace `CONCAT` with `BSON_CONCAT` after libbson dependency is
+// upgraded to 1.20.0 or higher.
+#ifndef CONCAT
+#define CONCAT_1(a, b) a##b
+#define CONCAT(a, b) CONCAT_1 (a, b)
+#endif
+// TODO: replace `CONCAT3` with `BSON_CONCAT3` after libbson dependency is
+// upgraded to 1.20.0 or higher.
+#ifndef CONCAT3
+#define CONCAT3(a, b, c) CONCAT (a, CONCAT (b, c))
+#endif
+
+/// Declare a token type named 'Name', with constructor parameters given by the
+/// remaining arguments. Each constructor will also have the implicit first
+/// argument '_mongocrypt_crypto_t* crypto' and a final argument
+/// 'mongocrypt_status_t* status'
+#define DECL_TOKEN_TYPE(Name, ...) \
+   DECL_TOKEN_TYPE_1 (Name, CONCAT (Name, _t), __VA_ARGS__)
+
+#define DECL_TOKEN_TYPE_1(Prefix, T, ...)                                    \
+   /* Opaque typedef the struct */                                           \
+   typedef struct T T;                                                       \
+   /* Data-getter */                                                         \
+   extern const _mongocrypt_buffer_t *CONCAT (Prefix, _get) (const T *t);    \
+   /* Destructor */                                                          \
+   extern void CONCAT (Prefix, _destroy) (T * t);                            \
+   /* Constructor for server to create tokens from raw buffer */             \
+   extern T *CONCAT (Prefix, _new_from_buffer) (_mongocrypt_buffer_t * buf); \
+   /* Constructor. Parameter list given as variadic args */                  \
+   extern T *CONCAT (Prefix, _new) (_mongocrypt_crypto_t * crypto,           \
+                                    __VA_ARGS__,                             \
+                                    mongocrypt_status_t * status)
+
+DECL_TOKEN_TYPE (mc_CollectionsLevel1Token, const _mongocrypt_buffer_t *);
+DECL_TOKEN_TYPE (mc_ServerDataEncryptionLevel1Token,
+                 const _mongocrypt_buffer_t *);
+DECL_TOKEN_TYPE (mc_EDCToken,
+                 const mc_CollectionsLevel1Token_t *CollectionsLevel1Token);
+DECL_TOKEN_TYPE (mc_ESCToken,
+                 const mc_CollectionsLevel1Token_t *CollectionsLevel1Token);
+DECL_TOKEN_TYPE (mc_ECCToken,
+                 const mc_CollectionsLevel1Token_t *CollectionsLevel1Token);
+DECL_TOKEN_TYPE (mc_ECOCToken,
+                 const mc_CollectionsLevel1Token_t *CollectionsLevel1Token);
+DECL_TOKEN_TYPE (mc_EDCDerivedFromDataToken,
+                 const mc_EDCToken_t *EDCToken,
+                 const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE (mc_ECCDerivedFromDatatoken,
+                 const mc_ECCToken_t *ECCToken,
+                 const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE (mc_ESCDerivedFromDataToken,
+                 const mc_ESCToken_t *ESCToken,
+                 const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE (mc_ECCDerivedFromDataToken,
+                 const mc_ECCToken_t *ECCToken,
+                 const _mongocrypt_buffer_t *v);
+DECL_TOKEN_TYPE (mc_EDCDerivedFromDataTokenAndCounter,
+                 const mc_EDCDerivedFromDataToken_t *EDCDerivedFromDataToken,
+                 uint64_t u);
+DECL_TOKEN_TYPE (mc_ESCDerivedFromDataTokenAndCounter,
+                 const mc_ESCDerivedFromDataToken_t *ESCDerivedFromDataToken,
+                 uint64_t u);
+DECL_TOKEN_TYPE (mc_ECCDerivedFromDataTokenAndCounter,
+                 const mc_ECCDerivedFromDataToken_t *ECCDerivedFromDataToken,
+                 uint64_t u);
+
+#undef DECL_TOKEN_TYPE
+#undef DECL_TOKEN_TYPE_1
+
+#endif /* MONGOCRYPT_TOKENS_PRIVATE_H */

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

@@ -0,0 +1,151 @@
+/*
+ * 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-tokens-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 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 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)

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

@@ -0,0 +1,89 @@
+#ifndef MLIB_CHECK_HPP_INCLUDED
+#define MLIB_CHECK_HPP_INCLUDED
+
+#include <iostream>
+#include <cstdio>
+#include <string>
+
+namespace mlib
+{
+namespace detail
+{
+struct check_info {
+   const char *filename;
+   int line;
+   const char *expr;
+};
+
+struct nil {
+};
+
+template <typename Left> struct bound_lhs {
+   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 (>=)
+#undef DEFOP
+};
+
+struct check_magic {
+   check_info info;
+
+   template <typename Oper>
+   bound_lhs<Oper>
+   operator->*(Oper op)
+   {
+      return bound_lhs<Oper>{info, op};
+   }
+};
+
+struct check_consume {
+   void
+   operator= (nil)
+   {
+   }
+
+   void
+   operator= (bound_lhs<bool> const &l)
+   {
+      // Invoke the test for truthiness:
+      (void) (l == true);
+   }
+};
+
+/**
+ * @brief Create an assertion that prints the expanded expression upon failure.
+ *
+ * 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
+
+} // namespace detail
+} // namespace mlib
+
+#endif // MLIB_CHECK_HPP_INCLUDED

data/ext/libmongocrypt/libmongocrypt/src/mlib/endian.h

@@ -0,0 +1,42 @@
+#ifndef MLIB_ENDIAN_H_INCLUDED
+#define MLIB_ENDIAN_H_INCLUDED
+
+#ifdef __has_include
+// Some platforms require including other headers that will define the necessary
+// macros
+#if __has_include(<endian.h>)
+// This may recursively include our own file in a pathological case, but that
+// won't cause an issue. The default will include the system's version instead:
+#include <endian.h>
+#endif
+#if __has_include(<sys/param.h>)
+#include <sys/param.h>
+#endif
+#endif
+
+#include "./macros.h"
+
+enum mlib_endian_kind {
+#ifdef _MSC_VER // MSVC only targets little-endian arches at the moment
+   MLIB_ENDIAN_LITTLE = 1234,
+   MLIB_ENDIAN_BIG = 4321,
+   MLIB_ENDIAN_NATIVE = MLIB_ENDIAN_LITTLE,
+#elif defined(__BYTE_ORDER__) // Commonly built-in defined in newer compilers
+   MLIB_ENDIAN_LITTLE = __ORDER_LITTLE_ENDIAN__,
+   MLIB_ENDIAN_BIG = __ORDER_BIG_ENDIAN__,
+   MLIB_ENDIAN_NATIVE = __BYTE_ORDER__,
+#elif defined(__BYTE_ORDER)   // Common in <sys/param.h> or <endian.h>
+   MLIB_ENDIAN_LITTLE = __LITTLE_ENDIAN,
+   MLIB_ENDIAN_BIG = __BIG_ENDIAN,
+   MLIB_ENDIAN_NATIVE = __BYTE_ORDER,
+#else
+#error This compiler does not define an endianness macro.
+#endif
+};
+
+enum {
+   MLIB_IS_LITTLE_ENDIAN = MLIB_ENDIAN_NATIVE == MLIB_ENDIAN_LITTLE,
+   MLIB_IS_BIG_ENDIAN = MLIB_ENDIAN_NATIVE == MLIB_ENDIAN_BIG,
+};
+
+#endif // MLIB_ENDIAN_H_INCLUDED

data/ext/libmongocrypt/libmongocrypt/src/mlib/error.h

@@ -0,0 +1,59 @@
+#ifndef MLIB_ERROR_PRIVATE_H
+#define MLIB_ERROR_PRIVATE_H
+
+#include "./user-check.h"
+
+#include "./str.h"
+
+#ifdef _WIN32
+#include "./windows-lean.h"
+#else
+#include <errno.h>
+#endif
+
+/**
+ * @brief Obtain a string containing an error message corresponding to an error
+ * code from the host platform.
+ *
+ * @param errn An error code for the system. (e.g. GetLastError() on Windows)
+ * @return mstr A new string containing the resulting error. Must be freed with
+ * @ref mstr_free().
+ */
+static inline mstr
+merror_system_error_string (int errn)
+{
+#ifdef _WIN32
+   wchar_t *wbuffer = NULL;
+   DWORD slen = FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                   FORMAT_MESSAGE_FROM_SYSTEM |
+                                   FORMAT_MESSAGE_IGNORE_INSERTS,
+                                NULL,
+                                (DWORD) errn,
+                                0,
+                                (LPWSTR) &wbuffer,
+                                0,
+                                NULL);
+   if (slen == 0) {
+      return mstr_copy_cstr (
+         "[Error while getting error string from FormatMessageW()]");
+   }
+   mstr_narrow_result narrow = mstr_win32_narrow (wbuffer);
+   LocalFree (wbuffer);
+   assert (narrow.error == 0);
+   // Messages from FormatMessage contain an additional CR+LF
+   if (mstr_ends_with (narrow.string.view, mstrv_lit ("\r\n"))) {
+      mstr_inplace_remove_suffix (&narrow.string, 2);
+   }
+   return narrow.string;
+#else
+   errno = 0;
+   char *const str = strerror (errn);
+   if (errno) {
+      return mstr_copy_cstr (
+         "[Error while getting error string from strerror()]");
+   }
+   return mstr_copy_cstr (str);
+#endif
+}
+
+#endif // MLIB_ERROR_PRIVATE_H