grpc 1.84.1 → 1.85.0.pre1

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

@@ -20,10 +20,12 @@
 #include "internal.h"
 
 
+using namespace bssl;
+
 // kMaxDepth limits the recursion depth to avoid overflowing the stack.
 static const uint32_t kMaxDepth = 128;
 
-// is_string_type returns one if |tag| is a string type and zero otherwise. It
+// is_string_type returns one if `tag` is a string type and zero otherwise. It
 // ignores the constructed bit.
 static int is_string_type(CBS_ASN1_TAG tag) {
   // While BER supports constructed BIT STRINGS, OpenSSL misparses them. To
@@ -48,10 +50,10 @@ static int is_string_type(CBS_ASN1_TAG tag) {
   }
 }
 
-// cbs_find_ber walks an ASN.1 structure in |orig_in| and sets |*ber_found|
+// cbs_find_ber walks an ASN.1 structure in `orig_in` and sets `*ber_found`
 // depending on whether an indefinite length element or constructed string was
-// found. The value of |orig_in| is not changed. It returns one on success (i.e.
-// |*ber_found| was set) and zero on error.
+// found. The value of `orig_in` is not changed. It returns one on success (i.e.
+// `*ber_found` was set) and zero on error.
 static int cbs_find_ber(const CBS *orig_in, int *ber_found, uint32_t depth) {
   if (depth > kMaxDepth) {
     return 0;
@@ -92,8 +94,8 @@ static int cbs_find_ber(const CBS *orig_in, int *ber_found, uint32_t depth) {
   return 1;
 }
 
-// cbs_get_eoc returns one if |cbs| begins with an "end of contents" (EOC) value
-// and zero otherwise. If an EOC was found, it advances |cbs| past it.
+// cbs_get_eoc returns one if `cbs` begins with an "end of contents" (EOC) value
+// and zero otherwise. If an EOC was found, it advances `cbs` past it.
 static int cbs_get_eoc(CBS *cbs) {
   if (CBS_len(cbs) >= 2 &&
       CBS_data(cbs)[0] == 0 && CBS_data(cbs)[1] == 0) {
@@ -102,11 +104,11 @@ static int cbs_get_eoc(CBS *cbs) {
   return 0;
 }
 
-// cbs_convert_ber reads BER data from |in| and writes DER data to |out|. If
-// |string_tag| is non-zero, then all elements must match |string_tag| up to the
-// constructed bit and primitive element bodies are written to |out| without
+// cbs_convert_ber reads BER data from `in` and writes DER data to `out`. If
+// `string_tag` is non-zero, then all elements must match `string_tag` up to the
+// constructed bit and primitive element bodies are written to `out` without
 // element headers. This is used when concatenating the fragments of a
-// constructed string. If |looking_for_eoc| is set then any EOC elements found
+// constructed string. If `looking_for_eoc` is set then any EOC elements found
 // will cause the function to return after consuming it. It returns one on
 // success and zero on error.
 static int cbs_convert_ber(CBS *in, CBB *out, CBS_ASN1_TAG string_tag,
@@ -128,13 +130,13 @@ static int cbs_convert_ber(CBS *in, CBB *out, CBS_ASN1_TAG string_tag,
     int indefinite;
     CBB *out_contents, out_contents_storage;
     if (!CBS_get_any_ber_asn1_element(in, &contents, &tag, &header_len,
-                                      /*out_ber_found=*/NULL, &indefinite)) {
+                                      /*out_ber_found=*/nullptr, &indefinite)) {
       return 0;
     }
 
     if (string_tag != 0) {
       // This is part of a constructed string. All elements must match
-      // |string_tag| up to the constructed bit and get appended to |out|
+      // `string_tag` up to the constructed bit and get appended to `out`
       // without a child element.
       if ((tag & ~CBS_ASN1_CONSTRUCTED) != string_tag) {
         return 0;
@@ -189,7 +191,7 @@ static int cbs_convert_ber(CBS *in, CBB *out, CBS_ASN1_TAG string_tag,
   return looking_for_eoc == 0;
 }
 
-int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
+int bssl::CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
   CBB cbb;
 
   // First, do a quick walk to find any indefinite-length elements. Most of the
@@ -200,10 +202,10 @@ int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
   }
 
   if (!conversion_needed) {
-    if (!CBS_get_any_asn1_element(in, out, NULL, NULL)) {
+    if (!CBS_get_any_asn1_element(in, out, nullptr, nullptr)) {
       return 0;
     }
-    *out_storage = NULL;
+    *out_storage = nullptr;
     return 1;
   }
 
@@ -219,21 +221,21 @@ int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
   return 1;
 }
 
-int CBS_get_asn1_implicit_string(CBS *in, CBS *out, uint8_t **out_storage,
-                                 CBS_ASN1_TAG outer_tag,
-                                 CBS_ASN1_TAG inner_tag) {
+int bssl::CBS_get_asn1_implicit_string(CBS *in, CBS *out, uint8_t **out_storage,
+                                       CBS_ASN1_TAG outer_tag,
+                                       CBS_ASN1_TAG inner_tag) {
   assert(!(outer_tag & CBS_ASN1_CONSTRUCTED));
   assert(!(inner_tag & CBS_ASN1_CONSTRUCTED));
   assert(is_string_type(inner_tag));
 
   if (CBS_peek_asn1_tag(in, outer_tag)) {
     // Normal implicitly-tagged string.
-    *out_storage = NULL;
+    *out_storage = nullptr;
     return CBS_get_asn1(in, out, outer_tag);
   }
 
   // Otherwise, try to parse an implicitly-tagged constructed string.
-  // |CBS_asn1_ber_to_der| is assumed to have run, so only allow one level deep
+  // `CBS_asn1_ber_to_der` is assumed to have run, so only allow one level deep
   // of nesting.
   CBB result;
   CBS child;

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

@@ -22,13 +22,16 @@
 #include <openssl/mem.h>
 
 #include "../internal.h"
+#include "internal.h"
 
 
+using namespace bssl;
+
 void CBB_zero(CBB *cbb) { OPENSSL_memset(cbb, 0, sizeof(CBB)); }
 
 static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
   cbb->is_child = 0;
-  cbb->child = NULL;
+  cbb->child = nullptr;
   cbb->u.base.buf = buf;
   cbb->u.base.len = 0;
   cbb->u.base.cap = cap;
@@ -40,7 +43,7 @@ int CBB_init(CBB *cbb, size_t initial_capacity) {
   CBB_zero(cbb);
 
   uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(initial_capacity));
-  if (initial_capacity > 0 && buf == NULL) {
+  if (initial_capacity > 0 && buf == nullptr) {
     return 0;
   }
 
@@ -55,8 +58,8 @@ int CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len) {
 }
 
 void CBB_cleanup(CBB *cbb) {
-  // Child |CBB|s are non-owning. They are implicitly discarded and should not
-  // be used with |CBB_cleanup| or |ScopedCBB|.
+  // Child `CBB`s are non-owning. They are implicitly discarded and should not
+  // be used with `CBB_cleanup` or `ScopedCBB`.
   assert(!cbb->is_child);
   if (cbb->is_child) {
     return;
@@ -64,12 +67,13 @@ void CBB_cleanup(CBB *cbb) {
 
   if (cbb->u.base.can_resize) {
     OPENSSL_free(cbb->u.base.buf);
+    cbb->u.base.buf = nullptr;
   }
 }
 
 static int cbb_buffer_reserve(struct cbb_buffer_st *base, uint8_t **out,
                               size_t len) {
-  if (base == NULL) {
+  if (base == nullptr) {
     return 0;
   }
 
@@ -92,7 +96,7 @@ static int cbb_buffer_reserve(struct cbb_buffer_st *base, uint8_t **out,
     }
     uint8_t *newbuf =
         reinterpret_cast<uint8_t *>(OPENSSL_realloc(base->buf, newcap));
-    if (newbuf == NULL) {
+    if (newbuf == nullptr) {
       goto err;
     }
 
@@ -116,7 +120,7 @@ static int cbb_buffer_add(struct cbb_buffer_st *base, uint8_t **out,
   if (!cbb_buffer_reserve(base, out, len)) {
     return 0;
   }
-  // This will not overflow or |cbb_buffer_reserve| would have failed.
+  // This will not overflow or `cbb_buffer_reserve` would have failed.
   base->len += len;
   return 1;
 }
@@ -131,18 +135,18 @@ int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len) {
     return 0;
   }
 
-  if (cbb->u.base.can_resize && (out_data == NULL || out_len == NULL)) {
-    // |out_data| and |out_len| can only be NULL if the CBB is fixed.
+  if (cbb->u.base.can_resize && (out_data == nullptr || out_len == nullptr)) {
+    // `out_data` and `out_len` can only be NULL if the CBB is fixed.
     return 0;
   }
 
-  if (out_data != NULL) {
+  if (out_data != nullptr) {
     *out_data = cbb->u.base.buf;
   }
-  if (out_len != NULL) {
+  if (out_len != nullptr) {
     *out_len = cbb->u.base.len;
   }
-  cbb->u.base.buf = NULL;
+  cbb->u.base.buf = nullptr;
   CBB_cleanup(cbb);
   return 1;
 }
@@ -155,41 +159,41 @@ static struct cbb_buffer_st *cbb_get_base(CBB *cbb) {
 }
 
 static void cbb_on_error(CBB *cbb) {
-  // Due to C's lack of destructors and |CBB|'s auto-flushing API, a failing
-  // |CBB|-taking function may leave a dangling pointer to a child |CBB|. As a
-  // result, the convention is callers may not write to |CBB|s that have failed.
-  // But, as a safety measure, we lock the |CBB| into an error state. Once the
-  // error bit is set, |cbb->child| will not be read.
+  // Due to C's lack of destructors and `CBB`'s auto-flushing API, a failing
+  // `CBB`-taking function may leave a dangling pointer to a child `CBB`. As a
+  // result, the convention is callers may not write to `CBB`s that have failed.
+  // But, as a safety measure, we lock the `CBB` into an error state. Once the
+  // error bit is set, `cbb->child` will not be read.
   //
-  // TODO(davidben): This still isn't quite ideal. A |CBB| function *outside*
-  // this file may originate an error while the |CBB| points to a local child.
+  // TODO(davidben): This still isn't quite ideal. A `CBB` function *outside*
+  // this file may originate an error while the `CBB` points to a local child.
   // In that case we don't set the error bit and are reliant on the error
-  // convention. Perhaps we allow |CBB_cleanup| on child |CBB|s and make every
-  // child's |CBB_cleanup| set the error bit if unflushed. That will be
+  // convention. Perhaps we allow `CBB_cleanup` on child `CBB`s and make every
+  // child's `CBB_cleanup` set the error bit if unflushed. That will be
   // convenient for C++ callers, but very tedious for C callers. So C callers
-  // perhaps should get a |CBB_on_error| function that can be, less tediously,
-  // stuck in a |goto err| block.
+  // perhaps should get a `CBB_on_error` function that can be, less tediously,
+  // stuck in a `goto err` block.
   cbb_get_base(cbb)->error = 1;
 
   // Clearing the pointer is not strictly necessary, but GCC's dangling pointer
-  // warning does not know |cbb->child| will not be read once |error| is set
+  // warning does not know `cbb->child` will not be read once `error` is set
   // above.
-  cbb->child = NULL;
+  cbb->child = nullptr;
 }
 
 // CBB_flush recurses and then writes out any pending length prefix. The
 // current length of the underlying base is taken to be the length of the
 // length-prefixed data.
 int CBB_flush(CBB *cbb) {
-  // If |base| has hit an error, the buffer is in an undefined state, so
-  // fail all following calls. In particular, |cbb->child| may point to invalid
+  // If `base` has hit an error, the buffer is in an undefined state, so
+  // fail all following calls. In particular, `cbb->child` may point to invalid
   // memory.
   struct cbb_buffer_st *base = cbb_get_base(cbb);
-  if (base == NULL || base->error) {
+  if (base == nullptr || base->error) {
     return 0;
   }
 
-  if (cbb->child == NULL) {
+  if (cbb->child == nullptr) {
     // Nothing to flush.
     return 1;
   }
@@ -241,7 +245,7 @@ int CBB_flush(CBB *cbb) {
     if (len_len != 1) {
       // We need to move the contents along in order to make space.
       size_t extra_bytes = len_len - 1;
-      if (!cbb_buffer_add(base, NULL, extra_bytes)) {
+      if (!cbb_buffer_add(base, nullptr, extra_bytes)) {
         goto err;
       }
       OPENSSL_memmove(base->buf + child_start + extra_bytes,
@@ -260,8 +264,8 @@ int CBB_flush(CBB *cbb) {
     goto err;
   }
 
-  child->base = NULL;
-  cbb->child = NULL;
+  child->base = nullptr;
+  cbb->child = nullptr;
 
   return 1;
 
@@ -270,8 +274,8 @@ err:
   return 0;
 }
 
-const uint8_t *CBB_data(const CBB *cbb) {
-  assert(cbb->child == NULL);
+uint8_t *CBB_data(const CBB *cbb) {
+  assert(cbb->child == nullptr);
   if (cbb->is_child) {
     return cbb->u.child.base->buf + cbb->u.child.offset +
            cbb->u.child.pending_len_len;
@@ -280,7 +284,7 @@ const uint8_t *CBB_data(const CBB *cbb) {
 }
 
 size_t CBB_len(const CBB *cbb) {
-  assert(cbb->child == NULL);
+  assert(cbb->child == nullptr);
   if (cbb->is_child) {
     assert(cbb->u.child.offset + cbb->u.child.pending_len_len <=
            cbb->u.child.base->len);
@@ -292,7 +296,7 @@ size_t CBB_len(const CBB *cbb) {
 
 static int cbb_add_child(CBB *cbb, CBB *out_child, uint8_t len_len,
                          int is_asn1) {
-  assert(cbb->child == NULL);
+  assert(cbb->child == nullptr);
   assert(!is_asn1 || len_len == 1);
   struct cbb_buffer_st *base = cbb_get_base(cbb);
   size_t offset = base->len;
@@ -335,7 +339,7 @@ int CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents) {
   return cbb_add_length_prefixed(cbb, out_contents, 3);
 }
 
-// add_base128_integer encodes |v| as a big-endian base-128 integer where the
+// add_base128_integer encodes `v` as a big-endian base-128 integer where the
 // high bit of each byte indicates where there is more data. This is the
 // encoding used in DER for both high tag number form and OID components.
 static int add_base128_integer(CBB *cbb, uint64_t v) {
@@ -379,7 +383,7 @@ int CBB_add_asn1(CBB *cbb, CBB *out_contents, CBS_ASN1_TAG tag) {
     return 0;
   }
 
-  // Reserve one byte of length prefix. |CBB_flush| will finish it later.
+  // Reserve one byte of length prefix. `CBB_flush` will finish it later.
   return cbb_add_child(cbb, out_contents, /*len_len=*/1, /*is_asn1=*/1);
 }
 
@@ -419,7 +423,7 @@ int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len) {
 int CBB_did_write(CBB *cbb, size_t len) {
   struct cbb_buffer_st *base = cbb_get_base(cbb);
   size_t newlen = base->len + len;
-  if (cbb->child != NULL || newlen < base->len || newlen > base->cap) {
+  if (cbb->child != nullptr || newlen < base->len || newlen > base->cap) {
     return 0;
   }
   base->len = newlen;
@@ -437,7 +441,7 @@ static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
     v >>= 8;
   }
 
-  // |v| must fit in |len_len| bytes.
+  // `v` must fit in `len_len` bytes.
   if (v != 0) {
     cbb_on_error(cbb);
     return 0;
@@ -468,8 +472,15 @@ int CBB_add_u64le(CBB *cbb, uint64_t value) {
   return CBB_add_u64(cbb, CRYPTO_bswap8(value));
 }
 
+void CBB_discard(CBB *cbb, size_t len) {
+  BSSL_CHECK(cbb->child == nullptr);
+  BSSL_CHECK(len <= CBB_len(cbb));
+  struct cbb_buffer_st *base = cbb_get_base(cbb);
+  base->len -= len;
+}
+
 void CBB_discard_child(CBB *cbb) {
-  if (cbb->child == NULL) {
+  if (cbb->child == nullptr) {
     return;
   }
 
@@ -477,8 +488,21 @@ void CBB_discard_child(CBB *cbb) {
   assert(cbb->child->is_child);
   base->len = cbb->child->u.child.offset;
 
-  cbb->child->u.child.base = NULL;
-  cbb->child = NULL;
+  cbb->child->u.child.base = nullptr;
+  cbb->child = nullptr;
+}
+
+int CBB_add_asn1_element(CBB *cbb, CBS_ASN1_TAG tag, const uint8_t *data,
+                         size_t data_len) {
+  CBB child;
+  if (!CBB_add_asn1(cbb, &child, tag) ||
+      !CBB_add_bytes(&child, data, data_len) ||  //
+      !CBB_flush(cbb)) {
+    cbb_on_error(cbb);
+    return 0;
+  }
+
+  return 1;
 }
 
 int CBB_add_asn1_uint64(CBB *cbb, uint64_t value) {
@@ -557,14 +581,7 @@ err:
 }
 
 int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
-  CBB child;
-  if (!CBB_add_asn1(cbb, &child, CBS_ASN1_OCTETSTRING) ||
-      !CBB_add_bytes(&child, data, data_len) || !CBB_flush(cbb)) {
-    cbb_on_error(cbb);
-    return 0;
-  }
-
-  return 1;
+  return CBB_add_asn1_element(cbb, CBS_ASN1_OCTETSTRING, data, data_len);
 }
 
 int CBB_add_asn1_bool(CBB *cbb, int value) {
@@ -578,9 +595,9 @@ int CBB_add_asn1_bool(CBB *cbb, int value) {
   return 1;
 }
 
-// parse_dotted_decimal parses one decimal component from |cbs|, where |cbs| is
+// parse_dotted_decimal parses one decimal component from `cbs`, where `cbs` is
 // an OID literal, e.g., "1.2.840.113554.4.1.72585". It consumes both the
-// component and the dot, so |cbs| may be passed into the function again for the
+// component and the dot, so `cbs` may be passed into the function again for the
 // next value.
 static int parse_dotted_decimal(CBS *cbs, uint64_t *out) {
   if (!CBS_get_u64_decimal(cbs, out)) {
@@ -608,8 +625,8 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
     return 0;
   }
 
-  // The first component is encoded as 40 * |a| + |b|. This assumes that |a| is
-  // 0, 1, or 2 and that, when it is 0 or 1, |b| is at most 39.
+  // The first component is encoded as 40 * `a` + `b`. This assumes that `a` is
+  // 0, 1, or 2 and that, when it is 0 or 1, `b` is at most 39.
   if (a > 2 || (a < 2 && b > 39) || b > UINT64_MAX - 80 ||
       !add_base128_integer(cbb, 40u * a + b)) {
     return 0;
@@ -625,6 +642,38 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
   return 1;
 }
 
+int CBB_add_asn1_relative_oid_from_text(CBB *cbb, const char *text,
+                                        size_t len) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  // Relative OIDs must have at least one component.
+  if (!len) {
+    return 0;
+  }
+
+  CBS cbs;
+  CBS_init(&cbs, reinterpret_cast<const uint8_t *>(text), len);
+
+  while (CBS_len(&cbs) > 0) {
+    uint64_t a;
+    if (!parse_dotted_decimal(&cbs, &a) || !add_base128_integer(cbb, a)) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+int CBB_add_asn1_oid_component(CBB *cbb, uint64_t value) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  return add_base128_integer(cbb, value);
+}
+
 static int compare_set_of_element(const void *a_ptr, const void *b_ptr) {
   // See X.690, section 11.6 for the ordering. They are sorted in ascending
   // order by their DER encoding.
@@ -653,7 +702,7 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   size_t num_children = 0;
   CBS_init(&cbs, CBB_data(cbb), CBB_len(cbb));
   while (CBS_len(&cbs) != 0) {
-    if (!CBS_get_any_asn1_element(&cbs, NULL, NULL, NULL)) {
+    if (!CBS_get_any_asn1_element(&cbs, nullptr, nullptr, nullptr)) {
       OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
       return 0;
     }
@@ -665,7 +714,7 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   }
 
   // Parse out the children and sort. We alias them into a copy of so they
-  // remain valid as we rewrite |cbb|.
+  // remain valid as we rewrite `cbb`.
   int ret = 0;
   size_t buf_len = CBB_len(cbb);
   uint8_t *buf =
@@ -674,12 +723,12 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
       reinterpret_cast<CBS *>(OPENSSL_calloc(num_children, sizeof(CBS)));
   uint8_t *out;
   size_t offset = 0;
-  if (buf == NULL || children == NULL) {
+  if (buf == nullptr || children == nullptr) {
     goto err;
   }
   CBS_init(&cbs, buf, buf_len);
   for (size_t i = 0; i < num_children; i++) {
-    if (!CBS_get_any_asn1_element(&cbs, &children[i], NULL, NULL)) {
+    if (!CBS_get_any_asn1_element(&cbs, &children[i], nullptr, nullptr)) {
       goto err;
     }
   }
@@ -700,3 +749,14 @@ err:
   OPENSSL_free(children);
   return ret;
 }
+
+bool bssl::CBBFinishArray(CBB *cbb, Array<uint8_t> *out) {
+  uint8_t *ptr;
+  size_t len;
+  if (!CBB_finish(cbb, &ptr, &len)) {
+    OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+  out->Reset(ptr, len);
+  return true;
+}