grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/fipsmodule/ec/p256-nistz.h

@@ -1,207 +0,0 @@
-// Copyright 2014-2016 The OpenSSL Project Authors. All Rights Reserved.
-// Copyright (c) 2014, Intel Corporation. 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.
-//
-// Originally written by Shay Gueron (1, 2), and Vlad Krasnov (1)
-// (1) Intel Corporation, Israel Development Center, Haifa, Israel
-// (2) University of Haifa, Israel
-//
-// Reference:
-// S.Gueron and V.Krasnov, "Fast Prime Field Elliptic Curve Cryptography with
-//                          256 Bit Primes"
-
-#ifndef OPENSSL_HEADER_CRYPTO_FIPSMODULE_EC_P256_NISTZ_H
-#define OPENSSL_HEADER_CRYPTO_FIPSMODULE_EC_P256_NISTZ_H
-
-#include <openssl/base.h>
-
-#include <openssl/bn.h>
-
-#include "../bn/internal.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-
-#if !defined(OPENSSL_NO_ASM) && \
-    (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) &&   \
-    !defined(OPENSSL_SMALL)
-
-// P-256 field operations.
-//
-// An element mod P in P-256 is represented as a little-endian array of
-// |P256_LIMBS| |BN_ULONG|s, spanning the full range of values.
-//
-// The following functions take fully-reduced inputs mod P and give
-// fully-reduced outputs. They may be used in-place.
-
-#define P256_LIMBS (256 / BN_BITS2)
-
-// ecp_nistz256_neg sets |res| to -|a| mod P.
-void ecp_nistz256_neg(BN_ULONG res[P256_LIMBS], const BN_ULONG a[P256_LIMBS]);
-
-// ecp_nistz256_mul_mont sets |res| to |a| * |b| * 2^-256 mod P.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_mul_mont_nohw(BN_ULONG res[P256_LIMBS],
-                                const BN_ULONG a[P256_LIMBS],
-                                const BN_ULONG b[P256_LIMBS]);
-void ecp_nistz256_mul_mont_adx(BN_ULONG res[P256_LIMBS],
-                               const BN_ULONG a[P256_LIMBS],
-                               const BN_ULONG b[P256_LIMBS]);
-#else
-void ecp_nistz256_mul_mont(BN_ULONG res[P256_LIMBS],
-                           const BN_ULONG a[P256_LIMBS],
-                           const BN_ULONG b[P256_LIMBS]);
-#endif
-
-// ecp_nistz256_sqr_mont sets |res| to |a| * |a| * 2^-256 mod P.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_sqr_mont_nohw(BN_ULONG res[P256_LIMBS],
-                                const BN_ULONG a[P256_LIMBS]);
-void ecp_nistz256_sqr_mont_adx(BN_ULONG res[P256_LIMBS],
-                               const BN_ULONG a[P256_LIMBS]);
-#else
-void ecp_nistz256_sqr_mont(BN_ULONG res[P256_LIMBS],
-                           const BN_ULONG a[P256_LIMBS]);
-#endif
-
-
-// P-256 scalar operations.
-//
-// The following functions compute modulo N, where N is the order of P-256. They
-// take fully-reduced inputs and give fully-reduced outputs.
-
-// ecp_nistz256_ord_mul_mont sets |res| to |a| * |b| where inputs and outputs
-// are in Montgomery form. That is, |res| is |a| * |b| * 2^-256 mod N.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_ord_mul_mont_nohw(BN_ULONG res[P256_LIMBS],
-                                    const BN_ULONG a[P256_LIMBS],
-                                    const BN_ULONG b[P256_LIMBS]);
-void ecp_nistz256_ord_mul_mont_adx(BN_ULONG res[P256_LIMBS],
-                                   const BN_ULONG a[P256_LIMBS],
-                                   const BN_ULONG b[P256_LIMBS]);
-#else
-void ecp_nistz256_ord_mul_mont(BN_ULONG res[P256_LIMBS],
-                               const BN_ULONG a[P256_LIMBS],
-                               const BN_ULONG b[P256_LIMBS]);
-#endif
-
-// ecp_nistz256_ord_sqr_mont sets |res| to |a|^(2*|rep|) where inputs and
-// outputs are in Montgomery form. That is, |res| is
-// (|a| * 2^-256)^(2*|rep|) * 2^256 mod N.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_ord_sqr_mont_nohw(BN_ULONG res[P256_LIMBS],
-                                    const BN_ULONG a[P256_LIMBS], BN_ULONG rep);
-void ecp_nistz256_ord_sqr_mont_adx(BN_ULONG res[P256_LIMBS],
-                                   const BN_ULONG a[P256_LIMBS], BN_ULONG rep);
-#else
-void ecp_nistz256_ord_sqr_mont(BN_ULONG res[P256_LIMBS],
-                               const BN_ULONG a[P256_LIMBS], BN_ULONG rep);
-#endif
-
-// beeu_mod_inverse_vartime sets out = a^-1 mod p using a Euclidean algorithm.
-// Assumption: 0 < a < p < 2^(256) and p is odd.
-int beeu_mod_inverse_vartime(BN_ULONG out[P256_LIMBS],
-                             const BN_ULONG a[P256_LIMBS],
-                             const BN_ULONG p[P256_LIMBS]);
-
-
-// P-256 point operations.
-//
-// The following functions may be used in-place. All coordinates are in the
-// Montgomery domain.
-
-// A P256_POINT represents a P-256 point in Jacobian coordinates.
-typedef struct {
-  BN_ULONG X[P256_LIMBS];
-  BN_ULONG Y[P256_LIMBS];
-  BN_ULONG Z[P256_LIMBS];
-} P256_POINT;
-
-// A P256_POINT_AFFINE represents a P-256 point in affine coordinates. Infinity
-// is encoded as (0, 0).
-typedef struct {
-  BN_ULONG X[P256_LIMBS];
-  BN_ULONG Y[P256_LIMBS];
-} P256_POINT_AFFINE;
-
-// ecp_nistz256_select_w5 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 16
-// and all zeros (the point at infinity) if |index| is 0. This is done in
-// constant time.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_select_w5_nohw(P256_POINT *val, const P256_POINT in_t[16],
-                                 int index);
-void ecp_nistz256_select_w5_avx2(P256_POINT *val, const P256_POINT in_t[16],
-                                 int index);
-#else
-void ecp_nistz256_select_w5(P256_POINT *val, const P256_POINT in_t[16],
-                            int index);
-#endif
-
-// ecp_nistz256_select_w7 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 64
-// and all zeros (the point at infinity) if |index| is 0. This is done in
-// constant time.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_select_w7_nohw(P256_POINT_AFFINE *val,
-                                 const P256_POINT_AFFINE in_t[64], int index);
-void ecp_nistz256_select_w7_avx2(P256_POINT_AFFINE *val,
-                                 const P256_POINT_AFFINE in_t[64], int index);
-#else
-void ecp_nistz256_select_w7(P256_POINT_AFFINE *val,
-                            const P256_POINT_AFFINE in_t[64], int index);
-#endif
-
-// ecp_nistz256_point_double sets |r| to |a| doubled.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_point_double_nohw(P256_POINT *r, const P256_POINT *a);
-void ecp_nistz256_point_double_adx(P256_POINT *r, const P256_POINT *a);
-#else
-void ecp_nistz256_point_double(P256_POINT *r, const P256_POINT *a);
-#endif
-
-// ecp_nistz256_point_add adds |a| to |b| and places the result in |r|.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_point_add_nohw(P256_POINT *r, const P256_POINT *a,
-                                 const P256_POINT *b);
-void ecp_nistz256_point_add_adx(P256_POINT *r, const P256_POINT *a,
-                                const P256_POINT *b);
-#else
-void ecp_nistz256_point_add(P256_POINT *r, const P256_POINT *a,
-                            const P256_POINT *b);
-#endif
-
-// ecp_nistz256_point_add_affine adds |a| to |b| and places the result in
-// |r|. |a| and |b| must not represent the same point unless they are both
-// infinity.
-#if defined(OPENSSL_X86_64)
-void ecp_nistz256_point_add_affine_adx(P256_POINT *r, const P256_POINT *a,
-                                       const P256_POINT_AFFINE *b);
-void ecp_nistz256_point_add_affine_nohw(P256_POINT *r, const P256_POINT *a,
-                                        const P256_POINT_AFFINE *b);
-#else
-void ecp_nistz256_point_add_affine(P256_POINT *r, const P256_POINT *a,
-                                   const P256_POINT_AFFINE *b);
-#endif
-
-#endif /* !defined(OPENSSL_NO_ASM) && \
-          (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) &&   \
-          !defined(OPENSSL_SMALL) */
-
-
-#if defined(__cplusplus)
-}  // extern C++
-#endif
-
-#endif  // OPENSSL_HEADER_CRYPTO_FIPSMODULE_EC_P256_NISTZ_H

