grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/slhdsa/thash.h

@@ -0,0 +1,85 @@
+/* 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. */
+
+#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
+#define OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
+
+#include "./params.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// Implements PRF_msg: a pseudo-random function that is used to generate the
+// randomizer r for the randomized hashing of the message to be signed.
+// (Section 4.1, page 11)
+void slhdsa_thash_prfmsg(uint8_t output[SLHDSA_SHA2_128S_N],
+                         const uint8_t sk_prf[SLHDSA_SHA2_128S_N],
+                         const uint8_t opt_rand[SLHDSA_SHA2_128S_N],
+                         const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
+                         const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
+                         size_t msg_len);
+
+// Implements H_msg: a hash function used to generate the digest of the message
+// to be signed. (Section 4.1, page 11)
+void slhdsa_thash_hmsg(uint8_t output[SLHDSA_SHA2_128S_DIGEST_SIZE],
+                       const uint8_t r[SLHDSA_SHA2_128S_N],
+                       const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
+                       const uint8_t pk_root[SLHDSA_SHA2_128S_N],
+                       const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
+                       const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
+                       size_t msg_len);
+
+// Implements PRF: a pseudo-random function that is used to generate the secret
+// values in WOTS+ and FORS private keys. (Section 4.1, page 11)
+void slhdsa_thash_prf(uint8_t output[SLHDSA_SHA2_128S_N],
+                      const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
+                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                      uint8_t addr[32]);
+
+// Implements T_l: a hash function that maps an l*n-byte message to an n-byte
+// message. Used for WOTS+ public key compression. (Section 4.1, page 11)
+void slhdsa_thash_tl(uint8_t output[SLHDSA_SHA2_128S_N],
+                     const uint8_t input[SLHDSA_SHA2_128S_WOTS_BYTES],
+                     const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
+                     uint8_t addr[32]);
+
+// Implements H: a hash function that takes a 2*n-byte message as input and
+// produces an n-byte output. (Section 4.1, page 11)
+void slhdsa_thash_h(uint8_t output[SLHDSA_SHA2_128S_N],
+                    const uint8_t input[2 * SLHDSA_SHA2_128S_N],
+                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
+                    uint8_t addr[32]);
+
+// Implements F: a hash function that takes an n-byte message as input and
+// produces an n-byte output. (Section 4.1, page 11)
+void slhdsa_thash_f(uint8_t output[SLHDSA_SHA2_128S_N],
+                    const uint8_t input[SLHDSA_SHA2_128S_N],
+                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
+                    uint8_t addr[32]);
+
+// Implements T_k: a hash function that maps a k*n-byte message to an n-byte
+// message. Used for FORS public key compression. (Section 4.1, page 11)
+void slhdsa_thash_tk(
+    uint8_t output[SLHDSA_SHA2_128S_N],
+    const uint8_t input[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N],
+    const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H

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

@@ -0,0 +1,171 @@
+/* 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/base.h>
+
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../internal.h"
+#include "./address.h"
+#include "./params.h"
+#include "./thash.h"
+#include "./wots.h"
+
+
+// Implements Algorithm 5: chain function, page 18
+static void chain(uint8_t output[SLHDSA_SHA2_128S_N],
+                  const uint8_t input[SLHDSA_SHA2_128S_N], uint32_t start,
+                  uint32_t steps, const uint8_t pub_seed[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, 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 slhdsa_wots_do_chain(uint8_t out[SLHDSA_SHA2_128S_N],
+                                 uint8_t sk_addr[32], uint8_t addr[32],
+                                 uint8_t value,
+                                 const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                                 const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                                 uint32_t chain_index) {
+  uint8_t tmp_sk[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);
+}
+
+// Implements Algorithm 6: wots_pkGen function, page 18
+void slhdsa_wots_pk_gen(uint8_t pk[SLHDSA_SHA2_128S_N],
+                        const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                        const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                        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 * SLHDSA_SHA2_128S_N, sk_addr, addr,
+                         SLHDSA_SHA2_128S_WOTS_W - 1, 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);
+}
+
+// Implements Algorithm 7: wots_sign function, page 20
+void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
+                      const uint8_t msg[SLHDSA_SHA2_128S_N],
+                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                      const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                      uint8_t addr[32]) {
+  // Compute checksum
+  static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == SLHDSA_SHA2_128S_N * 2, "");
+  uint16_t csum = 0;
+  for (size_t i = 0; i < 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);
+  }
+
+  // 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);
+
+  uint32_t chain_index = 0;
+  for (size_t i = 0; i < SLHDSA_SHA2_128S_N; ++i) {
+    slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] >> 4, sk_seed, pub_seed,
+                         chain_index++);
+    sig += SLHDSA_SHA2_128S_N;
+
+    slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] & 15, sk_seed, pub_seed,
+                         chain_index++);
+    sig += SLHDSA_SHA2_128S_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 += SLHDSA_SHA2_128S_N;
+  slhdsa_wots_do_chain(sig, sk_addr, addr, (csum >> 4) & 15, sk_seed, pub_seed,
+                       chain_index++);
+  sig += SLHDSA_SHA2_128S_N;
+  slhdsa_wots_do_chain(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[SLHDSA_SHA2_128S_N], uint32_t chain_index) {
+  slhdsa_set_chain_addr(addr, chain_index);
+  chain(out + chain_index * SLHDSA_SHA2_128S_N,
+        in + chain_index * SLHDSA_SHA2_128S_N, value,
+        SLHDSA_SHA2_128S_WOTS_W - 1 - value, pub_seed, addr);
+}
+
+// Implements Algorithm 8: wots_pkFromSig function, page 21
+void slhdsa_wots_pk_from_sig(uint8_t pk[SLHDSA_SHA2_128S_N],
+                             const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
+                             const uint8_t msg[SLHDSA_SHA2_128S_N],
+                             const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                             uint8_t addr[32]) {
+  // Compute checksum
+  static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == SLHDSA_SHA2_128S_N * 2, "");
+  uint16_t csum = 0;
+  for (size_t i = 0; i < 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);
+  }
+
+  uint8_t tmp[SLHDSA_SHA2_128S_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 == SLHDSA_SHA2_128S_N * 2, "");
+  for (size_t i = 0; i < 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++);
+  }
+
+  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,
+                                   chain_index++);
+  slhdsa_wots_pk_from_sig_do_chain(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);
+}

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

@@ -0,0 +1,50 @@
+/* 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. */
+
+#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
+#define OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
+
+#include "./params.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// Implements Algorithm 6: wots_pkGen function, page 18
+void slhdsa_wots_pk_gen(uint8_t pk[SLHDSA_SHA2_128S_N],
+                        const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                        const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                        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[SLHDSA_SHA2_128S_N],
+                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
+                      const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                      uint8_t addr[32]);
+
+// Implements Algorithm 8: wots_pkFromSig function, page 21
+void slhdsa_wots_pk_from_sig(uint8_t pk[SLHDSA_SHA2_128S_N],
+                             const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
+                             const uint8_t msg[SLHDSA_SHA2_128S_N],
+                             const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
+                             uint8_t addr[32]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H

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

@@ -84,12 +84,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 +119,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 +199,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 +369,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_none.c → thread_none.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/{thread_pthread.c → thread_pthread.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
@@ -53,9 +53,7 @@ void CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX *lock) {
   }
 }
 
-void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {
-  pthread_rwlock_destroy(lock);
-}
+void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) { pthread_rwlock_destroy(lock); }
 
 void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
   if (pthread_once(once, init) != 0) {
@@ -81,7 +79,7 @@ static void thread_local_destructor(void *arg) {
   pthread_mutex_unlock(&g_destructors_lock);
 
   unsigned i;
-  void **pointers = arg;
+  void **pointers = reinterpret_cast<void **>(arg);
   for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
     if (destructors[i] != NULL) {
       destructors[i](pointers[i]);
@@ -106,7 +104,8 @@ void *CRYPTO_get_thread_local(thread_local_data_t index) {
     return NULL;
   }
 
-  void **pointers = pthread_getspecific(g_thread_local_key);
+  void **pointers =
+      reinterpret_cast<void **>(pthread_getspecific(g_thread_local_key));
   if (pointers == NULL) {
     return NULL;
   }
@@ -121,9 +120,11 @@ int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
     return 0;
   }
 
-  void **pointers = pthread_getspecific(g_thread_local_key);
+  void **pointers =
+      reinterpret_cast<void **>(pthread_getspecific(g_thread_local_key));
   if (pointers == NULL) {
-    pointers = malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
+    pointers = reinterpret_cast<void **>(
+        malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS));
     if (pointers == NULL) {
       destructor(value);
       return 0;

data/third_party/boringssl-with-bazel/src/crypto/{thread_win.c → thread_win.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
@@ -38,13 +38,9 @@ void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
   }
 }
 
-void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) {
-  InitializeSRWLock(lock);
-}
+void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) { InitializeSRWLock(lock); }
 
