libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

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

@@ -14,678 +14,557 @@
  * limitations under the License.
  */
 
-#include <bson/bson.h>
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt-endian-private.h"
 #include "mongocrypt-util-private.h"
+#include <bson/bson.h>
 
 #define INT32_LEN 4
 #define TYPE_LEN 1
 #define NULL_BYTE_LEN 1
 #define NULL_BYTE_VAL 0x00
 
-
 /* if a buffer is not owned, copy the data and make it owned. */
-static void
-_make_owned (_mongocrypt_buffer_t *buf)
-{
-   uint8_t *tmp;
-
-   BSON_ASSERT_PARAM (buf);
-   if (buf->owned) {
-      return;
-   }
-   tmp = buf->data;
-   if (buf->len > 0) {
-      buf->data = bson_malloc (buf->len);
-      BSON_ASSERT (buf->data);
-      memcpy (buf->data, tmp, buf->len);
-   } else {
-      buf->data = NULL;
-   }
-
-   buf->owned = true;
+static void _make_owned(_mongocrypt_buffer_t *buf) {
+    uint8_t *tmp;
+
+    BSON_ASSERT_PARAM(buf);
+    if (buf->owned) {
+        return;
+    }
+    tmp = buf->data;
+    if (buf->len > 0) {
+        buf->data = bson_malloc(buf->len);
+        BSON_ASSERT(buf->data);
+        memcpy(buf->data, tmp, buf->len);
+    } else {
+        buf->data = NULL;
+    }
+
+    buf->owned = true;
 }
 
 /* TODO CDRIVER-2990 have buffer operations require initialized buffer to
  * prevent leaky code. */
-void
-_mongocrypt_buffer_init (_mongocrypt_buffer_t *buf)
-{
-   BSON_ASSERT_PARAM (buf);
+void _mongocrypt_buffer_init(_mongocrypt_buffer_t *buf) {
+    BSON_ASSERT_PARAM(buf);
 
-   memset (buf, 0, sizeof (*buf));
+    memset(buf, 0, sizeof(*buf));
 }
 
+void _mongocrypt_buffer_resize(_mongocrypt_buffer_t *buf, uint32_t len) {
+    BSON_ASSERT_PARAM(buf);
+
+    /* Currently this just wipes whatever was in data before,
+       but a fancier implementation could copy over up to 'len'
+       bytes from the old buffer to the new one. */
+    if (buf->owned) {
+        buf->data = bson_realloc(buf->data, len);
+        buf->len = len;
+        return;
+    }
 
-void
-_mongocrypt_buffer_resize (_mongocrypt_buffer_t *buf, uint32_t len)
-{
-   BSON_ASSERT_PARAM (buf);
+    buf->data = bson_malloc(len);
+    BSON_ASSERT(buf->data);
 
-   /* Currently this just wipes whatever was in data before,
-      but a fancier implementation could copy over up to 'len'
-      bytes from the old buffer to the new one. */
-   if (buf->owned) {
-      buf->data = bson_realloc (buf->data, len);
-      buf->len = len;
-      return;
-   }
+    buf->len = len;
+    buf->owned = true;
+}
 
-   buf->data = bson_malloc (len);
-   BSON_ASSERT (buf->data);
+void _mongocrypt_buffer_init_size(_mongocrypt_buffer_t *buf, uint32_t len) {
+    BSON_ASSERT_PARAM(buf);
 
-   buf->len = len;
-   buf->owned = true;
+    _mongocrypt_buffer_init(buf);
+    _mongocrypt_buffer_resize(buf, len);
 }
 
+void _mongocrypt_buffer_steal(_mongocrypt_buffer_t *buf, _mongocrypt_buffer_t *src) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(src);
 
-void
-_mongocrypt_buffer_init_size (_mongocrypt_buffer_t *buf, uint32_t len)
-{
-   BSON_ASSERT_PARAM (buf);
+    if (!src->owned) {
+        _mongocrypt_buffer_copy_to(src, buf);
+        _mongocrypt_buffer_init(src);
+        return;
+    }
 
-   _mongocrypt_buffer_init (buf);
-   _mongocrypt_buffer_resize (buf, len);
+    buf->data = src->data;
+    buf->len = src->len;
+    buf->owned = true;
+    _mongocrypt_buffer_init(src);
 }
 
+bool _mongocrypt_buffer_from_binary_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
+
+    if (!BSON_ITER_HOLDS_BINARY(iter)) {
+        return false;
+    }
+    _mongocrypt_buffer_init(buf);
+    bson_iter_binary(iter, &buf->subtype, &buf->len, (const uint8_t **)&buf->data);
+    buf->owned = false;
+    return true;
+}
 
-void
-_mongocrypt_buffer_steal (_mongocrypt_buffer_t *buf, _mongocrypt_buffer_t *src)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (src);
+bool _mongocrypt_buffer_copy_from_binary_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
 
-   if (!src->owned) {
-      _mongocrypt_buffer_copy_to (src, buf);
-      _mongocrypt_buffer_init (src);
-      return;
-   }
+    if (!_mongocrypt_buffer_from_binary_iter(buf, iter)) {
+        return false;
+    }
 
-   buf->data = src->data;
-   buf->len = src->len;
-   buf->owned = true;
-   _mongocrypt_buffer_init (src);
+    _make_owned(buf);
+    return true;
 }
 
-bool
-_mongocrypt_buffer_from_binary_iter (_mongocrypt_buffer_t *buf,
-                                     bson_iter_t *iter)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
+bool _mongocrypt_buffer_from_document_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
 
-   if (!BSON_ITER_HOLDS_BINARY (iter)) {
-      return false;
-   }
-   _mongocrypt_buffer_init (buf);
-   bson_iter_binary (
-      iter, &buf->subtype, &buf->len, (const uint8_t **) &buf->data);
-   buf->owned = false;
-   return true;
+    if (!BSON_ITER_HOLDS_DOCUMENT(iter)) {
+        return false;
+    }
+    _mongocrypt_buffer_init(buf);
+    bson_iter_document(iter, &buf->len, (const uint8_t **)&buf->data);
+    buf->owned = false;
+    return true;
 }
 
