libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

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

@@ -15,12 +15,13 @@
  */
 
 #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(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 */                                                                              \
@@ -28,9 +29,9 @@
         _mongocrypt_buffer_t data;                                                                                     \
     };                                                                                                                 \
     /* Data-getter */                                                                                                  \
-    const _mongocrypt_buffer_t *CONCAT(Prefix, _get)(const T *self) { return &self->data; }                            \
+    const _mongocrypt_buffer_t *BSON_CONCAT(Prefix, _get)(const T *self) { return &self->data; }                       \
     /* Destructor */                                                                                                   \
-    void CONCAT(Prefix, _destroy)(T * self) {                                                                          \
+    void BSON_CONCAT(Prefix, _destroy)(T * self) {                                                                     \
         if (!self) {                                                                                                   \
             return;                                                                                                    \
         }                                                                                                              \
@@ -38,23 +39,23 @@
         bson_free(self);                                                                                               \
     }                                                                                                                  \
     /* Constructor. From raw buffer */                                                                                 \
-    T *CONCAT(Prefix, _new_from_buffer)(_mongocrypt_buffer_t * buf) {                                                  \
+    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 *CONCAT(Prefix, _new)(_mongocrypt_crypto_t * crypto, __VA_ARGS__, mongocrypt_status_t * status)
+    T *BSON_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)));                                                   \
+        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)) {                                           \
-            CONCAT(Name, _destroy)(t);                                                                                 \
+            BSON_CONCAT(Name, _destroy)(t);                                                                            \
             Clean;                                                                                                     \
             return NULL;                                                                                               \
         }                                                                                                              \
@@ -97,23 +98,46 @@ 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_EDCDerivedFromDataTokenAndCounter,
+DEF_TOKEN_TYPE(mc_EDCDerivedFromDataTokenAndContentionFactor,
                const mc_EDCDerivedFromDataToken_t *EDCDerivedFromDataToken,
                uint64_t u)
-IMPL_TOKEN_NEW_CONST(mc_EDCDerivedFromDataTokenAndCounter, mc_EDCDerivedFromDataToken_get(EDCDerivedFromDataToken), u)
+IMPL_TOKEN_NEW_CONST(mc_EDCDerivedFromDataTokenAndContentionFactor,
+                     mc_EDCDerivedFromDataToken_get(EDCDerivedFromDataToken),
+                     u)
 
