grpc 1.69.0 → 1.71.0

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

@@ -1,16 +1,16 @@
-/* Copyright (c) 2019, 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 2019 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 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.cc

@@ -0,0 +1,98 @@
+// Copyright 1999-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>
+
+#include <string.h>
+
+#include <openssl/hmac.h>
+
+#include "../internal.h"
+
+
+int PKCS5_PBKDF2_HMAC(const char *password, size_t password_len,
+                      const uint8_t *salt, size_t salt_len, uint32_t iterations,
+                      const EVP_MD *digest, size_t key_len, uint8_t *out_key) {
+  // See RFC 8018, section 5.2.
+  bssl::ScopedHMAC_CTX hctx;
+  if (!HMAC_Init_ex(hctx.get(), password, password_len, digest, NULL)) {
+    return 0;
+  }
+
+  uint32_t i = 1;
+  size_t md_len = EVP_MD_size(digest);
+  while (key_len > 0) {
+    size_t todo = md_len;
+    if (todo > key_len) {
+      todo = key_len;
+    }
+
+    uint8_t i_buf[4];
+    i_buf[0] = (uint8_t)((i >> 24) & 0xff);
+    i_buf[1] = (uint8_t)((i >> 16) & 0xff);
+    i_buf[2] = (uint8_t)((i >> 8) & 0xff);
+    i_buf[3] = (uint8_t)(i & 0xff);
+
+    // Compute U_1.
+    uint8_t digest_tmp[EVP_MAX_MD_SIZE];
+    if (!HMAC_Init_ex(hctx.get(), NULL, 0, NULL, NULL) ||
+        !HMAC_Update(hctx.get(), salt, salt_len) ||
+        !HMAC_Update(hctx.get(), i_buf, 4) ||
+        !HMAC_Final(hctx.get(), digest_tmp, NULL)) {
+      return 0;
+    }
+
+    OPENSSL_memcpy(out_key, digest_tmp, todo);
+    for (uint32_t j = 1; j < iterations; j++) {
+      // Compute the remaining U_* values and XOR.
+      if (!HMAC_Init_ex(hctx.get(), NULL, 0, NULL, NULL) ||
+          !HMAC_Update(hctx.get(), digest_tmp, md_len) ||
+          !HMAC_Final(hctx.get(), digest_tmp, NULL)) {
+        return 0;
+      }
+      for (size_t k = 0; k < todo; k++) {
+        out_key[k] ^= digest_tmp[k];
+      }
+    }
+
+    key_len -= todo;
+    out_key += todo;
+    i++;
+  }
+
+  // RFC 8018 describes iterations (c) as being a "positive integer", so a
+  // value of 0 is an error.
+  //
+  // Unfortunately not all consumers of PKCS5_PBKDF2_HMAC() check their return
+  // value, expecting it to succeed and unconditionally using |out_key|.  As a
+  // precaution for such callsites in external code, the old behavior of
+  // iterations < 1 being treated as iterations == 1 is preserved, but
+  // additionally an error result is returned.
+  //
+  // TODO(eroman): Figure out how to remove this compatibility hack, or change
+  // the default to something more sensible like 2048.
+  if (iterations == 0) {
+    return 0;
+  }
+
+  return 1;
+}
+
+int PKCS5_PBKDF2_HMAC_SHA1(const char *password, size_t password_len,
+                           const uint8_t *salt, size_t salt_len,
+                           uint32_t iterations, size_t key_len,
+                           uint8_t *out_key) {
+  return PKCS5_PBKDF2_HMAC(password, password_len, salt, salt_len, iterations,
+                           EVP_sha1(), key_len, out_key);
+}

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

@@ -1,54 +1,16 @@
-/* ====================================================================
- * 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>
 
@@ -60,8 +22,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 +67,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 +77,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 +123,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;
   }
 

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

@@ -1,11 +1,16 @@
-/*
- * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
- *
- * Licensed under the OpenSSL license (the "License").  You may not use
- * this file except in compliance with the License.  You can obtain a copy
- * in the file LICENSE in the source distribution or at
- * https://www.openssl.org/source/license.html
- */
+// Copyright 2015-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>
 
@@ -27,7 +32,9 @@
 // scrypt blocks, respectively.
 
 // A block_t is a Salsa20 block.
-typedef struct { uint32_t words[16]; } block_t;
+typedef struct {
+  uint32_t words[16];
+} block_t;
 
 static_assert(sizeof(block_t) == 64, "block_t has padding");
 
