grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/cipher/{e_aes.c.inc → e_aes.cc.inc}

@@ -57,17 +57,17 @@
 #include <openssl/mem.h>
 #include <openssl/nid.h>
 
-#include "internal.h"
 #include "../../internal.h"
 #include "../aes/internal.h"
 #include "../bcm_interface.h"
+#include "../delocate.h"
 #include "../modes/internal.h"
 #include "../service_indicator/internal.h"
-#include "../delocate.h"
+#include "internal.h"
 
 
 OPENSSL_MSVC_PRAGMA(warning(push))
-OPENSSL_MSVC_PRAGMA(warning(disable: 4702))  // Unreachable code.
+OPENSSL_MSVC_PRAGMA(warning(disable : 4702))  // Unreachable code.
 
 #define AES_GCM_NONCE_LENGTH 12
 
@@ -131,9 +131,9 @@ typedef struct {
   int key_set;  // Set if key initialised
   int iv_set;   // Set if an iv is set
   uint8_t *iv;  // Temporary IV store
-  int ivlen;         // IV length
+  int ivlen;    // IV length
   int taglen;
-  int iv_gen;      // It is OK to generate IVs
+  int iv_gen;  // It is OK to generate IVs
   ctr128_f ctr;
 } EVP_AES_GCM_CTX;
 
@@ -332,7 +332,7 @@ ctr128_f aes_ctr_set_key(AES_KEY *aes_key, GCM128_KEY *gcm_key,
 }
 
 #if defined(OPENSSL_32_BIT)
-#define EVP_AES_GCM_CTX_PADDING (4+8)
+#define EVP_AES_GCM_CTX_PADDING (4 + 8)
 #else
 #define EVP_AES_GCM_CTX_PADDING 8
 #endif
