grpc 1.61.3 → 1.62.0.pre1

data/third_party/boringssl-with-bazel/src/crypto/spx/thash.c

@@ -0,0 +1,136 @@
+/* Copyright (c) 2023, Google LLC
+ *
+ * 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 <stdio.h>
+#include <string.h>
+
+#include <openssl/sha.h>
+
+#include "./params.h"
+#include "./spx_util.h"
+#include "./thash.h"
+
+static void spx_thash(uint8_t *output, const uint8_t *input,
+                      size_t input_blocks, const uint8_t pk_seed[SPX_N],
+                      uint8_t addr[32]) {
+  uint8_t hash[32];
+  SHA256_CTX sha256;
+  SHA256_Init(&sha256);
+
+  // Process pubseed with padding to full block.
+  // TODO: This could be precomputed instead as it will be the same across all
+  // hash calls.
+  uint8_t padded_pk_seed[64] = {0};
+  memcpy(padded_pk_seed, pk_seed, SPX_N);
+
+  SHA256_Update(&sha256, padded_pk_seed, sizeof(padded_pk_seed));
+  SHA256_Update(&sha256, addr, SPX_SHA256_ADDR_BYTES);
+  SHA256_Update(&sha256, input, input_blocks * SPX_N);
+
+  SHA256_Final(hash, &sha256);
+  memcpy(output, hash, SPX_N);
+}
+
+void spx_thash_f(uint8_t *output, const uint8_t input[SPX_N],
+                 const uint8_t pk_seed[SPX_N], uint8_t addr[32]) {
+  spx_thash(output, input, 1, pk_seed, addr);
+}
+
+void spx_thash_h(uint8_t *output, const uint8_t input[2 * SPX_N],
+                 const uint8_t pk_seed[SPX_N], uint8_t addr[32]) {
+  spx_thash(output, input, 2, pk_seed, addr);
+}
+
+void spx_thash_hmsg(uint8_t *output, const uint8_t r[SPX_N],
+                    const uint8_t pk_seed[SPX_N], const uint8_t pk_root[SPX_N],
+                    const uint8_t *msg, size_t msg_len) {
+  // MGF1-SHA-256(R || PK.seed || SHA-256(R || PK.seed || PK.root || M), m)
+  // input_buffer stores R || PK_SEED || SHA256(..) || 4-byte index
+  uint8_t input_buffer[2 * SPX_N + 32 + 4] = {0};
+  memcpy(input_buffer, r, SPX_N);
+  memcpy(input_buffer + SPX_N, pk_seed, SPX_N);
+
+  // Inner hash
+  SHA256_CTX ctx;
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, r, SPX_N);
+  SHA256_Update(&ctx, pk_seed, SPX_N);
+  SHA256_Update(&ctx, pk_root, SPX_N);
+  SHA256_Update(&ctx, msg, msg_len);
+  // Write directly into the input buffer
+  SHA256_Final(input_buffer + 2 * SPX_N, &ctx);
+
+  // MGF1-SHA-256
+  uint8_t output_buffer[3 * 32];
+  // Need to call SHA256 3 times for message digest.
+  static_assert(SPX_DIGEST_SIZE <= sizeof(output_buffer),
+                "not enough room for hashes");
+  SHA256(input_buffer, sizeof(input_buffer), output_buffer);
+  input_buffer[2 * SPX_N + 32 + 3] = 1;
+  SHA256(input_buffer, sizeof(input_buffer), output_buffer + 32);
+  input_buffer[2 * SPX_N + 32 + 3] = 2;
+  SHA256(input_buffer, sizeof(input_buffer), output_buffer + 64);
+
+  memcpy(output, output_buffer, SPX_DIGEST_SIZE);
+}
+
+void spx_thash_prf(uint8_t *output, const uint8_t pk_seed[SPX_N],
+                   const uint8_t sk_seed[SPX_N], uint8_t addr[32]) {
+  spx_thash(output, sk_seed, 1, pk_seed, addr);
+}
+
+void spx_thash_prfmsg(uint8_t *output, const uint8_t sk_prf[SPX_N],
+                      const uint8_t opt_rand[SPX_N], const uint8_t *msg,
+                      size_t msg_len) {
+  // Compute HMAC-SHA256(sk_prf, opt_rand || msg). We inline HMAC to avoid an
+  // allocation.
+  uint8_t hmac_key[SHA256_CBLOCK] = {0};
+  static_assert(SPX_N <= SHA256_CBLOCK, "HMAC key is larger than block size");
+  memcpy(hmac_key, sk_prf, SPX_N);
+  for (size_t i = 0; i < sizeof(hmac_key); i++) {
+    hmac_key[i] ^= 0x36;
+  }
+
+  uint8_t hash[SHA256_DIGEST_LENGTH];
+  SHA256_CTX ctx;
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, hmac_key, sizeof(hmac_key));
+  SHA256_Update(&ctx, opt_rand, SPX_N);
+  SHA256_Update(&ctx, msg, msg_len);
+  SHA256_Final(hash, &ctx);
+
+  for (size_t i = 0; i < sizeof(hmac_key); i++) {
+    hmac_key[i] ^= 0x36 ^ 0x5c;
+  }
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, hmac_key, sizeof(hmac_key));
+  SHA256_Update(&ctx, hash, sizeof(hash));
+  SHA256_Final(hash, &ctx);
+
+  // Truncate to SPX_N bytes
+  memcpy(output, hash, SPX_N);
+}
+
+void spx_thash_tl(uint8_t *output, const uint8_t input[SPX_WOTS_BYTES],
+                  const uint8_t pk_seed[SPX_N], uint8_t addr[32]) {
+  spx_thash(output, input, SPX_WOTS_LEN, pk_seed, addr);
+}
+
+void spx_thash_tk(uint8_t *output, const uint8_t input[SPX_FORS_TREES * SPX_N],
+                  const uint8_t pk_seed[SPX_N], uint8_t addr[32]) {
+  spx_thash(output, input, SPX_FORS_TREES, pk_seed, addr);
+}

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

@@ -0,0 +1,70 @@
+/* Copyright (c) 2023, Google LLC
+ *
+ * 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_SPX_THASH_H
+#define OPENSSL_HEADER_CRYPTO_SPX_THASH_H
+
+#include <openssl/base.h>
+
+#include "./params.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// Implements F: a hash function takes an n-byte message as input and produces
+// an n-byte output.
+void spx_thash_f(uint8_t *output, const uint8_t input[SPX_N],
+                 const uint8_t pk_seed[SPX_N], uint8_t addr[32]);
+
+// Implements H: a hash function takes a 2*n-byte message as input and produces
+// an n-byte output.
+void spx_thash_h(uint8_t *output, const uint8_t input[2 * SPX_N],
+                 const uint8_t pk_seed[SPX_N], uint8_t addr[32]);
+
+// Implements Hmsg: a hash function used to generate the digest of the message
+// to be signed.
+void spx_thash_hmsg(uint8_t *output, const uint8_t r[SPX_N],
+                    const uint8_t pk_seed[SPX_N], const uint8_t pk_root[SPX_N],
+                    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.
+void spx_thash_prf(uint8_t *output, const uint8_t pk_seed[SPX_N],
+                   const uint8_t sk_seed[SPX_N], uint8_t addr[32]);
+
+// Implements PRF: a pseudo-random function that is used to generate the
+// randomizer r for the randomized hashing of the message to be signed. values
+// in WOTS+ and FORS private keys.
+void spx_thash_prfmsg(uint8_t *output, const uint8_t sk_prf[SPX_N],
+                      const uint8_t opt_rand[SPX_N], const uint8_t *msg,
+                      size_t msg_len);
+
+// Implements Tl: a hash function that maps an l*n-byte message to an n-byte
+// message.
+void spx_thash_tl(uint8_t *output, const uint8_t input[SPX_WOTS_BYTES],
+                  const uint8_t pk_seed[SPX_N], uint8_t addr[32]);
+
+// Implements Tk: a hash function that maps a k*n-byte message to an n-byte
+// message.
+void spx_thash_tk(uint8_t *output, const uint8_t input[SPX_FORS_TREES * SPX_N],
+                  const uint8_t pk_seed[SPX_N], uint8_t addr[32]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_CRYPTO_SPX_THASH_H

data/third_party/boringssl-with-bazel/src/crypto/spx/wots.c

@@ -0,0 +1,135 @@
+/* Copyright (c) 2023, Google LLC
+ *
+ * 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 <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "./address.h"
+#include "./params.h"
+#include "./spx_util.h"
+#include "./thash.h"
+#include "./wots.h"
+
+// Chaining function used in WOTS+.
+static void chain(uint8_t *output, const uint8_t *input, uint32_t start,
+                  uint32_t steps, const uint8_t *pub_seed, uint8_t addr[32]) {
+  memcpy(output, input, SPX_N);
+
+  for (size_t i = start; i < (start + steps) && i < SPX_WOTS_W; ++i) {
+    spx_set_hash_addr(addr, i);
+    spx_thash_f(output, output, pub_seed, addr);
+  }
+}
+
+void spx_wots_pk_from_sig(uint8_t *pk, const uint8_t *sig, const uint8_t *msg,
+                          const uint8_t pub_seed[SPX_N], uint8_t addr[32]) {
+  uint8_t tmp[SPX_WOTS_BYTES];
+  uint8_t wots_pk_addr[32];
+  memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
+
+  // Convert message to base w
+  uint32_t base_w_msg[SPX_WOTS_LEN];
+  spx_base_b(base_w_msg, SPX_WOTS_LEN1, msg, /*log2_b=*/SPX_WOTS_LOG_W);
+
+  // Compute checksum
+  uint64_t csum = 0;
+  for (size_t i = 0; i < SPX_WOTS_LEN1; ++i) {
+    csum += SPX_WOTS_W - 1 - base_w_msg[i];
+  }
+
+  // Convert csum to base w as in Algorithm 7, Line 9
+  uint8_t csum_bytes[(SPX_WOTS_LEN2 * SPX_WOTS_LOG_W + 7) / 8];
+  csum = csum << ((8 - ((SPX_WOTS_LEN2 * SPX_WOTS_LOG_W)) % 8) % 8);
+  spx_uint64_to_len_bytes(csum_bytes, sizeof(csum_bytes), csum);
+
+  // Write the base w representation of csum to the end of the message.
+  spx_base_b(base_w_msg + SPX_WOTS_LEN1, SPX_WOTS_LEN2, csum_bytes,
+             /*log2_b=*/SPX_WOTS_LOG_W);
+
+  // Compute chains
+  for (size_t i = 0; i < SPX_WOTS_LEN; ++i) {
+    spx_set_chain_addr(addr, i);
+    chain(tmp + i * SPX_N, sig + i * SPX_N, base_w_msg[i],
+          SPX_WOTS_W - 1 - base_w_msg[i], pub_seed, addr);
+  }
+
+  // Compress pk
+  spx_set_type(wots_pk_addr, SPX_ADDR_TYPE_WOTSPK);
+  spx_copy_keypair_addr(wots_pk_addr, addr);
+  spx_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
+}
+
+void spx_wots_pk_gen(uint8_t *pk, const uint8_t sk_seed[SPX_N],
+                     const uint8_t pub_seed[SPX_N], uint8_t addr[32]) {
+  uint8_t tmp[SPX_WOTS_BYTES];
+  uint8_t tmp_sk[SPX_N];
+  uint8_t wots_pk_addr[32], sk_addr[32];
+  memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
+  memcpy(sk_addr, addr, sizeof(sk_addr));
+
+  spx_set_type(sk_addr, SPX_ADDR_TYPE_WOTSPRF);
+  spx_copy_keypair_addr(sk_addr, addr);
+
+  for (size_t i = 0; i < SPX_WOTS_LEN; ++i) {
+    spx_set_chain_addr(sk_addr, i);
+    spx_thash_prf(tmp_sk, pub_seed, sk_seed, sk_addr);
+    spx_set_chain_addr(addr, i);
+    chain(tmp + i * SPX_N, tmp_sk, 0, SPX_WOTS_W - 1, pub_seed, addr);
+  }
+
+  // Compress pk
+  spx_set_type(wots_pk_addr, SPX_ADDR_TYPE_WOTSPK);
+  spx_copy_keypair_addr(wots_pk_addr, addr);
+  spx_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
+}
+
+void spx_wots_sign(uint8_t *sig, const uint8_t msg[SPX_N],
+                   const uint8_t sk_seed[SPX_N], const uint8_t pub_seed[SPX_N],
+                   uint8_t addr[32]) {
+  // Convert message to base w
+  uint32_t base_w_msg[SPX_WOTS_LEN];
+  spx_base_b(base_w_msg, SPX_WOTS_LEN1, msg, /*log2_b=*/SPX_WOTS_LOG_W);
+
+  // Compute checksum
+  uint64_t csum = 0;
+  for (size_t i = 0; i < SPX_WOTS_LEN1; ++i) {
+    csum += SPX_WOTS_W - 1 - base_w_msg[i];
+  }
+
+  // Convert csum to base w as in Algorithm 6, Line 9
+  uint8_t csum_bytes[(SPX_WOTS_LEN2 * SPX_WOTS_LOG_W + 7) / 8];
+  csum = csum << ((8 - ((SPX_WOTS_LEN2 * SPX_WOTS_LOG_W)) % 8) % 8);
+  spx_uint64_to_len_bytes(csum_bytes, sizeof(csum_bytes), csum);
+
+  // Write the base w representation of csum to the end of the message.
+  spx_base_b(base_w_msg + SPX_WOTS_LEN1, SPX_WOTS_LEN2, csum_bytes,
+             /*log2_b=*/SPX_WOTS_LOG_W);
+
+  // Compute chains
+  uint8_t tmp_sk[SPX_N];
+  uint8_t sk_addr[32];
+  memcpy(sk_addr, addr, sizeof(sk_addr));
+  spx_set_type(sk_addr, SPX_ADDR_TYPE_WOTSPRF);
+  spx_copy_keypair_addr(sk_addr, addr);
+
+  for (size_t i = 0; i < SPX_WOTS_LEN; ++i) {
+    spx_set_chain_addr(sk_addr, i);
+    spx_thash_prf(tmp_sk, pub_seed, sk_seed, sk_addr);
+    spx_set_chain_addr(addr, i);
+    chain(sig + i * SPX_N, tmp_sk, 0, base_w_msg[i], pub_seed, addr);
+  }
+}

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