@@ -138,7 +145,7 @@ static void scryptROMix(block_t *B, uint64_t r, uint64_t N, block_t *T,
 
 // SCRYPT_MAX_MEM is the default maximum memory that may be allocated by
 // |EVP_PBE_scrypt|.
-#define SCRYPT_MAX_MEM (1024 * 1024 * 32)
+#define SCRYPT_MAX_MEM (1024 * 1024 * 65)
 
 int EVP_PBE_scrypt(const char *password, size_t password_len,
                    const uint8_t *salt, size_t salt_len, uint64_t N, uint64_t r,
@@ -162,8 +169,7 @@ int EVP_PBE_scrypt(const char *password, size_t password_len,
   }
 
   size_t max_scrypt_blocks = max_mem / (2 * r * sizeof(block_t));
-  if (max_scrypt_blocks < p + 1 ||
-      max_scrypt_blocks - p - 1 < N) {
+  if (max_scrypt_blocks < p + 1 || max_scrypt_blocks - p - 1 < N) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_MEMORY_LIMIT_EXCEEDED);
     return 0;
   }
@@ -175,7 +181,8 @@ int EVP_PBE_scrypt(const char *password, size_t password_len,
   size_t B_bytes = B_blocks * sizeof(block_t);
   size_t T_blocks = 2 * r;
   size_t V_blocks = N * 2 * r;
-  block_t *B = OPENSSL_calloc(B_blocks + T_blocks + V_blocks, sizeof(block_t));
+  block_t *B = reinterpret_cast<block_t *>(
+      OPENSSL_calloc(B_blocks + T_blocks + V_blocks, sizeof(block_t)));
   if (B == NULL) {
     return 0;
   }

data/third_party/boringssl-with-bazel/src/crypto/evp/sign.cc

@@ -0,0 +1,114 @@
+// Copyright 1995-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>
+
+#include <limits.h>
+
+#include <openssl/digest.h>
+#include <openssl/err.h>
+
+#include "internal.h"
+
+
+int EVP_SignInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl) {
+  return EVP_DigestInit_ex(ctx, type, impl);
+}
+
+int EVP_SignInit(EVP_MD_CTX *ctx, const EVP_MD *type) {
+  return EVP_DigestInit(ctx, type);
+}
+
+int EVP_SignUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) {
+  return EVP_DigestUpdate(ctx, data, len);
+}
+
+int EVP_SignFinal(const EVP_MD_CTX *ctx, uint8_t *sig, unsigned *out_sig_len,
+                  EVP_PKEY *pkey) {
+  uint8_t m[EVP_MAX_MD_SIZE];
+  unsigned m_len;
+  int ret = 0;
+  EVP_MD_CTX tmp_ctx;
+  EVP_PKEY_CTX *pkctx = NULL;
+  size_t sig_len = EVP_PKEY_size(pkey);
+
+  // Ensure the final result will fit in |unsigned|.
+  if (sig_len > UINT_MAX) {
+    sig_len = UINT_MAX;
+  }
+
+  *out_sig_len = 0;
+  EVP_MD_CTX_init(&tmp_ctx);
+  if (!EVP_MD_CTX_copy_ex(&tmp_ctx, ctx) ||
+      !EVP_DigestFinal_ex(&tmp_ctx, m, &m_len)) {
+    goto out;
+  }
+  EVP_MD_CTX_cleanup(&tmp_ctx);
+
+  pkctx = EVP_PKEY_CTX_new(pkey, NULL);
+  if (!pkctx ||  //
+      !EVP_PKEY_sign_init(pkctx) ||
+      !EVP_PKEY_CTX_set_signature_md(pkctx, ctx->digest) ||
+      !EVP_PKEY_sign(pkctx, sig, &sig_len, m, m_len)) {
+    goto out;
+  }
+  *out_sig_len = (unsigned)sig_len;
+  ret = 1;
+
+out:
+  EVP_PKEY_CTX_free(pkctx);
+  return ret;
+}
+
+int EVP_VerifyInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl) {
+  return EVP_DigestInit_ex(ctx, type, impl);
+}
+
+int EVP_VerifyInit(EVP_MD_CTX *ctx, const EVP_MD *type) {
+  return EVP_DigestInit(ctx, type);
+}
+
+int EVP_VerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) {
+  return EVP_DigestUpdate(ctx, data, len);
+}
+
+int EVP_VerifyFinal(EVP_MD_CTX *ctx, const uint8_t *sig, size_t sig_len,
+                    EVP_PKEY *pkey) {
+  uint8_t m[EVP_MAX_MD_SIZE];
+  unsigned m_len;
+  int ret = 0;
+  EVP_MD_CTX tmp_ctx;
+  EVP_PKEY_CTX *pkctx = NULL;
+
+  EVP_MD_CTX_init(&tmp_ctx);
+  if (!EVP_MD_CTX_copy_ex(&tmp_ctx, ctx) ||
+      !EVP_DigestFinal_ex(&tmp_ctx, m, &m_len)) {
+    EVP_MD_CTX_cleanup(&tmp_ctx);
+    goto out;
+  }
+  EVP_MD_CTX_cleanup(&tmp_ctx);
+
+  pkctx = EVP_PKEY_CTX_new(pkey, NULL);
+  if (!pkctx ||
+      !EVP_PKEY_verify_init(pkctx) ||
+      !EVP_PKEY_CTX_set_signature_md(pkctx, ctx->digest)) {
+    goto out;
+  }
+  ret = EVP_PKEY_verify(pkctx, sig, sig_len, m, m_len);
+
+out:
+  EVP_PKEY_CTX_free(pkctx);
+  return ret;
+}
+

