grpc 1.84.1 → 1.85.0.pre1

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

@@ -23,34 +23,57 @@
 #include <limits.h>
 #include <string.h>
 
-#include "../bytestring/internal.h"
+#include <algorithm>
+
 #include "../internal.h"
 #include "internal.h"
 
-// Constructed types with a recursive definition (such as can be found in PKCS7)
-// could eventually exceed the stack given malicious input with excessive
-// recursion. Therefore we limit the stack depth. This is the maximum number of
-// recursive invocations of asn1_item_embed_d2i().
+
+using namespace bssl;
+
+// Constructed types with a recursive definition could eventually exceed the
+// stack given malicious input with excessive recursion. We don't currently
+// support such types (our PKCS#7 parser does not use this framework and does
+// not implement the full recursive PKCS#7), but limit recursion nonetheless.
 #define ASN1_MAX_CONSTRUCTED_NEST 30
 
-static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass,
-                           char *cst, const unsigned char **in, long len,
-                           int exptag, int expclass, char opt);
-
-static int asn1_template_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
-                                long len, const ASN1_TEMPLATE *tt, char opt,
-                                CRYPTO_BUFFER *buf, int depth);
-static int asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in,
-                                   long len, const ASN1_TEMPLATE *tt, char opt,
-                                   CRYPTO_BUFFER *buf, int depth);
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
-                       int utype, const ASN1_ITEM *it);
-static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in,
-                                 long len, const ASN1_ITEM *it, int tag,
-                                 int aclass, char opt);
-static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
-                            long len, const ASN1_ITEM *it, int tag, int aclass,
-                            char opt, CRYPTO_BUFFER *buf, int depth);
+// The following functions parse a structure of type `it` (or `tt`) from `cbs`
+// and write the result to `*pval`. They return one on success and zero on
+// error.
+//
+// If `opt` is true, the field is optional. If an optional element is missing,
+// the function returns one and consumes zero bytes from `cbs`.
+//
+// If `tag` is non-zero, the type is implicitly-tagged with the specified tag.
+// `tag` should not have the constructed bit set. If the ASN.1 type is
+// constructed, it will be set as appropriate.
+//
+// On entry, `*pval` may either be null or a default-initialized object,
+// according to tasn_new.cc. It, however, may not be an arbitrary object.
+// Historically, this code supported arbitrary objects, though not very well, so
+// some remnants of more general handling remain.
+//
+// With the exception of `asn1_parse_item`, there may be a partial object left
+// in `*pval` on error. `asn1_parse_item` is the main entrypoint and is
+// responsible for recursively freeing objects on error.
+static int asn1_parse_item(ASN1_VALUE **pval, CBS *cbs, const ASN1_ITEM *it,
+                           CBS_ASN1_TAG tag, bool opt, int depth);
+static int asn1_parse_template(ASN1_VALUE **pval, CBS *cbs,
+                               const ASN1_TEMPLATE *tt, CBS_ASN1_TAG tag,
+                               bool opt, int depth);
+
+// asn1_parse_template_no_explicit behaves like `asn1_parse_template` but
+// ignores any explicit tag specified in `tt`.
+static int asn1_parse_template_no_explicit(ASN1_VALUE **pval, CBS *cbs,
+                                           const ASN1_TEMPLATE *tt,
+                                           CBS_ASN1_TAG tag, bool opt,
+                                           int depth);
+
+// asn1_parse_item_primitive behaves like `asn1_parse_item` but only supports
+// primitive types.
+static int asn1_parse_item_primitive(ASN1_VALUE **pval, CBS *cbs,
+                                     const ASN1_ITEM *it, CBS_ASN1_TAG tag,
+                                     bool opt, int depth);
 
 unsigned long ASN1_tag2bit(int tag) {
   switch (tag) {
@@ -91,873 +114,498 @@ unsigned long ASN1_tag2bit(int tag) {
   }
 }
 
-static int is_supported_universal_type(int tag, int aclass) {
-  if (aclass != V_ASN1_UNIVERSAL) {
-    return 0;
+ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **pval, const uint8_t **in, long len,
+                          const ASN1_ITEM *it) {
+  if (len < 0) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_BUFFER_TOO_SMALL);
+    return nullptr;
   }
-  return tag == V_ASN1_OBJECT || tag == V_ASN1_NULL || tag == V_ASN1_BOOLEAN ||
-         tag == V_ASN1_BIT_STRING || tag == V_ASN1_INTEGER ||
-         tag == V_ASN1_ENUMERATED || tag == V_ASN1_OCTET_STRING ||
-         tag == V_ASN1_NUMERICSTRING || tag == V_ASN1_PRINTABLESTRING ||
-         tag == V_ASN1_T61STRING || tag == V_ASN1_VIDEOTEXSTRING ||
-         tag == V_ASN1_IA5STRING || tag == V_ASN1_UTCTIME ||
-         tag == V_ASN1_GENERALIZEDTIME || tag == V_ASN1_GRAPHICSTRING ||
-         tag == V_ASN1_VISIBLESTRING || tag == V_ASN1_GENERALSTRING ||
-         tag == V_ASN1_UNIVERSALSTRING || tag == V_ASN1_BMPSTRING ||
-         tag == V_ASN1_UTF8STRING || tag == V_ASN1_SET ||
-         tag == V_ASN1_SEQUENCE;
-}
 
-// Macro to initialize and invalidate the cache
+  // Bound `len` to comfortably fit in an `int`. Historically, this parser
+  // routinely mismatched integer types and did not correctly handle overflow.
+  // This is now largely fixed, but continue to cap the length to be safe.
+  len = std::min(len, long{INT_MAX / 2});
 
