libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/crypto/cng.c

@@ -35,150 +35,138 @@ static BCRYPT_ALG_HANDLE _random;
 
 bool _native_crypto_initialized = false;
 
-void
-_native_crypto_init (void)
-{
-   DWORD cbOutput;
-   NTSTATUS nt_status;
-
-   /* Note, there is no mechanism for libmongocrypt to close these providers,
-    * If we ever add such a mechanism, call BCryptCloseAlgorithmProvider.
-    */
-   nt_status = BCryptOpenAlgorithmProvider (&_algo_sha512_hmac,
+void _native_crypto_init(void) {
+    DWORD cbOutput;
+    NTSTATUS nt_status;
+
+    /* Note, there is no mechanism for libmongocrypt to close these providers,
+     * If we ever add such a mechanism, call BCryptCloseAlgorithmProvider.
+     */
+    nt_status = BCryptOpenAlgorithmProvider(&_algo_sha512_hmac,
                                             BCRYPT_SHA512_ALGORITHM,
                                             MS_PRIMITIVE_PROVIDER,
                                             BCRYPT_ALG_HANDLE_HMAC_FLAG);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
 
-   nt_status = BCryptOpenAlgorithmProvider (&_algo_sha256_hmac,
+    nt_status = BCryptOpenAlgorithmProvider(&_algo_sha256_hmac,
                                             BCRYPT_SHA256_ALGORITHM,
                                             MS_PRIMITIVE_PROVIDER,
                                             BCRYPT_ALG_HANDLE_HMAC_FLAG);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
-
-   nt_status = BCryptOpenAlgorithmProvider (
-      &_algo_aes256_cbc, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
-
-   nt_status = BCryptSetProperty (
-      _algo_aes256_cbc,
-      BCRYPT_CHAINING_MODE,
-      (PUCHAR) (BCRYPT_CHAIN_MODE_CBC),
-      (ULONG) (sizeof (wchar_t) * wcslen (BCRYPT_CHAIN_MODE_CBC)),
-      0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
-
-   nt_status = BCryptOpenAlgorithmProvider (
-      &_algo_aes256_ecb, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
-
-   nt_status = BCryptSetProperty (
-      _algo_aes256_ecb,
-      BCRYPT_CHAINING_MODE,
-      (PUCHAR) (BCRYPT_CHAIN_MODE_ECB),
-      (ULONG) (sizeof (wchar_t) * wcslen (BCRYPT_CHAIN_MODE_ECB)),
-      0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
-
-   cbOutput = sizeof (_aes256_key_blob_length);
-   nt_status = BCryptGetProperty (_algo_aes256_cbc,
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
+
+    nt_status = BCryptOpenAlgorithmProvider(&_algo_aes256_cbc, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
+
+    nt_status = BCryptSetProperty(_algo_aes256_cbc,
+                                  BCRYPT_CHAINING_MODE,
+                                  (PUCHAR)(BCRYPT_CHAIN_MODE_CBC),
+                                  (ULONG)(sizeof(wchar_t) * wcslen(BCRYPT_CHAIN_MODE_CBC)),
+                                  0);
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
+
+    nt_status = BCryptOpenAlgorithmProvider(&_algo_aes256_ecb, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
+
+    nt_status = BCryptSetProperty(_algo_aes256_ecb,
+                                  BCRYPT_CHAINING_MODE,
+                                  (PUCHAR)(BCRYPT_CHAIN_MODE_ECB),
+                                  (ULONG)(sizeof(wchar_t) * wcslen(BCRYPT_CHAIN_MODE_ECB)),
+                                  0);
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
+
+    cbOutput = sizeof(_aes256_key_blob_length);
+    nt_status = BCryptGetProperty(_algo_aes256_cbc,
                                   BCRYPT_OBJECT_LENGTH,
-                                  (PUCHAR) (&_aes256_key_blob_length),
+                                  (PUCHAR)(&_aes256_key_blob_length),
                                   cbOutput,
                                   &cbOutput,
                                   0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
 
-   cbOutput = sizeof (_aes256_block_length);
-   nt_status = BCryptGetProperty (_algo_aes256_cbc,
+    cbOutput = sizeof(_aes256_block_length);
+    nt_status = BCryptGetProperty(_algo_aes256_cbc,
                                   BCRYPT_BLOCK_LENGTH,
-                                  (PUCHAR) (&_aes256_block_length),
+                                  (PUCHAR)(&_aes256_block_length),
                                   cbOutput,
                                   &cbOutput,
                                   0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
 
-   nt_status = BCryptOpenAlgorithmProvider (
-      &_random, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      return;
-   }
+    nt_status = BCryptOpenAlgorithmProvider(&_random, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        return;
+    }
 
-   _native_crypto_initialized = true;
+    _native_crypto_initialized = true;
 }
 
 typedef struct {
-   unsigned char *key_object;
-   uint32_t key_object_length;
+    unsigned char *key_object;
+    uint32_t key_object_length;
 
-   BCRYPT_KEY_HANDLE key_handle;
+    BCRYPT_KEY_HANDLE key_handle;
 
-   unsigned char *iv;
-   uint32_t iv_len;
+    unsigned char *iv;
+    uint32_t iv_len;
 } cng_encrypt_state;
 
-static void
-_crypto_state_destroy (cng_encrypt_state *state);
+static void _crypto_state_destroy(cng_encrypt_state *state);
 
 static cng_encrypt_state *
-_crypto_state_init (const _mongocrypt_buffer_t *key,
-                    const _mongocrypt_buffer_t *iv,
-                    mongocrypt_status_t *status)
-{
-   cng_encrypt_state *state;
-   uint32_t keyBlobLength;
-   unsigned char *keyBlob;
-   BCRYPT_KEY_DATA_BLOB_HEADER blobHeader;
-   NTSTATUS nt_status;
-
-   BSON_ASSERT_PARAM (key);
-   BSON_ASSERT_PARAM (iv);
+_crypto_state_init(const _mongocrypt_buffer_t *key, const _mongocrypt_buffer_t *iv, mongocrypt_status_t *status) {
+    cng_encrypt_state *state;
+    uint32_t keyBlobLength;
+    unsigned char *keyBlob;
+    BCRYPT_KEY_DATA_BLOB_HEADER blobHeader;
+    NTSTATUS nt_status;
 
-   keyBlob = NULL;
+    BSON_ASSERT_PARAM(key);
+    BSON_ASSERT_PARAM(iv);
 
-   state = bson_malloc0 (sizeof (*state));
-   BSON_ASSERT (state);
+    keyBlob = NULL;
 
-   state->key_handle = INVALID_HANDLE_VALUE;
+    state = bson_malloc0(sizeof(*state));
+    BSON_ASSERT(state);
 
-   /* Initialize key storage buffer */
-   state->key_object = bson_malloc0 (_aes256_key_blob_length);
-   BSON_ASSERT (state->key_object);
+    state->key_handle = INVALID_HANDLE_VALUE;
 
-   state->key_object_length = _aes256_key_blob_length;
+    /* Initialize key storage buffer */
+    state->key_object = bson_malloc0(_aes256_key_blob_length);
+    BSON_ASSERT(state->key_object);
 
-   /* Allocate temporary buffer for key import */
-   BSON_ASSERT (sizeof (BCRYPT_KEY_DATA_BLOB_HEADER) + key->len <= UINT32_MAX);
-   keyBlobLength = sizeof (BCRYPT_KEY_DATA_BLOB_HEADER) + key->len;
-   keyBlob = bson_malloc0 (keyBlobLength);
-   BSON_ASSERT (keyBlob);
+    state->key_object_length = _aes256_key_blob_length;
 
+    /* Allocate temporary buffer for key import */
+    BSON_ASSERT(sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->len <= UINT32_MAX);
+    keyBlobLength = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->len;
+    keyBlob = bson_malloc0(keyBlobLength);
+    BSON_ASSERT(keyBlob);
 
-   blobHeader.dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
-   blobHeader.dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
-   blobHeader.cbKeyData = key->len;
+    blobHeader.dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
+    blobHeader.dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
+    blobHeader.cbKeyData = key->len;
 
-   memcpy (keyBlob, &blobHeader, sizeof (BCRYPT_KEY_DATA_BLOB_HEADER));
+    memcpy(keyBlob, &blobHeader, sizeof(BCRYPT_KEY_DATA_BLOB_HEADER));
 
-   memcpy (keyBlob + sizeof (BCRYPT_KEY_DATA_BLOB_HEADER), key->data, key->len);
+    memcpy(keyBlob + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER), key->data, key->len);
 
-   nt_status = BCryptImportKey (_algo_aes256_cbc,
+    nt_status = BCryptImportKey(_algo_aes256_cbc,
                                 NULL,
                                 BCRYPT_KEY_DATA_BLOB,
                                 &(state->key_handle),
@@ -187,60 +175,54 @@ _crypto_state_init (const _mongocrypt_buffer_t *key,
                                 keyBlob,
                                 keyBlobLength,
                                 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("Import Key Failed: 0x%x", (int) nt_status);
-      goto fail;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("Import Key Failed: 0x%x", (int)nt_status);
+        goto fail;
+    }
 
-   bson_free (keyBlob);
+    bson_free(keyBlob);
 
-   state->iv = bson_malloc0 (iv->len);
-   BSON_ASSERT (state->iv);
+    state->iv = bson_malloc0(iv->len);
+    BSON_ASSERT(state->iv);
 
-   state->iv_len = iv->len;
-   memcpy (state->iv, iv->data, iv->len);
+    state->iv_len = iv->len;
+    memcpy(state->iv, iv->data, iv->len);
 
-   return state;
+    return state;
 fail:
-   _crypto_state_destroy (state);
-   bson_free (keyBlob);
+    _crypto_state_destroy(state);
+    bson_free(keyBlob);
 
-   return NULL;
+    return NULL;
 }
 
-
-static void
-_crypto_state_destroy (cng_encrypt_state *state)
-{
-   if (state) {
-      /* Free the key handle before the key_object that contains it */
-      if (state->key_handle != INVALID_HANDLE_VALUE) {
-         BCryptDestroyKey (state->key_handle);
-      }
-
-      bson_free (state->key_object);
-      bson_free (state->iv);
-      bson_free (state);
-   }
+static void _crypto_state_destroy(cng_encrypt_state *state) {
+    if (state) {
+        /* Free the key handle before the key_object that contains it */
+        if (state->key_handle != INVALID_HANDLE_VALUE) {
+            BCryptDestroyKey(state->key_handle);
+        }
+
+        bson_free(state->key_object);
+        bson_free(state->iv);
+        bson_free(state);
+    }
 }
 
+bool _native_crypto_aes_256_cbc_encrypt(aes_256_args_t args) {
+    BSON_ASSERT(args.in);
+    BSON_ASSERT(args.out);
 
-bool
-_native_crypto_aes_256_cbc_encrypt (aes_256_args_t args)
-{
-   BSON_ASSERT (args.in);
-   BSON_ASSERT (args.out);
+    bool ret = false;
+    mongocrypt_status_t *status = args.status;
+    cng_encrypt_state *state = _crypto_state_init(args.key, args.iv, status);
 
-   bool ret = false;
-   mongocrypt_status_t *status = args.status;
-   cng_encrypt_state *state = _crypto_state_init (args.key, args.iv, status);
+    BSON_ASSERT(state);
 
-   BSON_ASSERT (state);
+    NTSTATUS nt_status;
 
-   NTSTATUS nt_status;
-
-   nt_status = BCryptEncrypt (state->key_handle,
-                              (PUCHAR) (args.in->data),
+    nt_status = BCryptEncrypt(state->key_handle,
+                              (PUCHAR)(args.in->data),
                               args.in->len,
                               NULL,
                               state->iv,
@@ -250,34 +232,31 @@ _native_crypto_aes_256_cbc_encrypt (aes_256_args_t args)
                               args.bytes_written,
                               0);
 
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error initializing cipher: 0x%x", (int) nt_status);
-      goto done;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error initializing cipher: 0x%x", (int)nt_status);
+        goto done;
+    }
 
-   ret = true;
+    ret = true;
 done:
-   _crypto_state_destroy (state);
-   return ret;
+    _crypto_state_destroy(state);
+    return ret;
 }
 
+bool _native_crypto_aes_256_cbc_decrypt(aes_256_args_t args) {
+    BSON_ASSERT(args.in);
+    BSON_ASSERT(args.out);
 
-bool
-_native_crypto_aes_256_cbc_decrypt (aes_256_args_t args)
-{
-   BSON_ASSERT (args.in);
-   BSON_ASSERT (args.out);
-
-   bool ret = false;
-   mongocrypt_status_t *status = args.status;
-   cng_encrypt_state *state = _crypto_state_init (args.key, args.iv, status);
+    bool ret = false;
+    mongocrypt_status_t *status = args.status;
+    cng_encrypt_state *state = _crypto_state_init(args.key, args.iv, status);
 
-   BSON_ASSERT (state);
+    BSON_ASSERT(state);
 
-   NTSTATUS nt_status;
+    NTSTATUS nt_status;
 
-   nt_status = BCryptDecrypt (state->key_handle,
-                              (PUCHAR) (args.in->data),
+    nt_status = BCryptDecrypt(state->key_handle,
+                              (PUCHAR)(args.in->data),
                               args.in->len,
                               NULL,
                               state->iv,
@@ -287,16 +266,15 @@ _native_crypto_aes_256_cbc_decrypt (aes_256_args_t args)
                               args.bytes_written,
                               0);
 
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error initializing cipher: 0x%x", (int)nt_status);
+        goto done;
+    }
 
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error initializing cipher: 0x%x", (int) nt_status);
-      goto done;
-   }
-
-   ret = true;
+    ret = true;
 done:
-   _crypto_state_destroy (state);
-   return ret;
+    _crypto_state_destroy(state);
+    return ret;
 }
 
 /* _hmac_with_algorithm computes an HMAC of @in with the algorithm specified by
@@ -305,99 +283,85 @@ done:
  * @out is the output. @out must be allocated by the caller with
  * the expected length @expect_out_len for the output.
  * Returns false and sets @status on error. @status is required. */
-static bool
-_hmac_with_algorithm (BCRYPT_ALG_HANDLE hAlgorithm,
-                      const _mongocrypt_buffer_t *key,
-                      const _mongocrypt_buffer_t *in,
-                      _mongocrypt_buffer_t *out,
-                      uint32_t expect_out_len,
-                      mongocrypt_status_t *status)
-{
-   bool ret = false;
-   BCRYPT_HASH_HANDLE hHash;
-   NTSTATUS nt_status;
-
-   BSON_ASSERT_PARAM (key);
-   BSON_ASSERT_PARAM (in);
-   BSON_ASSERT_PARAM (out);
-
-   if (out->len != expect_out_len) {
-      CLIENT_ERR ("out does not contain " PRIu32 " bytes", expect_out_len);
-      return false;
-   }
-
-   nt_status = BCryptCreateHash (
-      hAlgorithm, &hHash, NULL, 0, (PUCHAR) key->data, (ULONG) key->len, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error initializing hmac: 0x%x", (int) nt_status);
-      /* Only call BCryptDestroyHash if BCryptCreateHash succeeded. */
-      return false;
-   }
-
-   nt_status = BCryptHashData (hHash, (PUCHAR) in->data, (ULONG) in->len, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error hashing data: 0x%x", (int) nt_status);
-      goto done;
-   }
-
-   nt_status = BCryptFinishHash (hHash, out->data, out->len, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error finishing hmac: 0x%x", (int) nt_status);
-      goto done;
-   }
-
-   ret = true;
+static bool _hmac_with_algorithm(BCRYPT_ALG_HANDLE hAlgorithm,
+                                 const _mongocrypt_buffer_t *key,
+                                 const _mongocrypt_buffer_t *in,
+                                 _mongocrypt_buffer_t *out,
+                                 uint32_t expect_out_len,
+                                 mongocrypt_status_t *status) {
+    bool ret = false;
+    BCRYPT_HASH_HANDLE hHash;
+    NTSTATUS nt_status;
+
+    BSON_ASSERT_PARAM(key);
+    BSON_ASSERT_PARAM(in);
+    BSON_ASSERT_PARAM(out);
+
+    if (out->len != expect_out_len) {
+        CLIENT_ERR("out does not contain " PRIu32 " bytes", expect_out_len);
+        return false;
+    }
+
+    nt_status = BCryptCreateHash(hAlgorithm, &hHash, NULL, 0, (PUCHAR)key->data, (ULONG)key->len, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error initializing hmac: 0x%x", (int)nt_status);
+        /* Only call BCryptDestroyHash if BCryptCreateHash succeeded. */
+        return false;
+    }
+
+    nt_status = BCryptHashData(hHash, (PUCHAR)in->data, (ULONG)in->len, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error hashing data: 0x%x", (int)nt_status);
+        goto done;
+    }
+
+    nt_status = BCryptFinishHash(hHash, out->data, out->len, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error finishing hmac: 0x%x", (int)nt_status);
+        goto done;
+    }
+
+    ret = true;
 done:
-   (void) BCryptDestroyHash (hHash);
-   return ret;
+    (void)BCryptDestroyHash(hHash);
+    return ret;
 }
 
-bool
-_native_crypto_hmac_sha_512 (const _mongocrypt_buffer_t *key,
-                             const _mongocrypt_buffer_t *in,
-                             _mongocrypt_buffer_t *out,
-                             mongocrypt_status_t *status)
-{
-   return _hmac_with_algorithm (
-      _algo_sha512_hmac, key, in, out, MONGOCRYPT_HMAC_SHA512_LEN, status);
+bool _native_crypto_hmac_sha_512(const _mongocrypt_buffer_t *key,
+                                 const _mongocrypt_buffer_t *in,
+                                 _mongocrypt_buffer_t *out,
+                                 mongocrypt_status_t *status) {
+    return _hmac_with_algorithm(_algo_sha512_hmac, key, in, out, MONGOCRYPT_HMAC_SHA512_LEN, status);
 }
 
+bool _native_crypto_random(_mongocrypt_buffer_t *out, uint32_t count, mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(out);
 
-bool
-_native_crypto_random (_mongocrypt_buffer_t *out,
-                       uint32_t count,
-                       mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (out);
-
-   NTSTATUS nt_status = BCryptGenRandom (_random, out->data, count, 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("BCryptGenRandom Failed: 0x%x", (int) nt_status);
-      return false;
-   }
+    NTSTATUS nt_status = BCryptGenRandom(_random, out->data, count, 0);
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("BCryptGenRandom Failed: 0x%x", (int)nt_status);
+        return false;
+    }
 
-   return true;
+    return true;
 }
 
 typedef struct {
-   BCRYPT_KEY_HANDLE key_handle;
+    BCRYPT_KEY_HANDLE key_handle;
 
-   unsigned char *input_block;
-   uint32_t input_block_len;
+    unsigned char *input_block;
+    uint32_t input_block_len;
 
-   unsigned char *output_block;
-   uint32_t output_block_len;
-   uint32_t output_block_ptr;
+    unsigned char *output_block;
+    uint32_t output_block_len;
+    uint32_t output_block_ptr;
 } cng_ctr_encrypt_state;
 
-static bool
-_cng_ctr_crypto_generate (cng_ctr_encrypt_state *state,
-                          mongocrypt_status_t *status)
-{
-   BSON_ASSERT (state);
+static bool _cng_ctr_crypto_generate(cng_ctr_encrypt_state *state, mongocrypt_status_t *status) {
+    BSON_ASSERT(state);
 
-   uint32_t bytesEncrypted = 0;
-   NTSTATUS nt_status = BCryptEncrypt (state->key_handle,
+    uint32_t bytesEncrypted = 0;
+    NTSTATUS nt_status = BCryptEncrypt(state->key_handle,
                                        state->input_block,
                                        state->input_block_len,
                                        NULL,
@@ -407,109 +371,99 @@ _cng_ctr_crypto_generate (cng_ctr_encrypt_state *state,
                                        state->output_block_len,
                                        &bytesEncrypted,
                                        0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("error encrypting: 0x%x", (int) nt_status);
-      return false;
-   }
-   BSON_ASSERT (bytesEncrypted);
-   state->output_block_ptr = 0;
-   return true;
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("error encrypting: 0x%x", (int)nt_status);
+        return false;
+    }
+    BSON_ASSERT(bytesEncrypted);
+    state->output_block_ptr = 0;
+    return true;
 }
 
-static void
-_cng_ctr_crypto_advance (cng_ctr_encrypt_state *state)
-{
-   BSON_ASSERT_PARAM (state);
-
-   /* Assert rather than return false/NULL since this function's type is void */
-   BSON_ASSERT (sizeof (BCRYPT_KEY_DATA_BLOB_HEADER) <=
-                UINT32_MAX - state->input_block_len);
-
-   uint32_t carry = 1;
-   for (int i = (int) state->input_block_len - 1; i >= 0 && carry != 0; --i) {
-      uint32_t bpp = (uint32_t) (state->input_block[i]) + carry;
-      carry = bpp >> 8;
-      state->input_block[i] = bpp & 0xFF;
-   }
+static void _cng_ctr_crypto_advance(cng_ctr_encrypt_state *state) {
+    BSON_ASSERT_PARAM(state);
+
+    /* Assert rather than return false/NULL since this function's type is void */
+    BSON_ASSERT(sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) <= UINT32_MAX - state->input_block_len);
+
+    uint32_t carry = 1;
+    for (int i = (int)state->input_block_len - 1; i >= 0 && carry != 0; --i) {
+        uint32_t bpp = (uint32_t)(state->input_block[i]) + carry;
+        carry = bpp >> 8;
+        state->input_block[i] = bpp & 0xFF;
+    }
 }
 
-static bool
-_cng_ctr_crypto_next (cng_ctr_encrypt_state *state,
-                      mongocrypt_status_t *status,
-                      unsigned char *mask)
-{
-   BSON_ASSERT_PARAM (state);
-   BSON_ASSERT_PARAM (mask);
-
-   if (state->output_block_ptr >= state->output_block_len) {
-      _cng_ctr_crypto_advance (state);
-      if (!_cng_ctr_crypto_generate (state, status)) {
-         return false;
-      };
-   }
-
-   *mask = state->output_block[state->output_block_ptr];
-   ++state->output_block_ptr;
-
-   return true;
+static bool _cng_ctr_crypto_next(cng_ctr_encrypt_state *state, mongocrypt_status_t *status, unsigned char *mask) {
+    BSON_ASSERT_PARAM(state);
+    BSON_ASSERT_PARAM(mask);
+
+    if (state->output_block_ptr >= state->output_block_len) {
+        _cng_ctr_crypto_advance(state);
+        if (!_cng_ctr_crypto_generate(state, status)) {
+            return false;
+        };
+    }
+
+    *mask = state->output_block[state->output_block_ptr];
+    ++state->output_block_ptr;
+
+    return true;
 }
 
-static void
-_cng_ctr_crypto_state_destroy (cng_ctr_encrypt_state *state);
+static void _cng_ctr_crypto_state_destroy(cng_ctr_encrypt_state *state);
 
-static cng_ctr_encrypt_state *
-_cng_ctr_crypto_state_init (const _mongocrypt_buffer_t *key,
-                            const _mongocrypt_buffer_t *iv,
-                            mongocrypt_status_t *status)
-{
-   cng_ctr_encrypt_state *state;
-   uint32_t keyBlobLength;
-   unsigned char *keyBlob;
-   BCRYPT_KEY_DATA_BLOB_HEADER blobHeader;
-   NTSTATUS nt_status;
+static cng_ctr_encrypt_state *_cng_ctr_crypto_state_init(const _mongocrypt_buffer_t *key,
+                                                         const _mongocrypt_buffer_t *iv,
+                                                         mongocrypt_status_t *status) {
+    cng_ctr_encrypt_state *state;
+    uint32_t keyBlobLength;
+    unsigned char *keyBlob;
+    BCRYPT_KEY_DATA_BLOB_HEADER blobHeader;
+    NTSTATUS nt_status;
 
-   BSON_ASSERT_PARAM (key);
-   BSON_ASSERT_PARAM (iv);
+    BSON_ASSERT_PARAM(key);
+    BSON_ASSERT_PARAM(iv);
 
-   keyBlob = NULL;
+    keyBlob = NULL;
 
-   state = bson_malloc0 (sizeof (*state));
-   BSON_ASSERT (state);
+    state = bson_malloc0(sizeof(*state));
+    BSON_ASSERT(state);
 
-   if (UINT32_MAX - key->len < sizeof (BCRYPT_KEY_DATA_BLOB_HEADER)) {
-      CLIENT_ERR ("key is too long");
-      goto fail;
-   }
+    if (UINT32_MAX - key->len < sizeof(BCRYPT_KEY_DATA_BLOB_HEADER)) {
+        CLIENT_ERR("key is too long");
+        goto fail;
+    }
 
-   state->key_handle = INVALID_HANDLE_VALUE;
+    state->key_handle = INVALID_HANDLE_VALUE;
 
-   /* Initialize input storage buffer */
-   state->input_block = bson_malloc0 (_aes256_block_length);
-   BSON_ASSERT (state->input_block);
-   state->input_block_len = _aes256_block_length;
-   BSON_ASSERT (iv->len == _aes256_block_length);
-   memcpy (state->input_block, iv->data, iv->len);
+    /* Initialize input storage buffer */
+    state->input_block = bson_malloc0(_aes256_block_length);
+    BSON_ASSERT(state->input_block);
+    state->input_block_len = _aes256_block_length;
+    BSON_ASSERT(iv->len == _aes256_block_length);
+    memcpy(state->input_block, iv->data, iv->len);
 
-   /* Initialize output storage buffer */
-   state->output_block = bson_malloc0 (_aes256_block_length);
-   BSON_ASSERT (state->output_block);
-   state->output_block_len = _aes256_block_length;
-   state->output_block_ptr = 0;
+    /* Initialize output storage buffer */
+    state->output_block = bson_malloc0(_aes256_block_length);
+    BSON_ASSERT(state->output_block);
+    state->output_block_len = _aes256_block_length;
+    state->output_block_ptr = 0;
 
-   /* Allocate temporary buffer for key import */
-   keyBlobLength = sizeof (BCRYPT_KEY_DATA_BLOB_HEADER) + key->len;
-   keyBlob = bson_malloc0 (keyBlobLength);
-   BSON_ASSERT (keyBlob);
+    /* Allocate temporary buffer for key import */
+    keyBlobLength = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->len;
+    keyBlob = bson_malloc0(keyBlobLength);
+    BSON_ASSERT(keyBlob);
 
-   blobHeader.dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
-   blobHeader.dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
-   blobHeader.cbKeyData = key->len;
+    blobHeader.dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
+    blobHeader.dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
+    blobHeader.cbKeyData = key->len;
 
-   memcpy (keyBlob, &blobHeader, sizeof (BCRYPT_KEY_DATA_BLOB_HEADER));
+    memcpy(keyBlob, &blobHeader, sizeof(BCRYPT_KEY_DATA_BLOB_HEADER));
 
-   memcpy (keyBlob + sizeof (BCRYPT_KEY_DATA_BLOB_HEADER), key->data, key->len);
+    memcpy(keyBlob + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER), key->data, key->len);
 
-   nt_status = BCryptImportKey (_algo_aes256_ecb,
+    nt_status = BCryptImportKey(_algo_aes256_ecb,
                                 NULL,
                                 BCRYPT_KEY_DATA_BLOB,
                                 &(state->key_handle),
@@ -518,123 +472,114 @@ _cng_ctr_crypto_state_init (const _mongocrypt_buffer_t *key,
                                 keyBlob,
                                 keyBlobLength,
                                 0);
-   if (nt_status != STATUS_SUCCESS) {
-      CLIENT_ERR ("Import Key Failed: 0x%x", (int) nt_status);
-      goto fail;
-   }
+    if (nt_status != STATUS_SUCCESS) {
+        CLIENT_ERR("Import Key Failed: 0x%x", (int)nt_status);
+        goto fail;
+    }
 
-   bson_free (keyBlob);
+    bson_free(keyBlob);
 
-   if (!_cng_ctr_crypto_generate (state, status)) {
-      goto fail;
-   }
+    if (!_cng_ctr_crypto_generate(state, status)) {
+        goto fail;
+    }
 
-   return state;
+    return state;
 fail:
-   _cng_ctr_crypto_state_destroy (state);
-   bson_free (keyBlob);
+    _cng_ctr_crypto_state_destroy(state);
+    bson_free(keyBlob);
 
-   return NULL;
+    return NULL;
 }
 
-static void
-_cng_ctr_crypto_state_destroy (cng_ctr_encrypt_state *state)
-{
-   if (state) {
-      if (state->key_handle != INVALID_HANDLE_VALUE) {
-         BCryptDestroyKey (state->key_handle);
-      }
-
-      bson_free (state->input_block);
-      bson_free (state->output_block);
-      bson_free (state);
-   }
+static void _cng_ctr_crypto_state_destroy(cng_ctr_encrypt_state *state) {
+    if (state) {
+        if (state->key_handle != INVALID_HANDLE_VALUE) {
+            BCryptDestroyKey(state->key_handle);
+        }
+
+        bson_free(state->input_block);
+        bson_free(state->output_block);
+        bson_free(state);
+    }
 }
 
-bool
-_native_crypto_aes_256_ctr_encrypt (aes_256_args_t args)
-{
-   bool ret = false;
-   cng_ctr_encrypt_state *state = NULL;
-   mongocrypt_status_t *status = args.status;
-
-   BSON_ASSERT (args.in && args.in->data);
-   BSON_ASSERT (args.out && args.out->data);
-   if (args.out->len < args.in->len) {
-      CLIENT_ERR ("Output buffer is too small");
-      goto fail;
-   }
-
-   state = _cng_ctr_crypto_state_init (args.key, args.iv, status);
-   if (!state) {
-      goto fail;
-   }
-
-   for (uint32_t i = 0; i < args.in->len; ++i) {
-      unsigned char mask;
-      if (!_cng_ctr_crypto_next (state, status, &mask)) {
-         goto fail;
-      }
-      args.out->data[i] = args.in->data[i] ^ mask;
-   }
-
-   if (args.bytes_written) {
-      *args.bytes_written = args.in->len;
-   }
-
-   ret = true;
+bool _native_crypto_aes_256_ctr_encrypt(aes_256_args_t args) {
+    bool ret = false;
+    cng_ctr_encrypt_state *state = NULL;
+    mongocrypt_status_t *status = args.status;
+
+    BSON_ASSERT(args.in && args.in->data);
+    BSON_ASSERT(args.out && args.out->data);
+    if (args.out->len < args.in->len) {
+        CLIENT_ERR("Output buffer is too small");
+        goto fail;
+    }
+
+    state = _cng_ctr_crypto_state_init(args.key, args.iv, status);
+    if (!state) {
+        goto fail;
+    }
+
+    for (uint32_t i = 0; i < args.in->len; ++i) {
+        unsigned char mask;
+        if (!_cng_ctr_crypto_next(state, status, &mask)) {
+            goto fail;
+        }
+        args.out->data[i] = args.in->data[i] ^ mask;
+    }
+
+    if (args.bytes_written) {
+        *args.bytes_written = args.in->len;
+    }
+
+    ret = true;
 
 fail:
-   _cng_ctr_crypto_state_destroy (state);
-   return ret;
+    _cng_ctr_crypto_state_destroy(state);
+    return ret;
 }
 
-bool
-_native_crypto_aes_256_ctr_decrypt (aes_256_args_t args)
-{
-   bool ret = false;
-   cng_ctr_encrypt_state *state = NULL;
-   mongocrypt_status_t *status = args.status;
-
-   BSON_ASSERT (args.in && args.in->data);
-   BSON_ASSERT (args.out && args.out->data);
-   if (args.out->len < args.in->len) {
-      CLIENT_ERR ("Output buffer is too small");
-      goto fail;
-   }
-
-   state = _cng_ctr_crypto_state_init (args.key, args.iv, status);
-   if (!state) {
-      goto fail;
-   }
-
-   for (uint32_t i = 0; i < args.in->len; ++i) {
-      unsigned char mask;
-      if (!_cng_ctr_crypto_next (state, status, &mask)) {
-         goto fail;
-      }
-      args.out->data[i] = args.in->data[i] ^ mask;
-   }
-
-   if (args.bytes_written) {
-      *args.bytes_written = args.in->len;
-   }
-
-   ret = true;
+bool _native_crypto_aes_256_ctr_decrypt(aes_256_args_t args) {
+    bool ret = false;
+    cng_ctr_encrypt_state *state = NULL;
+    mongocrypt_status_t *status = args.status;
+
+    BSON_ASSERT(args.in && args.in->data);
+    BSON_ASSERT(args.out && args.out->data);
+    if (args.out->len < args.in->len) {
+        CLIENT_ERR("Output buffer is too small");
+        goto fail;
+    }
+
+    state = _cng_ctr_crypto_state_init(args.key, args.iv, status);
+    if (!state) {
+        goto fail;
+    }
+
+    for (uint32_t i = 0; i < args.in->len; ++i) {
+        unsigned char mask;
+        if (!_cng_ctr_crypto_next(state, status, &mask)) {
+            goto fail;
+        }
+        args.out->data[i] = args.in->data[i] ^ mask;
+    }
+
+    if (args.bytes_written) {
+        *args.bytes_written = args.in->len;
+    }
+
+    ret = true;
 
 fail:
-   _cng_ctr_crypto_state_destroy (state);
-   return ret;
+    _cng_ctr_crypto_state_destroy(state);
+    return ret;
 }
 
-bool
-_native_crypto_hmac_sha_256 (const _mongocrypt_buffer_t *key,
-                             const _mongocrypt_buffer_t *in,
-                             _mongocrypt_buffer_t *out,
-                             mongocrypt_status_t *status)
-{
-   return _hmac_with_algorithm (
-      _algo_sha256_hmac, key, in, out, MONGOCRYPT_HMAC_SHA256_LEN, status);
+bool _native_crypto_hmac_sha_256(const _mongocrypt_buffer_t *key,
+                                 const _mongocrypt_buffer_t *in,
+                                 _mongocrypt_buffer_t *out,
+                                 mongocrypt_status_t *status) {
+    return _hmac_with_algorithm(_algo_sha256_hmac, key, in, out, MONGOCRYPT_HMAC_SHA256_LEN, status);
 }
 
 #endif /* MONGOCRYPT_ENABLE_CRYPTO_CNG */