grpc 1.84.1 → 1.85.0

data/third_party/boringssl-with-bazel/crypto/fipsmodule/slhdsa/wots.cc.inc

@@ -25,147 +25,148 @@
 #include "./wots.h"
 
 
+using namespace bssl;
+
 // Implements Algorithm 5: chain function, page 18
-static void chain(uint8_t output[BCM_SLHDSA_SHA2_128S_N],
-                  const uint8_t input[BCM_SLHDSA_SHA2_128S_N], uint32_t start,
-                  uint32_t steps, const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                  uint8_t addr[32]) {
-  assert(start < SLHDSA_SHA2_128S_WOTS_W);
-  assert(steps < SLHDSA_SHA2_128S_WOTS_W);
-
-  OPENSSL_memcpy(output, input, BCM_SLHDSA_SHA2_128S_N);
-
-  for (size_t i = start; i < (start + steps) && i < SLHDSA_SHA2_128S_WOTS_W;
-       ++i) {
-    slhdsa_set_hash_addr(addr, i);
-    slhdsa_thash_f(output, output, pub_seed, addr);
+static void chain(const slh_dsa_config *config, uint8_t *output,
+                  const uint8_t *input, uint32_t start, uint32_t steps,
+                  const uint8_t *pub_seed, uint8_t addr[32]) {
+  assert(start < config->wots_w);
+  assert(steps < config->wots_w);
+
+  OPENSSL_memcpy(output, input, config->n);
+
+  for (uint32_t i = start; i < (start + steps) && i < config->wots_w; ++i) {
+    slhdsa_set_hash_addr(config, addr, i);
+    slhdsa_thash_f(config, output, output, pub_seed, addr);
   }
 }
 
-static void slhdsa_wots_do_chain(uint8_t out[BCM_SLHDSA_SHA2_128S_N],
+static void slhdsa_wots_do_chain(const slh_dsa_config *config, uint8_t *out,
                                  uint8_t sk_addr[32], uint8_t addr[32],
-                                 uint8_t value,
-                                 const uint8_t sk_seed[BCM_SLHDSA_SHA2_128S_N],
-                                 const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
+                                 uint8_t value, const uint8_t *sk_seed,
+                                 const uint8_t *pub_seed,
                                  uint32_t chain_index) {
-  uint8_t tmp_sk[BCM_SLHDSA_SHA2_128S_N];
-  slhdsa_set_chain_addr(sk_addr, chain_index);
-  slhdsa_thash_prf(tmp_sk, pub_seed, sk_seed, sk_addr);
-  slhdsa_set_chain_addr(addr, chain_index);
-  chain(out, tmp_sk, 0, value, pub_seed, addr);
+  uint8_t tmp_sk[SLHDSA_MAX_N];
+  slhdsa_set_chain_addr(config, sk_addr, chain_index);
+  slhdsa_thash_prf(config, tmp_sk, pub_seed, sk_seed, sk_addr);
+  slhdsa_set_chain_addr(config, addr, chain_index);
+  chain(config, out, tmp_sk, 0, value, pub_seed, addr);
 }
 
 // Implements Algorithm 6: wots_pkGen function, page 18
-void slhdsa_wots_pk_gen(uint8_t pk[BCM_SLHDSA_SHA2_128S_N],
-                        const uint8_t sk_seed[BCM_SLHDSA_SHA2_128S_N],
-                        const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                        uint8_t addr[32]) {
+void bssl::slhdsa_wots_pk_gen(const slh_dsa_config *config, uint8_t *pk,
+                              const uint8_t *sk_seed, const uint8_t *pub_seed,
+                              uint8_t addr[32]) {
   uint8_t wots_pk_addr[32], sk_addr[32];
   OPENSSL_memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
   OPENSSL_memcpy(sk_addr, addr, sizeof(sk_addr));
-  slhdsa_set_type(sk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPRF);
-  slhdsa_copy_keypair_addr(sk_addr, addr);
-
-  uint8_t tmp[SLHDSA_SHA2_128S_WOTS_BYTES];
-  for (size_t i = 0; i < SLHDSA_SHA2_128S_WOTS_LEN; ++i) {
-    slhdsa_wots_do_chain(tmp + i * BCM_SLHDSA_SHA2_128S_N, sk_addr, addr,
-                         SLHDSA_SHA2_128S_WOTS_W - 1, sk_seed, pub_seed, i);
+  slhdsa_set_type(config, sk_addr, SLHDSA_ADDR_TYPE_WOTSPRF);
+  slhdsa_copy_keypair_addr(config, sk_addr, addr);
+
+  uint8_t tmp[SLHDSA_MAX_WOTS_BYTES];
+  const uint32_t n = config->n;
+  const uint32_t wots_len = slhdsa_wots_len(config);
+  const uint32_t max_chain = config->wots_w - 1;
+  for (uint32_t i = 0; i < wots_len; ++i) {
+    slhdsa_wots_do_chain(config, tmp + i * n, sk_addr, addr, max_chain, sk_seed,
+                         pub_seed, i);
   }
 
   // Compress pk
-  slhdsa_set_type(wots_pk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPK);
-  slhdsa_copy_keypair_addr(wots_pk_addr, addr);
-  slhdsa_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
+  slhdsa_set_type(config, wots_pk_addr, SLHDSA_ADDR_TYPE_WOTSPK);
+  slhdsa_copy_keypair_addr(config, wots_pk_addr, addr);
+  slhdsa_thash_tl(config, pk, tmp, pub_seed, wots_pk_addr);
 }
 
 // Implements Algorithm 7: wots_sign function, page 20
-void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                      const uint8_t msg[BCM_SLHDSA_SHA2_128S_N],
-                      const uint8_t sk_seed[BCM_SLHDSA_SHA2_128S_N],
-                      const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                      uint8_t addr[32]) {
-  // Compute checksum
-  static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == BCM_SLHDSA_SHA2_128S_N * 2, "");
+void bssl::slhdsa_wots_sign(const slh_dsa_config *config, uint8_t *sig,
+                            const uint8_t *msg, const uint8_t *sk_seed,
+                            const uint8_t *pub_seed, uint8_t addr[32]) {
+  BSSL_CHECK(config->wots_w == 16);
+  const size_t n = config->n;
+  const uint32_t max_chain = config->wots_w - 1;
+
   uint16_t csum = 0;
-  for (size_t i = 0; i < BCM_SLHDSA_SHA2_128S_N; ++i) {
-    csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] >> 4);
-    csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] & 15);
+  for (size_t i = 0; i < n; ++i) {
+    csum += max_chain - (msg[i] >> 4);
+    csum += max_chain - (msg[i] & 15);
   }
 
   // Compute chains
   uint8_t sk_addr[32];
   OPENSSL_memcpy(sk_addr, addr, sizeof(sk_addr));
-  slhdsa_set_type(sk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPRF);
-  slhdsa_copy_keypair_addr(sk_addr, addr);
+  slhdsa_set_type(config, sk_addr, SLHDSA_ADDR_TYPE_WOTSPRF);
+  slhdsa_copy_keypair_addr(config, sk_addr, addr);
 
   uint32_t chain_index = 0;
-  for (size_t i = 0; i < BCM_SLHDSA_SHA2_128S_N; ++i) {
-    slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] >> 4, sk_seed, pub_seed,
-                         chain_index++);
-    sig += BCM_SLHDSA_SHA2_128S_N;
-
-    slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] & 15, sk_seed, pub_seed,
-                         chain_index++);
-    sig += BCM_SLHDSA_SHA2_128S_N;
+  for (size_t i = 0; i < n; ++i) {
+    slhdsa_wots_do_chain(config, sig, sk_addr, addr, msg[i] >> 4, sk_seed,
+                         pub_seed, chain_index++);
+    sig += n;
+
+    slhdsa_wots_do_chain(config, sig, sk_addr, addr, msg[i] & 15, sk_seed,
+                         pub_seed, chain_index++);
+    sig += n;
   }
 
