grpc 1.60.0 → 1.62.0

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

@@ -211,7 +211,8 @@ void OPENSSL_cpuid_setup(void) {
 
     // Clear the XSAVE bit on Knights Landing to mimic Silvermont. This enables
     // some Silvermont-specific codepaths which perform better. See OpenSSL
-    // commit 64d92d74985ebb3d0be58a9718f9e080a14a8e7f.
+    // commit 64d92d74985ebb3d0be58a9718f9e080a14a8e7f and
+    // |CRYPTO_cpu_perf_is_like_silvermont|.
     if ((eax & 0x0fff0ff0) == 0x00050670 /* Knights Landing */ ||
         (eax & 0x0fff0ff0) == 0x00080650 /* Knights Mill (per SDE) */) {
       ecx &= ~(1u << 26);
@@ -238,7 +239,8 @@ void OPENSSL_cpuid_setup(void) {
     // Clear AVX2 and AVX512* bits.
     //
     // TODO(davidben): Should bits 17 and 26-28 also be cleared? Upstream
-    // doesn't clear those.
+    // doesn't clear those. See the comments in
+    // |CRYPTO_hardware_supports_XSAVE|.
     extended_features[0] &=
         ~((1u << 5) | (1u << 16) | (1u << 21) | (1u << 30) | (1u << 31));
   }

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

@@ -78,6 +78,11 @@ HIDDEN uint8_t BORINGSSL_function_hit[7] = {0};
 // This value must be explicitly initialized to zero. See similar comment above.
 HIDDEN uint32_t OPENSSL_ia32cap_P[4] = {0};
 
+uint32_t OPENSSL_get_ia32cap(int idx) {
+  CRYPTO_library_init();
+  return OPENSSL_ia32cap_P[idx];
+}
+
 #elif defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
 
 #include <openssl/arm_arch.h>
@@ -116,10 +121,16 @@ HIDDEN uint32_t OPENSSL_armcap_P =
 HIDDEN uint32_t OPENSSL_armcap_P = 0;
 
 uint32_t *OPENSSL_get_armcap_pointer_for_test(void) {
+  CRYPTO_library_init();
   return &OPENSSL_armcap_P;
 }
 #endif
 
+uint32_t OPENSSL_get_armcap(void) {
+  CRYPTO_library_init();
+  return OPENSSL_armcap_P;
+}
+
 #endif
 
 #if defined(BORINGSSL_FIPS)

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

@@ -1906,6 +1906,8 @@ int ED25519_sign(uint8_t out_sig[64], const uint8_t *message,
   x25519_sc_reduce(hram);
   sc_muladd(out_sig + 32, hram, az, nonce);
 
+  // The signature is computed from the private key, but is public.
+  CONSTTIME_DECLASSIFY(out_sig, 64);
   return 1;
 }
 
@@ -1983,6 +1985,8 @@ void ED25519_keypair_from_seed(uint8_t out_public_key[32],
   ge_p3 A;
   x25519_ge_scalarmult_base(&A, az);
   ge_p3_tobytes(out_public_key, &A);
+  // The public key is derived from the private key, but it is public.
+  CONSTTIME_DECLASSIFY(out_public_key, 32);
 
   OPENSSL_memcpy(out_private_key, seed, 32);
   OPENSSL_memcpy(out_private_key + 32, out_public_key, 32);

data/third_party/boringssl-with-bazel/src/crypto/curve25519/spake25519.c

@@ -272,12 +272,11 @@ static const uint8_t kSpakeMSmallPrecomp[15 * 2 * 32] = {
 SPAKE2_CTX *SPAKE2_CTX_new(enum spake2_role_t my_role,
                            const uint8_t *my_name, size_t my_name_len,
                            const uint8_t *their_name, size_t their_name_len) {
-  SPAKE2_CTX *ctx = OPENSSL_malloc(sizeof(SPAKE2_CTX));
+  SPAKE2_CTX *ctx = OPENSSL_zalloc(sizeof(SPAKE2_CTX));
   if (ctx == NULL) {
     return NULL;
   }
 
-  OPENSSL_memset(ctx, 0, sizeof(SPAKE2_CTX));
   ctx->my_role = my_role;
 
   CBS my_name_cbs, their_name_cbs;

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

@@ -61,6 +61,91 @@
 #include "internal.h"
 
 
+/* IP and FP
+ * The problem is more of a geometric problem that random bit fiddling.
+ 0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
+ 8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
+16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
+24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
+
+32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
+40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
+48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
+56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
+
+The output has been subject to swaps of the form
+0 1 -> 3 1 but the odd and even bits have been put into
+2 3    2 0
+different words.  The main trick is to remember that
+t=((l>>size)^r)&(mask);
+r^=t;
+l^=(t<<size);
+can be used to swap and move bits between words.
+
+So l =  0  1  2  3  r = 16 17 18 19
+        4  5  6  7      20 21 22 23
+        8  9 10 11      24 25 26 27
+       12 13 14 15      28 29 30 31
+becomes (for size == 2 and mask == 0x3333)
+   t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
+         6^20  7^21 -- --        4  5 20 21       6  7 22 23
+        10^24 11^25 -- --        8  9 24 25      10 11 24 25
+        14^28 15^29 -- --       12 13 28 29      14 15 28 29
+
+Thanks for hints from Richard Outerbridge - he told me IP&FP
+could be done in 15 xor, 10 shifts and 5 ands.
+When I finally started to think of the problem in 2D
+I first got ~42 operations without xors.  When I remembered
+how to use xors :-) I got it to its final state.
+*/
+#define PERM_OP(a, b, t, n, m)          \
+  do {                                  \
+    (t) = ((((a) >> (n)) ^ (b)) & (m)); \
+    (b) ^= (t);                         \
+    (a) ^= ((t) << (n));                \
+  } while (0)
+
+#define IP(l, r)                        \
+  do {                                  \
+    uint32_t tt;                        \
+    PERM_OP(r, l, tt, 4, 0x0f0f0f0fL);  \
+    PERM_OP(l, r, tt, 16, 0x0000ffffL); \
+    PERM_OP(r, l, tt, 2, 0x33333333L);  \
+    PERM_OP(l, r, tt, 8, 0x00ff00ffL);  \
+    PERM_OP(r, l, tt, 1, 0x55555555L);  \
+  } while (0)
+
+#define FP(l, r)                        \
+  do {                                  \
+    uint32_t tt;                        \
+    PERM_OP(l, r, tt, 1, 0x55555555L);  \
+    PERM_OP(r, l, tt, 8, 0x00ff00ffL);  \
+    PERM_OP(l, r, tt, 2, 0x33333333L);  \
+    PERM_OP(r, l, tt, 16, 0x0000ffffL); \
+    PERM_OP(l, r, tt, 4, 0x0f0f0f0fL);  \
+  } while (0)
+
+#define LOAD_DATA(ks, R, S, u, t, E0, E1) \
+  do {                                    \
+    (u) = (R) ^ (ks)->subkeys[S][0];      \
+    (t) = (R) ^ (ks)->subkeys[S][1];      \
+  } while (0)
+
+#define D_ENCRYPT(ks, LL, R, S)                                                \
+  do {                                                                         \
+    LOAD_DATA(ks, R, S, u, t, E0, E1);                                         \
+    t = CRYPTO_rotr_u32(t, 4);                                                 \
+    (LL) ^=                                                                    \
+        DES_SPtrans[0][(u >> 2L) & 0x3f] ^ DES_SPtrans[2][(u >> 10L) & 0x3f] ^ \
+        DES_SPtrans[4][(u >> 18L) & 0x3f] ^                                    \
+        DES_SPtrans[6][(u >> 26L) & 0x3f] ^ DES_SPtrans[1][(t >> 2L) & 0x3f] ^ \
+        DES_SPtrans[3][(t >> 10L) & 0x3f] ^                                    \
+        DES_SPtrans[5][(t >> 18L) & 0x3f] ^ DES_SPtrans[7][(t >> 26L) & 0x3f]; \
+  } while (0)
+
+#define ITERATIONS 16
+#define HALF_ITERATIONS 8
+
 static const uint32_t des_skb[8][64] = {
     {  // for C bits (numbered as per FIPS 46) 1 2 3 4 5 6
      0x00000000, 0x00000010, 0x20000000, 0x20000010, 0x00010000,
@@ -378,7 +463,8 @@ void DES_set_odd_parity(DES_cblock *key) {
   }
 }
 
-static void DES_encrypt1(uint32_t *data, const DES_key_schedule *ks, int enc) {
+static void DES_encrypt1(uint32_t data[2], const DES_key_schedule *ks,
+                         int enc) {
   uint32_t l, r, t, u;
 
   r = data[0];
@@ -442,7 +528,8 @@ static void DES_encrypt1(uint32_t *data, const DES_key_schedule *ks, int enc) {
   data[1] = r;
 }
 
-static void DES_encrypt2(uint32_t *data, const DES_key_schedule *ks, int enc) {
+static void DES_encrypt2(uint32_t data[2], const DES_key_schedule *ks,
+                         int enc) {
   uint32_t l, r, t, u;
 
   r = data[0];
@@ -499,7 +586,7 @@ static void DES_encrypt2(uint32_t *data, const DES_key_schedule *ks, int enc) {
   data[1] = CRYPTO_rotr_u32(r, 3);
 }
 
-void DES_encrypt3(uint32_t *data, const DES_key_schedule *ks1,
+void DES_encrypt3(uint32_t data[2], const DES_key_schedule *ks1,
                   const DES_key_schedule *ks2, const DES_key_schedule *ks3) {
   uint32_t l, r;
 
@@ -508,9 +595,9 @@ void DES_encrypt3(uint32_t *data, const DES_key_schedule *ks1,
   IP(l, r);
   data[0] = l;
   data[1] = r;
-  DES_encrypt2((uint32_t *)data, ks1, DES_ENCRYPT);
-  DES_encrypt2((uint32_t *)data, ks2, DES_DECRYPT);
-  DES_encrypt2((uint32_t *)data, ks3, DES_ENCRYPT);
+  DES_encrypt2(data, ks1, DES_ENCRYPT);
+  DES_encrypt2(data, ks2, DES_DECRYPT);
+  DES_encrypt2(data, ks3, DES_ENCRYPT);
   l = data[0];
   r = data[1];
   FP(r, l);
@@ -518,7 +605,7 @@ void DES_encrypt3(uint32_t *data, const DES_key_schedule *ks1,
   data[1] = r;
 }
 
-void DES_decrypt3(uint32_t *data, const DES_key_schedule *ks1,
+void DES_decrypt3(uint32_t data[2], const DES_key_schedule *ks1,
                   const DES_key_schedule *ks2, const DES_key_schedule *ks3) {
   uint32_t l, r;
 
@@ -527,9 +614,9 @@ void DES_decrypt3(uint32_t *data, const DES_key_schedule *ks1,
   IP(l, r);
   data[0] = l;
   data[1] = r;
-  DES_encrypt2((uint32_t *)data, ks3, DES_DECRYPT);
-  DES_encrypt2((uint32_t *)data, ks2, DES_ENCRYPT);
-  DES_encrypt2((uint32_t *)data, ks1, DES_DECRYPT);
+  DES_encrypt2(data, ks3, DES_DECRYPT);
+  DES_encrypt2(data, ks2, DES_ENCRYPT);
+  DES_encrypt2(data, ks1, DES_DECRYPT);
   l = data[0];
   r = data[1];
   FP(r, l);
@@ -576,7 +663,7 @@ void DES_ncbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
       tin[0] = tin0;
       tin1 ^= tout1;
       tin[1] = tin1;
-      DES_encrypt1((uint32_t *)tin, schedule, DES_ENCRYPT);
+      DES_encrypt1(tin, schedule, DES_ENCRYPT);
       tout0 = tin[0];
       l2c(tout0, out);
       tout1 = tin[1];
@@ -588,7 +675,7 @@ void DES_ncbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
       tin[0] = tin0;
       tin1 ^= tout1;
       tin[1] = tin1;
-      DES_encrypt1((uint32_t *)tin, schedule, DES_ENCRYPT);
+      DES_encrypt1(tin, schedule, DES_ENCRYPT);
       tout0 = tin[0];
       l2c(tout0, out);
       tout1 = tin[1];
@@ -605,7 +692,7 @@ void DES_ncbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
       tin[0] = tin0;
       c2l(in, tin1);
       tin[1] = tin1;
-      DES_encrypt1((uint32_t *)tin, schedule, DES_DECRYPT);
+      DES_encrypt1(tin, schedule, DES_DECRYPT);
       tout0 = tin[0] ^ xor0;
       tout1 = tin[1] ^ xor1;
       l2c(tout0, out);
@@ -618,7 +705,7 @@ void DES_ncbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
       tin[0] = tin0;
       c2l(in, tin1);
       tin[1] = tin1;
-      DES_encrypt1((uint32_t *)tin, schedule, DES_DECRYPT);
+      DES_encrypt1(tin, schedule, DES_DECRYPT);
       tout0 = tin[0] ^ xor0;
       tout1 = tin[1] ^ xor1;
       l2cn(tout0, tout1, out, len);
@@ -678,7 +765,7 @@ void DES_ede3_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 
       tin[0] = tin0;
       tin[1] = tin1;
-      DES_encrypt3((uint32_t *)tin, ks1, ks2, ks3);
+      DES_encrypt3(tin, ks1, ks2, ks3);
       tout0 = tin[0];
       tout1 = tin[1];
 
@@ -692,7 +779,7 @@ void DES_ede3_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 
       tin[0] = tin0;
       tin[1] = tin1;
-      DES_encrypt3((uint32_t *)tin, ks1, ks2, ks3);
+      DES_encrypt3(tin, ks1, ks2, ks3);
       tout0 = tin[0];
       tout1 = tin[1];
 
@@ -716,7 +803,7 @@ void DES_ede3_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 
       tin[0] = tin0;
       tin[1] = tin1;
-      DES_decrypt3((uint32_t *)tin, ks1, ks2, ks3);
+      DES_decrypt3(tin, ks1, ks2, ks3);
       tout0 = tin[0];
       tout1 = tin[1];
 
@@ -736,7 +823,7 @@ void DES_ede3_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 
       tin[0] = tin0;
       tin[1] = tin1;
-      DES_decrypt3((uint32_t *)tin, ks1, ks2, ks3);
+      DES_decrypt3(tin, ks1, ks2, ks3);
       tout0 = tin[0];
       tout1 = tin[1];
 
@@ -769,16 +856,3 @@ void DES_ede2_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 void DES_set_key_unchecked(const DES_cblock *key, DES_key_schedule *schedule) {
   DES_set_key(key, schedule);
 }
-
-#undef HPERM_OP
-#undef c2l
-#undef l2c
-#undef c2ln
-#undef l2cn
-#undef PERM_OP
-#undef IP
-#undef FP
-#undef LOAD_DATA
-#undef D_ENCRYPT
-#undef ITERATIONS
-#undef HALF_ITERATIONS

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

@@ -58,6 +58,7 @@
 #define OPENSSL_HEADER_DES_INTERNAL_H
 
 #include <openssl/base.h>
+#include <openssl/des.h>
 
 #include "../internal.h"
 
@@ -145,90 +146,18 @@ extern "C" {
     }                                                     \
   } while (0)
 
-/* IP and FP
- * The problem is more of a geometric problem that random bit fiddling.
- 0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
- 8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
-16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
-24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
-
-32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
-40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
-48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
-56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
-
-The output has been subject to swaps of the form
-0 1 -> 3 1 but the odd and even bits have been put into
-2 3    2 0
-different words.  The main trick is to remember that
-t=((l>>size)^r)&(mask);
-r^=t;
-l^=(t<<size);
-can be used to swap and move bits between words.
-
-So l =  0  1  2  3  r = 16 17 18 19
-        4  5  6  7      20 21 22 23
-        8  9 10 11      24 25 26 27
-       12 13 14 15      28 29 30 31
-becomes (for size == 2 and mask == 0x3333)
-   t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
-         6^20  7^21 -- --        4  5 20 21       6  7 22 23
-        10^24 11^25 -- --        8  9 24 25      10 11 24 25
-        14^28 15^29 -- --       12 13 28 29      14 15 28 29
-
-Thanks for hints from Richard Outerbridge - he told me IP&FP
-could be done in 15 xor, 10 shifts and 5 ands.
-When I finally started to think of the problem in 2D
-I first got ~42 operations without xors.  When I remembered
-how to use xors :-) I got it to its final state.
-*/
-#define PERM_OP(a, b, t, n, m)          \
-  do {                                  \
-    (t) = ((((a) >> (n)) ^ (b)) & (m)); \
-    (b) ^= (t);                         \
-    (a) ^= ((t) << (n));                \
-  } while (0)
-
-#define IP(l, r)                        \
-  do {                                  \
-    uint32_t tt;                        \
-    PERM_OP(r, l, tt, 4, 0x0f0f0f0fL);  \
-    PERM_OP(l, r, tt, 16, 0x0000ffffL); \
-    PERM_OP(r, l, tt, 2, 0x33333333L);  \
-    PERM_OP(l, r, tt, 8, 0x00ff00ffL);  \
-    PERM_OP(r, l, tt, 1, 0x55555555L);  \
-  } while (0)
-
-#define FP(l, r)                        \
-  do {                                  \
-    uint32_t tt;                        \
-    PERM_OP(l, r, tt, 1, 0x55555555L);  \
-    PERM_OP(r, l, tt, 8, 0x00ff00ffL);  \
-    PERM_OP(l, r, tt, 2, 0x33333333L);  \
-    PERM_OP(r, l, tt, 16, 0x0000ffffL); \
-    PERM_OP(l, r, tt, 4, 0x0f0f0f0fL);  \
-  } while (0)
 
-#define LOAD_DATA(ks, R, S, u, t, E0, E1) \
-  do {                                    \
-    (u) = (R) ^ (ks)->subkeys[S][0];      \
-    (t) = (R) ^ (ks)->subkeys[S][1];      \
-  } while (0)
+// Private functions.
+//
+// These functions are only exported for use in |decrepit|.
 
-#define D_ENCRYPT(ks, LL, R, S)                                                \
-  do {                                                                         \
-    LOAD_DATA(ks, R, S, u, t, E0, E1);                                         \
-    t = CRYPTO_rotr_u32(t, 4);                                                 \
-    (LL) ^=                                                                    \
-        DES_SPtrans[0][(u >> 2L) & 0x3f] ^ DES_SPtrans[2][(u >> 10L) & 0x3f] ^ \
-        DES_SPtrans[4][(u >> 18L) & 0x3f] ^                                    \
-        DES_SPtrans[6][(u >> 26L) & 0x3f] ^ DES_SPtrans[1][(t >> 2L) & 0x3f] ^ \
-        DES_SPtrans[3][(t >> 10L) & 0x3f] ^                                    \
-        DES_SPtrans[5][(t >> 18L) & 0x3f] ^ DES_SPtrans[7][(t >> 26L) & 0x3f]; \
-  } while (0)
+OPENSSL_EXPORT void DES_decrypt3(uint32_t data[2], const DES_key_schedule *ks1,
+                                 const DES_key_schedule *ks2,
+                                 const DES_key_schedule *ks3);
 
-#define ITERATIONS 16
-#define HALF_ITERATIONS 8
+OPENSSL_EXPORT void DES_encrypt3(uint32_t data[2], const DES_key_schedule *ks1,
+                                 const DES_key_schedule *ks2,
+                                 const DES_key_schedule *ks3);
 
 
 #if defined(__cplusplus)

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

@@ -88,18 +88,14 @@ static int dsa_sign_setup(const DSA *dsa, BN_CTX *ctx_in, BIGNUM **out_kinv,
 static CRYPTO_EX_DATA_CLASS g_ex_data_class = CRYPTO_EX_DATA_CLASS_INIT;
 
 DSA *DSA_new(void) {
-  DSA *dsa = OPENSSL_malloc(sizeof(DSA));
+  DSA *dsa = OPENSSL_zalloc(sizeof(DSA));
   if (dsa == NULL) {
     return NULL;
   }
 
-  OPENSSL_memset(dsa, 0, sizeof(DSA));
-
   dsa->references = 1;
-
   CRYPTO_MUTEX_init(&dsa->method_mont_lock);
   CRYPTO_new_ex_data(&dsa->ex_data);
-
   return dsa;
 }
 
@@ -533,16 +529,7 @@ err:
   return ok;
 }
 
-DSA_SIG *DSA_SIG_new(void) {
-  DSA_SIG *sig;
-  sig = OPENSSL_malloc(sizeof(DSA_SIG));
-  if (!sig) {
-    return NULL;
-  }
-  sig->r = NULL;
-  sig->s = NULL;
-  return sig;
-}
+DSA_SIG *DSA_SIG_new(void) { return OPENSSL_zalloc(sizeof(DSA_SIG)); }
 
 void DSA_SIG_free(DSA_SIG *sig) {
   if (!sig) {

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

@@ -31,15 +31,7 @@ struct engine_st {
   ECDSA_METHOD *ecdsa_method;
 };
 
-ENGINE *ENGINE_new(void) {
-  ENGINE *engine = OPENSSL_malloc(sizeof(ENGINE));
-  if (engine == NULL) {
-    return NULL;
-  }
-
-  OPENSSL_memset(engine, 0, sizeof(ENGINE));
-  return engine;
-}
+ENGINE *ENGINE_new(void) { return OPENSSL_zalloc(sizeof(ENGINE)); }
 
 int ENGINE_free(ENGINE *engine) {
   // Methods are currently required to be static so are not unref'ed.

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

@@ -81,17 +81,13 @@ OPENSSL_DECLARE_ERROR_REASON(EVP, NOT_XOF_OR_INVALID_LENGTH)
 OPENSSL_DECLARE_ERROR_REASON(EVP, EMPTY_PSK)
 
 EVP_PKEY *EVP_PKEY_new(void) {
-  EVP_PKEY *ret;
-
-  ret = OPENSSL_malloc(sizeof(EVP_PKEY));
+  EVP_PKEY *ret = OPENSSL_zalloc(sizeof(EVP_PKEY));
   if (ret == NULL) {
     return NULL;
   }
 
-  OPENSSL_memset(ret, 0, sizeof(EVP_PKEY));
   ret->type = EVP_PKEY_NONE;
   ret->references = 1;
-
   return ret;
 }
 

data/third_party/boringssl-with-bazel/src/crypto/evp/evp_ctx.c

@@ -86,11 +86,10 @@ static const EVP_PKEY_METHOD *evp_pkey_meth_find(int type) {
 
 static EVP_PKEY_CTX *evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *e,
                                       const EVP_PKEY_METHOD *pmeth) {
-  EVP_PKEY_CTX *ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
+  EVP_PKEY_CTX *ret = OPENSSL_zalloc(sizeof(EVP_PKEY_CTX));
   if (!ret) {
     return NULL;
   }
-  OPENSSL_memset(ret, 0, sizeof(EVP_PKEY_CTX));
 
   ret->engine = e;
   ret->pmeth = pmeth;
@@ -156,13 +155,11 @@ EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx) {
     return NULL;
   }
 
-  EVP_PKEY_CTX *ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
+  EVP_PKEY_CTX *ret = OPENSSL_zalloc(sizeof(EVP_PKEY_CTX));
   if (!ret) {
     return NULL;
   }
 
-  OPENSSL_memset(ret, 0, sizeof(EVP_PKEY_CTX));
-
   ret->pmeth = ctx->pmeth;
   ret->engine = ctx->engine;
   ret->operation = ctx->operation;

data/third_party/boringssl-with-bazel/src/crypto/evp/p_ec.c

@@ -80,15 +80,12 @@ typedef struct {
 
 
 static int pkey_ec_init(EVP_PKEY_CTX *ctx) {
-  EC_PKEY_CTX *dctx;
-  dctx = OPENSSL_malloc(sizeof(EC_PKEY_CTX));
+  EC_PKEY_CTX *dctx = OPENSSL_zalloc(sizeof(EC_PKEY_CTX));
   if (!dctx) {
     return 0;
   }
-  OPENSSL_memset(dctx, 0, sizeof(EC_PKEY_CTX));
 
   ctx->data = dctx;
-
   return 1;
 }
 

data/third_party/boringssl-with-bazel/src/crypto/evp/p_hkdf.c

@@ -35,12 +35,11 @@ typedef struct {
 } HKDF_PKEY_CTX;
 
 static int pkey_hkdf_init(EVP_PKEY_CTX *ctx) {
-  HKDF_PKEY_CTX *hctx = OPENSSL_malloc(sizeof(HKDF_PKEY_CTX));
+  HKDF_PKEY_CTX *hctx = OPENSSL_zalloc(sizeof(HKDF_PKEY_CTX));
   if (hctx == NULL) {
     return 0;
   }
 
-  OPENSSL_memset(hctx, 0, sizeof(HKDF_PKEY_CTX));
   if (!CBB_init(&hctx->info, 0)) {
     OPENSSL_free(hctx);
     return 0;

data/third_party/boringssl-with-bazel/src/crypto/evp/p_rsa.c

@@ -97,12 +97,10 @@ typedef struct {
 } RSA_OAEP_LABEL_PARAMS;
 
 static int pkey_rsa_init(EVP_PKEY_CTX *ctx) {
-  RSA_PKEY_CTX *rctx;
-  rctx = OPENSSL_malloc(sizeof(RSA_PKEY_CTX));
+  RSA_PKEY_CTX *rctx = OPENSSL_zalloc(sizeof(RSA_PKEY_CTX));
   if (!rctx) {
     return 0;
   }
-  OPENSSL_memset(rctx, 0, sizeof(RSA_PKEY_CTX));
 
   rctx->nbits = 2048;
   rctx->pad_mode = RSA_PKCS1_PADDING;

data/third_party/boringssl-with-bazel/src/crypto/evp/scrypt.c

@@ -170,12 +170,12 @@ int EVP_PBE_scrypt(const char *password, size_t password_len,
 
   // Allocate and divide up the scratch space. |max_mem| fits in a size_t, which
   // is no bigger than uint64_t, so none of these operations may overflow.
-  static_assert(UINT64_MAX >= ((size_t)-1), "size_t exceeds uint64_t");
+  static_assert(UINT64_MAX >= SIZE_MAX, "size_t exceeds uint64_t");
   size_t B_blocks = p * 2 * r;
   size_t B_bytes = B_blocks * sizeof(block_t);
   size_t T_blocks = 2 * r;
   size_t V_blocks = N * 2 * r;
-  block_t *B = OPENSSL_malloc((B_blocks + T_blocks + V_blocks) * sizeof(block_t));
+  block_t *B = OPENSSL_calloc(B_blocks + T_blocks + V_blocks, sizeof(block_t));
   if (B == NULL) {
     return 0;
   }

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/bn/add.c

@@ -117,10 +117,7 @@ int bn_uadd_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
 
   BN_ULONG carry = bn_add_words(r->d, a->d, b->d, min);
   for (int i = min; i < max; i++) {
-    // |r| and |a| may alias, so use a temporary.
-    BN_ULONG tmp = carry + a->d[i];
-    carry = tmp < a->d[i];
-    r->d[i] = tmp;
+    r->d[i] = CRYPTO_addc_w(a->d[i], 0, carry, &carry);
   }
 
   r->d[max] = carry;
@@ -241,10 +238,7 @@ int bn_usub_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
 
   BN_ULONG borrow = bn_sub_words(r->d, a->d, b->d, b_width);
   for (int i = b_width; i < a->width; i++) {
-    // |r| and |a| may alias, so use a temporary.
-    BN_ULONG tmp = a->d[i];
-    r->d[i] = a->d[i] - borrow;
-    borrow = tmp < r->d[i];
+    r->d[i] = CRYPTO_subc_w(a->d[i], 0, borrow, &borrow);
   }
 
   if (borrow) {

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/bn/bn.c

@@ -361,7 +361,7 @@ int bn_wexpand(BIGNUM *bn, size_t words) {
     return 0;
   }
 
-  a = OPENSSL_malloc(sizeof(BN_ULONG) * words);
+  a = OPENSSL_calloc(words, sizeof(BN_ULONG));
   if (a == NULL) {
     return 0;
   }