grpc 1.69.0 → 1.70.1

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

@@ -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
@@ -35,7 +35,8 @@ typedef struct {
 } HKDF_PKEY_CTX;
 
 static int pkey_hkdf_init(EVP_PKEY_CTX *ctx) {
-  HKDF_PKEY_CTX *hctx = OPENSSL_zalloc(sizeof(HKDF_PKEY_CTX));
+  HKDF_PKEY_CTX *hctx =
+      reinterpret_cast<HKDF_PKEY_CTX *>(OPENSSL_zalloc(sizeof(HKDF_PKEY_CTX)));
   if (hctx == NULL) {
     return 0;
   }
@@ -54,13 +55,15 @@ static int pkey_hkdf_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
     return 0;
   }
 
-  HKDF_PKEY_CTX *hctx_dst = dst->data;
-  const HKDF_PKEY_CTX *hctx_src = src->data;
+  HKDF_PKEY_CTX *hctx_dst = reinterpret_cast<HKDF_PKEY_CTX *>(dst->data);
+  const HKDF_PKEY_CTX *hctx_src =
+      reinterpret_cast<const HKDF_PKEY_CTX *>(src->data);
   hctx_dst->mode = hctx_src->mode;
   hctx_dst->md = hctx_src->md;
 
   if (hctx_src->key_len != 0) {
-    hctx_dst->key = OPENSSL_memdup(hctx_src->key, hctx_src->key_len);
+    hctx_dst->key = reinterpret_cast<uint8_t *>(
+        OPENSSL_memdup(hctx_src->key, hctx_src->key_len));
     if (hctx_dst->key == NULL) {
       return 0;
     }
@@ -68,7 +71,8 @@ static int pkey_hkdf_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
   }
 
   if (hctx_src->salt_len != 0) {
-    hctx_dst->salt = OPENSSL_memdup(hctx_src->salt, hctx_src->salt_len);
+    hctx_dst->salt = reinterpret_cast<uint8_t *>(
+        OPENSSL_memdup(hctx_src->salt, hctx_src->salt_len));
     if (hctx_dst->salt == NULL) {
       return 0;
     }
@@ -84,7 +88,7 @@ static int pkey_hkdf_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
 }
 
 static void pkey_hkdf_cleanup(EVP_PKEY_CTX *ctx) {
-  HKDF_PKEY_CTX *hctx = ctx->data;
+  HKDF_PKEY_CTX *hctx = reinterpret_cast<HKDF_PKEY_CTX *>(ctx->data);
   if (hctx != NULL) {
     OPENSSL_free(hctx->key);
     OPENSSL_free(hctx->salt);
@@ -95,7 +99,7 @@ static void pkey_hkdf_cleanup(EVP_PKEY_CTX *ctx) {
 }
 
 static int pkey_hkdf_derive(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *out_len) {
-  HKDF_PKEY_CTX *hctx = ctx->data;
+  HKDF_PKEY_CTX *hctx = reinterpret_cast<HKDF_PKEY_CTX *>(ctx->data);
   if (hctx->md == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);
     return 0;
@@ -136,7 +140,7 @@ static int pkey_hkdf_derive(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *out_len) {
 }
 
 static int pkey_hkdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
-  HKDF_PKEY_CTX *hctx = ctx->data;
+  HKDF_PKEY_CTX *hctx = reinterpret_cast<HKDF_PKEY_CTX *>(ctx->data);
   switch (type) {
     case EVP_PKEY_CTRL_HKDF_MODE:
       if (p1 != EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND &&
@@ -148,24 +152,24 @@ static int pkey_hkdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
       hctx->mode = p1;
       return 1;
     case EVP_PKEY_CTRL_HKDF_MD:
-      hctx->md = p2;
+      hctx->md = reinterpret_cast<const EVP_MD *>(p2);
       return 1;
     case EVP_PKEY_CTRL_HKDF_KEY: {
-      const CBS *key = p2;
+      const CBS *key = reinterpret_cast<const CBS *>(p2);
       if (!CBS_stow(key, &hctx->key, &hctx->key_len)) {
         return 0;
       }
       return 1;
     }
     case EVP_PKEY_CTRL_HKDF_SALT: {
-      const CBS *salt = p2;
+      const CBS *salt = reinterpret_cast<const CBS *>(p2);
       if (!CBS_stow(salt, &hctx->salt, &hctx->salt_len)) {
         return 0;
       }
       return 1;
     }
     case EVP_PKEY_CTRL_HKDF_INFO: {
-      const CBS *info = p2;
+      const CBS *info = reinterpret_cast<const CBS *>(p2);
       // |EVP_PKEY_CTX_add1_hkdf_info| appends to the info string, rather than
       // replacing it.
       if (!CBB_add_bytes(&hctx->info, CBS_data(info), CBS_len(info))) {
@@ -180,7 +184,7 @@ static int pkey_hkdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
 }
 
 const EVP_PKEY_METHOD hkdf_pkey_meth = {
-    EVP_PKEY_HKDF,
+    /*pkey_id=*/EVP_PKEY_HKDF,
     pkey_hkdf_init,
     pkey_hkdf_copy,
     pkey_hkdf_cleanup,

data/third_party/boringssl-with-bazel/src/crypto/evp/{p_rsa.c → p_rsa.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.
@@ -97,7 +97,8 @@ typedef struct {
 } RSA_OAEP_LABEL_PARAMS;
 
 static int pkey_rsa_init(EVP_PKEY_CTX *ctx) {
-  RSA_PKEY_CTX *rctx = OPENSSL_zalloc(sizeof(RSA_PKEY_CTX));
+  RSA_PKEY_CTX *rctx =
+      reinterpret_cast<RSA_PKEY_CTX *>(OPENSSL_zalloc(sizeof(RSA_PKEY_CTX)));
   if (!rctx) {
     return 0;
   }
@@ -116,8 +117,8 @@ static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
   if (!pkey_rsa_init(dst)) {
     return 0;
   }
-  sctx = src->data;
-  dctx = dst->data;
+  sctx = reinterpret_cast<RSA_PKEY_CTX *>(src->data);
+  dctx = reinterpret_cast<RSA_PKEY_CTX *>(dst->data);
   dctx->nbits = sctx->nbits;
   if (sctx->pub_exp) {
     dctx->pub_exp = BN_dup(sctx->pub_exp);
@@ -132,7 +133,8 @@ static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
   dctx->saltlen = sctx->saltlen;
   if (sctx->oaep_label) {
     OPENSSL_free(dctx->oaep_label);
-    dctx->oaep_label = OPENSSL_memdup(sctx->oaep_label, sctx->oaep_labellen);
+    dctx->oaep_label = reinterpret_cast<uint8_t *>(
+        OPENSSL_memdup(sctx->oaep_label, sctx->oaep_labellen));
     if (!dctx->oaep_label) {
       return 0;
     }
@@ -143,7 +145,7 @@ static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
 }
 
 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx) {
-  RSA_PKEY_CTX *rctx = ctx->data;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
 
   if (rctx == NULL) {
     return;
@@ -159,7 +161,8 @@ static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk) {
   if (ctx->tbuf) {
     return 1;
   }
-  ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
+  ctx->tbuf =
+      reinterpret_cast<uint8_t *>(OPENSSL_malloc(EVP_PKEY_size(pk->pkey)));
   if (!ctx->tbuf) {
     return 0;
   }
@@ -168,8 +171,8 @@ static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk) {
 
 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
                          const uint8_t *tbs, size_t tbslen) {
-  RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
+  RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!sig) {
@@ -204,11 +207,10 @@ static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
   return RSA_sign_raw(rsa, siglen, sig, *siglen, tbs, tbslen, rctx->pad_mode);
 }
 
-static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig,
-                           size_t siglen, const uint8_t *tbs,
-                           size_t tbslen) {
-  RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey;
+static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig, size_t siglen,
+                           const uint8_t *tbs, size_t tbslen) {
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
+  RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
 
   if (rctx->md) {
     switch (rctx->pad_mode) {
@@ -229,8 +231,7 @@ static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig,
   if (!setup_tbuf(rctx, ctx) ||
       !RSA_verify_raw(rsa, &rslen, rctx->tbuf, key_len, sig, siglen,
                       rctx->pad_mode) ||
-      rslen != tbslen ||
-      CRYPTO_memcmp(tbs, rctx->tbuf, rslen) != 0) {
+      rslen != tbslen || CRYPTO_memcmp(tbs, rctx->tbuf, rslen) != 0) {
     return 0;
   }
 
@@ -240,8 +241,8 @@ static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig,
 static int pkey_rsa_verify_recover(EVP_PKEY_CTX *ctx, uint8_t *out,
                                    size_t *out_len, const uint8_t *sig,
                                    size_t sig_len) {
-  RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
+  RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (out == NULL) {
@@ -304,8 +305,8 @@ static int pkey_rsa_verify_recover(EVP_PKEY_CTX *ctx, uint8_t *out,
 
 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
                             const uint8_t *in, size_t inlen) {
-  RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
+  RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!out) {
@@ -333,11 +334,10 @@ static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
   return RSA_encrypt(rsa, outlen, out, *outlen, in, inlen, rctx->pad_mode);
 }
 
-static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, uint8_t *out,
-                            size_t *outlen, const uint8_t *in,
-                            size_t inlen) {
-  RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey;
+static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
+                            const uint8_t *in, size_t inlen) {
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
+  RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!out) {
@@ -392,7 +392,7 @@ static int is_known_padding(int padding_mode) {
 }
 
 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
-  RSA_PKEY_CTX *rctx = ctx->data;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
   switch (type) {
     case EVP_PKEY_CTRL_RSA_PADDING:
       if (!is_known_padding(p1) || !check_padding_md(rctx->md, p1) ||
@@ -443,7 +443,7 @@ static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
         return 0;
       }
       BN_free(rctx->pub_exp);
-      rctx->pub_exp = p2;
+      rctx->pub_exp = reinterpret_cast<BIGNUM *>(p2);
       return 1;
 
     case EVP_PKEY_CTRL_RSA_OAEP_MD:
@@ -455,15 +455,15 @@ static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
       if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD) {
         *(const EVP_MD **)p2 = rctx->md;
       } else {
-        rctx->md = p2;
+        rctx->md = reinterpret_cast<EVP_MD *>(p2);
       }
       return 1;
 
     case EVP_PKEY_CTRL_MD:
-      if (!check_padding_md(p2, rctx->pad_mode)) {
+      if (!check_padding_md(reinterpret_cast<EVP_MD *>(p2), rctx->pad_mode)) {
         return 0;
       }
-      rctx->md = p2;
+      rctx->md = reinterpret_cast<EVP_MD *>(p2);
       return 1;
 
     case EVP_PKEY_CTRL_GET_MD:
@@ -484,7 +484,7 @@ static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
           *(const EVP_MD **)p2 = rctx->md;
         }
       } else {
-        rctx->mgf1md = p2;
+        rctx->mgf1md = reinterpret_cast<EVP_MD *>(p2);
       }
       return 1;
 
@@ -494,7 +494,8 @@ static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
         return 0;
       }
       OPENSSL_free(rctx->oaep_label);
-      RSA_OAEP_LABEL_PARAMS *params = p2;
+      RSA_OAEP_LABEL_PARAMS *params =
+          reinterpret_cast<RSA_OAEP_LABEL_PARAMS *>(p2);
       rctx->oaep_label = params->data;
       rctx->oaep_labellen = params->len;
       return 1;
@@ -516,7 +517,7 @@ static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
 
 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
   RSA *rsa = NULL;
-  RSA_PKEY_CTX *rctx = ctx->data;
+  RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
 
   if (!rctx->pub_exp) {
     rctx->pub_exp = BN_new();
@@ -608,19 +609,19 @@ int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
 
 int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **out_md) {
   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
-                           EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void*) out_md);
+                           EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)out_md);
 }
 
 int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
                            EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
-                           EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void*) md);
+                           EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)md);
 }
 
 int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **out_md) {
   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
                            EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
-                           EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void*) out_md);
+                           EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)out_md);
 }
 
 int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, uint8_t *label,