-  // Include the SLHDSA_SHA2_128S_WOTS_LEN2 checksum values.
-  slhdsa_wots_do_chain(sig, sk_addr, addr, (csum >> 8) & 15, sk_seed, pub_seed,
-                       chain_index++);
-  sig += BCM_SLHDSA_SHA2_128S_N;
-  slhdsa_wots_do_chain(sig, sk_addr, addr, (csum >> 4) & 15, sk_seed, pub_seed,
-                       chain_index++);
-  sig += BCM_SLHDSA_SHA2_128S_N;
-  slhdsa_wots_do_chain(sig, sk_addr, addr, csum & 15, sk_seed, pub_seed,
+  // Include the WOTS checksum values (len2 = 3 for the parameter sets we
+  // support).
+  slhdsa_wots_do_chain(config, sig, sk_addr, addr, (csum >> 8) & 15, sk_seed,
+                       pub_seed, chain_index++);
+  sig += n;
+  slhdsa_wots_do_chain(config, sig, sk_addr, addr, (csum >> 4) & 15, sk_seed,
+                       pub_seed, chain_index++);
+  sig += n;
+  slhdsa_wots_do_chain(config, sig, sk_addr, addr, csum & 15, sk_seed, pub_seed,
                        chain_index++);
 }
 
-static void slhdsa_wots_pk_from_sig_do_chain(
-    uint8_t out[SLHDSA_SHA2_128S_WOTS_BYTES], uint8_t addr[32],
-    const uint8_t in[SLHDSA_SHA2_128S_WOTS_BYTES], uint8_t value,
-    const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N], uint32_t chain_index) {
-  slhdsa_set_chain_addr(addr, chain_index);
-  chain(out + chain_index * BCM_SLHDSA_SHA2_128S_N,
-        in + chain_index * BCM_SLHDSA_SHA2_128S_N, value,
-        SLHDSA_SHA2_128S_WOTS_W - 1 - value, pub_seed, addr);
+static void slhdsa_wots_pk_from_sig_do_chain(const slh_dsa_config *config,
+                                             uint8_t *out, uint8_t addr[32],
+                                             const uint8_t *in, uint8_t value,
+                                             const uint8_t *pub_seed,
+                                             uint32_t chain_index) {
+  slhdsa_set_chain_addr(config, addr, chain_index);
+  chain(config, out + chain_index * config->n, in + chain_index * config->n,
+        value, (config->wots_w - 1) - value, pub_seed, addr);
 }
 
 // Implements Algorithm 8: wots_pkFromSig function, page 21
-void slhdsa_wots_pk_from_sig(uint8_t pk[BCM_SLHDSA_SHA2_128S_N],
-                             const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                             const uint8_t msg[BCM_SLHDSA_SHA2_128S_N],
-                             const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                             uint8_t addr[32]) {
-  // Compute checksum
-  static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == BCM_SLHDSA_SHA2_128S_N * 2, "");
+void bssl::slhdsa_wots_pk_from_sig(const slh_dsa_config *config, uint8_t *pk,
+                                   const uint8_t *sig, const uint8_t *msg,
+                                   const uint8_t *pub_seed, uint8_t addr[32]) {
+  BSSL_CHECK(config->wots_w == 16);
+  const size_t n = config->n;
+  const uint32_t max_chain = config->wots_w - 1;
+
   uint16_t csum = 0;
-  for (size_t i = 0; i < BCM_SLHDSA_SHA2_128S_N; ++i) {
-    csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] >> 4);
-    csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] & 15);
+  for (size_t i = 0; i < n; ++i) {
+    csum += max_chain - (msg[i] >> 4);
+    csum += max_chain - (msg[i] & 15);
   }
 
