grpc 1.69.0 → 1.70.1

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

@@ -55,9 +55,9 @@
 
 #include <openssl/evp.h>
 
-#include <openssl/digest.h>
 #include <openssl/bn.h>
 #include <openssl/bytestring.h>
+#include <openssl/digest.h>
 #include <openssl/dsa.h>
 #include <openssl/err.h>
 
@@ -88,8 +88,7 @@ static int dsa_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
     goto err;
   }
 
-  if (!BN_parse_asn1_unsigned(key, dsa->pub_key) ||
-      CBS_len(key) != 0) {
+  if (!BN_parse_asn1_unsigned(key, dsa->pub_key) || CBS_len(key) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     goto err;
   }
@@ -103,7 +102,7 @@ err:
 }
 
 static int dsa_pub_encode(CBB *out, const EVP_PKEY *key) {
-  const DSA *dsa = key->pkey;
+  const DSA *dsa = reinterpret_cast<const DSA *>(key->pkey);
   const int has_params = dsa->p != NULL && dsa->q != NULL && dsa->g != NULL;
 
   // See RFC 5480, section 2.
@@ -112,12 +111,10 @@ static int dsa_pub_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1(&algorithm, &oid, CBS_ASN1_OBJECT) ||
       !CBB_add_bytes(&oid, dsa_asn1_meth.oid, dsa_asn1_meth.oid_len) ||
-      (has_params &&
-       !DSA_marshal_parameters(&algorithm, dsa)) ||
+      (has_params && !DSA_marshal_parameters(&algorithm, dsa)) ||
       !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
       !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !BN_marshal_asn1(&key_bitstring, dsa->pub_key) ||
-      !CBB_flush(out)) {
+      !BN_marshal_asn1(&key_bitstring, dsa->pub_key) || !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
   }
@@ -140,8 +137,7 @@ static int dsa_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
   if (dsa->priv_key == NULL) {
     goto err;
   }
-  if (!BN_parse_asn1_unsigned(key, dsa->priv_key) ||
-      CBS_len(key) != 0) {
+  if (!BN_parse_asn1_unsigned(key, dsa->priv_key) || CBS_len(key) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     goto err;
   }
@@ -174,7 +170,7 @@ err:
 }
 
 static int dsa_priv_encode(CBB *out, const EVP_PKEY *key) {
-  const DSA *dsa = key->pkey;
+  const DSA *dsa = reinterpret_cast<const DSA *>(key->pkey);
   if (dsa == NULL || dsa->priv_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);
     return 0;
@@ -189,8 +185,7 @@ static int dsa_priv_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_bytes(&oid, dsa_asn1_meth.oid, dsa_asn1_meth.oid_len) ||
       !DSA_marshal_parameters(&algorithm, dsa) ||
       !CBB_add_asn1(&pkcs8, &private_key, CBS_ASN1_OCTETSTRING) ||
-      !BN_marshal_asn1(&private_key, dsa->priv_key) ||
-      !CBB_flush(out)) {
+      !BN_marshal_asn1(&private_key, dsa->priv_key) || !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
   }
