grpc 1.56.2 → 1.58.0

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

@@ -56,7 +56,7 @@
 
 #include <openssl/bio.h>
 
-#if !defined(OPENSSL_TRUSTY)
+#if !defined(OPENSSL_NO_SOCK)
 
 #include <fcntl.h>
 #include <string.h>
@@ -104,7 +104,7 @@ static int sock_read(BIO *b, char *out, int outl) {
 #endif
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
-    if (bio_fd_should_retry(ret)) {
+    if (bio_socket_should_retry(ret)) {
       BIO_set_retry_read(b);
     }
   }
@@ -120,7 +120,7 @@ static int sock_write(BIO *b, const char *in, int inl) {
 #endif
   BIO_clear_retry_flags(b);
   if (ret <= 0) {
-    if (bio_fd_should_retry(ret)) {
+    if (bio_socket_should_retry(ret)) {
       BIO_set_retry_write(b);
     }
   }
@@ -186,4 +186,4 @@ BIO *BIO_new_socket(int fd, int close_flag) {
   return ret;
 }
 
-#endif  // OPENSSL_TRUSTY
+#endif  // OPENSSL_NO_SOCK

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

@@ -20,7 +20,7 @@
 #include <openssl/bio.h>
 #include <openssl/err.h>
 
-#if !defined(OPENSSL_TRUSTY)
+#if !defined(OPENSSL_NO_SOCK)
 
 #include <fcntl.h>
 #include <string.h>
@@ -121,4 +121,13 @@ int bio_sock_error(int sock) {
   return error;
 }
 
-#endif  // OPENSSL_TRUSTY
+int bio_socket_should_retry(int return_value) {
+#if defined(OPENSSL_WINDOWS)
+  return return_value == -1 && WSAGetLastError() == WSAEWOULDBLOCK;
+#else
+  // On POSIX platforms, sockets and fds are the same.
+  return bio_errno_should_retry(return_value);
+#endif
+}
+
+#endif  // OPENSSL_NO_SOCK

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

@@ -694,7 +694,7 @@ int CBS_is_unsigned_asn1_integer(const CBS *cbs) {
 
 static int add_decimal(CBB *out, uint64_t v) {
   char buf[DECIMAL_SIZE(uint64_t) + 1];
-  BIO_snprintf(buf, sizeof(buf), "%" PRIu64, v);
+  snprintf(buf, sizeof(buf), "%" PRIu64, v);
   return CBB_add_bytes(out, (const uint8_t *)buf, strlen(buf));
 }
 

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

@@ -91,7 +91,25 @@ void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in, size_t in_len,
   }
 #endif
 
-  ChaCha20_ctr32(out, in, in_len, key_ptr, counter_nonce);
+  while (in_len > 0) {
+    // The assembly functions do not have defined overflow behavior. While
+    // overflow is almost always a bug in the caller, we prefer our functions to
+    // behave the same across platforms, so divide into multiple calls to avoid
+    // this case.
+    uint64_t todo = 64 * ((UINT64_C(1) << 32) - counter_nonce[0]);
+    if (todo > in_len) {
+      todo = in_len;
+    }
+
+    ChaCha20_ctr32(out, in, (size_t)todo, key_ptr, counter_nonce);
+    in += todo;
+    out += todo;
+    in_len -= todo;
+
+    // We're either done and will next break out of the loop, or we stopped at
+    // the wraparound point and the counter should continue at zero.
+    counter_nonce[0] = 0;
+  }
 }
 
 #else

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

@@ -32,7 +32,14 @@ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
      defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
 #define CHACHA20_ASM
 
-// ChaCha20_ctr32 is defined in asm/chacha-*.pl.
+// ChaCha20_ctr32 encrypts |in_len| bytes from |in| and writes the result to
+// |out|. If |in| and |out| alias, they must be equal.
+//
+// |counter[0]| is the initial 32-bit block counter, and the remainder is the
+// 96-bit nonce. If the counter overflows, the output is undefined. The function
+// will produce output, but the output may vary by machine and may not be
+// self-consistent. (On some architectures, the assembly implements a mix of
+// 64-bit and 32-bit counters.)
 void ChaCha20_ctr32(uint8_t *out, const uint8_t *in, size_t in_len,
                     const uint32_t key[8], const uint32_t counter[4]);
 #endif

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

@@ -68,21 +68,10 @@
 #include "conf_def.h"
 #include "internal.h"
 #include "../internal.h"
-#include "../lhash/internal.h"
 
 
-DEFINE_LHASH_OF(CONF_VALUE)
-
-struct conf_st {
-  LHASH_OF(CONF_VALUE) *data;
-};
-
 static const char kDefaultSectionName[] = "default";
 
-// The maximum length we can grow a value to after variable expansion. 64k
-// should be more than enough for all reasonable uses.
-#define MAX_CONF_VALUE_LENGTH 65536
-
 static uint32_t conf_value_hash(const CONF_VALUE *v) {
   const uint32_t section_hash = v->section ? OPENSSL_strhash(v->section) : 0;
   const uint32_t name_hash = v->name ? OPENSSL_strhash(v->name) : 0;
@@ -139,24 +128,23 @@ CONF_VALUE *CONF_VALUE_new(void) {
 }
 
 static void value_free_contents(CONF_VALUE *value) {
-  if (value->section) {
-    OPENSSL_free(value->section);
-  }
+  OPENSSL_free(value->section);
   if (value->name) {
     OPENSSL_free(value->name);
-    if (value->value) {
-      OPENSSL_free(value->value);
-    }
+    OPENSSL_free(value->value);
   } else {
-    if (value->value) {
-      sk_CONF_VALUE_free((STACK_OF(CONF_VALUE)*)value->value);
-    }
+    // TODO(davidben): When |value->name| is NULL, |CONF_VALUE| is actually an
+    // entirely different structure. This is fragile and confusing. Make a
+    // proper |CONF_SECTION| type that doesn't require this.
+    sk_CONF_VALUE_free((STACK_OF(CONF_VALUE) *)value->value);
   }
 }
 
 static void value_free(CONF_VALUE *value) {
-  value_free_contents(value);
-  OPENSSL_free(value);
+  if (value != NULL) {
+    value_free_contents(value);
+    OPENSSL_free(value);
+  }
 }
 
 static void value_free_arg(CONF_VALUE *value, void *arg) { value_free(value); }
@@ -192,28 +180,21 @@ static CONF_VALUE *NCONF_new_section(const CONF *conf, const char *section) {
   if (!lh_CONF_VALUE_insert(conf->data, &old_value, v)) {
     goto err;
   }
-  if (old_value) {
-    value_free(old_value);
-  }
+  value_free(old_value);
   ok = 1;
 
 err:
   if (!ok) {
-    if (sk != NULL) {
-      sk_CONF_VALUE_free(sk);
-    }
-    if (v != NULL) {
-      OPENSSL_free(v);
-    }
+    sk_CONF_VALUE_free(sk);
+    OPENSSL_free(v);
     v = NULL;
   }
   return v;
 }
 
 static int str_copy(CONF *conf, char *section, char **pto, char *from) {
-  int q, r, rr = 0, to = 0, len = 0;
-  char *s, *e, *rp, *rrp, *np, *cp, v;
-  const char *p;
+  int q, to = 0, len = 0;
+  char v;
   BUF_MEM *buf;
 
   buf = BUF_MEM_new();
@@ -242,22 +223,6 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
       if (*from == q) {
         from++;
       }
-    } else if (IS_DQUOTE(conf, *from)) {
-      q = *from;
-      from++;
-      while (!IS_EOF(conf, *from)) {
-        if (*from == q) {
-          if (*(from + 1) == q) {
-            from++;
-          } else {
-            break;
-          }
-        }
-        buf->data[to++] = *(from++);
-      }
-      if (*from == q) {
-        from++;
-      }
     } else if (IS_ESC(conf, *from)) {
       from++;
       v = *(from++);
@@ -276,102 +241,23 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
     } else if (IS_EOF(conf, *from)) {
       break;
     } else if (*from == '$') {
-      // try to expand it
-      rrp = NULL;
-      s = &(from[1]);
-      if (*s == '{') {
-        q = '}';
-      } else if (*s == '(') {
-        q = ')';
-      } else {
-        q = 0;
-      }
-
-      if (q) {
-        s++;
-      }
-      cp = section;
-      e = np = s;
-      while (IS_ALPHA_NUMERIC(conf, *e)) {
-        e++;
-      }
-      if (e[0] == ':' && e[1] == ':') {
-        cp = np;
-        rrp = e;
-        rr = *e;
-        *rrp = '\0';
-        e += 2;
-        np = e;
-        while (IS_ALPHA_NUMERIC(conf, *e)) {
-          e++;
-        }
-      }
-      r = *e;
-      *e = '\0';
-      rp = e;
-      if (q) {
-        if (r != q) {
-          OPENSSL_PUT_ERROR(CONF, CONF_R_NO_CLOSE_BRACE);
-          goto err;
-        }
-        e++;
-      }
-      // So at this point we have
-      // np which is the start of the name string which is
-      //   '\0' terminated.
-      // cp which is the start of the section string which is
-      //   '\0' terminated.
-      // e is the 'next point after'.
-      // r and rr are the chars replaced by the '\0'
-      // rp and rrp is where 'r' and 'rr' came from.
-      p = NCONF_get_string(conf, cp, np);
-      if (rrp != NULL) {
-        *rrp = rr;
-      }
-      *rp = r;
-      if (p == NULL) {
-        OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_HAS_NO_VALUE);
-        goto err;
-      }
-      size_t newsize = strlen(p) + buf->length - (e - from);
-      if (newsize > MAX_CONF_VALUE_LENGTH) {
-        OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_TOO_LONG);
-        goto err;
-      }
-      if (!BUF_MEM_grow_clean(buf, newsize)) {
-        goto err;
-      }
-      while (*p) {
-        buf->data[to++] = *(p++);
-      }
-
-      /* Since we change the pointer 'from', we also have
-         to change the perceived length of the string it
-         points at.  /RL */
-      len -= e - from;
-      from = e;
-
-      /* In case there were no braces or parenthesis around
-         the variable reference, we have to put back the
-         character that was replaced with a '\0'.  /RL */
-      *rp = r;
+      // Historically, $foo would expand to a previously-parsed value. This
+      // feature has been removed as it was unused and is a DoS vector.
+      OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_NOT_SUPPORTED);
+      goto err;
     } else {
       buf->data[to++] = *(from++);
     }
   }
 
   buf->data[to] = '\0';
