grpc 1.69.0 → 1.70.1

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -19,20 +19,20 @@
 #include "../bcm_support.h"
 
 #if defined(OPENSSL_FORK_DETECTION_MADVISE)
-#include <unistd.h>
-#include <stdlib.h>
 #include <assert.h>
+#include <stdlib.h>
 #include <sys/mman.h>
+#include <unistd.h>
 #if defined(MADV_WIPEONFORK)
 static_assert(MADV_WIPEONFORK == 18, "MADV_WIPEONFORK is not 18");
 #else
 #define MADV_WIPEONFORK 18
 #endif
 #elif defined(OPENSSL_FORK_DETECTION_PTHREAD_ATFORK)
-#include <unistd.h>
-#include <stdlib.h>
 #include <pthread.h>
-#endif // OPENSSL_FORK_DETECTION_MADVISE
+#include <stdlib.h>
+#include <unistd.h>
+#endif  // OPENSSL_FORK_DETECTION_PTHREAD_ATFORK
 
 #include "../internal.h"
 
@@ -41,7 +41,7 @@ static int g_force_madv_wipeonfork;
 static int g_force_madv_wipeonfork_enabled;
 static CRYPTO_once_t g_fork_detect_once = CRYPTO_ONCE_INIT;
 static CRYPTO_MUTEX g_fork_detect_lock = CRYPTO_MUTEX_INIT;