@@ -199,17 +194,17 @@ static int dsa_priv_encode(CBB *out, const EVP_PKEY *key) {
 }
 
 static int int_dsa_size(const EVP_PKEY *pkey) {
-  const DSA *dsa = pkey->pkey;
+  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
   return DSA_size(dsa);
 }
 
 static int dsa_bits(const EVP_PKEY *pkey) {
-  const DSA *dsa = pkey->pkey;
+  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
   return BN_num_bits(DSA_get0_p(dsa));
 }
 
 static int dsa_missing_parameters(const EVP_PKEY *pkey) {
-  const DSA *dsa = pkey->pkey;
+  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
   if (DSA_get0_p(dsa) == NULL || DSA_get0_q(dsa) == NULL ||
       DSA_get0_g(dsa) == NULL) {
     return 1;
@@ -231,8 +226,8 @@ static int dup_bn_into(BIGNUM **out, BIGNUM *src) {
 }
 
 static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) {
-  DSA *to_dsa = to->pkey;
-  const DSA *from_dsa = from->pkey;
+  DSA *to_dsa = reinterpret_cast<DSA *>(to->pkey);
+  const DSA *from_dsa = reinterpret_cast<const DSA *>(from->pkey);
   if (!dup_bn_into(&to_dsa->p, from_dsa->p) ||
       !dup_bn_into(&to_dsa->q, from_dsa->q) ||
       !dup_bn_into(&to_dsa->g, from_dsa->g)) {
@@ -243,21 +238,21 @@ static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) {
 }
 
 static int dsa_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const DSA *a_dsa = a->pkey;
-  const DSA *b_dsa = b->pkey;
+  const DSA *a_dsa = reinterpret_cast<const DSA *>(a->pkey);
+  const DSA *b_dsa = reinterpret_cast<const DSA *>(b->pkey);
   return BN_cmp(DSA_get0_p(a_dsa), DSA_get0_p(b_dsa)) == 0 &&
          BN_cmp(DSA_get0_q(a_dsa), DSA_get0_q(b_dsa)) == 0 &&
          BN_cmp(DSA_get0_g(a_dsa), DSA_get0_g(b_dsa)) == 0;
 }
 
 static int dsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const DSA *a_dsa = a->pkey;
-  const DSA *b_dsa = b->pkey;
+  const DSA *a_dsa = reinterpret_cast<const DSA *>(a->pkey);
+  const DSA *b_dsa = reinterpret_cast<const DSA *>(b->pkey);
   return BN_cmp(DSA_get0_pub_key(b_dsa), DSA_get0_pub_key(a_dsa)) == 0;
 }
 
 static void int_dsa_free(EVP_PKEY *pkey) {
-  DSA_free(pkey->pkey);
+  DSA_free(reinterpret_cast<DSA *>(pkey->pkey));
   pkey->pkey = NULL;
 }
 
@@ -326,7 +321,7 @@ DSA *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_A_DSA_KEY);
     return NULL;
   }