-  uint8_t tmp[SLHDSA_SHA2_128S_WOTS_BYTES];
+  uint8_t tmp[SLHDSA_MAX_WOTS_BYTES];
   uint8_t wots_pk_addr[32];
   OPENSSL_memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
 
   uint32_t chain_index = 0;
-  static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == BCM_SLHDSA_SHA2_128S_N * 2, "");
-  for (size_t i = 0; i < BCM_SLHDSA_SHA2_128S_N; ++i) {
-    slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, msg[i] >> 4, pub_seed,
-                                     chain_index++);
-    slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, msg[i] & 15, pub_seed,
-                                     chain_index++);
+  for (size_t i = 0; i < n; ++i) {
+    slhdsa_wots_pk_from_sig_do_chain(config, tmp, addr, sig, msg[i] >> 4,
+                                     pub_seed, chain_index++);
+    slhdsa_wots_pk_from_sig_do_chain(config, tmp, addr, sig, msg[i] & 15,
+                                     pub_seed, chain_index++);
   }
 
-  slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, csum >> 8, pub_seed,
-                                   chain_index++);
-  slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, (csum >> 4) & 15, pub_seed,
+  slhdsa_wots_pk_from_sig_do_chain(config, tmp, addr, sig, csum >> 8, pub_seed,
                                    chain_index++);
