grpc 1.84.1 → 1.85.0.pre1

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

@@ -24,37 +24,24 @@
 #include <stdlib.h>
 #include <string.h>
 
+
+BSSL_NAMESPACE_BEGIN
+
 static BOOL CALLBACK call_once_init(INIT_ONCE *once, void *arg, void **out) {
-  void (**init)(void) = (void (**)(void))arg;
+  void (**init)() = (void (**)())arg;
   (**init)();
   return TRUE;
 }
 
-void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
-  if (!InitOnceExecuteOnce(once, call_once_init, &init, NULL)) {
-    abort();
-  }
+void CRYPTO_once(CRYPTO_once_t *once, void (*init)()) {
+  BSSL_CHECK(InitOnceExecuteOnce(once, call_once_init, &init, nullptr));
 }
 
-void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) { InitializeSRWLock(lock); }
-
-void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) { AcquireSRWLockShared(lock); }
-
-void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {
-  AcquireSRWLockExclusive(lock);
-}
-
-void CRYPTO_MUTEX_unlock_read(CRYPTO_MUTEX *lock) {
-  ReleaseSRWLockShared(lock);
-}
-
-void CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX *lock) {
-  ReleaseSRWLockExclusive(lock);
-}
-
-void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {
-  // SRWLOCKs require no cleanup.
-}
+void StaticMutex::LockRead() { AcquireSRWLockShared(&lock_); }
+void StaticMutex::UnlockRead() { ReleaseSRWLockShared(&lock_); }
+void StaticMutex::LockWrite() { AcquireSRWLockExclusive(&lock_); }
+void StaticMutex::UnlockWrite() { ReleaseSRWLockExclusive(&lock_); }
+Mutex::~Mutex() { /* SRWLOCKs require no cleanup. */ }
 
 static SRWLOCK g_destructors_lock = SRWLOCK_INIT;
 static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS];
@@ -63,17 +50,17 @@ static CRYPTO_once_t g_thread_local_init_once = CRYPTO_ONCE_INIT;
 static DWORD g_thread_local_key;
 static int g_thread_local_failed;
 