-// Decode an ASN1 item, this currently behaves just like a standard 'd2i'
-// function. 'in' points to a buffer to read the data from, in future we
-// will have more advanced versions that can input data a piece at a time and
-// this will simply be a special case.
-
-ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
-                          const ASN1_ITEM *it) {
-  ASN1_VALUE *ret = NULL;
-  if (asn1_item_ex_d2i(&ret, in, len, it, /*tag=*/-1, /*aclass=*/0, /*opt=*/0,
-                       /*buf=*/NULL, /*depth=*/0) <= 0) {
-    // Clean up, in case the caller left a partial object.
-    //
-    // TODO(davidben): I don't think it can leave one, but the codepaths below
-    // are a bit inconsistent. Revisit this when rewriting this function.
-    ASN1_item_ex_free(&ret, it);
+  CBS cbs;
+  CBS_init(&cbs, *in, len);
+  ASN1_VALUE *ret = nullptr;
+  if (!asn1_parse_item(&ret, &cbs, it, /*tag=*/0, /*opt=*/false, /*depth=*/0)) {
+    return nullptr;
   }
 
   // If the caller supplied an output pointer, free the old one and replace it
-  // with |ret|. This differs from OpenSSL slightly in that we don't support
+  // with `ret`. This differs from OpenSSL slightly in that we don't support
   // object reuse. We run this on both success and failure. On failure, even
   // with object reuse, OpenSSL destroys the previous object.
-  if (pval != NULL) {
+  if (pval != nullptr) {
     ASN1_item_ex_free(pval, it);
     *pval = ret;
   }
+  *in = CBS_data(&cbs);
   return ret;
 }
 
-// Decode an item, taking care of IMPLICIT tagging, if any. If 'opt' set and
-// tag mismatch return -1 to handle OPTIONAL
-//
-// TODO(davidben): Historically, all functions in this file had to account for
-// |*pval| containing an arbitrary existing value. This is no longer the case
-// because |ASN1_item_d2i| now always starts from NULL. As part of rewriting
-// this function, take the simplified assumptions into account. Though we must
-// still account for the internal calls to |ASN1_item_ex_new|.
-
-static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
-                            long len, const ASN1_ITEM *it, int tag, int aclass,
-                            char opt, CRYPTO_BUFFER *buf, int depth) {
-  const ASN1_TEMPLATE *tt, *errtt = NULL;
-  const unsigned char *p = NULL, *q;
-  unsigned char oclass;
-  char cst, isopt;
-  int i;
-  int otag;
-  int ret = 0;
-  ASN1_VALUE **pchptr;
-  if (!pval) {
-    return 0;
+template <typename T, T *new_func()>
+static T *ensure_value(ASN1_VALUE **pval) {
+  if (*pval) {
+    return reinterpret_cast<T *>(*pval);
   }
-
-  if (buf != NULL) {
-    assert(CRYPTO_BUFFER_data(buf) <= *in &&
-           *in + len <= CRYPTO_BUFFER_data(buf) + CRYPTO_BUFFER_len(buf));
-  }
-
-  // Bound |len| to comfortably fit in an int. Lengths in this module often
-  // switch between int and long without overflow checks.
-  if (len > INT_MAX / 2) {
-    len = INT_MAX / 2;
+  T *obj = new_func();
+  if (obj == nullptr) {
+    return nullptr;
   }
+  *pval = reinterpret_cast<ASN1_VALUE *>(obj);
+  return obj;
+}
 
+static int asn1_parse_item_no_error_cleanup(ASN1_VALUE **pval, CBS *cbs,
+                                            const ASN1_ITEM *it,
+                                            CBS_ASN1_TAG tag, bool opt,
+                                            int depth,
+                                            const ASN1_TEMPLATE **errtt) {
   if (++depth > ASN1_MAX_CONSTRUCTED_NEST) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_TOO_DEEP);
-    goto err;
+    return 0;
   }
 
   switch (it->itype) {
     case ASN1_ITYPE_PRIMITIVE:
       if (it->templates) {
-        // tagging or OPTIONAL is currently illegal on an item template
-        // because the flags can't get passed down. In practice this
-        // isn't a problem: we include the relevant flags from the item
-        // template in the template itself.
-        if ((tag != -1) || opt) {
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE);
-          goto err;
+        // This is an `ASN1_ITEM_TEMPLATE`, so the underlying template cannot be
+        // optional. Optionality should be expressed at the layer above.
+        if (it->templates->flags & ASN1_TFLG_OPTIONAL) {
+          OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
+          return 0;
         }
-        return asn1_template_ex_d2i(pval, in, len, it->templates, opt, buf,
-                                    depth);
+        return asn1_parse_template(pval, cbs, it->templates, tag, opt, depth);
       }
-      return asn1_d2i_ex_primitive(pval, in, len, it, tag, aclass, opt);
-      break;
+      return asn1_parse_item_primitive(pval, cbs, it, tag, opt, depth);
 
-    case ASN1_ITYPE_MSTRING:
-      // It never makes sense for multi-strings to have implicit tagging, so
-      // if tag != -1, then this looks like an error in the template.
-      if (tag != -1) {
+    case ASN1_ITYPE_MSTRING: {
+      // Multi-strings are CHOICE types and cannot be implicitly tagged.
+      if (tag != 0) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-        goto err;
-      }
-
-      p = *in;
-      // Just read in tag and class
-      ret = asn1_check_tlen(NULL, &otag, &oclass, NULL, &p, len, -1, 0, 1);
-      if (!ret) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
+        return 0;
       }
 
-      // Must be UNIVERSAL class
-      if (oclass != V_ASN1_UNIVERSAL) {
-        // If OPTIONAL, assume this is OK
+      tag = CBS_peek_any_asn1_tag(cbs);
+      if ((tag & CBS_ASN1_CLASS_MASK) != CBS_ASN1_UNIVERSAL ||
+          (tag & CBS_ASN1_CONSTRUCTED) ||
+          (ASN1_tag2bit(tag & CBS_ASN1_TAG_NUMBER_MASK) & it->utype) == 0) {
         if (opt) {
-          return -1;
-        }
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_MSTRING_NOT_UNIVERSAL);
-        goto err;
-      }
-      // Check tag matches bit map
-      if (!(ASN1_tag2bit(otag) & it->utype)) {
-        // If OPTIONAL, assume this is OK
-        if (opt) {
-          return -1;
+          ASN1_item_ex_free(pval, it);
+          return 1;  // Omitted optional field.
         }
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_MSTRING_WRONG_TAG);
-        goto err;
+        return 0;
       }
-      return asn1_d2i_ex_primitive(pval, in, len, it, otag, 0, 0);
+      ASN1_STRING *out = ensure_value<ASN1_STRING, ASN1_STRING_new>(pval);
+      return out != nullptr && asn1_parse_any_as_string(cbs, out);
+    }
 
     case ASN1_ITYPE_EXTERN: {
       // We don't support implicit tagging with external types.
-      if (tag != -1) {
+      if (tag != 0) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-        goto err;
+        return 0;
       }
-      const ASN1_EXTERN_FUNCS *ef =
-          reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
-      return ef->asn1_ex_d2i(pval, in, len, it, opt, NULL);
+      auto *ef = reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
+      return ef->asn1_ex_parse(pval, cbs, it, opt);
     }
 
     case ASN1_ITYPE_CHOICE: {
-      // It never makes sense for CHOICE types to have implicit tagging, so if
-      // tag != -1, then this looks like an error in the template.
-      if (tag != -1) {
+      // CHOICE types cannot be implicitly tagged.
+      if (tag != 0) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-        goto err;
+        return 0;
       }
 
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
-      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
-        goto auxerr;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
+      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, nullptr)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+        return 0;
       }
 
       if (*pval) {
-        // Free up and zero CHOICE value if initialised
-        i = asn1_get_choice_selector(pval, it);
-        if ((i >= 0) && (i < it->tcount)) {
-          tt = it->templates + i;
-          pchptr = asn1_get_field_ptr(pval, tt);
+        // Free up and zero the CHOICE value if initialised.
+        int idx = asn1_get_choice_selector(pval, it);
+        if (idx >= 0 && idx < it->tcount) {
+          const ASN1_TEMPLATE *tt = &it->templates[idx];
+          ASN1_VALUE **pchptr = asn1_get_field_ptr(pval, tt);
           ASN1_template_free(pchptr, tt);
           asn1_set_choice_selector(pval, -1, it);
         }
       } else if (!ASN1_item_ex_new(pval, it)) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
+        return 0;
       }
-      // CHOICE type, try each possibility in turn
-      p = *in;
-      for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
-        pchptr = asn1_get_field_ptr(pval, tt);
-        // We mark field as OPTIONAL so its absence can be recognised.
-        ret = asn1_template_ex_d2i(pchptr, &p, len, tt, 1, buf, depth);
-        // If field not present, try the next one
-        if (ret == -1) {
-          continue;
+
+      // Parse each possibility as an optional field and find the first one.
+      size_t orig_len = CBS_len(cbs);
+      int idx = 0;
+      for (idx = 0; idx < it->tcount; idx++) {
+        const ASN1_TEMPLATE *tt = &it->templates[idx];
+        ASN1_VALUE **pchptr = asn1_get_field_ptr(pval, tt);
+        if (!asn1_parse_template(pchptr, cbs, tt, /*tag=*/0, /*opt=*/true,
+                                 depth)) {
+          // Free any partial object left in `pchptr`. `asn1_item_parse` will
+          // clean up `pval`, but that will not clean up `pchptr` because the
+          // choice selector has not yet been set below.
+          ASN1_template_free(pchptr, tt);
+          *errtt = tt;
+          OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
+          return 0;
         }
-        // If positive return, read OK, break loop
-        if (ret > 0) {
-          break;
+        if (CBS_len(cbs) != orig_len) {
+          break;  // Found a match.
         }
-        // Otherwise must be an ASN1 parsing error
-        errtt = tt;
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
       }
-
-      // Did we fall off the end without reading anything?
-      if (i == it->tcount) {
-        // If OPTIONAL, this is OK
+      if (idx == it->tcount) {
+        // Nothing matched. If the CHOICE is OPTIONAL, this is OK.
         if (opt) {
-          // Free and zero it
           ASN1_item_ex_free(pval, it);
-          return -1;
+          return 1;
         }
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_NO_MATCHING_CHOICE_TYPE);
-        goto err;
+        return 0;
       }
-
-      asn1_set_choice_selector(pval, i, it);
-      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL)) {
-        goto auxerr;
+      asn1_set_choice_selector(pval, idx, it);
+      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, nullptr)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+        return 0;
       }
