grpc 1.63.0 → 1.65.2

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

@@ -56,6 +56,7 @@
 
 #include <openssl/conf.h>
 
+#include <assert.h>
 #include <string.h>
 #include <ctype.h>
 
@@ -65,7 +66,6 @@
 #include <openssl/lhash.h>
 #include <openssl/mem.h>
 
-#include "conf_def.h"
 #include "internal.h"
 #include "../internal.h"
 
@@ -183,6 +183,26 @@ err:
   return NULL;
 }
 
+static int is_comment(char c) { return c == '#'; }
+
+static int is_quote(char c) { return c == '"' || c == '\'' || c == '`'; }
+
+static int is_esc(char c) { return c == '\\'; }
+
+static int is_conf_ws(char c) {
+  // This differs from |OPENSSL_isspace| in that CONF does not accept '\v' and
+  // '\f' as whitespace.
+  return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+static int is_name_char(char c) {
+  // Alphanumeric characters, and a handful of symbols, may appear in value and
+  // section names without escaping.
+  return OPENSSL_isalnum(c) || c == '_' || c == '!' || c == '.' || c == '%' ||
+         c == '&' || c == '*' || c == '+' || c == ',' || c == '/' || c == ';' ||
+         c == '?' || c == '@' || c == '^' || c == '~' || c == '|' || c == '-';
+}
+
 static int str_copy(CONF *conf, char *section, char **pto, char *from) {
   int q, to = 0, len = 0;
   char v;
@@ -199,13 +219,13 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
   }
 
   for (;;) {
-    if (IS_QUOTE(conf, *from)) {
+    if (is_quote(*from)) {
       q = *from;
       from++;
-      while (!IS_EOF(conf, *from) && (*from != q)) {
-        if (IS_ESC(conf, *from)) {
+      while (*from != '\0' && *from != q) {
+        if (is_esc(*from)) {
           from++;
-          if (IS_EOF(conf, *from)) {
+          if (*from == '\0') {
             break;
           }
         }
@@ -214,10 +234,10 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
       if (*from == q) {
         from++;
       }
-    } else if (IS_ESC(conf, *from)) {
+    } else if (is_esc(*from)) {
       from++;
       v = *(from++);
-      if (IS_EOF(conf, v)) {
+      if (v == '\0') {
         break;
       } else if (v == 'r') {
         v = '\r';
@@ -229,11 +249,13 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
         v = '\t';
       }
       buf->data[to++] = v;
-    } else if (IS_EOF(conf, *from)) {
+    } else if (*from == '\0') {
       break;
     } else if (*from == '$') {
       // Historically, $foo would expand to a previously-parsed value. This
-      // feature has been removed as it was unused and is a DoS vector.
+      // feature has been removed as it was unused and is a DoS vector. If
+      // trying to embed '$' in a line, either escape it or wrap the value in
+      // quotes.
       OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_NOT_SUPPORTED);
       goto err;
     } else {
@@ -312,36 +334,39 @@ static int add_string(const CONF *conf, CONF_SECTION *section,
   return 1;
 }
 
-static char *eat_ws(CONF *conf, char *p) {
-  while (IS_WS(conf, *p) && !IS_EOF(conf, *p)) {
+static char *eat_ws(char *p) {
+  while (*p != '\0' && is_conf_ws(*p)) {
     p++;
   }
   return p;
 }
 
-#define scan_esc(conf, p) (((IS_EOF((conf), (p)[1])) ? ((p) + 1) : ((p) + 2)))
+static char *scan_esc(char *p) {
+  assert(p[0] == '\\');
+  return p[1] == '\0' ? p + 1 : p + 2;
+}
 
-static char *eat_alpha_numeric(CONF *conf, char *p) {
+static char *eat_name(char *p) {
   for (;;) {
-    if (IS_ESC(conf, *p)) {
-      p = scan_esc(conf, p);
+    if (is_esc(*p)) {
+      p = scan_esc(p);
       continue;
     }
-    if (!IS_ALPHA_NUMERIC_PUNCT(conf, *p)) {
+    if (!is_name_char(*p)) {
       return p;
     }
     p++;
   }
 }
 
-static char *scan_quote(CONF *conf, char *p) {
+static char *scan_quote(char *p) {
   int q = *p;
 
   p++;
-  while (!IS_EOF(conf, *p) && *p != q) {
-    if (IS_ESC(conf, *p)) {
+  while (*p != '\0' && *p != q) {
+    if (is_esc(*p)) {
       p++;
-      if (IS_EOF(conf, *p)) {
+      if (*p == '\0') {
         return p;
       }
     }
@@ -353,28 +378,28 @@ static char *scan_quote(CONF *conf, char *p) {
   return p;
 }
 
-static void clear_comments(CONF *conf, char *p) {
+static void clear_comments(char *p) {
   for (;;) {
-    if (!IS_WS(conf, *p)) {
+    if (!is_conf_ws(*p)) {
       break;
     }
     p++;
   }
 
   for (;;) {
-    if (IS_COMMENT(conf, *p)) {
+    if (is_comment(*p)) {
       *p = '\0';
       return;
     }
-    if (IS_QUOTE(conf, *p)) {
-      p = scan_quote(conf, p);
+    if (is_quote(*p)) {
+      p = scan_quote(p);
       continue;
     }
-    if (IS_ESC(conf, *p)) {
-      p = scan_esc(conf, p);
+    if (is_esc(*p)) {
+      p = scan_esc(p);
       continue;
     }
-    if (IS_EOF(conf, *p)) {
+    if (*p == '\0') {
       return;
     } else {
       p++;
@@ -454,7 +479,7 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
       // If we have bytes and the last char '\\' and
       // second last char is not '\\'
       p = &(buff->data[bufnum - 1]);
-      if (IS_ESC(conf, p[0]) && ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
+      if (is_esc(p[0]) && ((bufnum <= 1) || !is_esc(p[-1]))) {
         bufnum--;
         again = 1;
       }
@@ -465,20 +490,20 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
     bufnum = 0;
     buf = buff->data;
 
-    clear_comments(conf, buf);
-    s = eat_ws(conf, buf);
-    if (IS_EOF(conf, *s)) {
+    clear_comments(buf);
+    s = eat_ws(buf);
+    if (*s == '\0') {
       continue;  // blank line
     }
     if (*s == '[') {
       char *ss;
 
       s++;
-      start = eat_ws(conf, s);
+      start = eat_ws(s);
       ss = start;
     again:
-      end = eat_alpha_numeric(conf, ss);
-      p = eat_ws(conf, end);
+      end = eat_name(ss);
+      p = eat_ws(end);
       if (*p != ']') {
         if (*p != '\0' && ss != p) {
           ss = p;
@@ -502,27 +527,27 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
     } else {
       pname = s;
       psection = NULL;
-      end = eat_alpha_numeric(conf, s);
+      end = eat_name(s);
       if ((end[0] == ':') && (end[1] == ':')) {
         *end = '\0';
         end += 2;
         psection = pname;
         pname = end;
-        end = eat_alpha_numeric(conf, end);
+        end = eat_name(end);
       }
-      p = eat_ws(conf, end);
+      p = eat_ws(end);
       if (*p != '=') {
         OPENSSL_PUT_ERROR(CONF, CONF_R_MISSING_EQUAL_SIGN);
         goto err;
       }
       *end = '\0';
       p++;
-      start = eat_ws(conf, p);
-      while (!IS_EOF(conf, *p)) {
+      start = eat_ws(p);
+      while (*p != '\0') {
         p++;
       }
       p--;
-      while ((p != start) && (IS_WS(conf, *p))) {
+      while (p != start && is_conf_ws(*p)) {
         p--;
       }
       p++;

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

@@ -143,6 +143,9 @@ void OPENSSL_cpuid_setup(void) {
 
 int CRYPTO_has_broken_NEON(void) { return 0; }
 
-int CRYPTO_needs_hwcap2_workaround(void) { return g_needs_hwcap2_workaround; }
+int CRYPTO_needs_hwcap2_workaround(void) {
+  OPENSSL_init_cpuid();
+  return g_needs_hwcap2_workaround;
+}
 
 #endif  // OPENSSL_ARM && OPENSSL_LINUX && !OPENSSL_STATIC_ARMCAP

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

@@ -208,15 +208,6 @@ void OPENSSL_cpuid_setup(void) {
   // Reserved bit #30 is repurposed to signal an Intel CPU.
   if (is_intel) {
     edx |= (1u << 30);
-
-    // Clear the XSAVE bit on Knights Landing to mimic Silvermont. This enables
-    // some Silvermont-specific codepaths which perform better. See OpenSSL
-    // 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);
-    }
   } else {
     edx &= ~(1u << 30);
   }
@@ -251,12 +242,6 @@ void OPENSSL_cpuid_setup(void) {
     extended_features[0] &= ~(1u << 16);
   }
 
-  // Disable ADX instructions on Knights Landing. See OpenSSL commit
-  // 64d92d74985ebb3d0be58a9718f9e080a14a8e7f.
-  if ((ecx & (1u << 26)) == 0) {
-    extended_features[0] &= ~(1u << 19);
-  }
-
   OPENSSL_ia32cap_P[0] = edx;
   OPENSSL_ia32cap_P[1] = ecx;
   OPENSSL_ia32cap_P[2] = extended_features[0];

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

@@ -24,23 +24,6 @@
 static_assert(sizeof(ossl_ssize_t) == sizeof(size_t),
               "ossl_ssize_t should be the same size as size_t");
 
-#if !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_STATIC_ARMCAP) && \
-    (defined(OPENSSL_X86) || defined(OPENSSL_X86_64) ||            \
-     defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
-// x86, x86_64, and the ARMs need to record the result of a cpuid/getauxval call
-// for the asm to work correctly, unless compiled without asm code.
-#define NEED_CPUID
-
-#else
-
-// Otherwise, don't emit a static initialiser.
-
-#if !defined(BORINGSSL_NO_STATIC_INITIALIZER)
-#define BORINGSSL_NO_STATIC_INITIALIZER
-#endif
-
-#endif  // !NO_ASM && !STATIC_ARMCAP && (X86 || X86_64 || ARM || AARCH64)
-
 
 // Our assembly does not use the GOT to reference symbols, which means
 // references to visible symbols will often require a TEXTREL. This is
@@ -79,7 +62,7 @@ HIDDEN uint8_t BORINGSSL_function_hit[7] = {0};
 HIDDEN uint32_t OPENSSL_ia32cap_P[4] = {0};
 
 uint32_t OPENSSL_get_ia32cap(int idx) {
-  CRYPTO_library_init();
+  OPENSSL_init_cpuid();
   return OPENSSL_ia32cap_P[idx];
 }
 
@@ -121,60 +104,24 @@ 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();
+  OPENSSL_init_cpuid();
   return &OPENSSL_armcap_P;
 }
 #endif
 
 uint32_t OPENSSL_get_armcap(void) {
-  CRYPTO_library_init();
+  OPENSSL_init_cpuid();
   return OPENSSL_armcap_P;
 }
 
 #endif
 
-#if defined(BORINGSSL_FIPS)
-// In FIPS mode, the power-on self-test function calls |CRYPTO_library_init|
-// because we have to ensure that CPUID detection occurs first.
-#define BORINGSSL_NO_STATIC_INITIALIZER
-#endif
-
-#if defined(OPENSSL_WINDOWS) && !defined(BORINGSSL_NO_STATIC_INITIALIZER)
-#define OPENSSL_CDECL __cdecl
-#else
-#define OPENSSL_CDECL
-#endif
-
-#if defined(BORINGSSL_NO_STATIC_INITIALIZER)
-static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
-#elif defined(_MSC_VER)
-#pragma section(".CRT$XCU", read)
-static void __cdecl do_library_init(void);
-__declspec(allocate(".CRT$XCU")) void(*library_init_constructor)(void) =
-    do_library_init;
-#else
-static void do_library_init(void) __attribute__ ((constructor));
-#endif
-
-// do_library_init is the actual initialization function. If
-// BORINGSSL_NO_STATIC_INITIALIZER isn't defined, this is set as a static
-// initializer. Otherwise, it is called by CRYPTO_library_init.
-static void OPENSSL_CDECL do_library_init(void) {
- // WARNING: this function may only configure the capability variables. See the
- // note above about the linker bug.
 #if defined(NEED_CPUID)
-  OPENSSL_cpuid_setup();
+static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
+void OPENSSL_init_cpuid(void) { CRYPTO_once(&once, OPENSSL_cpuid_setup); }
 #endif
-}
 
-void CRYPTO_library_init(void) {
-  // TODO(davidben): It would be tidier if this build knob could be replaced
-  // with an internal lazy-init mechanism that would handle things correctly
-  // in-library. https://crbug.com/542879
-#if defined(BORINGSSL_NO_STATIC_INITIALIZER)
-  CRYPTO_once(&once, do_library_init);
-#endif
-}
+void CRYPTO_library_init(void) {}
 
 int CRYPTO_is_confidential_build(void) {
 #if defined(BORINGSSL_CONFIDENTIAL)
@@ -194,7 +141,7 @@ int CRYPTO_has_asm(void) {
 
 void CRYPTO_pre_sandbox_init(void) {
   // Read from /proc/cpuinfo if needed.
-  CRYPTO_library_init();
+  OPENSSL_init_cpuid();
   // Open /dev/urandom if needed.
   CRYPTO_init_sysrand();
   // Set up MADV_WIPEONFORK state if needed.
@@ -235,7 +182,6 @@ int ENGINE_register_all_complete(void) { return 1; }
 void OPENSSL_load_builtin_modules(void) {}
 
 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
-  CRYPTO_library_init();
   return 1;
 }
 

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

@@ -81,7 +81,7 @@ typedef uint64_t fe_limb_t;
 #define assert_fe(f)                                                    \
   do {                                                                  \
     for (unsigned _assert_fe_i = 0; _assert_fe_i < 5; _assert_fe_i++) { \
-      assert(f[_assert_fe_i] <= UINT64_C(0x8cccccccccccc));             \
+      declassify_assert(f[_assert_fe_i] <= UINT64_C(0x8cccccccccccc));  \
     }                                                                   \
   } while (0)
 
@@ -98,7 +98,7 @@ typedef uint64_t fe_limb_t;
 #define assert_fe_loose(f)                                              \
   do {                                                                  \
     for (unsigned _assert_fe_i = 0; _assert_fe_i < 5; _assert_fe_i++) { \
-      assert(f[_assert_fe_i] <= UINT64_C(0x1a666666666664));            \
+      declassify_assert(f[_assert_fe_i] <= UINT64_C(0x1a666666666664)); \
     }                                                                   \
   } while (0)
 
@@ -120,8 +120,8 @@ typedef uint32_t fe_limb_t;
 #define assert_fe(f)                                                     \
   do {                                                                   \
     for (unsigned _assert_fe_i = 0; _assert_fe_i < 10; _assert_fe_i++) { \
-      assert(f[_assert_fe_i] <=                                          \
-             ((_assert_fe_i & 1) ? 0x2333333u : 0x4666666u));            \
+      declassify_assert(f[_assert_fe_i] <=                               \
+                        ((_assert_fe_i & 1) ? 0x2333333u : 0x4666666u)); \
     }                                                                    \
   } while (0)
 
@@ -138,8 +138,8 @@ typedef uint32_t fe_limb_t;
 #define assert_fe_loose(f)                                               \
   do {                                                                   \
     for (unsigned _assert_fe_i = 0; _assert_fe_i < 10; _assert_fe_i++) { \
-      assert(f[_assert_fe_i] <=                                          \
-             ((_assert_fe_i & 1) ? 0x6999999u : 0xd333332u));            \
+      declassify_assert(f[_assert_fe_i] <=                               \
+                        ((_assert_fe_i & 1) ? 0x6999999u : 0xd333332u)); \
     }                                                                    \
   } while (0)
 
@@ -150,7 +150,7 @@ static_assert(sizeof(fe) == sizeof(fe_limb_t) * FE_NUM_LIMBS,
 
 static void fe_frombytes_strict(fe *h, const uint8_t s[32]) {
   // |fiat_25519_from_bytes| requires the top-most bit be clear.
-  assert((s[31] & 0x80) == 0);
+  declassify_assert((s[31] & 0x80) == 0);
   fiat_25519_from_bytes(h->v, s);
   assert_fe(h->v);
 }

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

@@ -220,6 +220,7 @@ int EVP_marshal_digest_algorithm(CBB *cbb, const EVP_MD *md) {
     return 0;
   }
 
+  // TODO(crbug.com/boringssl/710): Is this correct? See RFC 4055, section 2.1.
   if (!CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
       !CBB_flush(cbb)) {
     return 0;