visaljs 0.0.2 → 0.0.3

package/runtime/third_party/boringssl/crypto/bytestring/cbb.cc

@@ -0,0 +1,787 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/bytestring.h>
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <algorithm>
+
+#include <openssl/err.h>
+#include <openssl/mem.h>
+
+#include "../internal.h"
+#include "../mem_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 = nullptr;
+  cbb->u.base.buf = buf;
+  cbb->u.base.len = 0;
+  cbb->u.base.cap = cap;
+  cbb->u.base.can_resize = can_resize;
+  cbb->u.base.error = 0;
+}
+
+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 == nullptr) {
+    return 0;
+  }
+
+  cbb_init(cbb, buf, initial_capacity, /*can_resize=*/1);
+  return 1;
+}
+
+int CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len) {
+  CBB_zero(cbb);
+  cbb_init(cbb, buf, len, /*can_resize=*/0);
+  return 1;
+}
+
+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`.
+  assert(!cbb->is_child);
+  if (cbb->is_child) {
+    return;
+  }
+
+  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 == nullptr) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
+    return 0;
+  }
+
+  size_t newlen = base->len + len;
+  if (newlen < base->len) {
+    // Overflow
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+    goto err;
+  }
+
+  if (newlen > base->cap) {
+    if (!base->can_resize) {
+      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+      goto err;
+    }
+
+    size_t newcap = base->cap * 2;
+    if (newcap < base->cap || newcap < newlen) {
+      newcap = newlen;
+    }
+    uint8_t *newbuf =
+        reinterpret_cast<uint8_t *>(OPENSSL_realloc(base->buf, newcap));
+    if (newbuf == nullptr) {
+      goto err;
+    }
+
+    base->buf = newbuf;
+    base->cap = newcap;
+  }
+
+  if (out) {
+    *out = base->buf + base->len;
+  }
+
+  return 1;
+
+err:
+  base->error = 1;
+  return 0;
+}
+
+static int cbb_buffer_add(struct cbb_buffer_st *base, uint8_t **out,
+                          size_t len) {
+  if (!cbb_buffer_reserve(base, out, len)) {
+    return 0;
+  }
+  // This will not overflow or `cbb_buffer_reserve` would have failed.
+  base->len += len;
+  return 1;
+}
+
+int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len) {
+  if (cbb->is_child) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+    return 0;
+  }
+
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  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.
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+    return 0;
+  }
+
+  if (out_data != nullptr) {
+    *out_data = cbb->u.base.buf;
+  }
+  if (out_len != nullptr) {
+    *out_len = cbb->u.base.len;
+  }
+  cbb->u.base.buf = nullptr;
+  CBB_cleanup(cbb);
+  return 1;
+}
+
+static struct cbb_buffer_st *cbb_get_base(CBB *cbb) {
+  if (cbb->is_child) {
+    return cbb->u.child.base;
+  }
+  return &cbb->u.base;
+}
+
+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.
+  //
+  // 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
+  // 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.
+  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
+  // above.
+  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
+  // memory.
+  struct cbb_buffer_st *base = cbb_get_base(cbb);
+  if (base == nullptr || base->error) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+    return 0;
+  }
+
+  if (cbb->child == nullptr) {
+    // Nothing to flush.
+    return 1;
+  }
+
+  assert(cbb->child->is_child);
+  struct cbb_child_st *child = &cbb->child->u.child;
+  assert(child->base == base);
+  size_t child_start = child->offset + child->pending_len_len;
+
+  size_t len;
+  if (!CBB_flush(cbb->child)) {
+    goto err;
+  }
+  if (child_start < child->offset || base->len < child_start) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    goto err;
+  }
+
+  len = base->len - child_start;
+
+  if (child->pending_is_asn1) {
+    // For ASN.1 we assume that we'll only need a single byte for the length.
+    // If that turned out to be incorrect, we have to move the contents along
+    // in order to make space.
+    uint8_t len_len;
+    uint8_t initial_length_byte;
+
+    assert(child->pending_len_len == 1);
+
+    if (len > 0xfffffffe) {
+      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+      // Too large.
+      goto err;
+    } else if (len > 0xffffff) {
+      len_len = 5;
+      initial_length_byte = 0x80 | 4;
+    } else if (len > 0xffff) {
+      len_len = 4;
+      initial_length_byte = 0x80 | 3;
+    } else if (len > 0xff) {
+      len_len = 3;
+      initial_length_byte = 0x80 | 2;
+    } else if (len > 0x7f) {
+      len_len = 2;
+      initial_length_byte = 0x80 | 1;
+    } else {
+      len_len = 1;
+      initial_length_byte = (uint8_t)len;
+      len = 0;
+    }
+
+    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, nullptr, extra_bytes)) {
+        goto err;
+      }
+      OPENSSL_memmove(base->buf + child_start + extra_bytes,
+                      base->buf + child_start, len);
+    }
+    base->buf[child->offset++] = initial_length_byte;
+    child->pending_len_len = len_len - 1;
+  }
+
+  for (size_t i = child->pending_len_len - 1; i < child->pending_len_len; i--) {
+    base->buf[child->offset + i] = (uint8_t)len;
+    len >>= 8;
+  }
+  if (len != 0) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+    goto err;
+  }
+
+  child->base = nullptr;
+  cbb->child = nullptr;
+
+  return 1;
+
+err:
+  cbb_on_error(cbb);
+  return 0;
+}
+
+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;
+  }
+  return cbb->u.base.buf;
+}
+
+size_t CBB_len(const CBB *cbb) {
+  assert(cbb->child == nullptr);
+  if (cbb->is_child) {
+    assert(cbb->u.child.offset + cbb->u.child.pending_len_len <=
+           cbb->u.child.base->len);
+    return cbb->u.child.base->len - cbb->u.child.offset -
+           cbb->u.child.pending_len_len;
+  }
+  return cbb->u.base.len;
+}
+
+static int cbb_add_child(CBB *cbb, CBB *out_child, uint8_t len_len,
+                         int is_asn1) {
+  assert(cbb->child == nullptr);
+  assert(!is_asn1 || len_len == 1);
+  struct cbb_buffer_st *base = cbb_get_base(cbb);
+  size_t offset = base->len;
+
+  // Reserve space for the length prefix.
+  uint8_t *prefix_bytes;
+  if (!cbb_buffer_add(base, &prefix_bytes, len_len)) {
+    return 0;
+  }
+  OPENSSL_memset(prefix_bytes, 0, len_len);
+
+  CBB_zero(out_child);
+  out_child->is_child = 1;
+  out_child->u.child.base = base;
+  out_child->u.child.offset = offset;
+  out_child->u.child.pending_len_len = len_len;
+  out_child->u.child.pending_is_asn1 = is_asn1;
+  cbb->child = out_child;
+  return 1;
+}
+
+static int cbb_add_length_prefixed(CBB *cbb, CBB *out_contents,
+                                   uint8_t len_len) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  return cbb_add_child(cbb, out_contents, len_len, /*is_asn1=*/0);
+}
+
+int CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents) {
+  return cbb_add_length_prefixed(cbb, out_contents, 1);
+}
+
+int CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents) {
+  return cbb_add_length_prefixed(cbb, out_contents, 2);
+}
+
+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
+// 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) {
+  unsigned len_len = 0;
+  uint64_t copy = v;
+  while (copy > 0) {
+    len_len++;
+    copy >>= 7;
+  }
+  if (len_len == 0) {
+    len_len = 1;  // Zero is encoded with one byte.
+  }
+  for (unsigned i = len_len - 1; i < len_len; i--) {
+    uint8_t byte = (v >> (7 * i)) & 0x7f;
+    if (i != 0) {
+      // The high bit denotes whether there is more data.
+      byte |= 0x80;
+    }
+    if (!CBB_add_u8(cbb, byte)) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+int bssl::cbb_add_decimal_ascii(CBB *out, uint64_t v) {
+  char buf[DECIMAL_SIZE(uint64_t) + 1];
+  snprintf(buf, sizeof(buf), "%" PRIu64, v);
+  return CBB_add_bytes(out, reinterpret_cast<const uint8_t *>(buf),
+                       strlen(buf));
+}
+
+int CBB_add_asn1(CBB *cbb, CBB *out_contents, CBS_ASN1_TAG tag) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  // Split the tag into leading bits and tag number.
+  uint8_t tag_bits = (tag >> CBS_ASN1_TAG_SHIFT) & 0xe0;
+  CBS_ASN1_TAG tag_number = tag & CBS_ASN1_TAG_NUMBER_MASK;
+  if (tag_number >= 0x1f) {
+    // Set all the bits in the tag number to signal high tag number form.
+    if (!CBB_add_u8(cbb, tag_bits | 0x1f) ||
+        !add_base128_integer(cbb, tag_number)) {
+      return 0;
+    }
+  } else if (!CBB_add_u8(cbb, tag_bits | tag_number)) {
+    return 0;
+  }
+
+  // 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);
+}
+
+int CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len) {
+  uint8_t *out;
+  if (!CBB_add_space(cbb, &out, len)) {
+    return 0;
+  }
+  OPENSSL_memcpy(out, data, len);
+  return 1;
+}
+
+int CBB_add_zeros(CBB *cbb, size_t len) {
+  uint8_t *out;
+  if (!CBB_add_space(cbb, &out, len)) {
+    return 0;
+  }
+  OPENSSL_memset(out, 0, len);
+  return 1;
+}
+
+int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) {
+  if (!CBB_flush(cbb) || !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
+    return 0;
+  }
+  return 1;
+}
+
+int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len) {
+  if (!CBB_flush(cbb) ||
+      !cbb_buffer_reserve(cbb_get_base(cbb), out_data, len)) {
+    return 0;
+  }
+  return 1;
+}
+
+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 != nullptr || newlen < base->len || newlen > base->cap) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+    return 0;
+  }
+  base->len = newlen;
+  return 1;
+}
+
+static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
+  uint8_t *buf;
+  if (!CBB_add_space(cbb, &buf, len_len)) {
+    return 0;
+  }
+
+  for (size_t i = len_len - 1; i < len_len; i--) {
+    buf[i] = v;
+    v >>= 8;
+  }
+
+  // `v` must fit in `len_len` bytes.
+  if (v != 0) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
+    cbb_on_error(cbb);
+    return 0;
+  }
+
+  return 1;
+}
+
+int CBB_add_u8(CBB *cbb, uint8_t value) { return cbb_add_u(cbb, value, 1); }
+
+int CBB_add_u16(CBB *cbb, uint16_t value) { return cbb_add_u(cbb, value, 2); }
+
+int CBB_add_u16le(CBB *cbb, uint16_t value) {
+  return CBB_add_u16(cbb, CRYPTO_bswap2(value));
+}
+
+int CBB_add_u24(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 3); }
+
+int CBB_add_u32(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 4); }
+
+int CBB_add_u32le(CBB *cbb, uint32_t value) {
+  return CBB_add_u32(cbb, CRYPTO_bswap4(value));
+}
+
+int CBB_add_u48(CBB *cbb, uint64_t value) { return cbb_add_u(cbb, value, 6); }
+
+int CBB_add_u64(CBB *cbb, uint64_t value) { return cbb_add_u(cbb, value, 8); }
+
+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 == nullptr) {
+    return;
+  }
+
+  struct cbb_buffer_st *base = cbb_get_base(cbb);
+  assert(cbb->child->is_child);
+  base->len = cbb->child->u.child.offset;
+
+  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) {
+  return CBB_add_asn1_uint64_with_tag(cbb, value, CBS_ASN1_INTEGER);
+}
+
+int CBB_add_asn1_uint64_with_tag(CBB *cbb, uint64_t value, CBS_ASN1_TAG tag) {
+  CBB child;
+  int started = 0;
+  if (!CBB_add_asn1(cbb, &child, tag)) {
+    goto err;
+  }
+
+  for (size_t i = 0; i < 8; i++) {
+    uint8_t byte = (value >> 8 * (7 - i)) & 0xff;
+    if (!started) {
+      if (byte == 0) {
+        // Don't encode leading zeros.
+        continue;
+      }
+      // If the high bit is set, add a padding byte to make it
+      // unsigned.
+      if ((byte & 0x80) && !CBB_add_u8(&child, 0)) {
+        goto err;
+      }
+      started = 1;
+    }
+    if (!CBB_add_u8(&child, byte)) {
+      goto err;
+    }
+  }
+
+  // 0 is encoded as a single 0, not the empty string.
+  if (!started && !CBB_add_u8(&child, 0)) {
+    goto err;
+  }
+
+  return CBB_flush(cbb);
+
+err:
+  cbb_on_error(cbb);
+  return 0;
+}
+
+int CBB_add_asn1_int64(CBB *cbb, int64_t value) {
+  return CBB_add_asn1_int64_with_tag(cbb, value, CBS_ASN1_INTEGER);
+}
+
+int CBB_add_asn1_int64_with_tag(CBB *cbb, int64_t value, CBS_ASN1_TAG tag) {
+  if (value >= 0) {
+    return CBB_add_asn1_uint64_with_tag(cbb, (uint64_t)value, tag);
+  }
+
+  uint8_t bytes[sizeof(int64_t)];
+  memcpy(bytes, &value, sizeof(value));
+  int start = 7;
+  // Skip leading sign-extension bytes unless they are necessary.
+  while (start > 0 && (bytes[start] == 0xff && (bytes[start - 1] & 0x80))) {
+    start--;
+  }
+
+  CBB child;
+  if (!CBB_add_asn1(cbb, &child, tag)) {
+    goto err;
+  }
+  for (int i = start; i >= 0; i--) {
+    if (!CBB_add_u8(&child, bytes[i])) {
+      goto err;
+    }
+  }
+  return CBB_flush(cbb);
+
+err:
+  cbb_on_error(cbb);
+  return 0;
+}
+
+int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
+  return CBB_add_asn1_element(cbb, CBS_ASN1_OCTETSTRING, data, data_len);
+}
+
+int CBB_add_asn1_bool(CBB *cbb, int value) {
+  CBB child;
+  if (!CBB_add_asn1(cbb, &child, CBS_ASN1_BOOLEAN) ||
+      !CBB_add_u8(&child, value != 0 ? 0xff : 0) || !CBB_flush(cbb)) {
+    cbb_on_error(cbb);
+    return 0;
+  }
+
+  return 1;
+}
+
+// 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
+// next value.
+static int parse_dotted_decimal(CBS *cbs, uint64_t *out) {
+  if (!CBS_get_u64_decimal(cbs, out)) {
+    return 0;
+  }
+
+  // The integer must have either ended at the end of the string, or a
+  // non-terminal dot, which should be consumed. If the string ends with a dot,
+  // this is not a valid OID string.
+  uint8_t dot;
+  return !CBS_get_u8(cbs, &dot) || (dot == '.' && CBS_len(cbs) > 0);
+}
+
+int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  CBS cbs;
+  CBS_init(&cbs, (const uint8_t *)text, len);
+
+  // OIDs must have at least two components.
+  uint64_t a, b;
+  if (!parse_dotted_decimal(&cbs, &a) || !parse_dotted_decimal(&cbs, &b)) {
+    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.
+  if (a > 2 || (a < 2 && b > 39) || b > UINT64_MAX - 80 ||
+      !add_base128_integer(cbb, 40u * a + b)) {
+    return 0;
+  }
+
+  // The remaining components are encoded unmodified.
+  while (CBS_len(&cbs) > 0) {
+    if (!parse_dotted_decimal(&cbs, &a) || !add_base128_integer(cbb, a)) {
+      return 0;
+    }
+  }
+
+  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_relative_oid_from_der_to_text(CBB *cbb, const uint8_t *data,
+                                               size_t data_len) {
+  CBS der;
+  CBS_init(&der, data, data_len);
+  // Relative OIDs must have at least one component.
+  uint64_t v;
+  if (!CBS_get_asn1_oid_component(&der, &v) || !cbb_add_decimal_ascii(cbb, v)) {
+    return 0;
+  }
+
+  while (CBS_len(&der) != 0) {
+    if (!CBS_get_asn1_oid_component(&der, &v) || !CBB_add_u8(cbb, '.') ||
+        !cbb_add_decimal_ascii(cbb, v)) {
+      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);
+}
+
+int CBB_flush_asn1_set_of(CBB *cbb) {
+  if (!CBB_flush(cbb)) {
+    return 0;
+  }
+
+  size_t num_children = 0;
+  CBS cbs(CBBAsSpan(cbb));
+  while (CBS_len(&cbs) != 0) {
+    if (!CBS_get_any_asn1_element(&cbs, nullptr, nullptr, nullptr)) {
+      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+      return 0;
+    }
+    num_children++;
+  }
+
+  if (num_children < 2) {
+    return 1;  // Nothing to do. This is the common case for X.509.
+  }
+
+  // Parse out the children and sort. We alias them into a copy of so they
+  // remain valid as we rewrite `cbb`.
+  Array<uint8_t> copy;
+  Array<CBS> children;
+  if (!copy.CopyFrom(CBBAsSpan(cbb)) ||  //
+      !children.Init(num_children)) {
+    return 0;
+  }
+  cbs = CBS(copy);
+  for (size_t i = 0; i < num_children; i++) {
+    if (!CBS_get_any_asn1_element(&cbs, &children[i], nullptr, nullptr)) {
+      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+      return 0;
+    }
+  }
+  std::sort(children.begin(), children.end(), [](CBS a, CBS b) -> bool {
+    // See X.690, section 11.6 for the ordering. They are sorted in ascending
+    // order by their DER encoding. First compare the common prefix.
+    size_t a_len = CBS_len(&a), b_len = CBS_len(&b);
+    int cmp =
+        OPENSSL_memcmp(CBS_data(&a), CBS_data(&b), std::min(a_len, b_len));
+    if (cmp != 0) {
+      return cmp < 0;
+    }
+    // If one is a prefix of the other, the shorter one sorts first. (They're
+    // actually always equal length. DER encodings are prefix-free.)
+    return a_len < b_len;
+  });
+
+  // Write the contents back in the new order.
+  uint8_t *out = const_cast<uint8_t *>(CBB_data(cbb));
+  size_t offset = 0;
+  for (size_t i = 0; i < num_children; i++) {
+    OPENSSL_memcpy(out + offset, CBS_data(&children[i]), CBS_len(&children[i]));
+    offset += CBS_len(&children[i]);
+  }
+  assert(offset == copy.size());
+  return 1;
+}
+
+bool bssl::CBBFinishArray(CBB *cbb, Array<uint8_t> *out) {
+  uint8_t *ptr;
+  size_t len;
+  if (!CBB_finish(cbb, &ptr, &len)) {
+    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
+    return false;
+  }
+  out->Reset(ptr, len);
+  return true;
+}