grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/bytestring/cbs.cc

@@ -26,6 +26,8 @@
 #include "internal.h"
 
 
+using namespace bssl;
+
 static int cbs_get(CBS *cbs, const uint8_t **p, size_t n) {
   if (cbs->len < n) {
     return 0;
@@ -44,14 +46,14 @@ int CBS_skip(CBS *cbs, size_t len) {
 
 int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) {
   OPENSSL_free(*out_ptr);
-  *out_ptr = NULL;
+  *out_ptr = nullptr;
   *out_len = 0;
 
   if (cbs->len == 0) {
     return 1;
   }
   *out_ptr = reinterpret_cast<uint8_t *>(OPENSSL_memdup(cbs->data, cbs->len));
-  if (*out_ptr == NULL) {
+  if (*out_ptr == nullptr) {
     return 0;
   }
   *out_len = cbs->len;
@@ -59,15 +61,15 @@ int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) {
 }
 
 int CBS_strdup(const CBS *cbs, char **out_ptr) {
-  if (*out_ptr != NULL) {
+  if (*out_ptr != nullptr) {
     OPENSSL_free(*out_ptr);
   }
   *out_ptr = OPENSSL_strndup((const char *)cbs->data, cbs->len);
-  return (*out_ptr != NULL);
+  return (*out_ptr != nullptr);
 }
 
 int CBS_contains_zero_byte(const CBS *cbs) {
-  return OPENSSL_memchr(cbs->data, 0, cbs->len) != NULL;
+  return OPENSSL_memchr(cbs->data, 0, cbs->len) != nullptr;
 }
 
 int CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len) {
@@ -144,6 +146,8 @@ int CBS_get_u32le(CBS *cbs, uint32_t *out) {
   return 1;
 }
 
+int CBS_get_u48(CBS *cbs, uint64_t *out) { return cbs_get_u(cbs, out, 6); }
+
 int CBS_get_u64(CBS *cbs, uint64_t *out) { return cbs_get_u(cbs, out, 8); }
 
 int CBS_get_u64le(CBS *cbs, uint64_t *out) {
@@ -186,7 +190,7 @@ static int cbs_get_length_prefixed(CBS *cbs, CBS *out, size_t len_len) {
   if (!cbs_get_u(cbs, &len, len_len)) {
     return 0;
   }
-  // If |len_len| <= 3 then we know that |len| will fit into a |size_t|, even on
+  // If `len_len` <= 3 then we know that `len` will fit into a `size_t`, even on
   // 32-bit systems.
   assert(len_len <= 3);
   return CBS_get_bytes(cbs, out, len);
@@ -207,12 +211,48 @@ int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out) {
 int CBS_get_until_first(CBS *cbs, CBS *out, uint8_t c) {
   const uint8_t *split = reinterpret_cast<const uint8_t *>(
       OPENSSL_memchr(CBS_data(cbs), c, CBS_len(cbs)));
-  if (split == NULL) {
+  if (split == nullptr) {
     return 0;
   }
   return CBS_get_bytes(cbs, out, split - CBS_data(cbs));
 }
 
+int CBS_get_until_first_of(CBS *cbs, CBS *out, const char *chars) {
+  size_t pos = 0;
+  while (pos < CBS_len(cbs)) {
+    uint8_t c = CBS_data(cbs)[pos];
+    // Special-case for \0 characters. We don't want to match on a null byte,
+    // even though strchr will happily return the \0 at the end of `chars`.
+    if (!c || !strchr(chars, c)) {
+      pos++;
+    } else {
+      break;
+    }
+  }
+  if (pos == CBS_len(cbs)) {
+    return 0;
+  }
+  return CBS_get_bytes(cbs, out, pos);
+}
+
+int CBS_get_until_first_not_of(CBS *cbs, CBS *out, const char *chars) {
+  size_t pos = 0;
+  while (pos < CBS_len(cbs)) {
+    uint8_t c = CBS_data(cbs)[pos];
+    // Special-case for \0 characters. We don't want to match on a null byte,
+    // even though strchr will happily return the \0 at the end of `chars`.
+    if (c && strchr(chars, c)) {
+      pos++;
+    } else {
+      break;
+    }
+  }
+  if (pos == CBS_len(cbs)) {
+    return 0;
+  }
+  return CBS_get_bytes(cbs, out, pos);
+}
+
 int CBS_get_u64_decimal(CBS *cbs, uint64_t *out) {
   uint64_t v = 0;
   int seen_digit = 0;
@@ -237,8 +277,8 @@ int CBS_get_u64_decimal(CBS *cbs, uint64_t *out) {
   return seen_digit;
 }
 
-// parse_base128_integer reads a big-endian base-128 integer from |cbs| and sets
-// |*out| to the result. This is the encoding used in DER for both high tag
+// parse_base128_integer reads a big-endian base-128 integer from `cbs` and sets
+// `*out` to the result. This is the encoding used in DER for both high tag
 // number form and OID components.
 static int parse_base128_integer(CBS *cbs, uint64_t *out) {
   uint64_t v = 0;
@@ -309,22 +349,22 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
   CBS header = *cbs;
   CBS throwaway;
 
-  if (out == NULL) {
+  if (out == nullptr) {
     out = &throwaway;
   }
   if (ber_ok) {
     *out_ber_found = 0;
     *out_indefinite = 0;
   } else {
-    assert(out_ber_found == NULL);
-    assert(out_indefinite == NULL);
+    assert(out_ber_found == nullptr);
+    assert(out_indefinite == nullptr);
   }
 
   CBS_ASN1_TAG tag;
   if (!parse_asn1_tag(&header, &tag)) {
     return 0;
   }
-  if (out_tag != NULL) {
+  if (out_tag != nullptr) {
     *out_tag = tag;
   }
 
@@ -341,7 +381,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
   if ((length_byte & 0x80) == 0) {
     // Short form length.
     len = ((size_t)length_byte) + header_len;
-    if (out_header_len != NULL) {
+    if (out_header_len != nullptr) {
       *out_header_len = header_len;
     }
   } else {
@@ -353,7 +393,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
 
     if (ber_ok && (tag & CBS_ASN1_CONSTRUCTED) != 0 && num_bytes == 0) {
       // indefinite length
-      if (out_header_len != NULL) {
+      if (out_header_len != nullptr) {
         *out_header_len = header_len;
       }
       *out_ber_found = 1;
@@ -373,7 +413,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
     // ITU-T X.690 section 10.1 (DER length forms) requires encoding the
     // length with the minimum number of octets. BER could, technically, have
     // 125 superfluous zero bytes. We do not attempt to handle that and still
-    // require that the length fit in a |uint32_t| for BER.
+    // require that the length fit in a `uint32_t` for BER.
     if (len64 < 128) {
       // Length should have used short-form encoding.
       if (ber_ok) {
@@ -396,7 +436,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
       return 0;
     }
     len += header_len + num_bytes;
-    if (out_header_len != NULL) {
+    if (out_header_len != nullptr) {
       *out_header_len = header_len + num_bytes;
     }
   }
@@ -420,7 +460,8 @@ int CBS_get_any_asn1(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag) {
 
 int CBS_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
                              size_t *out_header_len) {
-  return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, NULL, NULL,
+  return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, nullptr,
+                                  nullptr,
                                   /*ber_ok=*/0);
 }
 
@@ -440,7 +481,7 @@ static int cbs_get_asn1(CBS *cbs, CBS *out, CBS_ASN1_TAG tag_value,
   CBS_ASN1_TAG tag;
   CBS throwaway;
 
-  if (out == NULL) {
+  if (out == nullptr) {
     out = &throwaway;
   }
 
@@ -465,10 +506,20 @@ int CBS_get_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG tag_value) {
   return cbs_get_asn1(cbs, out, tag_value, 0 /* include header */);
 }
 
-int CBS_peek_asn1_tag(const CBS *cbs, CBS_ASN1_TAG tag_value) {
+CBS_ASN1_TAG CBS_peek_any_asn1_tag(const CBS *cbs) {
   CBS copy = *cbs;
-  CBS_ASN1_TAG actual_tag;
-  return parse_asn1_tag(&copy, &actual_tag) && tag_value == actual_tag;
+  CBS_ASN1_TAG tag;
+  if (!parse_asn1_tag(&copy, &tag)) {
+    return 0;
+  }
+  return tag;
+}
+
+int CBS_peek_asn1_tag(const CBS *cbs, CBS_ASN1_TAG tag_value) {
+  CBS_ASN1_TAG actual_tag = CBS_peek_any_asn1_tag(cbs);
+  // The caller should never pass zero as |tag_value|, but return zero if they
+  // did.
+  return actual_tag != 0 && actual_tag == tag_value;
 }
 
 int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) {
@@ -546,7 +597,7 @@ int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present,
     present = 1;
   }
 
-  if (out_present != NULL) {
+  if (out_present != nullptr) {
     *out_present = present;
   }
 
@@ -567,7 +618,7 @@ int CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, int *out_present,
       return 0;
     }
   } else {
-    CBS_init(out, NULL, 0);
+    CBS_init(out, nullptr, 0);
   }
   if (out_present) {
     *out_present = present;
@@ -663,7 +714,7 @@ int CBS_is_valid_asn1_integer(const CBS *cbs, int *out_is_negative) {
   if (!CBS_get_u8(&copy, &first_byte)) {
     return 0;  // INTEGERs may not be empty.
   }
-  if (out_is_negative != NULL) {
+  if (out_is_negative != nullptr) {
     *out_is_negative = (first_byte & 0x80) != 0;
   }
   if (!CBS_get_u8(&copy, &second_byte)) {
@@ -696,8 +747,8 @@ int CBS_is_valid_asn1_oid(const CBS *cbs) {
   uint8_t v, prev = 0;
   while (CBS_get_u8(&copy, &v)) {
     // OID encodings are a sequence of minimally-encoded base-128 integers (see
-    // |parse_base128_integer|). If |prev|'s MSB was clear, it was the last byte
-    // of an integer (or |v| is the first byte). |v| is then the first byte of
+    // `parse_base128_integer`). If `prev`'s MSB was clear, it was the last byte
+    // of an integer (or `v` is the first byte). `v` is then the first byte of
     // the next integer. If first byte of an integer is 0x80, it is not
     // minimally-encoded.
     if ((prev & 0x80) == 0 && v == 0x80) {
@@ -750,7 +801,40 @@ char *CBS_asn1_oid_to_text(const CBS *cbs) {
 
 err:
   CBB_cleanup(&cbb);
-  return NULL;
+  return nullptr;
+}
+
+int CBS_is_valid_asn1_relative_oid(const CBS *cbs) {
+  return CBS_is_valid_asn1_oid(cbs);
+}
+
+char *CBS_asn1_relative_oid_to_text(const CBS *cbs) {
+  CBS copy = *cbs;
+  ScopedCBB cbb;
+  if (!CBB_init(cbb.get(), 32)) {
+    return nullptr;
+  }
+
+  // Relative OIDs must have at least one component.
+  uint64_t v;
+  if (!parse_base128_integer(&copy, &v) || !add_decimal(cbb.get(), v)) {
+    return nullptr;
+  }
+
+  while (CBS_len(&copy) != 0) {
+    if (!parse_base128_integer(&copy, &v) || !CBB_add_u8(cbb.get(), '.') ||
+        !add_decimal(cbb.get(), v)) {
+      return nullptr;
+    }
+  }
+
+  uint8_t *txt;
+  size_t txt_len;
+  if (!CBB_add_u8(cbb.get(), '\0') || !CBB_finish(cbb.get(), &txt, &txt_len)) {
+    return nullptr;
+  }
+
+  return reinterpret_cast<char *>(txt);
 }
 
 static int cbs_get_two_digits(CBS *cbs, int *out) {
@@ -846,10 +930,10 @@ static int CBS_parse_rfc5280_time_internal(const CBS *cbs, int is_gentime,
     case 'Z':
       break;  // We correctly have 'Z' on the end as per spec.
     case '+':
-      offset_sign = 1;
+      offset_sign = -1;
       break;  // Should not be allowed per RFC 5280.
     case '-':
-      offset_sign = -1;
+      offset_sign = 1;
       break;  // Should not be allowed per RFC 5280.
     default:
       return 0;  // Reject anything else after the time.
@@ -886,7 +970,7 @@ static int CBS_parse_rfc5280_time_internal(const CBS *cbs, int is_gentime,
     return 0;  // Reject invalid lengths.
   }
 
-  if (out_tm != NULL) {
+  if (out_tm != nullptr) {
     // Fill in the tm fields corresponding to what we validated.
     out_tm->tm_year = year - 1900;
     out_tm->tm_mon = month - 1;

data/third_party/boringssl-with-bazel/crypto/bytestring/internal.h

@@ -15,25 +15,29 @@
 #ifndef OPENSSL_HEADER_CRYPTO_BYTESTRING_INTERNAL_H
 #define OPENSSL_HEADER_CRYPTO_BYTESTRING_INTERNAL_H
 
-#include <openssl/base.h>
+#include <openssl/asn1.h>
+#include <openssl/bytestring.h>
+#include <openssl/err.h>
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+#include <type_traits>
 
+#include "../mem_internal.h"
 
-// CBS_asn1_ber_to_der reads a BER element from |in|. If it finds
+
+BSSL_NAMESPACE_BEGIN
+
+// CBS_asn1_ber_to_der reads a BER element from `in`. If it finds
 // indefinite-length elements or constructed strings then it converts the BER
-// data to DER, sets |out| to the converted contents and |*out_storage| to a
-// buffer which the caller must release with |OPENSSL_free|. Otherwise, it sets
-// |out| to the original BER element in |in| and |*out_storage| to NULL.
-// Additionally, |*in| will be advanced over the BER element.
+// data to DER, sets `out` to the converted contents and `*out_storage` to a
+// buffer which the caller must release with `OPENSSL_free`. Otherwise, it sets
+// `out` to the original BER element in `in` and `*out_storage` to NULL.
+// Additionally, `*in` will be advanced over the BER element.
 //
 // This function should successfully process any valid BER input, however it
 // will not convert all of BER's deviations from DER. BER is ambiguous between
 // implicitly-tagged SEQUENCEs of strings and implicitly-tagged constructed
 // strings. Implicitly-tagged strings must be parsed with
-// |CBS_get_ber_implicitly_tagged_string| instead of |CBS_get_asn1|. The caller
+// `CBS_get_ber_implicitly_tagged_string` instead of `CBS_get_asn1`. The caller
 // must also account for BER variations in the contents of a primitive.
 //
 // It returns one on success and zero otherwise.
@@ -41,15 +45,15 @@ OPENSSL_EXPORT int CBS_asn1_ber_to_der(CBS *in, CBS *out,
                                        uint8_t **out_storage);
 
 // CBS_get_asn1_implicit_string parses a BER string of primitive type
-// |inner_tag| implicitly-tagged with |outer_tag|. It sets |out| to the
-// contents. If concatenation was needed, it sets |*out_storage| to a buffer
-// which the caller must release with |OPENSSL_free|. Otherwise, it sets
-// |*out_storage| to NULL.
+// `inner_tag` implicitly-tagged with `outer_tag`. It sets `out` to the
+// contents. If concatenation was needed, it sets `*out_storage` to a buffer
+// which the caller must release with `OPENSSL_free`. Otherwise, it sets
+// `*out_storage` to NULL.
 //
 // This function does not parse all of BER. It requires the string be
 // definite-length. Constructed strings are allowed, but all children of the
 // outermost element must be primitive. The caller should use
-// |CBS_asn1_ber_to_der| before running this function.
+// `CBS_asn1_ber_to_der` before running this function.
 //
 // It returns one on success and zero otherwise.
 OPENSSL_EXPORT int CBS_get_asn1_implicit_string(CBS *in, CBS *out,
@@ -57,18 +61,69 @@ OPENSSL_EXPORT int CBS_get_asn1_implicit_string(CBS *in, CBS *out,
                                                 CBS_ASN1_TAG outer_tag,
                                                 CBS_ASN1_TAG inner_tag);
 
-// CBB_finish_i2d calls |CBB_finish| on |cbb| which must have been initialized
-// with |CBB_init|. If |outp| is not NULL then the result is written to |*outp|
-// and |*outp| is advanced just past the output. It returns the number of bytes
-// in the result, whether written or not, or a negative value on error. On
-// error, it calls |CBB_cleanup| on |cbb|.
+// CBB_finish_i2d calls `CBB_finish` on `cbb` which must have been initialized
+// with `CBB_init`. If `outp` is not NULL then the result is written to `*outp`
+// and `*outp` is advanced just past the output. It returns the number of bytes
+// in the result, whether written or not, or a negative value on error.
 //
 // This function may be used to help implement legacy i2d ASN.1 functions.
-int CBB_finish_i2d(CBB *cbb, uint8_t **outp);
+OPENSSL_EXPORT int CBB_finish_i2d(CBB *cbb, uint8_t **outp);
+
+// CBBAsSpan returns a span containing `cbb`'s contents. It does not flush
+// `cbb`. The span is valid until the next operation to `cbb`.
+//
+// To avoid unfinalized length prefixes, it is a fatal error to call this on a
+// CBB with any active children.
+inline Span<uint8_t> CBBAsSpan(const CBB *cbb) {
+  return Span(CBB_data(cbb), CBB_len(cbb));
+}
+
+// CBBFinishArray behaves like `CBB_finish` but stores the result in an Array.
+OPENSSL_EXPORT bool CBBFinishArray(CBB *cbb, Array<uint8_t> *out);
+
+// D2IFromCBS takes a functor of type `Unique<T>(CBS*)` and implements the d2i
+// calling convention. For compatibility with functions that don't tag their
+// return value (e.g. public APIs), `T*(CBS)` is also accepted. The callback can
+// assume that the `CBS`'s length fits in `long`. The callback should not access
+// `out`, `inp`, or `len` directly.
+template <typename T, typename CBSFunc>
+inline T *D2IFromCBS(T **out, const uint8_t **inp, long len, CBSFunc func) {
+  static_assert(std::is_invocable_v<CBSFunc, CBS *>);
+  static_assert(
+      std::is_same_v<std::invoke_result_t<CBSFunc, CBS *>, UniquePtr<T>> ||
+      std::is_same_v<std::invoke_result_t<CBSFunc, CBS *>, T *>);
+  if (len < 0) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_BUFFER_TOO_SMALL);
+    return nullptr;
+  }
+  CBS cbs;
+  CBS_init(&cbs, *inp, len);
+  UniquePtr<T> ret(func(&cbs));
+  if (ret == nullptr) {
+    return nullptr;
+  }
+  if (out != nullptr) {
+    UniquePtr<T> free_out(*out);
+    *out = ret.get();
+  }
+  *inp = CBS_data(&cbs);
+  return ret.release();
+}
 
+// I2DFromCBB takes a functor of type `bool(CBB*)` and implements the i2d
+// calling convention. It internally makes a `CBB` with the specified initial
+// capacity. The callback should not access `outp` directly.
+template <typename CBBFunc>
+inline int I2DFromCBB(size_t initial_capacity, uint8_t **outp, CBBFunc func) {
+  static_assert(std::is_invocable_v<CBBFunc, CBB *>);
+  static_assert(std::is_same_v<std::invoke_result_t<CBBFunc, CBB *>, bool>);
+  ScopedCBB cbb;
+  if (!CBB_init(cbb.get(), initial_capacity) || !func(cbb.get())) {
+    return -1;
+  }
+  return CBB_finish_i2d(cbb.get(), outp);
+}
 
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_BYTESTRING_INTERNAL_H

data/third_party/boringssl-with-bazel/crypto/bytestring/unicode.cc

@@ -33,10 +33,10 @@ static int is_valid_code_point(uint32_t v) {
   return 1;
 }
 
-// BOTTOM_BITS returns a byte with the bottom |n| bits set.
+// BOTTOM_BITS returns a byte with the bottom `n` bits set.
 #define BOTTOM_BITS(n) (uint8_t)((1u << (n)) - 1)
 
-// TOP_BITS returns a byte with the top |n| bits set.
+// TOP_BITS returns a byte with the top `n` bits set.
 #define TOP_BITS(n) ((uint8_t)~BOTTOM_BITS(8 - (n)))
 
 int CBS_get_utf8(CBS *cbs, uint32_t *out) {

data/third_party/boringssl-with-bazel/crypto/chacha/chacha.cc

@@ -24,6 +24,8 @@
 
 
 // sigma contains the ChaCha constants, which happen to be an ASCII string.
+using namespace bssl;
+
 static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
                                    '2', '-', 'b', 'y', 't', 'e', ' ', 'k' };
 
@@ -38,8 +40,8 @@ static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
   x[c] += x[d];                            \
   x[b] = CRYPTO_rotl_u32(x[b] ^ x[c], 7);
 
-void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
-                      const uint8_t nonce[16]) {
+void bssl::CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
+                            const uint8_t nonce[16]) {
   uint32_t x[16];
   OPENSSL_memcpy(x, sigma, sizeof(sigma));
   OPENSSL_memcpy(&x[4], key, 32);
@@ -148,7 +150,7 @@ void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in, size_t in_len,
 #else
 
 // chacha_core performs 20 rounds of ChaCha on the input words in
-// |input| and writes the 64 output bytes to |output|.
+// `input` and writes the 64 output bytes to `output`.
 static void chacha_core(uint8_t output[64], const uint32_t input[16]) {
   uint32_t x[16];
   int i;

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

@@ -19,10 +19,8 @@
 
 #include "../internal.h"
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
+BSSL_NAMESPACE_BEGIN
 
 // CRYPTO_hchacha20 computes the HChaCha20 function, which should only be used
 // as part of XChaCha20.
@@ -39,8 +37,9 @@ inline int ChaCha20_ctr32_ssse3_capable(size_t len) {
   // lengths.
   return len > 0 && CRYPTO_is_SSSE3_capable();
 }
-void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in, size_t in_len,
-                          const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in,
+                                     size_t in_len, const uint32_t key[8],
+                                     const uint32_t counter[4]);
 
 #elif !defined(OPENSSL_NO_ASM) && \
     (defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
@@ -51,8 +50,9 @@ void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in, size_t in_len,
 inline int ChaCha20_ctr32_neon_capable(size_t len) {
   return len >= 192 && CRYPTO_is_NEON_capable();
 }
-void ChaCha20_ctr32_neon(uint8_t *out, const uint8_t *in, size_t in_len,
-                         const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_neon(uint8_t *out, const uint8_t *in,
+                                    size_t in_len, const uint32_t key[8],
+                                    const uint32_t counter[4]);
 #elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64)
 #define CHACHA20_ASM_NOHW
 
@@ -60,8 +60,9 @@ void ChaCha20_ctr32_neon(uint8_t *out, const uint8_t *in, size_t in_len,
 inline int ChaCha20_ctr32_avx2_capable(size_t len) {
   return len > 128 && CRYPTO_is_AVX2_capable();
 }
-void ChaCha20_ctr32_avx2(uint8_t *out, const uint8_t *in, size_t in_len,
-                         const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_avx2(uint8_t *out, const uint8_t *in,
+                                    size_t in_len, const uint32_t key[8],
+                                    const uint32_t counter[4]);
 
 #define CHACHA20_ASM_SSSE3_4X
 inline int ChaCha20_ctr32_ssse3_4x_capable(size_t len) {
@@ -69,34 +70,34 @@ inline int ChaCha20_ctr32_ssse3_4x_capable(size_t len) {
   int faster = len > 192 || !CRYPTO_cpu_perf_is_like_silvermont();
   return capable && faster;
 }
-void ChaCha20_ctr32_ssse3_4x(uint8_t *out, const uint8_t *in, size_t in_len,
-                             const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_ssse3_4x(uint8_t *out, const uint8_t *in,
+                                        size_t in_len, const uint32_t key[8],
+                                        const uint32_t counter[4]);
 
 #define CHACHA20_ASM_SSSE3
 inline int ChaCha20_ctr32_ssse3_capable(size_t len) {
   return len > 128 && CRYPTO_is_SSSE3_capable();
 }
-void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in, size_t in_len,
-                          const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in,
+                                     size_t in_len, const uint32_t key[8],
+                                     const uint32_t counter[4]);
 #endif
 
 #if defined(CHACHA20_ASM_NOHW)
-// ChaCha20_ctr32_nohw encrypts |in_len| bytes from |in| and writes the result
-// to |out|. If |in| and |out| alias, they must be equal. |in_len| may not be
+// ChaCha20_ctr32_nohw encrypts `in_len` bytes from `in` and writes the result
+// to `out`. If `in` and `out` alias, they must be equal. `in_len` may not be
 // zero.
 //
-// |counter[0]| is the initial 32-bit block counter, and the remainder is the
+// `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_nohw(uint8_t *out, const uint8_t *in, size_t in_len,
-                         const uint32_t key[8], const uint32_t counter[4]);
+extern "C" void ChaCha20_ctr32_nohw(uint8_t *out, const uint8_t *in,
+                                    size_t in_len, const uint32_t key[8],
+                                    const uint32_t counter[4]);
 #endif
 
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_CHACHA_INTERNAL_H