-void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) {
-  AcquireSRWLockShared(lock);
-}
+void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) { AcquireSRWLockShared(lock); }
 
 void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {
   AcquireSRWLockExclusive(lock);
@@ -90,7 +86,7 @@ static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
     return;
   }
 
-  void **pointers = (void**) TlsGetValue(g_thread_local_key);
+  void **pointers = (void **)TlsGetValue(g_thread_local_key);
   if (pointers == NULL) {
     return;
   }
@@ -126,12 +122,10 @@ static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
 #define STRINGIFY(x) #x
 #define EXPAND_AND_STRINGIFY(x) STRINGIFY(x)
 #ifdef _WIN64
-__pragma(comment(linker, "/INCLUDE:_tls_used"))
-__pragma(comment(
+__pragma(comment(linker, "/INCLUDE:_tls_used")) __pragma(comment(
     linker, "/INCLUDE:" EXPAND_AND_STRINGIFY(p_thread_callback_boringssl)))
 #else
-__pragma(comment(linker, "/INCLUDE:__tls_used"))
-__pragma(comment(
+__pragma(comment(linker, "/INCLUDE:__tls_used")) __pragma(comment(
     linker, "/INCLUDE:_" EXPAND_AND_STRINGIFY(p_thread_callback_boringssl)))
 #endif
 
@@ -155,9 +149,13 @@ __pragma(comment(
 
 // .CRT section is merged with .rdata on x64 so it must be constant data.
 #pragma const_seg(".CRT$XLC")
-// When defining a const variable, it must have external linkage to be sure the
-// linker doesn't discard it.
-extern const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl;
+    // clang-format off
+    // When defining a const variable, it must have external linkage to be sure
+    // the linker doesn't discard it.
+extern "C" {
+  extern const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl;
+}
+// clang-format on
 const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 // Reset the default section.
 #pragma const_seg()
@@ -165,6 +163,11 @@ const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 #else
 
 #pragma data_seg(".CRT$XLC")
+    // clang-format off
+extern "C" {
+  extern PIMAGE_TLS_CALLBACK p_thread_callback_boringssl;
+}
+// clang-format on
 PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 // Reset the default section.
 #pragma data_seg()
@@ -184,7 +187,7 @@ static void **get_thread_locals(void) {
   //
   // https://msdn.microsoft.com/en-us/library/windows/desktop/ms686812(v=vs.85).aspx
   DWORD last_error = GetLastError();
-  void **ret = TlsGetValue(g_thread_local_key);
+  void **ret = reinterpret_cast<void **>(TlsGetValue(g_thread_local_key));
   SetLastError(last_error);
   return ret;
 }
@@ -212,7 +215,8 @@ int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
 
   void **pointers = get_thread_locals();
   if (pointers == NULL) {
-    pointers = malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
+    pointers = reinterpret_cast<void **>(
+        malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS));
     if (pointers == NULL) {
       destructor(value);
       return 0;

data/third_party/boringssl-with-bazel/src/crypto/trust_token/internal.h

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