libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

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

@@ -20,6 +20,7 @@
 #include "mc-efc-private.h"
 #include "mc-optional-private.h"
 #include "mc-rangeopts-private.h"
+#include "mc-schema-broker-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt-endpoint-private.h"
 #include "mongocrypt-key-broker-private.h"
@@ -63,6 +64,7 @@ typedef struct __mongocrypt_ctx_opts_t {
     _mongocrypt_buffer_t key_material;
     mongocrypt_encryption_algorithm_t algorithm;
     _mongocrypt_kek_t kek;
+    bool retry_enabled;
 
     struct {
         mongocrypt_index_type_t value;
@@ -87,6 +89,12 @@ typedef struct __mongocrypt_ctx_opts_t {
     } rangeopts;
 } _mongocrypt_ctx_opts_t;
 
+// `_mongocrypt_ctx_opts_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_opts_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_opts_t)
+                        >= BSON_MAX(BSON_ALIGNOF(_mongocrypt_key_alt_name_t), BSON_ALIGNOF(mc_RangeOpts_t)));
+
 /* All derived contexts may override these methods. */
 typedef struct {
     const char *(*mongo_db_collinfo)(mongocrypt_ctx_t *ctx);
@@ -152,7 +160,10 @@ typedef struct {
     char *target_coll;
 
     _mongocrypt_buffer_t list_collections_filter;
-    _mongocrypt_buffer_t schema;
+
+    // `sb` manages encryption schemas (JSONSchema for CSFLE and encryptedFields for QE).
+    mc_schema_broker_t *sb;
+
     /* TODO CDRIVER-3150: audit + rename these buffers.
      * original_cmd for explicit is {v: <BSON value>}, for auto is the command to
      * be encrypted.
@@ -170,24 +181,6 @@ typedef struct {
     _mongocrypt_buffer_t marked_cmd;
     _mongocrypt_buffer_t encrypted_cmd;
     _mongocrypt_buffer_t key_id;
-    bool used_local_schema;
-    /* collinfo_has_siblings is true if the schema came from a remote JSON
-     * schema, and there were siblings. */
-    bool collinfo_has_siblings;
-    /* encrypted_field_config is set when:
-     * 1. `target_ns` is present in an encrypted_field_config_map.
-     * 2. (TODO MONGOCRYPT-414) The collection has encryptedFields in the
-     * response to listCollections. encrypted_field_config is true if and only if
-     * encryption is using FLE 2.0.
-     * 3. The `bulkWrite` command is processed and needs an empty encryptedFields to be processed by query analysis.
-     * (`bulkWrite` does not support empty JSON schema).
-     */
-    _mongocrypt_buffer_t encrypted_field_config;
-    mc_EncryptedFieldConfig_t efc;
-    // `used_empty_encryptedFields` is true if the collection has no JSON schema or encryptedFields,
-    // yet an empty encryptedFields was constructed to support query analysis.
-    // When true, an empty encryptedFields is sent to query analysis, but not appended to the final command.
-    bool used_empty_encryptedFields;
     /* bypass_query_analysis is set to true to skip the
      * MONGOCRYPT_CTX_NEED_MONGO_MARKINGS state. */
     bool bypass_query_analysis;
@@ -202,6 +195,11 @@ typedef struct {
     const char *cmd_name;
 } _mongocrypt_ctx_encrypt_t;
 
+// `_mongocrypt_ctx_encrypt_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_encrypt_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_encrypt_t) >= BSON_ALIGNOF(mongocrypt_ctx_t));
+
 typedef struct {
     mongocrypt_ctx_t parent;
     /* TODO CDRIVER-3150: audit + rename these buffers.
@@ -212,6 +210,11 @@ typedef struct {
     _mongocrypt_buffer_t decrypted_doc;
 } _mongocrypt_ctx_decrypt_t;
 
+// `_mongocrypt_ctx_datakey_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_decrypt_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_decrypt_t) >= BSON_ALIGNOF(mongocrypt_ctx_t));
+
 typedef struct {
     mongocrypt_ctx_t parent;
     mongocrypt_kms_ctx_t kms;
@@ -225,6 +228,11 @@ typedef struct {
     _mongocrypt_buffer_t kmip_secretdata;
 } _mongocrypt_ctx_datakey_t;
 
+// `_mongocrypt_ctx_datakey_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_datakey_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_datakey_t) >= BSON_ALIGNOF(mongocrypt_ctx_t));
+
 typedef struct _mongocrypt_ctx_rmd_datakey_t _mongocrypt_ctx_rmd_datakey_t;
 
 struct _mongocrypt_ctx_rmd_datakey_t {
@@ -242,12 +250,40 @@ typedef struct {
     _mongocrypt_buffer_t results;
 } _mongocrypt_ctx_rewrap_many_datakey_t;
 
+// `_mongocrypt_ctx_rewrap_many_datakey_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_rewrap_many_datakey_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_rewrap_many_datakey_t) >= BSON_ALIGNOF(mongocrypt_ctx_t));
+
 typedef struct {
     mongocrypt_ctx_t parent;
     _mongocrypt_buffer_t result;
     mc_EncryptedFieldConfig_t efc;
 } _mongocrypt_ctx_compact_t;
 
+// `_mongocrypt_ctx_compact_t` inherits extended alignment from libbson. To dynamically allocate, use aligned
+// allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_ctx_compact_t,
+                    BSON_ALIGNOF(_mongocrypt_ctx_compact_t) >= BSON_ALIGNOF(mongocrypt_ctx_t));
+
+#define MONGOCRYPT_CTX_ALLOC_SIZE                                                                                      \
+    BSON_MAX(sizeof(_mongocrypt_ctx_encrypt_t),                                                                        \
+             BSON_MAX(sizeof(_mongocrypt_ctx_decrypt_t),                                                               \
+                      BSON_MAX(sizeof(_mongocrypt_ctx_datakey_t),                                                      \
+                               BSON_MAX(sizeof(_mongocrypt_ctx_rewrap_many_datakey_t),                                 \
+                                        sizeof(_mongocrypt_ctx_compact_t)))))
+
+#define MONGOCRYPT_CTX_ALLOC_ALIGNMENT                                                                                 \
+    BSON_MAX(BSON_ALIGNOF(_mongocrypt_ctx_encrypt_t),                                                                  \
+             BSON_MAX(BSON_ALIGNOF(_mongocrypt_ctx_decrypt_t),                                                         \
+                      BSON_MAX(BSON_ALIGNOF(_mongocrypt_ctx_datakey_t),                                                \
+                               BSON_MAX(BSON_ALIGNOF(_mongocrypt_ctx_rewrap_many_datakey_t),                           \
+                                        BSON_ALIGNOF(_mongocrypt_ctx_compact_t)))))
+
+// `_mongocrypt_ctx_t` inherits extended alignment from libbson. To dynamically allocate, use
+// aligned allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof_mongocrypt_ctx_t, BSON_ALIGNOF(mongocrypt_ctx_t) >= MONGOCRYPT_CTX_ALLOC_ALIGNMENT);
+
 /* Used for option validation. True means required. False means prohibited. */
 typedef enum { OPT_PROHIBITED = 0, OPT_REQUIRED, OPT_OPTIONAL } _mongocrypt_ctx_opt_spec_t;
 

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

@@ -282,7 +282,6 @@ bool mongocrypt_ctx_setopt_algorithm(mongocrypt_ctx_t *ctx, const char *algorith
 
 mongocrypt_ctx_t *mongocrypt_ctx_new(mongocrypt_t *crypt) {
     mongocrypt_ctx_t *ctx;
-    size_t ctx_size;
 
     if (!crypt) {
         return NULL;
@@ -294,19 +293,17 @@ mongocrypt_ctx_t *mongocrypt_ctx_new(mongocrypt_t *crypt) {
         CLIENT_ERR("cannot create context from uninitialized crypt");
         return NULL;
     }
-    ctx_size = sizeof(_mongocrypt_ctx_encrypt_t);
-    if (sizeof(_mongocrypt_ctx_decrypt_t) > ctx_size) {
-        ctx_size = sizeof(_mongocrypt_ctx_decrypt_t);
-    }
-    if (sizeof(_mongocrypt_ctx_datakey_t) > ctx_size) {
-        ctx_size = sizeof(_mongocrypt_ctx_datakey_t);
-    }
-    ctx = bson_malloc0(ctx_size);
+
+    // Allocate with memory and alignment large enough for any possible context type.
+    static const size_t ctx_alignment = MONGOCRYPT_CTX_ALLOC_ALIGNMENT;
+    static const size_t ctx_size = MONGOCRYPT_CTX_ALLOC_SIZE;
+    ctx = bson_aligned_alloc0(ctx_alignment, ctx_size);
     BSON_ASSERT(ctx);
 
     ctx->crypt = crypt;
     ctx->status = mongocrypt_status_new();
     ctx->opts.algorithm = MONGOCRYPT_ENCRYPTION_ALGORITHM_NONE;
+    ctx->opts.retry_enabled = crypt->retry_enabled;
     ctx->state = MONGOCRYPT_CTX_DONE;
     return ctx;
 }
@@ -513,8 +510,9 @@ mongocrypt_kms_ctx_t *mongocrypt_ctx_next_kms_ctx(mongocrypt_ctx_t *ctx) {
         return NULL;
     }
 
+    mongocrypt_kms_ctx_t *ret;
     switch (ctx->state) {
-    case MONGOCRYPT_CTX_NEED_KMS: return ctx->vtable.next_kms_ctx(ctx);
+    case MONGOCRYPT_CTX_NEED_KMS: ret = ctx->vtable.next_kms_ctx(ctx); break;
     case MONGOCRYPT_CTX_ERROR: return NULL;
     case MONGOCRYPT_CTX_DONE:
     case MONGOCRYPT_CTX_NEED_KMS_CREDENTIALS:
@@ -525,6 +523,11 @@ mongocrypt_kms_ctx_t *mongocrypt_ctx_next_kms_ctx(mongocrypt_ctx_t *ctx) {
     case MONGOCRYPT_CTX_READY:
     default: _mongocrypt_ctx_fail_w_msg(ctx, "wrong state"); return NULL;
     }
+
+    if (ret) {
+        ret->retry_enabled = ctx->opts.retry_enabled;
+    }
+    return ret;
 }
 
 bool mongocrypt_ctx_provide_kms_providers(mongocrypt_ctx_t *ctx, mongocrypt_binary_t *kms_providers_definition) {

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

@@ -807,6 +807,13 @@ mongocrypt_kms_ctx_t *_mongocrypt_key_broker_next_kms(_mongocrypt_key_broker_t *
         // Return the first not-yet-returned auth request.
         for (size_t i = 0; i < mc_mapof_kmsid_to_authrequest_len(kb->auth_requests); i++) {
             auth_request_t *ar = mc_mapof_kmsid_to_authrequest_at(kb->auth_requests, i);
+
+            if (ar->kms.should_retry) {
+                ar->kms.should_retry = false;
+                ar->returned = true;
+                return &ar->kms;
+            }
+
             if (ar->returned) {
                 continue;
             }
@@ -817,6 +824,13 @@ mongocrypt_kms_ctx_t *_mongocrypt_key_broker_next_kms(_mongocrypt_key_broker_t *
         return NULL;
     }
 
+    // Check if any requests need retry
+    for (key_returned_t *ptr = kb->keys_returned; ptr != NULL; ptr = ptr->next) {
+        if (ptr->kms.should_retry) {
+            ptr->kms.should_retry = false;
+            return &ptr->kms;
+        }
+    }
     while (kb->decryptor_iter) {
         if (!kb->decryptor_iter->decrypted) {
             key_returned_t *key_returned;
@@ -1148,6 +1162,7 @@ void _mongocrypt_key_broker_add_test_key(_mongocrypt_key_broker_t *kb, const _mo
     key_returned->decrypted = true;
     _mongocrypt_buffer_init(&key_returned->decrypted_key_material);
     _mongocrypt_buffer_resize(&key_returned->decrypted_key_material, MONGOCRYPT_KEY_LEN);
+    // Initialize test key material with all zeros.
     memset(key_returned->decrypted_key_material.data, 0, MONGOCRYPT_KEY_LEN);
     _mongocrypt_key_destroy(key_doc);
     /* Hijack state and move directly to DONE. */

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

@@ -27,6 +27,11 @@ typedef struct __mongocrypt_key_alt_name_t {
     bson_value_t value;
 } _mongocrypt_key_alt_name_t;
 
+// `_mongocrypt_key_alt_name_t` inherits extended alignment from libbson. To dynamically allocate, use aligned
+// allocation (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_key_alt_name_t,
+                    BSON_ALIGNOF(_mongocrypt_key_alt_name_t) >= BSON_ALIGNOF(bson_value_t));
+
 typedef struct {
     bson_t bson; /* original BSON for this key. */
     _mongocrypt_buffer_t id;
@@ -37,6 +42,10 @@ typedef struct {
     _mongocrypt_kek_t kek;
 } _mongocrypt_key_doc_t;
 
+// `_mongocrypt_key_doc_t` inherits extended alignment from libbson. To dynamically allocate, use aligned allocation
+// (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_key_doc_t, BSON_ALIGNOF(_mongocrypt_key_doc_t) >= BSON_ALIGNOF(bson_t));
+
 _mongocrypt_key_alt_name_t *_mongocrypt_key_alt_name_new(const bson_value_t *value);
 
 bool _mongocrypt_key_alt_name_from_iter(const bson_iter_t *iter,

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

@@ -271,7 +271,10 @@ bool _mongocrypt_key_parse_owned(const bson_t *bson, _mongocrypt_key_doc_t *out,
 _mongocrypt_key_doc_t *_mongocrypt_key_new(void) {
     _mongocrypt_key_doc_t *key_doc;
 
-    key_doc = (_mongocrypt_key_doc_t *)bson_malloc0(sizeof *key_doc);
+    key_doc = BSON_ALIGNED_ALLOC(_mongocrypt_key_doc_t);
+    // Use two sets of braces to avoid erroneous missing-braces warning in GCC. Refer:
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
+    *key_doc = (_mongocrypt_key_doc_t){{0}};
     bson_init(&key_doc->bson);
 
     return key_doc;
@@ -389,7 +392,8 @@ _mongocrypt_key_alt_name_t *_mongocrypt_key_alt_name_create(const char *name, ..
 _mongocrypt_key_alt_name_t *_mongocrypt_key_alt_name_new(const bson_value_t *value) {
     BSON_ASSERT_PARAM(value);
 
-    _mongocrypt_key_alt_name_t *name = bson_malloc0(sizeof(*name));
+    _mongocrypt_key_alt_name_t *name = BSON_ALIGNED_ALLOC(_mongocrypt_key_alt_name_t);
+    *name = (_mongocrypt_key_alt_name_t){0};
     BSON_ASSERT(name);
 
     bson_value_copy(value, &name->value);

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-kms-ctx-private.h

@@ -56,8 +56,14 @@ struct _mongocrypt_kms_ctx_t {
     char *endpoint;
     _mongocrypt_log_t *log;
     char *kmsid;
+    int64_t sleep_usec;
+    int attempts;
+    bool retry_enabled;
+    bool should_retry;
 };
 
+static const int kms_max_attempts = 3;
+
 bool _mongocrypt_kms_ctx_init_aws_decrypt(mongocrypt_kms_ctx_t *kms,
                                           _mongocrypt_opts_kms_providers_t *kms_providers,
                                           _mongocrypt_key_doc_t *key,

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-kms-ctx.c

@@ -20,6 +20,7 @@
 #include "mongocrypt-crypto-private.h"
 #include "mongocrypt-ctx-private.h"
 #include "mongocrypt-endpoint-private.h"
+#include "mongocrypt-kek-private.h"
 #include "mongocrypt-kms-ctx-private.h"
 #include "mongocrypt-log-private.h"
 #include "mongocrypt-opts-private.h"
@@ -27,6 +28,7 @@
 #include "mongocrypt-status-private.h"
 #include "mongocrypt-util-private.h"
 #include "mongocrypt.h"
+#include <bson/bson.h>
 #include <kms_message/kms_azure_request.h>
 #include <kms_message/kms_b64.h>
 #include <kms_message/kms_gcp_request.h>
@@ -142,6 +144,9 @@ _init_common(mongocrypt_kms_ctx_t *kms, _mongocrypt_log_t *log, _kms_request_typ
     kms->status = mongocrypt_status_new();
     kms->req_type = kms_type;
     _mongocrypt_buffer_init(&kms->result);
+    kms->sleep_usec = 0;
+    kms->attempts = 0;
+    kms->should_retry = false;
 }
 
 bool _mongocrypt_kms_ctx_init_aws_decrypt(mongocrypt_kms_ctx_t *kms,
@@ -427,11 +432,21 @@ uint32_t mongocrypt_kms_ctx_bytes_needed(mongocrypt_kms_ctx_t *kms) {
     if (!mongocrypt_status_ok(kms->status) || !_mongocrypt_buffer_empty(&kms->result)) {
         return 0;
     }
+    if (kms->should_retry) {
+        return 0;
+    }
     want_bytes = kms_response_parser_wants_bytes(kms->parser, DEFAULT_MAX_KMS_BYTE_REQUEST);
     BSON_ASSERT(want_bytes >= 0);
     return (uint32_t)want_bytes;
 }
 
+int64_t mongocrypt_kms_ctx_usleep(mongocrypt_kms_ctx_t *kms) {
+    if (!kms) {
+        return 0;
+    }
+    return kms->sleep_usec;
+}
+
 static void
 _handle_non200_http_status(int http_status, const char *body, size_t body_len, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(body);
@@ -455,6 +470,56 @@ _handle_non200_http_status(int http_status, const char *body, size_t body_len, m
     CLIENT_ERR("Error in KMS response. HTTP status=%d. Response body=\n%s", http_status, body);
 }
 
+static int64_t backoff_time_usec(int64_t attempts) {
+    static bool seeded = false;
+    if (!seeded) {
+        srand((uint32_t)time(NULL));
+        seeded = true;
+    }
+
+    /* Exponential backoff with jitter. */
+    const int64_t base = 200000;  /* 0.2 seconds */
+    const int64_t max = 20000000; /* 20 seconds */
+    BSON_ASSERT(attempts > 0);
+    int64_t backoff = base * ((int64_t)1 << (attempts - 1));
+    if (backoff > max) {
+        backoff = max;
+    }
+
+    /* Full jitter: between 1 and current max */
+    return (int64_t)((double)rand() / (double)RAND_MAX * (double)backoff) + 1;
+}
+
+static bool should_retry_http(int http_status, _kms_request_type_t t) {
+    static const int retryable_aws[] = {408, 429, 500, 502, 503, 509};
+    static const int retryable_azure[] = {408, 429, 500, 502, 503, 504};
+    if (t == MONGOCRYPT_KMS_AWS_ENCRYPT || t == MONGOCRYPT_KMS_AWS_DECRYPT) {
+        for (size_t i = 0; i < sizeof(retryable_aws) / sizeof(retryable_aws[0]); i++) {
+            if (http_status == retryable_aws[i]) {
+                return true;
+            }
+        }
+    } else if (t == MONGOCRYPT_KMS_AZURE_WRAPKEY || t == MONGOCRYPT_KMS_AZURE_UNWRAPKEY
+               || t == MONGOCRYPT_KMS_AZURE_OAUTH) {
+        for (size_t i = 0; i < sizeof(retryable_azure) / sizeof(retryable_azure[0]); i++) {
+            if (http_status == retryable_azure[i]) {
+                return true;
+            }
+        }
+    } else if (t == MONGOCRYPT_KMS_GCP_ENCRYPT || t == MONGOCRYPT_KMS_GCP_DECRYPT || t == MONGOCRYPT_KMS_GCP_OAUTH) {
+        if (http_status == 408 || http_status == 429 || http_status / 500 == 1) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void set_retry(mongocrypt_kms_ctx_t *kms) {
+    kms->should_retry = true;
+    kms->attempts++;
+    kms->sleep_usec = backoff_time_usec(kms->attempts);
+}
+
 /* An AWS KMS context has received full response. Parse out the result or error.
  */
 static bool _ctx_done_aws(mongocrypt_kms_ctx_t *kms, const char *json_field) {
@@ -485,6 +550,21 @@ static bool _ctx_done_aws(mongocrypt_kms_ctx_t *kms, const char *json_field) {
     }
     body = kms_response_get_body(response, &body_len);
 
+    if (kms->retry_enabled && should_retry_http(http_status, kms->req_type)) {
+        if (kms->attempts >= kms_max_attempts) {
+            // Wrap error to indicate maximum retries occurred.
+            _handle_non200_http_status(http_status, body, body_len, status);
+            CLIENT_ERR("KMS request failed after maximum of %d retries: %s",
+                       kms_max_attempts,
+                       mongocrypt_status_message(status, NULL));
+            goto fail;
+        } else {
+            ret = true;
+            set_retry(kms);
+            goto fail;
+        }
+    }
+
     if (http_status != 200) {
         _handle_non200_http_status(http_status, body, body_len, status);
         goto fail;
@@ -566,6 +646,21 @@ static bool _ctx_done_oauth(mongocrypt_kms_ctx_t *kms) {
     }
     body = kms_response_get_body(response, &body_len);
 
+    if (kms->retry_enabled && should_retry_http(http_status, kms->req_type)) {
+        if (kms->attempts >= kms_max_attempts) {
+            // Wrap error to indicate maximum retries occurred.
+            _handle_non200_http_status(http_status, body, body_len, status);
+            CLIENT_ERR("KMS request failed after maximum of %d retries: %s",
+                       kms_max_attempts,
+                       mongocrypt_status_message(status, NULL));
+            goto fail;
+        } else {
+            ret = true;
+            set_retry(kms);
+            goto fail;
+        }
+    }
+
     if (body_len == 0) {
         CLIENT_ERR("Empty KMS response. HTTP status=%d", http_status);
         goto fail;
@@ -643,6 +738,21 @@ static bool _ctx_done_azure_wrapkey_unwrapkey(mongocrypt_kms_ctx_t *kms) {
     }
     body = kms_response_get_body(response, &body_len);
 
+    if (kms->retry_enabled && should_retry_http(http_status, kms->req_type)) {
+        if (kms->attempts >= kms_max_attempts) {
+            // Wrap error to indicate maximum retries occurred.
+            _handle_non200_http_status(http_status, body, body_len, status);
+            CLIENT_ERR("KMS request failed after maximum of %d retries: %s",
+                       kms_max_attempts,
+                       mongocrypt_status_message(status, NULL));
+            goto fail;
+        } else {
+            ret = true;
+            set_retry(kms);
+            goto fail;
+        }
+    }
+
     if (body_len == 0) {
         CLIENT_ERR("Empty KMS response. HTTP status=%d", http_status);
         goto fail;
@@ -737,6 +847,21 @@ static bool _ctx_done_gcp(mongocrypt_kms_ctx_t *kms, const char *json_field) {
     }
     body = kms_response_get_body(response, &body_len);
 
+    if (kms->retry_enabled && should_retry_http(http_status, kms->req_type)) {
+        if (kms->attempts >= kms_max_attempts) {
+            // Wrap error to indicate maximum retries occurred.
+            _handle_non200_http_status(http_status, body, body_len, status);
+            CLIENT_ERR("KMS request failed after maximum of %d retries: %s",
+                       kms_max_attempts,
+                       mongocrypt_status_message(status, NULL));
+            goto fail;
+        } else {
+            ret = true;
+            set_retry(kms);
+            goto fail;
+        }
+    }
+
     if (http_status != 200) {
         _handle_non200_http_status(http_status, body, body_len, status);
         goto fail;
@@ -995,6 +1120,55 @@ done:
     return ret;
 }
 
+bool mongocrypt_kms_ctx_fail(mongocrypt_kms_ctx_t *kms) {
+    if (!kms) {
+        return false;
+    }
+
+    kms->should_retry = false;
+    mongocrypt_status_t *status = kms->status;
+
+    if (!kms->retry_enabled) {
+        CLIENT_ERR("KMS request failed due to network error");
+        return false;
+    }
+
+    if (kms->attempts >= kms_max_attempts) {
+        CLIENT_ERR("KMS request failed after %d retries due to a network error", kms_max_attempts);
+        return false;
+    }
+
+    // Check if request type is retryable. Some requests are non-idempotent and cannot be safely retried.
+    _kms_request_type_t retryable_types[] = {MONGOCRYPT_KMS_AZURE_OAUTH,
+                                             MONGOCRYPT_KMS_GCP_OAUTH,
+                                             MONGOCRYPT_KMS_AWS_ENCRYPT,
+                                             MONGOCRYPT_KMS_AWS_DECRYPT,
+                                             MONGOCRYPT_KMS_AZURE_WRAPKEY,
+                                             MONGOCRYPT_KMS_AZURE_UNWRAPKEY,
+                                             MONGOCRYPT_KMS_GCP_ENCRYPT,
+                                             MONGOCRYPT_KMS_GCP_DECRYPT};
+    bool is_retryable = false;
+    for (size_t i = 0; i < sizeof(retryable_types) / sizeof(retryable_types[0]); i++) {
+        if (retryable_types[i] == kms->req_type) {
+            is_retryable = true;
+            break;
+        }
+    }
+    if (!is_retryable) {
+        CLIENT_ERR("KMS request failed due to network error");
+        return false;
+    }
+
+    // Mark KMS context as retryable. Return again in `mongocrypt_ctx_next_kms_ctx`.
+    set_retry(kms);
+
+    // Reset intermediate state of parser.
+    if (kms->parser) {
+        kms_response_parser_reset(kms->parser);
+    }
+    return true;
+}
+
 bool mongocrypt_kms_ctx_feed(mongocrypt_kms_ctx_t *kms, mongocrypt_binary_t *bytes) {
     if (!kms) {
         return false;

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

@@ -37,7 +37,6 @@ void _mongocrypt_log_cleanup(_mongocrypt_log_t *log) {
     }
 
     _mongocrypt_mutex_cleanup(&log->mutex);
-    memset(log, 0, sizeof(*log));
 }
 
 void _mongocrypt_stdout_log_fn(mongocrypt_log_level_t level, const char *message, uint32_t message_len, void *ctx) {

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

@@ -45,6 +45,10 @@ typedef struct {
     };
 } _mongocrypt_marking_t;
 
+// `_mongocrypt_marking_t` inherits extended alignment from libbson. To dynamically allocate, use aligned allocation
+// (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_marking_t, BSON_ALIGNOF(_mongocrypt_marking_t) >= BSON_ALIGNOF(bson_iter_t));
+
 void _mongocrypt_marking_init(_mongocrypt_marking_t *marking);
 
 void _mongocrypt_marking_cleanup(_mongocrypt_marking_t *marking);