data/third_party/boringssl-with-bazel/crypto/fipsmodule/rsa/blinding.cc.inc

@@ -1,147 +0,0 @@
-// 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/rsa.h>
-
-#include <string.h>
-
-#include <openssl/bn.h>
-#include <openssl/err.h>
-#include <openssl/mem.h>
-
-#include "../../internal.h"
-#include "internal.h"
-
-
-#define BN_BLINDING_COUNTER 32
-
-struct bn_blinding_st {
-  BIGNUM *A;   // The base blinding factor, Montgomery-encoded.
-  BIGNUM *Ai;  // The inverse of the blinding factor, Montgomery-encoded.
-  unsigned counter;
-};
-
-static int bn_blinding_create_param(BN_BLINDING *b, const BIGNUM *e,
-                                    const BN_MONT_CTX *mont, BN_CTX *ctx);
-
-BN_BLINDING *BN_BLINDING_new(void) {
-  BN_BLINDING *ret =
-      reinterpret_cast<BN_BLINDING *>(OPENSSL_zalloc(sizeof(BN_BLINDING)));
-  if (ret == NULL) {
-    return NULL;
-  }
-
-  ret->A = BN_new();
-  if (ret->A == NULL) {
-    goto err;
-  }
-
-  ret->Ai = BN_new();
-  if (ret->Ai == NULL) {
-    goto err;
-  }
-
-  // The blinding values need to be created before this blinding can be used.
-  ret->counter = BN_BLINDING_COUNTER - 1;
-
-  return ret;
-
-err:
-  BN_BLINDING_free(ret);
-  return NULL;
-}
-
-void BN_BLINDING_free(BN_BLINDING *r) {
-  if (r == nullptr) {
-    return;
-  }
-  BN_free(r->A);
-  BN_free(r->Ai);
-  OPENSSL_free(r);
-}
-
-void BN_BLINDING_invalidate(BN_BLINDING *b) {
-  b->counter = BN_BLINDING_COUNTER - 1;
-}
-
-static int bn_blinding_update(BN_BLINDING *b, const BIGNUM *e,
-                              const BN_MONT_CTX *mont, BN_CTX *ctx) {
-  if (++b->counter == BN_BLINDING_COUNTER) {
-    // re-create blinding parameters
-    if (!bn_blinding_create_param(b, e, mont, ctx)) {
-      goto err;
-    }
-    b->counter = 0;
-  } else {
-    if (!BN_mod_mul_montgomery(b->A, b->A, b->A, mont, ctx) ||
-        !BN_mod_mul_montgomery(b->Ai, b->Ai, b->Ai, mont, ctx)) {
-      goto err;
-    }
-  }
-
-  return 1;
-
-err:
-  // |A| and |Ai| may be in an inconsistent state so they both need to be
-  // replaced the next time this blinding is used. Note that this is only
-  // sufficient because support for |BN_BLINDING_NO_UPDATE| and
-  // |BN_BLINDING_NO_RECREATE| was previously dropped.
-  b->counter = BN_BLINDING_COUNTER - 1;
-
-  return 0;
-}
-
-int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, const BIGNUM *e,
-                        const BN_MONT_CTX *mont, BN_CTX *ctx) {
-  // |n| is not Montgomery-encoded and |b->A| is. |BN_mod_mul_montgomery|
-  // cancels one Montgomery factor, so the resulting value of |n| is unencoded.
-  if (!bn_blinding_update(b, e, mont, ctx) ||
-      !BN_mod_mul_montgomery(n, n, b->A, mont, ctx)) {
-    return 0;
-  }
-
-  return 1;
-}
-
-int BN_BLINDING_invert(BIGNUM *n, const BN_BLINDING *b, BN_MONT_CTX *mont,
-                       BN_CTX *ctx) {
-  // |n| is not Montgomery-encoded and |b->A| is. |BN_mod_mul_montgomery|
-  // cancels one Montgomery factor, so the resulting value of |n| is unencoded.
-  return BN_mod_mul_montgomery(n, n, b->Ai, mont, ctx);
-}
-
-static int bn_blinding_create_param(BN_BLINDING *b, const BIGNUM *e,
-                                    const BN_MONT_CTX *mont, BN_CTX *ctx) {
-  int no_inverse;
-  if (!BN_rand_range_ex(b->A, 1, &mont->N) ||
-      // Compute |b->A|^-1 in Montgomery form. Note |BN_from_montgomery| +
-      // |BN_mod_inverse_blinded| is equivalent to, but more efficient than,
-      // |BN_mod_inverse_blinded| + |BN_to_montgomery|.
-      //
-      // We do not retry if |b->A| has no inverse. Finding a non-invertible
-      // value of |b->A| is equivalent to factoring |mont->N|. There is
-      // negligible probability of stumbling on one at random.
-      !BN_from_montgomery(b->Ai, b->A, mont, ctx) ||
-      !BN_mod_inverse_blinded(b->Ai, &no_inverse, b->Ai, mont, ctx) ||
-      // TODO(davidben): |BN_mod_exp_mont| internally computes the result in
-      // Montgomery form. Save a pair of Montgomery reductions and a
-      // multiplication by returning that value directly.
-      !BN_mod_exp_mont(b->A, b->A, e, &mont->N, ctx, mont) ||
-      !BN_to_montgomery(b->A, b->A, mont, ctx)) {
-    OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR);
-    return 0;
-  }
-
-  return 1;
-}

