Certificate Decoder
Decode and inspect X.509 SSL/TLS Certificates (PEM format). Verify expiry dates, Subject Alternative Names (SANs), and issuer details 100% locally in your browser.
Waiting for Certificate input...
Subject
Issuer
Validity
Details
How ZeroData protects your privacy
- ✓ No Uploads: Tool input is processed in your browser and is not sent to ZeroData servers.
- ✓ No Storage: Tool input is not saved by this website.
- ✓ No Input Tracking: Analytics never receive the text, files, keys, or credentials you process.
- ✓ Verifiable: Disconnect from the network after the page loads; local tool processing continues without uploading your input.
Why Parse Certificates Locally?
SSL/TLS certificates often contain sensitive organizational information, internal domain names in their SANs, and are frequently handled alongside their highly sensitive private keys. Uploading your certificates to a random third-party website for decoding is an unnecessary security risk.
Our Certificate Decoder runs entirely within your browser. It uses WebAssembly and JavaScript to parse the ASN.1 structure of the PEM file locally. If you need to generate a new key pair, use our SSH Key Generator. To check your signing requests, use the CSR Decoder. For Kubernetes, try the Kubernetes Secret Generator. This guarantees that your certificate's metadata and organizational structure are never transmitted over the internet or logged by a remote server.
Master HTTPS & SSL/TLS
Read our Complete Guide to X.509 Certificates to understand the TLS handshake, Certificate Authorities, and the difference between PEM, DER, and CSR formats.
Quick Solution
To decode an X.509 certificate on the command line without an online tool, you can use OpenSSL. Run openssl x509 -in cert.pem -text -noout to view the full details, including the issuer, validity dates, and Subject Alternative Names (SANs). If your certificate is in DER format (binary), add -inform der to the command.
Deep Dive: Certificate Chains, Intermediates, and Trust Stores
A massive percentage of TLS misconfigurations in production stem from a misunderstanding of the Certificate Chain of Trust. When you decode a certificate using this tool, you are typically looking at the Leaf Certificate (the one issued specifically to your domain). But trust is hierarchical.
Your browser (or operating system) maintains a Trust Store—a list of heavily audited Root Certificate Authorities (like DigiCert, Let's Encrypt ISRG Root X1, or GlobalSign). However, these Root CAs do not sign your Leaf Certificate directly. They sign an Intermediate CA, which in turn signs your Leaf Certificate.
When a client connects to your server, your server must provide the Leaf Certificate AND the Intermediate Certificates so the browser can mathematically trace the signature all the way back to the Root CA in its local Trust Store. If you configure Nginx with only the Leaf Certificate (ignoring the fullchain.pem), browsers on mobile devices or strict API clients (like curl) will throw an ERR_CERT_AUTHORITY_INVALID or unable to get local issuer certificate error, because they cannot bridge the gap to the Root.
Understanding Certificate Fields
When you decode a certificate, you'll see several important fields:
- Subject: The entity (domain, person, or organization) that the certificate represents. The Common Name (CN) is typically the primary domain.
- Issuer: The Certificate Authority (CA) that verified the subject and signed the certificate.
- Validity: The precise dates during which the certificate is considered legally and technically valid.
- SANs (Subject Alternative Names): A list of all hostnames secured by this certificate. Modern browsers enforce SANs over the legacy Common Name field.
Common SSL/TLS Errors & Certificate Troubleshooting
SSL/TLS misconfigurations are responsible for frequent website outages and browser security warnings. Below is a comprehensive troubleshooting guide for diagnosing X.509 certificate errors in production environments:
| Browser / Server Error | Root Cause & Production Impact | How to Diagnose & Fix |
|---|---|---|
| ERR_CERT_COMMON_NAME_INVALID | The hostname in the browser URL does not match any domain listed in the Subject Alternative Names (SANs) extension. | Decode the PEM file here and inspect the SANs list. Ensure exact subdomains or wildcard (*.example.com) patterns are present. |
| ERR_CERT_AUTHORITY_INVALID | The server is sending only the leaf certificate without the required intermediate Certificate Authority (CA) bundle. | Concatenate your leaf certificate and intermediate CA certificate into a single full-chain PEM file before configuring Nginx or Apache. |
| ERR_CERT_DATE_INVALID | The certificate has passed its "Valid To" expiration date or automated renewal scripts (like Certbot / Let's Encrypt) failed silently. | Check the validity dates in our decoder. Set up automated monitoring and cron jobs to renew certificates 30 days prior to expiry. |
| Private Key Mismatch | The deployed certificate was signed for a different Certificate Signing Request (CSR) and does not match the server's private key. | Verify that the RSA modulus MD5 hash of the certificate exactly matches the modulus hash of the private key using OpenSSL. |
| PEM Format Parsing Error | Missing -----BEGIN CERTIFICATE----- headers, trailing whitespace, or attempting to paste a binary DER / PKCS#12 `.pfx` file. | Ensure your input is valid Base64-encoded PEM text. If you have a `.der` or `.pfx` file, convert it to PEM format first. |
Actionable OpenSSL CLI Commands for Terminal Debugging
When inspecting certificates on remote Linux servers or debugging TLS handshakes from your command line, use these standard OpenSSL commands:
- Decode and print all certificate fields (subject, issuer, dates, SANs) in text format:
openssl x509 -in cert.pem -text -noout
- Check only the start and expiration dates of a PEM certificate:
openssl x509 -in cert.pem -noout -dates
OutputsnotBeforeandnotAftertimestamps for quick expiration checks in automation scripts. - Verify that a PEM certificate and private key form a matching pair:
openssl x509 -in cert.pem -noout -modulus | md5 openssl rsa -in key.pem -noout -modulus | md5
If the resulting MD5 hashes are identical, the certificate and private key match. - Fetch and inspect the live SSL/TLS certificate chain from a remote server:
openssl s_client -connect example.com:443 -showcerts
Displays the entire certificate chain presented during the TLS handshake, helping diagnose missing intermediate CAs.
When Should I Use This? vs When Should I NOT Use This?
✅ When You SHOULD Use This Tool
- Auditing certificate expiration dates and SANs before deploying to Nginx, Apache, or Kubernetes.
- Verifying the issuer and organizational subject fields of self-signed internal certificates.
- Inspecting certificate metadata on machines where OpenSSL command-line tools are unavailable.
- Checking public key bit lengths (e.g., RSA 2048-bit vs 4096-bit) for compliance audits.
❌ When You Should NOT Use This Tool
- Decoding binary PKCS#12 (`.pfx` / `.p12`) archives or encrypted keystores (convert to PEM first).
- Testing live server cipher suite vulnerabilities or TLS protocol deprecation (use SSL Labs or
testssl.sh). - Generating new private keys or Certificate Signing Requests (use our SSH Key or CSR tools instead).
Browser Compatibility & Zero-Upload Privacy Notice
Our Certificate Decoder executes entirely inside your web browser using client-side JavaScript and ASN.1 WebAssembly parsing libraries. No certificate strings, domain lists, organizational metadata, or internal hostnames are ever transmitted over network requests or stored on remote servers.
This zero-upload security model is critical for DevOps teams: even if an engineer accidentally pastes a bundled PEM file containing an unencrypted private key alongside the certificate, zero bytes leave the local device memory. The tool operates completely offline and is supported across all modern browsers (Chrome, Firefox, Safari, Edge).
How to Use the Certificate Decoder
- Paste your PEM-formatted X.509 certificate into the input area.
- The tool automatically parses the ASN.1 structure locally in your browser.
- Review the Subject, Issuer, and Validity dates extracted from the certificate.
- Check the Subject Alternative Names (SANs) to see all covered domains.
- Inspect the public key details, including algorithm and bit size.
Common Use Cases
- Verifying the expiry date of an SSL/TLS certificate before deploying it.
- Checking which domains and subdomains are covered by a certificate's SANs.
- Debugging SSL connection errors to see if the certificate matches the private key.
- Inspecting the issuer and subject details of a self-signed certificate.
- Extracting the public key size and algorithm (e.g., RSA 2048-bit) from a PEM file.
Frequently Asked Questions
What is an X.509 Certificate?
An X.509 certificate is a digital certificate that uses the X.509 public key infrastructure (PKI) standard to verify that a public key belongs to the user, computer, or service identity contained within the certificate.
Is my certificate data uploaded to a server?
No. This tool parses the PEM-formatted certificate locally in your browser using the node-forge library. Your certificate details never leave your computer.
What is the difference between a CSR and a Certificate?
A Certificate Signing Request (CSR) is a message sent to a Certificate Authority to apply for a digital identity certificate. The Certificate is the final, signed document issued by the Authority that verifies the identity and binds it to the public key.
Why does my certificate say 'Expired'?
Every certificate has a 'Valid From' and 'Valid To' date. If the current date is past the 'Valid To' date, the certificate is considered expired and browsers will show a security warning if it is used for HTTPS.
What are Subject Alternative Names (SANs)?
SANs allow a single SSL certificate to secure multiple hostnames (domains or IP addresses). Modern browsers require the domain you are visiting to be listed in the SANs extension rather than just the Common Name.
How do I check if a certificate is self-signed?
In a self-signed certificate, the Subject string and the Issuer string are identical because the creator signed their own public key rather than getting it validated by an external Certificate Authority (CA).
Can I decode binary DER or PKCS#12 (.pfx/.p12) certificate files with this tool?
This tool expects standard ASCII Base64 PEM format (starting with -----BEGIN CERTIFICATE-----). If you have a binary .der or .pfx/.p12 file, convert it to PEM using OpenSSL first: openssl x509 -inform der -in cert.der -out cert.pem.
What is the difference between a Root CA and an Intermediate CA?
A Root CA is the ultimate cryptographic anchor of trust, pre-installed in your browser or operating system. Because they are so valuable, Root CAs are kept offline. They sign Intermediate CAs, which remain online to sign and issue the actual 'leaf' certificates to end users. This separation minimizes the blast radius if an issuing server is compromised.
How do browsers know if a certificate has been revoked?
Certificates often contain URIs for CRL (Certificate Revocation Lists) or OCSP (Online Certificate Status Protocol) responders. Browsers query these endpoints during the TLS handshake to verify the CA hasn't revoked the certificate before its natural expiration date due to a private key compromise.
What is the difference between a Wildcard Certificate and a Multi-Domain (SAN) Certificate?
A Wildcard Certificate secures a single domain and its first-level subdomains (e.g., *.example.com secures api.example.com, but NOT v1.api.example.com). A Multi-Domain certificate uses the SAN (Subject Alternative Name) extension to explicitly list disparate domains, like example.com, example.net, and completely-different-site.org, on a single certificate.
Why does my PEM file contain multiple 'BEGIN CERTIFICATE' blocks?
This is known as a Certificate Bundle or a Full Chain. It typically contains your domain's 'leaf' certificate first, followed by one or more intermediate certificates. Web servers like Nginx and Apache require this full chain so they can present the complete path of trust to the client's browser during the handshake.
Related Tools
JWT Debugger
Inspect JWT headers and payloads locally without leaking tokens to third-party tools.
Nginx Config Generator
Generate Nginx server block configurations visually. Reverse proxy, SSL, gzip, and security headers — 100% browser-based.
JWK to PEM Converter
Convert JSON Web Keys (JWK) to PEM format and back. Supports RSA and EC keys using Web Crypto API — 100% browser-based, zero uploads.
CSR Decoder
Decode Certificate Signing Requests (CSR) locally. Inspect Common Name, SANs, and Organization details using Web Crypto APIs with zero uploads.