-      *in = p;
       return 1;
     }
 
     case ASN1_ITYPE_SEQUENCE: {
-      p = *in;
-
-      // If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL
-      if (tag == -1) {
-        tag = V_ASN1_SEQUENCE;
-        aclass = V_ASN1_UNIVERSAL;
+      tag = tag == 0 ? CBS_ASN1_SEQUENCE : (tag | CBS_ASN1_CONSTRUCTED);
+      if (opt && !CBS_peek_asn1_tag(cbs, tag)) {
+        ASN1_item_ex_free(pval, it);
+        return 1;
       }
-      // Get SEQUENCE length and update len, p
-      ret = asn1_check_tlen(&len, NULL, NULL, &cst, &p, len, tag, aclass, opt);
-      if (!ret) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
-      } else if (ret == -1) {
-        return -1;
-      }
-      if (!cst) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_SEQUENCE_NOT_CONSTRUCTED);
-        goto err;
+
+      CBS copy = *cbs, seq;
+      if (!CBS_get_asn1(cbs, &seq, tag)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+        return 0;
       }
 
       if (!*pval && !ASN1_item_ex_new(pval, it)) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
+        return 0;
       }
 
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
-      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
-        goto auxerr;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
+      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, nullptr)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+        return 0;
       }
 
-      // Free up and zero any ADB found
-      for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
+      // Free up and zero any ADB found.
+      for (int i = 0; i < it->tcount; i++) {
+        const ASN1_TEMPLATE *tt = &it->templates[i];
         if (tt->flags & ASN1_TFLG_ADB_MASK) {
-          const ASN1_TEMPLATE *seqtt;
-          ASN1_VALUE **pseqval;
-          seqtt = asn1_do_adb(pval, tt, 0);
-          if (seqtt == NULL) {
+          const ASN1_TEMPLATE *seqtt = asn1_do_adb(pval, tt, 0);
+          if (seqtt == nullptr) {
             continue;
           }
-          pseqval = asn1_get_field_ptr(pval, seqtt);
+          ASN1_VALUE **pseqval = asn1_get_field_ptr(pval, seqtt);
           ASN1_template_free(pseqval, seqtt);
         }
       }
 
-      // Get each field entry
-      for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
-        const ASN1_TEMPLATE *seqtt;
-        ASN1_VALUE **pseqval;
-        seqtt = asn1_do_adb(pval, tt, 1);
-        if (seqtt == NULL) {
-          goto err;
-        }
-        pseqval = asn1_get_field_ptr(pval, seqtt);
-        // Have we ran out of data?
-        if (!len) {
-          break;
-        }
-        q = p;
-        // This determines the OPTIONAL flag value. The field cannot be
-        // omitted if it is the last of a SEQUENCE and there is still
-        // data to be read. This isn't strictly necessary but it
-        // increases efficiency in some cases.
-        if (i == (it->tcount - 1)) {
-          isopt = 0;
-        } else {
-          isopt = (seqtt->flags & ASN1_TFLG_OPTIONAL) != 0;
+      // Get each field entry.
+      for (int i = 0; i < it->tcount; i++) {
+        const ASN1_TEMPLATE *tt = &it->templates[i];
+        const ASN1_TEMPLATE *seqtt = asn1_do_adb(pval, tt, /*nullerr=*/1);
+        if (seqtt == nullptr) {
+          return 0;
         }
-        // attempt to read in field, allowing each to be OPTIONAL
-
-        ret = asn1_template_ex_d2i(pseqval, &p, len, seqtt, isopt, buf, depth);
-        if (!ret) {
-          errtt = seqtt;
-          goto err;
-        } else if (ret == -1) {
-          // OPTIONAL component absent. Free and zero the field.
-          ASN1_template_free(pseqval, seqtt);
-          continue;
+        ASN1_VALUE **pseqval = asn1_get_field_ptr(pval, seqtt);
+        const bool field_opt = (tt->flags & ASN1_TFLG_OPTIONAL) != 0;
+        if (!asn1_parse_template(pseqval, &seq, seqtt, /*tag=*/0, field_opt,
+                                 depth)) {
+          *errtt = tt;
+          return 0;
         }
-        // Update length
-        len -= p - q;
       }
-
-      // Check all data read
-      if (len) {
+      if (CBS_len(&seq) != 0) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_SEQUENCE_LENGTH_MISMATCH);
-        goto err;
-      }
-
-      // If we get here we've got no more data in the SEQUENCE, however we
-      // may not have read all fields so check all remaining are OPTIONAL
-      // and clear any that are.
-      for (; i < it->tcount; tt++, i++) {
-        const ASN1_TEMPLATE *seqtt;
-        seqtt = asn1_do_adb(pval, tt, 1);
-        if (seqtt == NULL) {
-          goto err;
-        }
-        if (seqtt->flags & ASN1_TFLG_OPTIONAL) {
-          ASN1_VALUE **pseqval;
-          pseqval = asn1_get_field_ptr(pval, seqtt);
-          ASN1_template_free(pseqval, seqtt);
-        } else {
-          errtt = seqtt;
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_FIELD_MISSING);
-          goto err;
-        }
+        return 0;
       }
-      // Save encoding
-      if (!asn1_enc_save(pval, *in, p - *in, it, buf)) {
-        goto auxerr;
+      // Save a copy of the bytes consumed.
+      if (!asn1_enc_save(pval, CBS_data(&copy), CBS_len(&copy) - CBS_len(cbs),
+                         it)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+        return 0;
       }
-      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL)) {
-        goto auxerr;
+      if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, nullptr)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+        return 0;
       }