+bool _mongocrypt_buffer_copy_from_document_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
 
-bool
-_mongocrypt_buffer_copy_from_binary_iter (_mongocrypt_buffer_t *buf,
-                                          bson_iter_t *iter)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
+    if (!_mongocrypt_buffer_from_document_iter(buf, iter)) {
+        return false;
+    }
+    _make_owned(buf);
+    return true;
+}
 
-   if (!_mongocrypt_buffer_from_binary_iter (buf, iter)) {
-      return false;
-   }
+void _mongocrypt_buffer_steal_from_bson(_mongocrypt_buffer_t *buf, bson_t *bson) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(bson);
 
-   _make_owned (buf);
-   return true;
+    _mongocrypt_buffer_init(buf);
+    buf->data = bson_destroy_with_steal(bson, true, &buf->len);
+    buf->owned = true;
 }
 
+void _mongocrypt_buffer_from_bson(_mongocrypt_buffer_t *buf, const bson_t *bson) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(bson);
+
+    _mongocrypt_buffer_init(buf);
+    buf->data = (uint8_t *)bson_get_data(bson);
+    buf->len = bson->len;
+    buf->owned = false;
+}
 
-bool
-_mongocrypt_buffer_from_document_iter (_mongocrypt_buffer_t *buf,
-                                       bson_iter_t *iter)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
+bool _mongocrypt_buffer_to_bson(const _mongocrypt_buffer_t *buf, bson_t *bson) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(bson);
 
-   if (!BSON_ITER_HOLDS_DOCUMENT (iter)) {
-      return false;
-   }
-   _mongocrypt_buffer_init (buf);
-   bson_iter_document (iter, &buf->len, (const uint8_t **) &buf->data);
-   buf->owned = false;
-   return true;
+    return bson_init_static(bson, buf->data, buf->len);
 }
 
+bool _mongocrypt_buffer_append(const _mongocrypt_buffer_t *buf, bson_t *bson, const char *key, int key_len) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(bson);
+    BSON_ASSERT_PARAM(key);
 
-bool
-_mongocrypt_buffer_copy_from_document_iter (_mongocrypt_buffer_t *buf,
-                                            bson_iter_t *iter)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
+    return bson_append_binary(bson, key, key_len, buf->subtype, buf->data, buf->len);
+}
+
+void _mongocrypt_buffer_from_binary(_mongocrypt_buffer_t *buf, const mongocrypt_binary_t *binary) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(binary);
 
-   if (!_mongocrypt_buffer_from_document_iter (buf, iter)) {
-      return false;
-   }
-   _make_owned (buf);
-   return true;
+    _mongocrypt_buffer_init(buf);
+    buf->data = binary->data;
+    buf->len = binary->len;
+    buf->owned = false;
 }
 
+void _mongocrypt_buffer_copy_from_binary(_mongocrypt_buffer_t *buf, const struct _mongocrypt_binary_t *binary) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(binary);
+
+    _mongocrypt_buffer_from_binary(buf, binary);
+    _make_owned(buf);
+}
 