-  slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, csum & 15, pub_seed,
+  slhdsa_wots_pk_from_sig_do_chain(config, tmp, addr, sig, (csum >> 4) & 15,
+                                   pub_seed, chain_index++);
+  slhdsa_wots_pk_from_sig_do_chain(config, tmp, addr, sig, csum & 15, pub_seed,
                                    chain_index++);
 
   // Compress pk
-  slhdsa_set_type(wots_pk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPK);
-  slhdsa_copy_keypair_addr(wots_pk_addr, addr);
-  slhdsa_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
+  slhdsa_set_type(config, wots_pk_addr, SLHDSA_ADDR_TYPE_WOTSPK);
+  slhdsa_copy_keypair_addr(config, wots_pk_addr, addr);
+  slhdsa_thash_tl(config, pk, tmp, pub_seed, wots_pk_addr);
 }

data/third_party/boringssl-with-bazel/crypto/fipsmodule/slhdsa/wots.h

@@ -17,34 +17,24 @@
 
 #include "./params.h"
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
+BSSL_NAMESPACE_BEGIN
 
 // Implements Algorithm 6: wots_pkGen function, page 18
-void slhdsa_wots_pk_gen(uint8_t pk[BCM_SLHDSA_SHA2_128S_N],
-                        const uint8_t sk_seed[BCM_SLHDSA_SHA2_128S_N],
-                        const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
+void slhdsa_wots_pk_gen(const slh_dsa_config *config, uint8_t *pk,
+                        const uint8_t *sk_seed, const uint8_t *pub_seed,
                         uint8_t addr[32]);
 
 // Implements Algorithm 7: wots_sign function, page 20
-void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                      const uint8_t msg[BCM_SLHDSA_SHA2_128S_N],
-                      const uint8_t sk_seed[BCM_SLHDSA_SHA2_128S_N],
-                      const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                      uint8_t addr[32]);
+void slhdsa_wots_sign(const slh_dsa_config *config, uint8_t *sig,
+                      const uint8_t *msg, const uint8_t *sk_seed,
+                      const uint8_t *pub_seed, uint8_t addr[32]);
 
 // Implements Algorithm 8: wots_pkFromSig function, page 21
-void slhdsa_wots_pk_from_sig(uint8_t pk[BCM_SLHDSA_SHA2_128S_N],
-                             const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                             const uint8_t msg[BCM_SLHDSA_SHA2_128S_N],
-                             const uint8_t pub_seed[BCM_SLHDSA_SHA2_128S_N],
-                             uint8_t addr[32]);
+void slhdsa_wots_pk_from_sig(const slh_dsa_config *config, uint8_t *pk,
+                             const uint8_t *sig, const uint8_t *msg,
+                             const uint8_t *pub_seed, uint8_t addr[32]);
 
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_FIPSMODULE_SLHDSA_WOTS_H

data/third_party/boringssl-with-bazel/crypto/fipsmodule/tls/internal.h

@@ -17,19 +17,8 @@
 
 #include <openssl/base.h>
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
-
-// tls1_prf calculates |out_len| bytes of the TLS PDF, using |digest|, and
-// writes them to |out|. It returns one on success and zero on error.
-OPENSSL_EXPORT int CRYPTO_tls1_prf(const EVP_MD *digest,
-                                   uint8_t *out, size_t out_len,
-                                   const uint8_t *secret, size_t secret_len,
-                                   const char *label, size_t label_len,
-                                   const uint8_t *seed1, size_t seed1_len,
-                                   const uint8_t *seed2, size_t seed2_len);
+BSSL_NAMESPACE_BEGIN
 
 // CRYPTO_tls13_hkdf_expand_label computes the TLS 1.3 KDF function of the same
 // name. See https://www.rfc-editor.org/rfc/rfc8446#section-7.1.