-      *in = p;
       return 1;
     }
 
     default:
+      OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
       return 0;
   }
-auxerr:
-  OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
-err:
-  ASN1_item_ex_free(pval, it);
-  if (errtt) {
-    ERR_add_error_data(4, "Field=", errtt->field_name, ", Type=", it->sname);
-  } else {
-    ERR_add_error_data(2, "Type=", it->sname);
-  }
-  return 0;
-}
-
-int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
-                     const ASN1_ITEM *it, int tag, int aclass, char opt,
-                     CRYPTO_BUFFER *buf) {
-  return asn1_item_ex_d2i(pval, in, len, it, tag, aclass, opt, buf,
-                          /*depth=*/0);
 }
 
-// Templates are handled with two separate functions. One handles any
-// EXPLICIT tag and the other handles the rest.
-
-static int asn1_template_ex_d2i(ASN1_VALUE **val, const unsigned char **in,
-                                long inlen, const ASN1_TEMPLATE *tt, char opt,
-                                CRYPTO_BUFFER *buf, int depth) {
-  int aclass;
-  int ret;
-  long len;
-  const unsigned char *p, *q;
-  if (!val) {
+static int asn1_parse_item(ASN1_VALUE **pval, CBS *cbs, const ASN1_ITEM *it,
+                           CBS_ASN1_TAG tag, bool opt, int depth) {
+  const ASN1_TEMPLATE *errtt = nullptr;
+  if (!asn1_parse_item_no_error_cleanup(pval, cbs, it, tag, opt, depth,
+                                        &errtt)) {
+    ASN1_item_ex_free(pval, it);
+    if (errtt != nullptr) {
+      ERR_add_error_data(4, "Field=", errtt->field_name, ", Type=", it->sname);
+    } else {
+      ERR_add_error_data(2, "Type=", it->sname);
+    }
     return 0;
   }
+  return 1;
+}
+
+// Templates are handled with two separate functions. One handles any EXPLICIT
+// tag and the other handles the rest.
+
+static int asn1_parse_template(ASN1_VALUE **pval, CBS *cbs,
+                               const ASN1_TEMPLATE *tt, CBS_ASN1_TAG tag,
+                               bool opt, int depth) {
   uint32_t flags = tt->flags;
-  aclass = flags & ASN1_TFLG_TAG_CLASS;
-
-  p = *in;
-
-  // Check if EXPLICIT tag expected
-  if (flags & ASN1_TFLG_EXPTAG) {
-    char cst;
-    // Need to work out amount of data available to the inner content and
-    // where it starts: so read in EXPLICIT header to get the info.
-    ret = asn1_check_tlen(&len, NULL, NULL, &cst, &p, inlen, tt->tag, aclass,
-                          opt);
-    q = p;
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-      return 0;
-    } else if (ret == -1) {
-      return -1;
-    }
-    if (!cst) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED);
-      return 0;
-    }
-    // We've found the field so it can't be OPTIONAL now
-    ret = asn1_template_noexp_d2i(val, &p, len, tt, /*opt=*/0, buf, depth);
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
+  if ((flags & ASN1_TFLG_EXPTAG) == 0) {
+    return asn1_parse_template_no_explicit(pval, cbs, tt, tag, opt, depth);
+  }
+
+  // Determine the tag.
+  if (tag == 0) {
+    tag = asn1_tag_to_cbs(flags & ASN1_TFLG_TAG_CLASS, tt->tag);
+    if (tag == 0) {
       return 0;
     }
-    // We read the field in OK so update length
-    len -= p - q;
-    // Check for trailing data.
-    if (len) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_EXPLICIT_LENGTH_MISMATCH);
-      goto err;
-    }
-  } else {
-    return asn1_template_noexp_d2i(val, in, inlen, tt, opt, buf, depth);
   }
