Industry

Certificate Transparency logs went static, and your CT monitor may not have noticed

October 27, 202610 min readCertPulse Engineering

Certificate Transparency monitoring has an awkward property: when it breaks, it usually stays quiet. Nobody pages you about a certificate your monitor never saw. If a wildcard gets mis-issued for your login domain while the pipeline that should catch it is reading logs that no longer contain it, there's no 2am alert. The dashboard stays green and new entries keep arriving. The monitor looks healthy until someone shows you a certificate it should have flagged months ago.

Over the past year the CT ecosystem changed how logs serve their data, and a lot of tooling hasn't caught up. Check whether you're still seeing everything you think you're seeing. That applies whether you run CT monitoring yourself or pay a feed or vendor to do it.

What actually changed

RFC 6962 logs expose a dynamic read API. You call get-sth for the current signed tree head, then page through get-entries with a start and end index. The server returns however many entries it feels like, often far fewer than you asked for, so you loop. Every request hits an application server sitting on a database, and that gets expensive. In its end-of-life announcement, Let's Encrypt said its RFC 6962 logs cost "approaching seven figures" a year in cloud spend, mostly because of clients crawling them.

The static-ct-api spec gets rid of the dynamic read path. A log publishes a signed checkpoint, Merkle tree tiles, and data tiles of 256 entries each. All of these are plain files on object storage behind a CDN. Full tiles never change, and the checkpoint is the only thing that does. Submission works the same way as in RFC 6962, which is why CAs barely noticed the switch. Monitors are the ones that need new code.

The timeline so far:

  • Let's Encrypt moved to Sunlight. Its new logs, Sycamore and Willow, are tiled. Oak, its Trillian-based RFC 6962 log, went read-only on November 30, 2025 and shut down on February 28, 2026. Chrome's current log list marks Oak as retired as of that date.
  • Chrome has accepted tiled logs since Chrome 134, with one condition: at least one SCT had to come from an RFC 6962 log (announcement).
  • That condition is gone. After a ct-policy discussion in November 2025, Chrome announced that Chrome 144 and later would stop enforcing the one-6962-log rule. Since April 15, 2026, a TLS connection in Chrome can be backed entirely by SCTs from tiled logs. The current Chrome CT policy doesn't mention RFC 6962 at all.
  • Apple hasn't followed. As I write this, Apple's CT policy still requires at least one SCT from an RFC 6962-compliant log.

That last bullet matters most. For most monitors, Apple's policy is the main reason coverage still looks complete.

Why monitors go blind without an error

Nothing breaks, coverage just shrinks

A typical self-hosted monitor has a list of logs in its config and tails each one. Say half the ecosystem's write volume moves to logs it can't read. Nothing errors. The logs it can read keep returning entries, so throughput looks normal. Coverage is what shrinks: every certificate whose SCTs come only from tiled logs drops out of view.

Most teams haven't been hit yet, and Apple is the reason. A CA that wants its certificates to work on iPhones still embeds one RFC 6962 SCT, so nearly every certificate still lands in at least one log an old-style monitor can read. That redundancy comes from browser policy, though, not from anything your monitor does. It's eroding in three ways:

  • SCT counts are dropping. Chrome and Apple both require only two embedded SCTs for certificates valid 180 days or less. Once the 100-day maximum takes effect in March 2027, that rule covers every publicly trusted certificate. With two SCTs from two operators, and one of them probably tiled, a 6962-only monitor has exactly one way to see each certificate.
  • RFC 6962 logs are retiring. Let's Encrypt left because tiled logs are far cheaper to run, and other operators are paying the same kind of cloud bills.
  • You don't pick the logs. CT monitoring exists to catch certificates you didn't request, and the CA that mis-issues one decides where it gets logged. A certificate meant only for Chrome users doesn't need to satisfy anything beyond Chrome's policy.

Oak's shutdown also left a slower failure behind. Any monitor still pointed at Oak has been getting connection errors since February. If your tailer logs per-log errors at debug level and moves on, Oak just went quiet while the other logs kept the graphs busy.

Aggregated feeds inherit their operator's gaps

Most teams don't tail logs directly. They consume a CertStream-style websocket, query crt.sh, or call a vendor API. Each of those sees only the tiled logs its operator has added support for. A websocket feed written against get-entries a few years ago and never updated will keep streaming from the RFC 6962 logs it knows about, with no sign that anything is missing.

crt.sh is a useful reference. Its monitored logs page lists Sycamore, Willow, and Geomys's Tuscolo next to the older logs, with the age of the latest entry for each. That shows what crt.sh ingests. What your own feed ingests is a separate question.

Log lists go stale in two ways

Chrome's v3 log list now gives each operator two arrays: logs for RFC 6962 logs and tiled_logs for the rest. Tiled entries have separate submission and monitoring URLs instead of a single url field. A tool that refreshes the list daily but only parses logs is technically up to date and still misses every tiled log. At the time of writing, 9 of the 11 operators in Chrome's list run tiled logs, and three of them (Microsec, GoDaddy, HARICA) run nothing else. Apple's list uses the same split.

Hardcoded lists go stale faster, because logs are temporally sharded. Chrome's log policy caps each shard's expiry range at one calendar year, and Let's Encrypt uses half-year shards. On October 14, 2026, Sycamore2028h1, Sycamore2028h2, Willow2028h1, and Willow2028h2 became qualified in Chrome's list. Certificates expiring after mid-December 2027 will land in shards that weren't in any config snapshot taken earlier this month. At the other end, older shards go read-only and then retire as their windows close.