data/third_party/boringssl-with-bazel/crypto/rand/getrandom_fillin.h

@@ -1,64 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef OPENSSL_HEADER_CRYPTO_RAND_GETRANDOM_FILLIN_H
-#define OPENSSL_HEADER_CRYPTO_RAND_GETRANDOM_FILLIN_H
-
-#include <openssl/base.h>
-
-
-#if defined(OPENSSL_LINUX)
-
-#include <sys/syscall.h>
-
-#if defined(OPENSSL_X86_64)
-#define EXPECTED_NR_getrandom 318
-#elif defined(OPENSSL_X86)
-#define EXPECTED_NR_getrandom 355
-#elif defined(OPENSSL_AARCH64)
-#define EXPECTED_NR_getrandom 278
-#elif defined(OPENSSL_ARM)
-#define EXPECTED_NR_getrandom 384
-#elif defined(OPENSSL_RISCV64)
-#define EXPECTED_NR_getrandom 278
-#endif
-
-#if defined(EXPECTED_NR_getrandom)
-#define USE_NR_getrandom
-
-#if defined(__NR_getrandom)
-
-#if __NR_getrandom != EXPECTED_NR_getrandom
-#error "system call number for getrandom is not the expected value"
-#endif
-
-#else  // __NR_getrandom
-
-#define __NR_getrandom EXPECTED_NR_getrandom
-
-#endif  // __NR_getrandom
-
-#endif  // EXPECTED_NR_getrandom
-
-#if !defined(GRND_NONBLOCK)
-#define GRND_NONBLOCK 1
-#endif
-#if !defined(GRND_RANDOM)
-#define GRND_RANDOM 2
-#endif
-
-#endif  // OPENSSL_LINUX
-
-
-#endif  // OPENSSL_HEADER_CRYPTO_RAND_GETRANDOM_FILLIN_H