-void
-_mongocrypt_buffer_steal_from_bson (_mongocrypt_buffer_t *buf, bson_t *bson)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (bson);
+void _mongocrypt_buffer_to_binary(const _mongocrypt_buffer_t *buf, mongocrypt_binary_t *binary) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(binary);
 
-   _mongocrypt_buffer_init (buf);
-   buf->data = bson_destroy_with_steal (bson, true, &buf->len);
-   buf->owned = true;
+    binary->data = buf->data;
+    binary->len = buf->len;
 }
 
+void _mongocrypt_buffer_copy_to(const _mongocrypt_buffer_t *src, _mongocrypt_buffer_t *dst) {
+    if (src == dst) {
+        return;
+    }
+
+    BSON_ASSERT_PARAM(src);
+    BSON_ASSERT_PARAM(dst);
+
+    _mongocrypt_buffer_cleanup(dst);
+    if (src->len == 0) {
+        return;
+    }
 
-void
-_mongocrypt_buffer_from_bson (_mongocrypt_buffer_t *buf, const bson_t *bson)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (bson);
+    dst->data = bson_malloc((size_t)src->len);
+    BSON_ASSERT(dst->data);
 
-   _mongocrypt_buffer_init (buf);
-   buf->data = (uint8_t *) bson_get_data (bson);
-   buf->len = bson->len;
-   buf->owned = false;
+    memcpy(dst->data, src->data, src->len);
+    dst->len = src->len;
+    dst->subtype = src->subtype;
+    dst->owned = true;
 }
 
+void _mongocrypt_buffer_set_to(const _mongocrypt_buffer_t *src, _mongocrypt_buffer_t *dst) {
+    if (src == dst) {
+        return;
+    }
 
-bool
-_mongocrypt_buffer_to_bson (const _mongocrypt_buffer_t *buf, bson_t *bson)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (bson);
+    BSON_ASSERT_PARAM(src);
+    BSON_ASSERT_PARAM(dst);
 
-   return bson_init_static (bson, buf->data, buf->len);
+    dst->data = src->data;
+    dst->len = src->len;
+    dst->subtype = src->subtype;
+    dst->owned = false;
 }
 
+int _mongocrypt_buffer_cmp(const _mongocrypt_buffer_t *a, const _mongocrypt_buffer_t *b) {
+    BSON_ASSERT_PARAM(a);
+    BSON_ASSERT_PARAM(b);
 
-bool
-_mongocrypt_buffer_append (const _mongocrypt_buffer_t *buf,
-                           bson_t *bson,
-                           const char *key,
-                           int key_len)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (bson);
-   BSON_ASSERT_PARAM (key);
-
-   return bson_append_binary (
-      bson, key, key_len, buf->subtype, buf->data, buf->len);
+    if (a->len != b->len) {
+        return a->len > b->len ? 1 : -1;
+    }
+    if (0 == a->len) {
+        return 0;
+    }
+    return memcmp(a->data, b->data, a->len);
 }
 
+void _mongocrypt_buffer_cleanup(_mongocrypt_buffer_t *buf) {
+    if (buf && buf->owned) {
+        bson_free(buf->data);
+    }
+}
 
-void
-_mongocrypt_buffer_from_binary (_mongocrypt_buffer_t *buf,
-                                const mongocrypt_binary_t *binary)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (binary);
+bool _mongocrypt_buffer_empty(const _mongocrypt_buffer_t *buf) {
+    BSON_ASSERT_PARAM(buf);
 
-   _mongocrypt_buffer_init (buf);
-   buf->data = binary->data;
-   buf->len = binary->len;
-   buf->owned = false;
+    return buf->data == NULL;
 }
 
