Skip to content
AdminKit

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:

PartyWhat it doesWhat it checks
Certificate authoritySubmits each certificate (or precertificate) to logs and collects SCTsNothing new; it still does its usual domain validation
LogAppends entries to a public Merkle tree and signs SCTsThat each submitted chain leads to a known CA root (RFC 6962 §1)
MonitorWatches logs for new entries and for log misbehaviourThat logs stay append-only and consistent
Browser / user agentRequires SCTs before trusting a certificateNumber and source of SCTs, per its own CT policy
Domain ownerReviews what was logged for their namesWhether 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 methodWhere the SCT travelsWho has to configure it
X.509v3 extensionEmbedded in the certificate itselfThe CA, at issuance; nothing for the site operator
TLS extensionSent by the server in the TLS handshakeThe server operator
OCSP staplingInside a stapled OCSP responseThe 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 logsUsual meaningWhat to do
Your CA, a name you operate, a recent dateNormal issuance or renewalNothing
Precertificate and certificate with the same names and datesOne certificate, logged twiceNothing
Your CA, a name you don’t recogniseA team or vendor requested it, or an account was misusedFind the requester; revoke if unauthorised
A CA you don’t useMis-issuance, or a service using its own CACheck your CAA record; contact the CA if unauthorised
Your apex name inside an unknown wildcardPossible domain-validation failureTreat 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.

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.

Want AdminKit to watch this for you?

Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.

Huy Nguyen (David), Founder and CEO of Netbase JSC

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.