-static void thread_local_init(void) {
+static void thread_local_init() {
   g_thread_local_key = TlsAlloc();
   g_thread_local_failed = (g_thread_local_key == TLS_OUT_OF_INDEXES);
 }
 
 static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
                                           PVOID reserved) {
-  // Only free memory on |DLL_THREAD_DETACH|, not |DLL_PROCESS_DETACH|. In
+  // Only free memory on `DLL_THREAD_DETACH`, not `DLL_PROCESS_DETACH`. In
   // VS2015's debug runtime, the C runtime has been unloaded by the time
-  // |DLL_PROCESS_DETACH| runs. See https://crbug.com/575795. This is consistent
-  // with |pthread_key_create| which does not call destructors on process exit,
+  // `DLL_PROCESS_DETACH` runs. See https://crbug.com/575795. This is consistent
+  // with `pthread_key_create` which does not call destructors on process exit,
   // only thread exit.
   if (reason != DLL_THREAD_DETACH) {
     return;
@@ -85,7 +72,7 @@ static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
   }
 
   void **pointers = (void **)TlsGetValue(g_thread_local_key);
-  if (pointers == NULL) {
+  if (pointers == nullptr) {
     return;
   }
 
@@ -96,7 +83,7 @@ static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
   ReleaseSRWLockExclusive(&g_destructors_lock);
 
   for (unsigned i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
-    if (destructors[i] != NULL) {
+    if (destructors[i] != nullptr) {
       destructors[i](pointers[i]);
     }
   }
@@ -116,7 +103,7 @@ static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
 // a reference to p_thread_callback_boringssl to prevent whole program
 // optimization from discarding the variable.
 //
-// Note, in the prefixed build, |p_thread_callback_boringssl| may be a macro.
+// Note, in the prefixed build, `p_thread_callback_boringssl` may be a macro.
 #define STRINGIFY(x) #x
 #define EXPAND_AND_STRINGIFY(x) STRINGIFY(x)
 #ifdef _WIN64
@@ -172,14 +159,14 @@ PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 
 #endif  // _WIN64
 
-static void **get_thread_locals(void) {
-  // |TlsGetValue| clears the last error even on success, so that callers may
+static void **get_thread_locals() {
+  // `TlsGetValue` clears the last error even on success, so that callers may
   // distinguish it successfully returning NULL or failing. It is documented to
-  // never fail if the argument is a valid index from |TlsAlloc|, so we do not
+  // never fail if the argument is a valid index from `TlsAlloc`, so we do not
   // need to handle this.
   //
   // However, this error-mangling behavior interferes with the caller's use of
-  // |GetLastError|. In particular |SSL_get_error| queries the error queue to
+  // `GetLastError`. In particular `SSL_get_error` queries the error queue to
   // determine whether the caller should look at the OS's errors. To avoid
   // destroying state, save and restore the Windows error.
   //
@@ -193,12 +180,12 @@ static void **get_thread_locals(void) {
 void *CRYPTO_get_thread_local(thread_local_data_t index) {
   CRYPTO_once(&g_thread_local_init_once, thread_local_init);
   if (g_thread_local_failed) {
-    return NULL;
+    return nullptr;
   }
 
   void **pointers = get_thread_locals();
-  if (pointers == NULL) {
-    return NULL;
+  if (pointers == nullptr) {
+    return nullptr;
   }
   return pointers[index];
 }
@@ -212,10 +199,10 @@ int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
   }
 
   void **pointers = get_thread_locals();
-  if (pointers == NULL) {
+  if (pointers == nullptr) {
     pointers = reinterpret_cast<void **>(
         malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS));
-    if (pointers == NULL) {
+    if (pointers == nullptr) {
       destructor(value);
       return 0;
     }
@@ -235,4 +222,6 @@ int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
   return 1;
 }
 
+BSSL_NAMESPACE_END
+
 #endif  // OPENSSL_WINDOWS_THREADS

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

@@ -25,10 +25,7 @@
 #include <openssl/trust_token.h>
 
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
+BSSL_NAMESPACE_BEGIN
 
 // For the following cryptographic schemes, we use P-384 instead of our usual
 // choice of P-256. See Appendix I of
@@ -46,26 +43,27 @@ extern "C" {
 #define TRUST_TOKEN_NONCE_SIZE 64
 
 typedef struct {
-  // TODO(https://crbug.com/boringssl/334): These should store |EC_PRECOMP| so
-  // that |TRUST_TOKEN_finish_issuance| can use |ec_point_mul_scalar_precomp|.
-  EC_AFFINE pub0;
-  EC_AFFINE pub1;
-  EC_AFFINE pubs;
+  // TODO(https://crbug.com/boringssl/334): These should store
+  // `bssl::EC_PRECOMP` so that `TRUST_TOKEN_finish_issuance` can use
+  // `ec_point_mul_scalar_precomp`.
+  bssl::EC_AFFINE pub0;
+  bssl::EC_AFFINE pub1;
+  bssl::EC_AFFINE pubs;
 } TRUST_TOKEN_CLIENT_KEY;
 
 typedef struct {
-  EC_SCALAR x0;
-  EC_SCALAR y0;
-  EC_SCALAR x1;
-  EC_SCALAR y1;
-  EC_SCALAR xs;
-  EC_SCALAR ys;
-  EC_AFFINE pub0;
-  EC_PRECOMP pub0_precomp;
-  EC_AFFINE pub1;
-  EC_PRECOMP pub1_precomp;
-  EC_AFFINE pubs;
-  EC_PRECOMP pubs_precomp;
+  bssl::EC_SCALAR x0;
+  bssl::EC_SCALAR y0;
+  bssl::EC_SCALAR x1;
+  bssl::EC_SCALAR y1;
+  bssl::EC_SCALAR xs;
+  bssl::EC_SCALAR ys;
+  bssl::EC_AFFINE pub0;
+  bssl::EC_PRECOMP pub0_precomp;
+  bssl::EC_AFFINE pub1;
+  bssl::EC_PRECOMP pub1_precomp;
+  bssl::EC_AFFINE pubs;
+  bssl::EC_PRECOMP pubs_precomp;
 } TRUST_TOKEN_ISSUER_KEY;
 
 // TRUST_TOKEN_PRETOKEN represents the intermediate state a client keeps during
@@ -73,14 +71,14 @@ typedef struct {
 typedef struct pmb_pretoken_st {
   uint8_t salt[TRUST_TOKEN_NONCE_SIZE];
   uint8_t t[TRUST_TOKEN_NONCE_SIZE];
-  EC_SCALAR r;
-  EC_AFFINE Tp;
+  bssl::EC_SCALAR r;
+  bssl::EC_AFFINE Tp;
 } TRUST_TOKEN_PRETOKEN;
 
-// TRUST_TOKEN_PRETOKEN_free releases the memory associated with |token|.
+// TRUST_TOKEN_PRETOKEN_free releases the memory associated with `token`.
 OPENSSL_EXPORT void TRUST_TOKEN_PRETOKEN_free(TRUST_TOKEN_PRETOKEN *token);
 
-DEFINE_STACK_OF(TRUST_TOKEN_PRETOKEN)
+DEFINE_NAMESPACED_STACK_OF(TRUST_TOKEN_PRETOKEN)
 
 
 // PMBTokens.
@@ -90,8 +88,8 @@ DEFINE_STACK_OF(TRUST_TOKEN_PRETOKEN)
 // construction with validity verification, described in appendix H,
 // construction 6.
 
-// The following functions implement the corresponding |TRUST_TOKENS_METHOD|
-// functions for |TRUST_TOKENS_experiment_v1|'s PMBTokens construction which
+// The following functions implement the corresponding `TRUST_TOKENS_METHOD`
+// functions for `TRUST_TOKENS_experiment_v1`'s PMBTokens construction which
 // uses P-384.
 int pmbtoken_exp1_generate_key(CBB *out_private, CBB *out_public);
 int pmbtoken_exp1_derive_key_from_secret(CBB *out_private, CBB *out_public,
@@ -122,8 +120,8 @@ int pmbtoken_exp1_read(const TRUST_TOKEN_ISSUER_KEY *key,
 // function is used to confirm H was computed as expected.
 OPENSSL_EXPORT int pmbtoken_exp1_get_h_for_testing(uint8_t out[97]);
 
-// The following functions implement the corresponding |TRUST_TOKENS_METHOD|
-// functions for |TRUST_TOKENS_experiment_v2|'s PMBTokens construction which
+// The following functions implement the corresponding `TRUST_TOKENS_METHOD`
+// functions for `TRUST_TOKENS_experiment_v2`'s PMBTokens construction which
 // uses P-384.
 int pmbtoken_exp2_generate_key(CBB *out_private, CBB *out_public);
 int pmbtoken_exp2_derive_key_from_secret(CBB *out_private, CBB *out_public,
@@ -154,8 +152,8 @@ int pmbtoken_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key,
 // function is used to confirm H was computed as expected.
 OPENSSL_EXPORT int pmbtoken_exp2_get_h_for_testing(uint8_t out[97]);
 
-// The following functions implement the corresponding |TRUST_TOKENS_METHOD|
-// functions for |TRUST_TOKENS_pst_v1|'s PMBTokens construction which uses
+// The following functions implement the corresponding `TRUST_TOKENS_METHOD`
+// functions for `TRUST_TOKENS_pst_v1`'s PMBTokens construction which uses
 // P-384.
 int pmbtoken_pst1_generate_key(CBB *out_private, CBB *out_public);
 int pmbtoken_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public,
@@ -193,11 +191,11 @@ OPENSSL_EXPORT int pmbtoken_pst1_get_h_for_testing(uint8_t out[97]);
 // and provide anonymous tokens. This implementation uses TrustToken DSTs and
 // the DLEQ batching primitive from
 // https://eprint.iacr.org/2020/072/20200324:214215.
-// VOPRF only uses the |pub|' field of the TRUST_TOKEN_CLIENT_KEY and
-// |xs|/|pubs| fields of the TRUST_TOKEN_ISSUER_KEY.
+// VOPRF only uses the `pub`' field of the TRUST_TOKEN_CLIENT_KEY and
+// `xs`/`pubs` fields of the TRUST_TOKEN_ISSUER_KEY.
 
-// The following functions implement the corresponding |TRUST_TOKENS_METHOD|
-// functions for |TRUST_TOKENS_experiment_v2|'s VOPRF construction which uses
+// The following functions implement the corresponding `TRUST_TOKENS_METHOD`
+// functions for `TRUST_TOKENS_experiment_v2`'s VOPRF construction which uses
 // P-384.
 int voprf_exp2_generate_key(CBB *out_private, CBB *out_public);
 int voprf_exp2_derive_key_from_secret(CBB *out_private, CBB *out_public,
@@ -223,8 +221,8 @@ int voprf_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key,
                     size_t token_len, int include_message, const uint8_t *msg,
                     size_t msg_len);
 
-// The following functions implement the corresponding |TRUST_TOKENS_METHOD|
-// functions for |TRUST_TOKENS_pst_v1|'s VOPRF construction which uses P-384.
+// The following functions implement the corresponding `TRUST_TOKENS_METHOD`
+// functions for `TRUST_TOKENS_pst_v1`'s VOPRF construction which uses P-384.
 int voprf_pst1_generate_key(CBB *out_private, CBB *out_public);
 int voprf_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public,
                                       const uint8_t *secret, size_t secret_len);
@@ -253,75 +251,78 @@ int voprf_pst1_read(const TRUST_TOKEN_ISSUER_KEY *key,
                     size_t token_len, int include_message, const uint8_t *msg,
                     size_t msg_len);
 
+using StackOfTrustTokenPretoken = STACK_OF(TRUST_TOKEN_PRETOKEN);
+
+BSSL_NAMESPACE_END
 
 // Trust Tokens internals.
 
 struct trust_token_method_st {
   // generate_key generates a fresh keypair and writes their serialized
-  // forms into |out_private| and |out_public|. It returns one on success and
+  // forms into `out_private` and `out_public`. It returns one on success and
   // zero on failure.
   int (*generate_key)(CBB *out_private, CBB *out_public);
 
   // derive_key_from_secret deterministically derives a keypair based on
-  // |secret| and writes their serialized forms into |out_private| and
-  // |out_public|. It returns one on success and zero on failure.
+  // `secret` and writes their serialized forms into `out_private` and
+  // `out_public`. It returns one on success and zero on failure.
   int (*derive_key_from_secret)(CBB *out_private, CBB *out_public,
                                 const uint8_t *secret, size_t secret_len);
 
-  // client_key_from_bytes decodes a client key from |in| and sets |key|
+  // client_key_from_bytes decodes a client key from `in` and sets `key`
   // to the resulting key. It returns one on success and zero
   // on failure.
-  int (*client_key_from_bytes)(TRUST_TOKEN_CLIENT_KEY *key, const uint8_t *in,
-                               size_t len);
+  int (*client_key_from_bytes)(bssl::TRUST_TOKEN_CLIENT_KEY *key,
+                               const uint8_t *in, size_t len);
 
-  // issuer_key_from_bytes decodes a issuer key from |in| and sets |key|
+  // issuer_key_from_bytes decodes a issuer key from `in` and sets `key`
   // to the resulting key. It returns one on success and zero
   // on failure.
-  int (*issuer_key_from_bytes)(TRUST_TOKEN_ISSUER_KEY *key, const uint8_t *in,
-                               size_t len);
-
-  // blind generates a new issuance request for |count| tokens. If
-  // |include_message| is set, then |msg| is used to derive the token nonces. On
-  // success, it returns a newly-allocated |STACK_OF(TRUST_TOKEN_PRETOKEN)| and
-  // writes a request to the issuer to |cbb|. On failure, it returns NULL. The
-  // |STACK_OF(TRUST_TOKEN_PRETOKEN)|s should be passed to |pmbtoken_unblind|
+  int (*issuer_key_from_bytes)(bssl::TRUST_TOKEN_ISSUER_KEY *key,
+                               const uint8_t *in, size_t len);
+
+  // blind generates a new issuance request for `count` tokens. If
+  // `include_message` is set, then `msg` is used to derive the token nonces. On
+  // success, it returns a newly-allocated `STACK_OF(TRUST_TOKEN_PRETOKEN)` and
+  // writes a request to the issuer to `cbb`. On failure, it returns NULL. The
+  // `STACK_OF(TRUST_TOKEN_PRETOKEN)`s should be passed to `pmbtoken_unblind`
   // when the server responds.
   //
   // This function implements the AT.Usr0 operation.
-  STACK_OF(TRUST_TOKEN_PRETOKEN) *(*blind)(CBB *cbb, size_t count,
-                                           int include_message,
-                                           const uint8_t *msg, size_t msg_len);
+  bssl::StackOfTrustTokenPretoken *(*blind)(CBB *cbb, size_t count,
+                                            int include_message,
+                                            const uint8_t *msg, size_t msg_len);
 
-  // sign parses a request for |num_requested| tokens from |cbs| and
-  // issues |num_to_issue| tokens with |key| and a private metadata value of
-  // |private_metadata|. It then writes the response to |cbb|. It returns one on
+  // sign parses a request for `num_requested` tokens from `cbs` and
+  // issues `num_to_issue` tokens with `key` and a private metadata value of
+  // `private_metadata`. It then writes the response to `cbb`. It returns one on
   // success and zero on failure.
   //
   // This function implements the AT.Sig operation.
-  int (*sign)(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs,
+  int (*sign)(const bssl::TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs,
               size_t num_requested, size_t num_to_issue,
               uint8_t private_metadata);
 
-  // unblind processes an issuance response for |count| tokens from |cbs|
-  // and unblinds the signed tokens. |pretokens| are the pre-tokens returned
-  // from the corresponding |blind| call. On success, the function returns a
-  // newly-allocated |STACK_OF(TRUST_TOKEN)| containing the resulting tokens.
-  // Each token's serialization will have |key_id| prepended. Otherwise, it
+  // unblind processes an issuance response for `count` tokens from `cbs`
+  // and unblinds the signed tokens. `pretokens` are the pre-tokens returned
+  // from the corresponding `blind` call. On success, the function returns a
+  // newly-allocated `STACK_OF(TRUST_TOKEN)` containing the resulting tokens.
+  // Each token's serialization will have `key_id` prepended. Otherwise, it
   // returns NULL.
   //
   // This function implements the AT.Usr1 operation.
   STACK_OF(TRUST_TOKEN) *(*unblind)(
-      const TRUST_TOKEN_CLIENT_KEY *key,
-      const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count,
+      const bssl::TRUST_TOKEN_CLIENT_KEY *key,
+      const bssl::StackOfTrustTokenPretoken *pretokens, CBS *cbs, size_t count,
       uint32_t key_id);
 
-  // read parses a token from |token| and verifies it using |key|. If
-  // |include_message| is set, then the nonce is derived from |msg| and the salt
+  // read parses a token from `token` and verifies it using `key`. If
+  // `include_message` is set, then the nonce is derived from `msg` and the salt
   // in the token. On success, it returns one and stores the nonce and private
-  // metadata bit in |out_nonce| and |*out_private_metadata|. Otherwise, it
-  // returns zero. Note that, unlike the output of |unblind|, |token| does not
+  // metadata bit in `out_nonce` and `*out_private_metadata`. Otherwise, it
+  // returns zero. Note that, unlike the output of `unblind`, `token` does not
   // have a four-byte key ID prepended.
-  int (*read)(const TRUST_TOKEN_ISSUER_KEY *key,
+  int (*read)(const bssl::TRUST_TOKEN_ISSUER_KEY *key,
               uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE],
               uint8_t *out_private_metadata, const uint8_t *token,
               size_t token_len, int include_message, const uint8_t *msg,
@@ -337,6 +338,8 @@ struct trust_token_method_st {
   int has_srr;
 };
 
+BSSL_NAMESPACE_BEGIN
+
 // Structure representing a single Trust Token public key with the specified ID.
 struct trust_token_client_key_st {
   uint32_t id;
@@ -350,6 +353,8 @@ struct trust_token_issuer_key_st {
   TRUST_TOKEN_ISSUER_KEY key;
 };
 
+BSSL_NAMESPACE_END
+
 struct trust_token_client_st {
   const TRUST_TOKEN_METHOD *method;
 
@@ -358,13 +363,15 @@ struct trust_token_client_st {
 
   // keys is the set of public keys that are supported by the client for
   // issuance/redemptions.
-  struct trust_token_client_key_st keys[6];
+  // TODO(crbug.com/42290036): Replace this and `num_keys` with an
+  // InplaceVector.
+  struct bssl::trust_token_client_key_st keys[6];
 
   // num_keys is the number of keys currently configured.
   size_t num_keys;
 
   // pretokens is the intermediate state during an active issuance.
-  STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens;
+  bssl::StackOfTrustTokenPretoken *pretokens;
 
   // srr_key is the public key used to verify the signature of the SRR.
   EVP_PKEY *srr_key;
@@ -380,33 +387,19 @@ struct trust_token_issuer_st {
   // keys is the set of private keys that are supported by the issuer for
   // issuance/redemptions. The public metadata is an index into this list of
   // keys.
-  struct trust_token_issuer_key_st keys[6];
+  struct bssl::trust_token_issuer_key_st keys[6];
 
   // num_keys is the number of keys currently configured.
   size_t num_keys;
 
   // srr_key is the private key used to sign the SRR.
   EVP_PKEY *srr_key;
-
-  // metadata_key is the secret material used to encode the private metadata bit
-  // in the SRR.
-  uint8_t *metadata_key;
-  size_t metadata_key_len;
 };
 
-
-#if defined(__cplusplus)
-}  // extern C
-
-extern "C++" {
-
 BSSL_NAMESPACE_BEGIN
 
 BORINGSSL_MAKE_DELETER(TRUST_TOKEN_PRETOKEN, TRUST_TOKEN_PRETOKEN_free)
 
 BSSL_NAMESPACE_END
 
-}  // extern C++
-#endif
-
 #endif  // OPENSSL_HEADER_CRYPTO_TRUST_TOKEN_INTERNAL_H