libmongocrypt-helper 1.7.0.0.1001 → 1.7.4.0.1000

data/ext/libmongocrypt/libmongocrypt/src/mlib/str.test.c

@@ -0,0 +1,137 @@
+#include "./str.h"
+
+#define CHECK(Expr)                                   \
+   ((Expr) ? 0                                        \
+           : ((fprintf (stderr,                       \
+                        "%s:%d: Check '%s' failed\n", \
+                        __FILE__,                     \
+                        __LINE__,                     \
+                        #Expr),                       \
+               abort ()),                             \
+              0))
+
+#define test_predicate(Bool, Left, Pred, Right) \
+   MSTR_ASSERT (Bool, mstrv_lit (Left), Pred, mstrv_lit (Right))
+
+int
+main ()
+{
+   // Test the null-initializers:
+   mstr str = MSTR_NULL;
+   mstr_view null_view = MSTRV_NULL;
+   (void) null_view;
+
+   str = mstr_copy_cstr ("foo");
+   CHECK (str.len == 3);
+   MSTR_ASSERT_EQ (str.view, mstrv_lit ("foo"));
+   CHECK (strncmp (str.data, "foo", 3) == 0);
+
+   mstr_inplace_append (&str, mstrv_lit ("bar"));
+   MSTR_ASSERT_EQ (str.view, mstrv_lit ("foobar"));
+
+   mstr_free (str);
+
+   str = mstr_copy_cstr ("foobar");
+   mstr_inplace_trunc (&str, 3);
+   MSTR_ASSERT_EQ (str.view, mstrv_lit ("foo"));
+   mstr_free (str);
+
+   int pos = mstr_find (mstrv_lit ("foo"), mstrv_lit ("bar"));
+   CHECK (pos == -1);
+
+   pos = mstr_find (mstrv_lit ("foo"), mstrv_lit ("barbaz"));
+   CHECK (pos == -1);
+
+   pos = mstr_find (mstrv_lit ("foobar"), mstrv_lit ("bar"));
+   CHECK (pos == 3);
+
+   // Simple replacement:
+   str = mstr_copy_cstr ("foo bar baz");
+   mstr str2 = mstr_replace (str.view, mstrv_lit ("bar"), mstrv_lit ("foo"));
+   MSTR_ASSERT_EQ (str2.view, mstrv_lit ("foo foo baz"));
+   mstr_free (str);
+
+   // Replace multiple instances:
+   mstr_inplace_replace (&str2, mstrv_lit ("foo"), mstrv_lit ("baz"));
+   MSTR_ASSERT_EQ (str2.view, mstrv_lit ("baz baz baz"));
+
+   // Replace with a string containing the needle:
+   mstr_inplace_replace (&str2, mstrv_lit ("baz"), mstrv_lit ("foo bar baz"));
+   MSTR_ASSERT_EQ (str2.view,
+                   mstrv_lit ("foo bar baz foo bar baz foo bar baz"));
+
+   // Replace with empty string:
+   mstr_inplace_replace (&str2, mstrv_lit ("bar "), mstrv_lit (""));
+   MSTR_ASSERT_EQ (str2.view, mstrv_lit ("foo baz foo baz foo baz"));
+
+   // Replacing a string that isn't there:
+   mstr_inplace_replace (&str2, mstrv_lit ("quux"), mstrv_lit ("nope"));
+   MSTR_ASSERT_EQ (str2.view, mstrv_lit ("foo baz foo baz foo baz"));
+
+   // Replacing an empty string is just a duplication:
+   mstr_inplace_replace (&str2, mstrv_lit (""), mstrv_lit ("never"));
+   MSTR_ASSERT_EQ (str2.view, mstrv_lit ("foo baz foo baz foo baz"));
+
+   mstr_free (str2);
+
+   CHECK (mstrv_view_cstr ("foo\000bar").len == 3);
+   CHECK (mstrv_lit ("foo\000bar").len == 7);
+
+   str = mstr_new (0).mstr;
+   MSTR_ITER_SPLIT (part, mstrv_lit ("foo bar baz"), mstrv_lit (" "))
+   {
+      mstr_inplace_append (&str, part);
+      if (mstr_eq (part, mstrv_lit ("bar"))) {
+         break;
+      }
+   }
+   MSTR_ASSERT_EQ (str.view, mstrv_lit ("foobar"));
+   mstr_free (str);
+
+   // rfind at the beginning of the string
+   CHECK (mstr_rfind (mstrv_lit ("foobar"), mstrv_lit ("foo")) == 0);
+
+   str = mstr_splice (mstrv_lit ("foobar"), 1, 2, MSTRV_NULL);
+   MSTR_ASSERT_EQ (str.view, mstrv_lit ("fbar"));
+   mstr_free (str);
+
+   test_predicate (true, "foo", contains, "o");
+   test_predicate (true, "foo", contains, "oo");
+   test_predicate (true, "foo", contains, "foo");
+   test_predicate (true, "foo", contains, "fo");
+   test_predicate (true, "foo", contains, "f");
+   test_predicate (true, "foo", contains, "");
+   test_predicate (false, "foo", contains, "fooo");
+   test_predicate (false, "foo", contains, "ofo");
+   test_predicate (false, "foo", contains, "of");
+   test_predicate (false, "foo", contains, "bar");
+
+   test_predicate (true, "foo", starts_with, "f");
+   test_predicate (true, "foo", starts_with, "fo");
+   test_predicate (true, "foo", starts_with, "foo");
+   test_predicate (true, "foo", starts_with, "");
+   test_predicate (false, "foo", starts_with, "o");
+   test_predicate (false, "foo", starts_with, "oo");
+   test_predicate (false, "foo", starts_with, "oof");
+   test_predicate (false, "foo", starts_with, "bar");
+
+   test_predicate (true, "foo", ends_with, "o");
+   test_predicate (true, "foo", ends_with, "oo");
+   test_predicate (true, "foo", ends_with, "foo");
+   test_predicate (true, "foo", ends_with, "");
+   test_predicate (false, "foo", ends_with, "f");
+   test_predicate (false, "foo", ends_with, "fo");
+   test_predicate (false, "foo", ends_with, "oof");
+   test_predicate (false, "foo", ends_with, "bar");
+
+#ifdef _WIN32
+   const wchar_t *wide = L"🕴️";
+   mstr_narrow_result narrow = mstr_win32_narrow (wide);
+   CHECK (narrow.error == 0);
+   MSTR_ASSERT_EQ (
+      narrow.string.view,
+      mstrv_lit (
+         "\xc3\xb0\xc5\xb8\xe2\x80\xa2\xc2\xb4\xc3\xaf\xc2\xb8\xc2\x8f"));
+   mstr_free (narrow.string);
+#endif
+}

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

@@ -0,0 +1,88 @@
+#ifndef MLIB_THREAD_H
+#define MLIB_THREAD_H
+
+#include "./user-check.h"
+
+#ifdef _WIN32
+#include "./windows-lean.h"
+#else
+#include <pthread.h>
+#endif
+
+#include <stdbool.h>
+
+/**
+ * @brief A status object for @ref mlib_call_once.
+ */
+typedef struct mlib_once_flag {
+#ifdef _WIN32
+   INIT_ONCE _native;
+#else
+   pthread_once_t _native;
+#endif
+} mlib_once_flag;
+
+/**
+ * @brief A literal initializer suitable for static initializing an
+ * @ref mlib_once_flag object. Can also be used to dynamically initialize or
+ * "reset" a flag.
+ */
+#ifdef _WIN32
+#define MLIB_ONCE_INITIALIZER          \
+   {                                   \
+      ._native = INIT_ONCE_STATIC_INIT \
+   }
+#else
+#define MLIB_ONCE_INITIALIZER      \
+   {                               \
+      ._native = PTHREAD_ONCE_INIT \
+   }
+#endif
+
+/**
+ * @brief The type of an mlib_call_once callback function.
+ */
+typedef void (*mlib_init_once_fn_t) (void);
+
+#if _WIN32
+/**
+ * An indirection layer for mlib_once on Windows platforms. Do not use directly.
+ */
+static inline BOOL WINAPI
+_mlib_win32_once_callthru (PINIT_ONCE once, PVOID param, PVOID *ctx)
+{
+   (void) once;
+   (void) ctx;
+   mlib_init_once_fn_t *fn = param;
+   (*fn) ();
+   return TRUE;
+}
+#endif
+
+/**
+ * @brief Perform thread-safe call-once semantics.
+ *
+ * For each thread that calls with the same given flag, no thread shall return
+ * from this function until the flag is in the "finished" state. If a thread
+ * class this function with a "non-finished" flag object, then that thread MIGHT
+ * execute the passed pointed-to function. Once any thread fully executes the
+ * function for the flag, the flag is marked as "finished".
+ *
+ * @param flag A once-state flag. Should have been initialized by @ref
+ * MLIB_ONCE_INITIALIZER.
+ * @param fn A callback to execute if the flag is not in the "finished" state
+ * @return true on success, false otherwise
+ */
+static inline bool
+mlib_call_once (mlib_once_flag *flag, mlib_init_once_fn_t fn)
+{
+#ifdef _WIN32
+   bool okay = InitOnceExecuteOnce (
+      &flag->_native, &_mlib_win32_once_callthru, &fn, NULL);
+   return okay;
+#else
+   return pthread_once (&flag->_native, fn) == 0;
+#endif
+}
+
+#endif // MLIB_THREAD_H

data/ext/libmongocrypt/libmongocrypt/src/mlib/user-check.h

@@ -0,0 +1,4 @@
+#ifndef MLIB_USER
+#error \
+   "The file being compiled transitively #include'd a mongo-mlib header, but is not a direct consumer of mlib, which is a private library for MongoDB C driver libraries"
+#endif

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

@@ -0,0 +1,19 @@
+/**
+ * This file is simply a wrapper around <windows.h> and ensures that
+ * WIN32_LEAN_AND_MEAN is defined before including it.
+ */
+#ifndef MLIB_WINDOWS_LEAN_H
+#define MLIB_WINDOWS_LEAN_H
+
+#ifdef __has_include
+#if !__has_include(<windows.h>)
+#error "<mlib/windows-lean.h> is only available when <windows.h> in available."
+#endif
+#endif
+
+#pragma push_macro("WIN32_LEAN_AND_MEAN")
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#pragma pop_macro("WIN32_LEAN_AND_MEAN")
+
+#endif // MLIB_WINDOWS_LEAN_H

data/ext/libmongocrypt/libmongocrypt/src/mongo_crypt-v1.h

@@ -0,0 +1,320 @@
+/**
+ *    Copyright (C) 2021-present MongoDB, Inc.
+ */
+
+// clang-format off
+
+#ifndef MONGO_CRYPT_SUPPORT_H
+#define MONGO_CRYPT_SUPPORT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma push_macro("MONGO_API_CALL")
+#undef MONGO_API_CALL
+
+#pragma push_macro("MONGO_API_IMPORT")
+#undef MONGO_API_IMPORT
+
+#pragma push_macro("MONGO_API_EXPORT")
+#undef MONGO_API_EXPORT
+
+#pragma push_macro("MONGO_CRYPT_SUPPORT_API")
+#undef MONGO_CRYPT_SUPPORT_API
+
+#if defined(_WIN32)
+#define MONGO_API_CALL __cdecl
+#define MONGO_API_IMPORT __declspec(dllimport)
+#define MONGO_API_EXPORT __declspec(dllexport)
+#else
+#define MONGO_API_CALL
+#define MONGO_API_IMPORT __attribute__((visibility("default")))
+#define MONGO_API_EXPORT __attribute__((used, visibility("default")))
+#endif
+
+#if defined(MONGO_CRYPT_SUPPORT_STATIC)
+#define MONGO_CRYPT_API
+#else
+#if defined(MONGO_CRYPT_SUPPORT_COMPILING)
+#define MONGO_CRYPT_API MONGO_API_EXPORT
+#else
+#define MONGO_CRYPT_API MONGO_API_IMPORT
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * An object which describes the details of the failure of an operation.
+ *
+ * The Mongo Crypt Shared Library uses allocated objects of this type to report the details of any
+ * failure, when an operation cannot be completed. Several `mongo_crypt_v1_status` functions are
+ * provided which permit observing the details of these failures. Further a construction function
+ * and a destruction function for these objects are also provided.
+ *
+ * The use of status objects from multiple threads is not thread safe unless all of the threads
+ * accessing a single status object are passing that object as a const-qualified (const
+ * mongo_crypt_v1_status *) pointer. If a single thread is passing a status object to a function
+ * taking it by non-const-qualified (mongo_crypt_v1_status*) pointer, then no other thread may
+ * access the status object.
+ *
+ * The `status` parameter is optional for all `mongo_crypt_v1_` functions that can take a status
+ * pointer. The caller may pass NULL instead of a valid `status` object, in which case the function
+ * will execute normally but will not provide any detailed error information in the caes of a
+ * failure.
+ *
+ * All `mongo_crypt_v1_status` functions can be used before the Mongo Crypt Shared library is
+ * initialized. This facilitates detailed error reporting from all library functions.
+ */
+typedef struct mongo_crypt_v1_status mongo_crypt_v1_status;
+
+/**
+ * Allocate and construct an API-return-status buffer object.
+ *
+ * Returns NULL when construction of a mongo_crypt_v1_status object fails.
+ *
+ * This function may be called before mongo_crypt_v1_lib_create().
+ */
+MONGO_CRYPT_API mongo_crypt_v1_status* MONGO_API_CALL mongo_crypt_v1_status_create(void);
+
+/**
+ * Destroys a valid status object.
+ *
+ * The status object must be a valid mongo_crypt_v1_status object or NULL.
+ *
+ * This function is not thread safe, and it must not execute concurrently with any other function
+ * that accesses the status object being destroyed. It is, however, safe to destroy distinct status
+ * objects on distinct threads.
+ *
+ * This function does not report failures.
+ *
+ * This function may be called before `mongo_crypt_v1_lib_create()`.
+ *
+ * This function causes all storage associated with the specified status object to be released,
+ * including the storage referenced by functions that returned observable storage buffers from this
+ * status, such as strings.
+ */
+MONGO_CRYPT_API void MONGO_API_CALL mongo_crypt_v1_status_destroy(mongo_crypt_v1_status* status);
+
+/**
+ * The error codes reported by `mongo_crypt_v1` functions will be given the symbolic names as
+ * mapped by this enum.
+ *
+ * When a `mongo_crypt_v1` function fails (and it has been documented to report errors) it will
+ * report that error in the form of an `int` status code. That status code will always be returned
+ * as the type `int`; however, the values in this enum can be used to classify the failure.
+ */
+typedef enum {
+    MONGO_CRYPT_V1_ERROR_IN_REPORTING_ERROR = -2,
+    MONGO_CRYPT_V1_ERROR_UNKNOWN = -1,
+
+    MONGO_CRYPT_V1_SUCCESS = 0,
+
+    MONGO_CRYPT_V1_ERROR_ENOMEM = 1,
+    MONGO_CRYPT_V1_ERROR_EXCEPTION = 2,
+    MONGO_CRYPT_V1_ERROR_LIBRARY_ALREADY_INITIALIZED = 3,
+    MONGO_CRYPT_V1_ERROR_LIBRARY_NOT_INITIALIZED = 4,
+    MONGO_CRYPT_V1_ERROR_INVALID_LIB_HANDLE = 5,
+    MONGO_CRYPT_V1_ERROR_REENTRANCY_NOT_ALLOWED = 6,
+} mongo_crypt_v1_error;
+
+/**
+ * Gets an error code from a `mongo_crypt_v1_status` object.
+ *
+ * When a `mongo_crypt_v1` function fails (and it has been documented to report errors) it will
+ * report its error in the form of an `int` status code which is stored into a supplied
+ * `mongo_crypt_v1_status` object, if provided. Some of these functions may also report extra
+ * information, which will be reported by other observer functions. Every `mongo_crypt_v1`
+ * function which reports errors will always update the `Error` code stored in a
+ * `mongo_crypt_v1_status` object, even upon success.
+ *
+ * This function does not report its own failures.
+ */
+MONGO_CRYPT_API int MONGO_API_CALL
+mongo_crypt_v1_status_get_error(const mongo_crypt_v1_status* status);
+
+/**
+ * Gets a descriptive error message from a `mongo_crypt_v1_status` object.
+ *
+ * For failures where the error is MONGO_CRYPT_V1_ERROR_EXCEPTION, this returns a string
+ * representation of the internal C++ exception.
+ *
+ * The function to which the specified status object was passed must not have returned
+ * MONGO_CRYPT_V1_SUCCESS as its error code.
+ *
+ * The storage for the returned string is associated with the specified status object, and therefore
+ * it will be deallocated when the status is destroyed using mongo_crypt_v1_status_destroy().
+ *
+ * This function does not report its own failures.
+ */
+MONGO_CRYPT_API const char* MONGO_API_CALL
+mongo_crypt_v1_status_get_explanation(const mongo_crypt_v1_status* status);
+
+/**
+ * Gets a status code from a `mongo_crypt_v1_status` object.
+ *
+ * Returns a numeric status code associated with the status parameter which indicates a sub-category
+ * of failure.
+ *
+ * For any status object that does not have MONGO_CRYPT_V1_ERROR_EXCEPTION as its error, the
+ * value of this code is unspecified.
+ *
+ * This function does not report its own failures.
+ */
+MONGO_CRYPT_API int MONGO_API_CALL
+mongo_crypt_v1_status_get_code(const mongo_crypt_v1_status* status);
+
+/**
+ * An object which describes the runtime state of the Mongo Crypt Shared Library.
+ *
+ * The Mongo Crypt Shared Library uses allocated objects of this type to indicate the present state
+ * of the library. Some operations which the library provides need access to this object. Further a
+ * construction function and a destruction function for these objects are also provided. No more
+ * than a single object instance of this type may exist at any given time.
+ *
+ * The use of `mongo_crypt_v1_lib` objects from multiple threads is not thread safe unless all of
+ * the threads accessing a single `mongo_crypt_v1_lib` object are not destroying this object.  If
+ * a single thread is passing a `mongo_crypt_v1_lib` to its destruction function, then no other
+ * thread may access the `mongo_crypt_v1_lib` object.
+ */
+typedef struct mongo_crypt_v1_lib mongo_crypt_v1_lib;
+
+/**
+ * Creates a mongo_crypt_v1_lib object, which stores context for the Mongo Crypt Shared library. A
+ * process should only ever have one mongo_crypt_v1_lib instance.
+ *
+ * On failure, returns NULL and populates the 'status' object if it is not NULL.
+ */
+MONGO_CRYPT_API mongo_crypt_v1_lib* MONGO_API_CALL
+mongo_crypt_v1_lib_create(mongo_crypt_v1_status* status);
+
+/**
+ * Tears down the state of this library. Existing mongo_crypt_v1_status objects remain valid.
+ * Existing mongo_crypt_v1_query_analyzer objects created from this library MUST BE destroyed
+ * before destroying the library object.
+ *
+ * The 'lib' parameter must be a valid mongo_crypt_v1_lib instance and must not be NULL.
+ *
+ * The 'status' parameter may be NULL, but must be a valid mongo_crypt_v1_status instance if it
+ * is not NULL.
+ *
+ * Returns MONGO_CRYPT_V1_SUCCESS on success.
+ *
+ * Returns MONGO_CRYPT_V1_ERROR_LIBRARY_NOT_INITIALIZED and modifies 'status' if
+ * mongo_crypt_v1_lib_create() has not been called previously.
+ */
+MONGO_CRYPT_API int MONGO_API_CALL mongo_crypt_v1_lib_destroy(mongo_crypt_v1_lib* lib,
+                                                              mongo_crypt_v1_status* status);
+
+
+/**
+ * Returns a product version in 64-bit integer in four 16-bit words, from high to low:
+ *
+ * - Major version
+ * - Minor version
+ * - Revision
+ * - Reserved
+ *
+ * For example, version 6.2.1 would be encoded as: 0x0006000200010000
+ *
+ */
+MONGO_CRYPT_API uint64_t MONGO_API_CALL mongo_crypt_v1_get_version(void);
+
+/**
+ * Returns a product version as a text string. The string should not be modified or released
+ *
+ * Examples:
+ *    Dev Build/patch: mongo_crypt_v1-rhel80-6.2.1-alpha4-284-g8662e7d
+ *    Release build: mongo_crypt_v1-rhel80-6.2.1
+ */
+MONGO_CRYPT_API const char* MONGO_API_CALL mongo_crypt_v1_get_version_str(void);
+
+
+/**
+ * A single query analyzer can be used across repeated calls to mongo_crypt_v1_analyze_query.
+ *
+ * It is not safe to simultaneously invoke mongo_crypt_v1_query_analyzer_create on the same
+ * query analyzer from multiple threads
+ *
+ * It is the client's responsibility to call mongo_crypt_v1_query_analyzer_destroy() to free up
+ * resources used by the query analyzer. Once a query analyzer is destroyed, it is not safe to
+ * call mongo_crypt_v1_analyze_query.
+ */
+typedef struct mongo_crypt_v1_query_analyzer mongo_crypt_v1_query_analyzer;
+
+/**
+ * Creates a mongo_crypt_v1_query_analyzer object, which stores a parsed collation.
+ *
+ * The 'lib' parameter must be a valid mongo_crypt_v1_lib instance and must not be NULL.
+ *
+ * On failure, it returns NULL and populates the 'status' object if it is not NULL.
+ */
+MONGO_CRYPT_API mongo_crypt_v1_query_analyzer* MONGO_API_CALL
+mongo_crypt_v1_query_analyzer_create(mongo_crypt_v1_lib* lib, mongo_crypt_v1_status* status);
+
+/**
+ * Destroys a valid mongo_crypt_v1_query_analyzer object.
+ *
+ * This function is not thread safe, and it must not execute concurrently with any other function
+ * that accesses the collation object being destroyed including those that access a matcher,
+ * projection or update object which references the collation object.
+ *
+ * This function does not report failures.
+ */
+MONGO_CRYPT_API void MONGO_API_CALL
+mongo_crypt_v1_query_analyzer_destroy(mongo_crypt_v1_query_analyzer* analyzer);
+
+
+/**
+ * Analyzes the 'documentBSON' input document which includes a JSON schema for namespace 'ns_str'
+ * and returns a new BSON document that replaces fields that need encryption with BinData
+ * (subtype 6, first byte 0) placeholders.
+ *
+ * The input document must be a valid OP_MSG document supports aggregate, count, delete, distinct,
+ *  explain, find, findAndModify, insert and update.
+ * In addition, the input document must include two additional top-level fields:
+ * - jsonSchema : document - contains a valid JSON schema
+ * - isRemoteSchema : bool - true if schema comes from MongoD as opposed to client-side
+ *
+ * The 'analyzer' and 'documentBSON' parameters must point to initialized objects of their
+ * respective types.
+ *
+ * When the analysis is successful, this function returns non-null value which points to a valid
+ * BSON document and updates bson_len with the length of the BSON document
+ */
+MONGO_CRYPT_API uint8_t* MONGO_API_CALL
+mongo_crypt_v1_analyze_query(mongo_crypt_v1_query_analyzer* analyzer,
+                             const uint8_t* documentBSON,
+                             const char* ns_str,
+                             uint32_t ns_len,
+                             uint32_t* bson_len,
+                             mongo_crypt_v1_status* status);
+
+/**
+ * Free the memory of a BSON buffer returned by mongo_crypt_v1_analyze_query(). This function can be
+ * safely called on a NULL pointer.
+ *
+ * This function can be called at any time to deallocate a BSON buffer and will not invalidate any
+ * library object.
+ */
+MONGO_CRYPT_API void MONGO_API_CALL mongo_crypt_v1_bson_free(uint8_t* bson);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#undef MONGO_CRYPT_SUPPORT_API
+#pragma pop_macro("MONGO_CRYPT_SUPPORT_API")
+
+#undef MONGO_API_EXPORT
+#pragma push_macro("MONGO_API_EXPORT")
+
+#undef MONGO_API_IMPORT
+#pragma push_macro("MONGO_API_IMPORT")
+
+#undef MONGO_API_CALL
+#pragma pop_macro("MONGO_API_CALL")
+
+#endif  // MONGO_CRYPT_SUPPORT_H

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018-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_BINARY_PRIVATE_H
+#define MONGOCRYPT_BINARY_PRIVATE_H
+
+#include <bson/bson.h>
+
+#include "mongocrypt.h"
+
+struct _mongocrypt_binary_t {
+   uint8_t *data;
+   uint32_t len;
+};
+
+bool
+_mongocrypt_binary_to_bson (mongocrypt_binary_t *binary,
+                            bson_t *out) MONGOCRYPT_WARN_UNUSED_RESULT;
+
+
+#endif /* MONGOCRYPT_BINARY_PRIVATE_H */

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2018-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 <bson/bson.h>
+
+#include "mongocrypt-binary-private.h"
+#include "mongocrypt-buffer-private.h"
+
+mongocrypt_binary_t *
+mongocrypt_binary_new (void)
+{
+   mongocrypt_binary_t *binary;
+
+   binary = (mongocrypt_binary_t *) bson_malloc0 (sizeof *binary);
+
+   return binary;
+}
+
+
+mongocrypt_binary_t *
+mongocrypt_binary_new_from_data (uint8_t *data, uint32_t len)
+{
+   mongocrypt_binary_t *binary;
+
+   BSON_ASSERT_PARAM (data);
+
+   binary = (mongocrypt_binary_t *) bson_malloc0 (sizeof *binary);
+   BSON_ASSERT (binary);
+   binary->data = data;
+   binary->len = len;
+
+   return binary;
+}
+
+
+bool
+_mongocrypt_binary_to_bson (mongocrypt_binary_t *binary, bson_t *out)
+{
+   BSON_ASSERT_PARAM (binary);
+   BSON_ASSERT_PARAM (out);
+
+   return bson_init_static (out, binary->data, binary->len);
+}
+
+
+uint8_t *
+mongocrypt_binary_data (const mongocrypt_binary_t *binary)
+{
+   if (!binary) {
+      return NULL;
+   }
+   return binary->data;
+}
+
+
+uint32_t
+mongocrypt_binary_len (const mongocrypt_binary_t *binary)
+{
+   if (!binary) {
+      return 0;
+   }
+   return binary->len;
+}
+
+
+void
+mongocrypt_binary_destroy (mongocrypt_binary_t *binary)
+{
+   if (!binary) {
+      return;
+   }
+
+   bson_free (binary);
+}