grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/x509/x_name.cc

@@ -13,489 +13,417 @@
 // limitations under the License.
 
 #include <ctype.h>
+#include <limits.h>
 #include <string.h>
 
+#include <utility>
+
 #include <openssl/asn1.h>
 #include <openssl/asn1t.h>
+#include <openssl/bytestring.h>
 #include <openssl/buf.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/obj.h>
 #include <openssl/stack.h>
 #include <openssl/x509.h>
-#include <cstdint>
 
 #include "../asn1/internal.h"
+#include "../bytestring/internal.h"
 #include "../internal.h"
+#include "../mem_internal.h"
 #include "internal.h"
 
 
-typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
-DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)
-
-// Maximum length of X509_NAME: much larger than anything we should
-// ever see in practice.
+using namespace bssl;
 
+// X509_NAME_MAX is the length of the maximum encoded `X509_NAME` we accept.
 #define X509_NAME_MAX (1024 * 1024)
 
-static int x509_name_ex_d2i(ASN1_VALUE **val, const unsigned char **in,
-                            long len, const ASN1_ITEM *it, int opt,
-                            ASN1_TLC *ctx);
-
-static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out,
-                            const ASN1_ITEM *it);
-static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it);
-static void x509_name_ex_free(ASN1_VALUE **val, const ASN1_ITEM *it);
-
-static int x509_name_encode(X509_NAME *a);
-static int x509_name_canon(X509_NAME *a);
-static int asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in);
-static int i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname,
-                          unsigned char **in);
-
-ASN1_SEQUENCE(X509_NAME_ENTRY) = {
-    ASN1_SIMPLE(X509_NAME_ENTRY, object, ASN1_OBJECT),
-    ASN1_SIMPLE(X509_NAME_ENTRY, value, ASN1_ANY_AS_STRING),
-} ASN1_SEQUENCE_END(X509_NAME_ENTRY)
-
-IMPLEMENT_ASN1_ALLOC_FUNCTIONS(X509_NAME_ENTRY)
-IMPLEMENT_ASN1_DUP_FUNCTION_const(X509_NAME_ENTRY)
-
-// For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY } so
-// declare two template wrappers for this
+static int asn1_marshal_string_canon(CBB *cbb, const ASN1_STRING *in);
 
-ASN1_ITEM_TEMPLATE(X509_NAME_ENTRIES) = ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF,
-                                                              0, RDNS,
-                                                              X509_NAME_ENTRY)
-ASN1_ITEM_TEMPLATE_END(X509_NAME_ENTRIES)
-
-ASN1_ITEM_TEMPLATE(X509_NAME_INTERNAL) =
-    ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, Name, X509_NAME_ENTRIES)
-ASN1_ITEM_TEMPLATE_END(X509_NAME_INTERNAL)
-
-// Normally that's where it would end: we'd have two nested STACK structures
-// representing the ASN1. Unfortunately X509_NAME uses a completely different
-// form and caches encodings so we have to process the internal form and
-// convert to the external form.
-
-static const ASN1_EXTERN_FUNCS x509_name_ff = {
-    x509_name_ex_new,
-    x509_name_ex_free,
-    x509_name_ex_d2i,
-    x509_name_ex_i2d,
-};
-
-IMPLEMENT_EXTERN_ASN1(X509_NAME, V_ASN1_SEQUENCE, x509_name_ff)
-
-IMPLEMENT_ASN1_FUNCTIONS(X509_NAME)
-
-IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME)
+X509_NAME_ENTRY *X509_NAME_ENTRY_new() {
+  UniquePtr<X509_NAME_ENTRY> ret = MakeUnique<X509_NAME_ENTRY>();
+  if (ret == nullptr) {
+    return nullptr;
+  }
+  ret->object = const_cast<ASN1_OBJECT *>(OBJ_get_undef());
+  asn1_string_init(&ret->value, -1);
+  ret->set = 0;
+  return ret.release();
+}
 