+  tag |= CBS_ASN1_CONSTRUCTED;
 
-  *in = p;
-  return 1;
-
-err:
-  ASN1_template_free(val, tt);
-  return 0;
-}
+  if (opt && !CBS_peek_asn1_tag(cbs, tag)) {
+    ASN1_template_free(pval, tt);
+    return 1;
+  }
 
-static int asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in,
-                                   long len, const ASN1_TEMPLATE *tt, char opt,
-                                   CRYPTO_BUFFER *buf, int depth) {
-  int aclass;
-  int ret;
-  const unsigned char *p;
-  if (!val) {
+  CBS child;
+  if (!CBS_get_asn1(cbs, &child, tag)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
     return 0;
   }
-  uint32_t flags = tt->flags;
-  aclass = flags & ASN1_TFLG_TAG_CLASS;
+  if (!asn1_parse_template_no_explicit(pval, &child, tt, /*tag=*/0,
+                                       /*opt=*/false, depth)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
+    return 0;
+  }
+  if (CBS_len(&child) != 0) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_EXPLICIT_LENGTH_MISMATCH);
+    return 0;
+  }
+  return 1;
+}
 
-  p = *in;
+static int asn1_parse_template_no_explicit(ASN1_VALUE **pval, CBS *cbs,
+                                           const ASN1_TEMPLATE *tt,
+                                           CBS_ASN1_TAG tag, bool opt,
+                                           int depth) {
+  // If `tt` provides implicit tagging and the caller did not already override
+  // the tag, pick up the tag from the template.
+  uint32_t flags = tt->flags;
+  if ((flags & ASN1_TFLG_IMPTAG) && tag == 0) {
+    tag = asn1_tag_to_cbs(flags & ASN1_TFLG_TAG_CLASS, tt->tag);
+    if (tag == 0) {
+      return 0;
+    }
+  }
 
   if (flags & ASN1_TFLG_SK_MASK) {
-    // SET OF, SEQUENCE OF
-    int sktag, skaclass;
-    // First work out expected inner tag value
-    if (flags & ASN1_TFLG_IMPTAG) {
-      sktag = tt->tag;
-      skaclass = aclass;
-    } else {
-      skaclass = V_ASN1_UNIVERSAL;
-      if (flags & ASN1_TFLG_SET_OF) {
-        sktag = V_ASN1_SET;
-      } else {
-        sktag = V_ASN1_SEQUENCE;
-      }
+    if (tag == 0) {
+      tag = (flags & ASN1_TFLG_SET_OF) ? CBS_ASN1_SET : CBS_ASN1_SEQUENCE;
     }
-    // Get the tag
-    ret =
-        asn1_check_tlen(&len, NULL, NULL, NULL, &p, len, sktag, skaclass, opt);
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-      return 0;
-    } else if (ret == -1) {
-      return -1;
+    tag |= CBS_ASN1_CONSTRUCTED;
+
+    if (opt && !CBS_peek_asn1_tag(cbs, tag)) {
+      ASN1_template_free(pval, tt);
+      return 1;
     }
-    if (!*val) {
-      *val = (ASN1_VALUE *)sk_ASN1_VALUE_new_null();
-    } else {
-      // We've got a valid STACK: free up any items present
-      STACK_OF(ASN1_VALUE) *sktmp = (STACK_OF(ASN1_VALUE) *)*val;
-      ASN1_VALUE *vtmp;
-      while (sk_ASN1_VALUE_num(sktmp) > 0) {
-        vtmp = sk_ASN1_VALUE_pop(sktmp);
-        ASN1_item_ex_free(&vtmp, ASN1_ITEM_ptr(tt->item));
-      }
+    CBS seq;
+    if (!CBS_get_asn1(cbs, &seq, tag)) {
+      OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+      return 0;
     }
 
-    if (!*val) {
-      goto err;
+    STACK_OF(ASN1_VALUE) *sk =
+        ensure_value<STACK_OF(ASN1_VALUE), sk_ASN1_VALUE_new_null>(pval);
+    if (sk == nullptr) {
+      return 0;
     }
+    assert(sk_ASN1_VALUE_num(sk) == 0);
 
-    // Read as many items as we can
-    while (len > 0) {
-      ASN1_VALUE *skfield;
-      const unsigned char *q = p;
-      skfield = NULL;
-      if (!asn1_item_ex_d2i(&skfield, &p, len, ASN1_ITEM_ptr(tt->item),
-                            /*tag=*/-1, /*aclass=*/0, /*opt=*/0, buf, depth)) {
+    while (CBS_len(&seq) != 0) {
+      ASN1_VALUE *skfield = nullptr;
+      if (!asn1_parse_item(&skfield, &seq, ASN1_ITEM_ptr(tt->item), /*tag=*/0,
+                           /*opt=*/false, depth)) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-        goto err;
+        ASN1_item_ex_free(&skfield, ASN1_ITEM_ptr(tt->item));
+        return 0;
       }
-      len -= p - q;
-      if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, skfield)) {
+      if (!sk_ASN1_VALUE_push(sk, skfield)) {
         ASN1_item_ex_free(&skfield, ASN1_ITEM_ptr(tt->item));
-        goto err;
+        return 0;
       }
     }
-  } else if (flags & ASN1_TFLG_IMPTAG) {
-    // IMPLICIT tagging
-    ret = asn1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item), tt->tag,
-                           aclass, opt, buf, depth);
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-      goto err;
-    } else if (ret == -1) {
-      return -1;
-    }
-  } else {
-    // Nothing special
-    ret = asn1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item), /*tag=*/-1,
-                           /*aclass=*/0, opt, buf, depth);
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-      goto err;
-    } else if (ret == -1) {
-      return -1;
-    }
+    return 1;
   }
 