-DEF_TOKEN_TYPE(mc_ESCDerivedFromDataTokenAndCounter,
+DEF_TOKEN_TYPE(mc_ESCDerivedFromDataTokenAndContentionFactor,
                const mc_ESCDerivedFromDataToken_t *ESCDerivedFromDataToken,
                uint64_t u)
-IMPL_TOKEN_NEW_CONST(mc_ESCDerivedFromDataTokenAndCounter, mc_ESCDerivedFromDataToken_get(ESCDerivedFromDataToken), u)
+IMPL_TOKEN_NEW_CONST(mc_ESCDerivedFromDataTokenAndContentionFactor,
+                     mc_ESCDerivedFromDataToken_get(ESCDerivedFromDataToken),
+                     u)
 
-DEF_TOKEN_TYPE(mc_ECCDerivedFromDataTokenAndCounter,
+DEF_TOKEN_TYPE(mc_ECCDerivedFromDataTokenAndContentionFactor,
                const mc_ECCDerivedFromDataToken_t *ECCDerivedFromDataToken,
                uint64_t u)
-IMPL_TOKEN_NEW_CONST(mc_ECCDerivedFromDataTokenAndCounter, mc_ECCDerivedFromDataToken_get(ECCDerivedFromDataToken), u)
+IMPL_TOKEN_NEW_CONST(mc_ECCDerivedFromDataTokenAndContentionFactor,
+                     mc_ECCDerivedFromDataToken_get(ECCDerivedFromDataToken),
+                     u)
 
 /* FLE2v2 */
 
@@ -133,3 +157,23 @@ IMPL_TOKEN_NEW_CONST(mc_ServerCountAndContentionFactorEncryptionToken,
 
 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/mlib/int128.h

@@ -200,6 +200,13 @@ static mlib_constexpr_fn mlib_int128 mlib_int128_bitor(mlib_int128 l, mlib_int12
     return MLIB_INIT(mlib_int128) MLIB_INT128_FROM_PARTS(l.r.lo | r.r.lo, l.r.hi | r.r.hi);
 }
 
+/**
+ * @brief Bitwise-and two 128-bit integers
+ */
+static mlib_constexpr_fn mlib_int128 mlib_int128_bitand(mlib_int128 l, mlib_int128 r) {
+    return MLIB_INIT(mlib_int128) MLIB_INT128_FROM_PARTS(l.r.lo & r.r.lo, l.r.hi & r.r.hi);
+}
+
 // Multiply two 64bit integers to get a 128-bit result without overflow
 static mlib_constexpr_fn mlib_int128 _mlibUnsignedMult128(uint64_t left, uint64_t right) {
     // Perform a Knuth 4.3.1M multiplication
@@ -245,6 +252,16 @@ static mlib_constexpr_fn int _mlibCountLeadingZeros_u64(uint64_t bits) {
     return n;
 }
 
+static mlib_constexpr_fn int _mlibCountLeadingZeros_u128(mlib_int128 r) {
+    int clz_l = _mlibCountLeadingZeros_u64(r.r.hi);
+    if (clz_l != 64) {
+        return clz_l;
+    }
+
+    int clz_r = _mlibCountLeadingZeros_u64(r.r.lo);
+    return clz_l + clz_r;
+}
+
 /// Implementation of Knuth's algorithm 4.3.1 D for unsigned integer division
 static mlib_constexpr_fn void
 _mlibKnuth431D(uint32_t *const u, const int ulen, const uint32_t *const v, const int vlen, uint32_t *quotient) {

data/ext/libmongocrypt/libmongocrypt/src/mlib/int128.test.cpp

@@ -14,6 +14,11 @@
 // Old GCC and old MSVC have partially-broken constexpr that prevents us from
 // properly using static_assert with from_string()
 #define BROKEN_CONSTEXPR
+#elif (defined(_MSC_VER) && _MSC_VER >= 1930)
+// Avoid internal compiler error on VS 2022 versions 17.0 and newer when
+// evaluating mlib_int128_from_string via operator""_i128. Assumed to be related
+// to: https://developercommunity.visualstudio.com/t/User-defined-literals-cause-ICEs/10259122
+#define BROKEN_CONSTEXPR
 #endif
 
 #ifndef BROKEN_CONSTEXPR

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

@@ -21,11 +21,6 @@
 
 #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-buffer.c

@@ -19,6 +19,11 @@
 #include "mongocrypt-util-private.h"
 #include <bson/bson.h>
 
+// Require libbson 1.16.0 or newer. Fix for CDRIVER-3360 is needed.
+#if !BSON_CHECK_VERSION(1, 16, 0)
+#error "libbson 1.16.0 or newer is required."
+#endif
+
 #define INT32_LEN 4
 #define TYPE_LEN 1
 #define NULL_BYTE_LEN 1
@@ -306,13 +311,6 @@ bool _mongocrypt_buffer_to_bson_value(_mongocrypt_buffer_t *plaintext, uint8_t t
     }
     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);

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-key.c

@@ -85,6 +85,7 @@ static void _dump_attr(void *attr_in) {
     for (altname = attr->alt_names; NULL != altname; altname = altname->next) {
         printf("%s\n", _mongocrypt_key_alt_name_get_string(altname));
     }
+    bson_free(hex);
 }
 
 _mongocrypt_cache_key_value_t *_mongocrypt_cache_key_value_new(_mongocrypt_key_doc_t *key_doc,

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-oauth-private.h

@@ -20,21 +20,19 @@
 #include "mongocrypt-mutex-private.h"
 #include "mongocrypt-status-private.h"
 
-typedef struct {
-    bson_t *entry;
-    char *access_token;
-    int64_t expiration_time_us;
-    mongocrypt_mutex_t mutex; /* global lock of cache. */
-} _mongocrypt_cache_oauth_t;
-
-_mongocrypt_cache_oauth_t *_mongocrypt_cache_oauth_new(void);
-
-void _mongocrypt_cache_oauth_destroy(_mongocrypt_cache_oauth_t *cache);
-
-bool _mongocrypt_cache_oauth_add(_mongocrypt_cache_oauth_t *cache, bson_t *oauth_response, mongocrypt_status_t *status);
-
-/* Returns a copy of the base64 encoded oauth token, or NULL if nothing is
- * cached. */
-char *_mongocrypt_cache_oauth_get(_mongocrypt_cache_oauth_t *cache);
-
-#endif /* MONGOCRYPT_CACHE_OAUTH_PRIVATE_H */
+// `mc_mapof_kmsid_to_token_t` maps a KMS ID (e.g. `azure` or `azure:myname`) to an OAuth token.
+typedef struct _mc_mapof_kmsid_to_token_t mc_mapof_kmsid_to_token_t;
+
+mc_mapof_kmsid_to_token_t *mc_mapof_kmsid_to_token_new(void);
+void mc_mapof_kmsid_to_token_destroy(mc_mapof_kmsid_to_token_t *k2t);
+// `mc_mapof_kmsid_to_token_get_token` returns a copy of the base64 encoded oauth token, or NULL.
+// Thread-safe.
+char *mc_mapof_kmsid_to_token_get_token(mc_mapof_kmsid_to_token_t *k2t, const char *kmsid);
+// `mc_mapof_kmsid_to_token_add_response` overwrites an entry if `kms_id` exists.
+// Thread-safe.
+bool mc_mapof_kmsid_to_token_add_response(mc_mapof_kmsid_to_token_t *k2t,
+                                          const char *kmsid,
+                                          bson_t *response,
+                                          mongocrypt_status_t *status);
+
+#endif /* MONGOCRYPT_CACHE_OAUTH_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-oauth.c

@@ -16,6 +16,7 @@
 
 #include "mongocrypt-cache-oauth-private.h"
 
+#include "mc-array-private.h"
 #include "mongocrypt-private.h"
 
 /* How long before the reported "expires_in" time cache entries get evicted.
@@ -24,91 +25,119 @@
  */
 #define MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US 5000 * 1000
 
-_mongocrypt_cache_oauth_t *_mongocrypt_cache_oauth_new(void) {
-    _mongocrypt_cache_oauth_t *cache;
-
-    cache = bson_malloc0(sizeof(_mongocrypt_cache_oauth_t));
-    _mongocrypt_mutex_init(&cache->mutex);
-    return cache;
-}
-
-void _mongocrypt_cache_oauth_destroy(_mongocrypt_cache_oauth_t *cache) {
-    BSON_ASSERT_PARAM(cache);
-
-    _mongocrypt_mutex_cleanup(&cache->mutex);
-    bson_destroy(cache->entry);
-    bson_free(cache->access_token);
-    bson_free(cache);
-}
-
-bool _mongocrypt_cache_oauth_add(_mongocrypt_cache_oauth_t *cache,
-                                 bson_t *oauth_response,
-                                 mongocrypt_status_t *status) {
-    bson_iter_t iter;
+typedef struct {
+    char *kmsid;
+    char *access_token;
     int64_t expiration_time_us;
-    int64_t cache_time_us;
-    int64_t expires_in_s;
-    int64_t expires_in_us;
-    const char *access_token;
-
-    BSON_ASSERT_PARAM(cache);
-    BSON_ASSERT_PARAM(oauth_response);
+} mc_mapof_kmsid_to_token_entry_t;
+
+struct _mc_mapof_kmsid_to_token_t {
+    mc_array_t entries;
+    mongocrypt_mutex_t mutex; // Guards `entries`.
+};
+
+mc_mapof_kmsid_to_token_t *mc_mapof_kmsid_to_token_new(void) {
+    mc_mapof_kmsid_to_token_t *k2t = bson_malloc0(sizeof(mc_mapof_kmsid_to_token_t));
+    _mc_array_init(&k2t->entries, sizeof(mc_mapof_kmsid_to_token_entry_t));
+    _mongocrypt_mutex_init(&k2t->mutex);
+    return k2t;
+}
 
-    /* The OAuth spec strongly implies that the value of expires_in is positive,
-     * so the overflow checks in this function don't consider negative values. */
-    if (!bson_iter_init_find(&iter, oauth_response, "expires_in") || !BSON_ITER_HOLDS_INT(&iter)) {
-        CLIENT_ERR("OAuth response invalid, no 'expires_in' field.");
-        return false;
-    }
-    cache_time_us = bson_get_monotonic_time();
-    expires_in_s = bson_iter_as_int64(&iter);
-    BSON_ASSERT(expires_in_s <= INT64_MAX / 1000 / 1000);
-    expires_in_us = expires_in_s * 1000 * 1000;
-    BSON_ASSERT(expires_in_us <= INT64_MAX - cache_time_us
-                && expires_in_us + cache_time_us > MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US);
-    expiration_time_us = expires_in_us + cache_time_us - MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US;
-
-    if (!bson_iter_init_find(&iter, oauth_response, "access_token") || !BSON_ITER_HOLDS_UTF8(&iter)) {
-        CLIENT_ERR("OAuth response invalid, no 'access_token' field.");
-        return false;
+void mc_mapof_kmsid_to_token_destroy(mc_mapof_kmsid_to_token_t *k2t) {
+    if (!k2t) {
+        return;
     }
-    access_token = bson_iter_utf8(&iter, NULL);
-
-    _mongocrypt_mutex_lock(&cache->mutex);
-    if (expiration_time_us > cache->expiration_time_us) {
-        bson_destroy(cache->entry);
-        cache->entry = bson_copy(oauth_response);
-        cache->expiration_time_us = expiration_time_us;
-        bson_free(cache->access_token);
-        cache->access_token = bson_strdup(access_token);
+    _mongocrypt_mutex_cleanup(&k2t->mutex);
+    for (size_t i = 0; i < k2t->entries.len; i++) {
+        mc_mapof_kmsid_to_token_entry_t k2te = _mc_array_index(&k2t->entries, mc_mapof_kmsid_to_token_entry_t, i);
+        bson_free(k2te.kmsid);
+        bson_free(k2te.access_token);
     }
-    _mongocrypt_mutex_unlock(&cache->mutex);
-    return true;
+    _mc_array_destroy(&k2t->entries);
+    bson_free(k2t);
 }
 
-/* Returns a copy of the base64 encoded oauth token, or NULL if nothing is
- * cached. */
-char *_mongocrypt_cache_oauth_get(_mongocrypt_cache_oauth_t *cache) {
-    char *access_token;
+char *mc_mapof_kmsid_to_token_get_token(mc_mapof_kmsid_to_token_t *k2t, const char *kmsid) {
+    BSON_ASSERT_PARAM(k2t);
+    BSON_ASSERT_PARAM(kmsid);
+
+    _mongocrypt_mutex_lock(&k2t->mutex);
+
+    for (size_t i = 0; i < k2t->entries.len; i++) {
+        mc_mapof_kmsid_to_token_entry_t k2te = _mc_array_index(&k2t->entries, mc_mapof_kmsid_to_token_entry_t, i);
+        if (0 == strcmp(k2te.kmsid, kmsid)) {
+            if (bson_get_monotonic_time() >= k2te.expiration_time_us) {
+                // Expired.
+                _mongocrypt_mutex_unlock(&k2t->mutex);
+                return NULL;
+            }
+            char *access_token = bson_strdup(k2te.access_token);
+            _mongocrypt_mutex_unlock(&k2t->mutex);
+            return access_token;
+        }
+    }
 
-    BSON_ASSERT_PARAM(cache);
+    _mongocrypt_mutex_unlock(&k2t->mutex);
+    return NULL;
+}
 
-    _mongocrypt_mutex_lock(&cache->mutex);
-    if (!cache->entry) {
-        _mongocrypt_mutex_unlock(&cache->mutex);
-        return NULL;
-    }
+bool mc_mapof_kmsid_to_token_add_response(mc_mapof_kmsid_to_token_t *k2t,
+                                          const char *kmsid,
+                                          bson_t *response,
+                                          mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(k2t);
+    BSON_ASSERT_PARAM(kmsid);
+    BSON_ASSERT_PARAM(response);
 
-    if (bson_get_monotonic_time() >= cache->expiration_time_us) {
-        bson_destroy(cache->entry);
-        cache->entry = NULL;
-        cache->expiration_time_us = 0;
-        _mongocrypt_mutex_unlock(&cache->mutex);
-        return NULL;
+    // Parse access token before locking.
+    const char *access_token;
+    int64_t expiration_time_us;
+    {
+        bson_iter_t iter;
+        int64_t cache_time_us;
+        int64_t expires_in_s;
+        int64_t expires_in_us;
+
+        /* The OAuth spec strongly implies that the value of expires_in is positive,
+         * so the overflow checks in this function don't consider negative values. */
+        if (!bson_iter_init_find(&iter, response, "expires_in") || !BSON_ITER_HOLDS_INT(&iter)) {
+            CLIENT_ERR("OAuth response invalid, no 'expires_in' field.");
+            return false;
+        }
+        cache_time_us = bson_get_monotonic_time();
+        expires_in_s = bson_iter_as_int64(&iter);
+        BSON_ASSERT(expires_in_s <= INT64_MAX / 1000 / 1000);
+        expires_in_us = expires_in_s * 1000 * 1000;
+        BSON_ASSERT(expires_in_us <= INT64_MAX - cache_time_us
+                    && expires_in_us + cache_time_us > MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US);
+        expiration_time_us = expires_in_us + cache_time_us - MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US;
+
+        if (!bson_iter_init_find(&iter, response, "access_token") || !BSON_ITER_HOLDS_UTF8(&iter)) {
+            CLIENT_ERR("OAuth response invalid, no 'access_token' field.");
+            return false;
+        }
+        access_token = bson_iter_utf8(&iter, NULL);
     }
 
-    access_token = bson_strdup(cache->access_token);
-    _mongocrypt_mutex_unlock(&cache->mutex);
-
-    return access_token;
+    _mongocrypt_mutex_lock(&k2t->mutex);
+
+    // Check if there is an existing entry.
+    for (size_t i = 0; i < k2t->entries.len; i++) {
+        mc_mapof_kmsid_to_token_entry_t *k2te = &_mc_array_index(&k2t->entries, mc_mapof_kmsid_to_token_entry_t, i);
+        if (0 == strcmp(k2te->kmsid, kmsid)) {
+            // Update entry.
+            bson_free(k2te->access_token);
+            k2te->access_token = bson_strdup(access_token);
+            k2te->expiration_time_us = expiration_time_us;
+            _mongocrypt_mutex_unlock(&k2t->mutex);
+            return true;
+        }
+    }
+    // Create an entry.
+    mc_mapof_kmsid_to_token_entry_t to_put = {.kmsid = bson_strdup(kmsid),
+                                              .access_token = bson_strdup(access_token),
+                                              .expiration_time_us = expiration_time_us};
+    _mc_array_append_val(&k2t->entries, to_put);
+    _mongocrypt_mutex_unlock(&k2t->mutex);
+    return true;
 }

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

@@ -78,7 +78,10 @@ static bool _crypto_aes_256_ctr_encrypt_decrypt_via_ecb(void *ctx,
 
         /* XOR resulting stream with original data */
         for (uint32_t i = 0; i < bytes_written && ptr < args.in->len; i++, ptr++) {
-            out_bin.data[ptr] = in_bin.data[ptr] ^ tmp_bin.data[i];
+            uint8_t *in_bin_u8 = in_bin.data;
+            uint8_t *out_bin_u8 = out_bin.data;
+            uint8_t *tmp_bin_u8 = tmp_bin.data;
+            out_bin_u8[ptr] = in_bin_u8[ptr] ^ tmp_bin_u8[i];
         }
 
         /* Increment value in CTR buffer */
@@ -86,9 +89,10 @@ static bool _crypto_aes_256_ctr_encrypt_decrypt_via_ecb(void *ctx,
         /* assert rather than return since this should never happen */
         BSON_ASSERT(ctr_bin.len == 0u || ctr_bin.len - 1u <= INT_MAX);
         for (int i = (int)ctr_bin.len - 1; i >= 0 && carry != 0; --i) {
-            uint32_t bpp = carry + ctr_bin.data[i];
+            uint8_t *ctr_bin_u8 = ctr_bin.data;
+            uint32_t bpp = carry + ctr_bin_u8[i];
             carry = bpp >> 8;
-            ctr_bin.data[i] = bpp & 0xFF;
+            ctr_bin_u8[i] = bpp & 0xFF;
         }
     }
 
@@ -1384,6 +1388,8 @@ bool _mongocrypt_random_uint64(_mongocrypt_crypto_t *crypto,
         }
 
         memcpy(&rand_u64, rand_u64_buf.data, rand_u64_buf.len);
+        // Use little-endian to enable deterministic tests on big-endian machines.
+        rand_u64 = BSON_UINT64_FROM_LE(rand_u64);
 
         if (rand_u64 >= min) {
             break;