-  if (*pto != NULL) {
-    OPENSSL_free(*pto);
-  }
+  OPENSSL_free(*pto);
   *pto = buf->data;
   OPENSSL_free(buf);
   return 1;
 
 err:
-  if (buf != NULL) {
-    BUF_MEM_free(buf);
-  }
+  BUF_MEM_free(buf);
   return 0;
 }
 
@@ -472,33 +358,8 @@ static char *scan_quote(CONF *conf, char *p) {
   return p;
 }
 
-
-static char *scan_dquote(CONF *conf, char *p) {
-  int q = *p;
-
-  p++;
-  while (!(IS_EOF(conf, *p))) {
-    if (*p == q) {
-      if (*(p + 1) == q) {
-        p++;
-      } else {
-        break;
-      }
-    }
-    p++;
-  }
-  if (*p == q) {
-    p++;
-  }
-  return p;
-}
-
 static void clear_comments(CONF *conf, char *p) {
   for (;;) {
-    if (IS_FCOMMENT(conf, *p)) {
-      *p = '\0';
-      return;
-    }
     if (!IS_WS(conf, *p)) {
       break;
     }
@@ -510,10 +371,6 @@ static void clear_comments(CONF *conf, char *p) {
       *p = '\0';
       return;
     }
-    if (IS_DQUOTE(conf, *p)) {
-      p = scan_dquote(conf, p);
-      continue;
-    }
     if (IS_QUOTE(conf, *p)) {
       p = scan_quote(conf, p);
       continue;
@@ -530,7 +387,7 @@ static void clear_comments(CONF *conf, char *p) {
   }
 }
 
-static int def_load_bio(CONF *conf, BIO *in, long *out_error_line) {
+int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
   static const size_t CONFBUFSIZE = 512;
   int bufnum = 0, i, ii;
   BUF_MEM *buff = NULL;
@@ -707,37 +564,23 @@ static int def_load_bio(CONF *conf, BIO *in, long *out_error_line) {
       v = NULL;
     }
   }
-  if (buff != NULL) {
-    BUF_MEM_free(buff);
-  }
-  if (section != NULL) {
-    OPENSSL_free(section);
-  }
+  BUF_MEM_free(buff);
+  OPENSSL_free(section);
   return 1;
 
 err:
-  if (buff != NULL) {
-    BUF_MEM_free(buff);
-  }
-  if (section != NULL) {
-    OPENSSL_free(section);
-  }
+  BUF_MEM_free(buff);
+  OPENSSL_free(section);
   if (out_error_line != NULL) {
     *out_error_line = eline;
   }
-  BIO_snprintf(btmp, sizeof btmp, "%ld", eline);
+  snprintf(btmp, sizeof btmp, "%ld", eline);
   ERR_add_error_data(2, "line ", btmp);
 
   if (v != NULL) {
-    if (v->name != NULL) {
-      OPENSSL_free(v->name);
-    }
-    if (v->value != NULL) {
-      OPENSSL_free(v->value);
-    }
-    if (v != NULL) {
-      OPENSSL_free(v);
-    }
+    OPENSSL_free(v->name);
+    OPENSSL_free(v->value);
+    OPENSSL_free(v);
   }
   return 0;
 }
@@ -751,16 +594,12 @@ int NCONF_load(CONF *conf, const char *filename, long *out_error_line) {
     return 0;
   }
 
-  ret = def_load_bio(conf, in, out_error_line);
+  ret = NCONF_load_bio(conf, in, out_error_line);
   BIO_free(in);
 
   return ret;
 }
 