-  *in = p;
-  return 1;
-
-err:
-  ASN1_template_free(val, tt);
-  return 0;
+  return asn1_parse_item(pval, cbs, ASN1_ITEM_ptr(tt->item), tag, opt, depth);
 }
 
-static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in,
-                                 long inlen, const ASN1_ITEM *it, int tag,
-                                 int aclass, char opt) {
-  int ret = 0, utype;
-  long plen;
-  char cst;
-  const unsigned char *p;
-  const unsigned char *cont = NULL;
-  long len;
-  if (!pval) {
-    OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_NULL);
-    return 0;  // Should never happen
-  }
-
-  assert(it->itype == ASN1_ITYPE_PRIMITIVE || it->itype == ASN1_ITYPE_MSTRING);
-  if (it->itype == ASN1_ITYPE_MSTRING) {
-    utype = tag;
-    tag = -1;
-  } else {
-    utype = it->utype;
-  }
-
-  if (utype == V_ASN1_ANY || utype == V_ASN1_ANY_AS_STRING) {
-    // If type is ANY need to figure out type from tag
-    unsigned char oclass;
-    if (tag >= 0) {
+static int asn1_parse_item_primitive(ASN1_VALUE **pval, CBS *cbs,
+                                     const ASN1_ITEM *it, CBS_ASN1_TAG tag,
+                                     bool opt, int depth) {
+  assert(it->itype == ASN1_ITYPE_PRIMITIVE);
+  // `ASN1_ITEM_TEMPLATE` should have been handled by the caller.
+  assert(it->templates == nullptr);
+  // Historically, `it->funcs` for primitive types contained an
+  // `ASN1_PRIMITIVE_FUNCS` table of callbacks.
+  assert(it->funcs == nullptr);
+  int utype = it->utype;
+
+  // Handle ANY types.
+  if (utype == V_ASN1_ANY) {
+    if (tag != 0) {
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_TAGGED_ANY);
       return 0;
     }
-    if (opt) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_OPTIONAL_ANY);
-      return 0;
+    if (opt && CBS_len(cbs) == 0) {
+      ASN1_item_ex_free(pval, it);
+      return 1;  // Omitted OPTIONAL value.
     }
-    const int is_string = utype == V_ASN1_ANY_AS_STRING;
-    p = *in;
-    ret = asn1_check_tlen(&plen, &utype, &oclass, &cst, &p, inlen, -1, 0, 0);
-    if (!ret) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
+    ASN1_TYPE *typ = ensure_value<ASN1_TYPE, ASN1_TYPE_new>(pval);
+    if (typ == nullptr) {
       return 0;
     }
-    if (!is_supported_universal_type(utype, oclass)) {
-      utype = V_ASN1_OTHER;
-    }
-    // These three types are not represented as |ASN1_STRING|, so they must be
-    // parsed separately and then treated as an opaque |V_ASN1_OTHER|.
-    if (is_string && (utype == V_ASN1_OBJECT || utype == V_ASN1_NULL ||
-                      utype == V_ASN1_BOOLEAN)) {
-      if (cst) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_TYPE_NOT_PRIMITIVE);
-        return 0;
-      }
-      CBS cbs;
-      CBS_init(&cbs, p, plen);
-      if (utype == V_ASN1_OBJECT && !CBS_is_valid_asn1_oid(&cbs)) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_OBJECT_ENCODING);
-        return 0;
-      }
-      if (utype == V_ASN1_NULL && CBS_len(&cbs) != 0) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_NULL_IS_WRONG_LENGTH);
-        return 0;
-      }
-      if (utype == V_ASN1_BOOLEAN) {
-        if (CBS_len(&cbs) != 1) {
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
-          return 0;
-        }
-        uint8_t v = CBS_data(&cbs)[0];
-        if (v != 0 && v != 0xff) {
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
-          return 0;
-        }
-      }
-      utype = V_ASN1_OTHER;
-    }
-  }
-  if (tag == -1) {
-    tag = utype;
-    aclass = V_ASN1_UNIVERSAL;
-  }
-  p = *in;
-  // Check header
-  ret = asn1_check_tlen(&plen, NULL, NULL, &cst, &p, inlen, tag, aclass, opt);
-  if (!ret) {
-    OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
-    return 0;
-  } else if (ret == -1) {
-    return -1;
+    return asn1_parse_any(cbs, typ);
   }