+bool _mongocrypt_buffer_to_bson_value(_mongocrypt_buffer_t *plaintext, uint8_t type, bson_value_t *out) {
+    bool ret = false;
+    bson_iter_t iter;
+    bson_t wrapper;
+    uint32_t data_len;
+    uint32_t le_data_len;
+    uint8_t *data;
+    uint8_t data_prefix;
+
+    BSON_ASSERT_PARAM(plaintext);
+    BSON_ASSERT_PARAM(out);
+
+    data_prefix = INT32_LEN      /* adds document size */
+                + TYPE_LEN       /* element type */
+                + NULL_BYTE_LEN; /* and doc's null byte terminator */
+
+    BSON_ASSERT(plaintext->len <= UINT32_MAX - data_prefix - NULL_BYTE_LEN);
 
-void
-_mongocrypt_buffer_copy_from_binary (_mongocrypt_buffer_t *buf,
-                                     const struct _mongocrypt_binary_t *binary)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (binary);
+    data_len = (plaintext->len + data_prefix + NULL_BYTE_LEN);
+    le_data_len = BSON_UINT32_TO_LE(data_len);
 
-   _mongocrypt_buffer_from_binary (buf, binary);
-   _make_owned (buf);
+    data = bson_malloc0(data_len);
+    BSON_ASSERT(data);
+
+    memcpy(data + data_prefix, plaintext->data, plaintext->len);
+    memcpy(data, &le_data_len, INT32_LEN);
+    memcpy(data + INT32_LEN, &type, TYPE_LEN);
+    data[data_len - 1] = NULL_BYTE_VAL;
+
+    if (!bson_init_static(&wrapper, data, data_len)) {
+        goto fail;
+    }
+
+    if (!bson_validate(&wrapper, BSON_VALIDATE_NONE, NULL)) {
+        goto fail;
+    }
+
+    if (!bson_iter_init_find(&iter, &wrapper, "")) {
+        goto fail;
+    }
+    bson_value_copy(bson_iter_value(&iter), out);
+
+    /* Due to an open libbson bug (CDRIVER-3340), give an empty
+     * binary payload a real address. TODO: remove this after
+     * CDRIVER-3340 is fixed. */
+    if (out->value_type == BSON_TYPE_BINARY && 0 == out->value.v_binary.data_len) {
+        out->value.v_binary.data = bson_malloc(1); /* Freed in bson_value_destroy */
+    }
+
+    ret = true;
+fail:
+    bson_free(data);
+    return ret;
 }
 
+void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *iter) {
+    bson_t wrapper = BSON_INITIALIZER;
+    int32_t offset = INT32_LEN      /* skips document size */
+                   + TYPE_LEN       /* element type */
+                   + NULL_BYTE_LEN; /* and the key's null byte terminator */
+
+    uint8_t *wrapper_data;
+
+    BSON_ASSERT_PARAM(plaintext);
+    BSON_ASSERT_PARAM(iter);
+
+    /* It is not straightforward to transform a bson_value_t to a string of
+     * bytes. As a workaround, we wrap the value in a bson document with an empty
+     * key, then use the raw buffer from inside the new bson_t, skipping the
+     * length and type header information and the key name. */
+    bson_append_iter(&wrapper, "", 0, iter);
+    wrapper_data = ((uint8_t *)bson_get_data(&wrapper));
+    BSON_ASSERT(wrapper.len >= (uint32_t)offset + NULL_BYTE_LEN);
+    plaintext->len = wrapper.len - (uint32_t)offset - NULL_BYTE_LEN; /* the final null byte */
+    plaintext->data = bson_malloc(plaintext->len);
+    BSON_ASSERT(plaintext->data);
 
-void
-_mongocrypt_buffer_to_binary (const _mongocrypt_buffer_t *buf,
-                              mongocrypt_binary_t *binary)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (binary);
+    plaintext->owned = true;
+    memcpy(plaintext->data, wrapper_data + offset, plaintext->len);
 
-   binary->data = buf->data;
-   binary->len = buf->len;
+    bson_destroy(&wrapper);
 }
 
+bool _mongocrypt_buffer_from_uuid_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    const uint8_t *data;
+    bson_subtype_t subtype;
+    uint32_t len;
 
-void
-_mongocrypt_buffer_copy_to (const _mongocrypt_buffer_t *src,
-                            _mongocrypt_buffer_t *dst)
-{
-   if (src == dst) {
-      return;
-   }
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
 
-   BSON_ASSERT_PARAM (src);
-   BSON_ASSERT_PARAM (dst);
+    if (!BSON_ITER_HOLDS_BINARY(iter)) {
+        return false;
+    }
+    bson_iter_binary(iter, &subtype, &len, &data);
+    if (subtype != BSON_SUBTYPE_UUID) {
+        return false;
+    }
+    if (len != UUID_LEN) {
+        return false;
+    }
+    _mongocrypt_buffer_init(buf);
+    buf->data = (uint8_t *)data;
+    buf->len = len;
+    buf->subtype = subtype;
+    buf->owned = false;
+    return true;
+}
+
+bool _mongocrypt_buffer_copy_from_uuid_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(iter);
 
-   _mongocrypt_buffer_cleanup (dst);
-   if (src->len == 0) {
-      return;
-   }
+    if (!_mongocrypt_buffer_from_uuid_iter(buf, iter)) {
+        return false;
+    }
+    _make_owned(buf);
+    return true;
+}
 
-   dst->data = bson_malloc ((size_t) src->len);
-   BSON_ASSERT (dst->data);
+bool _mongocrypt_buffer_is_uuid(_mongocrypt_buffer_t *buf) {
+    BSON_ASSERT_PARAM(buf);
 
-   memcpy (dst->data, src->data, src->len);
-   dst->len = src->len;
-   dst->subtype = src->subtype;
-   dst->owned = true;
+    return buf->len == UUID_LEN && buf->subtype == BSON_SUBTYPE_UUID;
 }
 