-int NCONF_load_bio(CONF *conf, BIO *bio, long *out_error_line) {
-  return def_load_bio(conf, bio, out_error_line);
-}
-
 int CONF_parse_list(const char *list, char sep, int remove_whitespace,
                     int (*list_cb)(const char *elem, size_t len, void *usr),
                     void *arg) {

data/third_party/boringssl-with-bazel/src/crypto/conf/conf_def.h

@@ -55,8 +55,9 @@
  * [including the GNU Public Licence.]
  */
 
-/* THIS FILE WAS AUTOMAGICALLY GENERATED!
-   Please modify and use keysets.pl to regenerate it. */
+// This file was historically generated by keysets.pl in OpenSSL.
+//
+// TODO(davidben): Replace it with something more readable.
 
 #define CONF_NUMBER		1
 #define CONF_UPPER		2
@@ -66,9 +67,7 @@
 #define CONF_WS			16
 #define CONF_ESC		32
 #define CONF_QUOTE		64
-#define CONF_DQUOTE		1024
 #define CONF_COMMENT		128
-#define CONF_FCOMMENT		2048
 #define CONF_EOF		8
 #define CONF_HIGHBIT		4096
 #define CONF_ALPHA		(CONF_UPPER|CONF_LOWER)
@@ -78,7 +77,6 @@
 
 #define KEYTYPES(c)		CONF_type_default
 #define IS_COMMENT(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
-#define IS_FCOMMENT(c,a)	(KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
 #define IS_EOF(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_EOF)
 #define IS_ESC(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_ESC)
 #define IS_NUMBER(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
@@ -87,8 +85,6 @@
 #define IS_ALPHA_NUMERIC_PUNCT(c,a) \
 				(KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
 #define IS_QUOTE(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
-#define IS_DQUOTE(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
-#define IS_HIGHBIT(c,a)		(KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
 
 static const unsigned short CONF_type_default[256]={
 	0x0008,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,

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

@@ -17,11 +17,19 @@
 
 #include <openssl/base.h>
 
+#include "../lhash/internal.h"
+
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 
+DEFINE_LHASH_OF(CONF_VALUE)
+
+struct conf_st {
+  LHASH_OF(CONF_VALUE) *data;
+};
+
 // CONF_VALUE_new returns a freshly allocated and zeroed |CONF_VALUE|.
 CONF_VALUE *CONF_VALUE_new(void);
 

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

@@ -23,8 +23,6 @@
 #include <openssl/arm_arch.h>
 
 
-extern uint32_t OPENSSL_armcap_P;
-
 static int has_hw_feature(const char *name) {
   int value;
   size_t len = sizeof(value);
@@ -65,6 +63,9 @@ void OPENSSL_cpuid_setup(void) {
   // available in macOS 12. For compatibility with macOS 11, we also support
   // the old names. The old names don't have values for features like FEAT_AES,
   // so instead we detect them statically above.
+  //
+  // If querying new sysctls, update the Chromium sandbox definition. See
+  // https://crrev.com/c/4415225.
   if (has_hw_feature("hw.optional.arm.FEAT_SHA512") ||
       has_hw_feature("hw.optional.armv8_2_sha512")) {
     OPENSSL_armcap_P |= ARMV8_SHA512;

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

@@ -23,7 +23,6 @@
 
 #include <openssl/arm_arch.h>
 
-extern uint32_t OPENSSL_armcap_P;
 
 void OPENSSL_cpuid_setup(void) {
   uint32_t hwcap;

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

@@ -22,8 +22,6 @@
 #include <openssl/arm_arch.h>
 
 
-extern uint32_t OPENSSL_armcap_P;
-
 void OPENSSL_cpuid_setup(void) {
   unsigned long hwcap = getauxval(AT_HWCAP);
 

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

@@ -25,7 +25,6 @@
 
 #include "internal.h"
 
-extern uint32_t OPENSSL_armcap_P;
 
 void OPENSSL_cpuid_setup(void) {
   int isar0_mib[] = { CTL_MACHDEP, CPU_ID_AA64ISAR0 };

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

@@ -0,0 +1,93 @@
+/* Copyright (c) 2023, Google Inc.
+ *
+ * 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 "internal.h"
+
+// While Arm system registers are normally not available to userspace, FreeBSD
+// expects userspace to simply read them. It traps the reads and fills in CPU
+// capabilities.
+#if defined(OPENSSL_AARCH64) && !defined(OPENSSL_STATIC_ARMCAP) && \
+    (defined(ANDROID_BAREMETAL) || defined(OPENSSL_FREEBSD))
+
+#include <openssl/arm_arch.h>
+
+#define ID_AA64PFR0_EL1_ADVSIMD 5
+
+#define ID_AA64ISAR0_EL1_AES 1
+#define ID_AA64ISAR0_EL1_SHA1 2
+#define ID_AA64ISAR0_EL1_SHA2 3
+
+#define NBITS_ID_FIELD 4
+
+#define READ_SYSREG(name)                \
+  ({                                     \
+    uint64_t _r;                         \
+    __asm__("mrs %0, " name : "=r"(_r)); \
+    _r;                                  \
+  })
+
+static unsigned get_id_field(uint64_t reg, unsigned field) {
+  return (reg >> (field * NBITS_ID_FIELD)) & ((1 << NBITS_ID_FIELD) - 1);
+}
+
+static int get_signed_id_field(uint64_t reg, unsigned field) {
+  unsigned value = get_id_field(reg, field);
+  if (value & (1 << (NBITS_ID_FIELD - 1))) {
+    return (int)(value | (UINT64_MAX << NBITS_ID_FIELD));
+  } else {
+    return (int)value;
+  }
+}
+
+static uint32_t read_armcap(void) {
+  uint32_t armcap = ARMV7_NEON;
+
+  uint64_t id_aa64pfr0_el1 = READ_SYSREG("id_aa64pfr0_el1");
+
+  if (get_signed_id_field(id_aa64pfr0_el1, ID_AA64PFR0_EL1_ADVSIMD) < 0) {
+    // If AdvSIMD ("NEON") is missing, don't report other features either.
+    // This matches OpenSSL.
+    return 0;
+  }
+
+  uint64_t id_aa64isar0_el1 = READ_SYSREG("id_aa64isar0_el1");
+
+  unsigned aes = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_AES);
+  if (aes > 0) {
+    armcap |= ARMV8_AES;
+  }
+  if (aes > 1) {
+    armcap |= ARMV8_PMULL;
+  }
+
+  unsigned sha1 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA1);
+  if (sha1 > 0) {
+    armcap |= ARMV8_SHA1;
+  }
+
+  unsigned sha2 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA2);
+  if (sha2 > 0) {
+    armcap |= ARMV8_SHA256;
+  }
+  if (sha2 > 1) {
+    armcap |= ARMV8_SHA512;
+  }
+
+  return armcap;
+}
+
+void OPENSSL_cpuid_setup(void) { OPENSSL_armcap_P |= read_armcap(); }
+
+#endif  // OPENSSL_AARCH64 && !OPENSSL_STATIC_ARMCAP &&
+        // (ANDROID_BAREMETAL || OPENSSL_FREEBSD)

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

@@ -22,7 +22,7 @@
 
 #include <openssl/arm_arch.h>
 
-extern uint32_t OPENSSL_armcap_P;
+
 void OPENSSL_cpuid_setup(void) {
   // We do not need to check for the presence of NEON, as Armv8-A always has it
   OPENSSL_armcap_P |= ARMV7_NEON;

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

@@ -22,7 +22,6 @@
 #include <openssl/arm_arch.h>
 #include <openssl/mem.h>
 
-extern uint32_t OPENSSL_armcap_P;
 
 void OPENSSL_cpuid_setup(void) {
   unsigned long hwcap = 0, hwcap2 = 0;

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

@@ -95,8 +95,6 @@ err:
   return ret;
 }
 
-extern uint32_t OPENSSL_armcap_P;
-
 static int g_needs_hwcap2_workaround;
 
 void OPENSSL_cpuid_setup(void) {