-  ret = 0;
-  // SEQUENCE, SET and "OTHER" are left in encoded form
-  if ((utype == V_ASN1_SEQUENCE) || (utype == V_ASN1_SET) ||
-      (utype == V_ASN1_OTHER)) {
-    // SEQUENCE and SET must be constructed
-    if (utype != V_ASN1_OTHER && !cst) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_TYPE_NOT_CONSTRUCTED);
-      return 0;
-    }
 
-    cont = *in;
-    len = p - cont + plen;
-    p += plen;
-  } else if (cst) {
-    // This parser historically supported BER constructed strings. We no
-    // longer do and will gradually tighten this parser into a DER
-    // parser. BER types should use |CBS_asn1_ber_to_der|.
-    OPENSSL_PUT_ERROR(ASN1, ASN1_R_TYPE_NOT_PRIMITIVE);
-    return 0;
-  } else {
-    cont = p;
-    len = plen;
-    p += plen;
+  // Determine the ASN.1 tag. `utype` must be a primitive `ASN1_ITEM`, handled
+  // by `DECLARE_ASN1_ITEM`.
+  assert(0 <= utype && utype <= int{CBS_ASN1_TAG_NUMBER_MASK});
+  if (tag == 0) {
+    tag = static_cast<CBS_ASN1_TAG>(utype);
   }
-
-  // We now have content length and type: translate into a structure
-  if (!asn1_ex_c2i(pval, cont, len, utype, it)) {
-    goto err;
+  if (utype == V_ASN1_SEQUENCE || utype == V_ASN1_SET) {
+    tag |= CBS_ASN1_CONSTRUCTED;
   }
 
-  *in = p;
-  ret = 1;
-err:
-  return ret;
-}
-
-// Translate ASN1 content octets into a structure
-
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
-                       int utype, const ASN1_ITEM *it) {
-  ASN1_VALUE **opval = NULL;
-  ASN1_STRING *stmp;
-  ASN1_TYPE *typ = NULL;
-  int ret = 0;
-  ASN1_INTEGER **tint;
-
-  // Historically, |it->funcs| for primitive types contained an
-  // |ASN1_PRIMITIVE_FUNCS| table of callbacks.
-  assert(it->funcs == NULL);
-
-  // If ANY type clear type and set pointer to internal value
-  if (it->utype == V_ASN1_ANY) {
-    if (!*pval) {
-      typ = ASN1_TYPE_new();
-      if (typ == NULL) {
-        goto err;
-      }
-      *pval = (ASN1_VALUE *)typ;
-    } else {
-      typ = (ASN1_TYPE *)*pval;
-    }
-
-    if (utype != typ->type) {
-      ASN1_TYPE_set(typ, utype, NULL);
-    }
-    opval = pval;
-    pval = &typ->value.asn1_value;
+  if (opt && !CBS_peek_asn1_tag(cbs, tag)) {
+    ASN1_item_ex_free(pval, it);
+    return 1;  // Omitted OPTIONAL value.
   }
 
-  // If implementing a type that is not represented in |ASN1_STRING|, the
-  // |V_ASN1_ANY_AS_STRING| logic must be modified to redirect it to
-  // |V_ASN1_OTHER|.
+  // Handle non-`ASN1_STRING` types.
   switch (utype) {
-    case V_ASN1_OBJECT:
-      if (!c2i_ASN1_OBJECT((ASN1_OBJECT **)pval, &cont, len)) {
-        goto err;
+    case V_ASN1_OBJECT: {
+      UniquePtr<ASN1_OBJECT> obj(asn1_parse_object(cbs, tag));
+      if (obj == nullptr) {
+        return 0;
       }
-      break;
-
-    case V_ASN1_NULL:
-      if (len) {
+      ASN1_OBJECT_free((ASN1_OBJECT *)*pval);
+      *pval = (ASN1_VALUE *)obj.release();
+      return 1;
+    }
+    case V_ASN1_NULL: {
+      CBS null;
+      if (!CBS_get_asn1(cbs, &null, tag)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+        return 0;
+      }
+      if (CBS_len(&null) != 0) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_NULL_IS_WRONG_LENGTH);
-        goto err;
+        return 0;
       }
       *pval = (ASN1_VALUE *)1;
-      break;
-
-    case V_ASN1_BOOLEAN:
-      if (len != 1) {
+      return 1;
+    }
+    case V_ASN1_BOOLEAN: {
+      CBS child;
+      if (!CBS_get_asn1(cbs, &child, tag)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+        return 0;
+      }
+      // TODO(crbug.com/42290221): Reject invalid BOOLEAN encodings and just
+      // call `CBS_get_asn1_bool`.
+      if (CBS_len(&child) != 1) {
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
-        goto err;
-      } else {
-        ASN1_BOOLEAN *tbool;
-        tbool = (ASN1_BOOLEAN *)pval;
-        *tbool = *cont;
+        return 0;
       }
-      break;
+      ASN1_BOOLEAN *tbool;
+      tbool = (ASN1_BOOLEAN *)pval;
+      *tbool = CBS_data(&child)[0];
+      return 1;
+    }
+  }
 
-    case V_ASN1_BIT_STRING:
-      if (!c2i_ASN1_BIT_STRING((ASN1_BIT_STRING **)pval, &cont, len)) {
-        goto err;
-      }
-      break;
+  // All other types as an `ASN1_STRING` representation.
+  ASN1_STRING *str = ensure_value<ASN1_STRING, ASN1_STRING_new>(pval);
+  if (str == nullptr) {
+    return 0;
+  }
 
+  switch (utype) {
+    case V_ASN1_BIT_STRING:
+      return asn1_parse_bit_string(cbs, str, tag);
     case V_ASN1_INTEGER:
+      return asn1_parse_integer(cbs, str, tag);
     case V_ASN1_ENUMERATED:
-      tint = (ASN1_INTEGER **)pval;
-      if (!c2i_ASN1_INTEGER(tint, &cont, len)) {
-        goto err;
-      }
-      // Fixup type to match the expected form
-      (*tint)->type = utype | ((*tint)->type & V_ASN1_NEG);
-      break;
-
+      return asn1_parse_enumerated(cbs, str, tag);
+    case V_ASN1_UNIVERSALSTRING:
+      return asn1_parse_universal_string(cbs, str, tag);
+    case V_ASN1_BMPSTRING:
+      return asn1_parse_bmp_string(cbs, str, tag);
+    case V_ASN1_UTF8STRING:
+      return asn1_parse_utf8_string(cbs, str, tag);
+    case V_ASN1_UTCTIME:
+      // TODO(crbug.com/42290221): Reject timezone offsets. We need to parse
+      // invalid timestamps in `X509` objects, but that parser no longer uses
+      // this code.
+      return asn1_parse_utc_time(cbs, str, tag, /*allow_timezone_offset=*/1);
+    case V_ASN1_GENERALIZEDTIME:
+      return asn1_parse_generalized_time(cbs, str, tag);
     case V_ASN1_OCTET_STRING:
+      return asn1_parse_octet_string(cbs, str, tag);
+    case V_ASN1_T61STRING:
+      return asn1_parse_t61_string(cbs, str, tag);
     case V_ASN1_NUMERICSTRING:
     case V_ASN1_PRINTABLESTRING:
-    case V_ASN1_T61STRING:
     case V_ASN1_VIDEOTEXSTRING:
     case V_ASN1_IA5STRING:
-    case V_ASN1_UTCTIME:
-    case V_ASN1_GENERALIZEDTIME:
     case V_ASN1_GRAPHICSTRING:
     case V_ASN1_VISIBLESTRING:
     case V_ASN1_GENERALSTRING:
-    case V_ASN1_UNIVERSALSTRING:
-    case V_ASN1_BMPSTRING:
-    case V_ASN1_UTF8STRING:
-    case V_ASN1_OTHER:
-    case V_ASN1_SET:
+      // TODO(crbug.com/42290290): Enforce the encoding of the other string
+      // types.
+      return asn1_parse_string_unchecked(cbs, str, utype, tag);
     case V_ASN1_SEQUENCE: {
-      CBS cbs;
-      CBS_init(&cbs, cont, (size_t)len);
-      if (utype == V_ASN1_BMPSTRING) {
-        while (CBS_len(&cbs) != 0) {
-          uint32_t c;
-          if (!CBS_get_ucs2_be(&cbs, &c)) {
-            OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BMPSTRING);
-            goto err;
-          }
-        }
-      }
-      if (utype == V_ASN1_UNIVERSALSTRING) {
-        while (CBS_len(&cbs) != 0) {
-          uint32_t c;
-          if (!CBS_get_utf32_be(&cbs, &c)) {
-            OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_UNIVERSALSTRING);
-            goto err;
-          }
-        }
-      }
-      if (utype == V_ASN1_UTF8STRING) {
-        while (CBS_len(&cbs) != 0) {
-          uint32_t c;
-          if (!CBS_get_utf8(&cbs, &c)) {
-            OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_UTF8STRING);
-            goto err;
-          }
-        }
-      }
-      if (utype == V_ASN1_UTCTIME) {
-        if (!CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1)) {
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_TIME_FORMAT);
-          goto err;
-        }
-      }
-      if (utype == V_ASN1_GENERALIZEDTIME) {
-        if (!CBS_parse_generalized_time(&cbs, NULL,
-                                        /*allow_timezone_offset=*/0)) {
-          OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_TIME_FORMAT);
-          goto err;
-        }
-      }
-      // TODO(https://crbug.com/boringssl/427): Check other string types.
-
-      // All based on ASN1_STRING and handled the same
-      if (!*pval) {
-        stmp = ASN1_STRING_type_new(utype);
-        if (!stmp) {
-          goto err;
-        }
-        *pval = (ASN1_VALUE *)stmp;
-      } else {
-        stmp = (ASN1_STRING *)*pval;
-        stmp->type = utype;
-      }
-      if (!ASN1_STRING_set(stmp, cont, len)) {
-        ASN1_STRING_free(stmp);
-        *pval = NULL;
-        goto err;
+      // Save the entire element in the string.
+      CBS elem;
+      if (!CBS_get_asn1_element(cbs, &elem, tag)) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+        return 0;
       }
