grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/asn1/a_strex.cc

@@ -24,26 +24,29 @@
 #include <openssl/bio.h>
 #include <openssl/bytestring.h>
 #include <openssl/mem.h>
+#include <openssl/span.h>
 
 #include "../bytestring/internal.h"
 #include "../internal.h"
 #include "internal.h"
 
 
+using namespace bssl;
+
 #define ESC_FLAGS                                                           \
   (ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_QUOTE | ASN1_STRFLGS_ESC_CTRL | \
    ASN1_STRFLGS_ESC_MSB)
 
 static int maybe_write(BIO *out, const void *buf, int len) {
-  // If |out| is NULL, ignore the output but report the length.
-  return out == NULL || BIO_write(out, buf, len) == len;
+  // If `out` is NULL, ignore the output but report the length.
+  return out == nullptr || BIO_write(out, buf, len) == len;
 }
 
 static int is_control_character(unsigned char c) { return c < 32 || c == 127; }
 
 static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
                        BIO *out, int is_first, int is_last) {
-  // |c| is a |uint32_t| because, depending on |ASN1_STRFLGS_UTF8_CONVERT|,
+  // `c` is a `uint32_t` because, depending on `ASN1_STRFLGS_UTF8_CONVERT`,
   // we may be escaping bytes or Unicode codepoints.
   char buf[16];  // Large enough for "\\W01234567".
   unsigned char u8 = (unsigned char)c;
@@ -65,7 +68,7 @@ static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
                (is_last && (c == ' '))) {
       if (flags & ASN1_STRFLGS_ESC_QUOTE) {
         // No need to escape, just tell the caller to quote.
-        if (do_quotes != NULL) {
+        if (do_quotes != nullptr) {
           *do_quotes = 1;
         }
         return maybe_write(out, &u8, 1) ? 1 : -1;
@@ -133,7 +136,7 @@ static int do_buf(const unsigned char *buf, int buflen, int encoding,
       CBB_init_fixed(&utf8_cbb, utf8_buf, sizeof(utf8_buf));
       if (!CBB_add_utf8(&utf8_cbb, c)) {
         OPENSSL_PUT_ERROR(ASN1, ERR_R_INTERNAL_ERROR);
-        return 1;
+        return -1;
       }
       size_t utf8_len = CBB_len(&utf8_cbb);
       for (size_t i = 0; i < utf8_len; i++) {
@@ -155,25 +158,22 @@ static int do_buf(const unsigned char *buf, int buflen, int encoding,
   return outlen;
 }
 
-// This function hex dumps a buffer of characters
-
-static int do_hex_dump(BIO *out, unsigned char *buf, int buflen) {
-  static const char hexdig[] = "0123456789ABCDEF";
-  unsigned char *p, *q;
-  char hextmp[2];
+static int do_hex_dump(BIO *out, Span<const uint8_t> in) {
+  if (in.size() > INT_MAX / 2) {
+    return -1;
+  }
   if (out) {
-    p = buf;
-    q = buf + buflen;
-    while (p != q) {
-      hextmp[0] = hexdig[*p >> 4];
-      hextmp[1] = hexdig[*p & 0xf];
+    static const char kHexDigit[] = "0123456789ABCDEF";
+    for (uint8_t b : in) {
+      char hextmp[2];
+      hextmp[0] = kHexDigit[b >> 4];
+      hextmp[1] = kHexDigit[b & 0xf];
       if (!maybe_write(out, hextmp, 2)) {
         return -1;
       }
-      p++;
     }
   }
-  return buflen << 1;
+  return static_cast<int>(in.size() * 2);
 }
 
 // "dump" a string. This is done when the type is unknown, or the flags
@@ -187,37 +187,33 @@ static int do_dump(unsigned long flags, BIO *out, const ASN1_STRING *str) {
 
   // If we don't dump DER encoding just dump content octets
   if (!(flags & ASN1_STRFLGS_DUMP_DER)) {
-    int outlen = do_hex_dump(out, str->data, str->length);
+    int outlen = do_hex_dump(out, Span(str->data, str->length));
     if (outlen < 0) {
       return -1;
     }
     return outlen + 1;
   }
 
-  // Placing the ASN1_STRING in a temporary ASN1_TYPE allows the DER encoding
-  // to readily obtained.
-  ASN1_TYPE t;
-  OPENSSL_memset(&t, 0, sizeof(ASN1_TYPE));
-  asn1_type_set0_string(&t, (ASN1_STRING *)str);
-  unsigned char *der_buf = NULL;
-  int der_len = i2d_ASN1_TYPE(&t, &der_buf);
-  if (der_len < 0) {
+  ScopedCBB cbb;
+  // Roughly estimate the encoded size with `str->length` to reduce unnecessary
+  // reallocations. (Tag, length, miscellaneous type-dependent overhead.)
+  if (!CBB_init(cbb.get(), 4 + str->length) ||
+      !asn1_marshal_any_string(cbb.get(), str)) {
     return -1;
   }
-  int outlen = do_hex_dump(out, der_buf, der_len);
-  OPENSSL_free(der_buf);
+  int outlen = do_hex_dump(out, CBBAsSpan(cbb.get()));
   if (outlen < 0) {
     return -1;
   }
   return outlen + 1;
 }
 
-// string_type_to_encoding returns the |MBSTRING_*| constant for the encoding
-// used by the |ASN1_STRING| type |type|, or -1 if |tag| is not a string
+// string_type_to_encoding returns the `MBSTRING_*` constant for the encoding
+// used by the `ASN1_STRING` type `type`, or -1 if `tag` is not a string
 // type.
 static int string_type_to_encoding(int type) {
   // This function is sometimes passed ASN.1 universal types and sometimes
-  // passed |ASN1_STRING| type values
+  // passed `ASN1_STRING` type values
   switch (type) {
     case V_ASN1_UTF8STRING:
       return MBSTRING_UTF8;
@@ -228,7 +224,7 @@ static int string_type_to_encoding(int type) {
     case V_ASN1_UTCTIME:
     case V_ASN1_GENERALIZEDTIME:
     case V_ASN1_ISO64STRING:
-      // |MBSTRING_ASC| refers to Latin-1, not ASCII.
+      // `MBSTRING_ASC` refers to Latin-1, not ASCII.
       return MBSTRING_ASC;
     case V_ASN1_UNIVERSALSTRING:
       return MBSTRING_UNIV;
@@ -255,7 +251,7 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str,
     outlen++;
   }
 
-  // Decide what to do with |str|, either dump the contents or display it.
+  // Decide what to do with `str`, either dump the contents or display it.
   int encoding;
   if (flags & ASN1_STRFLGS_DUMP_ALL) {
     // Dump everything.
@@ -281,7 +277,7 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str,
 
   // Measure the length.
   char quotes = 0;
-  int len = do_buf(str->data, str->length, encoding, flags, &quotes, NULL);
+  int len = do_buf(str->data, str->length, encoding, flags, &quotes, nullptr);
   if (len < 0) {
     return -1;
   }
@@ -295,7 +291,7 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str,
 
   // Encode the value.
   if ((quotes && !maybe_write(out, "\"", 1)) ||
-      do_buf(str->data, str->length, encoding, flags, NULL, out) < 0 ||
+      do_buf(str->data, str->length, encoding, flags, nullptr, out) < 0 ||
       (quotes && !maybe_write(out, "\"", 1))) {
     return -1;
   }
@@ -304,12 +300,12 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str,
 
 int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str,
                             unsigned long flags) {
-  BIO *bio = NULL;
-  if (fp != NULL) {
-    // If |fp| is NULL, this function returns the number of bytes without
+  BIO *bio = nullptr;
+  if (fp != nullptr) {
+    // If `fp` is NULL, this function returns the number of bytes without
     // writing.
     bio = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (bio == NULL) {
+    if (bio == nullptr) {
       return -1;
     }
   }
@@ -328,7 +324,7 @@ int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in) {
     return -1;
   }
   ASN1_STRING stmp, *str = &stmp;
-  stmp.data = NULL;
+  stmp.data = nullptr;
   stmp.length = 0;
   stmp.flags = 0;
   int ret =
@@ -345,7 +341,7 @@ int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v) {
   char buf[80];
   const char *p;
 
-  if (v == NULL) {
+  if (v == nullptr) {
     return 0;
   }
   n = 0;

data/third_party/boringssl-with-bazel/crypto/asn1/a_strnid.cc

@@ -18,23 +18,32 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <iterator>
+
 #include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/obj.h>
 
 #include "../internal.h"
 #include "../lhash/internal.h"
+#include "../mem_internal.h"
 #include "internal.h"
 
 
+using namespace bssl;
+
+BSSL_NAMESPACE_BEGIN
+
 DEFINE_LHASH_OF(ASN1_STRING_TABLE)
 
-static LHASH_OF(ASN1_STRING_TABLE) *string_tables = NULL;
-static CRYPTO_MUTEX string_tables_lock = CRYPTO_MUTEX_INIT;
+BSSL_NAMESPACE_END
+
+static LHASH_OF(ASN1_STRING_TABLE) *string_tables = nullptr;
+static StaticMutex string_tables_lock;
 
 void ASN1_STRING_set_default_mask(unsigned long mask) {}
 
-unsigned long ASN1_STRING_get_default_mask(void) { return B_ASN1_UTF8STRING; }
+unsigned long ASN1_STRING_get_default_mask() { return B_ASN1_UTF8STRING; }
 
 int ASN1_STRING_set_default_mask_asc(const char *p) { return 1; }
 
@@ -46,13 +55,13 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid);
 
 ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in,
                                     ossl_ssize_t len, int inform, int nid) {
-  ASN1_STRING *str = NULL;
+  ASN1_STRING *str = nullptr;
   int ret;
   if (!out) {
     out = &str;
   }
   const ASN1_STRING_TABLE *tbl = asn1_string_table_get(nid);
-  if (tbl != NULL) {
+  if (tbl != nullptr) {
     unsigned long mask = tbl->mask;
     if (!(tbl->flags & STABLE_NO_MASK)) {
       mask &= B_ASN1_UTF8STRING;
@@ -63,7 +72,7 @@ ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in,
     ret = ASN1_mbstring_copy(out, in, len, inform, B_ASN1_UTF8STRING);
   }
   if (ret <= 0) {
-    return NULL;
+    return nullptr;
   }
   return *out;
 }
@@ -129,19 +138,19 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid) {
   ASN1_STRING_TABLE key;
   key.nid = nid;
   const ASN1_STRING_TABLE *tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
-      bsearch(&key, tbl_standard, OPENSSL_ARRAY_SIZE(tbl_standard),
+      bsearch(&key, tbl_standard, std::size(tbl_standard),
               sizeof(ASN1_STRING_TABLE), table_cmp_void));
-  if (tbl != NULL) {
+  if (tbl != nullptr) {
     return tbl;
   }
 
-  CRYPTO_MUTEX_lock_read(&string_tables_lock);
-  if (string_tables != NULL) {
+  string_tables_lock.LockRead();
+  if (string_tables != nullptr) {
     tbl = lh_ASN1_STRING_TABLE_retrieve(string_tables, &key);
   }
-  CRYPTO_MUTEX_unlock_read(&string_tables_lock);
-  // Note returning |tbl| without the lock is only safe because
-  // |ASN1_STRING_TABLE_add| cannot modify or delete existing entries. If we
+  string_tables_lock.UnlockRead();
+  // Note returning `tbl` without the lock is only safe because
+  // `ASN1_STRING_TABLE_add` cannot modify or delete existing entries. If we
   // wish to support that, this function must copy the result under a lock.
   return tbl;
 }
@@ -149,35 +158,32 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid) {
 int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
                           unsigned long mask, unsigned long flags) {
   // Existing entries cannot be overwritten.
-  if (asn1_string_table_get(nid) != NULL) {
+  if (asn1_string_table_get(nid) != nullptr) {
     OPENSSL_PUT_ERROR(ASN1, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
     return 0;
   }
 
-  int ret = 0;
-  CRYPTO_MUTEX_lock_write(&string_tables_lock);
-
-  ASN1_STRING_TABLE *tbl = NULL;
-  if (string_tables == NULL) {
+  MutexWriteLock lock(&string_tables_lock);
+  ASN1_STRING_TABLE *tbl = nullptr;
+  if (string_tables == nullptr) {
     string_tables = lh_ASN1_STRING_TABLE_new(table_hash, table_cmp);
-    if (string_tables == NULL) {
-      goto err;
+    if (string_tables == nullptr) {
+      return 0;
     }
   } else {
     // Check again for an existing entry. One may have been added while
     // unlocked.
     ASN1_STRING_TABLE key;
     key.nid = nid;
-    if (lh_ASN1_STRING_TABLE_retrieve(string_tables, &key) != NULL) {
+    if (lh_ASN1_STRING_TABLE_retrieve(string_tables, &key) != nullptr) {
       OPENSSL_PUT_ERROR(ASN1, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-      goto err;
+      return 0;
     }
   }
 
-  tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
-      OPENSSL_malloc(sizeof(ASN1_STRING_TABLE)));
-  if (tbl == NULL) {
-    goto err;
+  tbl = New<ASN1_STRING_TABLE>();
+  if (tbl == nullptr) {
+    return 0;
   }
   tbl->nid = nid;
   tbl->flags = flags;
@@ -186,21 +192,17 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
   tbl->mask = mask;
   ASN1_STRING_TABLE *old_tbl;
   if (!lh_ASN1_STRING_TABLE_insert(string_tables, &old_tbl, tbl)) {
-    OPENSSL_free(tbl);
-    goto err;
+    Delete(tbl);
+    return 0;
   }
-  assert(old_tbl == NULL);
-  ret = 1;
-
-err:
-  CRYPTO_MUTEX_unlock_write(&string_tables_lock);
-  return ret;
+  assert(old_tbl == nullptr);
+  return 1;
 }
 
-void ASN1_STRING_TABLE_cleanup(void) {}
+void ASN1_STRING_TABLE_cleanup() {}
 
-void asn1_get_string_table_for_testing(const ASN1_STRING_TABLE **out_ptr,
-                                       size_t *out_len) {
+void bssl::asn1_get_string_table_for_testing(const ASN1_STRING_TABLE **out_ptr,
+                                             size_t *out_len) {
   *out_ptr = tbl_standard;
-  *out_len = OPENSSL_ARRAY_SIZE(tbl_standard);
+  *out_len = std::size(tbl_standard);
 }

data/third_party/boringssl-with-bazel/crypto/asn1/a_time.cc

@@ -15,6 +15,8 @@
 #include <openssl/asn1.h>
 #include <openssl/posix_time.h>
 
+#include <assert.h>
+#include <stdio.h>
 #include <string.h>
 #include <time.h>
 
@@ -25,12 +27,19 @@
 
 #include "internal.h"
 
+
+using namespace bssl;
+
 // This is an implementation of the ASN1 Time structure which is: Time ::=
 // CHOICE { utcTime UTCTime, generalTime GeneralizedTime } written by Steve
 // Henson.
 
+BSSL_NAMESPACE_BEGIN
+
 IMPLEMENT_ASN1_MSTRING(ASN1_TIME, B_ASN1_TIME)
 
+BSSL_NAMESPACE_END
+
 IMPLEMENT_ASN1_FUNCTIONS_const(ASN1_TIME)
 
 ASN1_TIME *ASN1_TIME_set_posix(ASN1_TIME *s, int64_t posix_time) {
@@ -51,11 +60,11 @@ ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, int64_t posix_time, int offset_day,
 
   if (!OPENSSL_posix_to_tm(posix_time, &tm)) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_ERROR_GETTING_TIME);
-    return NULL;
+    return nullptr;
   }
   if (offset_day || offset_sec) {
     if (!OPENSSL_gmtime_adj(&tm, offset_day, offset_sec)) {
-      return NULL;
+      return nullptr;
     }
   }
   if (fits_in_utc_time(&tm)) {
@@ -77,14 +86,17 @@ int ASN1_TIME_check(const ASN1_TIME *t) {
 ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *in,
                                                    ASN1_GENERALIZEDTIME **out) {
   if (!ASN1_TIME_check(in)) {
-    return NULL;
+    return nullptr;
   }
 
-  ASN1_GENERALIZEDTIME *ret = NULL;
+  UniquePtr<ASN1_GENERALIZEDTIME> tmp;
+  ASN1_GENERALIZEDTIME *ret = nullptr;
   if (!out || !*out) {
-    if (!(ret = ASN1_GENERALIZEDTIME_new())) {
-      goto err;
+    tmp.reset(ASN1_GENERALIZEDTIME_new());
+    if (tmp == nullptr) {
+      return nullptr;
     }
+    ret = tmp.get();
   } else {
     ret = *out;
   }
@@ -92,40 +104,35 @@ ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *in,
   // If already GeneralizedTime just copy across
   if (in->type == V_ASN1_GENERALIZEDTIME) {
     if (!ASN1_STRING_set(ret, in->data, in->length)) {
-      goto err;
+      return nullptr;
     }
-    goto done;
-  }
-
-  // Grow the string to accomodate the two-digit century.
-  if (!ASN1_STRING_set(ret, NULL, in->length + 2)) {
-    goto err;
-  }
-
-  {
-    char *const out_str = (char *)ret->data;
-    // |ASN1_STRING_set| also allocates an additional byte for a trailing NUL.
-    const size_t out_str_capacity = in->length + 2 + 1;
-    // Work out the century and prepend
+  } else {
+    assert(in->type == V_ASN1_UTCTIME);
+    // `ASN1_TIME_check` implies a bound on the string's lengths. In particular,
+    // the longest possible UTCTime is "YYMMDDHHMMSS+HHMM", with the (invalid)
+    // timezone offsets.
+    static constexpr size_t kMaxUTCTimeLength = 17;
+    BSSL_CHECK(in->length > 0 &&
+               static_cast<size_t>(in->length) <= kMaxUTCTimeLength);
+    char buf[2 /* century */ + kMaxUTCTimeLength + 1 /* NUL */];
+    // Work out the century and prepend.
     if (in->data[0] >= '5') {
-      OPENSSL_strlcpy(out_str, "19", out_str_capacity);
+      snprintf(buf, sizeof(buf), "19%.*s", in->length,
+               reinterpret_cast<const char *>(in->data));
     } else {
-      OPENSSL_strlcpy(out_str, "20", out_str_capacity);
+      snprintf(buf, sizeof(buf), "20%.*s", in->length,
+               reinterpret_cast<const char *>(in->data));
+    }
+    if (!ASN1_STRING_set(ret, buf, -1 /* use strlen */)) {
+      return nullptr;
     }
-    OPENSSL_strlcat(out_str, (const char *)in->data, out_str_capacity);
   }
 
-done:
-  if (out != NULL && *out == NULL) {
+  if (out != nullptr && *out == nullptr) {
     *out = ret;
   }
+  tmp.release();  // Ownership passed to caller.
   return ret;
-
-err:
-  if (out == NULL || *out != ret) {
-    ASN1_GENERALIZEDTIME_free(ret);
-  }
-  return NULL;
 }
 
 int ASN1_TIME_set_string(ASN1_TIME *s, const char *str) {
@@ -138,7 +145,7 @@ int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str) {
   CBS_init(&cbs, (const uint8_t *)str, strlen(str));
   int type;
   struct tm tm;
-  if (CBS_parse_utc_time(&cbs, /*out_tm=*/NULL,
+  if (CBS_parse_utc_time(&cbs, /*out_tm=*/nullptr,
                          /*allow_timezone_offset=*/0)) {
     type = V_ASN1_UTCTIME;
   } else if (CBS_parse_generalized_time(&cbs, &tm,
@@ -152,7 +159,7 @@ int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str) {
     return 0;
   }
 
-  if (s != NULL) {
+  if (s != nullptr) {
     if (!ASN1_STRING_set(s, CBS_data(&cbs), CBS_len(&cbs))) {
       return 0;
     }
@@ -163,8 +170,8 @@ int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str) {
 
 static int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *t,
                            int allow_timezone_offset) {
-  if (t == NULL) {
-    if (OPENSSL_posix_to_tm(time(NULL), tm)) {
+  if (t == nullptr) {
+    if (OPENSSL_posix_to_tm(time(nullptr), tm)) {
       return 1;
     }
     return 0;
@@ -222,3 +229,20 @@ int ASN1_TIME_to_posix(const ASN1_TIME *t, int64_t *out_time) {
   }
   return OPENSSL_tm_to_posix(&tm, out_time);
 }
+
+int bssl::asn1_parse_time(CBS *cbs, ASN1_TIME *out,
+                          int allow_utc_timezone_offset) {
+  if (CBS_peek_asn1_tag(cbs, CBS_ASN1_UTCTIME)) {
+    return asn1_parse_utc_time(cbs, out, /*tag=*/0, allow_utc_timezone_offset);
+  }
+  return asn1_parse_generalized_time(cbs, out, /*tag=*/0);
+}
+
+int bssl::asn1_marshal_time(CBB *cbb, const ASN1_TIME *in) {
+  if (in->type != V_ASN1_UTCTIME && in->type != V_ASN1_GENERALIZEDTIME) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_WRONG_TYPE);
+    return 0;
+  }
+  return asn1_marshal_octet_string(cbb, in,
+                                   static_cast<CBS_ASN1_TAG>(in->type));
+}