data/third_party/boringssl-with-bazel/src/crypto/evp/{p_rsa_asn1.c → p_rsa_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
@@ -68,7 +68,7 @@
 
 static int rsa_pub_encode(CBB *out, const EVP_PKEY *key) {
   // See RFC 3279, section 2.3.1.
-  const RSA *rsa = key->pkey;
+  const RSA *rsa = reinterpret_cast<const RSA *>(key->pkey);
   CBB spki, algorithm, oid, null, key_bitstring;
   if (!CBB_add_asn1(out, &spki, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
@@ -77,7 +77,7 @@ static int rsa_pub_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
       !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
       !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !RSA_marshal_public_key(&key_bitstring, rsa) ||
+      !RSA_marshal_public_key(&key_bitstring, rsa) ||  //
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -91,8 +91,7 @@ static int rsa_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 
   // The parameters must be NULL.
   CBS null;
-  if (!CBS_get_asn1(params, &null, CBS_ASN1_NULL) ||
-      CBS_len(&null) != 0 ||
+  if (!CBS_get_asn1(params, &null, CBS_ASN1_NULL) || CBS_len(&null) != 0 ||
       CBS_len(params) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return 0;
@@ -110,14 +109,14 @@ static int rsa_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const RSA *a_rsa = a->pkey;
-  const RSA *b_rsa = b->pkey;
+  const RSA *a_rsa = reinterpret_cast<const RSA *>(a->pkey);
+  const RSA *b_rsa = reinterpret_cast<const RSA *>(b->pkey);
   return BN_cmp(RSA_get0_n(b_rsa), RSA_get0_n(a_rsa)) == 0 &&
          BN_cmp(RSA_get0_e(b_rsa), RSA_get0_e(a_rsa)) == 0;
 }
 
 static int rsa_priv_encode(CBB *out, const EVP_PKEY *key) {
-  const RSA *rsa = key->pkey;
+  const RSA *rsa = reinterpret_cast<const RSA *>(key->pkey);
   CBB pkcs8, algorithm, oid, null, private_key;
   if (!CBB_add_asn1(out, &pkcs8, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1_uint64(&pkcs8, 0 /* version */) ||
@@ -126,7 +125,7 @@ static int rsa_priv_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_bytes(&oid, rsa_asn1_meth.oid, rsa_asn1_meth.oid_len) ||
       !CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
       !CBB_add_asn1(&pkcs8, &private_key, CBS_ASN1_OCTETSTRING) ||
-      !RSA_marshal_private_key(&private_key, rsa) ||
+      !RSA_marshal_private_key(&private_key, rsa) ||  //
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -138,8 +137,7 @@ static int rsa_priv_encode(CBB *out, const EVP_PKEY *key) {
 static int rsa_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
   // Per RFC 3447, A.1, the parameters have type NULL.
   CBS null;
-  if (!CBS_get_asn1(params, &null, CBS_ASN1_NULL) ||
-      CBS_len(&null) != 0 ||
+  if (!CBS_get_asn1(params, &null, CBS_ASN1_NULL) || CBS_len(&null) != 0 ||
       CBS_len(params) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return 0;
@@ -157,22 +155,22 @@ static int rsa_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int rsa_opaque(const EVP_PKEY *pkey) {
-  const RSA *rsa = pkey->pkey;
+  const RSA *rsa = reinterpret_cast<const RSA *>(pkey->pkey);
   return RSA_is_opaque(rsa);
 }
 
 static int int_rsa_size(const EVP_PKEY *pkey) {
-  const RSA *rsa = pkey->pkey;
+  const RSA *rsa = reinterpret_cast<const RSA *>(pkey->pkey);
   return RSA_size(rsa);
 }
 
 static int rsa_bits(const EVP_PKEY *pkey) {
-  const RSA *rsa = pkey->pkey;
+  const RSA *rsa = reinterpret_cast<const RSA *>(pkey->pkey);
   return RSA_bits(rsa);
 }
 
 static void int_rsa_free(EVP_PKEY *pkey) {
-  RSA_free(pkey->pkey);
+  RSA_free(reinterpret_cast<RSA *>(pkey->pkey));
   pkey->pkey = NULL;
 }
 
@@ -229,7 +227,7 @@ RSA *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_AN_RSA_KEY);
     return NULL;
   }
-  return pkey->pkey;
+  return reinterpret_cast<RSA *>(pkey->pkey);
 }
 
 RSA *EVP_PKEY_get1_RSA(const EVP_PKEY *pkey) {

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, Google Inc.
+/* Copyright 2019 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_x25519_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) { return 1; }
 
 static int pkey_x25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
-  X25519_KEY *key = OPENSSL_malloc(sizeof(X25519_KEY));
+  X25519_KEY *key =
+      reinterpret_cast<X25519_KEY *>(OPENSSL_malloc(sizeof(X25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -47,8 +48,10 @@ static int pkey_x25519_derive(EVP_PKEY_CTX *ctx, uint8_t *out,
     return 0;
   }
 
-  const X25519_KEY *our_key = ctx->pkey->pkey;
-  const X25519_KEY *peer_key = ctx->peerkey->pkey;
+  const X25519_KEY *our_key =
+      reinterpret_cast<const X25519_KEY *>(ctx->pkey->pkey);
+  const X25519_KEY *peer_key =
+      reinterpret_cast<const X25519_KEY *>(ctx->peerkey->pkey);
   if (our_key == NULL || peer_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_KEYS_NOT_SET);
     return 0;
@@ -88,19 +91,19 @@ static int pkey_x25519_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
 }
 
 const EVP_PKEY_METHOD x25519_pkey_meth = {
-    EVP_PKEY_X25519,
-    NULL /* init */,
-    pkey_x25519_copy,
-    NULL /* cleanup */,
-    pkey_x25519_keygen,
-    NULL /* sign */,
-    NULL /* sign_message */,
-    NULL /* verify */,
-    NULL /* verify_message */,
-    NULL /* verify_recover */,
-    NULL /* encrypt */,
-    NULL /* decrypt */,
-    pkey_x25519_derive,
-    NULL /* paramgen */,
-    pkey_x25519_ctrl,
+    /*pkey_id=*/EVP_PKEY_X25519,
+    /*init=*/NULL,
+    /*copy=*/pkey_x25519_copy,
+    /*cleanup=*/NULL,
+    /*keygen=*/pkey_x25519_keygen,
+    /*sign=*/NULL,
+    /*sign_message=*/NULL,
+    /*verify=*/NULL,
+    /*verify_message=*/NULL,
+    /*verify_recover=*/NULL,
+    /*encrypt=*/NULL,
+    /*decrypt=*/NULL,
+    /*derive=*/pkey_x25519_derive,
+    /*paramgen=*/NULL,
+    /*ctrl=*/pkey_x25519_ctrl,
 };

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, Google Inc.
+/* Copyright 2019 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 x25519_free(EVP_PKEY *pkey) {
@@ -34,7 +34,8 @@ static int x25519_set_priv_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
     return 0;
   }
 
-  X25519_KEY *key = OPENSSL_malloc(sizeof(X25519_KEY));
+  X25519_KEY *key =
+      reinterpret_cast<X25519_KEY *>(OPENSSL_malloc(sizeof(X25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -54,7 +55,8 @@ static int x25519_set_pub_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
     return 0;
   }
 
-  X25519_KEY *key = OPENSSL_malloc(sizeof(X25519_KEY));
+  X25519_KEY *key =
+      reinterpret_cast<X25519_KEY *>(OPENSSL_malloc(sizeof(X25519_KEY)));
   if (key == NULL) {
     return 0;
   }
@@ -69,7 +71,7 @@ static int x25519_set_pub_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
 
 static int x25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
                                size_t *out_len) {
-  const X25519_KEY *key = pkey->pkey;
+  const X25519_KEY *key = reinterpret_cast<X25519_KEY *>(pkey->pkey);
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -91,8 +93,8 @@ static int x25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
 }
 
 static int x25519_get_pub_raw(const EVP_PKEY *pkey, uint8_t *out,
-                               size_t *out_len) {
-  const X25519_KEY *key = pkey->pkey;
+                              size_t *out_len) {
+  const X25519_KEY *key = reinterpret_cast<X25519_KEY *>(pkey->pkey);
   if (out == NULL) {
     *out_len = 32;
     return 1;
@@ -115,13 +117,13 @@ static int x25519_set1_tls_encodedpoint(EVP_PKEY *pkey, const uint8_t *in,
 
 static size_t x25519_get1_tls_encodedpoint(const EVP_PKEY *pkey,
                                            uint8_t **out_ptr) {
-  const X25519_KEY *key = pkey->pkey;
+  const X25519_KEY *key = reinterpret_cast<X25519_KEY *>(pkey->pkey);
   if (key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
     return 0;
   }
 
-  *out_ptr = OPENSSL_memdup(key->pub, 32);
+  *out_ptr = reinterpret_cast<uint8_t *>(OPENSSL_memdup(key->pub, 32));
   return *out_ptr == NULL ? 0 : 32;
 }
 
@@ -138,7 +140,7 @@ static int x25519_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int x25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
-  const X25519_KEY *key = pkey->pkey;
+  const X25519_KEY *key = reinterpret_cast<X25519_KEY *>(pkey->pkey);
 
   // See RFC 8410, section 4.
   CBB spki, algorithm, oid, key_bitstring;
@@ -148,7 +150,7 @@ static int x25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
       !CBB_add_bytes(&oid, x25519_asn1_meth.oid, x25519_asn1_meth.oid_len) ||
       !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
       !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !CBB_add_bytes(&key_bitstring, key->pub, 32) ||
+      !CBB_add_bytes(&key_bitstring, key->pub, 32) ||  //
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -158,8 +160,8 @@ static int x25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
 }
 
 static int x25519_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const X25519_KEY *a_key = a->pkey;
-  const X25519_KEY *b_key = b->pkey;
+  const X25519_KEY *a_key = reinterpret_cast<const X25519_KEY *>(a->pkey);
+  const X25519_KEY *b_key = reinterpret_cast<const X25519_KEY *>(b->pkey);
   return OPENSSL_memcmp(a_key->pub, b_key->pub, 32) == 0;
 }
 
@@ -170,8 +172,7 @@ static int x25519_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;
   }
@@ -180,7 +181,7 @@ static int x25519_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int x25519_priv_encode(CBB *out, const EVP_PKEY *pkey) {
-  const X25519_KEY *key = pkey->pkey;
+  const X25519_KEY *key = reinterpret_cast<const X25519_KEY *>(pkey->pkey);
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -197,7 +198,7 @@ static int x25519_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->priv, 32) ||
+      !CBB_add_bytes(&inner, key->priv, 32) ||  //
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;

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

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 1999.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 1999.
  */
 /* ====================================================================
  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.

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

@@ -60,8 +60,8 @@
 #include <openssl/mem.h>
 #include <openssl/rsa.h>
 
-#include "../internal.h"
 #include "../fipsmodule/rsa/internal.h"
+#include "../internal.h"
 
 
 static int print_hex(BIO *bp, const uint8_t *data, size_t len, int off) {
@@ -105,7 +105,7 @@ static int bn_print(BIO *bp, const char *name, const BIGNUM *num, int off) {
   }
 
   if (BIO_printf(bp, "%s%s", name,
-                  (BN_is_negative(num)) ? " (Negative)" : "") <= 0) {
+                 (BN_is_negative(num)) ? " (Negative)" : "") <= 0) {
     return 0;
   }
 
@@ -115,7 +115,7 @@ static int bn_print(BIO *bp, const char *name, const BIGNUM *num, int off) {
   // TODO(davidben): Do we need to do this? We already print "(Negative)" above
   // and negative values are never valid in keys anyway.
   size_t len = BN_num_bytes(num);
-  uint8_t *buf = OPENSSL_malloc(len + 1);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len + 1));
   if (buf == NULL) {
     return 0;
   }
@@ -161,8 +161,7 @@ static int do_rsa_print(BIO *out, const RSA *rsa, int off,
     str = "Modulus:";
     s = "Exponent:";
   }
-  if (!bn_print(out, str, rsa->n, off) ||
-      !bn_print(out, s, rsa->e, off)) {
+  if (!bn_print(out, str, rsa->n, off) || !bn_print(out, s, rsa->e, off)) {
     return 0;
   }