-  return pkey->pkey;
+  return reinterpret_cast<DSA *>(pkey->pkey);
 }
 
 DSA *EVP_PKEY_get1_DSA(const EVP_PKEY *pkey) {

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

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 2006.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 2006.
  */
 /* ====================================================================
  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
@@ -67,9 +67,9 @@
 #include <openssl/mem.h>
 #include <openssl/nid.h>
 
-#include "internal.h"
 #include "../fipsmodule/ec/internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 typedef struct {
@@ -80,7 +80,8 @@ typedef struct {
 
 
 static int pkey_ec_init(EVP_PKEY_CTX *ctx) {
-  EC_PKEY_CTX *dctx = OPENSSL_zalloc(sizeof(EC_PKEY_CTX));
+  EC_PKEY_CTX *dctx =
+      reinterpret_cast<EC_PKEY_CTX *>(OPENSSL_zalloc(sizeof(EC_PKEY_CTX)));
   if (!dctx) {
     return 0;
   }
@@ -94,15 +95,15 @@ static int pkey_ec_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
     return 0;
   }
 
-  const EC_PKEY_CTX *sctx = src->data;
-  EC_PKEY_CTX *dctx = dst->data;
+  const EC_PKEY_CTX *sctx = reinterpret_cast<EC_PKEY_CTX *>(src->data);
+  EC_PKEY_CTX *dctx = reinterpret_cast<EC_PKEY_CTX *>(dst->data);
   dctx->md = sctx->md;
   dctx->gen_group = sctx->gen_group;
   return 1;
 }
 
 static void pkey_ec_cleanup(EVP_PKEY_CTX *ctx) {
-  EC_PKEY_CTX *dctx = ctx->data;
+  EC_PKEY_CTX *dctx = reinterpret_cast<EC_PKEY_CTX *>(ctx->data);
   if (!dctx) {
     return;
   }
@@ -112,7 +113,7 @@ static void pkey_ec_cleanup(EVP_PKEY_CTX *ctx) {
 
 static int pkey_ec_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
                         const uint8_t *tbs, size_t tbslen) {
-  const EC_KEY *ec = ctx->pkey->pkey;
+  const EC_KEY *ec = reinterpret_cast<EC_KEY *>(ctx->pkey->pkey);
   if (!sig) {
     *siglen = ECDSA_size(ec);
     return 1;
@@ -131,18 +132,17 @@ static int pkey_ec_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
 
 static int pkey_ec_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig, size_t siglen,
                           const uint8_t *tbs, size_t tbslen) {
-  const EC_KEY *ec_key = ctx->pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<EC_KEY *>(ctx->pkey->pkey);
   return ECDSA_verify(0, tbs, tbslen, sig, siglen, ec_key);
 }
 
-static int pkey_ec_derive(EVP_PKEY_CTX *ctx, uint8_t *key,
-                          size_t *keylen) {
+static int pkey_ec_derive(EVP_PKEY_CTX *ctx, uint8_t *key, size_t *keylen) {
   if (!ctx->pkey || !ctx->peerkey) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_KEYS_NOT_SET);
     return 0;
   }
 
-  const EC_KEY *eckey = ctx->pkey->pkey;
+  const EC_KEY *eckey = reinterpret_cast<EC_KEY *>(ctx->pkey->pkey);
   if (!key) {
     const EC_GROUP *group;
     group = EC_KEY_get0_group(eckey);
@@ -150,7 +150,7 @@ static int pkey_ec_derive(EVP_PKEY_CTX *ctx, uint8_t *key,
     return 1;
   }
 
-  const EC_KEY *eckey_peer = ctx->peerkey->pkey;
+  const EC_KEY *eckey_peer = reinterpret_cast<EC_KEY *>(ctx->peerkey->pkey);
   const EC_POINT *pubkey = EC_KEY_get0_public_key(eckey_peer);
 
   // NB: unlike PKCS#3 DH, if *outlen is less than maximum size this is
@@ -165,11 +165,11 @@ static int pkey_ec_derive(EVP_PKEY_CTX *ctx, uint8_t *key,
 }
 
 static int pkey_ec_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
-  EC_PKEY_CTX *dctx = ctx->data;
+  EC_PKEY_CTX *dctx = reinterpret_cast<EC_PKEY_CTX *>(ctx->data);
 
   switch (type) {
     case EVP_PKEY_CTRL_MD: {
-      const EVP_MD *md = p2;
+      const EVP_MD *md = reinterpret_cast<const EVP_MD *>(p2);
       int md_type = EVP_MD_type(md);
       if (md_type != NID_sha1 && md_type != NID_sha224 &&
           md_type != NID_sha256 && md_type != NID_sha384 &&
@@ -205,19 +205,17 @@ static int pkey_ec_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
 }
 
 static int pkey_ec_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
-  EC_PKEY_CTX *dctx = ctx->data;
+  EC_PKEY_CTX *dctx = reinterpret_cast<EC_PKEY_CTX *>(ctx->data);
   const EC_GROUP *group = dctx->gen_group;
   if (group == NULL) {
     if (ctx->pkey == NULL) {
       OPENSSL_PUT_ERROR(EVP, EVP_R_NO_PARAMETERS_SET);
       return 0;
     }
-    group = EC_KEY_get0_group(ctx->pkey->pkey);
+    group = EC_KEY_get0_group(reinterpret_cast<EC_KEY *>(ctx->pkey->pkey));
   }
   EC_KEY *ec = EC_KEY_new();
-  if (ec == NULL ||
-      !EC_KEY_set_group(ec, group) ||
-      !EC_KEY_generate_key(ec)) {
+  if (ec == NULL || !EC_KEY_set_group(ec, group) || !EC_KEY_generate_key(ec)) {
     EC_KEY_free(ec);
     return 0;
   }
@@ -226,14 +224,13 @@ static int pkey_ec_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
 }
 
 static int pkey_ec_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
-  EC_PKEY_CTX *dctx = ctx->data;
+  EC_PKEY_CTX *dctx = reinterpret_cast<EC_PKEY_CTX *>(ctx->data);
   if (dctx->gen_group == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NO_PARAMETERS_SET);
     return 0;
   }
   EC_KEY *ec = EC_KEY_new();
-  if (ec == NULL ||
-      !EC_KEY_set_group(ec, dctx->gen_group)) {
+  if (ec == NULL || !EC_KEY_set_group(ec, dctx->gen_group)) {
     EC_KEY_free(ec);
     return 0;
   }

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

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 2006.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 2006.
  */
 /* ====================================================================
  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
@@ -9,7 +9,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -66,7 +66,7 @@
 
 
 static int eckey_pub_encode(CBB *out, const EVP_PKEY *key) {
-  const EC_KEY *ec_key = key->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(key->pkey);
   const EC_GROUP *group = EC_KEY_get0_group(ec_key);
   const EC_POINT *public_key = EC_KEY_get0_public_key(ec_key);
 
@@ -101,7 +101,7 @@ static int eckey_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
   }
 
   eckey = EC_KEY_new();
-  if (eckey == NULL || //
+  if (eckey == NULL ||  //
       !EC_KEY_set_group(eckey, group) ||
       !EC_KEY_oct2key(eckey, CBS_data(key), CBS_len(key), NULL)) {
     goto err;
@@ -116,8 +116,8 @@ err:
 }
 
 static int eckey_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const EC_KEY *a_ec = a->pkey;
-  const EC_KEY *b_ec = b->pkey;
+  const EC_KEY *a_ec = reinterpret_cast<const EC_KEY *>(a->pkey);
+  const EC_KEY *b_ec = reinterpret_cast<const EC_KEY *>(b->pkey);
   const EC_GROUP *group = EC_KEY_get0_group(b_ec);
   const EC_POINT *pa = EC_KEY_get0_public_key(a_ec),
                  *pb = EC_KEY_get0_public_key(b_ec);
@@ -151,7 +151,7 @@ static int eckey_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int eckey_priv_encode(CBB *out, const EVP_PKEY *key) {
-  const EC_KEY *ec_key = key->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(key->pkey);
 
   // Omit the redundant copy of the curve name. This contradicts RFC 5915 but
   // aligns with PKCS #11. SEC 1 only says they may be omitted if known by other
@@ -179,7 +179,7 @@ static int eckey_priv_encode(CBB *out, const EVP_PKEY *key) {
 
 static int eckey_set1_tls_encodedpoint(EVP_PKEY *pkey, const uint8_t *in,
                                        size_t len) {
-  EC_KEY *ec_key = pkey->pkey;
+  EC_KEY *ec_key = reinterpret_cast<EC_KEY *>(pkey->pkey);
   if (ec_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
     return 0;
@@ -190,7 +190,7 @@ static int eckey_set1_tls_encodedpoint(EVP_PKEY *pkey, const uint8_t *in,
 
 static size_t eckey_get1_tls_encodedpoint(const EVP_PKEY *pkey,
                                           uint8_t **out_ptr) {
-  const EC_KEY *ec_key = pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(pkey->pkey);
   if (ec_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
     return 0;
@@ -200,12 +200,12 @@ static size_t eckey_get1_tls_encodedpoint(const EVP_PKEY *pkey,
 }
 
 static int int_ec_size(const EVP_PKEY *pkey) {
-  const EC_KEY *ec_key = pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(pkey->pkey);
   return ECDSA_size(ec_key);
 }
 
 static int ec_bits(const EVP_PKEY *pkey) {
-  const EC_KEY *ec_key = pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(pkey->pkey);
   const EC_GROUP *group = EC_KEY_get0_group(ec_key);
   if (group == NULL) {
     ERR_clear_error();
@@ -215,12 +215,12 @@ static int ec_bits(const EVP_PKEY *pkey) {
 }
 
 static int ec_missing_parameters(const EVP_PKEY *pkey) {
-  const EC_KEY *ec_key = pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(pkey->pkey);
   return ec_key == NULL || EC_KEY_get0_group(ec_key) == NULL;
 }
 
 static int ec_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) {
-  const EC_KEY *from_key = from->pkey;
+  const EC_KEY *from_key = reinterpret_cast<const EC_KEY *>(from->pkey);
   if (from_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
     return 0;
@@ -236,12 +236,12 @@ static int ec_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) {
       return 0;
     }
   }
-  return EC_KEY_set_group(to->pkey, group);
+  return EC_KEY_set_group(reinterpret_cast<EC_KEY *>(to->pkey), group);
 }
 
 static int ec_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const EC_KEY *a_ec = a->pkey;
-  const EC_KEY *b_ec = b->pkey;
+  const EC_KEY *a_ec = reinterpret_cast<const EC_KEY *>(a->pkey);
+  const EC_KEY *b_ec = reinterpret_cast<const EC_KEY *>(b->pkey);
   if (a_ec == NULL || b_ec == NULL) {
     return -2;
   }
@@ -258,12 +258,12 @@ static int ec_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b) {
 }
 
 static void int_ec_free(EVP_PKEY *pkey) {
-  EC_KEY_free(pkey->pkey);
+  EC_KEY_free(reinterpret_cast<EC_KEY *>(pkey->pkey));
   pkey->pkey = NULL;
 }
 
 static int eckey_opaque(const EVP_PKEY *pkey) {
-  const EC_KEY *ec_key = pkey->pkey;
+  const EC_KEY *ec_key = reinterpret_cast<const EC_KEY *>(pkey->pkey);
   return EC_KEY_is_opaque(ec_key);
 }
 
@@ -320,7 +320,7 @@ EC_KEY *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_AN_EC_KEY_KEY);
     return NULL;
   }
-  return pkey->pkey;
+  return reinterpret_cast<EC_KEY *>(pkey->pkey);
 }
 
 EC_KEY *EVP_PKEY_get1_EC_KEY(const EVP_PKEY *pkey) {

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

@@ -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
@@ -25,7 +25,8 @@
 static int pkey_ed25519_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) { return 1; }
 
 static int pkey_ed25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
-  ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
+  ED25519_KEY *key =
+      reinterpret_cast<ED25519_KEY *>(OPENSSL_malloc(sizeof(ED25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -44,7 +45,8 @@ static int pkey_ed25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
 static int pkey_ed25519_sign_message(EVP_PKEY_CTX *ctx, uint8_t *sig,
                                      size_t *siglen, const uint8_t *tbs,
                                      size_t tbslen) {
-  const ED25519_KEY *key = ctx->pkey->pkey;
+  const ED25519_KEY *key =
+      reinterpret_cast<const ED25519_KEY *>(ctx->pkey->pkey);
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -71,7 +73,8 @@ static int pkey_ed25519_sign_message(EVP_PKEY_CTX *ctx, uint8_t *sig,
 static int pkey_ed25519_verify_message(EVP_PKEY_CTX *ctx, const uint8_t *sig,
                                        size_t siglen, const uint8_t *tbs,
                                        size_t tbslen) {
-  const ED25519_KEY *key = ctx->pkey->pkey;
+  const ED25519_KEY *key =
+      reinterpret_cast<const ED25519_KEY *>(ctx->pkey->pkey);
   if (siglen != 64 ||
       !ED25519_verify(tbs, tbslen, sig, key->key + ED25519_PUBLIC_KEY_OFFSET)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_SIGNATURE);
@@ -82,19 +85,19 @@ static int pkey_ed25519_verify_message(EVP_PKEY_CTX *ctx, const uint8_t *sig,
 }
 
 const EVP_PKEY_METHOD ed25519_pkey_meth = {
-    EVP_PKEY_ED25519,
-    NULL /* init */,
-    pkey_ed25519_copy,
-    NULL /* cleanup */,
-    pkey_ed25519_keygen,
-    NULL /* sign */,
-    pkey_ed25519_sign_message,
-    NULL /* verify */,
-    pkey_ed25519_verify_message,
-    NULL /* verify_recover */,
-    NULL /* encrypt */,
-    NULL /* decrypt */,
-    NULL /* derive */,
-    NULL /* paramgen */,
-    NULL /* ctrl */,
+    /*pkey_id=*/EVP_PKEY_ED25519,
+    /*init=*/nullptr,
+    /*copy=*/pkey_ed25519_copy,
+    /*cleanup=*/nullptr,
+    /*keygen=*/pkey_ed25519_keygen,
+    /*sign=*/nullptr,
+    /*sign_message=*/pkey_ed25519_sign_message,
+    /*verify=*/nullptr,
+    /*verify_message=*/pkey_ed25519_verify_message,
+    /*verify_recover=*/nullptr,
+    /*encrypt=*/nullptr,
+    /*decrypt=*/nullptr,
+    /*derive=*/nullptr,
+    /*paramgen=*/nullptr,
+    /*ctrl=*/nullptr,
 };

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