-static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it) {
-  X509_NAME *ret = NULL;
-  ret = reinterpret_cast<X509_NAME *>(OPENSSL_malloc(sizeof(X509_NAME)));
-  if (!ret) {
-    goto memerr;
+void X509_NAME_ENTRY_free(X509_NAME_ENTRY *entry) {
+  if (entry != nullptr) {
+    ASN1_OBJECT_free(entry->object);
+    asn1_string_cleanup(&entry->value);
+    Delete(entry);
   }
-  if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL) {
-    goto memerr;
+}
+
+static int x509_parse_name_entry(CBS *cbs, X509_NAME_ENTRY *out) {
+  CBS seq;
+  if (!CBS_get_asn1(cbs, &seq, CBS_ASN1_SEQUENCE)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+    return 0;
   }
-  if ((ret->bytes = BUF_MEM_new()) == NULL) {
-    goto memerr;
+  ASN1_OBJECT_free(out->object);
+  out->object = asn1_parse_object(&seq, /*tag=*/0);
+  if (out->object == nullptr ||                        //
+      !asn1_parse_any_as_string(&seq, &out->value) ||  //
+      CBS_len(&seq) != 0) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+    return 0;
   }
-  ret->canon_enc = NULL;
-  ret->canon_enclen = 0;
-  ret->modified = 1;
-  *val = (ASN1_VALUE *)ret;
   return 1;
+}
 
-memerr:
-  if (ret) {
-    if (ret->entries) {
-      sk_X509_NAME_ENTRY_free(ret->entries);
-    }
-    OPENSSL_free(ret);
+static int x509_marshal_name_entry(CBB *cbb, const X509_NAME_ENTRY *entry,
+                                   int canonicalize) {
+  CBB seq;
+  if (!CBB_add_asn1(cbb, &seq, CBS_ASN1_SEQUENCE) ||
+      !asn1_marshal_object(&seq, entry->object, /*tag=*/0)) {
+    return 0;
+  }
+  int ok = canonicalize ? asn1_marshal_string_canon(&seq, &entry->value)
+                        : asn1_marshal_any_string(&seq, &entry->value);
+  if (!ok) {
+    return 0;
   }
-  return 0;
+  return CBB_flush(cbb);
 }
 
-static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  X509_NAME *a;
-  if (!pval || !*pval) {
-    return;
-  }
-  a = (X509_NAME *)*pval;
+static int x509_marshal_name_entry_no_canon(CBB *cbb,
+                                            const X509_NAME_ENTRY *entry) {
+  return x509_marshal_name_entry(cbb, entry, /*canonicalize=*/0);
+}
+
+BSSL_NAMESPACE_BEGIN
 
-  BUF_MEM_free(a->bytes);
-  sk_X509_NAME_ENTRY_pop_free(a->entries, X509_NAME_ENTRY_free);
-  if (a->canon_enc) {
-    OPENSSL_free(a->canon_enc);
+IMPLEMENT_EXTERN_ASN1_PARSE_INTO(X509_NAME_ENTRY, X509_NAME_ENTRY_new,
+                                 X509_NAME_ENTRY_free, CBS_ASN1_SEQUENCE,
+                                 x509_parse_name_entry,
+                                 x509_marshal_name_entry_no_canon)
+
+BSSL_NAMESPACE_END
+
+X509_NAME_ENTRY *X509_NAME_ENTRY_dup(const X509_NAME_ENTRY *entry) {
+  ScopedCBB cbb;
+  if (!CBB_init(cbb.get(), 16) ||
+      !x509_marshal_name_entry(cbb.get(), entry, /*canonicalize=*/0)) {
+    return nullptr;
   }
-  OPENSSL_free(a);
-  *pval = NULL;
+  CBS cbs;
+  CBS_init(&cbs, CBB_data(cbb.get()), CBB_len(cbb.get()));
+  UniquePtr<X509_NAME_ENTRY> copy(X509_NAME_ENTRY_new());
+  if (copy == nullptr || !x509_parse_name_entry(&cbs, copy.get())) {
+    return nullptr;
+  }
+  return copy.release();
 }
 
-static void local_sk_X509_NAME_ENTRY_free(STACK_OF(X509_NAME_ENTRY) *ne) {
-  sk_X509_NAME_ENTRY_free(ne);
+void bssl::x509_name_init(X509_NAME *name) {
+  auto *impl = FromOpaque(name);
+  OPENSSL_memset(impl, 0, sizeof(*impl));
 }
 
-static void local_sk_X509_NAME_ENTRY_pop_free(STACK_OF(X509_NAME_ENTRY) *ne) {
-  sk_X509_NAME_ENTRY_pop_free(ne, X509_NAME_ENTRY_free);
+void bssl::x509_name_cleanup(X509_NAME *name) {
+  auto *impl = FromOpaque(name);
+  sk_X509_NAME_ENTRY_pop_free(impl->entries, X509_NAME_ENTRY_free);
+  Delete(impl->cache.exchange(nullptr));
 }
 
-static int x509_name_ex_d2i(ASN1_VALUE **val, const unsigned char **in,
-                            long len, const ASN1_ITEM *it, int opt,
-                            ASN1_TLC *ctx) {
-  const unsigned char *p = *in, *q;
-  STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname = NULL;
-  X509_NAME *nm = NULL;
-  size_t i, j;
-  int ret;
-  STACK_OF(X509_NAME_ENTRY) *entries;
-  X509_NAME_ENTRY *entry;
-  // Bound the size of an X509_NAME we are willing to parse.
-  if (len > X509_NAME_MAX) {
-    len = X509_NAME_MAX;
-  }
-  q = p;
-
-  // Get internal representation of Name
-  ASN1_VALUE *intname_val = NULL;
-  ret = ASN1_item_ex_d2i(&intname_val, &p, len,
-                         ASN1_ITEM_rptr(X509_NAME_INTERNAL), /*tag=*/-1,
-                         /*aclass=*/0, opt, /*buf=*/NULL);
-  if (ret <= 0) {
-    return ret;
-  }
-  intname = (STACK_OF(STACK_OF_X509_NAME_ENTRY) *)intname_val;
-
-  if (*val) {
-    x509_name_ex_free(val, NULL);
-  }
-  ASN1_VALUE *nm_val = NULL;
-  if (!x509_name_ex_new(&nm_val, NULL)) {
-    goto err;
-  }
-  nm = (X509_NAME *)nm_val;
-  // We've decoded it: now cache encoding
-  if (!BUF_MEM_grow(nm->bytes, p - q)) {
-    goto err;
-  }
-  OPENSSL_memcpy(nm->bytes->data, q, p - q);
-
-  // Convert internal representation to X509_NAME structure
-  for (i = 0; i < sk_STACK_OF_X509_NAME_ENTRY_num(intname); i++) {
-    entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname, i);
-    for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) {
-      entry = sk_X509_NAME_ENTRY_value(entries, j);
-      entry->set = (int)i;
-      if (!sk_X509_NAME_ENTRY_push(nm->entries, entry)) {
-        goto err;
-      }
-      (void)sk_X509_NAME_ENTRY_set(entries, j, NULL);
-    }
+X509_NAME *X509_NAME_new() { return New<X509Name>(); }
+
+void X509_NAME_free(X509_NAME *name) {
+  if (name != nullptr) {
+    x509_name_cleanup(name);
+    Delete(FromOpaque(name));
   }
-  ret = x509_name_canon(nm);
-  if (!ret) {
-    goto err;
-  }
-  sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname, local_sk_X509_NAME_ENTRY_free);
-  nm->modified = 0;
-  *val = (ASN1_VALUE *)nm;
-  *in = p;
-  return ret;
-err:
-  X509_NAME_free(nm);
-  sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname,
-                                       local_sk_X509_NAME_ENTRY_pop_free);
-  OPENSSL_PUT_ERROR(X509, ERR_R_ASN1_LIB);
-  return 0;
 }
 
-static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out,
-                            const ASN1_ITEM *it) {
-  X509_NAME *a = (X509_NAME *)*val;
-  if (a->modified && (!x509_name_encode(a) || !x509_name_canon(a))) {
-    return -1;
+int bssl::x509_parse_name(CBS *cbs, X509_NAME *out) {
+  auto *impl = FromOpaque(out);
+  // Reset the old state.
+  x509_name_cleanup(impl);
+  x509_name_init(impl);
+
+  impl->entries = sk_X509_NAME_ENTRY_new_null();
+  if (impl->entries == nullptr) {
+    return 0;
   }
-  int ret = a->bytes->length;
-  if (out != NULL) {
-    OPENSSL_memcpy(*out, a->bytes->data, ret);
-    *out += ret;
+  CBS seq, rdn;
+  if (!CBS_get_asn1(cbs, &seq, CBS_ASN1_SEQUENCE) ||
+      // Bound the size of an X509_NAME we are willing to parse.
+      CBS_len(&seq) > X509_NAME_MAX) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+    return 0;
   }
-  return ret;
-}
-
-static int x509_name_encode(X509_NAME *a) {
-  int len;
-  unsigned char *p;
-  STACK_OF(X509_NAME_ENTRY) *entries = NULL;
-  X509_NAME_ENTRY *entry;
-  int set = -1;
-  size_t i;
-  STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname =
-      sk_STACK_OF_X509_NAME_ENTRY_new_null();
-
-  {
-    if (!intname) {
-      goto err;
+  static_assert(X509_NAME_MAX <= INT_MAX, "set may overflow");
+  for (int set = 0; CBS_len(&seq) > 0; set++) {
+    if (!CBS_get_asn1(&seq, &rdn, CBS_ASN1_SET) ||  //
+        CBS_len(&rdn) == 0) {
+      OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+      return 0;
     }
-    for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
-      entry = sk_X509_NAME_ENTRY_value(a->entries, i);
-      if (entry->set != set) {
-        entries = sk_X509_NAME_ENTRY_new_null();
-        if (!entries) {
-          goto err;
-        }
-        if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries)) {
-          sk_X509_NAME_ENTRY_free(entries);
-          goto err;
-        }
-        set = entry->set;
+    while (CBS_len(&rdn) != 0) {
+      UniquePtr<X509_NAME_ENTRY> entry(X509_NAME_ENTRY_new());
+      if (entry == nullptr || !x509_parse_name_entry(&rdn, entry.get())) {
+        return 0;
       }
-      if (!sk_X509_NAME_ENTRY_push(entries, entry)) {
-        goto err;
+      entry->set = set;
+      if (!PushToStack(impl->entries, std::move(entry))) {
+        return 0;
       }
     }
-    ASN1_VALUE *intname_val = (ASN1_VALUE *)intname;
-    len =
-        ASN1_item_ex_i2d(&intname_val, NULL, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
-                         /*tag=*/-1, /*aclass=*/0);
-    if (len <= 0) {
-      goto err;
-    }
-    if (!BUF_MEM_grow(a->bytes, len)) {
-      goto err;
-    }
-    p = (unsigned char *)a->bytes->data;
-    if (ASN1_item_ex_i2d(&intname_val, &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
-                         /*tag=*/-1, /*aclass=*/0) <= 0) {
-      goto err;
-    }
-    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname,
-                                         local_sk_X509_NAME_ENTRY_free);
-    a->modified = 0;
-    return 1;
   }
 
-err:
-  sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname, local_sk_X509_NAME_ENTRY_free);
-  return 0;
+  // While we are single-threaded, also fill in the cached state.
+  return x509_name_get_cache(impl) != nullptr;
 }
 
-// This function generates the canonical encoding of the Name structure. In
-// it all strings are converted to UTF8, leading, trailing and multiple
-// spaces collapsed, converted to lower case and the leading SEQUENCE header
-// removed. In future we could also normalize the UTF8 too. By doing this
-// comparison of Name structures can be rapidly perfomed by just using
-// OPENSSL_memcmp() of the canonical encoding. By omitting the leading SEQUENCE
-// name constraints of type dirName can also be checked with a simple
-// OPENSSL_memcmp().
-
-static int x509_name_canon(X509_NAME *a) {
-  unsigned char *p;
-  STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname = NULL;
-  STACK_OF(X509_NAME_ENTRY) *entries = NULL;
-  X509_NAME_ENTRY *entry, *tmpentry = NULL;
-  int set = -1, ret = 0, len;
-  size_t i;
-
-  if (a->canon_enc) {
-    OPENSSL_free(a->canon_enc);
-    a->canon_enc = NULL;
-  }
-  // Special case: empty X509_NAME => null encoding
-  if (sk_X509_NAME_ENTRY_num(a->entries) == 0) {
-    a->canon_enclen = 0;
+static int x509_marshal_name_entries(CBB *out, const X509_NAME *name,
+                                     int canonicalize) {
+  auto *impl = FromOpaque(name);
+  if (sk_X509_NAME_ENTRY_num(impl->entries) == 0) {
     return 1;
   }
-  intname = sk_STACK_OF_X509_NAME_ENTRY_new_null();
-  if (!intname) {
-    goto err;
+
+  // Bootstrap the first RDN.
+  int set = sk_X509_NAME_ENTRY_value(impl->entries, 0)->set;
+  CBB rdn;
+  if (!CBB_add_asn1(out, &rdn, CBS_ASN1_SET)) {
+    return 0;
   }
-  for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
-    entry = sk_X509_NAME_ENTRY_value(a->entries, i);
+
+  for (const X509_NAME_ENTRY *entry : impl->entries) {
     if (entry->set != set) {
-      entries = sk_X509_NAME_ENTRY_new_null();
-      if (!entries) {
-        goto err;
-      }
-      if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries)) {
-        sk_X509_NAME_ENTRY_free(entries);
-        goto err;
+      // Flush the previous RDN and start a new one.
+      if (!CBB_flush_asn1_set_of(&rdn) ||
+          !CBB_add_asn1(out, &rdn, CBS_ASN1_SET)) {
+        return 0;
       }
       set = entry->set;
     }
-    tmpentry = X509_NAME_ENTRY_new();
-    if (tmpentry == NULL) {
-      goto err;
-    }
-    tmpentry->object = OBJ_dup(entry->object);
-    if (!asn1_string_canon(tmpentry->value, entry->value)) {
-      goto err;
-    }
-    if (!sk_X509_NAME_ENTRY_push(entries, tmpentry)) {
-      goto err;
+    if (!x509_marshal_name_entry(&rdn, entry, canonicalize)) {
+      return 0;
     }
-    tmpentry = NULL;
   }
 
-  // Finally generate encoding
+  return CBB_flush_asn1_set_of(&rdn) && CBB_flush(out);
+}
 
-  len = i2d_name_canon(intname, NULL);
-  if (len < 0) {
-    goto err;
+const X509_NAME_CACHE *bssl::x509_name_get_cache(const X509_NAME *name) {
+  auto *impl = FromOpaque(name);
+  const X509_NAME_CACHE *cache = impl->cache.load();
+  if (cache != nullptr) {
+    return cache;
   }
-  a->canon_enclen = len;
 
-  p = reinterpret_cast<uint8_t *>(OPENSSL_malloc(a->canon_enclen));
-
-  if (!p) {
-    goto err;
+  UniquePtr<X509_NAME_CACHE> new_cache = MakeUnique<X509_NAME_CACHE>();
+  // Cache the DER encoding, including the outer TLV.
+  ScopedCBB cbb;
+  CBB seq;
+  if (!CBB_init(cbb.get(), 16) ||
+      !CBB_add_asn1(cbb.get(), &seq, CBS_ASN1_SEQUENCE) ||
+      !x509_marshal_name_entries(&seq, impl, /*canonicalize=*/0) ||
+      !CBBFinishArray(cbb.get(), &new_cache->der)) {
+    return nullptr;
+  }
+  // Cache the canonicalized form, without the outer TLV.
+  if (!CBB_init(cbb.get(), 16) ||
+      !x509_marshal_name_entries(cbb.get(), impl, /*canonicalize=*/1) ||
+      !CBBFinishArray(cbb.get(), &new_cache->canon)) {
+    return nullptr;
   }
 
-  a->canon_enc = p;
-
-  i2d_name_canon(intname, &p);
+  X509_NAME_CACHE *expected = nullptr;
+  if (impl->cache.compare_exchange_strong(expected, new_cache.get())) {
+    // We won the race. `impl` now owns `new_cache`.
+    return new_cache.release();
+  }
 
-  ret = 1;
+  // Some other thread installed a (presumably identical) cache. Release the one
+  // we made and return the winning one.
+  assert(expected != nullptr);
+  return expected;
+}
 
-err:
+void bssl::x509_name_invalidate_cache(X509_NAME *name) {
+  auto *impl = FromOpaque(name);
+  Delete(impl->cache.exchange(nullptr));
+}
 
-  if (tmpentry) {
-    X509_NAME_ENTRY_free(tmpentry);
-  }
-  if (intname) {
-    sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname,
-                                         local_sk_X509_NAME_ENTRY_pop_free);
+int bssl::x509_marshal_name(CBB *out, const X509_NAME *in) {
+  const X509_NAME_CACHE *cache = x509_name_get_cache(in);
+  if (cache == nullptr) {
+    return 0;
   }
-  return ret;
+  return CBB_add_bytes(out, cache->der.data(), cache->der.size());
 }
 
-// Bitmap of all the types of string that will be canonicalized.
-
-#define ASN1_MASK_CANON                                            \
-  (B_ASN1_UTF8STRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING | \
-   B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING |  \
-   B_ASN1_VISIBLESTRING)
-
-static int asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in) {
-  unsigned char *to, *from;
-  int len, i;
-
-  // If type not in bitmask just copy string across
-  if (!(ASN1_tag2bit(in->type) & ASN1_MASK_CANON)) {
-    if (!ASN1_STRING_copy(out, in)) {
-      return 0;
-    }
+int bssl::x509_name_copy(X509_NAME *dst, const X509_NAME *src) {
+  const X509_NAME_CACHE *cache = x509_name_get_cache(src);
+  if (cache == nullptr) {
+    return 0;
+  }
+  // Callers sometimes try to set a name back to itself. We check this after
+  // `x509_name_get_cache` because, if `src` was so broken that it could not be
+  // serialized, we used to return an error. (It's not clear if this codepath is
+  // even possible.)
+  if (dst == src) {
     return 1;
   }
-
-  out->type = V_ASN1_UTF8STRING;
-  out->length = ASN1_STRING_to_UTF8(&out->data, in);
-  if (out->length == -1) {
+  CBS cbs(cache->der);
+  if (!x509_parse_name(&cbs, dst)) {
     return 0;
   }
+  assert(CBS_len(&cbs) == 0);
+  return 1;
+}
 
-  to = out->data;
-  from = to;
-
-  len = out->length;
-
-  // Convert string in place to canonical form.
-
-  // Ignore leading spaces
-  while ((len > 0) && OPENSSL_isspace(*from)) {
-    from++;
-    len--;
+X509_NAME *X509_NAME_dup(const X509_NAME *name) {
+  UniquePtr<X509_NAME> copy(X509_NAME_new());
+  if (copy == nullptr || !x509_name_copy(copy.get(), name)) {
+    return nullptr;
   }
+  return copy.release();
+}
 
-  to = from + len;
+X509_NAME *d2i_X509_NAME(X509_NAME **out, const uint8_t **inp, long len) {
+  return D2IFromCBS(out, inp, len, [](CBS *cbs) -> UniquePtr<X509_NAME> {
+    UniquePtr<X509_NAME> name(X509_NAME_new());
+    if (name == nullptr || !x509_parse_name(cbs, name.get())) {
+      return nullptr;
+    }
+    return name;
+  });
+}
 
-  // Ignore trailing spaces
-  while ((len > 0) && OPENSSL_isspace(to[-1])) {
-    to--;
-    len--;
+int i2d_X509_NAME(const X509_NAME *in, uint8_t **outp) {
+  if (in == nullptr) {
+    OPENSSL_PUT_ERROR(X509, ERR_R_PASSED_NULL_PARAMETER);
+    return -1;
+  }
+  const X509_NAME_CACHE *cache = x509_name_get_cache(in);
+  if (cache == nullptr) {
+    return -1;
   }
+  if (cache->der.size() > INT_MAX) {
+    OPENSSL_PUT_ERROR(X509, ERR_R_OVERFLOW);
+    return -1;
+  }
+  int len = static_cast<int>(cache->der.size());
+  if (outp == nullptr) {
+    return len;
+  }
+  if (*outp == nullptr) {
+    *outp = static_cast<uint8_t *>(
+        OPENSSL_memdup(cache->der.data(), cache->der.size()));
+    return *outp != nullptr ? len : -1;
+  }
+  OPENSSL_memcpy(*outp, cache->der.data(), cache->der.size());
+  *outp += cache->der.size();
+  return len;
+}
 
-  to = out->data;
+IMPLEMENT_EXTERN_ASN1_PARSE_INTO(X509_NAME, X509_NAME_new, X509_NAME_free,
+                                 CBS_ASN1_SEQUENCE, x509_parse_name,
+                                 x509_marshal_name)
+
+static int asn1_marshal_string_canon(CBB *cbb, const ASN1_STRING *in) {
+  int (*decode_func)(CBS *, uint32_t *);
+  int error;
+  switch (in->type) {
+    case V_ASN1_UTF8STRING:
+      decode_func = CBS_get_utf8;
+      error = ASN1_R_INVALID_UTF8STRING;
+      break;
+    case V_ASN1_BMPSTRING:
+      decode_func = CBS_get_ucs2_be;
+      error = ASN1_R_INVALID_BMPSTRING;
+      break;
+    case V_ASN1_UNIVERSALSTRING:
+      decode_func = CBS_get_utf32_be;
+      error = ASN1_R_INVALID_UNIVERSALSTRING;
+      break;
+    case V_ASN1_PRINTABLESTRING:
+    case V_ASN1_T61STRING:
+    case V_ASN1_IA5STRING:
+    case V_ASN1_VISIBLESTRING:
+      decode_func = CBS_get_latin1;
+      error = ERR_R_INTERNAL_ERROR;  // Latin-1 inputs are never invalid.
+      break;
+    default:
+      // Other string types are not canonicalized.
+      return asn1_marshal_any_string(cbb, in);
+  }
+
+  CBB child;
+  if (!CBB_add_asn1(cbb, &child, CBS_ASN1_UTF8STRING)) {
+    return 0;
+  }
 
-  i = 0;
-  while (i < len) {
-    // Collapse multiple spaces
-    if (OPENSSL_isspace(*from)) {
-      // Copy one space across
-      *to++ = ' ';
-      // Ignore subsequent spaces. Note: don't need to check len here
-      // because we know the last character is a non-space so we can't
-      // overflow.
-      do {
-        from++;
-        i++;
-      } while (OPENSSL_isspace(*from));
+  bool empty = true;
+  bool in_whitespace = false;
+  CBS cbs;
+  CBS_init(&cbs, in->data, in->length);
+  while (CBS_len(&cbs) != 0) {
+    uint32_t c;
+    if (!decode_func(&cbs, &c)) {
+      OPENSSL_PUT_ERROR(ASN1, error);
+      return 0;
+    }
+    if (OPENSSL_isspace(c)) {
+      if (empty) {
+        continue;  // Trim leading whitespace.
+      }
+      in_whitespace = true;
     } else {
-      *to++ = OPENSSL_tolower(*from);
-      from++;
-      i++;
+      if (in_whitespace) {
+        // Collapse the previous run of whitespace into one space.
+        if (!CBB_add_u8(&child, ' ')) {
+          return 0;
+        }
+      }
+      in_whitespace = false;
+      // Lowecase ASCII codepoints.
+      if (c <= 0x7f) {
+        c = OPENSSL_tolower(c);
+      }
+      if (!CBB_add_utf8(&child, c)) {
+        return 0;
+      }
+      empty = false;
     }
   }
 
-  out->length = to - out->data;
-
-  return 1;
+  return CBB_flush(cbb);
 }
 
-static int i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) *_intname,
-                          unsigned char **in) {
-  int len, ltmp;
-  size_t i;
-  ASN1_VALUE *v;
-  STACK_OF(ASN1_VALUE) *intname = (STACK_OF(ASN1_VALUE) *)_intname;
-
-  len = 0;
-  for (i = 0; i < sk_ASN1_VALUE_num(intname); i++) {
-    v = sk_ASN1_VALUE_value(intname, i);
-    ltmp = ASN1_item_ex_i2d(&v, in, ASN1_ITEM_rptr(X509_NAME_ENTRIES),
-                            /*tag=*/-1, /*aclass=*/0);
-    if (ltmp < 0) {
-      return ltmp;
-    }
-    len += ltmp;
-  }
-  return len;
-}
-
-int X509_NAME_set(X509_NAME **xn, X509_NAME *name) {
-  if ((name = X509_NAME_dup(name)) == NULL) {
+int X509_NAME_set(X509_NAME **xn, const X509_NAME *name) {
+  UniquePtr<X509_NAME> copy(X509_NAME_dup(name));
+  if (copy == nullptr) {
     return 0;
   }
   X509_NAME_free(*xn);
-  *xn = name;
+  *xn = copy.release();
   return 1;
 }
 
 int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne) { return ne->set; }
 
-int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **out_der,
+int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **out_der,
                        size_t *out_der_len) {
-  // Make sure encoding is valid
-  if (i2d_X509_NAME(nm, NULL) <= 0) {
+  const X509_NAME_CACHE *cache = x509_name_get_cache(nm);
+  if (cache == nullptr) {
     return 0;
   }
-  if (out_der != NULL) {
-    *out_der = (unsigned char *)nm->bytes->data;
+  if (out_der != nullptr) {
+    *out_der = cache->der.data();
   }
-  if (out_der_len != NULL) {
-    *out_der_len = nm->bytes->length;
+  if (out_der_len != nullptr) {
+    *out_der_len = cache->der.size();
   }
   return 1;
 }
-
-int x509_marshal_name(CBB *out, X509_NAME *in) {
-  int len = i2d_X509_NAME(in, nullptr);
-  if (len <= 0) {
-    return 0;
-  }
-  uint8_t *ptr;
-  return CBB_add_space(out, &ptr, len) && i2d_X509_NAME(in, &ptr) == len;
-}