ASN.1 / DER Decoder

Decode any ASN.1 DER structure into a readable tree. Paste a PEM block, base64 or hex — an X.509 certificate, a CSR, a public or private key, a signature, anything DER-encoded — and see its nested tag / length / value structure laid out with indentation, with object identifiers resolved to human names (commonName, rsaEncryption, prime256v1 and many more), integers and strings decoded, and tagged elements labelled. It parses entirely in your browser, so even private keys stay on your machine.

How to use the ASN.1 / DER Decoder

Paste whatever you have. A PEM block (the -----BEGIN…----- wrapper around base64) is read directly; so is raw base64 or a hex string with or without spaces. The decoder figures out the encoding, walks the DER byte by byte, and renders the structure as an indented tree where each node shows its type, its length in bytes, and — for primitive values — the decoded content. Constructed types like SEQUENCE and SET contain their children indented beneath them, exactly mirroring the nesting in the data.

Object identifiers are resolved to readable names where known — so you'll see sha256WithRSAEncryption rather than a string of numbers, and the attribute names inside a certificate's subject and issuer. Integers are shown in decimal when small and hex when large, strings are decoded by their ASN.1 type, and [n] markers denote context-specific tagged elements, the optional or positional fields common in certificates. The decoder will also peek inside BIT STRING and OCTET STRING wrappers when their contents are themselves DER — which is how it shows you the key inside a SubjectPublicKeyInfo or the value inside a certificate extension. Everything is parsed locally; nothing you paste is uploaded, so it's safe for private keys and internal certificates.

ASN.1, DER and the structures they encode

ASN.1 — Abstract Syntax Notation One — is a language for describing data structures independently of how they're stored, and DER (Distinguished Encoding Rules) is the canonical binary encoding of those structures. Together they are the backbone of public-key cryptography's file formats: X.509 certificates, certificate signing requests, public and private keys, PKCS containers, OCSP responses and digital signatures are all ASN.1 structures serialised as DER, then usually base64-wrapped into the familiar PEM text. If you've ever looked at a .crt, .cer, .key or .csr file, you've looked at DER.

The encoding is built from one simple, recursive idea: tag, length, value (TLV). Every element starts with a tag byte saying what type it is — an integer, a string, an object identifier, a sequence — followed by a length, followed by that many bytes of value. Constructed types like SEQUENCE and SET have values that are themselves a series of TLV elements, which is how arbitrarily nested structures are built. A certificate, for example, is a SEQUENCE containing the to-be-signed certificate (itself a SEQUENCE of version, serial number, signature algorithm, issuer, validity, subject, public key and extensions), the signature algorithm, and the signature bits. Reading DER is just walking that tree. Among the types, the object identifier (OID) deserves special mention: it's a globally-registered dotted-number sequence like 1.2.840.113549.1.1.11 that names algorithms, attributes and extensions, and decoding those numbers into names is half the battle in making a structure legible.

Being able to decode DER by hand — or with a tool like this — is a practical skill whenever you work with TLS or PKI. It lets you confirm what algorithm a key uses, read the subject and SAN entries in a certificate, check the constraints in an extension, verify that a CSR contains what you expect before submitting it to a CA, or debug an interoperability problem where two systems disagree about a structure. The encoding is unforgiving and the error messages from libraries are often cryptic, so seeing the actual TLV tree — where a parse fails, which OID is unexpected, how a field is tagged — is frequently the fastest way to understand what's really in a cryptographic blob. Because the structure is self-describing, you don't need to know in advance what you're decoding; the tags tell you.

Common use cases

  • Inspecting certificates. Read the subject, issuer, validity, algorithms and extensions inside an X.509 cert.
  • Checking CSRs. Verify a certificate signing request contains the right subject and key before submitting it.
  • Key debugging. Confirm the algorithm and curve of a public or private key from its DER structure.
  • PKI troubleshooting. See exactly where a malformed DER blob fails to parse and which fields look wrong.

Frequently asked questions

What input formats does it accept?
PEM blocks (the -----BEGIN…----- wrapper), raw base64, and hex strings with or without whitespace. It detects which you pasted and decodes the underlying DER bytes. For PEM it reads the base64 between the header and footer lines.

What does the tag/length/value tree show?
Each node is one ASN.1 element: its type (SEQUENCE, INTEGER, OBJECT IDENTIFIER, a string type, etc.), its length in bytes, and its decoded value for primitives. Constructed types show their children indented beneath them, so the indentation mirrors the structure's nesting exactly.

Why are some elements labelled [0], [1] and so on?
Those are context-specific tagged elements — the optional or positional fields ASN.1 uses, very common in certificates (for example the version field and the extensions block). The number is the tag; the decoder shows it because the meaning depends on the surrounding structure rather than a universal type.

Can it decode encrypted or private keys?
It decodes the ASN.1 structure of whatever you paste, including unencrypted private keys, showing their fields. It does not decrypt encrypted key files (it shows their structure, not the protected contents). Everything is parsed in your browser, so it is safe to inspect private material locally.

Is my data sent anywhere?
No. The entire parse runs in your browser with no network calls, so certificates, keys and signatures you paste never leave your machine. That makes it safe for internal or private cryptographic data.