Certificate Transparency logs: what they catch, and how to monitor your own domain
Certificate Transparency (CT), defined in RFC 6962, is a system of append-only, publicly auditable logs in which certificate authorities publish the TLS certificates they issue. Anyone can search them, so a domain owner can find every certificate issued for their domain, even one they never requested, and compare it with what AdminKit's SSL/TLS check shows a server presenting.
By AdminKit team, Netbase JSC · Updated
Key takeaways
- Certificate Transparency makes certificate issuance public. CAs submit certificates to append-only logs, and anyone can search those logs.
- CT detects mis-issuance but does not prevent it. A wrongly issued certificate is logged just like a correct one, and someone still has to look.
- Chrome and Apple platforms only trust a publicly trusted certificate if it carries enough Signed Certificate Timestamps (SCTs). Chrome requires 2 for certificates valid 180 days or less, and 3 for longer ones.
- You can monitor your own domain for free through a log search such as crt.sh, or by subscribing to a CT monitor.
- Every name on a publicly trusted certificate ends up in a public log, internal subdomain names included.
Why did certificates need a public paper trail?
Before Certificate Transparency, the trust placed in a TLS certificate — one link in the public key infrastructure browsers rely on — rested entirely on the issuing CA getting its validation right, with no independent way to check its work after the fact. If a CA issued a certificate for a domain it shouldn’t have — through a validation bug, a compromised account, or an insider mistake — the only way anyone found out was if the rogue certificate was actually observed in the wild, usually too late to matter. RFC 6962 states its aim plainly: to mitigate the problem of misissued certificates with publicly auditable, append-only logs of all issued certificates. It fixes the visibility gap rather than the issuance process itself. The logs “do not themselves prevent misissue”, in the RFC’s words, but they let the parties named in certificates detect it.
How does a CT log actually work?
A CT log is built as a Merkle tree, a cryptographic structure that lets anyone verify two things efficiently: that a given certificate really is included in the log, and that the log hasn’t silently rewritten its own history to remove or alter an earlier entry. When a CA submits a certificate, the log returns a Signed Certificate Timestamp (SCT) — a promise, cryptographically signed by the log operator, that the certificate will appear in the log within a defined window, called the Maximum Merge Delay. Browsers that enforce CT policy (see certificate.transparency.dev for the current list of participating logs and policy details) check for a valid SCT, embedded in the certificate itself or delivered alongside it, before trusting the connection without a warning.
Most CAs log a precertificate first. As certificate.transparency.dev explains, a precertificate contains all the information the final certificate will have, plus a “poison” extension so user agents won’t accept it. The CA submits the precertificate, collects SCTs and embeds them in the real certificate before it signs it. That is why a log search often shows two entries for one certificate.
Five parties take part, and each one checks a different thing:
| Party | What it does | What it checks |
|---|---|---|
| Certificate authority | Submits each certificate (or precertificate) to logs and collects SCTs | Nothing new; it still does its usual domain validation |
| Log | Appends entries to a public Merkle tree and signs SCTs | That each submitted chain leads to a known CA root (RFC 6962 §1) |
| Monitor | Watches logs for new entries and for log misbehaviour | That logs stay append-only and consistent |
| Browser / user agent | Requires SCTs before trusting a certificate | Number and source of SCTs, per its own CT policy |
| Domain owner | Reviews what was logged for their names | Whether each certificate was expected |
How does a certificate prove it was logged?
A certificate proves it was logged by carrying SCTs. RFC 6962 §3.3 allows three ways to deliver them, and a browser accepts any of them as long as its policy is met:
| Delivery method | Where the SCT travels | Who has to configure it |
|---|---|---|
| X.509v3 extension | Embedded in the certificate itself | The CA, at issuance; nothing for the site operator |
| TLS extension | Sent by the server in the TLS handshake | The server operator |
| OCSP stapling | Inside a stapled OCSP response | The CA and the server operator |
Embedding is the common case because it needs no server changes. If you want to see the embedded SCTs on a certificate you have saved as a file, OpenSSL prints them in its text dump. The output below is an illustrative, shortened example for example.com, not a real certificate:
$ openssl x509 -in example.com.pem -noout -text | grep -A 3 "CT Precertificate SCTs"
CT Precertificate SCTs:
Signed Certificate Timestamp:
Version : v1 (0x0)
Log ID : (32-byte log identifier)
How many SCTs are enough is set by each browser, not by the RFC. Chrome’s CT policy asks for at least two SCTs from distinct logs for a certificate valid 180 days or less, three for a longer one, and SCTs from at least two distinct log operators. A certificate that falls short “will simply fail to validate” in CT-enforcing versions of Chrome. Apple’s policy is similar: 2 SCTs for 180 days or less, 3 for 181–398 days, with at least one SCT from a log compliant with RFC 6962.
Which CT specification applies: RFC 6962 or RFC 9162?
Both exist, and the difference matters when you read documentation. RFC 6962 (2013) defines CT version 1.0. RFC 9162 (2021) defines version 2.0 and formally obsoletes RFC 6962. Both are Experimental RFCs, not Standards Track. Browser policy still refers to version 1 logs: Apple’s policy, for example, requires at least one SCT from a log compliant with RFC 6962. In practice, when a certificate tool shows “SCT version v1”, it is reporting RFC 6962 behaviour, and that is normal.
What CT logging does not do
It’s easy to overstate CT’s guarantees, so it’s worth being precise about the boundary:
- CT does: make every issued certificate publicly visible and auditable, give domain owners an early-warning signal, and let browsers require proof of logging before trusting a connection.
- CT does not: validate domain ownership, replace a CA’s own issuance checks, or block a mis-issued certificate from being logged in the first place — it only guarantees the mis-issuance becomes visible after the fact.
A certificate can be perfectly well-formed, correctly logged, and still have been issued to the wrong party if the underlying domain-validation step was tricked or compromised; CT turns that into a discoverable event instead of an invisible one, nothing more. It’s a detection and accountability layer, not a prevention mechanism.
CT also has a side effect worth planning for. Logs are public, and anyone can query them, so every hostname on a publicly trusted certificate becomes public too. A certificate for staging-db.internal.example.com reveals that name to anyone who searches. If a hostname should stay private, either keep it off publicly trusted certificates or cover it with a wildcard (see wildcard vs SAN certificates).
How do you monitor your own domain?
Because every publicly trusted certificate for your domain ends up logged, you can treat the logs as a free early-warning system. crt.sh offers a public search interface over the logs — querying your domain surfaces every certificate issued for it, including subdomains, the issuing CA, and the issuance date, with no account or tooling required. Run this check periodically, and treat an unexpected CA name or an unfamiliar subdomain certificate as the signal worth investigating; a certificate from your own CA for a subdomain you actually operate is normal and expected. Pairing this with a CAA record (see our guide on what CAA records do) narrows which CAs can legitimately issue for your domain in the first place, which makes an unexpected entry in the logs even easier to spot as out of policy.
If manual searches are not enough, certificate.transparency.dev describes the alternative: subscribe to a CT monitor for your domain, and you get updates when precertificates and certificates for those names are included in the logs that monitor watches.
Most entries you find will be routine. This table is a starting point for triage:
| What you see in the logs | Usual meaning | What to do |
|---|---|---|
| Your CA, a name you operate, a recent date | Normal issuance or renewal | Nothing |
| Precertificate and certificate with the same names and dates | One certificate, logged twice | Nothing |
| Your CA, a name you don’t recognise | A team or vendor requested it, or an account was misused | Find the requester; revoke if unauthorised |
| A CA you don’t use | Mis-issuance, or a service using its own CA | Check your CAA record; contact the CA if unauthorised |
| Your apex name inside an unknown wildcard | Possible domain-validation failure | Treat as an incident; ask the CA to revoke |
When an entry is unauthorised, RFC 6962 leaves the response to “existing business mechanisms”. In practice, that means contacting the issuing CA’s revocation or problem-reporting contact, which each CA publishes.
Related checks
CT logs tell you a certificate was issued; they don’t tell you whether the certificate currently in use is healthy. AdminKit’s SSL/TLS check is live and complements CT monitoring: it reads the certificate a server presents today, with its issuer, names, expiry date and negotiated protocol. You can then compare it with what the logs say was issued. See our guide on reading a TLS/SSL certificate check result for what that check covers, and HSTS and HSTS preload explained for the companion protection that stops a browser from ever accepting a plain HTTP connection to your domain in the first place. See the glossary entry for a Certificate Transparency log for a terse, one-paragraph definition of the term used throughout this guide. This guide also sits alongside AdminKit’s device- and protocol-exposure checks in the machine protocols cluster, since a mis-issued certificate and an exposed management port are both the kind of silent misconfiguration that monitoring is meant to catch before someone else finds it first.
This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.
Frequently asked questions
What is Certificate Transparency in plain terms?
It's a public record-keeping system for TLS certificates. RFC 6962 defines a log format where any publicly trusted certificate authority (CA) submits every certificate it issues to one or more independently operated CT logs before the certificate is considered valid by modern browsers. Each log is append-only and cryptographically verifiable — entries cannot be quietly removed or edited after the fact — so the existence of a certificate becomes a matter of public record rather than something only the CA and the certificate's holder know about.
What problem does CT actually solve?
It solves detection, not prevention: before CT, a CA could mis-issue a certificate for a domain it doesn't control — by mistake, through a compromised validation process, or under coercion — and the domain's real owner would have no way to find out unless they happened to encounter the rogue certificate directly. CT doesn't stop a CA from mis-issuing; it guarantees that if a publicly trusted CA does issue a certificate for your domain, a record of it becomes publicly visible in the logs, which is what makes monitoring possible in the first place.
Does a certificate appearing in CT logs mean it's safe or legitimate?
No. CT logging is neutral — it doesn't judge whether an issuance was authorized, it just makes the issuance visible and auditable. A correctly issued certificate for your own domain and a mis-issued certificate obtained by someone else both end up in the logs; the logs don't flag which is which. The security benefit only materializes when someone — you, a monitoring service, or a browser vendor's own detection tooling — actually reviews what's logged for a given domain.
How do I monitor CT logs for my own domain?
Search a public CT log aggregator such as crt.sh, which lets you query by domain name and see every logged certificate, including the issuing CA and issuance date, without needing to run your own log client. Review the list periodically for certificates you didn't request — an unfamiliar CA name or an unexpected subdomain is the signal worth investigating, not the mere presence of an entry.
Is CT logging mandatory for every certificate?
In practice, yes for any certificate that needs to be trusted by Chrome, Safari, or other major browsers that enforce a CT policy: certificates issued since the policies took effect must carry proof of logging (an embedded Signed Certificate Timestamp) or the browser will not treat the connection as valid. See Chrome's and the wider Certificate Transparency project's own policy documentation, linked below, for the current enforcement details, since specifics (log count requirements, grace periods) have evolved since RFC 6962 was first published.
Sources
- RFC 6962 — Certificate Transparency
- certificate.transparency.dev — how CT works and current log/policy documentation
- crt.sh — public Certificate Transparency log search
- RFC 9162 — Certificate Transparency Version 2.0 (Experimental)
- certificate.transparency.dev — How CT works (logs, monitors, precertificates, SCTs)
- Chrome Certificate Transparency policy
- Apple — Certificate Transparency policy
Want AdminKit to watch this for you?
Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.
Talk to an expert
Huy Nguyen (David), Founder & CEO, Netbase JSC
Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.