@@ -347,7 +347,7 @@ static EVP_AES_GCM_CTX *aes_gcm_from_cipher_ctx(EVP_CIPHER_CTX *ctx) {
   assert(ctx->cipher->ctx_size ==
          sizeof(EVP_AES_GCM_CTX) + EVP_AES_GCM_CTX_PADDING);
 
-  char *ptr = ctx->cipher_data;
+  char *ptr = reinterpret_cast<char *>(ctx->cipher_data);
 #if defined(OPENSSL_32_BIT)
   assert((uintptr_t)ptr % 4 == 0);
   ptr += (uintptr_t)ptr & 4;
@@ -430,7 +430,7 @@ static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) {
         if (gctx->iv != c->iv) {
           OPENSSL_free(gctx->iv);
         }
-        gctx->iv = OPENSSL_malloc(arg);
+        gctx->iv = reinterpret_cast<uint8_t *>(OPENSSL_malloc(arg));
         if (!gctx->iv) {
           return 0;
         }
@@ -508,7 +508,7 @@ static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) {
       return 1;
 
     case EVP_CTRL_COPY: {
-      EVP_CIPHER_CTX *out = ptr;
+      EVP_CIPHER_CTX *out = reinterpret_cast<EVP_CIPHER_CTX *>(ptr);
       EVP_AES_GCM_CTX *gctx_out = aes_gcm_from_cipher_ctx(out);
       // |EVP_CIPHER_CTX_copy| copies this generically, but we must redo it in
       // case |out->cipher_data| and |in->cipher_data| are differently aligned.
@@ -516,7 +516,8 @@ static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) {
       if (gctx->iv == c->iv) {
         gctx_out->iv = out->iv;
       } else {
-        gctx_out->iv = OPENSSL_memdup(gctx->iv, gctx->ivlen);
+        gctx_out->iv =
+            reinterpret_cast<uint8_t *>(OPENSSL_memdup(gctx->iv, gctx->ivlen));
         if (!gctx_out->iv) {
           return 0;
         }
@@ -809,7 +810,9 @@ static int aes_hw_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
     return 1;
   }
 
-  aes_hw_ecb_encrypt(in, out, len, ctx->cipher_data, ctx->encrypt);
+  aes_hw_ecb_encrypt(in, out, len,
+                     reinterpret_cast<const AES_KEY *>(ctx->cipher_data),
+                     ctx->encrypt);
 
   return 1;
 }
@@ -927,7 +930,7 @@ static_assert(alignof(union evp_aead_ctx_st_state) >=
 
 static int aead_aes_gcm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                              size_t key_len, size_t requested_tag_len) {
-  struct aead_aes_gcm_ctx *gcm_ctx = (struct aead_aes_gcm_ctx *) &ctx->state;
+  struct aead_aes_gcm_ctx *gcm_ctx = (struct aead_aes_gcm_ctx *)&ctx->state;
 
   size_t actual_tag_len;
   if (!aead_aes_gcm_init_impl(gcm_ctx, &actual_tag_len, key, key_len,
@@ -942,13 +945,10 @@ static int aead_aes_gcm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
 static void aead_aes_gcm_cleanup(EVP_AEAD_CTX *ctx) {}
 
 static int aead_aes_gcm_seal_scatter_impl(
-    const struct aead_aes_gcm_ctx *gcm_ctx,
-    uint8_t *out, uint8_t *out_tag, size_t *out_tag_len, size_t max_out_tag_len,
-    const uint8_t *nonce, size_t nonce_len,
-    const uint8_t *in, size_t in_len,
-    const uint8_t *extra_in, size_t extra_in_len,
-    const uint8_t *ad, size_t ad_len,
-    size_t tag_len) {
+    const struct aead_aes_gcm_ctx *gcm_ctx, uint8_t *out, uint8_t *out_tag,
+    size_t *out_tag_len, size_t max_out_tag_len, const uint8_t *nonce,
+    size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *extra_in,
+    size_t extra_in_len, const uint8_t *ad, size_t ad_len, size_t tag_len) {
   if (extra_in_len + tag_len < tag_len) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
     return 0;
@@ -1003,14 +1003,11 @@ static int aead_aes_gcm_seal_scatter_impl(
   return 1;
 }
 
-static int aead_aes_gcm_seal_scatter(const EVP_AEAD_CTX *ctx, uint8_t *out,
-                                     uint8_t *out_tag, size_t *out_tag_len,
-                                     size_t max_out_tag_len,
-                                     const uint8_t *nonce, size_t nonce_len,
-                                     const uint8_t *in, size_t in_len,
-                                     const uint8_t *extra_in,
-                                     size_t extra_in_len,
-                                     const uint8_t *ad, size_t ad_len) {
+static int aead_aes_gcm_seal_scatter(
+    const EVP_AEAD_CTX *ctx, uint8_t *out, uint8_t *out_tag,
+    size_t *out_tag_len, size_t max_out_tag_len, const uint8_t *nonce,
+    size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *extra_in,
+    size_t extra_in_len, const uint8_t *ad, size_t ad_len) {
   const struct aead_aes_gcm_ctx *gcm_ctx =
       (const struct aead_aes_gcm_ctx *)&ctx->state;
   return aead_aes_gcm_seal_scatter_impl(
@@ -1019,13 +1016,11 @@ static int aead_aes_gcm_seal_scatter(const EVP_AEAD_CTX *ctx, uint8_t *out,
 }
 
 static int aead_aes_gcm_open_gather_impl(const struct aead_aes_gcm_ctx *gcm_ctx,
-                                         uint8_t *out,
-                                         const uint8_t *nonce, size_t nonce_len,
-                                         const uint8_t *in, size_t in_len,
-                                         const uint8_t *in_tag,
-                                         size_t in_tag_len,
-                                         const uint8_t *ad, size_t ad_len,
-                                         size_t tag_len) {
+                                         uint8_t *out, const uint8_t *nonce,
+                                         size_t nonce_len, const uint8_t *in,
+                                         size_t in_len, const uint8_t *in_tag,
+                                         size_t in_tag_len, const uint8_t *ad,
+                                         size_t ad_len, size_t tag_len) {
   uint8_t tag[EVP_AEAD_AES_GCM_TAG_LEN];
 
   if (nonce_len == 0) {
@@ -1150,12 +1145,11 @@ static int aead_aes_gcm_init_randnonce(EVP_AEAD_CTX *ctx, const uint8_t *key,
 }
 
 static int aead_aes_gcm_seal_scatter_randnonce(
-    const EVP_AEAD_CTX *ctx,
-    uint8_t *out, uint8_t *out_tag, size_t *out_tag_len, size_t max_out_tag_len,
-    const uint8_t *external_nonce, size_t external_nonce_len,
-    const uint8_t *in, size_t in_len,
-    const uint8_t *extra_in, size_t extra_in_len,
-    const uint8_t *ad, size_t ad_len) {
+    const EVP_AEAD_CTX *ctx, uint8_t *out, uint8_t *out_tag,
+    size_t *out_tag_len, size_t max_out_tag_len, const uint8_t *external_nonce,
+    size_t external_nonce_len, const uint8_t *in, size_t in_len,
+    const uint8_t *extra_in, size_t extra_in_len, const uint8_t *ad,
+    size_t ad_len) {
   if (external_nonce_len != 0) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE);
     return 0;
@@ -1193,11 +1187,10 @@ static int aead_aes_gcm_seal_scatter_randnonce(
 }
 
 static int aead_aes_gcm_open_gather_randnonce(
-    const EVP_AEAD_CTX *ctx, uint8_t *out,
-    const uint8_t *external_nonce, size_t external_nonce_len,
-    const uint8_t *in, size_t in_len,
-    const uint8_t *in_tag, size_t in_tag_len,
-    const uint8_t *ad, size_t ad_len) {
+    const EVP_AEAD_CTX *ctx, uint8_t *out, const uint8_t *external_nonce,
+    size_t external_nonce_len, const uint8_t *in, size_t in_len,
+    const uint8_t *in_tag, size_t in_tag_len, const uint8_t *ad,
+    size_t ad_len) {
   if (external_nonce_len != 0) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE);
     return 0;
@@ -1212,9 +1205,9 @@ static int aead_aes_gcm_open_gather_randnonce(
   const struct aead_aes_gcm_ctx *gcm_ctx =
       (const struct aead_aes_gcm_ctx *)&ctx->state;
   if (!aead_aes_gcm_open_gather_impl(
-      gcm_ctx, out, nonce, AES_GCM_NONCE_LENGTH, in, in_len, in_tag,
-      in_tag_len - AES_GCM_NONCE_LENGTH, ad, ad_len,
-      ctx->tag_len - AES_GCM_NONCE_LENGTH)) {
+          gcm_ctx, out, nonce, AES_GCM_NONCE_LENGTH, in, in_len, in_tag,
+          in_tag_len - AES_GCM_NONCE_LENGTH, ad, ad_len,
+          ctx->tag_len - AES_GCM_NONCE_LENGTH)) {
     return 0;
   }
 
@@ -1267,7 +1260,7 @@ static_assert(alignof(union evp_aead_ctx_st_state) >=
 static int aead_aes_gcm_tls12_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                    size_t key_len, size_t requested_tag_len) {
   struct aead_aes_gcm_tls12_ctx *gcm_ctx =
-      (struct aead_aes_gcm_tls12_ctx *) &ctx->state;
+      (struct aead_aes_gcm_tls12_ctx *)&ctx->state;
 
   gcm_ctx->min_next_nonce = 0;
 
@@ -1287,7 +1280,7 @@ static int aead_aes_gcm_tls12_seal_scatter(
     size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *extra_in,
     size_t extra_in_len, const uint8_t *ad, size_t ad_len) {
   struct aead_aes_gcm_tls12_ctx *gcm_ctx =
-      (struct aead_aes_gcm_tls12_ctx *) &ctx->state;
+      (struct aead_aes_gcm_tls12_ctx *)&ctx->state;
 
   if (nonce_len != AES_GCM_NONCE_LENGTH) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_UNSUPPORTED_NONCE_SIZE);
@@ -1361,7 +1354,7 @@ static_assert(alignof(union evp_aead_ctx_st_state) >=
 static int aead_aes_gcm_tls13_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                    size_t key_len, size_t requested_tag_len) {
   struct aead_aes_gcm_tls13_ctx *gcm_ctx =
-      (struct aead_aes_gcm_tls13_ctx *) &ctx->state;
+      (struct aead_aes_gcm_tls13_ctx *)&ctx->state;
 
   gcm_ctx->min_next_nonce = 0;
   gcm_ctx->first = 1;
@@ -1382,7 +1375,7 @@ static int aead_aes_gcm_tls13_seal_scatter(
     size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *extra_in,
     size_t extra_in_len, const uint8_t *ad, size_t ad_len) {
   struct aead_aes_gcm_tls13_ctx *gcm_ctx =
-      (struct aead_aes_gcm_tls13_ctx *) &ctx->state;
+      (struct aead_aes_gcm_tls13_ctx *)&ctx->state;
 
   if (nonce_len != AES_GCM_NONCE_LENGTH) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_UNSUPPORTED_NONCE_SIZE);
@@ -1403,8 +1396,7 @@ static int aead_aes_gcm_tls13_seal_scatter(
   }
   given_counter ^= gcm_ctx->mask;
 
-  if (given_counter == UINT64_MAX ||
-      given_counter < gcm_ctx->min_next_nonce) {
+  if (given_counter == UINT64_MAX || given_counter < gcm_ctx->min_next_nonce) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE);
     return 0;
   }

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/cmac/{cmac.c.inc → cmac.cc.inc}

@@ -119,7 +119,7 @@ int AES_CMAC(uint8_t out[16], const uint8_t *key, size_t key_len,
 }
 
 CMAC_CTX *CMAC_CTX_new(void) {
-  CMAC_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));
+  CMAC_CTX *ctx = reinterpret_cast<CMAC_CTX *>(OPENSSL_malloc(sizeof(*ctx)));
   if (ctx != NULL) {
     CMAC_CTX_init(ctx);
   }
@@ -155,7 +155,7 @@ static void binary_field_mul_x_128(uint8_t out[16], const uint8_t in[16]) {
 
   // Shift |in| to left, including carry.
   for (i = 0; i < 15; i++) {
-    out[i] = (in[i] << 1) | (in[i+1] >> 7);
+    out[i] = (in[i] << 1) | (in[i + 1] >> 7);
   }
 
   // If MSB set fixup with R.
@@ -172,7 +172,7 @@ static void binary_field_mul_x_64(uint8_t out[8], const uint8_t in[8]) {
 
   // Shift |in| to left, including carry.
   for (i = 0; i < 7; i++) {
-    out[i] = (in[i] << 1) | (in[i+1] >> 7);
+    out[i] = (in[i] << 1) | (in[i + 1] >> 7);
   }
 
   // If MSB set fixup with R.
@@ -194,7 +194,8 @@ int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t key_len,
   size_t block_size = EVP_CIPHER_block_size(cipher);
   if ((block_size != AES_BLOCK_SIZE && block_size != 8 /* 3-DES */) ||
       EVP_CIPHER_key_length(cipher) != key_len ||
-      !EVP_EncryptInit_ex(&ctx->cipher_ctx, cipher, NULL, key, kZeroIV) ||
+      !EVP_EncryptInit_ex(&ctx->cipher_ctx, cipher, NULL,
+                          reinterpret_cast<const uint8_t *>(key), kZeroIV) ||
       !EVP_Cipher(&ctx->cipher_ctx, scratch, kZeroIV, block_size) ||
       // Reset context again ready for first data.
       !EVP_EncryptInit_ex(&ctx->cipher_ctx, NULL, NULL, NULL, kZeroIV)) {
@@ -291,13 +292,12 @@ int CMAC_Final(CMAC_CTX *ctx, uint8_t *out, size_t *out_len) {
   FIPS_service_indicator_lock_state();
 
   *out_len = block_size;
+  const uint8_t *mask = ctx->k1;
   if (out == NULL) {
     ret = 1;
     goto out;
   }
 
-  const uint8_t *mask = ctx->k1;
-
   if (ctx->block_used != block_size) {
     // If the last block is incomplete, terminate it with a single 'one' bit
     // followed by zeros.

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/delocate.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -22,19 +22,23 @@
 
 #if !defined(BORINGSSL_SHARED_LIBRARY) && defined(BORINGSSL_FIPS) && \
     !defined(OPENSSL_ASAN) && !defined(OPENSSL_MSAN)
-#define DEFINE_BSS_GET(type, name)        \
-  static type name __attribute__((used)); \
-  type *name##_bss_get(void) __attribute__((const));
+#define DEFINE_BSS_GET(type, name, init_value)         \
+  static type name __attribute__((used)) = init_value; \
+  extern "C" {                                         \
+  type *name##_bss_get(void) __attribute__((const));   \
+  }
 // For FIPS builds we require that CRYPTO_ONCE_INIT be zero.
-#define DEFINE_STATIC_ONCE(name) DEFINE_BSS_GET(CRYPTO_once_t, name)
+#define DEFINE_STATIC_ONCE(name) \
+  DEFINE_BSS_GET(CRYPTO_once_t, name, CRYPTO_ONCE_INIT)
 // For FIPS builds we require that CRYPTO_MUTEX_INIT be zero.
-#define DEFINE_STATIC_MUTEX(name) DEFINE_BSS_GET(CRYPTO_MUTEX, name)
+#define DEFINE_STATIC_MUTEX(name) \
+  DEFINE_BSS_GET(CRYPTO_MUTEX, name, CRYPTO_MUTEX_INIT)
 // For FIPS builds we require that CRYPTO_EX_DATA_CLASS_INIT be zero.
 #define DEFINE_STATIC_EX_DATA_CLASS(name) \
-  DEFINE_BSS_GET(CRYPTO_EX_DATA_CLASS, name)
+  DEFINE_BSS_GET(CRYPTO_EX_DATA_CLASS, name, CRYPTO_EX_DATA_CLASS_INIT)
 #else
-#define DEFINE_BSS_GET(type, name) \
-  static type name;                \
+#define DEFINE_BSS_GET(type, name, init_value) \
+  static type name = init_value;               \
   static type *name##_bss_get(void) { return &name; }
 #define DEFINE_STATIC_ONCE(name)                \
   static CRYPTO_once_t name = CRYPTO_ONCE_INIT; \
@@ -48,7 +52,7 @@
 #endif
 
 #define DEFINE_DATA(type, name, accessor_decorations)                         \
-  DEFINE_BSS_GET(type, name##_storage)                                        \
+  DEFINE_BSS_GET(type, name##_storage, {})                                    \
   DEFINE_STATIC_ONCE(name##_once)                                             \
   static void name##_do_init(type *out);                                      \
   static void name##_init(void) { name##_do_init(name##_storage_bss_get()); } \

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/dh/{dh.c.inc → dh.cc.inc}

@@ -59,8 +59,8 @@
 #include <string.h>
 
 #include <openssl/bn.h>
-#include <openssl/err.h>
 #include <openssl/digest.h>
+#include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/thread.h>
 
@@ -71,7 +71,7 @@
 
 
 DH *DH_new(void) {
-  DH *dh = OPENSSL_zalloc(sizeof(DH));
+  DH *dh = reinterpret_cast<DH *>(OPENSSL_zalloc(sizeof(DH)));
   if (dh == NULL) {
     return NULL;
   }
@@ -151,8 +151,7 @@ void DH_get0_pqg(const DH *dh, const BIGNUM **out_p, const BIGNUM **out_q,
 }
 
 int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g) {
-  if ((dh->p == NULL && p == NULL) ||
-      (dh->g == NULL && g == NULL)) {
+  if ((dh->p == NULL && p == NULL) || (dh->g == NULL && g == NULL)) {
     return 0;
   }
 
@@ -322,8 +321,7 @@ static int dh_compute_key(DH *dh, BIGNUM *out_shared_key,
 
   if (!BN_mod_exp_mont_consttime(out_shared_key, peers_key, dh->priv_key, dh->p,
                                  ctx, dh->method_mont_p) ||
-      !BN_copy(p_minus_1, dh->p) ||
-      !BN_sub_word(p_minus_1, 1)) {
+      !BN_copy(p_minus_1, dh->p) || !BN_sub_word(p_minus_1, 1)) {
     OPENSSL_PUT_ERROR(DH, ERR_R_BN_LIB);
     goto err;
   }
@@ -337,7 +335,7 @@ static int dh_compute_key(DH *dh, BIGNUM *out_shared_key,
 
   ret = 1;
 
- err:
+err:
   BN_CTX_end(ctx);
   return ret;
 }
@@ -353,8 +351,7 @@ int dh_compute_key_padded_no_self_test(unsigned char *out,
   int dh_size = DH_size(dh);
   int ret = -1;
   BIGNUM *shared_key = BN_CTX_get(ctx);
-  if (shared_key &&
-      dh_compute_key(dh, shared_key, peers_key, ctx) &&
+  if (shared_key && dh_compute_key(dh, shared_key, peers_key, ctx) &&
       BN_bn2bin_padded(out, dh_size, shared_key)) {
     ret = dh_size;
   }
@@ -405,7 +402,7 @@ int DH_compute_key_hashed(DH *dh, uint8_t *out, size_t *out_len,
 
   int ret = 0;
   const size_t dh_len = DH_size(dh);
-  uint8_t *shared_bytes = OPENSSL_malloc(dh_len);
+  uint8_t *shared_bytes = reinterpret_cast<uint8_t *>(OPENSSL_malloc(dh_len));
   unsigned out_len_unsigned;
   if (!shared_bytes ||
       // SP 800-56A is ambiguous about whether the output should be padded prior
@@ -423,7 +420,7 @@ int DH_compute_key_hashed(DH *dh, uint8_t *out, size_t *out_len,
   *out_len = digest_len;
   ret = 1;
 
- err:
+err:
   FIPS_service_indicator_unlock_state();
   OPENSSL_free(shared_bytes);
   return ret;
@@ -472,18 +469,17 @@ DH *DH_get_rfc7919_2048(void) {
   bn_set_static_words(ffdhe2048_p, kFFDHE2048Data,
                       OPENSSL_ARRAY_SIZE(kFFDHE2048Data));
 
-  if (!BN_rshift1(ffdhe2048_q, ffdhe2048_p) ||
-      !BN_set_word(ffdhe2048_g, 2) ||
+  if (!BN_rshift1(ffdhe2048_q, ffdhe2048_p) || !BN_set_word(ffdhe2048_g, 2) ||
       !DH_set0_pqg(dh, ffdhe2048_p, ffdhe2048_q, ffdhe2048_g)) {
     goto err;
   }
 
   return dh;
 
- err:
-    BN_free(ffdhe2048_p);
-    BN_free(ffdhe2048_q);
-    BN_free(ffdhe2048_g);
-    DH_free(dh);
-    return NULL;
+err:
+  BN_free(ffdhe2048_p);
+  BN_free(ffdhe2048_q);
+  BN_free(ffdhe2048_g);
+  DH_free(dh);
+  return NULL;
 }

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/dh/internal.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2022, Google Inc.
+/* Copyright 2022 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -26,8 +26,6 @@ extern "C" {
 #endif
 
 
-#define OPENSSL_DH_MAX_MODULUS_BITS 10000
-
 struct dh_st {
   BIGNUM *p;
   BIGNUM *g;

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/digest/{digest.c.inc → digest.cc.inc}

@@ -62,8 +62,8 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../../internal.h"
+#include "internal.h"
 
 
 int EVP_MD_type(const EVP_MD *md) { return md->type; }
@@ -82,7 +82,8 @@ void EVP_MD_CTX_init(EVP_MD_CTX *ctx) {
 }
 
 EVP_MD_CTX *EVP_MD_CTX_new(void) {
-  EVP_MD_CTX *ctx = OPENSSL_malloc(sizeof(EVP_MD_CTX));
+  EVP_MD_CTX *ctx =
+      reinterpret_cast<EVP_MD_CTX *>(OPENSSL_malloc(sizeof(EVP_MD_CTX)));
 
   if (ctx) {
     EVP_MD_CTX_init(ctx);
@@ -152,7 +153,8 @@ int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in) {
   if (in->digest != NULL) {
     if (out->digest != in->digest) {
       assert(in->digest->ctx_size != 0);
-      tmp_buf = OPENSSL_malloc(in->digest->ctx_size);
+      tmp_buf =
+          reinterpret_cast<uint8_t *>(OPENSSL_malloc(in->digest->ctx_size));
       if (tmp_buf == NULL) {
         if (pctx) {
           in->pctx_ops->free(pctx);
@@ -163,7 +165,7 @@ int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in) {
       // |md_data| will be the correct size in this case. It's removed from
       // |out| so that |EVP_MD_CTX_cleanup| doesn't free it, and then it's
       // reused.
-      tmp_buf = out->md_data;
+      tmp_buf = reinterpret_cast<uint8_t *>(out->md_data);
       out->md_data = NULL;
     }
   }
@@ -207,7 +209,8 @@ int EVP_MD_CTX_reset(EVP_MD_CTX *ctx) {
 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *engine) {
   if (ctx->digest != type) {
     assert(type->ctx_size != 0);
-    uint8_t *md_data = OPENSSL_malloc(type->ctx_size);
+    uint8_t *md_data =
+        reinterpret_cast<uint8_t *>(OPENSSL_malloc(type->ctx_size));
     if (md_data == NULL) {
       return 0;
     }
@@ -263,26 +266,27 @@ int EVP_Digest(const void *data, size_t count, uint8_t *out_md,
   return ret;
 }
 
-
-const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx) {
+const EVP_MD *EVP_MD_CTX_get0_md(const EVP_MD_CTX *ctx) {
   if (ctx == NULL) {
     return NULL;
   }
   return ctx->digest;
 }
 
+const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx) {
+  return EVP_MD_CTX_get0_md(ctx);
+}
+
 size_t EVP_MD_CTX_size(const EVP_MD_CTX *ctx) {
-  return EVP_MD_size(EVP_MD_CTX_md(ctx));
+  return EVP_MD_size(EVP_MD_CTX_get0_md(ctx));
 }
 
 size_t EVP_MD_CTX_block_size(const EVP_MD_CTX *ctx) {
-  return EVP_MD_block_size(EVP_MD_CTX_md(ctx));
+  return EVP_MD_block_size(EVP_MD_CTX_get0_md(ctx));
 }
 
 int EVP_MD_CTX_type(const EVP_MD_CTX *ctx) {
-  return EVP_MD_type(EVP_MD_CTX_md(ctx));
+  return EVP_MD_type(EVP_MD_CTX_get0_md(ctx));
 }
 
-int EVP_add_digest(const EVP_MD *digest) {
-  return 1;
-}
+int EVP_add_digest(const EVP_MD *digest) { return 1; }