@@ -0,0 +1,45 @@
+/* Copyright (c) 2023, Google LLC
+ *
+ * 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_SPX_WOTS_H
+#define OPENSSL_HEADER_CRYPTO_SPX_WOTS_H
+
+#include <openssl/base.h>
+
+#include "./params.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// Algorithm 5: Generate a WOTS+ public key.
+void spx_wots_pk_gen(uint8_t *pk, const uint8_t sk_seed[SPX_N],
+                     const uint8_t pub_seed[SPX_N], uint8_t addr[32]);
+
+// Algorithm 6: Generate a WOTS+ signature on an n-byte message.
+void spx_wots_sign(uint8_t *sig, const uint8_t msg[SPX_N],
+                   const uint8_t sk_seed[SPX_N], const uint8_t pub_seed[SPX_N],
+                   uint8_t addr[32]);
+
+// Algorithm 7: Compute a WOTS+ public key from a message and its signature.
+void spx_wots_pk_from_sig(uint8_t *pk, const uint8_t *sig, const uint8_t *msg,
+                          const uint8_t pub_seed[SPX_N], uint8_t addr[32]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_CRYPTO_SPX_WOTS_H

data/third_party/boringssl-with-bazel/src/crypto/stack/stack.c

@@ -84,19 +84,16 @@ struct stack_st {
 static const size_t kMinSize = 4;
 
 OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_cmp_func comp) {
-  OPENSSL_STACK *ret = OPENSSL_malloc(sizeof(OPENSSL_STACK));
+  OPENSSL_STACK *ret = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
   if (ret == NULL) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(OPENSSL_STACK));
 
-  ret->data = OPENSSL_malloc(sizeof(void *) * kMinSize);
+  ret->data = OPENSSL_calloc(kMinSize, sizeof(void *));
   if (ret->data == NULL) {
     goto err;
   }
 
-  OPENSSL_memset(ret->data, 0, sizeof(void *) * kMinSize);
-
   ret->comp = comp;
   ret->num_alloc = kMinSize;
 
@@ -370,19 +367,17 @@ OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *sk) {
     return NULL;
   }
 
-  OPENSSL_STACK *ret = OPENSSL_malloc(sizeof(OPENSSL_STACK));
+  OPENSSL_STACK *ret = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
   if (ret == NULL) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(OPENSSL_STACK));
 
-  ret->data = OPENSSL_malloc(sizeof(void *) * sk->num_alloc);
+  ret->data = OPENSSL_memdup(sk->data, sizeof(void *) * sk->num_alloc);
   if (ret->data == NULL) {
     goto err;
   }
 
   ret->num = sk->num;
-  OPENSSL_memcpy(ret->data, sk->data, sizeof(void *) * sk->num);
   ret->sorted = sk->sorted;
   ret->num_alloc = sk->num_alloc;
   ret->comp = sk->comp;

data/third_party/boringssl-with-bazel/src/crypto/trust_token/pmbtoken.c

@@ -799,18 +799,12 @@ static int pmbtoken_sign(const PMBTOKEN_METHOD *method,
     return 0;
   }
 
-  if (num_to_issue > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      num_to_issue > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return 0;
-  }
-
   int ret = 0;
-  EC_JACOBIAN *Tps = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Sps = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wps = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wsps = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_malloc(num_to_issue * sizeof(EC_SCALAR));
+  EC_JACOBIAN *Tps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Sps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Wps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Wsps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_SCALAR *es = OPENSSL_calloc(num_to_issue, sizeof(EC_SCALAR));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
   if (!Tps ||
@@ -940,19 +934,13 @@ static STACK_OF(TRUST_TOKEN) *pmbtoken_unblind(
     return NULL;
   }
 
-  if (count > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      count > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return NULL;
-  }
-
   int ok = 0;
   STACK_OF(TRUST_TOKEN) *ret = sk_TRUST_TOKEN_new_null();
-  EC_JACOBIAN *Tps = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Sps = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wps = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wsps = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_malloc(count * sizeof(EC_SCALAR));
+  EC_JACOBIAN *Tps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Sps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Wps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Wsps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_SCALAR *es = OPENSSL_calloc(count, sizeof(EC_SCALAR));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
   if (ret == NULL ||

data/third_party/boringssl-with-bazel/src/crypto/trust_token/trust_token.c

@@ -118,11 +118,10 @@ void TRUST_TOKEN_PRETOKEN_free(TRUST_TOKEN_PRETOKEN *pretoken) {
 }
 
 TRUST_TOKEN *TRUST_TOKEN_new(const uint8_t *data, size_t len) {
-  TRUST_TOKEN *ret = OPENSSL_malloc(sizeof(TRUST_TOKEN));
+  TRUST_TOKEN *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN));
   if (ret == NULL) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(TRUST_TOKEN));
   ret->data = OPENSSL_memdup(data, len);
   if (len != 0 && ret->data == NULL) {
     OPENSSL_free(ret);
@@ -205,11 +204,10 @@ TRUST_TOKEN_CLIENT *TRUST_TOKEN_CLIENT_new(const TRUST_TOKEN_METHOD *method,
     return NULL;
   }
 
-  TRUST_TOKEN_CLIENT *ret = OPENSSL_malloc(sizeof(TRUST_TOKEN_CLIENT));
+  TRUST_TOKEN_CLIENT *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN_CLIENT));
   if (ret == NULL) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(TRUST_TOKEN_CLIENT));
   ret->method = method;
   ret->max_batchsize = (uint16_t)max_batchsize;
   return ret;
@@ -446,11 +444,10 @@ TRUST_TOKEN_ISSUER *TRUST_TOKEN_ISSUER_new(const TRUST_TOKEN_METHOD *method,
     return NULL;
   }
 
-  TRUST_TOKEN_ISSUER *ret = OPENSSL_malloc(sizeof(TRUST_TOKEN_ISSUER));
+  TRUST_TOKEN_ISSUER *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN_ISSUER));
   if (ret == NULL) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(TRUST_TOKEN_ISSUER));
   ret->method = method;
   ret->max_batchsize = (uint16_t)max_batchsize;
   return ret;

data/third_party/boringssl-with-bazel/src/crypto/trust_token/voprf.c

@@ -483,16 +483,10 @@ static int voprf_sign_tt(const VOPRF_METHOD *method,
     return 0;
   }
 
-  if (num_to_issue > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      num_to_issue > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return 0;
-  }
-
   int ret = 0;
-  EC_JACOBIAN *BTs = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Zs = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_malloc(num_to_issue * sizeof(EC_SCALAR));
+  EC_JACOBIAN *BTs = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Zs = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_SCALAR *es = OPENSSL_calloc(num_to_issue, sizeof(EC_SCALAR));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
   if (!BTs ||
@@ -582,17 +576,11 @@ static STACK_OF(TRUST_TOKEN) *voprf_unblind_tt(
     return NULL;
   }
 
-  if (count > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      count > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return NULL;
-  }
-
   int ok = 0;
   STACK_OF(TRUST_TOKEN) *ret = sk_TRUST_TOKEN_new_null();
-  EC_JACOBIAN *BTs = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Zs = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_malloc(count * sizeof(EC_SCALAR));
+  EC_JACOBIAN *BTs = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Zs = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_SCALAR *es = OPENSSL_calloc(count, sizeof(EC_SCALAR));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
   if (ret == NULL ||
@@ -868,16 +856,10 @@ static int voprf_sign_impl(const VOPRF_METHOD *method,
     return 0;
   }
 
-  if (num_to_issue > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      num_to_issue > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return 0;
-  }
-
   int ret = 0;
-  EC_JACOBIAN *BTs = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Zs = OPENSSL_malloc(num_to_issue * sizeof(EC_JACOBIAN));
-  EC_SCALAR *dis = OPENSSL_malloc(num_to_issue * sizeof(EC_SCALAR));
+  EC_JACOBIAN *BTs = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Zs = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
+  EC_SCALAR *dis = OPENSSL_calloc(num_to_issue, sizeof(EC_SCALAR));
   if (!BTs || !Zs || !dis) {
     goto err;
   }
@@ -984,17 +966,11 @@ static STACK_OF(TRUST_TOKEN) *voprf_unblind(
     return NULL;
   }
 
-  if (count > ((size_t)-1) / sizeof(EC_JACOBIAN) ||
-      count > ((size_t)-1) / sizeof(EC_SCALAR)) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW);
-    return NULL;
-  }
-
   int ok = 0;
   STACK_OF(TRUST_TOKEN) *ret = sk_TRUST_TOKEN_new_null();
-  EC_JACOBIAN *BTs = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Zs = OPENSSL_malloc(count * sizeof(EC_JACOBIAN));
-  EC_SCALAR *dis = OPENSSL_malloc(count * sizeof(EC_SCALAR));
+  EC_JACOBIAN *BTs = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_JACOBIAN *Zs = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
+  EC_SCALAR *dis = OPENSSL_calloc(count, sizeof(EC_SCALAR));
   if (ret == NULL || !BTs || !Zs || !dis) {
     goto err;
   }

data/third_party/boringssl-with-bazel/src/crypto/x509/algorithm.c

@@ -116,8 +116,7 @@ int x509_digest_sign_algorithm(EVP_MD_CTX *ctx, X509_ALGOR *algor) {
   // it.
   int paramtype =
       (EVP_PKEY_id(pkey) == EVP_PKEY_RSA) ? V_ASN1_NULL : V_ASN1_UNDEF;
-  X509_ALGOR_set0(algor, OBJ_nid2obj(sign_nid), paramtype, NULL);
-  return 1;
+  return X509_ALGOR_set0(algor, OBJ_nid2obj(sign_nid), paramtype, NULL);
 }
 
 int x509_digest_verify_init(EVP_MD_CTX *ctx, const X509_ALGOR *sigalg,

data/third_party/boringssl-with-bazel/src/crypto/x509/asn1_gen.c

@@ -65,11 +65,9 @@
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
 #include <openssl/obj.h>
-#include <openssl/x509v3.h>
 
 #include "../conf/internal.h"
 #include "../internal.h"
-#include "../x509v3/internal.h"
 #include "internal.h"