+void _mongocrypt_buffer_copy_from_hex(_mongocrypt_buffer_t *buf, const char *hex) {
+    uint32_t i;
+    size_t hex_len;
+
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(hex);
 
-void
-_mongocrypt_buffer_set_to (const _mongocrypt_buffer_t *src,
-                           _mongocrypt_buffer_t *dst)
-{
-   if (src == dst) {
-      return;
-   }
+    hex_len = strlen(hex);
+    if (hex_len == 0) {
+        _mongocrypt_buffer_init(buf);
+        return;
+    }
 
-   BSON_ASSERT_PARAM (src);
-   BSON_ASSERT_PARAM (dst);
+    BSON_ASSERT(hex_len / 2u <= UINT32_MAX);
+    buf->len = (uint32_t)(hex_len / 2u);
+    buf->data = bson_malloc(buf->len);
+    BSON_ASSERT(buf->data);
 
-   dst->data = src->data;
-   dst->len = src->len;
-   dst->subtype = src->subtype;
-   dst->owned = false;
+    buf->owned = true;
+    for (i = 0; i < buf->len; i++) {
+        uint32_t tmp;
+        BSON_ASSERT(i <= UINT32_MAX / 2);
+        BSON_ASSERT(sscanf(hex + (2 * i), "%02x", &tmp));
+        *(buf->data + i) = (uint8_t)tmp;
+    }
 }
 
+int _mongocrypt_buffer_cmp_hex(_mongocrypt_buffer_t *buf, const char *hex) {
+    _mongocrypt_buffer_t tmp;
+    int res;
 
-int
-_mongocrypt_buffer_cmp (const _mongocrypt_buffer_t *a,
-                        const _mongocrypt_buffer_t *b)
-{
-   BSON_ASSERT_PARAM (a);
-   BSON_ASSERT_PARAM (b);
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(hex);
 
-   if (a->len != b->len) {
-      return a->len > b->len ? 1 : -1;
-   }
-   if (0 == a->len) {
-      return 0;
-   }
-   return memcmp (a->data, b->data, a->len);
+    _mongocrypt_buffer_copy_from_hex(&tmp, hex);
+    res = _mongocrypt_buffer_cmp(buf, &tmp);
+    _mongocrypt_buffer_cleanup(&tmp);
+    return res;
 }
 
+char *_mongocrypt_buffer_to_hex(_mongocrypt_buffer_t *buf) {
+    BSON_ASSERT_PARAM(buf);
+    /* since buf->len is a uint32_t, even doubling it won't bring it anywhere
+     * near to SIZE_MAX */
 
-void
-_mongocrypt_buffer_cleanup (_mongocrypt_buffer_t *buf)
-{
-   if (buf && buf->owned) {
-      bson_free (buf->data);
-   }
+    char *hex = bson_malloc0(buf->len * 2 + 1);
+    BSON_ASSERT(hex);
+
+    char *out = hex;
+
+    for (uint32_t i = 0; i < buf->len; i++, out += 2) {
+        sprintf(out, "%02X", buf->data[i]);
+    }
+    return hex;
 }
 
+bool _mongocrypt_buffer_concat(_mongocrypt_buffer_t *dst, const _mongocrypt_buffer_t *srcs, uint32_t num_srcs) {
+    uint32_t total = 0;
+    uint32_t offset;
+    uint32_t i;
+
+    BSON_ASSERT_PARAM(dst);
+    BSON_ASSERT_PARAM(srcs);
 
-bool
-_mongocrypt_buffer_empty (const _mongocrypt_buffer_t *buf)
-{
-   BSON_ASSERT_PARAM (buf);
+    for (i = 0; i < num_srcs; i++) {
+        uint32_t old_total = total;
 
-   return buf->data == NULL;
+        total += srcs[i].len;
+        /* If the previous operation overflowed, then total will have a smaller
+         * value than previously. */
+        if (total < old_total) {
+            return false;
+        }
+    }
+
+    _mongocrypt_buffer_init(dst);
+    _mongocrypt_buffer_resize(dst, total);
+    offset = 0;
+    for (i = 0; i < num_srcs; i++) {
+        if (srcs[i].len) {
+            memcpy(dst->data + offset, srcs[i].data, srcs[i].len);
+        }
+        offset += srcs[i].len;
+    }
+    return true;
 }
 
-bool
-_mongocrypt_buffer_to_bson_value (_mongocrypt_buffer_t *plaintext,
-                                  uint8_t type,
-                                  bson_value_t *out)
-{
-   bool ret = false;
-   bson_iter_t iter;
-   bson_t wrapper;
-   uint32_t data_len;
-   uint32_t le_data_len;
-   uint8_t *data;
-   uint8_t data_prefix;
+struct _mongocrypt_binary_t *_mongocrypt_buffer_as_binary(_mongocrypt_buffer_t *buf) {
+    BSON_ASSERT_PARAM(buf);
 
-   BSON_ASSERT_PARAM (plaintext);
-   BSON_ASSERT_PARAM (out);
+    buf->bin.data = buf->data;
+    buf->bin.len = buf->len;
+    return &buf->bin;
+}
 
-   data_prefix = INT32_LEN        /* adds document size */
-                 + TYPE_LEN       /* element type */
-                 + NULL_BYTE_LEN; /* and doc's null byte terminator */
+bool _mongocrypt_buffer_copy_from_data_and_size(_mongocrypt_buffer_t *buf, const uint8_t *data, size_t len) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(data);
 
-   BSON_ASSERT (plaintext->len <= UINT32_MAX - data_prefix - NULL_BYTE_LEN);
+    _mongocrypt_buffer_init(buf);
 
-   data_len = (plaintext->len + data_prefix + NULL_BYTE_LEN);
-   le_data_len = BSON_UINT32_TO_LE (data_len);
+    if (!size_to_uint32(len, &buf->len)) {
+        return false;
+    }
 
-   data = bson_malloc0 (data_len);
-   BSON_ASSERT (data);
+    if ((buf->data = bson_malloc(len))) {
+        memcpy(buf->data, data, len);
+        buf->owned = true;
+    }
 
-   memcpy (data + data_prefix, plaintext->data, plaintext->len);
-   memcpy (data, &le_data_len, INT32_LEN);
-   memcpy (data + INT32_LEN, &type, TYPE_LEN);
-   data[data_len - 1] = NULL_BYTE_VAL;
+    return true;
+}
 
-   if (!bson_init_static (&wrapper, data, data_len)) {
-      goto fail;
-   }
+bool _mongocrypt_buffer_steal_from_data_and_size(_mongocrypt_buffer_t *buf, uint8_t *data, size_t len) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(data);
 
-   if (!bson_validate (&wrapper, BSON_VALIDATE_NONE, NULL)) {
-      goto fail;
-   }
+    _mongocrypt_buffer_init(buf);
+    if (!size_to_uint32(len, &buf->len)) {
+        return false;
+    }
+    buf->data = data;
+    buf->owned = true;
+    return true;
+}
 
-   if (!bson_iter_init_find (&iter, &wrapper, "")) {
-      goto fail;
-   }
-   bson_value_copy (bson_iter_value (&iter), out);
+bool _mongocrypt_buffer_steal_from_string(_mongocrypt_buffer_t *buf, char *str) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(str);
 
-   /* Due to an open libbson bug (CDRIVER-3340), give an empty
-    * binary payload a real address. TODO: remove this after
-    * CDRIVER-3340 is fixed. */
-   if (out->value_type == BSON_TYPE_BINARY &&
-       0 == out->value.v_binary.data_len) {
-      out->value.v_binary.data =
-         bson_malloc (1); /* Freed in bson_value_destroy */
-   }
+    _mongocrypt_buffer_init(buf);
+    if (!size_to_uint32(strlen(str), &buf->len)) {
+        return false;
+    }
+    buf->data = (uint8_t *)str;
+    buf->owned = true;
+    return true;
+}
 
-   ret = true;
-fail:
-   bson_free (data);
-   return ret;
-}
-
-void
-_mongocrypt_buffer_from_iter (_mongocrypt_buffer_t *plaintext,
-                              bson_iter_t *iter)
-{
-   bson_t wrapper = BSON_INITIALIZER;
-   int32_t offset = INT32_LEN        /* skips document size */
-                    + TYPE_LEN       /* element type */
-                    + NULL_BYTE_LEN; /* and the key's null byte terminator */
-
-   uint8_t *wrapper_data;
-
-   BSON_ASSERT_PARAM (plaintext);
-   BSON_ASSERT_PARAM (iter);
-
-   /* It is not straightforward to transform a bson_value_t to a string of
-    * bytes. As a workaround, we wrap the value in a bson document with an empty
-    * key, then use the raw buffer from inside the new bson_t, skipping the
-    * length and type header information and the key name. */
-   bson_append_iter (&wrapper, "", 0, iter);
-   wrapper_data = ((uint8_t *) bson_get_data (&wrapper));
-   BSON_ASSERT (wrapper.len >= (uint32_t) offset + NULL_BYTE_LEN);
-   plaintext->len =
-      wrapper.len - (uint32_t) offset - NULL_BYTE_LEN; /* the final null byte */
-   plaintext->data = bson_malloc (plaintext->len);
-   BSON_ASSERT (plaintext->data);
-
-   plaintext->owned = true;
-   memcpy (plaintext->data, wrapper_data + offset, plaintext->len);
-
-   bson_destroy (&wrapper);
-}
-
-
-bool
-_mongocrypt_buffer_from_uuid_iter (_mongocrypt_buffer_t *buf, bson_iter_t *iter)
-{
-   const uint8_t *data;
-   bson_subtype_t subtype;
-   uint32_t len;
-
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
-
-   if (!BSON_ITER_HOLDS_BINARY (iter)) {
-      return false;
-   }
-   bson_iter_binary (iter, &subtype, &len, &data);
-   if (subtype != BSON_SUBTYPE_UUID) {
-      return false;
-   }
-   if (len != UUID_LEN) {
-      return false;
-   }
-   _mongocrypt_buffer_init (buf);
-   buf->data = (uint8_t *) data;
-   buf->len = len;
-   buf->subtype = subtype;
-   buf->owned = false;
-   return true;
-}
-
-
-bool
-_mongocrypt_buffer_copy_from_uuid_iter (_mongocrypt_buffer_t *buf,
-                                        bson_iter_t *iter)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (iter);
-
-   if (!_mongocrypt_buffer_from_uuid_iter (buf, iter)) {
-      return false;
-   }
-   _make_owned (buf);
-   return true;
-}
-
-bool
-_mongocrypt_buffer_is_uuid (_mongocrypt_buffer_t *buf)
-{
-   BSON_ASSERT_PARAM (buf);
-
-   return buf->len == UUID_LEN && buf->subtype == BSON_SUBTYPE_UUID;
-}
-
-void
-_mongocrypt_buffer_copy_from_hex (_mongocrypt_buffer_t *buf, const char *hex)
-{
-   uint32_t i;
-   size_t hex_len;
-
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (hex);
-
-   hex_len = strlen (hex);
-   if (hex_len == 0) {
-      _mongocrypt_buffer_init (buf);
-      return;
-   }
-
-   BSON_ASSERT (hex_len / 2u <= UINT32_MAX);
-   buf->len = (uint32_t) (hex_len / 2u);
-   buf->data = bson_malloc (buf->len);
-   BSON_ASSERT (buf->data);
-
-   buf->owned = true;
-   for (i = 0; i < buf->len; i++) {
-      uint32_t tmp;
-      BSON_ASSERT (i <= UINT32_MAX / 2);
-      BSON_ASSERT (sscanf (hex + (2 * i), "%02x", &tmp));
-      *(buf->data + i) = (uint8_t) tmp;
-   }
-}
-
-int
-_mongocrypt_buffer_cmp_hex (_mongocrypt_buffer_t *buf, const char *hex)
-{
-   _mongocrypt_buffer_t tmp;
-   int res;
-
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (hex);
-
-   _mongocrypt_buffer_copy_from_hex (&tmp, hex);
-   res = _mongocrypt_buffer_cmp (buf, &tmp);
-   _mongocrypt_buffer_cleanup (&tmp);
-   return res;
-}
-
-char *
-_mongocrypt_buffer_to_hex (_mongocrypt_buffer_t *buf)
-{
-   BSON_ASSERT_PARAM (buf);
-   /* since buf->len is a uint32_t, even doubling it won't bring it anywhere
-    * near to SIZE_MAX */
-
-   char *hex = bson_malloc0 (buf->len * 2 + 1);
-   BSON_ASSERT (hex);
-
-   char *out = hex;
-
-   for (uint32_t i = 0; i < buf->len; i++, out += 2) {
-      sprintf (out, "%02X", buf->data[i]);
-   }
-   return hex;
-}
-
-bool
-_mongocrypt_buffer_concat (_mongocrypt_buffer_t *dst,
-                           const _mongocrypt_buffer_t *srcs,
-                           uint32_t num_srcs)
-{
-   uint32_t total = 0;
-   uint32_t offset;
-   uint32_t i;
-
-   BSON_ASSERT_PARAM (dst);
-   BSON_ASSERT_PARAM (srcs);
-
-   for (i = 0; i < num_srcs; i++) {
-      uint32_t old_total = total;
-
-      total += srcs[i].len;
-      /* If the previous operation overflowed, then total will have a smaller
-       * value than previously. */
-      if (total < old_total) {
-         return false;
-      }
-   }
-
-   _mongocrypt_buffer_init (dst);
-   _mongocrypt_buffer_resize (dst, total);
-   offset = 0;
-   for (i = 0; i < num_srcs; i++) {
-      if (srcs[i].len) {
-         memcpy (dst->data + offset, srcs[i].data, srcs[i].len);
-      }
-      offset += srcs[i].len;
-   }
-   return true;
-}
-
-struct _mongocrypt_binary_t *
-_mongocrypt_buffer_as_binary (_mongocrypt_buffer_t *buf)
-{
-   BSON_ASSERT_PARAM (buf);
-
-   buf->bin.data = buf->data;
-   buf->bin.len = buf->len;
-   return &buf->bin;
-}
-
-bool
-_mongocrypt_buffer_copy_from_data_and_size (_mongocrypt_buffer_t *buf,
-                                            const uint8_t *data,
-                                            size_t len)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (data);
-
-   _mongocrypt_buffer_init (buf);
-
-   if (!size_to_uint32 (len, &buf->len)) {
-      return false;
-   }
-   buf->data = bson_malloc (len);
-   memcpy (buf->data, data, len);
-   buf->owned = true;
-   return true;
-}
-
-bool
-_mongocrypt_buffer_steal_from_data_and_size (_mongocrypt_buffer_t *buf,
-                                             uint8_t *data,
-                                             size_t len)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (data);
-
-   _mongocrypt_buffer_init (buf);
-   if (!size_to_uint32 (len, &buf->len)) {
-      return false;
-   }
-   buf->data = data;
-   buf->owned = true;
-   return true;
-}
-
-bool
-_mongocrypt_buffer_steal_from_string (_mongocrypt_buffer_t *buf, char *str)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (str);
-
-   _mongocrypt_buffer_init (buf);
-   if (!size_to_uint32 (strlen (str), &buf->len)) {
-      return false;
-   }
-   buf->data = (uint8_t *) str;
-   buf->owned = true;
-   return true;
-}
-
-bool
-_mongocrypt_buffer_from_string (_mongocrypt_buffer_t *buf, const char *str)
-{
-   BSON_ASSERT_PARAM (buf);
-   BSON_ASSERT_PARAM (str);
-
-   _mongocrypt_buffer_init (buf);
-   if (!size_to_uint32 (strlen (str), &buf->len)) {
-      return false;
-   }
-   buf->data = (uint8_t *) str;
-   buf->owned = false;
-   return true;
-}
-
-void
-_mongocrypt_buffer_copy_from_uint64_le (_mongocrypt_buffer_t *buf,
-                                        uint64_t value)
-{
-   uint64_t value_le = MONGOCRYPT_UINT64_TO_LE (value);
-
-   BSON_ASSERT_PARAM (buf);
-
-   _mongocrypt_buffer_init (buf);
-   _mongocrypt_buffer_resize (buf, sizeof (value));
-   memcpy (buf->data, &value_le, buf->len);
-}
-
-bool
-_mongocrypt_buffer_from_subrange (_mongocrypt_buffer_t *out,
-                                  const _mongocrypt_buffer_t *in,
-                                  uint32_t offset,
-                                  uint32_t len)
-{
-   BSON_ASSERT_PARAM (out);
-   BSON_ASSERT_PARAM (in);
-
-   _mongocrypt_buffer_init (out);
-   BSON_ASSERT (offset <= UINT32_MAX - len);
-   if (offset + len > in->len) {
-      return false;
-   }
-   out->data = in->data + offset;
-   out->len = len;
-   return true;
+bool _mongocrypt_buffer_from_string(_mongocrypt_buffer_t *buf, const char *str) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(str);
+
+    _mongocrypt_buffer_init(buf);
+    if (!size_to_uint32(strlen(str), &buf->len)) {
+        return false;
+    }
+    buf->data = (uint8_t *)str;
+    buf->owned = false;
+    return true;
+}
+
+void _mongocrypt_buffer_copy_from_uint64_le(_mongocrypt_buffer_t *buf, uint64_t value) {
+    uint64_t value_le = MONGOCRYPT_UINT64_TO_LE(value);
+
+    BSON_ASSERT_PARAM(buf);
+
+    _mongocrypt_buffer_init(buf);
+    _mongocrypt_buffer_resize(buf, sizeof(value));
+    memcpy(buf->data, &value_le, buf->len);
+}
+
+bool _mongocrypt_buffer_from_subrange(_mongocrypt_buffer_t *out,
+                                      const _mongocrypt_buffer_t *in,
+                                      uint32_t offset,
+                                      uint32_t len) {
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    _mongocrypt_buffer_init(out);
+    BSON_ASSERT(offset <= UINT32_MAX - len);
+    if (offset + len > in->len) {
+        return false;
+    }
+    out->data = in->data + offset;
+    out->len = len;
+    return true;
 }