-static CRYPTO_atomic_u32 * g_fork_detect_addr;
+static CRYPTO_atomic_u32 *g_fork_detect_addr;
 static uint64_t g_fork_generation;
 
 static void init_fork_detect(void) {
@@ -71,10 +71,10 @@ static void init_fork_detect(void) {
     return;
   }
 
-  CRYPTO_atomic_store_u32(addr, 1);
-  g_fork_detect_addr = addr;
+  CRYPTO_atomic_u32 *const atomic = reinterpret_cast<CRYPTO_atomic_u32 *>(addr);
+  CRYPTO_atomic_store_u32(atomic, 1);
+  g_fork_detect_addr = atomic;
   g_fork_generation = 1;
-
 }
 
 uint64_t CRYPTO_get_fork_generation(void) {
@@ -95,8 +95,7 @@ uint64_t CRYPTO_get_fork_generation(void) {
   if (flag_ptr == NULL) {
     // Our kernel is too old to support |MADV_WIPEONFORK| or
     // |g_force_madv_wipeonfork| is set.
-    if (g_force_madv_wipeonfork &&
-        g_force_madv_wipeonfork_enabled) {
+    if (g_force_madv_wipeonfork && g_force_madv_wipeonfork_enabled) {
       // A constant generation number to simulate support, even if the kernel
       // doesn't support it.
       return 42;

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -22,7 +22,7 @@
 
 // g_buffering_enabled is one if fork-unsafe buffering has been enabled and zero
 // otherwise.
-static CRYPTO_atomic_u32 g_buffering_enabled = 0;
+static CRYPTO_atomic_u32 g_buffering_enabled;
 
 #if !defined(OPENSSL_WINDOWS)
 void RAND_enable_fork_unsafe_buffering(int fd) {

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2023, Google Inc.
+/* Copyright 2023 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/rand_extra/getrandom_fillin.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2023, Google Inc.
+/* Copyright 2023 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -14,12 +14,14 @@
 
 #include <openssl/ctrdrbg.h>
 
-#include "../fipsmodule/bcm_interface.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
@@ -41,7 +43,6 @@ static void passive_get_seed_entropy(uint8_t *out_entropy,
 #if defined(OPENSSL_ANDROID)
 
 #include <errno.h>
-#include <stdatomic.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
@@ -52,7 +53,7 @@ static void passive_get_seed_entropy(uint8_t *out_entropy,
 // 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 socket_history_t {
+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
@@ -61,8 +62,8 @@ enum socket_history_t {
   socket_failed,
 };
 
-static _Atomic enum socket_history_t g_socket_history =
-    socket_not_yet_attempted;
+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.
@@ -78,31 +79,31 @@ static int get_seed_from_daemon(uint8_t *out_entropy, size_t out_entropy_len) {
     abort();
   }
 
-  const enum socket_history_t socket_history = atomic_load(&g_socket_history);
-  if (socket_history == socket_failed) {
+  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;
   }
 
-  struct sockaddr_un sun;
   memset(&sun, 0, sizeof(sun));
   sun.sun_family = AF_UNIX;
-  static const char kSocketPath[] = "/dev/socket/prng_seeder";
-  static_assert(sizeof(kSocketPath) <= UNIX_PATH_MAX,
-                      "kSocketPath too long");
+  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;
   }
 
-  uint8_t buffer[DAEMON_RESPONSE_LEN];
-  size_t done = 0;
   while (done < sizeof(buffer)) {
     ssize_t n;
     do {
@@ -126,12 +127,15 @@ static int get_seed_from_daemon(uint8_t *out_entropy, size_t out_entropy_len) {
   ret = 1;
 
 out:
-  if (socket_history == socket_not_yet_attempted) {
-    enum socket_history_t expected = socket_history;
+  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.
-    atomic_compare_exchange_strong(&g_socket_history, &expected,
-                                   (ret == 0) ? socket_failed : socket_success);
+    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);

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/rand_extra/sysrand_internal.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2024, Google Inc.
+/* Copyright 2024 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2023, Google Inc.
+/* Copyright 2023 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -59,17 +59,19 @@
 #endif
 #endif  // OPENSSL_LINUX
 
-#include <openssl/thread.h>
 #include <openssl/mem.h>
+#include <openssl/thread.h>
 
-#include "getrandom_fillin.h"
 #include "../internal.h"
+#include "getrandom_fillin.h"
 
 
 #if defined(USE_NR_getrandom)
 
 #if defined(OPENSSL_MSAN)
+extern "C" {
 void __msan_unpoison(void *, size_t);
+}
 #endif
 
 static ssize_t boringssl_getrandom(void *buf, size_t buf_len, unsigned flags) {
@@ -254,7 +256,7 @@ static int fill_with_entropy(uint8_t *out, size_t len, int block, int seed) {
   }
 #endif
 
-#if defined (USE_NR_getrandom)
+#if defined(USE_NR_getrandom)
   if (seed) {
     getrandom_flags |= extra_getrandom_flags_for_seed;
   }
@@ -294,9 +296,7 @@ static int fill_with_entropy(uint8_t *out, size_t len, int block, int seed) {
   return 1;
 }
 
-void CRYPTO_init_sysrand(void) {
-  CRYPTO_once(&rand_once, init_once);
-}
+void CRYPTO_init_sysrand(void) { CRYPTO_once(&rand_once, init_once); }
 
 // CRYPTO_sysrand puts |requested| random bytes into |out|.
 void CRYPTO_sysrand(uint8_t *out, size_t requested) {

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, Google Inc.
+/* Copyright 2015 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

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

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

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

@@ -58,12 +58,12 @@
 
 #include <limits.h>
 
-#include <openssl/err.h>
-#include <openssl/rsa.h>
 #include <openssl/bn.h>
-#include <openssl/rand.h>
-#include <openssl/mem.h>
+#include <openssl/err.h>
 #include <openssl/evp.h>
+#include <openssl/mem.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
 
 #include "../fipsmodule/bn/internal.h"
 #include "../fipsmodule/rsa/internal.h"
@@ -128,7 +128,7 @@ int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len,
     goto out;
   }
 
-  dbmask = OPENSSL_malloc(emlen - mdlen);
+  dbmask = reinterpret_cast<uint8_t *>(OPENSSL_malloc(emlen - mdlen));
   if (dbmask == NULL) {
     goto out;
   }
@@ -161,92 +161,95 @@ int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
                                       const EVP_MD *mgf1md) {
   uint8_t *db = NULL;
 
-  if (md == NULL) {
-    md = EVP_sha1();
-  }
-  if (mgf1md == NULL) {
-    mgf1md = md;
-  }
+  {
+    if (md == NULL) {
+      md = EVP_sha1();
+    }
+    if (mgf1md == NULL) {
+      mgf1md = md;
+    }
 
-  size_t mdlen = EVP_MD_size(md);
+    size_t mdlen = EVP_MD_size(md);
 
-  // The encoded message is one byte smaller than the modulus to ensure that it
-  // doesn't end up greater than the modulus. Thus there's an extra "+1" here
-  // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
-  if (from_len < 1 + 2 * mdlen + 1) {
-    // 'from_len' is the length of the modulus, i.e. does not depend on the
-    // particular ciphertext.
-    goto decoding_err;
-  }
+    // The encoded message is one byte smaller than the modulus to ensure that
+    // it doesn't end up greater than the modulus. Thus there's an extra "+1"
+    // here compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
+    if (from_len < 1 + 2 * mdlen + 1) {
+      // 'from_len' is the length of the modulus, i.e. does not depend on the
+      // particular ciphertext.
+      goto decoding_err;
+    }
 
-  size_t dblen = from_len - mdlen - 1;
-  db = OPENSSL_malloc(dblen);
-  if (db == NULL) {
-    goto err;
-  }
+    size_t dblen = from_len - mdlen - 1;
+    db = reinterpret_cast<uint8_t *>(OPENSSL_malloc(dblen));
+    if (db == NULL) {
+      goto err;
+    }
 
-  const uint8_t *maskedseed = from + 1;
-  const uint8_t *maskeddb = from + 1 + mdlen;
+    const uint8_t *maskedseed = from + 1;
+    const uint8_t *maskeddb = from + 1 + mdlen;
 
-  uint8_t seed[EVP_MAX_MD_SIZE];
-  if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
-    goto err;
-  }
-  for (size_t i = 0; i < mdlen; i++) {
-    seed[i] ^= maskedseed[i];
-  }
+    uint8_t seed[EVP_MAX_MD_SIZE];
+    if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
+      goto err;
+    }
+    for (size_t i = 0; i < mdlen; i++) {
+      seed[i] ^= maskedseed[i];
+    }
 
-  if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
-    goto err;
-  }
-  for (size_t i = 0; i < dblen; i++) {
-    db[i] ^= maskeddb[i];
-  }
+    if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
+      goto err;
+    }
+    for (size_t i = 0; i < dblen; i++) {
+      db[i] ^= maskeddb[i];
+    }
 
-  uint8_t phash[EVP_MAX_MD_SIZE];
-  if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
-    goto err;
-  }
+    uint8_t phash[EVP_MAX_MD_SIZE];
+    if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
+      goto err;
+    }
 
-  crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
-  bad |= ~constant_time_is_zero_w(from[0]);
+    crypto_word_t bad =
+        ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
+    bad |= ~constant_time_is_zero_w(from[0]);
+
+    crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
+    size_t one_index = 0;
+    for (size_t i = mdlen; i < dblen; i++) {
+      crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
+      crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
+      one_index =
+          constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
+      looking_for_one_byte =
+          constant_time_select_w(equals1, 0, looking_for_one_byte);
+      bad |= looking_for_one_byte & ~equals0;
+    }
 
-  crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
-  size_t one_index = 0;
-  for (size_t i = mdlen; i < dblen; i++) {
-    crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
-    crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
-    one_index =
-        constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
-    looking_for_one_byte =
-        constant_time_select_w(equals1, 0, looking_for_one_byte);
-    bad |= looking_for_one_byte & ~equals0;
-  }
+    bad |= looking_for_one_byte;
 
-  bad |= looking_for_one_byte;
+    // Whether the overall padding was valid or not in OAEP is public.
+    if (constant_time_declassify_w(bad)) {
+      goto decoding_err;
+    }
 
-  // Whether the overall padding was valid or not in OAEP is public.
-  if (constant_time_declassify_w(bad)) {
-    goto decoding_err;
-  }
+    // Once the padding is known to be valid, the output length is also public.
+    static_assert(sizeof(size_t) <= sizeof(crypto_word_t),
+                  "size_t does not fit in crypto_word_t");
+    one_index = constant_time_declassify_w(one_index);
 
-  // Once the padding is known to be valid, the output length is also public.
-  static_assert(sizeof(size_t) <= sizeof(crypto_word_t),
-                "size_t does not fit in crypto_word_t");
-  one_index = constant_time_declassify_w(one_index);
+    one_index++;
+    size_t mlen = dblen - one_index;
+    if (max_out < mlen) {
+      OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
+      goto err;
+    }
 
-  one_index++;
-  size_t mlen = dblen - one_index;
-  if (max_out < mlen) {
-    OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
-    goto err;
+    OPENSSL_memcpy(out, db + one_index, mlen);
+    *out_len = mlen;
+    OPENSSL_free(db);
+    return 1;
   }
 
-  OPENSSL_memcpy(out, db + one_index, mlen);
-  *out_len = mlen;
-  OPENSSL_free(db);
-  return 1;
-
 decoding_err:
   // To avoid chosen ciphertext attacks, the error message should not reveal
   // which kind of decoding error happened.
@@ -406,7 +409,7 @@ int RSA_encrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out,
   BN_CTX_start(ctx);
   f = BN_CTX_get(ctx);
   result = BN_CTX_get(ctx);
-  buf = OPENSSL_malloc(rsa_size);
+  buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
   if (!f || !result || !buf) {
     goto err;
   }
@@ -483,7 +486,7 @@ static int rsa_default_decrypt(RSA *rsa, size_t *out_len, uint8_t *out,
     buf = out;
   } else {
     // Allocate a temporary buffer to hold the padded plaintext.
-    buf = OPENSSL_malloc(rsa_size);
+    buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
     if (buf == NULL) {
       goto err;
     }

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

@@ -0,0 +1,17 @@
+/* Copyright 2024 The BoringSSL Authors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * 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. */
+
+#include <openssl/rsa.h>
+
+void RSA_blinding_off(RSA *rsa) {}

data/third_party/boringssl-with-bazel/src/crypto/sha/sha1.cc

@@ -0,0 +1,52 @@
+/* Copyright 2024 The BoringSSL Authors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * 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. */
+
+#include <openssl/sha.h>
+
+#include <openssl/mem.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+int SHA1_Init(SHA_CTX *sha) {
+  BCM_sha1_init(sha);
+  return 1;
+}
+
+int SHA1_Update(SHA_CTX *sha, const void *data, size_t len) {
+  BCM_sha1_update(sha, data, len);
+  return 1;
+}
+
+int SHA1_Final(uint8_t out[SHA_DIGEST_LENGTH], SHA_CTX *sha) {
+  BCM_sha1_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA1(const uint8_t *data, size_t len, uint8_t out[SHA_DIGEST_LENGTH]) {
+  SHA_CTX ctx;
+  BCM_sha1_init(&ctx);
+  BCM_sha1_update(&ctx, data, len);
+  BCM_sha1_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+void SHA1_Transform(SHA_CTX *sha, const uint8_t block[SHA_CBLOCK]) {
+  BCM_sha1_transform(sha, block);
+}
+
+void CRYPTO_fips_186_2_prf(uint8_t *out, size_t out_len,
+                           const uint8_t xkey[SHA_DIGEST_LENGTH]) {
+  BCM_fips_186_2_prf(out, out_len, xkey);
+}

data/third_party/boringssl-with-bazel/src/crypto/sha/sha256.cc

@@ -0,0 +1,87 @@
+/* Copyright 2024 The BoringSSL Authors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * 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. */
+
+#include <openssl/sha.h>
+
+#include <openssl/mem.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+
+int SHA224_Init(SHA256_CTX *sha) {
+  BCM_sha224_init(sha);
+  return 1;
+}
+
+int SHA224_Update(SHA256_CTX *sha, const void *data, size_t len) {
+  BCM_sha224_update(sha, data, len);
+  return 1;
+}
+
+int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH], SHA256_CTX *sha) {
+  BCM_sha224_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA224(const uint8_t *data, size_t len,
+                uint8_t out[SHA224_DIGEST_LENGTH]) {
+  SHA256_CTX ctx;
+  BCM_sha224_init(&ctx);
+  BCM_sha224_update(&ctx, data, len);
+  BCM_sha224_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+int SHA256_Init(SHA256_CTX *sha) {
+  BCM_sha256_init(sha);
+  return 1;
+}
+
+int SHA256_Update(SHA256_CTX *sha, const void *data, size_t len) {
+  BCM_sha256_update(sha, data, len);
+  return 1;
+}
+
+int SHA256_Final(uint8_t out[SHA256_DIGEST_LENGTH], SHA256_CTX *sha) {
+  // TODO(bbe): This overflow check one of the few places a low-level hash
+  // 'final' function can fail. SHA-512 does not have a corresponding check.
+  // The BCM function is infallible and will abort if this is done incorrectly.
+  // we should verify nothing crashes with this removed and eliminate the 0
+  // return.
+  if (sha->md_len > SHA256_DIGEST_LENGTH) {
+    return 0;
+  }
+  BCM_sha256_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA256(const uint8_t *data, size_t len,
+                uint8_t out[SHA256_DIGEST_LENGTH]) {
+  SHA256_CTX ctx;
+  BCM_sha256_init(&ctx);
+  BCM_sha256_update(&ctx, data, len);
+  BCM_sha256_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+void SHA256_Transform(SHA256_CTX *sha, const uint8_t block[SHA256_CBLOCK]) {
+  BCM_sha256_transform(sha, block);
+}
+
+void SHA256_TransformBlocks(uint32_t state[8], const uint8_t *data,
+                            size_t num_blocks) {
+  BCM_sha256_transform_blocks(state, data, num_blocks);
+}