-      break;
+      str->type = V_ASN1_SEQUENCE;
+      return ASN1_STRING_set(str, CBS_data(&elem), CBS_len(&elem));
     }
-
     default:
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-      goto err;
-  }
-  // If ASN1_ANY and NULL type fix up value
-  if (typ && (utype == V_ASN1_NULL)) {
-    typ->value.ptr = NULL;
-  }
-
-  ret = 1;
-err:
-  if (!ret) {
-    ASN1_TYPE_free(typ);
-    if (opval) {
-      *opval = NULL;
-    }
-  }
-  return ret;
-}
-
-// Check an ASN1 tag and length: a bit like ASN1_get_object but it
-// checks the expected tag.
-
-static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass,
-                           char *cst, const unsigned char **in, long len,
-                           int exptag, int expclass, char opt) {
-  int i;
-  int ptag, pclass;
-  long plen;
-  const unsigned char *p;
-  p = *in;
-
-  i = ASN1_get_object(&p, &plen, &ptag, &pclass, len);
-  if (i & 0x80) {
-    OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_OBJECT_HEADER);
-    return 0;
-  }
-  if (exptag >= 0) {
-    if ((exptag != ptag) || (expclass != pclass)) {
-      // If type is OPTIONAL, not an error: indicate missing type.
-      if (opt) {
-        return -1;
-      }
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_WRONG_TAG);
       return 0;
-    }
-  }
-
-  if (cst) {
-    *cst = i & V_ASN1_CONSTRUCTED;
-  }
-
-  if (olen) {
-    *olen = plen;
-  }
-
-  if (oclass) {
-    *oclass = pclass;
   }
-
-  if (otag) {
-    *otag = ptag;
-  }
-
-  *in = p;
-  return 1;
 }