@@ -39,9 +28,6 @@ OPENSSL_EXPORT int CRYPTO_tls13_hkdf_expand_label(
     const uint8_t *label, size_t label_len,              //
     const uint8_t *hash, size_t hash_len);
 
-
-#if defined(__cplusplus)
-}
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_FIPSMODULE_TLS_INTERNAL_H

data/third_party/boringssl-with-bazel/crypto/fipsmodule/tls/kdf.cc.inc

@@ -19,20 +19,22 @@
 #include <openssl/hkdf.h>
 #include <openssl/hmac.h>
 #include <openssl/mem.h>
+#include <openssl/tls_prf.h>
 
-#include "internal.h"
 #include "../../internal.h"
 #include "../service_indicator/internal.h"
+#include "internal.h"
 
 
+using namespace bssl;
+
 // tls1_P_hash computes the TLS P_<hash> function as described in RFC 5246,
-// section 5. It XORs |out_len| bytes to |out|, using |md| as the hash and
-// |secret| as the secret. |label|, |seed1|, and |seed2| are concatenated to
+// section 5. It XORs `out_len` bytes to `out`, using `md` as the hash and
+// `secret` as the secret. `label`, `seed1`, and `seed2` are concatenated to
 // form the seed parameter. It returns true on success and false on failure.