data/third_party/boringssl-with-bazel/src/crypto/ex_data.cc

@@ -0,0 +1,141 @@
+// Copyright 1995-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/ex_data.h>
+
+#include <assert.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#include <openssl/mem.h>
+#include <openssl/thread.h>
+
+#include "internal.h"
+
+
+DEFINE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
+
+struct crypto_ex_data_func_st {
+  long argl;   // Arbitary long
+  void *argp;  // Arbitary void pointer
+  CRYPTO_EX_free *free_func;
+  // next points to the next |CRYPTO_EX_DATA_FUNCS| or NULL if this is the last
+  // one. It may only be read if synchronized with a read from |num_funcs|.
+  CRYPTO_EX_DATA_FUNCS *next;
+};
+
+int CRYPTO_get_ex_new_index_ex(CRYPTO_EX_DATA_CLASS *ex_data_class, long argl,
+                               void *argp, CRYPTO_EX_free *free_func) {
+  CRYPTO_EX_DATA_FUNCS *funcs = reinterpret_cast<CRYPTO_EX_DATA_FUNCS *>(
+      OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS)));
+  if (funcs == NULL) {
+    return -1;
+  }
+
+  funcs->argl = argl;
+  funcs->argp = argp;
+  funcs->free_func = free_func;
+  funcs->next = NULL;
+
+  CRYPTO_MUTEX_lock_write(&ex_data_class->lock);
+
+  uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs);
+  // The index must fit in |int|.
+  if (num_funcs > (size_t)(INT_MAX - ex_data_class->num_reserved)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+    CRYPTO_MUTEX_unlock_write(&ex_data_class->lock);
+    return -1;
+  }
+
+  // Append |funcs| to the linked list.
+  if (ex_data_class->last == NULL) {
+    assert(num_funcs == 0);
+    ex_data_class->funcs = funcs;
+    ex_data_class->last = funcs;
+  } else {
+    ex_data_class->last->next = funcs;
+    ex_data_class->last = funcs;
+  }
+
+  CRYPTO_atomic_store_u32(&ex_data_class->num_funcs, num_funcs + 1);
+  CRYPTO_MUTEX_unlock_write(&ex_data_class->lock);
+  return (int)num_funcs + ex_data_class->num_reserved;
+}
+
+int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int index, void *val) {
+  if (index < 0) {
+    // A caller that can accidentally pass in an invalid index into this
+    // function will hit an memory error if |index| happened to be valid, and
+    // expected |val| to be of a different type.
+    abort();
+  }
+
+  if (ad->sk == NULL) {
+    ad->sk = sk_void_new_null();
+    if (ad->sk == NULL) {
+      return 0;
+    }
+  }
+
+  // Add NULL values until the stack is long enough.
+  for (size_t i = sk_void_num(ad->sk); i <= (size_t)index; i++) {
+    if (!sk_void_push(ad->sk, NULL)) {
+      return 0;
+    }
+  }
+
+  sk_void_set(ad->sk, (size_t)index, val);
+  return 1;
+}
+
+void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx) {
+  if (ad->sk == NULL || idx < 0 || (size_t)idx >= sk_void_num(ad->sk)) {
+    return NULL;
+  }
+  return sk_void_value(ad->sk, idx);
+}
+
+void CRYPTO_new_ex_data(CRYPTO_EX_DATA *ad) { ad->sk = NULL; }
+
+void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class, void *obj,
+                         CRYPTO_EX_DATA *ad) {
+  if (ad->sk == NULL) {
+    // Nothing to do.
+    return;
+  }
+
+  uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs);
+  // |CRYPTO_get_ex_new_index_ex| will not allocate indices beyond |INT_MAX|.
+  assert(num_funcs <= (size_t)(INT_MAX - ex_data_class->num_reserved));
+
+  // Defer dereferencing |ex_data_class->funcs| and |funcs->next|. It must come
+  // after the |num_funcs| comparison to be correctly synchronized.
+  CRYPTO_EX_DATA_FUNCS *const *funcs = &ex_data_class->funcs;
+  for (uint32_t i = 0; i < num_funcs; i++) {
+    if ((*funcs)->free_func != NULL) {
+      int index = (int)i + ex_data_class->num_reserved;
+      void *ptr = CRYPTO_get_ex_data(ad, index);
+      (*funcs)->free_func(obj, ptr, ad, index, (*funcs)->argl, (*funcs)->argp);
+    }
+    funcs = &(*funcs)->next;
+  }
+
+  sk_void_free(ad->sk);
+  ad->sk = NULL;
+}
+
+void CRYPTO_cleanup_all_ex_data(void) {}