grpc 1.69.0 → 1.71.0

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

@@ -1,57 +1,16 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 2006.
- */
-/* ====================================================================
- * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    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
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    licensing@OpenSSL.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com). */
+// Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/evp.h>
 
@@ -66,7 +25,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);
 
@@ -93,31 +52,26 @@ static int eckey_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
   // See RFC 5480, section 2.
 
   // The parameters are a named curve.
-  EC_KEY *eckey = NULL;
   const EC_GROUP *group = EC_KEY_parse_curve_name(params);
   if (group == NULL || CBS_len(params) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    goto err;
+    return 0;
   }
 
-  eckey = EC_KEY_new();
-  if (eckey == NULL || //
-      !EC_KEY_set_group(eckey, group) ||
-      !EC_KEY_oct2key(eckey, CBS_data(key), CBS_len(key), NULL)) {
-    goto err;
+  bssl::UniquePtr<EC_KEY> eckey(EC_KEY_new());
+  if (eckey == nullptr ||  //
+      !EC_KEY_set_group(eckey.get(), group) ||
+      !EC_KEY_oct2key(eckey.get(), CBS_data(key), CBS_len(key), nullptr)) {
+    return 0;
   }
 
-  EVP_PKEY_assign_EC_KEY(out, eckey);
+  EVP_PKEY_assign_EC_KEY(out, eckey.release());
   return 1;
-
-err:
-  EC_KEY_free(eckey);
-  return 0;
 }
 
 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 +105,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 +133,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 +144,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 +154,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 +169,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 +190,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 +212,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 +274,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,16 +1,16 @@
-/* Copyright (c) 2017, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2017 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/evp.h>
 
@@ -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,16 +1,16 @@
-/* Copyright (c) 2017, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2017 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/evp.h>
 
@@ -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;

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

@@ -1,16 +1,16 @@
-/* Copyright (c) 2022, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2022 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/evp.h>
 
@@ -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,