-static int tls1_P_hash(uint8_t *out, size_t out_len,
-                       const EVP_MD *md,
+static int tls1_P_hash(uint8_t *out, size_t out_len, const EVP_MD *md,
                        const uint8_t *secret, size_t secret_len,
-                       const char *label, size_t label_len,
+                       const uint8_t *label, size_t label_len,
                        const uint8_t *seed1, size_t seed1_len,
                        const uint8_t *seed2, size_t seed2_len) {
   HMAC_CTX ctx, ctx_tmp, ctx_init;
@@ -45,11 +47,11 @@ static int tls1_P_hash(uint8_t *out, size_t out_len,
   HMAC_CTX_init(&ctx_tmp);
   HMAC_CTX_init(&ctx_init);
 
-  if (!HMAC_Init_ex(&ctx_init, secret, secret_len, md, NULL) ||
+  if (!HMAC_Init_ex(&ctx_init, secret, secret_len, md, nullptr) ||
       !HMAC_CTX_copy_ex(&ctx, &ctx_init) ||
-      !HMAC_Update(&ctx, (const uint8_t *) label, label_len) ||
+      !HMAC_Update(&ctx, label, label_len) ||
       !HMAC_Update(&ctx, seed1, seed1_len) ||
-      !HMAC_Update(&ctx, seed2, seed2_len) ||
+      !HMAC_Update(&ctx, seed2, seed2_len) ||  //
       !HMAC_Final(&ctx, A1, &A1_len)) {
     goto err;
   }
@@ -57,11 +59,10 @@ static int tls1_P_hash(uint8_t *out, size_t out_len,
   for (;;) {
     unsigned len_u;
     uint8_t hmac[EVP_MAX_MD_SIZE];
-    if (!HMAC_CTX_copy_ex(&ctx, &ctx_init) ||
-        !HMAC_Update(&ctx, A1, A1_len) ||
-        // Save a copy of |ctx| to compute the next A1 value below.
+    if (!HMAC_CTX_copy_ex(&ctx, &ctx_init) || !HMAC_Update(&ctx, A1, A1_len) ||
+        // Save a copy of `ctx` to compute the next A1 value below.
         (out_len > chunk && !HMAC_CTX_copy_ex(&ctx_tmp, &ctx)) ||
-        !HMAC_Update(&ctx, (const uint8_t *) label, label_len) ||
+        !HMAC_Update(&ctx, (const uint8_t *)label, label_len) ||
         !HMAC_Update(&ctx, seed1, seed1_len) ||
         !HMAC_Update(&ctx, seed2, seed2_len) ||
         !HMAC_Final(&ctx, hmac, &len_u)) {
@@ -70,7 +71,7 @@ static int tls1_P_hash(uint8_t *out, size_t out_len,
     size_t len = len_u;
     assert(len == chunk);
 
-    // XOR the result into |out|.
+    // XOR the result into `out`.
     if (len > out_len) {
       len = out_len;
     }
@@ -100,10 +101,9 @@ err:
   return ret;
 }
 
-int CRYPTO_tls1_prf(const EVP_MD *digest,
-                    uint8_t *out, size_t out_len,
+int CRYPTO_tls1_prf(const EVP_MD *digest, uint8_t *out, size_t out_len,
                     const uint8_t *secret, size_t secret_len,
-                    const char *label, size_t label_len,
+                    const uint8_t *label, size_t label_len,
                     const uint8_t *seed1, size_t seed1_len,
                     const uint8_t *seed2, size_t seed2_len) {
   if (out_len == 0) {
@@ -117,14 +117,14 @@ int CRYPTO_tls1_prf(const EVP_MD *digest,
   int ret = 0;
 
   if (digest == EVP_md5_sha1()) {
-    // If using the MD5/SHA1 PRF, |secret| is partitioned between MD5 and SHA-1.
+    // If using the MD5/SHA1 PRF, `secret` is partitioned between MD5 and SHA-1.
     size_t secret_half = secret_len - (secret_len / 2);
     if (!tls1_P_hash(out, out_len, EVP_md5(), secret, secret_half, label,
                      label_len, seed1, seed1_len, seed2, seed2_len)) {
       goto end;
     }
 
-    // Note that, if |secret_len| is odd, the two halves share a byte.
+    // Note that, if `secret_len` is odd, the two halves share a byte.
     secret += secret_len - secret_half;
     secret_len = secret_half;
     digest = EVP_sha1();
@@ -141,14 +141,15 @@ end:
   return ret;
 }
 
-int CRYPTO_tls13_hkdf_expand_label(uint8_t *out, size_t out_len,
-                                   const EVP_MD *digest,  //
-                                   const uint8_t *secret, size_t secret_len,
-                                   const uint8_t *label, size_t label_len,
-                                   const uint8_t *hash, size_t hash_len) {
+int bssl::CRYPTO_tls13_hkdf_expand_label(uint8_t *out, size_t out_len,
+                                         const EVP_MD *digest,  //
+                                         const uint8_t *secret,
+                                         size_t secret_len,
+                                         const uint8_t *label, size_t label_len,
+                                         const uint8_t *hash, size_t hash_len) {
   static const uint8_t kProtocolLabel[] = "tls13 ";
   CBB cbb, child;
-  uint8_t *hkdf_label = NULL;
+  uint8_t *hkdf_label = nullptr;
   size_t hkdf_label_len;
 
   FIPS_service_indicator_lock_state();
@@ -177,4 +178,3 @@ int CRYPTO_tls13_hkdf_expand_label(uint8_t *out, size_t out_len,
   }
   return ret;
 }
-

data/third_party/boringssl-with-bazel/crypto/fuzzer_mode.cc

@@ -17,14 +17,14 @@
 #include "internal.h"
 
 
+using namespace bssl;
+
 #if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
-static CRYPTO_atomic_u32 fuzzer_mode_enabled = 0;
+static bssl::Atomic<uint32_t> fuzzer_mode_enabled = 0;
 
-int CRYPTO_fuzzer_mode_enabled(void) {
-  return CRYPTO_atomic_load_u32(&fuzzer_mode_enabled);
-}
+int bssl::CRYPTO_fuzzer_mode_enabled() { return fuzzer_mode_enabled.load(); }
 
 void CRYPTO_set_fuzzer_mode(int enabled) {
-  CRYPTO_atomic_store_u32(&fuzzer_mode_enabled, !!enabled);
+  fuzzer_mode_enabled.store(!!enabled);
 }
 #endif  // FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION