oktools

SSL Certificate & CSR Decoder

Decode X.509 SSL/TLS certificates and PKCS#10 certificate signing requests: subject, issuer, validity dates, Subject Alternative Names, key usage, extensions and fingerprints. Paste a PEM block or a whole chain, or drop a .crt, .cer, .pem, .der or .csr file. Everything is parsed in your browser — nothing you paste is uploaded.

Paste a PEM certificate, a certificate chain or a certificate signing request, or drop a certificate file onto this box.

1 certificate decoded

demo.oktools.dev

CertificateEnd-entity
The validity period is 7300 days. Publicly trusted TLS certificates issued from 15 March 2026 are capped at 200 days, so this one was issued privately or by an internal CA.
This certificate is self-signed, so no certificate authority vouches for it. Clients will reject it unless it has been trusted explicitly.
20.0 years total
Not before2026-09-18 20:22:06 UTC
Not after2046-09-13 20:22:06 UTC

Subject

Common Name (CN)demo.oktools.dev
Organization (O)OkTools
Organizational Unit (OU)Engineering
Locality (L)Stockholm
State or Province (ST)Stockholm
Country (C)SE

Issuer

Common Name (CN) demo.oktools.dev
Organization (O) OkTools
Organizational Unit (OU) Engineering
Locality (L) Stockholm
State or Province (ST) Stockholm
Country (C) SE

Subject Alternative Names

7
DNSdemo.oktools.devDNS*.demo.oktools.devDNSoktools.devIP192.0.2.10IP2001:db8::10Emailhostmaster@oktools.devURIhttps://oktools.dev/

What this key may be used for

Digital SignatureKey EnciphermentTLS Server AuthenticationTLS Client Authentication

Details

Serial numberE5:69:88:27:0D:29:0A:FA (16530893608546011898)
VersionX.509 v3
Signature algorithmSHA-256 with RSA
Public keyRSA 2048-bit, exponent 65537
Subject key identifier67:53:59:03:25:24:A2:F2:D0:D1:89:9C:1A:D8:05:04:D8:1F:76:0B
Certificate policiesDomain Validated (DV)
OCSP responderhttp://ocsp.oktools.dev
CRL distributionhttp://crl.oktools.dev/demo.crl

Fingerprints

Fingerprints are digests, which need Web Crypto — available once this page is running in a browser over HTTPS.

All 8 extensions
Basic ConstraintsCritical2.5.29.19
  • Certificate Authority: No
Key UsageCritical2.5.29.15
  • Digital Signature
  • Key Encipherment
Extended Key Usage2.5.29.37
  • TLS Server Authentication
  • TLS Client Authentication
Subject Key Identifier2.5.29.14
  • 67:53:59:03:25:24:A2:F2:D0:D1:89:9C:1A:D8:05:04:D8:1F:76:0B
Subject Alternative Name2.5.29.17
  • DNS: demo.oktools.dev
  • DNS: *.demo.oktools.dev
  • DNS: oktools.dev
  • IP: 192.0.2.10
  • IP: 2001:db8::10
  • Email: hostmaster@oktools.dev
  • URI: https://oktools.dev/
CRL Distribution Points2.5.29.31
  • http://crl.oktools.dev/demo.crl
Authority Information Access1.3.6.1.5.5.7.1.1
  • OCSP: http://ocsp.oktools.dev
  • CA Issuers: http://crt.oktools.dev/demo.crt
Certificate Policies2.5.29.32
  • Domain Validated (DV) (2.23.140.1.2.1)

How it works

The box accepts a certificate in whatever wrapping it arrived in. Line endings are normalised, a value lifted out of JSON or an environment variable has its quotes and escaped \n sequences undone, and base64 that unwraps to a PEM file, as a Kubernetes secret or a cloud API returns it, is decoded once. Every -----BEGIN block is then decoded in order, the prose openssl x509 -text prints above a block is ignored, and input with no header lines is tried as bare base64 DER. A dropped or uploaded file is read as bytes: a leading 0x30 means DER, anything else is treated as text.

Parsing is done by a DER reader written for this page. It walks the ASN.1 tags and lengths, refuses the indefinite lengths that mark BER, and names a truncated or missing field instead of failing silently. The structure, not the PEM label, decides whether a block is a certificate or a PKCS#10 request, so a CSR saved as .crt still decodes as a request. Algorithms, curves, extensions, key usages and policies are looked up in OID tables and given the names openssl uses — SHA-256 with RSA, P-256 (prime256v1), Domain Validated (DV) — and anything unknown appears as its dotted OID with raw bytes.