data/third_party/boringssl-with-bazel/crypto/rand/passive.cc

@@ -1,178 +0,0 @@
-// Copyright 2020 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/ctrdrbg.h>
-
-#include "../bcm_support.h"
-#include "../fipsmodule/bcm_interface.h"
-#include "../internal.h"
-
-#if defined(BORINGSSL_FIPS)
-
-#include <atomic>
-
-// passive_get_seed_entropy writes |out_entropy_len| bytes of entropy, suitable
-// for seeding a DRBG, to |out_entropy|. It sets |*out_used_cpu| to one if the
-// entropy came directly from the CPU and zero if it came from the OS. It
-// actively obtains entropy from the CPU/OS
-static void passive_get_seed_entropy(uint8_t *out_entropy,
-                                     size_t out_entropy_len,
-                                     int *out_want_additional_input) {
-  *out_want_additional_input = 0;
-  if (bcm_success(BCM_rand_bytes_hwrng(out_entropy, out_entropy_len))) {
-    *out_want_additional_input = 1;
-  } else {
-    CRYPTO_sysrand_for_seed(out_entropy, out_entropy_len);
-  }
-}
-
-#define ENTROPY_READ_LEN \
-  (/* last_block size */ 16 + CTR_DRBG_ENTROPY_LEN * BORINGSSL_FIPS_OVERREAD)
-
-#if defined(OPENSSL_ANDROID)
-
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-// socket_history_t enumerates whether the entropy daemon should be contacted
-// for a given entropy request. Values other than socket_not_yet_attempted are
-// sticky so if the first attempt to read from the daemon fails it's assumed
-// that the daemon is not present and no more attempts will be made. If the
-// first attempt is successful then attempts will be made forever more.
-enum class socket_history_t {
-  // initial value, no connections to the entropy daemon have been made yet.
-  socket_not_yet_attempted = 0,
-  // reading from the entropy daemon was successful
-  socket_success,
-  // reading from the entropy daemon failed.
-  socket_failed,
-};
-
-static std::atomic<socket_history_t> g_socket_history{
-    socket_history_t::socket_not_yet_attempted};
-
-// DAEMON_RESPONSE_LEN is the number of bytes that the entropy daemon replies
-// with.
-#define DAEMON_RESPONSE_LEN 496
-
-static_assert(ENTROPY_READ_LEN == DAEMON_RESPONSE_LEN,
-              "entropy daemon response length mismatch");
-
-static int get_seed_from_daemon(uint8_t *out_entropy, size_t out_entropy_len) {
-  // |RAND_need_entropy| should never call this function for more than
-  // |DAEMON_RESPONSE_LEN| bytes.
-  if (out_entropy_len > DAEMON_RESPONSE_LEN) {
-    abort();
-  }
-
-  const socket_history_t socket_history =
-      g_socket_history.load(std::memory_order_acquire);
-  if (socket_history == socket_history_t::socket_failed) {
-    return 0;
-  }
-
-  int ret = 0;
-  static const char kSocketPath[] = "/dev/socket/prng_seeder";
-  struct sockaddr_un sun;
-  uint8_t buffer[DAEMON_RESPONSE_LEN];
-  size_t done = 0;
-  const int sock = socket(AF_UNIX, SOCK_STREAM, 0);
-  if (sock < 0) {
-    goto out;
-  }
-
-  memset(&sun, 0, sizeof(sun));
-  sun.sun_family = AF_UNIX;
-  static_assert(sizeof(kSocketPath) <= UNIX_PATH_MAX, "kSocketPath too long");
-  OPENSSL_memcpy(sun.sun_path, kSocketPath, sizeof(kSocketPath));
-
-  if (connect(sock, (struct sockaddr *)&sun, sizeof(sun))) {
-    goto out;
-  }
-
-  while (done < sizeof(buffer)) {
-    ssize_t n;
-    do {
-      n = read(sock, buffer + done, sizeof(buffer) - done);
-    } while (n == -1 && errno == EINTR);
-
-    if (n < 1) {
-      goto out;
-    }
-    done += n;
-  }
-
-  if (done != DAEMON_RESPONSE_LEN) {
-    // The daemon should always write |DAEMON_RESPONSE_LEN| bytes on every
-    // connection.
-    goto out;
-  }
-
-  assert(out_entropy_len <= DAEMON_RESPONSE_LEN);
-  OPENSSL_memcpy(out_entropy, buffer, out_entropy_len);
-  ret = 1;
-
-out:
-  if (socket_history == socket_history_t::socket_not_yet_attempted) {
-    socket_history_t expected = socket_history_t::socket_not_yet_attempted;
-    // If another thread has already updated |g_socket_history| then we defer
-    // to their value.
-    g_socket_history.compare_exchange_strong(
-        expected,
-        (ret == 0) ? socket_history_t::socket_failed
-                   : socket_history_t::socket_success,
-        std::memory_order_release, std::memory_order_relaxed);
-  }
-
-  close(sock);
-  return ret;
-}
-
-#else
-
-static int get_seed_from_daemon(uint8_t *out_entropy, size_t out_entropy_len) {
-  return 0;
-}
-
-#endif  // OPENSSL_ANDROID
-
-// RAND_need_entropy is called by the FIPS module when it has blocked because of
-// a lack of entropy. This signal is used as an indication to feed it more.
-void RAND_need_entropy(size_t bytes_needed) {
-  uint8_t buf[ENTROPY_READ_LEN];
-  size_t todo = sizeof(buf);
-  if (todo > bytes_needed) {
-    todo = bytes_needed;
-  }
-
-  int want_additional_input;
-  if (get_seed_from_daemon(buf, todo)) {
-    want_additional_input = 1;
-  } else {
-    passive_get_seed_entropy(buf, todo, &want_additional_input);
-  }
-
-  if (boringssl_fips_break_test("CRNG")) {
-    // This breaks the "continuous random number generator test" defined in FIPS
-    // 140-2, section 4.9.2, and implemented in |rand_get_seed|.
-    OPENSSL_memset(buf, 0, todo);
-  }
-
-  BCM_rand_load_entropy(buf, todo, want_additional_input);
-}
-
-#endif  // FIPS