Checking your own coverage

Reading configs won't prove your monitor is complete. You have to test it, and a canary certificate is the cheapest test there is.

  1. Issue a fresh certificate on a domain your monitor watches. Give it a unique hostname, such as a dated canary subdomain, so you can search for it without noise. Do this for every CA you actually use: Let's Encrypt, Amazon Trust Services through ACM, Google Trust Services, your commercial CA. They log to different places. (If someone in your org set ACM's CT logging preference to disabled, those certificates won't show up anywhere, and Chrome will reject them with NET::ERR_CERTIFICATE_TRANSPARENCY_REQUIRED. Take that up with whoever set it.)
  2. Read the embedded SCTs. openssl x509 -noout -text lists them under the CT Precertificate SCTs extension, each with a log ID and a timestamp.
  3. Map each log ID to a log. In the published lists, the log ID is the base64 SHA-256 of the log's public key. openssl prints it as colon-separated hex, so you'll need to convert one format to the other. Note whether each match is in logs or tiled_logs.
  4. For tiled SCTs, find the exact entry. Static-ct-api SCTs carry the leaf index in an extension. Divide it by 256 to get the data tile your certificate sits in, then fetch that tile and check that the certificate is there.
  5. Check what your monitor did. Did it alert? How long after issuance? Which log did it attribute the entry to? Every tiled log in Chrome's list declares a 60-second MMD, so if you hear about the certificate hours later, the delay is in your pipeline.
  6. Cross-check with crt.sh. The certificate's page there lists every log entry crt.sh found. If crt.sh shows an entry in Sycamore and your monitor only reports the RFC 6962 one, your coverage depends on Apple's policy.

One canary only covers the logs your CA picked that day, and CAs rotate logs. Run it on a schedule. Once a month per CA is cheap, and with lifetimes this short the extra certificates do no harm.

For coverage across the whole list, add per-log health checks. For every log in the current list that's qualified, usable, or readonly, track when your monitor last ingested an entry from it. A busy log that hasn't produced anything in an hour is a real signal. Small or newly qualified shards can be legitimately quiet, so set thresholds per log rather than globally. Watch the list itself too. Alert on state transitions (pending, qualified, usable, readonly, retired), on new shards appearing, and on shards reaching the end of their windows. Those alerts tell you to update your config before a gap opens.

If you run your own monitor

Mostly good news here: tiled logs are much nicer to tail than RFC 6962 logs ever were. Full tiles are immutable, so you can cache them forever, fetch them in parallel, and stop guessing how many entries a server will return per request. Data tiles reference issuer certificates by fingerprint instead of repeating the whole chain in every entry the way get-entries did. You fetch each issuer once and cache it. Verifying tiles against the signed checkpoint is cheap enough that monitors which used to skip inclusion checks have no excuse left.

A few things work differently, and they'll cause bugs if you port get-entries logic directly:

  • At the right edge of the tree, logs publish partial tiles, identified by width, until 256 entries accumulate. The full tile then replaces the partial one, which may be deleted. If you treat a partial tile as final, you'll either miss the entries that fill it out or process the early ones twice, depending on how you track position. If you treat a 404 on a partial tile as fatal, your tailer stalls.
  • The checkpoint is the one resource that changes, and it updates every few seconds. Polling it hard across dozens of shards is wasteful and rude. Back off on 429s and 5xx responses as you always should, and remember a CDN may sit between you and the log's origin.
  • Filippo Valsorda has proposed an optional names tiles extension: gzipped JSON lines with the index, timestamp, subject, and DNS and IP SANs for each entry. On a test log they came out more than 20 times smaller than data tiles. Most domain monitoring only needs hostname matching. If yours does too, check whether the logs you care about serve names tiles.

Also plan for more volume. Under SC-081v3, the maximum certificate lifetime drops to 100 days in March 2027 and to 47 days in March 2029. A team that used to renew once a year will produce roughly ten times as many CT entries for the same names. Every other organization with public certificates will do the same, so a tailer that keeps up comfortably today could be falling behind by 2029.

What to do this week

  • Audit your log list and your parser. Find out where your tooling gets its list, whether that list is current, and whether the code reads tiled_logs. Grep for "tiled" before you trust it.
  • Alert per log. "No new entries in N hours" for each qualified, usable, or readonly log is the cheapest health signal you'll get. Aggregate throughput hides dead logs.
  • Schedule the canary for each CA. Map each SCT to its log, confirm your monitor reported the certificate, and record which log it came from. If your monitor only ever reports RFC 6962 entries, it probably isn't reading tiled logs.
  • Treat log state changes as config changes. Handle new shards and retirements when they happen. Finding out about them during an incident is too late.
  • Ask your vendor directly. "Do you ingest static-ct-api logs, and which ones?" has a short answer. If you get a long, vague one, run the canary and find out yourself.

That applies to us too. CertPulse watches CT logs for your domains, and you shouldn't just take our word that it sees the tiled ones. Issue a canary, read its SCTs, and check that we reported it with the right log. Then do it again next month, because passing once doesn't prove much.

This is why we built CertPulse

CertPulse connects to your AWS, Azure, and GCP accounts, enumerates every certificate, monitors your external endpoints, and watches Certificate Transparency logs. One dashboard for every cert. Alerts when auto-renewal fails. Alerts when certs approach expiry. Alerts when someone issues a cert for your domain that you didn't request.

If you're looking for complete certificate visibility without maintaining scripts, we can get you there in about 5 minutes.