Notes are derived from those fields: validity is checked against the clock with a 30-day amber window; the signature algorithm is checked for SHA-1, MD5 or MD2; an RSA key below 2048 bits or an EC key below 256 bits is flagged; and for an end-entity certificate the Common Name is matched against the SAN list’s DNS entries, a wildcard covering one label. Self-signing is detected by comparing the encoded issuer and subject bytes, and that plus Basic Constraints gives the role badge: End-entity, Intermediate CA or Root CA. The chain summary compares each issuer with the next subject, a name check rather than signature verification.

Examples

Read a server certificate

Press Example certificate and this decode appears; the text below is what its Copy all details button puts on the clipboard. On the page the same values sit in panels, with the SANs as chips, a VALID badge and the lifetime as 20.0 years.

Copied details
Subject: CN=demo.oktools.dev, O=OkTools, OU=Engineering, L=Stockholm, ST=Stockholm, C=SE
Issuer: CN=demo.oktools.dev, O=OkTools, OU=Engineering, L=Stockholm, ST=Stockholm, C=SE
Not before: 2026-09-18 20:22:06 UTC
Not after: 2046-09-13 20:22:06 UTC
Serial number: E5:69:88:27:0D:29:0A:FA (16530893608546011898)
Version: X.509 v3
Signature algorithm: SHA-256 with RSA
Public key: RSA 2048-bit, exponent 65537
Subject key identifier: 67:53:59:03:25:24:A2:F2:D0:D1:89:9C:1A:D8:05:04:D8:1F:76:0B
Certificate policies: Domain Validated (DV)
OCSP responder: http://ocsp.oktools.dev
CRL distribution: http://crl.oktools.dev/demo.crl
Subject alternative names: DNS: demo.oktools.dev
DNS: *.demo.oktools.dev
DNS: oktools.dev
IP: 192.0.2.10
IP: 2001:db8::10
Email: hostmaster@oktools.dev
URI: https://oktools.dev/

Check what a CSR asks for

Press Example CSR. A request has no issuer and no dates, so those lines are absent; the three names, the key size and, on the page, the TLS Server Authentication usage all come from the extensionRequest attribute, which is where a CA reads them too.

Copied details
Subject: CN=api.example.com, O=Example Inc, C=US, emailAddress=admin@example.com
Version: PKCS#10 v1
Signature algorithm: SHA-256 with RSA
Public key: RSA 2048-bit, exponent 65537
Subject alternative names: DNS: api.example.com
DNS: www.example.com
IP: 198.51.100.7

Spot a certificate browsers will reject

Three problems in one short certificate — a SHA-1 signature, a 1024-bit key and a Common Name the SAN list does not cover — each stated with why it fails. Two further notes say its 400-day validity could not have come from a public CA and that it is self-signed.

Pasted certificate
-----BEGIN CERTIFICATE-----
MIIB8jCCAVugAwIBAgIJAKc2Cp1vc5VZMA0GCSqGSIb3DQEBBQUAMBsxGTAXBgNV
BAMMEHNob3AuZXhhbXBsZS5jb20wHhcNMjYwOTE4MjAzMDAwWhcNMjcxMDIzMjAz
MDAwWjAbMRkwFwYDVQQDDBBzaG9wLmV4YW1wbGUuY29tMIGfMA0GCSqGSIb3DQEB
AQUAA4GNADCBiQKBgQDc4JpfzalDOIGAlj4V7RBmjZnIAh+vZFvXHo8Zzj+p8/Zg
HhQSPJYBr6bcd0IYypjzbw2WLtcSrKQ3laevqMcLcKJkN8OGbmkzmH7Z1ShFbn+H
z5psgZeUflsRHPRUa8V5et+jcdPuM5V7Fhodgl2yPgQT5LPUOUQIbYZoeuxDvwID
AQABoz4wPDAaBgNVHREEEzARgg93d3cuZXhhbXBsZS5jb20wEwYDVR0lBAwwCgYI
KwYBBQUHAwEwCQYDVR0TBAIwADANBgkqhkiG9w0BAQUFAAOBgQCsKCgXJ9yjywrU
fDEmmdwQ6MMBhWg9U6ag/Pb3RVbOypfcmv/xNnY72F63F/p6mMOsmGIhNp1HF3dF
mMSCLep4wVEJpfsuCO6RD+XIk3f3PPBXxx/iK8VhvH6jlHg2Hf+MVD+uHGNuyJKM
4pUjDBxmh/+pSAVGC6v8uNDYYxWIaQ==
-----END CERTIFICATE-----
Warnings
Signed with SHA-1 with RSA. That hash is broken for signatures, and browsers reject certificates that use it.
The RSA key is only 1024 bits. Anything below 2048 is rejected by browsers and by every public CA.
The Common Name "shop.example.com" is not covered by any DNS entry in the Subject Alternative Name list, and only that list is checked.

