n.Newfeed

Technology · 6 min read

How Certificate Transparency Makes TLS Certificates Auditable

A step-by-step account of precertificates, signed timestamps, Merkle proofs, monitors, browser enforcement, and the limits of public logging.

How Certificate Transparency Makes TLS Certificates Auditable

When a browser opens an HTTPS site, it checks a certificate that binds the site’s name to a public key. That certificate normally chains back to a certification authority, or CA, trusted by the browser. This arrangement can encrypt a connection and authenticate the server, but it creates a governance problem: a trusted CA may issue a certificate to the wrong party, whether through error, compromised systems, or deception. A browser presented with a technically valid certificate once had little independent evidence that the domain owner knew it existed.

Certificate Transparency, or CT, changes that information problem. It creates public, append-only logs of issued or proposed TLS certificates. Browsers can require evidence that a certificate was submitted to recognized logs, while domain owners and monitors can search those logs for unexpected names. Cryptographic proofs make omission and rewriting detectable under specified assumptions.

CT does not decide who owns a domain, revoke a bad certificate, or stop a CA from making a mistake. It makes certificate issuance observable and gives other actors evidence with which to respond. The distinction between visibility and prevention is the key to understanding both the mechanism and its limits.

The problem transparency was built to address

Publicly trusted TLS depends on many organizations. Root certificates distributed in browsers anchor chains that may include subordinate CAs. The CA/Browser Forum’s Baseline Requirements specify identity checks, certificate profiles, audits, and operating rules for public TLS certificates, but compliance cannot remove every possibility of mis-issuance.

Without a public record, a domain owner might learn about an unauthorized certificate only after it was used or disclosed. Traditional CA audits inspect processes over intervals; they do not give each domain a continuously searchable view of certificates issued for its names. CT adds a separate accountability layer. RFC 9162, the current protocol specification, describes its purpose as logging TLS server certificates so anyone can examine CA activity, identify suspect issuance, and audit the logs themselves.

The system distributes trust rather than eliminating it. A CT log is still an operated network service. Browsers choose which logs they recognize and set policies for acceptable evidence. Monitors decide what to watch. The protocol’s contribution is that these parties can compare cryptographically checkable commitments instead of accepting an operator’s database on assertion alone.

From a precertificate to a signed promise

Most submissions begin before the final certificate is issued. A CA creates a precertificate containing the intended certificate information plus a special extension that prevents normal TLS use. This solves a sequencing problem: the final certificate needs evidence from a log, but the log needs certificate data before it can provide that evidence.

The CA submits the precertificate to one or more CT logs. A log that accepts it returns a Signed Certificate Timestamp, commonly shortened to SCT. The SCT is a digitally signed promise that the log will incorporate the entry within its maximum merge delay. The CT educational documentation notes that this delay is commonly up to 24 hours, although policies and log parameters determine the applicable value.

The CA can embed SCTs in the final certificate. Other delivery methods exist, including TLS extensions and stapled status responses. A browser receiving the certificate checks the SCT signatures and whether they satisfy its current CT policy. The number and diversity of acceptable SCTs can depend on certificate lifetime and browser rules. Those policy details can change; the stable mechanism is the signed commitment connecting a certificate to a particular log.

An SCT is not yet proof that the entry is visible in the final tree. It is evidence that the log promised inclusion. Monitors can later check whether the promise was kept.

How Merkle proofs expose inconsistency

CT logs organize entries in a Merkle hash tree. Each leaf is derived from a logged item. Pairs of leaf hashes are hashed together, then pairs of those results, until one root hash commits to the tree’s contents and order. The log periodically signs information including the tree size and root, producing a signed tree head.

The structure supports two compact proof types. An inclusion proof shows that a particular leaf contributes to a stated root. It does not require downloading and rehashing the entire log; the verifier needs only the neighboring hashes along the path to the root. A consistency proof shows that a newer tree extends an older tree without changing or deleting the older entries.

This makes “append-only” a verifiable property, not a database setting. If a log presents one history to one observer and an incompatible history to another, comparing signed tree heads and requesting consistency proofs can expose the split. The mathematics does not guarantee that observers will compare views, however. Detection depends on monitoring and information exchange, sometimes called gossip. A dishonest log isolated from comparison could show different consistent-looking views to different parties for a time.

Cryptographic assurance also has a defined scope. Hash and signature security are assumed; software implementations and operator keys must be protected; and log availability matters. The tree proves relationships among entries and commitments. It does not prove that a certificate’s identity validation was correct.

What browsers, monitors, and operators each do

Logs accept submissions, build trees, sign commitments, and answer queries. Certification authorities validate requests, submit precertificates, collect SCTs, and issue final certificates. Browsers enforce policy by rejecting or warning about certificates that lack acceptable CT evidence. Monitors scan logs, verify promises and tree growth, and alert domain owners to suspicious entries.

These roles overlap imperfectly. A browser’s successful SCT check tells the user that recognized logs made suitable commitments; the browser may not perform every later inclusion query during the connection. A monitor can discover a certificate for example.com, but it cannot infer from the name alone whether the issuance was authorized. The domain owner supplies that context.

The public record can also help researchers measure the Web PKI, but it has privacy costs. Logging certificates exposes domain names found in them. Operators should not assume that an unpublicized hostname will remain obscure once placed in a public certificate. CT is designed for public TLS, not as a secrecy system for internal naming.

Visibility is not prevention

The strongest established claim is that CT makes public certificate issuance substantially more observable and makes a log’s append-only history cryptographically auditable. It narrows the period in which a publicly trusted certificate can exist without leaving evidence in recognized logs, when browsers enforce CT policy.

It cannot by itself remove a certificate from circulation. After detecting mis-issuance, a domain owner, CA, browser vendor, or other authority must investigate and act. Responses may include revocation, browser distrust, account remediation, or changes to CA procedures. Revocation has its own delivery and reliability constraints.

Questions also remain about governance. Browser vendors maintain log qualification policies and can disqualify unreliable operators. That enforcement is necessary, but it concentrates practical authority over which logs count. The protocol is open and auditable; the deployed ecosystem still depends on institutional decisions, operational capacity, and sustained monitoring.

CT is therefore best understood as an accountability mechanism. It turns a certificate from a private exchange between a CA and requester into an entry that outsiders can inspect. The log does not certify that the issuance was legitimate. It ensures that, under the system’s assumptions and enforcement rules, the issuance is harder to keep invisible.

Sources

4 sources, every one with a link you can follow.

  1. IETF, RFC 9162: Certificate Transparency Version 2.0.
  2. Certificate Transparency project, How CT Works.
  3. CA/Browser Forum, Baseline Requirements for publicly trusted TLS certificates.
  4. Google Public Key Infrastructure, Certificate Transparency logging FAQ.

Want the reader to remember this spot? Sign in — it is free.

Next How Passkeys Use Public-Key Signatures for Authentication

The app

Keep going, or take it with you.

Free accounts read twenty pieces a day. Pro is US$1.99 a month or US$11.99 a year for unlimited reading.