@@ -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
@@ -19,8 +19,8 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 static void ed25519_free(EVP_PKEY *pkey) {
@@ -34,7 +34,8 @@ static int ed25519_set_priv_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
     return 0;
   }
 
-  ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
+  ED25519_KEY *key =
+      reinterpret_cast<ED25519_KEY *>(OPENSSL_malloc(sizeof(ED25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -56,7 +57,8 @@ static int ed25519_set_pub_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
     return 0;
   }
 
-  ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
+  ED25519_KEY *key =
+      reinterpret_cast<ED25519_KEY *>(OPENSSL_malloc(sizeof(ED25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -71,7 +73,7 @@ static int ed25519_set_pub_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
 
 static int ed25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
                                 size_t *out_len) {
-  const ED25519_KEY *key = pkey->pkey;
+  const ED25519_KEY *key = reinterpret_cast<const ED25519_KEY *>(pkey->pkey);
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -95,7 +97,7 @@ static int ed25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
 
 static int ed25519_get_pub_raw(const EVP_PKEY *pkey, uint8_t *out,
                                size_t *out_len) {
-  const ED25519_KEY *key = pkey->pkey;
+  const ED25519_KEY *key = reinterpret_cast<const ED25519_KEY *>(pkey->pkey);
   if (out == NULL) {
     *out_len = 32;
     return 1;
@@ -124,7 +126,7 @@ static int ed25519_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int ed25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
-  const ED25519_KEY *key = pkey->pkey;
+  const ED25519_KEY *key = reinterpret_cast<const ED25519_KEY *>(pkey->pkey);
 
   // See RFC 8410, section 4.
   CBB spki, algorithm, oid, key_bitstring;
@@ -145,8 +147,8 @@ static int ed25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
 }
 
 static int ed25519_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const ED25519_KEY *a_key = a->pkey;
-  const ED25519_KEY *b_key = b->pkey;
+  const ED25519_KEY *a_key = reinterpret_cast<const ED25519_KEY *>(a->pkey);
+  const ED25519_KEY *b_key = reinterpret_cast<const ED25519_KEY *>(b->pkey);
   return OPENSSL_memcmp(a_key->key + ED25519_PUBLIC_KEY_OFFSET,
                         b_key->key + ED25519_PUBLIC_KEY_OFFSET, 32) == 0;
 }
@@ -158,8 +160,7 @@ static int ed25519_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
   // OCTET STRING layer.
   CBS inner;
   if (CBS_len(params) != 0 ||
-      !CBS_get_asn1(key, &inner, CBS_ASN1_OCTETSTRING) ||
-      CBS_len(key) != 0) {
+      !CBS_get_asn1(key, &inner, CBS_ASN1_OCTETSTRING) || CBS_len(key) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return 0;
   }
@@ -168,7 +169,7 @@ static int ed25519_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int ed25519_priv_encode(CBB *out, const EVP_PKEY *pkey) {
-  const ED25519_KEY *key = pkey->pkey;
+  const ED25519_KEY *key = reinterpret_cast<const ED25519_KEY *>(pkey->pkey);
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -185,7 +186,7 @@ static int ed25519_priv_encode(CBB *out, const EVP_PKEY *pkey) {
       !CBB_add_asn1(&private_key, &inner, CBS_ASN1_OCTETSTRING) ||
       // The PKCS#8 encoding stores only the 32-byte seed which is the first 32
       // bytes of the private key.
-      !CBB_add_bytes(&inner, key->key, 32) ||
+      !CBB_add_bytes(&inner, key->key, 32) ||  //
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;