SSL/TLS Certificate Decoder
Decode PEM & X.509 certificates offline or inspect live SSL/TLS certificate chains with expiration countdowns and health checks.
Free SSL/TLS certificate decoder, X.509 parser, and live domain TLS health checker. Decode raw PEM, CRT, CER, and base64 DER certificates air-gapped directly in your browser with zero network transmission, or test any live HTTPS endpoint for TLS 1.3/1.2 cipher suites, full certificate chains (Leaf → Intermediate CA → Root CA), Subject Alternative Names (SANs), expiration timelines, and DNS CAA records (RFC 6844). Perform automated security health scoring (0–100) evaluating key strength (RSA 2048/4096-bit, ECDSA P-256/P-384, Ed25519), weak signature hashes (MD5, SHA-1), and RFC 6125 wildcard matching (*.domain.com). Export parsed metadata as structured JSON or audit reports.
Keywords: ssl certificate decoder, ssl checker online, x509 decoder, cert decoder, ssl decoder online, tls checker, view pem cert, check ssl expiration, ssl certificate chain viewer, subject alternative name checker, caa record check, ssl security health audit, x509 parser, pem crt viewer, decode crt file, tls 1.3 inspector, intermediate certificate check, wildcard cert validator, ocsp aia inspection
Tags: ssl, tls, certificate, x509, pem, https, security, crypto, san, caa
Popular Security & Crypto tools
- Password GeneratorGenerate secure passwords, passphrases, and PINs with real-time strength analysis.
SSL/TLS Certificate Decoder is also known as: X.509 Certificate Decoder, SSL Checker Online, TLS Certificate Inspector, PEM Certificate Viewer, SSL Expiration Checker, Certificate Chain Analyzer, X509 Parser Online, HTTPS Certificate Validator.
How to SSL/TLS Certificate Decoder Online
Select your operational mode: choose "Live Domain Check" to query an active HTTPS endpoint, or "Decode PEM" to parse raw certificate files offline.
For live domains, enter any fully qualified domain name (e.g., example.com, api.domain.org) and optional port (defaults to 443), then click "Check SSL Certificate".
For offline decoding, paste your PEM-formatted certificate block (beginning with -----BEGIN CERTIFICATE-----) or click "Upload .CRT / .PEM" to load a file directly from your machine.
Review the Expiration Status & Timeline bar to inspect the certificate start date, expiration date, total lifetime in days, and real-time days remaining.
Examine the Subject and Issuer cards to verify the Common Name (CN), Organization (O), Organizational Unit (OU), Country (C), State/Province (ST), Locality (L), and Serial Number.
Switch to the "Chain" tab to audit the full Certificate Chain of Trust (Leaf Server Certificate → Intermediate CA → Root CA) and verify cryptographic signature paths.
Check the "Health" tab for an automated security health rating (0–100 with A+ to F grades) evaluating key size, signature algorithm, expiration status, and DNS CAA records.
Use the interactive "Hostname Coverage Checker" to test whether specific subdomains, multi-level domains, or wildcards (*.example.com) are validly secured.
Click "Copy Report" or "Copy PEM / JSON" to export the structured audit results into tickets, configuration files, or compliance reports.
SSL/TLS Certificate Decoder Features
Dual-mode operation: 100% client-side air-gapped PEM decoder + high-performance server-side live domain TLS inspector.
Comprehensive ASN.1 DER parser: decodes standard X.509 v1, v2, and v3 certificates, multi-certificate bundles, and raw DER base64 streams.
Live expiration countdown & lifetime progress bar: visual timeline showing percentage elapsed, days remaining, start date, and expiry date.
Multi-algorithm cryptographic support: decodes RSA (1024, 2048, 3072, 4096-bit), Elliptic Curve (ECDSA P-256, P-384, P-521), Ed25519, and Ed448.
Subject Alternative Name (SAN) inspection: full extraction of DNS names, IPv4/IPv6 addresses, RFC822 email addresses, and URIs with search and one-click copy.
Visual certificate chain hierarchy: renders interactive Leaf (Server), Intermediate CA, and Root CA trees with trust authorization validation.
Automated security health score & grading: assigns 0–100 scores and A+ to F grades checking for weak hashes (MD5, SHA-1), undersized keys, and upcoming expiration.
RFC 6125 wildcard hostname matching: interactive tester verifies if subdomains and microservices match certificate SANs or wildcard patterns (*.domain.com).
DNS CAA record resolution: queries and analyzes Certification Authority Authorization records (RFC 6844) to verify permitted certificate issuers.
Multi-format cryptographic fingerprints: generates SHA-256, SHA-1, and MD5 fingerprints in both colon-separated hex and raw formats.
Full X.509 extension parsing: Basic Constraints (CA flag, Path Length), Key Usage flags, Extended Key Usage (Server Auth, Client Auth, Code Signing), SKI, and AKI.
Revocation & Authority endpoint discovery: extracts Authority Information Access (AIA) OCSP responder URLs, CA Issuers URLs, and CRL Distribution Points.
TLS protocol & cipher suite detection: identifies negotiated TLS version (TLS 1.2, TLS 1.3) and cipher suite parameters on live connections.
Recent check history: local storage history allows one-click re-runs of recent domain checks without transmitting search logs to external databases.
Zero-knowledge air-gapped privacy: pasted certificates and sensitive internal cryptographic blocks remain strictly on your local browser in PEM mode.
One-click multi-format export: export parsed certificate metadata as structured JSON, cleaned PEM, or formatted text audit reports.
Supported Formats & Dialects
The SSL/TLS Certificate Decoder supports 6 syntax formats and dialects for accurate parsing and processing.
- PEM (Privacy-Enhanced Mail) & Base64 DER Containers
- The primary text-based container format for certificates (.pem, .crt, .cer). Consists of base64-encoded ASN.1 DER binary data enclosed between "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----" ASCII armor boundaries. Universally used by Nginx, Apache, Node.js, and ACME clients like Certbot.
- Binary DER (Distinguished Encoding Rules) & ASN.1 Structures
- The raw binary ASN.1 encoding of an X.509 certificate (.der, .cer). Provides strict canonical tag-length-value representation used natively by Java keystores, Windows CryptoAPI certificate stores, hardware security modules (HSMs), and smart cards.
- PKCS#7 / P7B Certificate Bundles & Chains
- A cryptographic message syntax standard (.p7b, .p7c) designed to package entire certificate chains (Leaf + Intermediate CAs + Root) and Certificate Revocation Lists (CRLs) without containing private keys. Standard format for Microsoft IIS and Windows Server imports.
- PKCS#12 / PFX Encrypted Key & Certificate Archives
- An encrypted, password-protected binary archive format (.pfx, .p12) capable of bundling public certificates, complete intermediate trust chains, and private keys into a single portable container. Widely used for IIS, Tomcat, and enterprise code-signing certificates.
- PKCS#10 / CSR (Certificate Signing Requests)
- A standardized request block sent to a Certificate Authority containing the applicant public key, distinguished identity attributes (Common Name, Organization, Country), and requested SANs, signed by the private key to prove key ownership before certificate issuance.
- OCSP Stapling & CRL Distribution Profiles
- Revocation and trust verification mechanisms referenced in X.509 extensions. Authority Information Access (AIA) defines OCSP responder URIs for real-time certificate status checks, while CRL Distribution Points specify download endpoints for periodic revocation lists.
In-Depth Technical Guides
All GuidesCryptographic Hash Functions in Modern Web Architecture: SHA-2, SHA-3, BLAKE2 & HMAC Guide
Master cryptographic hashing: evaluate collision resistance, benchmark SHA-2 vs SHA-3 vs BLAKE2, prevent length extension attacks with HMAC, and safely verify file checksums.
SSL/TLS Certificate Decoding & Chain Validation: Complete Production Troubleshooting Guide
Master X.509 certificate decoding, debug missing intermediate CA chains, fix SSL_ERROR_UNTRUSTED_ISSUER, configure DNS CAA records, and verify TLS 1.3 setups.
Related Standards & RFC Specifications
All StandardsHSTS (RFC 6797) is a web security policy header that forces browsers to communicate with websites exclusively over secure HTTPS connections, preventing SSL stripping.
An SSL/TLS certificate is a digital document (X.509 standard) that cryptographically binds a public key to an identity to enable encrypted HTTPS sessions.
Transport Layer Security (TLS) is the standard cryptographic protocol that encrypts and authenticates internet communications across HTTPS, WebSockets, and APIs.
Pre-built Automation Pipelines
Chain SSL/TLS Certificate Decoder with other utilities in a multi-step visual workflow.
Base64 Decode → JSON Format
Decode a Base64 string and pretty-print the JSON inside it.
CSV → JSON → YAML
Convert CSV data to JSON, then to YAML format.
JSON Format → TypeScript Schema
Format JSON and generate TypeScript/Zod schema from it.
Example Input & Output
Sample ReferenceInteractive Example: SSL/TLS Certificate Decoder in ActionShow example
Sample Input (yaml)
-----BEGIN CERTIFICATE-----
MIIEczCCA1ugAwIBAgIRAJ3... (PEM Encoded Certificate)
-----END CERTIFICATE-----Sample Output
Subject: CN=wtool.dev
Issuer: C=US, O=Let's Encrypt, CN=R3
Valid From: 2026-08-01 00:00:00 UTC
Valid To: 2026-11-01 23:59:59 UTC (62 days remaining)
SANs: wtool.dev, *.wtool.dev
Algorithm: SHA256-RSA (2048 bit)What happened:
Parses ASN.1 DER structures, validates certificate chains, and checks expiration milestones offline.
Error Diagnostics & Triage Guides
All Debug GuidesJsonWebTokenError: invalid signature / algorithm mismatch
The cryptographic signature in the third segment of the JWT does not match the computed hash of the header and payload using the provided verification key. This commonly happens when symmetric HS256 secrets are mistakenly used against asymmetric RS256 public keys.
error:1e08010c:decoder routines::unsupported / bad decrypt
OpenSSL 3.0 deprecated legacy cryptographic algorithms like RC4, DES, and MD5-based key derivation by default. When an application attempts to parse a legacy encrypted key without modern AES-256-GCM encryption, it fails with bad decrypt.
Error: certificate has expired (CERT_HAS_EXPIRED)
The TLS certificate presented by the remote server has passed its `notAfter` validity expiration date. Modern HTTP clients and web browsers immediately terminate TLS handshakes to protect users from stale keys.
Frequently Asked Questions
- What is an X.509 SSL/TLS certificate and how does it establish PKI trust?
- An X.509 certificate is a digital standard (RFC 5280) that cryptographically binds a public key to an identity (such as a domain name, server, or organization). When a client establishes an HTTPS connection, the server presents its X.509 certificate. The client verifies the digital signature of the certificate against a trusted Certificate Authority (CA) root store to establish an encrypted, authenticated, and tamper-proof TLS session.
- What is the difference between offline PEM decoding and a live domain check?
- Offline PEM decoding parses raw base64-encoded ASN.1 DER data directly inside your browser sandbox using pure TypeScript and Web Crypto. It requires zero network requests and is completely air-gapped, making it ideal for auditing certificates before deployment. A live domain check connects over TCP port 443 to perform a TLS handshake with a live server, inspecting the served certificate chain, cipher suite, negotiated TLS protocol version, and DNS CAA records.
- Is it safe to paste certificates into this tool?
- Yes. In "Decode PEM" mode, all parsing and cryptographic hash calculations occur 100% locally in your browser sandbox without sending any data to our servers. Furthermore, public X.509 certificates contain only public keys and metadata, which are designed to be publicly accessible. You should never paste private keys (starting with -----BEGIN PRIVATE KEY-----), and this tool specifically processes only public certificate blocks.
- What are Subject Alternative Names (SANs) and why are they mandatory?
- Subject Alternative Names (SANs) are an X.509 extension (RFC 5280 / RFC 2818) that lists all domain names, subdomains, and IP addresses secured by a single certificate. Modern web browsers (including Google Chrome, Mozilla Firefox, Apple Safari, and Microsoft Edge) mandate the presence of SANs and completely ignore the legacy Common Name (CN) field during hostname verification.
- How do wildcard SSL certificates work (*.example.com) and what are their limitations?
- A wildcard certificate includes an asterisk in the leftmost label of a SAN (e.g., *.example.com). Under RFC 6125 standards, it secures all immediate single-level subdomains (such as api.example.com or blog.example.com). However, a wildcard does not secure the apex domain (example.com) unless explicitly listed as a separate SAN entry, nor does it secure multi-level subdomains like dev.api.example.com.
- What causes an "Incomplete Certificate Chain" or "Missing Intermediate CA" error?
- When a browser connects to an HTTPS server, it expects the server to send its leaf certificate along with any intermediate CA certificates required to build a path to a trusted Root CA. If a web server (like Nginx, Apache, or Caddy) is configured with only the leaf certificate instead of the full bundle (fullchain.pem), desktop browsers may attempt to fetch the intermediate via AIA chasing, but mobile browsers and API clients (cURL, Python, Node.js) will fail with SSL_ERROR_UNTRUSTED_ISSUER.
- What are DNS CAA records and why are they important for SSL health?
- Certification Authority Authorization (CAA) is a DNS resource record (RFC 6844) that allows domain owners to specify which Certificate Authorities (e.g., Let’s Encrypt, DigiCert, Sectigo) are permitted to issue certificates for their domain. Before issuing a certificate, all public CAs are required by the CA/Browser Forum to check CAA records, protecting your domain from unauthorized certificate issuance.
- What is the difference between RSA and ECDSA SSL certificates?
- RSA is the traditional asymmetric algorithm using prime factorization, typically requiring 2048-bit or 4096-bit keys. ECDSA (Elliptic Curve Digital Signature Algorithm) uses elliptic curves (like P-256 or P-384) to achieve equivalent or superior cryptographic security with much smaller key sizes (256-bit ECDSA equals roughly 3072-bit RSA). ECDSA certificates result in smaller TLS handshake sizes and faster cryptographic computations.
- How do certificate expiration countdowns and renewal thresholds work?
- Public SSL/TLS certificates have a maximum validity period of 398 days (approx. 13 months). Industry best practices recommend renewing certificates when 30 days remain (and treating ≤7 days as critical). Automated tools like Certbot or ACME clients typically renew certificates automatically when 30 days of validity remain to prevent unexpected outages.
- What is the difference between SHA-256, SHA-1, and MD5 fingerprints?
- A certificate fingerprint (or thumbprint) is a cryptographic hash computed over the entire raw DER-encoded certificate. It acts as a unique digital identifier. Modern systems rely exclusively on SHA-256 fingerprints for certificate pinning and identification. SHA-1 and MD5 fingerprints are provided for legacy diagnostic verification only, as their collision resistance is mathematically broken.
- What is Key Usage and Extended Key Usage (EKU)?
- Key Usage defines the core cryptographic operations permitted with the certificate’s public key (such as Digital Signature, Key Encipherment, or Certificate Signing). Extended Key Usage (EKU) specifies the higher-level application purposes for which the certificate may be used, such as Server Authentication (TLS Web Server), Client Authentication (mTLS), Code Signing, or Secure Email (S/MIME).
- How do OCSP and CRL endpoints handle certificate revocation?
- When a certificate is compromised or revoked before its expiration date, CAs publish revocation status via Certificate Revocation Lists (CRLs) or real-time Online Certificate Status Protocol (OCSP) responders. The Authority Information Access (AIA) and CRL Distribution Points extensions embedded in the certificate tell clients where to verify live revocation status.
- How is the 0–100 security health score calculated?
- The security health score evaluates four primary dimensions: (1) Expiration timeline — full score for active validity, deductions for expiration or near-expiry (<30d, <7d); (2) Signature algorithm strength — full score for SHA-256/SHA-384, severe deductions for MD5/SHA-1; (3) Key length & curve security — full score for RSA ≥ 2048-bit or ECC ≥ 256-bit; (4) Authority trust & DNS CAA setup — verified CA chains and configured CAA records.
Related Developer Tools
- DNS LookupLook up DNS records for any domain — A, AAAA, MX, TXT, NS, SOA, SRV, CAA, and more.
- DMARC, SPF & DKIM CheckerCheck DMARC, SPF & DKIM records for any domain, get an authentication score, and generate SPF/DMARC records.
- HTTP Headers AnalyzerAnalyze HTTP response headers for security, caching, and compliance issues.
- Domain WHOISLook up domain registration info — registrar, dates, name servers, and status.
- CSP Builder & ValidatorBuild and validate Content Security Policy headers with security scoring.
- Hash GeneratorGenerate and verify cryptographic hashes with multiple algorithms.
- API Request BuilderBuild and test HTTP API requests with headers, body, auth, and response visualization.
- WebSocket TesterConnect to WebSocket endpoints (ws:// or wss://) in real time to inspect frames, measure latency, test heartbeats, and debug payloads.
- JWT DecoderDecode, inspect, and validate JWT tokens with claim and signature analysis.
- IP LookupLook up geolocation, network, and security details for any IP address.