Find the break in a chain

The example certificate pasted above a root that did not issue it. Each link compares a certificate’s issuer with the subject of the block that follows, so the leaf is called out as not joining, while the root, self-signed and last, needs no link. A bundle in the wrong order is reported the same way.

Chain summary
Chain of 2 certificates
1. End-entity — demo.oktools.dev
   Issued by "CN=demo.oktools.dev, O=OkTools, OU=Engineering, L=Stockholm, ST=Stockholm, C=SE", which is not the next certificate in this bundle.
2. Root CA — Example Root CA

Supported formats

  • PEM certificates and requestsBlocks labelled CERTIFICATE, CERTIFICATE REQUEST or NEW CERTIFICATE REQUEST, one or many, with CRLF or LF endings, a mismatched END label and any text around them. The PEM tab shows each block re-wrapped at 64 columns, which is what Copy PEM copies.
  • Wrapped and bare encodingsA quoted JSON or YAML string with \n escapes, a PEM that has been base64-encoded a second time by kubectl get secret or a secrets manager, and a bare base64 DER string of 32 characters or more with no header lines at all.
  • Binary files.crt, .cer, .der, .csr, .req, .pem and .txt by upload or drag and drop, one file at a time. DER is recognised by its leading SEQUENCE tag and written back into the box as PEM, so a drop doubles as a DER-to-PEM conversion.
  • Keys and signature algorithmsRSA with modulus size and exponent, RSASSA-PSS with its hash, EC keys on P-256, P-384, P-521, secp256k1 and the brainpool curves, Ed25519, Ed448, X25519, X448 and DSA; signatures with SHA-1 to SHA-512 over RSA, ECDSA or DSA, plus GOST R 34.10-2012.
  • ExtensionsSubject Alternative Name with DNS, IP, email and URI entries, Key Usage, Extended Key Usage, Basic Constraints with path length, Subject and Authority Key Identifier, Certificate Policies with the DV, OV, IV and EV OIDs named, Authority Information Access, CRL Distribution Points, Name Constraints, OCSP Must-Staple and embedded SCTs, plus a CSR’s extensionRequest and challengePassword attributes. Anything else is listed by OID with its raw value and critical flag.

Use cases

  • Work out why a browser reports a name mismatchPaste the certificate the server presented and read the SAN chips: the hostname has to appear there, exactly or under a one-label wildcard. The Common Name is not consulted, and the decoder says so when it is the only place the name appears.
  • Inspect what a server actually sendsRun openssl s_client -connect host:443 -showcerts, paste the whole output, prose and all, and every certificate in the handshake is decoded in order with a chain summary. A missing intermediate shows up as a link that does not join.
  • Review a CSR before the CA sees itConfirm the SAN list, organisation and key size the request asks for, so a certificate is not issued with a typo in the O field or without the www name. For an ACME client’s request with an empty subject, the SAN list is the whole story.
  • Convert DER to PEM without opensslDrop a .cer or .der file exported from Windows or a Java keystore onto the box: the PEM equivalent appears in it, ready for Copy PEM, and the decode confirms it is the certificate you expected.

Limitations

  • No signature or trust-path verificationThe chain check compares names, not signatures: it shows whether the blocks line up, not whether each was really signed by the next or whether the root is in any trust store. For that, openssl verify -CAfile chain.pem cert.pem.
  • No revocation or network checksThe OCSP and CRL URLs are shown but never fetched. The page makes no requests, so it cannot say whether a certificate has been revoked, whether a host is serving it, or whether its SCTs are in any log.
  • Keys and containers are refused or unsupportedA private key is refused with a warning to rotate it. A bare public key, a PKCS#7 or CMS bundle, a CRL or a parameters block is explained but not decoded, and a PKCS#12 .pfx or .p12 fails as malformed; extract its certificates first with openssl pkcs12 -nokeys.
  • DER onlyIndefinite-length BER encoding is rejected with a message that says so, as is a length field no real certificate would carry. Re-encode with openssl x509 -outform DER before pasting.
  • Fingerprints need Web CryptoSHA-1, SHA-256 and the pin are computed with crypto.subtle, which browsers expose only on HTTPS and localhost. On a plain http:// copy of the page the fingerprint panel explains itself instead, and the rest of the decode is unaffected.