data/third_party/boringssl-with-bazel/crypto/x509/ext_dat.h

@@ -1,92 +0,0 @@
-// 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.
-
-// This file contains a table of "standard" extensions
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-extern const X509V3_EXT_METHOD v3_bcons, v3_nscert, v3_key_usage, v3_ext_ku;
-extern const X509V3_EXT_METHOD v3_info, v3_sinfo;
-extern const X509V3_EXT_METHOD v3_ns_ia5_list[], v3_alt[], v3_skey_id,
-    v3_akey_id;
-extern const X509V3_EXT_METHOD v3_crl_num, v3_crl_reason, v3_crl_invdate;
-extern const X509V3_EXT_METHOD v3_delta_crl, v3_cpols, v3_crld, v3_freshest_crl;
-extern const X509V3_EXT_METHOD v3_ocsp_nonce, v3_ocsp_accresp, v3_ocsp_acutoff;
-extern const X509V3_EXT_METHOD v3_ocsp_crlid, v3_ocsp_nocheck,
-    v3_ocsp_serviceloc;
-extern const X509V3_EXT_METHOD v3_crl_hold;
-extern const X509V3_EXT_METHOD v3_policy_mappings, v3_policy_constraints;
-extern const X509V3_EXT_METHOD v3_name_constraints, v3_inhibit_anyp, v3_idp;
-extern const X509V3_EXT_METHOD v3_addr, v3_asid;
-
-// This table will be searched using OBJ_bsearch so it *must* kept in order
-// of the ext_nid values.
-
-// TODO(fork): OCSP support
-#define OPENSSL_NO_OCSP
-
-static const X509V3_EXT_METHOD *const standard_exts[] = {
-    &v3_nscert,
-    &v3_ns_ia5_list[0],
-    &v3_ns_ia5_list[1],
-    &v3_ns_ia5_list[2],
-    &v3_ns_ia5_list[3],
-    &v3_ns_ia5_list[4],
-    &v3_ns_ia5_list[5],
-    &v3_ns_ia5_list[6],
-    &v3_skey_id,
-    &v3_key_usage,
-    &v3_alt[0],
-    &v3_alt[1],
-    &v3_bcons,
-    &v3_crl_num,
-    &v3_cpols,
-    &v3_akey_id,
-    &v3_crld,
-    &v3_ext_ku,
-    &v3_delta_crl,
-    &v3_crl_reason,
-    &v3_crl_invdate,
-    &v3_info,
-#ifndef OPENSSL_NO_OCSP
-    &v3_ocsp_nonce,
-    &v3_ocsp_crlid,
-    &v3_ocsp_accresp,
-    &v3_ocsp_acutoff,
-    &v3_ocsp_serviceloc,
-#endif
-    &v3_ocsp_nocheck,
-    &v3_sinfo,
-    &v3_policy_constraints,
-#ifndef OPENSSL_NO_OCSP
-    &v3_crl_hold,
-#endif
-    &v3_name_constraints,
-    &v3_policy_mappings,
-    &v3_inhibit_anyp,
-    &v3_idp,
-    &v3_alt[2],
-    &v3_freshest_crl,
-};
-
-// Number of standard extensions
-
-#define STANDARD_EXTENSION_COUNT \
-  (sizeof(standard_exts) / sizeof(X509V3_EXT_METHOD *))
-
-#if defined(__cplusplus)
-}  // extern C
-#endif