Every publicly trusted TLS certificate for your domains ends up in public Certificate Transparency logs, yet most web teams never look, so a certificate obtained through a hijacked DNS record, a taken-over subdomain or a careless internal team goes unnoticed until it is used. Chrome, Safari and Firefox now require CT logging for publicly trusted certificates, which turns the logs into a near-complete, real-time feed of issuance for any name. This guide is the operational companion to the Certificate Transparency Guide: it covers how to choose a monitoring source, build a watch list, match certificates to what you expected, triage and revoke, harden issuance with CAA, and keep noise manageable as certificate lifetimes fall to 47 days. It is written for web platform, SRE and security operations teams.
Key takeaways
- Monitoring is your job, not the browser's. Browsers check that a certificate was logged; nobody checks that it was authorised except the domain owner.
- Match against expected issuance, not just a domain list. Alerts become useful when each certificate is compared with your approved CAs, ACME accounts and naming patterns, so only deviations reach a human.
- CT monitoring for your domains does not find lookalikes. Cloudflare's own documentation notes its CT alerts do not trigger for names such as
cloudf1are.com; lookalike detection needs separate fuzzy matching. - Know the revocation route before you need it. The CA/Browser Forum Baseline Requirements oblige CAs to investigate a Certificate Problem Report within 24 hours and to revoke within 24 hours when the subscriber says the request was not authorised.
- Volume will rise sharply. Maximum validity falls to 200 days from 15 March 2026, 100 days from 15 March 2027 and 47 days from 15 March 2029 under Baseline Requirements Section 6.3.2, so suppression of expected renewals is a design requirement.
What CT monitoring detects
Certificate Transparency logs are append-only Merkle tree logs of issued certificates. When a CA submits a certificate (usually a precertificate, marked with the poison extension OID 1.3.6.1.4.1.11129.2.4.3) a log returns a Signed Certificate Timestamp (SCT), which the CA embeds in the final certificate. MDN notes that since June 2021 most publicly trusted certificates in active use carry embedded SCTs.
Browser enforcement is what makes monitoring reliable. The Chrome CT Policy requires all publicly trusted TLS certificates to be CT compliant to validate; for embedded SCTs that means SCTs from at least two distinct logs for certificates valid up to 180 days, three for longer lifetimes, and at least two distinct log operators. MDN records that Apple requires SCTs for Safari, and that Firefox desktop from version 135 and Firefox for Android from version 145 require CT log inclusion for certificates from CAs in Mozilla's Root CA Program. A certificate that was not logged will fail in those browsers, so an attacker who wants a usable certificate has to log it.
SSLMate's Cert Spotter documentation summarises the threats this exposes:
- DNS compromise: certificates issued to attackers who control your DNS and redirect visitors. See the DNS Hijack Playbook.
- Abandoned subdomains: certificates for a subdomain an attacker has taken over. See the Subdomain Takeover and Dangling DNS Guide.
- CA compromise or mis-issuance: certificates a CA issued without valid domain control.
- Policy violations: certificates obtained outside central procurement, such as a team using an unapproved CA or a wildcard where policy forbids it.
CT also has limits. It only covers publicly trusted certificates: private PKI, internal CAs and self-signed certificates do not appear. It reveals names, so internal hostnames in public certificates leak to everyone watching, including attackers performing reconnaissance (ATT&CK T1596.003 Search Open Technical Databases: Digital Certificates).
Choosing a monitoring source
| Option | How it works | Best for | Watch out for |
|---|---|---|---|
| CDN or CA built-in alerts | Email when a certificate covering your zone is logged; Cloudflare's CT Monitoring is opt-in and filters out certificates Cloudflare issued for you | Small teams with one provider | Shared certificates can alert on other customers' SANs; coverage limited to zones on that platform |
| Search tools such as crt.sh | Ad hoc queries of aggregated log data | Baselining and investigations | Not a continuous monitor; can lag or time out on large domains |
| Hosted CT monitoring services | Watch all logs, alert by email, webhook or chat, often with dashboards | Most organisations | Check which logs are covered and the alert latency |
| Self-hosted open-source monitor (for example Cert Spotter) | Reads logs directly; watch list file, email or hook scripts on match | Teams wanting control and SOC integration | Bandwidth and operation; Cert Spotter's -start_at_end saves bandwidth but skips certificates logged before you started |
| Streaming aggregators (for example certstream) | WebSocket feed of new certificate updates with all domains in each leaf | Lookalike and brand keyword detection at scale | Third-party availability; you must handle filtering and reconnection |
| Your own log reader | Read RFC 6962 get-entries or Static CT API tiles directly | Large platforms and security vendors | Log list churn and engineering effort |
Note the shift in log design. The C2SP Static CT API (formerly the Sunlight API) defines a read path served as static tiles alongside the RFC 6962 submission endpoints. Monitors written only against the RFC 6962 read endpoints will miss logs that serve the static read path, so check that any tool you choose supports both. Google publishes the log list used by Chrome as log_list.json (v3 schema), with log states Pending, Qualified, Usable, ReadOnly, Retired and Rejected; a self-built monitor should track that list rather than a hard-coded set.
Decision guidance
- Small organisation, few domains: turn on provider alerts and subscribe to one independent monitor so you are not relying on the party that issues your certificates to tell you about unexpected ones.
- Mid-size: a hosted service with webhook delivery into the ticketing system or SIEM, plus a monthly crt.sh baseline review.
- Large or regulated: self-hosted or vendor monitor feeding the SOC, automated matching against the certificate inventory and ACME account list, and a separate lookalike pipeline.
Building the watch list and the expected-issuance baseline
- Enumerate registered domains: pull the list from your registrar accounts, not from memory. Include parked, defensive and acquired domains, which are often the ones nobody watches.
- Decide scope per entry: Cert Spotter's convention is typical: a leading dot (
.example.com) watches the domain and every subdomain, a bare name watches only that name. - Baseline current issuance: query existing certificates for each domain and record issuer, SAN pattern, key type, validity and the team that owns each name.
- Write the expected-issuance policy: approved CAs, approved ACME accounts, whether wildcards are allowed and where, and naming conventions (for example no internal hostnames in public certificates).
- Publish it in DNS: CAA records (RFC 8659) tell CAs who may issue. Let's Encrypt documents the
issueandissuewildtags, and thevalidationmethodsandaccounturiparameters, which restrict a CA to particular validation methods and particular ACME accounts. Withaccounturi, someone who briefly hijacks your domain but lacks your ACME account key cannot obtain a certificate from that CA. - Load the baseline into the monitor: as allow rules (known issuer plus known account or known name pattern) so that matching certificates are logged but not alerted. Cert Spotter provides a
certspotter-authorizecommand for marking known certificates.
See the ACME and Automated Certificate Management Guide for managing ACME accounts, which are machine credentials in their own right.
Alert rules that work
| Rule | Severity | Rationale |
|---|---|---|
| Issuer not in approved CA list | High | Either a policy breach or an attacker who passed validation with another CA |
| Approved CA, ACME account not in approved list | High | Someone else proved domain control |
| Name matches a decommissioned or dangling host | High | Classic subdomain takeover signal |
| Wildcard where policy forbids it | Medium | Over-broad certificate, larger blast radius if the key leaks |
Internal-looking hostname (for example vpn, jira, staging) in a public certificate | Medium | Information disclosure for reconnaissance |
| Certificate for an apex domain from a new issuer after a registrar or DNS change | High | Correlate with registrar audit logs; see the Authoritative DNS and Registrar Account Security Guide |
| Precertificate with no matching final certificate deployed | Low | Often benign (failed issuance); worth a check if paired with other signals |
| Brand keyword or lookalike of your domain (separate pipeline) | Medium | Phishing infrastructure; see the Typosquatting and Lookalike Domains Guide |
Deduplicate precertificates and final certificates (they share serial number and issuer), and group SANs from one certificate into one alert. Send alerts to a queue owned by a named team, not a shared mailbox.
Triage and response
- Confirm ownership: check the certificate inventory, ACME logs and change tickets. Most alerts are an internal team or a SaaS provider issuing for a name you delegated to them.
- If unauthorised, contain: identify how domain control was demonstrated. Look at DNS change history, registrar account audit logs, web server content for HTTP validation files, and whether a CNAME points at a deprovisioned cloud resource.
- Request revocation: file a Certificate Problem Report with the issuing CA using its published process. Baseline Requirements Section 4.9.3 requires CAs to accept reports around the clock and publish instructions; Section 4.9.5 requires an investigation and preliminary report within 24 hours; Section 4.9.1.1 requires revocation within 24 hours when the subscriber states the original request was not authorised (CRLReason privilegeWithdrawn) or the domain validation should not be relied upon.
- Close the path: fix the DNS or registrar weakness, tighten CAA (
accounturi,validationmethods), and remove dangling records. - Hunt for use: check whether the certificate was deployed (for example scan or passive DNS for the name resolving to unfamiliar addresses) and whether users were redirected. Treat any credential entered on the affected names as exposed.
- Record evidence: keep the log entry, SCTs, CA correspondence and timeline for the incident record. See the Certificate Revocation Guide for how revocation reaches clients.
Rolling out monitoring
- Week 1, observe: run the monitor in log-only mode against the full watch list and collect a month of issuance.
- Week 2 to 4, tune: convert recurring benign patterns into allow rules keyed on issuer plus ACME account or SaaS provider, never on name alone.
- Enable alerting: high-severity rules to the on-call or SOC queue, medium to the owning team's backlog.
- Exercise: issue a test certificate from an unapproved but legitimate CA for a test subdomain, confirm the alert fires, and walk through the response runbook including a revocation request for your own test certificate.
- Review quarterly: refresh the domain list from registrars, retire allow rules for decommissioned services, and review CAA coverage.
Rollback is simple: drop rules back to log-only. Do not disable collection, because the history is what lets you answer "when was this name first issued?" during an incident.
Detection and measurement
- Coverage: percentage of registered domains on the watch list and with CAA records (target 100% for both).
- Latency: median time from log entry to alert, and from alert to triage decision.
- Signal quality: share of alerts closed as expected issuance; rising numbers mean allow rules need work.
- Outcomes: unauthorised certificates found and revoked per quarter, with root cause (DNS, registrar, dangling record, policy breach).
- Discovery value: previously unknown hosts added to the asset inventory from CT data.
Where identity fits
A TLS certificate is a machine identity, and CT monitoring is one of the few controls that sees every machine identity issued in your name by a public CA, including ones your inventory does not know about. Three identity links are worth making explicit:
- ACME account keys are credentials: whoever holds the account key for an
accounturi-bound CAA record can issue for your domains. Store these keys in a secrets manager, scope accounts per environment, and rotate them when staff or automation pipelines change. - Registrar and DNS provider logins are the root of trust: domain validation is only as strong as the accounts that control DNS. Enforce phishing-resistant MFA and least privilege on registrar and DNS API credentials, which are frequently long-lived API tokens held by automation.
- Certificate owners must be named: every alert should resolve to a team that owns the name and the key. Feed CT discoveries into the machine identity inventory so that unknown certificates get an owner or get revoked. See the Machine Identity, PKI and Certificate Lifecycle Guide.
Common failure patterns
- Watching only the main domain: parked, regional and acquired domains are left out, and those are the ones with weak registrar hygiene.
- Allow rules keyed on name only: suppressing every certificate for
shop.example.comalso suppresses the attacker's certificate for it. Key rules on issuer and account. - Relying on the issuer to tell you: a provider's alert covers its own platform; an attacker will use a different CA.
- Treating CT as phishing protection: your-domain monitoring misses lookalikes by design.
- No CAA, or CAA without account binding: any CA can issue, and anyone who briefly controls DNS can pass validation.
- Alert fatigue after lifetimes shrink: without renewal suppression, 47-day certificates bury the real signal.
Framework mapping
| Framework | Reference | How CT monitoring applies |
|---|---|---|
| NIST CSF 2.0 | DE.CM-09; ID.AM-08; RS.MA-01 | Monitor certificates for adverse events; lifecycle management; coordinate revocation with the CA |
| NIST SP 800-53 Rev. 5 | SC-17 Public Key Infrastructure Certificates; SI-4 System Monitoring; IR-4 Incident Handling | Certificate control, continuous monitoring, response |
| CA/Browser Forum Baseline Requirements | Sections 3.2.2.8 (CAA), 4.9.1.1, 4.9.3, 4.9.5, 6.3.2 | CAA checking, revocation timelines, validity periods |
| MITRE ATT&CK | T1588.004 Obtain Capabilities: Digital Certificates; T1608.003 Stage Capabilities: Install Digital Certificate; T1583.001 Acquire Infrastructure: Domains; T1596.003 Search Open Technical Databases: Digital Certificates | Attacker certificate acquisition and reconnaissance that CT exposes |
Practitioner checklist
- Pull the full domain list from every registrar account and put every domain on a CT watch list.
- Record approved CAs, ACME accounts, wildcard rules and naming conventions as an expected-issuance policy.
- Publish CAA records for every domain, using
accounturiandvalidationmethodswhere your CA supports them. - Use at least one monitor independent of the provider that issues your certificates.
- Key allow rules on issuer plus account, never on hostname alone.
- Route high-severity alerts to the SOC with a written runbook that includes the CA's problem reporting address.
- Run a separate lookalike and brand keyword pipeline for phishing infrastructure.
- Keep internal hostnames out of public certificates; use private PKI for them.
- Test the alert and revocation path at least annually.
Standards and references
- IETF: RFC 9162 Certificate Transparency Version 2.0
- IETF: RFC 6962 Certificate Transparency
- CA/Browser Forum: TLS Baseline Requirements
- Google Chrome: Certificate Transparency Policy
- MDN: Certificate Transparency
- C2SP: Static Certificate Transparency API
- Let's Encrypt: Certificate Authority Authorization (CAA)
- SSLMate: Cert Spotter open-source CT monitor
Related NHI Mgmt Group resources: Certificate Transparency Guide · Subdomain Takeover and Dangling DNS Guide · Certificate Expiry Outages and 47-Day TLS Certificates Guide · Machine Identity, PKI and Certificate Lifecycle Guide · Typosquatting and Lookalike Domains Guide