Frequently asked questions

How do I decode an SSL certificate without openssl?

Paste the PEM block — everything from -----BEGIN CERTIFICATE----- to -----END CERTIFICATE----- — into the box, or drop the .crt, .cer, .pem or .der file onto it. The subject, issuer, validity dates, Subject Alternative Names, key usage, extensions and fingerprints are read out immediately. It is the same information openssl x509 -text prints, without installing anything, and the certificate is parsed in your browser rather than uploaded.

How do I check when a certificate expires?

The validity panel shows Not Before and Not After as full UTC timestamps along with how long is left in plain language, and the badge turns amber under 30 days and red once the certificate has expired. Remember that both ends matter: a certificate that is not valid yet produces exactly the same browser error as an expired one, and the usual cause is a clock that is wrong on the server or the client.

What is a Subject Alternative Name, and why does my certificate not match my domain?

The Subject Alternative Name extension lists every hostname, IP address and email address a certificate is valid for, and it is the only thing browsers check. The Common Name in the subject has been ignored by Chrome, Firefox and Safari since 2017, so a certificate whose CN is your domain but whose SAN list does not include it will fail with a name mismatch. This tool flags that case specifically, and a wildcard entry such as *.example.com covers one label only, so it matches www.example.com but not a.b.example.com.

How do I check what is inside a CSR before sending it to a CA?

Paste the certificate request and it is decoded the same way, showing the subject, the public key and — crucially — the extensions the request is asking for, which live inside the PKCS#9 extensionRequest attribute rather than at the top level. This is how you catch a missing SAN list or a typo in the organisation name before the CA issues a certificate you have to reissue. The request is only a proposal: the CA sets the final dates and may drop or rewrite anything in it.

What is the difference between PEM and DER?

They are two encodings of the same bytes. DER is the raw binary ASN.1 structure, typically in a .der or .cer file. PEM is that binary base64-encoded and wrapped in BEGIN and END lines, which is what fits into config files and terminals, typically in a .pem or .crt file. This tool accepts either, along with base64 with the header lines stripped, and shows you the PEM form of whatever you give it.

Is it safe to paste a certificate here?

Yes. The decoding happens entirely in your browser — the page makes no network request with your input, and nothing is stored or logged. It is also worth knowing that a certificate is public by design: it is sent in the clear to every client that connects to your server. The private key is the secret half, and this tool deliberately refuses to decode one and tells you to rotate it if you have pasted it somewhere.

How do I get the SHA-256 fingerprint or the public key pin of a certificate?

Both are shown under Fingerprints. The SHA-256 and SHA-1 fingerprints are digests of the whole certificate, which is what a browser shows in its certificate viewer and what you compare against when verifying a self-signed certificate by hand. The public key pin is base64(SHA-256(SubjectPublicKeyInfo)), the value used for certificate pinning and for HTTP Public Key Pinning headers, and it survives reissuance as long as the same key is reused.

Can I paste a whole certificate chain at once?

Yes. Paste the full bundle and every certificate in it is decoded in order, with a chain summary showing which is the leaf, which are intermediates and which is the root. Each link is checked by comparing one certificate’s issuer to the next certificate’s subject, so a bundle assembled in the wrong order or missing an intermediate is called out — that is the single most common cause of a certificate that works in a browser but fails in curl, Java or a mobile app.

How long can a publicly trusted SSL certificate be valid for?

It depends on when it was issued. Publicly trusted TLS certificates were capped at 398 days from September 2020, and CA/Browser Forum ballot SC-081 steps that down: 200 days for certificates issued on or after 15 March 2026, 100 days from 15 March 2027 and 47 days from 15 March 2029. Browsers reject anything longer. This tool picks the cap from the Not Before date and, when a server certificate exceeds it, says so as a note rather than an error: a multi-year certificate from a private or internal CA, or a root or intermediate, is perfectly legitimate.