grpc 1.69.0 → 1.71.0

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

@@ -0,0 +1,501 @@
+// Copyright 2024 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/base.h>
+
+#include <assert.h>
+#include <string.h>
+
+#include <openssl/bn.h>
+#include <openssl/bytestring.h>
+#include <openssl/crypto.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/hkdf.h>
+#include <openssl/hmac.h>
+#include <openssl/mem.h>
+#include <openssl/rand.h>
+#include <openssl/sha.h>
+
+#include "../fipsmodule/bn/internal.h"
+#include "../fipsmodule/ec/internal.h"
+#include "../internal.h"
+#include "./internal.h"
+
+BSSL_NAMESPACE_BEGIN
+namespace spake2plus {
+namespace {
+
+const uint8_t kDefaultAdditionalData[32] = {0};
+
+// https://www.rfc-editor.org/rfc/rfc9383.html#appendix-B
+// seed: 1.2.840.10045.3.1.7 point generation seed (M)
+// M =
+// 02886e2f97ace46e55ba9dd7242579f2993b64e16ef3dcab95afd497333d8fa12f
+//
+// `M` is interpreted as a X9.62-format compressed point. This is then the
+// uncompressed form:
+const uint8_t kM_bytes[] = {
+    0x04, 0x88, 0x6e, 0x2f, 0x97, 0xac, 0xe4, 0x6e, 0x55, 0xba, 0x9d,
+    0xd7, 0x24, 0x25, 0x79, 0xf2, 0x99, 0x3b, 0x64, 0xe1, 0x6e, 0xf3,
+    0xdc, 0xab, 0x95, 0xaf, 0xd4, 0x97, 0x33, 0x3d, 0x8f, 0xa1, 0x2f,
+    0x5f, 0xf3, 0x55, 0x16, 0x3e, 0x43, 0xce, 0x22, 0x4e, 0x0b, 0x0e,
+    0x65, 0xff, 0x02, 0xac, 0x8e, 0x5c, 0x7b, 0xe0, 0x94, 0x19, 0xc7,
+    0x85, 0xe0, 0xca, 0x54, 0x7d, 0x55, 0xa1, 0x2e, 0x2d, 0x20};
+
+// https://www.rfc-editor.org/rfc/rfc9383.html#appendix-B
+// seed: 1.2.840.10045.3.1.7 point generation seed (N)
+// N =
+// 03d8bbd6c639c62937b04d997f38c3770719c629d7014d49a24b4f98baa1292b49
+//
+// `N` is interpreted as a X9.62-format compressed point. This is then the
+// uncompressed form:
+const uint8_t kN_bytes[] = {
+    0x04, 0xd8, 0xbb, 0xd6, 0xc6, 0x39, 0xc6, 0x29, 0x37, 0xb0, 0x4d,
+    0x99, 0x7f, 0x38, 0xc3, 0x77, 0x07, 0x19, 0xc6, 0x29, 0xd7, 0x01,
+    0x4d, 0x49, 0xa2, 0x4b, 0x4f, 0x98, 0xba, 0xa1, 0x29, 0x2b, 0x49,
+    0x07, 0xd6, 0x0a, 0xa6, 0xbf, 0xad, 0xe4, 0x50, 0x08, 0xa6, 0x36,
+    0x33, 0x7f, 0x51, 0x68, 0xc6, 0x4d, 0x9b, 0xd3, 0x60, 0x34, 0x80,
+    0x8c, 0xd5, 0x64, 0x49, 0x0b, 0x1e, 0x65, 0x6e, 0xdb, 0xe7};
+
+void UpdateWithLengthPrefix(SHA256_CTX *sha, Span<const uint8_t> data) {
+  uint8_t len_le[8];
+  CRYPTO_store_u64_le(len_le, data.size());
+  SHA256_Update(sha, len_le, sizeof(len_le));
+  SHA256_Update(sha, data.data(), data.size());
+}
+
+void ConstantToJacobian(const EC_GROUP *group, EC_JACOBIAN *out,
+                        bssl::Span<const uint8_t> in) {
+  EC_AFFINE point;
+  BSSL_CHECK(ec_point_from_uncompressed(group, &point, in.data(), in.size()));
+  ec_affine_to_jacobian(group, out, &point);
+}
+
+void ScalarToSizedBuffer(const EC_GROUP *group, const EC_SCALAR *s,
+                         Span<uint8_t> out_buf) {
+  size_t out_bytes;
+  ec_scalar_to_bytes(group, out_buf.data(), &out_bytes, s);
+  BSSL_CHECK(out_bytes == out_buf.size());
+}
+
+bool AddLengthPrefixed(CBB *cbb, Span<const uint8_t> bytes) {
+  return CBB_add_u64le(cbb, bytes.size()) &&
+         CBB_add_bytes(cbb, bytes.data(), bytes.size());
+}
+
+void InitTranscriptHash(SHA256_CTX *sha, Span<const uint8_t> context,
+                        Span<const uint8_t> id_prover,
+                        Span<const uint8_t> id_verifier) {
+  SHA256_Init(sha);
+  UpdateWithLengthPrefix(sha, context);
+  UpdateWithLengthPrefix(sha, id_prover);
+  UpdateWithLengthPrefix(sha, id_verifier);
+  UpdateWithLengthPrefix(sha, kM_bytes);
+  UpdateWithLengthPrefix(sha, kN_bytes);
+}
+
+bool ComputeTranscript(uint8_t out_prover_confirm[kConfirmSize],
+                       uint8_t out_verifier_confirm[kConfirmSize],
+                       uint8_t out_secret[kSecretSize],
+                       const uint8_t prover_share[kShareSize],
+                       const uint8_t verifier_share[kShareSize],
+                       SHA256_CTX *sha, const EC_AFFINE *Z, const EC_AFFINE *V,
+                       const EC_SCALAR *w0) {
+  const EC_GROUP *group = EC_group_p256();
+
+  uint8_t Z_enc[kShareSize];
+  size_t Z_enc_len = ec_point_to_bytes(group, Z, POINT_CONVERSION_UNCOMPRESSED,
+                                       Z_enc, sizeof(Z_enc));
+  BSSL_CHECK(Z_enc_len == sizeof(Z_enc));
+
+  uint8_t V_enc[kShareSize];
+  size_t V_enc_len = ec_point_to_bytes(group, V, POINT_CONVERSION_UNCOMPRESSED,
+                                       V_enc, sizeof(V_enc));
+  BSSL_CHECK(V_enc_len == sizeof(V_enc));
+
+  uint8_t w0_enc[kVerifierSize];
+  ScalarToSizedBuffer(group, w0, w0_enc);
+
+  uint8_t K_main[SHA256_DIGEST_LENGTH];
+  UpdateWithLengthPrefix(sha, Span(prover_share, kShareSize));
+  UpdateWithLengthPrefix(sha, Span(verifier_share, kShareSize));
+  UpdateWithLengthPrefix(sha, Z_enc);
+  UpdateWithLengthPrefix(sha, V_enc);
+  UpdateWithLengthPrefix(sha, w0_enc);
+  SHA256_Final(K_main, sha);
+
+  auto confirmation_str = StringAsBytes("ConfirmationKeys");
+  uint8_t keys[kSecretSize * 2];
+  if (!HKDF(keys, sizeof(keys), EVP_sha256(), K_main, sizeof(K_main), nullptr,
+            0, confirmation_str.data(), confirmation_str.size())) {
+    return false;
+  }
+
+  auto secret_info_str = StringAsBytes("SharedKey");
+  if (!HKDF(out_secret, kSecretSize, EVP_sha256(), K_main, sizeof(K_main),
+            nullptr, 0, secret_info_str.data(), secret_info_str.size())) {
+    return false;
+  }
+
+  unsigned prover_confirm_len;
+  if (HMAC(EVP_sha256(), keys, kSecretSize, verifier_share, kShareSize,
+           out_prover_confirm, &prover_confirm_len) == nullptr) {
+    return false;
+  }
+  BSSL_CHECK(prover_confirm_len == kConfirmSize);
+
+  unsigned verifier_confirm_len;
+  if (HMAC(EVP_sha256(), keys + kSecretSize, kSecretSize, prover_share,
+           kShareSize, out_verifier_confirm,
+           &verifier_confirm_len) == nullptr) {
+    return false;
+  }
+  BSSL_CHECK(verifier_confirm_len == kConfirmSize);
+
+  return true;
+}
+
+}  // namespace
+
+bool Register(Span<uint8_t> out_w0, Span<uint8_t> out_w1,
+              Span<uint8_t> out_registration_record,
+              Span<const uint8_t> password, Span<const uint8_t> id_prover,
+              Span<const uint8_t> id_verifier) {
+  if (out_w0.size() != kVerifierSize || out_w1.size() != kVerifierSize ||
+      out_registration_record.size() != kRegistrationRecordSize) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  // Offline registration format from:
+  // https://www.rfc-editor.org/rfc/rfc9383.html#section-3.2
+  ScopedCBB mhf_input;
+  if (!CBB_init(mhf_input.get(), password.size() + id_prover.size() +
+                                     id_verifier.size() +
+                                     3 * sizeof(uint64_t)) ||  //
+      !AddLengthPrefixed(mhf_input.get(), password) ||
+      !AddLengthPrefixed(mhf_input.get(), id_prover) ||
+      !AddLengthPrefixed(mhf_input.get(), id_verifier) ||
+      !CBB_flush(mhf_input.get())) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  // https://neuromancer.sk/std/nist/P-256
+  //   sage: p =
+  //   0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
+  //   ....: K = GF(p)
+  //   ....: a =
+  //   K(0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc)
+  //   ....: b =
+  //   K(0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b)
+  //   ....: E = EllipticCurve(K, (a, b))
+  //   ....: G =
+  //   E(0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296,
+  //   ....: 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5)
+  //   ....:
+  //   E.set_order(0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63
+  //   ....: 2551 * 0x1)
+  //   sage: k = 64
+  //   sage: L = (2 * (ceil(log(p)/log(2)) + k)) / 8
+
+  // RFC 9383 Section 3.2
+  constexpr size_t kKDFOutputSize = 80;
+  constexpr size_t kKDFOutputWords = kKDFOutputSize / BN_BYTES;
+
+  uint8_t key[kKDFOutputSize];
+  if (!EVP_PBE_scrypt((const char *)CBB_data(mhf_input.get()),
+                      CBB_len(mhf_input.get()), nullptr, 0,
+                      /*N=*/32768, /*r=*/8, /*p=*/1,
+                      /*max_mem=*/1024 * 1024 * 33, key, kKDFOutputSize)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  const EC_GROUP *group = EC_group_p256();
+  BN_ULONG w0_words[kKDFOutputWords / 2];
+  bn_big_endian_to_words(w0_words, kKDFOutputWords / 2, key,
+                         kKDFOutputSize / 2);
+  EC_SCALAR w0;
+  ec_scalar_reduce(group, &w0, w0_words, kKDFOutputWords / 2);
+  ScalarToSizedBuffer(group, &w0, out_w0);
+
+  BN_ULONG w1_words[kKDFOutputWords / 2];
+  bn_big_endian_to_words(w1_words, kKDFOutputWords / 2,
+                         key + kKDFOutputSize / 2, kKDFOutputSize / 2);
+  EC_SCALAR w1;
+  ec_scalar_reduce(group, &w1, w1_words, kKDFOutputWords / 2);
+  ScalarToSizedBuffer(group, &w1, out_w1);
+
+  EC_JACOBIAN L_j;
+  EC_AFFINE L;
+  if (!ec_point_mul_scalar_base(group, &L_j, &w1) ||  //
+      !ec_jacobian_to_affine(group, &L, &L_j) ||      //
+      !ec_point_to_bytes(group, &L, POINT_CONVERSION_UNCOMPRESSED,
+                         out_registration_record.data(),
+                         kRegistrationRecordSize)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  return true;
+}
+
+Prover::Prover() = default;
+Prover::~Prover() = default;
+
+bool Prover::Init(Span<const uint8_t> context, Span<const uint8_t> id_prover,
+                  Span<const uint8_t> id_verifier, Span<const uint8_t> w0,
+                  Span<const uint8_t> w1, Span<const uint8_t> x) {
+  const EC_GROUP *group = EC_group_p256();
+
+  if (!ec_scalar_from_bytes(group, &w0_, w0.data(), w0.size()) ||
+      !ec_scalar_from_bytes(group, &w1_, w1.data(), w1.size()) ||
+      (!x.empty() &&
+       !ec_scalar_from_bytes(group, &x_, x.data(), x.size())) ||  //
+      (x.empty() && !ec_random_scalar(group, &x_, kDefaultAdditionalData))) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  InitTranscriptHash(&transcript_hash_, context, id_prover, id_verifier);
+
+  return true;
+}
+
+bool Prover::GenerateShare(Span<uint8_t> out_share) {
+  if (state_ != State::kInit || out_share.size() != kShareSize) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  // Compute X = x×P + w0×M.
+  // TODO(crbug.com/383778231): This could be sped up with a constant-time,
+  // two-point multiplication.
+  const EC_GROUP *group = EC_group_p256();
+  EC_JACOBIAN l;
+  if (!ec_point_mul_scalar_base(group, &l, &x_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  EC_JACOBIAN M_j;
+  ConstantToJacobian(group, &M_j, kM_bytes);
+
+  EC_JACOBIAN r;
+  if (!ec_point_mul_scalar(group, &r, &M_j, &w0_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  EC_JACOBIAN X_j;
+  group->meth->add(group, &X_j, &l, &r);
+  if (!ec_jacobian_to_affine(group, &X_, &X_j)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  size_t written = ec_point_to_bytes(group, &X_, POINT_CONVERSION_UNCOMPRESSED,
+                                     out_share.data(), kShareSize);
+  BSSL_CHECK(written == kShareSize);
+
+  memcpy(share_, out_share.data(), kShareSize);
+  state_ = State::kShareGenerated;
+  return true;
+}
+
+bool Prover::ComputeConfirmation(Span<uint8_t> out_confirm,
+                                 Span<uint8_t> out_secret,
+                                 Span<const uint8_t> peer_share,
+                                 Span<const uint8_t> peer_confirm) {
+  if (state_ != State::kShareGenerated || out_confirm.size() != kConfirmSize ||
+      out_secret.size() != kSecretSize || peer_share.size() != kShareSize ||
+      peer_confirm.size() != kConfirmSize) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  const EC_GROUP *group = EC_group_p256();
+  EC_AFFINE Y;
+  if (!ec_point_from_uncompressed(group, &Y, peer_share.data(),
+                                  peer_share.size())) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  EC_JACOBIAN N_j;
+  ConstantToJacobian(group, &N_j, kN_bytes);
+
+  EC_JACOBIAN r;
+  if (!ec_point_mul_scalar(group, &r, &N_j, &w0_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  ec_felem_neg(group, &r.Y, &r.Y);
+
+  EC_JACOBIAN Y_j;
+  ec_affine_to_jacobian(group, &Y_j, &Y);
+
+  EC_JACOBIAN t;
+  group->meth->add(group, &t, &Y_j, &r);
+
+  EC_JACOBIAN tmp;
+  EC_AFFINE Z, V;
+  // TODO(crbug.com/383778231): The two affine conversions could be batched
+  // together.
+  if (!ec_point_mul_scalar(group, &tmp, &t, &x_) ||   //
+      !ec_jacobian_to_affine(group, &Z, &tmp) ||      //
+      !ec_point_mul_scalar(group, &tmp, &t, &w1_) ||  //
+      !ec_jacobian_to_affine(group, &V, &tmp)) {
+    return 0;
+  }
+
+  uint8_t verifier_confirm[kConfirmSize];
+  if (!ComputeTranscript(out_confirm.data(), verifier_confirm,
+                         out_secret.data(), share_, peer_share.data(),
+                         &transcript_hash_, &Z, &V, &w0_) ||
+      CRYPTO_memcmp(verifier_confirm, peer_confirm.data(),
+                    sizeof(verifier_confirm)) != 0) {
+    return 0;
+  }
+
+  state_ = State::kDone;
+  return true;
+}
+
+Verifier::Verifier() = default;
+Verifier::~Verifier() = default;
+
+bool Verifier::Init(Span<const uint8_t> context, Span<const uint8_t> id_prover,
+                    Span<const uint8_t> id_verifier, Span<const uint8_t> w0,
+                    Span<const uint8_t> registration_record,
+                    Span<const uint8_t> y) {
+  const EC_GROUP *group = EC_group_p256();
+
+  if (!ec_scalar_from_bytes(group, &w0_, w0.data(), w0.size()) ||
+      !ec_point_from_uncompressed(group, &L_, registration_record.data(),
+                                  registration_record.size()) ||  //
+      (!y.empty() &&
+       !ec_scalar_from_bytes(group, &y_, y.data(), y.size())) ||  //
+      (y.empty() && !ec_random_scalar(group, &y_, kDefaultAdditionalData))) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  InitTranscriptHash(&transcript_hash_, context, id_prover, id_verifier);
+
+  return true;
+}
+
+
+bool Verifier::ProcessProverShare(Span<uint8_t> out_share,
+                                  Span<uint8_t> out_confirm,
+                                  Span<uint8_t> out_secret,
+                                  Span<const uint8_t> prover_share) {
+  if (state_ != State::kInit ||  //
+      out_share.size() != kShareSize || out_confirm.size() != kConfirmSize ||
+      out_secret.size() != kSecretSize || prover_share.size() != kShareSize) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  const EC_GROUP *group = EC_group_p256();
+  EC_JACOBIAN l, r, M_j, N_j;
+  ConstantToJacobian(group, &M_j, kM_bytes);
+  ConstantToJacobian(group, &N_j, kN_bytes);
+
+  // Compute Y = y×P + w0×M.
+  // TODO(crbug.com/383778231): This could be sped up with a constant-time,
+  // two-point multiplication.
+  if (!ec_point_mul_scalar_base(group, &l, &y_) ||
+      !ec_point_mul_scalar(group, &r, &N_j, &w0_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  EC_JACOBIAN Y_j;
+  EC_AFFINE Y;
+  group->meth->add(group, &Y_j, &l, &r);
+  if (!ec_jacobian_to_affine(group, &Y, &Y_j)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  const size_t written = ec_point_to_bytes(
+      group, &Y, POINT_CONVERSION_UNCOMPRESSED, out_share.data(), kShareSize);
+  BSSL_CHECK(written == kShareSize);
+
+  EC_JACOBIAN r2;
+  EC_AFFINE X;
+  if (!ec_point_from_uncompressed(group, &X, prover_share.data(),
+                                  prover_share.size()) ||
+      !ec_point_mul_scalar(group, &r2, &M_j, &w0_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  ec_felem_neg(group, &r2.Y, &r2.Y);
+
+  EC_JACOBIAN X_j, T;
+  ec_affine_to_jacobian(group, &X_j, &X);
+  group->meth->add(group, &T, &X_j, &r2);
+
+  // TODO(crbug.com/383778231): The two affine conversions could be batched
+  // together.
+  EC_JACOBIAN tmp;
+  EC_AFFINE Z;
+  if (!ec_point_mul_scalar(group, &tmp, &T, &y_) ||  //
+      !ec_jacobian_to_affine(group, &Z, &tmp)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  EC_JACOBIAN L_j;
+  EC_AFFINE V;
+  ec_affine_to_jacobian(group, &L_j, &L_);
+  if (!ec_point_mul_scalar(group, &tmp, &L_j, &y_) ||  //
+      !ec_jacobian_to_affine(group, &V, &tmp)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  if (!ComputeTranscript(confirm_, out_confirm.data(), out_secret.data(),
+                         prover_share.data(), out_share.data(),
+                         &transcript_hash_, &Z, &V, &w0_)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  state_ = State::kProverShareSeen;
+  return true;
+}
+
+bool Verifier::VerifyProverConfirmation(Span<const uint8_t> peer_confirm) {
+  if (state_ != State::kProverShareSeen ||    //
+      peer_confirm.size() != kConfirmSize ||  //
+      CRYPTO_memcmp(confirm_, peer_confirm.data(), sizeof(confirm_)) != 0) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+
+  state_ = State::kDone;
+  return true;
+}
+
+}  // namespace spake2plus
+
+BSSL_NAMESPACE_END

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

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * 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 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 acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS 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 AUTHOR OR 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.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// 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/stack.h>
 
@@ -84,12 +42,14 @@ struct stack_st {
 static const size_t kMinSize = 4;
 
 OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_cmp_func comp) {
-  OPENSSL_STACK *ret = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
+  OPENSSL_STACK *ret =
+      reinterpret_cast<OPENSSL_STACK *>(OPENSSL_zalloc(sizeof(OPENSSL_STACK)));
   if (ret == NULL) {
     return NULL;
   }
 
-  ret->data = OPENSSL_calloc(kMinSize, sizeof(void *));
+  ret->data =
+      reinterpret_cast<void **>(OPENSSL_calloc(kMinSize, sizeof(void *)));
   if (ret->data == NULL) {
     goto err;
   }
@@ -117,7 +77,7 @@ void OPENSSL_sk_zero(OPENSSL_STACK *sk) {
   if (sk == NULL || sk->num == 0) {
     return;
   }
-  OPENSSL_memset(sk->data, 0, sizeof(void*) * sk->num);
+  OPENSSL_memset(sk->data, 0, sizeof(void *) * sk->num);
   sk->num = 0;
   sk->sorted = 0;
 }
@@ -197,7 +157,7 @@ size_t OPENSSL_sk_insert(OPENSSL_STACK *sk, void *p, size_t where) {
       return 0;
     }
 
-    data = OPENSSL_realloc(sk->data, alloc_size);
+    data = reinterpret_cast<void **>(OPENSSL_realloc(sk->data, alloc_size));
     if (data == NULL) {
       return 0;
     }
@@ -367,12 +327,14 @@ OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *sk) {
     return NULL;
   }
 
-  OPENSSL_STACK *ret = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
+  OPENSSL_STACK *ret =
+      reinterpret_cast<OPENSSL_STACK *>(OPENSSL_zalloc(sizeof(OPENSSL_STACK)));
   if (ret == NULL) {
     return NULL;
   }
 
-  ret->data = OPENSSL_memdup(sk->data, sizeof(void *) * sk->num_alloc);
+  ret->data = reinterpret_cast<void **>(
+      OPENSSL_memdup(sk->data, sizeof(void *) * sk->num_alloc));
   if (ret->data == NULL) {
     goto err;
   }

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

@@ -0,0 +1,68 @@
+// 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/thread.h>
+
+
+int CRYPTO_num_locks(void) { return 1; }
+
+void CRYPTO_set_locking_callback(void (*func)(int mode, int lock_num,
+                                              const char *file, int line)) {}
+
+void (*CRYPTO_get_locking_callback(void))(int mode, int lock_num,
+                                          const char *file, int line) {
+  return NULL;
+}
+
+void CRYPTO_set_add_lock_callback(int (*func)(int *num, int mount, int lock_num,
+                                              const char *file, int line)) {}
+
+const char *CRYPTO_get_lock_name(int lock_num) {
+  return "No old-style OpenSSL locks anymore";
+}
+
+int CRYPTO_THREADID_set_callback(void (*func)(CRYPTO_THREADID *)) { return 1; }
+
+void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val) {}
+
+void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr) {}
+
+void CRYPTO_THREADID_current(CRYPTO_THREADID *id) {}
+
+void CRYPTO_set_id_callback(unsigned long (*func)(void)) {}
+
+void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(
+    *dyn_create_function)(const char *file, int line)) {}
+
+void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(
+    int mode, struct CRYPTO_dynlock_value *l, const char *file, int line)) {}
+
+void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(
+    struct CRYPTO_dynlock_value *l, const char *file, int line)) {}
+
+struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(
+    const char *file, int line) {
+  return NULL;
+}
+
+void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
+                                               struct CRYPTO_dynlock_value *l,
+                                               const char *file, int line) {
+  return NULL;
+}
+
+void (*CRYPTO_get_dynlock_destroy_callback(void))(
+    struct CRYPTO_dynlock_value *l, const char *file, int line) {
+  return NULL;
+}