grpc 1.27.0 → 1.30.2

data/third_party/{boringssl → boringssl-with-bazel/src}/crypto/hrss/internal.h

@@ -36,7 +36,6 @@ struct poly3 {
   struct poly2 s, a;
 };
 
-OPENSSL_EXPORT void HRSS_poly2_rotr_consttime(struct poly2 *p, size_t bits);
 OPENSSL_EXPORT void HRSS_poly3_mul(struct poly3 *out, const struct poly3 *x,
                                    const struct poly3 *y);
 OPENSSL_EXPORT void HRSS_poly3_invert(struct poly3 *out,

data/third_party/{boringssl → boringssl-with-bazel/src}/crypto/internal.h

@@ -200,6 +200,14 @@ typedef __uint128_t uint128_t;
 #define OPENSSL_FALLTHROUGH
 #endif
 
+// For convenience in testing 64-bit generic code, we allow disabling SSE2
+// intrinsics via |OPENSSL_NO_SSE2_FOR_TESTING|. x86_64 always has SSE2
+// available, so we would otherwise need to test such code on a non-x86_64
+// platform.
+#if defined(__SSE2__) && !defined(OPENSSL_NO_SSE2_FOR_TESTING)
+#define OPENSSL_SSE2
+#endif
+
 // buffers_alias returns one if |a| and |b| alias and zero otherwise.
 static inline int buffers_alias(const uint8_t *a, size_t a_len,
                                 const uint8_t *b, size_t b_len) {
@@ -681,6 +689,10 @@ OPENSSL_EXPORT void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class,
 // Endianness conversions.
 
 #if defined(__GNUC__) && __GNUC__ >= 2
+static inline uint16_t CRYPTO_bswap2(uint16_t x) {
+  return __builtin_bswap16(x);
+}
+
 static inline uint32_t CRYPTO_bswap4(uint32_t x) {
   return __builtin_bswap32(x);
 }
@@ -692,7 +704,11 @@ static inline uint64_t CRYPTO_bswap8(uint64_t x) {
 OPENSSL_MSVC_PRAGMA(warning(push, 3))
 #include <stdlib.h>
 OPENSSL_MSVC_PRAGMA(warning(pop))
-#pragma intrinsic(_byteswap_uint64, _byteswap_ulong)
+#pragma intrinsic(_byteswap_uint64, _byteswap_ulong, _byteswap_ushort)
+static inline uint16_t CRYPTO_bswap2(uint16_t x) {
+  return _byteswap_ushort(x);
+}
+
 static inline uint32_t CRYPTO_bswap4(uint32_t x) {
   return _byteswap_ulong(x);
 }
@@ -701,6 +717,10 @@ static inline uint64_t CRYPTO_bswap8(uint64_t x) {
   return _byteswap_uint64(x);
 }
 #else
+static inline uint16_t CRYPTO_bswap2(uint16_t x) {
+  return (x >> 8) | (x << 8);
+}
+
 static inline uint32_t CRYPTO_bswap4(uint32_t x) {
   x = (x >> 16) | (x << 16);
   x = ((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8);

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

@@ -60,6 +60,8 @@
 #include <stdarg.h>
 #include <stdio.h>
 
+#include <openssl/err.h>
+
 #if defined(OPENSSL_WINDOWS)
 OPENSSL_MSVC_PRAGMA(warning(push, 3))
 #include <windows.h>
@@ -82,27 +84,34 @@ static void __asan_unpoison_memory_region(const void *addr, size_t size) {}
 // Windows doesn't really support weak symbols as of May 2019, and Clang on
 // Windows will emit strong symbols instead. See
 // https://bugs.llvm.org/show_bug.cgi?id=37598
-#if defined(__GNUC__) || (defined(__clang__) && !defined(_MSC_VER))
+#if defined(__ELF__) && defined(__GNUC__)
+#define WEAK_SYMBOL_FUNC(rettype, name, args) \
+  rettype name args __attribute__((weak));
+#else
+#define WEAK_SYMBOL_FUNC(rettype, name, args) static rettype(*name) args = NULL;
+#endif
+
 // sdallocx is a sized |free| function. By passing the size (which we happen to
 // always know in BoringSSL), the malloc implementation can save work. We cannot
-// depend on |sdallocx| being available so we declare a wrapper that falls back
-// to |free| as a weak symbol.
+// depend on |sdallocx| being available, however, so it's a weak symbol.
 //
 // This will always be safe, but will only be overridden if the malloc
 // implementation is statically linked with BoringSSL. So, if |sdallocx| is
 // provided in, say, libc.so, we still won't use it because that's dynamically
 // linked. This isn't an ideal result, but its helps in some cases.
-void sdallocx(void *ptr, size_t size, int flags);
+WEAK_SYMBOL_FUNC(void, sdallocx, (void *ptr, size_t size, int flags));
 
-__attribute((weak, noinline))
-#else
-static
-#endif
-void sdallocx(void *ptr, size_t size, int flags) {
-  free(ptr);
-}
+// The following two functions are for memory tracking. They are no-ops by
+// default but can be overridden at link time if the application needs to
+// observe heap operations.
+WEAK_SYMBOL_FUNC(void, OPENSSL_track_memory_alloc, (void *ptr, size_t size));
+WEAK_SYMBOL_FUNC(void, OPENSSL_track_memory_free, (void *ptr, size_t size));
 
 void *OPENSSL_malloc(size_t size) {
+  if (size + OPENSSL_MALLOC_PREFIX < size) {
+    return NULL;
+  }
+
   void *ptr = malloc(size + OPENSSL_MALLOC_PREFIX);
   if (ptr == NULL) {
     return NULL;
@@ -111,6 +120,9 @@ void *OPENSSL_malloc(size_t size) {
   *(size_t *)ptr = size;
 
   __asan_poison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
+  if (OPENSSL_track_memory_alloc) {
+    OPENSSL_track_memory_alloc(ptr, size + OPENSSL_MALLOC_PREFIX);
+  }
   return ((uint8_t *)ptr) + OPENSSL_MALLOC_PREFIX;
 }
 
@@ -123,8 +135,15 @@ void OPENSSL_free(void *orig_ptr) {
   __asan_unpoison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
 
   size_t size = *(size_t *)ptr;
+  if (OPENSSL_track_memory_free) {
+    OPENSSL_track_memory_free(ptr, size + OPENSSL_MALLOC_PREFIX);
+  }
   OPENSSL_cleanse(ptr, size + OPENSSL_MALLOC_PREFIX);
-  sdallocx(ptr, size + OPENSSL_MALLOC_PREFIX, 0 /* flags */);
+  if (sdallocx) {
+    sdallocx(ptr, size + OPENSSL_MALLOC_PREFIX, 0 /* flags */);
+  } else {
+    free(ptr);
+  }
 }
 
 void *OPENSSL_realloc(void *orig_ptr, size_t new_size) {
@@ -211,6 +230,9 @@ size_t OPENSSL_strnlen(const char *s, size_t len) {
 }
 
 char *OPENSSL_strdup(const char *s) {
+  if (s == NULL) {
+    return NULL;
+  }
   const size_t len = strlen(s) + 1;
   char *ret = OPENSSL_malloc(len);
   if (ret == NULL) {
@@ -270,3 +292,68 @@ int BIO_snprintf(char *buf, size_t n, const char *format, ...) {
 int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) {
   return vsnprintf(buf, n, format, args);
 }
+
+char *OPENSSL_strndup(const char *str, size_t size) {
+  char *ret;
+  size_t alloc_size;
+
+  if (str == NULL) {
+    return NULL;
+  }
+
+  size = OPENSSL_strnlen(str, size);
+
+  alloc_size = size + 1;
+  if (alloc_size < size) {
+    // overflow
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
+    return NULL;
+  }
+  ret = OPENSSL_malloc(alloc_size);
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
+    return NULL;
+  }
+
+  OPENSSL_memcpy(ret, str, size);
+  ret[size] = '\0';
+  return ret;
+}
+
+size_t OPENSSL_strlcpy(char *dst, const char *src, size_t dst_size) {
+  size_t l = 0;
+
+  for (; dst_size > 1 && *src; dst_size--) {
+    *dst++ = *src++;
+    l++;
+  }
+
+  if (dst_size) {
+    *dst = 0;
+  }
+
+  return l + strlen(src);
+}
+
+size_t OPENSSL_strlcat(char *dst, const char *src, size_t dst_size) {
+  size_t l = 0;
+  for (; dst_size > 0 && *dst; dst_size--, dst++) {
+    l++;
+  }
+  return l + OPENSSL_strlcpy(dst, src, dst_size);
+}
+
+void *OPENSSL_memdup(const void *data, size_t size) {
+  if (size == 0) {
+    return NULL;
+  }
+
+  void *ret = OPENSSL_malloc(size);
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
+    return NULL;
+  }
+
+  OPENSSL_memcpy(ret, data, size);
+  return ret;
+}

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

@@ -61,7 +61,6 @@
 #include <string.h>
 
 #include <openssl/asn1.h>
-#include <openssl/buf.h>
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
 #include <openssl/lhash.h>
@@ -190,7 +189,7 @@ size_t OBJ_length(const ASN1_OBJECT *obj) {
 // an |ASN1_OBJECT|* that we're looking for and |element| is a pointer to an
 // unsigned int in the array.
 static int obj_cmp(const void *key, const void *element) {
-  unsigned nid = *((const unsigned*) element);
+  uint16_t nid = *((const uint16_t *)element);
   const ASN1_OBJECT *a = key;
   const ASN1_OBJECT *b = &kObjects[nid];
 
@@ -203,8 +202,6 @@ static int obj_cmp(const void *key, const void *element) {
 }
 
 int OBJ_obj2nid(const ASN1_OBJECT *obj) {
-  const unsigned int *nid_ptr;
-
   if (obj == NULL) {
     return NID_undef;
   }
@@ -225,8 +222,9 @@ int OBJ_obj2nid(const ASN1_OBJECT *obj) {
   }
   CRYPTO_STATIC_MUTEX_unlock_read(&global_added_lock);
 
-  nid_ptr = bsearch(obj, kNIDsInOIDOrder, OPENSSL_ARRAY_SIZE(kNIDsInOIDOrder),
-                    sizeof(kNIDsInOIDOrder[0]), obj_cmp);
+  const uint16_t *nid_ptr =
+      bsearch(obj, kNIDsInOIDOrder, OPENSSL_ARRAY_SIZE(kNIDsInOIDOrder),
+              sizeof(kNIDsInOIDOrder[0]), obj_cmp);
   if (nid_ptr == NULL) {
     return NID_undef;
   }
@@ -251,15 +249,13 @@ int OBJ_cbs2nid(const CBS *cbs) {
 // |key| argument is name that we're looking for and |element| is a pointer to
 // an unsigned int in the array.
 static int short_name_cmp(const void *key, const void *element) {
-  const char *name = (const char *) key;
-  unsigned nid = *((unsigned*) element);
+  const char *name = (const char *)key;
+  uint16_t nid = *((const uint16_t *)element);
 
   return strcmp(name, kObjects[nid].sn);
 }
 
 int OBJ_sn2nid(const char *short_name) {
-  const unsigned int *nid_ptr;
-
   CRYPTO_STATIC_MUTEX_lock_read(&global_added_lock);
   if (global_added_by_short_name != NULL) {
     ASN1_OBJECT *match, template;
@@ -273,9 +269,10 @@ int OBJ_sn2nid(const char *short_name) {
   }
   CRYPTO_STATIC_MUTEX_unlock_read(&global_added_lock);
 
-  nid_ptr = bsearch(short_name, kNIDsInShortNameOrder,
-                    OPENSSL_ARRAY_SIZE(kNIDsInShortNameOrder),
-                    sizeof(kNIDsInShortNameOrder[0]), short_name_cmp);
+  const uint16_t *nid_ptr =
+      bsearch(short_name, kNIDsInShortNameOrder,
+              OPENSSL_ARRAY_SIZE(kNIDsInShortNameOrder),
+              sizeof(kNIDsInShortNameOrder[0]), short_name_cmp);
   if (nid_ptr == NULL) {
     return NID_undef;
   }
@@ -287,15 +284,13 @@ int OBJ_sn2nid(const char *short_name) {
 // |key| argument is name that we're looking for and |element| is a pointer to
 // an unsigned int in the array.
 static int long_name_cmp(const void *key, const void *element) {
-  const char *name = (const char *) key;
-  unsigned nid = *((unsigned*) element);
+  const char *name = (const char *)key;
+  uint16_t nid = *((const uint16_t *)element);
 
   return strcmp(name, kObjects[nid].ln);
 }
 
 int OBJ_ln2nid(const char *long_name) {
-  const unsigned int *nid_ptr;
-
   CRYPTO_STATIC_MUTEX_lock_read(&global_added_lock);
   if (global_added_by_long_name != NULL) {
     ASN1_OBJECT *match, template;
@@ -309,9 +304,9 @@ int OBJ_ln2nid(const char *long_name) {
   }
   CRYPTO_STATIC_MUTEX_unlock_read(&global_added_lock);
 
-  nid_ptr = bsearch(long_name, kNIDsInLongNameOrder,
-                    OPENSSL_ARRAY_SIZE(kNIDsInLongNameOrder),
-                    sizeof(kNIDsInLongNameOrder[0]), long_name_cmp);
+  const uint16_t *nid_ptr = bsearch(
+      long_name, kNIDsInLongNameOrder, OPENSSL_ARRAY_SIZE(kNIDsInLongNameOrder),
+      sizeof(kNIDsInLongNameOrder[0]), long_name_cmp);
   if (nid_ptr == NULL) {
     return NID_undef;
   }
@@ -424,7 +419,7 @@ ASN1_OBJECT *OBJ_txt2obj(const char *s, int dont_search_names) {
 }
 
 static int strlcpy_int(char *dst, const char *src, int dst_size) {
-  size_t ret = BUF_strlcpy(dst, src, dst_size < 0 ? 0 : (size_t)dst_size);
+  size_t ret = OPENSSL_strlcpy(dst, src, dst_size < 0 ? 0 : (size_t)dst_size);
   if (ret > INT_MAX) {
     OPENSSL_PUT_ERROR(OBJ, ERR_R_OVERFLOW);
     return -1;

data/third_party/{boringssl → boringssl-with-bazel/src}/crypto/obj/obj_dat.h

@@ -57,7 +57,7 @@
 /* This file is generated by crypto/obj/objects.go. */
 
 
-#define NUM_NID 960
+#define NUM_NID 963
 
 static const uint8_t kObjectData[] = {
     /* NID_rsadsi */
@@ -7111,10 +7111,32 @@ static const uint8_t kObjectData[] = {
     0x01,
     0x0e,
     0x03,
+    /* NID_X25519 */
+    0x2b,
+    0x65,
+    0x6e,
     /* NID_ED25519 */
     0x2b,
     0x65,
     0x70,
+    /* NID_ED448 */
+    0x2b,
+    0x65,
+    0x71,
+    /* NID_X448 */
+    0x2b,
+    0x65,
+    0x6f,
+    /* NID_sha512_256 */
+    0x60,
+    0x86,
+    0x48,
+    0x01,
+    0x65,
+    0x03,
+    0x04,
+    0x02,
+    0x06,
 };
 
 static const ASN1_OBJECT kObjects[NUM_NID] = {
@@ -8743,8 +8765,8 @@ static const ASN1_OBJECT kObjects[NUM_NID] = {
      NID_dhSinglePass_cofactorDH_sha512kdf_scheme, 6, &kObjectData[6169], 0},
     {"dh-std-kdf", "dh-std-kdf", NID_dh_std_kdf, 0, NULL, 0},
     {"dh-cofactor-kdf", "dh-cofactor-kdf", NID_dh_cofactor_kdf, 0, NULL, 0},
-    {"X25519", "X25519", NID_X25519, 0, NULL, 0},
-    {"ED25519", "ED25519", NID_ED25519, 3, &kObjectData[6175], 0},
+    {"X25519", "X25519", NID_X25519, 3, &kObjectData[6175], 0},
+    {"ED25519", "ED25519", NID_ED25519, 3, &kObjectData[6178], 0},
     {"ChaCha20-Poly1305", "chacha20-poly1305", NID_chacha20_poly1305, 0, NULL,
      0},
     {"KxRSA", "kx-rsa", NID_kx_rsa, 0, NULL, 0},
@@ -8756,9 +8778,12 @@ static const ASN1_OBJECT kObjects[NUM_NID] = {
     {"KxANY", "kx-any", NID_kx_any, 0, NULL, 0},
     {"AuthANY", "auth-any", NID_auth_any, 0, NULL, 0},
     {"CECPQ2", "CECPQ2", NID_CECPQ2, 0, NULL, 0},
+    {"ED448", "ED448", NID_ED448, 3, &kObjectData[6181], 0},
+    {"X448", "X448", NID_X448, 3, &kObjectData[6184], 0},
+    {"SHA512-256", "sha512-256", NID_sha512_256, 9, &kObjectData[6187], 0},
 };
 
-static const unsigned kNIDsInShortNameOrder[] = {
+static const uint16_t kNIDsInShortNameOrder[] = {
     364 /* AD_DVCS */,
     419 /* AES-128-CBC */,
     916 /* AES-128-CBC-HMAC-SHA1 */,
@@ -8851,6 +8876,7 @@ static const unsigned kNIDsInShortNameOrder[] = {
     67 /* DSA-old */,
     297 /* DVCS */,
     949 /* ED25519 */,
+    960 /* ED448 */,
     99 /* GN */,
     855 /* HMAC */,
     780 /* HMAC-MD5 */,
@@ -8944,6 +8970,7 @@ static const unsigned kNIDsInShortNameOrder[] = {
     672 /* SHA256 */,
     673 /* SHA384 */,
     674 /* SHA512 */,
+    962 /* SHA512-256 */,
     188 /* SMIME */,
     167 /* SMIME-CAPS */,
     100 /* SN */,
@@ -8952,6 +8979,7 @@ static const unsigned kNIDsInShortNameOrder[] = {
     458 /* UID */,
     0 /* UNDEF */,
     948 /* X25519 */,
+    961 /* X448 */,
     11 /* X500 */,
     378 /* X500algorithms */,
     12 /* X509 */,
@@ -9711,7 +9739,7 @@ static const unsigned kNIDsInShortNameOrder[] = {
     160 /* x509Crl */,
 };
 
-static const unsigned kNIDsInLongNameOrder[] = {
+static const uint16_t kNIDsInLongNameOrder[] = {
     363 /* AD Time Stamping */,
     405 /* ANSI X9.62 */,
     368 /* Acceptable OCSP Responses */,
@@ -9729,6 +9757,7 @@ static const unsigned kNIDsInLongNameOrder[] = {
     392 /* Domain */,
     132 /* E-mail Protection */,
     949 /* ED25519 */,
+    960 /* ED448 */,
     389 /* Enterprises */,
     384 /* Experimental */,
     372 /* Extended OCSP Status */,
@@ -9821,6 +9850,7 @@ static const unsigned kNIDsInLongNameOrder[] = {
     133 /* Time Stamping */,
     375 /* Trust Root */,
     948 /* X25519 */,
+    961 /* X448 */,
     12 /* X509 */,
     402 /* X509v3 AC Targeting */,
     746 /* X509v3 Any Policy */,
@@ -10614,6 +10644,7 @@ static const unsigned kNIDsInLongNameOrder[] = {
     673 /* sha384 */,
     669 /* sha384WithRSAEncryption */,
     674 /* sha512 */,
+    962 /* sha512-256 */,
     670 /* sha512WithRSAEncryption */,
     42 /* shaWithRSAEncryption */,
     52 /* signingTime */,
@@ -10664,7 +10695,7 @@ static const unsigned kNIDsInLongNameOrder[] = {
     125 /* zlib compression */,
 };
 
-static const unsigned kNIDsInOIDOrder[] = {
+static const uint16_t kNIDsInOIDOrder[] = {
     434 /* 0.9 (OBJ_data) */,
     182 /* 1.2 (OBJ_member_body) */,
     379 /* 1.3 (OBJ_org) */,
@@ -10680,7 +10711,10 @@ static const unsigned kNIDsInOIDOrder[] = {
     435 /* 0.9.2342 (OBJ_pss) */,
     183 /* 1.2.840 (OBJ_ISO_US) */,
     381 /* 1.3.6.1 (OBJ_iana) */,
+    948 /* 1.3.101.110 (OBJ_X25519) */,
+    961 /* 1.3.101.111 (OBJ_X448) */,
     949 /* 1.3.101.112 (OBJ_ED25519) */,
+    960 /* 1.3.101.113 (OBJ_ED448) */,
     677 /* 1.3.132 (OBJ_certicom_arc) */,
     394 /* 2.5.1.5 (OBJ_selected_attribute_types) */,
     13 /* 2.5.4.3 (OBJ_commonName) */,
@@ -11370,6 +11404,7 @@ static const unsigned kNIDsInOIDOrder[] = {
     673 /* 2.16.840.1.101.3.4.2.2 (OBJ_sha384) */,
     674 /* 2.16.840.1.101.3.4.2.3 (OBJ_sha512) */,
     675 /* 2.16.840.1.101.3.4.2.4 (OBJ_sha224) */,
+    962 /* 2.16.840.1.101.3.4.2.6 (OBJ_sha512_256) */,
     802 /* 2.16.840.1.101.3.4.3.1 (OBJ_dsa_with_SHA224) */,
     803 /* 2.16.840.1.101.3.4.3.2 (OBJ_dsa_with_SHA256) */,
     71 /* 2.16.840.1.113730.1.1 (OBJ_netscape_cert_type) */,