grpc 1.69.0 → 1.70.1

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 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

data/third_party/boringssl-with-bazel/src/crypto/ecdsa_extra/{ecdsa_asn1.c → ecdsa_asn1.cc}

@@ -57,8 +57,8 @@
 
 #include <openssl/bn.h>
 #include <openssl/bytestring.h>
-#include <openssl/err.h>
 #include <openssl/ec_key.h>
+#include <openssl/err.h>
 #include <openssl/mem.h>
 
 #include "../bytestring/internal.h"
@@ -79,8 +79,7 @@ static ECDSA_SIG *ecdsa_sig_from_fixed(const EC_KEY *key, const uint8_t *in,
     return NULL;
   }
   ECDSA_SIG *ret = ECDSA_SIG_new();
-  if (ret == NULL ||
-      !BN_bin2bn(in, scalar_len, ret->r) ||
+  if (ret == NULL || !BN_bin2bn(in, scalar_len, ret->r) ||
       !BN_bin2bn(in + scalar_len, scalar_len, ret->s)) {
     ECDSA_SIG_free(ret);
     return NULL;
@@ -100,8 +99,7 @@ static int ecdsa_sig_to_fixed(const EC_KEY *key, uint8_t *out, size_t *out_len,
     OPENSSL_PUT_ERROR(EC, EC_R_BUFFER_TOO_SMALL);
     return 0;
   }
-  if (BN_is_negative(sig->r) ||
-      !BN_bn2bin_padded(out, scalar_len, sig->r) ||
+  if (BN_is_negative(sig->r) || !BN_bn2bin_padded(out, scalar_len, sig->r) ||
       BN_is_negative(sig->s) ||
       !BN_bn2bin_padded(out + scalar_len, scalar_len, sig->s)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
@@ -115,7 +113,7 @@ int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
                unsigned int *out_sig_len, const EC_KEY *eckey) {
   if (eckey->ecdsa_meth && eckey->ecdsa_meth->sign) {
     return eckey->ecdsa_meth->sign(digest, digest_len, sig, out_sig_len,
-                                   (EC_KEY*) eckey /* cast away const */);
+                                   (EC_KEY *)eckey /* cast away const */);
   }
 
   *out_sig_len = 0;
@@ -137,8 +135,7 @@ int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
   CBB cbb;
   CBB_init_fixed(&cbb, sig, ECDSA_size(eckey));
   size_t len;
-  if (!ECDSA_SIG_marshal(&cbb, s) ||
-      !CBB_finish(&cbb, NULL, &len)) {
+  if (!ECDSA_SIG_marshal(&cbb, s) || !CBB_finish(&cbb, NULL, &len)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     goto err;
   }
@@ -165,8 +162,8 @@ int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
 
   // Defend against potential laxness in the DER parser.
   size_t der_len;
-  if (!ECDSA_SIG_to_bytes(&der, &der_len, s) ||
-      der_len != sig_len || OPENSSL_memcmp(sig, der, sig_len) != 0) {
+  if (!ECDSA_SIG_to_bytes(&der, &der_len, s) || der_len != sig_len ||
+      OPENSSL_memcmp(sig, der, sig_len) != 0) {
     // This should never happen. crypto/bytestring is strictly DER.
     OPENSSL_PUT_ERROR(ECDSA, ERR_R_INTERNAL_ERROR);
     goto err;
@@ -205,7 +202,8 @@ size_t ECDSA_size(const EC_KEY *key) {
 }
 
 ECDSA_SIG *ECDSA_SIG_new(void) {
-  ECDSA_SIG *sig = OPENSSL_malloc(sizeof(ECDSA_SIG));
+  ECDSA_SIG *sig =
+      reinterpret_cast<ECDSA_SIG *>(OPENSSL_malloc(sizeof(ECDSA_SIG)));
   if (sig == NULL) {
     return NULL;
   }
@@ -228,13 +226,9 @@ void ECDSA_SIG_free(ECDSA_SIG *sig) {
   OPENSSL_free(sig);
 }
 
-const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig) {
-  return sig->r;
-}
+const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig) { return sig->r; }
 
-const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig) {
-  return sig->s;
-}
+const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig) { return sig->s; }
 
 void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **out_r,
                     const BIGNUM **out_s) {
@@ -301,8 +295,7 @@ ECDSA_SIG *ECDSA_SIG_parse(CBS *cbs) {
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
       !BN_parse_asn1_unsigned(&child, ret->r) ||
-      !BN_parse_asn1_unsigned(&child, ret->s) ||
-      CBS_len(&child) != 0) {
+      !BN_parse_asn1_unsigned(&child, ret->s) || CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
     ECDSA_SIG_free(ret);
     return NULL;
@@ -325,8 +318,7 @@ ECDSA_SIG *ECDSA_SIG_from_bytes(const uint8_t *in, size_t in_len) {
 int ECDSA_SIG_marshal(CBB *cbb, const ECDSA_SIG *sig) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
-      !BN_marshal_asn1(&child, sig->r) ||
-      !BN_marshal_asn1(&child, sig->s) ||
+      !BN_marshal_asn1(&child, sig->r) || !BN_marshal_asn1(&child, sig->s) ||
       !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     return 0;
@@ -338,8 +330,7 @@ int ECDSA_SIG_to_bytes(uint8_t **out_bytes, size_t *out_len,
                        const ECDSA_SIG *sig) {
   CBB cbb;
   CBB_zero(&cbb);
-  if (!CBB_init(&cbb, 0) ||
-      !ECDSA_SIG_marshal(&cbb, sig) ||
+  if (!CBB_init(&cbb, 0) || !ECDSA_SIG_marshal(&cbb, sig) ||
       !CBB_finish(&cbb, out_bytes, out_len)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
     CBB_cleanup(&cbb);
@@ -402,8 +393,7 @@ ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **out, const uint8_t **inp, long len) {
 
 int i2d_ECDSA_SIG(const ECDSA_SIG *sig, uint8_t **outp) {
   CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !ECDSA_SIG_marshal(&cbb, sig)) {
+  if (!CBB_init(&cbb, 0) || !ECDSA_SIG_marshal(&cbb, sig)) {
     CBB_cleanup(&cbb);
     return -1;
   }

data/third_party/boringssl-with-bazel/src/crypto/engine/{engine.c → engine.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 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
@@ -14,8 +14,8 @@
 
 #include <openssl/engine.h>
 
-#include <string.h>
 #include <assert.h>
+#include <string.h>
 
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
@@ -31,7 +31,9 @@ struct engine_st {
   ECDSA_METHOD *ecdsa_method;
 };
 
-ENGINE *ENGINE_new(void) { return OPENSSL_zalloc(sizeof(ENGINE)); }
+ENGINE *ENGINE_new(void) {
+  return reinterpret_cast<ENGINE *>(OPENSSL_zalloc(sizeof(ENGINE)));
+}
 
 int ENGINE_free(ENGINE *engine) {
   // Methods are currently required to be static so are not unref'ed.
@@ -46,17 +48,18 @@ int ENGINE_free(ENGINE *engine) {
 // static.
 static int set_method(void **out_member, const void *method, size_t method_size,
                       size_t compiled_size) {
-  const struct openssl_method_common_st *common = method;
+  const struct openssl_method_common_st *common =
+      reinterpret_cast<const openssl_method_common_st *>(method);
   if (method_size != compiled_size || !common->is_static) {
     return 0;
   }
 
-  *out_member = (void*) method;
+  *out_member = (void *)method;
   return 1;
 }
 
 int ENGINE_set_RSA_method(ENGINE *engine, const RSA_METHOD *method,
-                         size_t method_size) {
+                          size_t method_size) {
   return set_method((void **)&engine->rsa_method, method, method_size,
                     sizeof(RSA_METHOD));
 }
@@ -76,11 +79,12 @@ ECDSA_METHOD *ENGINE_get_ECDSA_method(const ENGINE *engine) {
 }
 
 void METHOD_ref(void *method_in) {
-  assert(((struct openssl_method_common_st*) method_in)->is_static);
+  assert(((struct openssl_method_common_st *)method_in)->is_static);
 }
 
 void METHOD_unref(void *method_in) {
-  struct openssl_method_common_st *method = method_in;
+  struct openssl_method_common_st *method =
+      reinterpret_cast<openssl_method_common_st *>(method_in);
 
   if (method == NULL) {
     return;

data/third_party/boringssl-with-bazel/src/crypto/err/{err.c → err.cc}

@@ -168,7 +168,7 @@ static char *strdup_libc_malloc(const char *str) {
   // |strdup| is not in C until C23, so MSVC triggers deprecation warnings, and
   // glibc and musl gate it on a feature macro. Reimplementing it is easier.
   size_t len = strlen(str);
-  char *ret = malloc(len + 1);
+  char *ret = reinterpret_cast<char *>(malloc(len + 1));
   if (ret != NULL) {
     memcpy(ret, str, len + 1);
   }
@@ -202,7 +202,7 @@ static int global_next_library = ERR_NUM_LIBS;
 static CRYPTO_MUTEX global_next_library_mutex = CRYPTO_MUTEX_INIT;
 
 static void err_state_free(void *statep) {
-  ERR_STATE *state = statep;
+  ERR_STATE *state = reinterpret_cast<ERR_STATE *>(statep);
 
   if (state == NULL) {
     return;
@@ -217,9 +217,10 @@ static void err_state_free(void *statep) {
 
 // err_get_state gets the ERR_STATE object for the current thread.
 static ERR_STATE *err_get_state(void) {
-  ERR_STATE *state = CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR);
+  ERR_STATE *state = reinterpret_cast<ERR_STATE *>(
+      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR));
   if (state == NULL) {
-    state = malloc(sizeof(ERR_STATE));
+    state = reinterpret_cast<ERR_STATE *>(malloc(sizeof(ERR_STATE)));
     if (state == NULL) {
       return NULL;
     }
@@ -380,19 +381,15 @@ int ERR_get_next_error_library(void) {
   return ret;
 }
 
-void ERR_remove_state(unsigned long pid) {
-  ERR_clear_error();
-}
+void ERR_remove_state(unsigned long pid) { ERR_clear_error(); }
 
-void ERR_clear_system_error(void) {
-  errno = 0;
-}
+void ERR_clear_system_error(void) { errno = 0; }
 
 // err_string_cmp is a compare function for searching error values with
 // |bsearch| in |err_string_lookup|.
 static int err_string_cmp(const void *a, const void *b) {
-  const uint32_t a_key = *((const uint32_t*) a) >> 15;
-  const uint32_t b_key = *((const uint32_t*) b) >> 15;
+  const uint32_t a_key = *((const uint32_t *)a) >> 15;
+  const uint32_t b_key = *((const uint32_t *)b) >> 15;
 
   if (a_key < b_key) {
     return -1;
@@ -406,8 +403,7 @@ static int err_string_cmp(const void *a, const void *b) {
 // err_string_lookup looks up the string associated with |lib| and |key| in
 // |values| and |string_data|. It returns the string or NULL if not found.
 static const char *err_string_lookup(uint32_t lib, uint32_t key,
-                                     const uint32_t *values,
-                                     size_t num_values,
+                                     const uint32_t *values, size_t num_values,
                                      const char *string_data) {
   // |values| points to data in err_data.h, which is generated by
   // err_data_generate.go. It's an array of uint32_t values. Each value has the
@@ -426,8 +422,8 @@ static const char *err_string_lookup(uint32_t lib, uint32_t key,
     return NULL;
   }
   uint32_t search_key = lib << 26 | key << 15;
-  const uint32_t *result = bsearch(&search_key, values, num_values,
-                                   sizeof(uint32_t), err_string_cmp);
+  const uint32_t *result = reinterpret_cast<const uint32_t *>(bsearch(
+      &search_key, values, num_values, sizeof(uint32_t), err_string_cmp));
   if (result == NULL) {
     return NULL;
   }
@@ -632,7 +628,7 @@ void ERR_print_errors_cb(ERR_print_errors_callback_t callback, void *ctx) {
 
   // thread_hash is the least-significant bits of the |ERR_STATE| pointer value
   // for this thread.
-  const unsigned long thread_hash = (uintptr_t) err_get_state();
+  const unsigned long thread_hash = (uintptr_t)err_get_state();
 
   for (;;) {
     packed_error = ERR_get_error_line_data(&file, &line, &data, &flags);
@@ -649,9 +645,9 @@ void ERR_print_errors_cb(ERR_print_errors_callback_t callback, void *ctx) {
   }
 }
 
-static int print_errors_to_file(const char* msg, size_t msg_len, void* ctx) {
+static int print_errors_to_file(const char *msg, size_t msg_len, void *ctx) {
   assert(msg[msg_len] == '\0');
-  FILE* fp = ctx;
+  FILE *fp = reinterpret_cast<FILE *>(ctx);
   int res = fputs(msg, fp);
   return res < 0 ? 0 : 1;
 }
@@ -722,16 +718,16 @@ static void err_add_error_vdata(unsigned num, va_list args) {
     }
     size_t substr_len = strlen(substr);
     if (SIZE_MAX - total_size < substr_len) {
-      return; // Would overflow.
+      return;  // Would overflow.
     }
     total_size += substr_len;
   }
   va_end(args_copy);
   if (total_size == SIZE_MAX) {
-      return; // Would overflow.
+    return;  // Would overflow.
   }
-  total_size += 1; // NUL terminator.
-  if ((buf = malloc(total_size)) == NULL) {
+  total_size += 1;  // NUL terminator.
+  if ((buf = reinterpret_cast<char *>(malloc(total_size))) == NULL) {
     return;
   }
   buf[0] = '\0';
@@ -741,10 +737,9 @@ static void err_add_error_vdata(unsigned num, va_list args) {
       continue;
     }
     if (OPENSSL_strlcat(buf, substr, total_size) >= total_size) {
-      assert(0); // should not be possible.
+      assert(0);  // should not be possible.
     }
   }
-  va_end(args);
   err_set_error_data(buf);
 }
 
@@ -855,7 +850,8 @@ ERR_SAVE_STATE *ERR_save_state(void) {
     return NULL;
   }
 
-  ERR_SAVE_STATE *ret = malloc(sizeof(ERR_SAVE_STATE));
+  ERR_SAVE_STATE *ret =
+      reinterpret_cast<ERR_SAVE_STATE *>(malloc(sizeof(ERR_SAVE_STATE)));
   if (ret == NULL) {
     return NULL;
   }
@@ -865,7 +861,8 @@ ERR_SAVE_STATE *ERR_save_state(void) {
                           ? state->top - state->bottom
                           : ERR_NUM_ERRORS + state->top - state->bottom;
   assert(num_errors < ERR_NUM_ERRORS);
-  ret->errors = malloc(num_errors * sizeof(struct err_error_st));
+  ret->errors = reinterpret_cast<err_error_st *>(
+      malloc(num_errors * sizeof(struct err_error_st)));
   if (ret->errors == NULL) {
     free(ret);
     return NULL;

data/third_party/boringssl-with-bazel/src/crypto/err/internal.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

data/third_party/boringssl-with-bazel/src/crypto/evp/{evp.c → evp.cc}

@@ -64,8 +64,8 @@
 #include <openssl/nid.h>
 #include <openssl/thread.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 // Node depends on |EVP_R_NOT_XOF_OR_INVALID_LENGTH|.
@@ -78,7 +78,8 @@ OPENSSL_DECLARE_ERROR_REASON(EVP, NOT_XOF_OR_INVALID_LENGTH)
 OPENSSL_DECLARE_ERROR_REASON(EVP, EMPTY_PSK)
 
 EVP_PKEY *EVP_PKEY_new(void) {
-  EVP_PKEY *ret = OPENSSL_zalloc(sizeof(EVP_PKEY));
+  EVP_PKEY *ret =
+      reinterpret_cast<EVP_PKEY *>(OPENSSL_zalloc(sizeof(EVP_PKEY)));
   if (ret == NULL) {
     return NULL;
   }
@@ -196,9 +197,7 @@ int EVP_PKEY_bits(const EVP_PKEY *pkey) {
   return 0;
 }
 
-int EVP_PKEY_id(const EVP_PKEY *pkey) {
-  return pkey->type;
-}
+int EVP_PKEY_id(const EVP_PKEY *pkey) { return pkey->type; }
 
 // evp_pkey_asn1_find returns the ASN.1 method table for the given |nid|, which
 // should be one of the |EVP_PKEY_*| values. It returns NULL if |nid| is
@@ -238,13 +237,13 @@ int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key) {
   // public API.
   switch (type) {
     case EVP_PKEY_RSA:
-      return EVP_PKEY_assign_RSA(pkey, key);
+      return EVP_PKEY_assign_RSA(pkey, reinterpret_cast<RSA *>(key));
     case EVP_PKEY_DSA:
-      return EVP_PKEY_assign_DSA(pkey, key);
+      return EVP_PKEY_assign_DSA(pkey, reinterpret_cast<DSA *>(key));
     case EVP_PKEY_EC:
-      return EVP_PKEY_assign_EC_KEY(pkey, key);
+      return EVP_PKEY_assign_EC_KEY(pkey, reinterpret_cast<EC_KEY *>(key));
     case EVP_PKEY_DH:
-      return EVP_PKEY_assign_DH(pkey, key);
+      return EVP_PKEY_assign_DH(pkey, reinterpret_cast<DH *>(key));
   }
 
   OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);

data/third_party/boringssl-with-bazel/src/crypto/evp/{evp_ctx.c → evp_ctx.cc}

@@ -67,15 +67,12 @@
 
 
 static const EVP_PKEY_METHOD *const evp_methods[] = {
-    &rsa_pkey_meth,
-    &ec_pkey_meth,
-    &ed25519_pkey_meth,
-    &x25519_pkey_meth,
-    &hkdf_pkey_meth,
+    &rsa_pkey_meth,    &ec_pkey_meth,   &ed25519_pkey_meth,
+    &x25519_pkey_meth, &hkdf_pkey_meth,
 };
 
 static const EVP_PKEY_METHOD *evp_pkey_meth_find(int type) {
-  for (size_t i = 0; i < sizeof(evp_methods)/sizeof(EVP_PKEY_METHOD*); i++) {
+  for (size_t i = 0; i < sizeof(evp_methods) / sizeof(EVP_PKEY_METHOD *); i++) {
     if (evp_methods[i]->pkey_id == type) {
       return evp_methods[i];
     }
@@ -86,7 +83,8 @@ static const EVP_PKEY_METHOD *evp_pkey_meth_find(int type) {
 
 static EVP_PKEY_CTX *evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *e,
                                       const EVP_PKEY_METHOD *pmeth) {
-  EVP_PKEY_CTX *ret = OPENSSL_zalloc(sizeof(EVP_PKEY_CTX));
+  EVP_PKEY_CTX *ret =
+      reinterpret_cast<EVP_PKEY_CTX *>(OPENSSL_zalloc(sizeof(EVP_PKEY_CTX)));
   if (!ret) {
     return NULL;
   }
@@ -155,7 +153,8 @@ EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx) {
     return NULL;
   }
 
-  EVP_PKEY_CTX *ret = OPENSSL_zalloc(sizeof(EVP_PKEY_CTX));
+  EVP_PKEY_CTX *ret =
+      reinterpret_cast<EVP_PKEY_CTX *>(OPENSSL_zalloc(sizeof(EVP_PKEY_CTX)));
   if (!ret) {
     return NULL;
   }

data/third_party/boringssl-with-bazel/src/crypto/evp/{p_dh.c → p_dh.cc}

@@ -23,7 +23,8 @@ typedef struct dh_pkey_ctx_st {
 } DH_PKEY_CTX;
 
 static int pkey_dh_init(EVP_PKEY_CTX *ctx) {
-  DH_PKEY_CTX *dctx = OPENSSL_zalloc(sizeof(DH_PKEY_CTX));
+  DH_PKEY_CTX *dctx =
+      reinterpret_cast<DH_PKEY_CTX *>(OPENSSL_zalloc(sizeof(DH_PKEY_CTX)));
   if (dctx == NULL) {
     return 0;
   }
@@ -37,8 +38,8 @@ static int pkey_dh_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
     return 0;
   }
 
-  const DH_PKEY_CTX *sctx = src->data;
-  DH_PKEY_CTX *dctx = dst->data;
+  const DH_PKEY_CTX *sctx = reinterpret_cast<DH_PKEY_CTX *>(src->data);
+  DH_PKEY_CTX *dctx = reinterpret_cast<DH_PKEY_CTX *>(dst->data);
   dctx->pad = sctx->pad;
   return 1;
 }
@@ -63,14 +64,14 @@ static int pkey_dh_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
 }
 
 static int pkey_dh_derive(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *out_len) {
-  DH_PKEY_CTX *dctx = ctx->data;
+  DH_PKEY_CTX *dctx = reinterpret_cast<DH_PKEY_CTX *>(ctx->data);
   if (ctx->pkey == NULL || ctx->peerkey == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_KEYS_NOT_SET);
     return 0;
   }
 
-  DH *our_key = ctx->pkey->pkey;
-  DH *peer_key = ctx->peerkey->pkey;
+  DH *our_key = reinterpret_cast<DH *>(ctx->pkey->pkey);
+  DH *peer_key = reinterpret_cast<DH *>(ctx->peerkey->pkey);
   if (our_key == NULL || peer_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_KEYS_NOT_SET);
     return 0;
@@ -104,7 +105,7 @@ static int pkey_dh_derive(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *out_len) {
 }
 
 static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
-  DH_PKEY_CTX *dctx = ctx->data;
+  DH_PKEY_CTX *dctx = reinterpret_cast<DH_PKEY_CTX *>(ctx->data);
   switch (type) {
     case EVP_PKEY_CTRL_PEER_KEY:
       // |EVP_PKEY_derive_set_peer| requires the key implement this command,
@@ -122,13 +123,21 @@ static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
 }
 
 const EVP_PKEY_METHOD dh_pkey_meth = {
-    .pkey_id = EVP_PKEY_DH,
-    .init = pkey_dh_init,
-    .copy = pkey_dh_copy,
-    .cleanup = pkey_dh_cleanup,
-    .keygen = pkey_dh_keygen,
-    .derive = pkey_dh_derive,
-    .ctrl = pkey_dh_ctrl,
+    /*pkey_id=*/EVP_PKEY_DH,
+    /*init=*/pkey_dh_init,
+    /*copy=*/pkey_dh_copy,
+    /*cleanup=*/pkey_dh_cleanup,
+    /*keygen=*/pkey_dh_keygen,
+    /*sign=*/nullptr,
+    /*sign_message=*/nullptr,
+    /*verify=*/nullptr,
+    /*verify_message=*/nullptr,
+    /*verify_recover=*/nullptr,
+    /*encrypt=*/nullptr,
+    /*decrypt=*/nullptr,
+    /*derive=*/pkey_dh_derive,
+    /*paramgen=*/nullptr,
+    /*ctrl=*/pkey_dh_ctrl,
 };
 
 int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad) {

data/third_party/boringssl-with-bazel/src/crypto/evp/{p_dh_asn1.c → p_dh_asn1.cc}

@@ -13,21 +13,25 @@
 #include <openssl/dh.h>
 #include <openssl/err.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 static void dh_free(EVP_PKEY *pkey) {
-  DH_free(pkey->pkey);
+  DH_free(reinterpret_cast<DH *>(pkey->pkey));
   pkey->pkey = NULL;
 }
 
-static int dh_size(const EVP_PKEY *pkey) { return DH_size(pkey->pkey); }
+static int dh_size(const EVP_PKEY *pkey) {
+  return DH_size(reinterpret_cast<const DH *>(pkey->pkey));
+}
 
-static int dh_bits(const EVP_PKEY *pkey) { return DH_bits(pkey->pkey); }
+static int dh_bits(const EVP_PKEY *pkey) {
+  return DH_bits(reinterpret_cast<const DH *>(pkey->pkey));
+}
 
 static int dh_param_missing(const EVP_PKEY *pkey) {
-  const DH *dh = pkey->pkey;
+  const DH *dh = reinterpret_cast<const DH *>(pkey->pkey);
   return dh == NULL || DH_get0_p(dh) == NULL || DH_get0_g(dh) == NULL;
 }
 
@@ -37,13 +41,13 @@ static int dh_param_copy(EVP_PKEY *to, const EVP_PKEY *from) {
     return 0;
   }
 
-  const DH *dh = from->pkey;
+  const DH *dh = reinterpret_cast<DH *>(from->pkey);
   const BIGNUM *q_old = DH_get0_q(dh);
   BIGNUM *p = BN_dup(DH_get0_p(dh));
   BIGNUM *q = q_old == NULL ? NULL : BN_dup(q_old);
   BIGNUM *g = BN_dup(DH_get0_g(dh));
   if (p == NULL || (q_old != NULL && q == NULL) || g == NULL ||
-      !DH_set0_pqg(to->pkey, p, q, g)) {
+      !DH_set0_pqg(reinterpret_cast<DH *>(to->pkey), p, q, g)) {
     BN_free(p);
     BN_free(q);
     BN_free(g);
@@ -61,8 +65,8 @@ static int dh_param_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
 
   // Matching OpenSSL, only compare p and g for PKCS#3-style Diffie-Hellman.
   // OpenSSL only checks q in X9.42-style Diffie-Hellman ("DHX").
-  const DH *a_dh = a->pkey;
-  const DH *b_dh = b->pkey;
+  const DH *a_dh = reinterpret_cast<const DH *>(a->pkey);
+  const DH *b_dh = reinterpret_cast<const DH *>(b->pkey);
   return BN_cmp(DH_get0_p(a_dh), DH_get0_p(b_dh)) == 0 &&
          BN_cmp(DH_get0_g(a_dh), DH_get0_g(b_dh)) == 0;
 }
@@ -72,21 +76,34 @@ static int dh_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
     return 0;
   }
 
-  const DH *a_dh = a->pkey;
-  const DH *b_dh = b->pkey;
+  const DH *a_dh = reinterpret_cast<const DH *>(a->pkey);
+  const DH *b_dh = reinterpret_cast<const DH *>(b->pkey);
   return BN_cmp(DH_get0_pub_key(a_dh), DH_get0_pub_key(b_dh)) == 0;
 }
 
 const EVP_PKEY_ASN1_METHOD dh_asn1_meth = {
-    .pkey_id = EVP_PKEY_DH,
-    .pkey_method = &dh_pkey_meth,
-    .pub_cmp = dh_pub_cmp,
-    .pkey_size = dh_size,
-    .pkey_bits = dh_bits,
-    .param_missing = dh_param_missing,
-    .param_copy = dh_param_copy,
-    .param_cmp = dh_param_cmp,
-    .pkey_free = dh_free,
+    /*pkey_id=*/EVP_PKEY_DH,
+    /*oid=*/{0},
+    /*oid_len=*/0,
+    /*pkey_method=*/&dh_pkey_meth,
+    /*pub_decode=*/nullptr,
+    /*pub_encode=*/nullptr,
+    /*pub_cmp=*/dh_pub_cmp,
+    /*priv_decode=*/nullptr,
+    /*priv_encode=*/nullptr,
+    /*set_priv_raw=*/nullptr,
+    /*set_pub_raw=*/nullptr,
+    /*get_priv_raw=*/nullptr,
+    /*get_pub_raw=*/nullptr,
+    /*set1_tls_encodedpoint=*/nullptr,
+    /*get1_tls_encodedpoint=*/nullptr,
+    /*pkey_opaque=*/nullptr,
+    /*pkey_size=*/dh_size,
+    /*pkey_bits=*/dh_bits,
+    /*param_missing=*/dh_param_missing,
+    /*param_copy=*/dh_param_copy,
+    /*param_cmp=*/dh_param_cmp,
+    /*pkey_free=*/dh_free,
 };
 
 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key) {
@@ -108,7 +125,7 @@ DH *EVP_PKEY_get0_DH(const EVP_PKEY *pkey) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_A_DH_KEY);
     return NULL;
   }
-  return pkey->pkey;
+  return reinterpret_cast<DH *>(const_cast<EVP_PKEY *>(pkey)->pkey);
 }
 
 DH *EVP_PKEY_get1_DH(const EVP_PKEY *pkey) {