Discovery findings
Findings are the actionable output of discovery. Every scan produces zero or more findings per certificate or endpoint: weak ciphers, legacy TLS, expiring certificates, self-signed, PQC vulnerabilities. Each has a severity, a suggested remediation, and a status you can advance (open → acknowledged / suppressed / resolved).
Finding types
| Type | Severity | Meaning |
|---|---|---|
expired | Critical | Past not_after. |
expiry_critical | High | Certificate expires within 7 days. |
expiry_high | Medium | Certificate expires within 30 days. |
unmanaged_expiring | Medium | A certificate not managed by CertAutoPilot expires within 30 days — the one nothing will renew. |
outdated_managed_version | Medium (High within 7 days of expiry) | A server still serves an earlier version of a certificate CertAutoPilot manages: its current version was not deployed there. Names the managed certificate; resolves once the servers serve the current version. |
weak_key | High | RSA key smaller than 2048 bits. RSA-2048 is not flagged. |
sha1_signature | High | Leaf certificate signed with SHA-1. |
self_signed | Medium | The certificate is signed by its own key (not merely naming itself as issuer). |
untrusted_chain | High | No endpoint presents a chain to a trusted root — a private CA, an intermediate not sent, an expired CA or an invalid chain. Add an internal CA's certificate to the source to verify against it. Self-signed certificates have their own finding. |
revoked | Critical | The certificate is revoked: a server staples an OCSP response saying so, or the CA answered so (opt-in revocation check). |
leaf_is_ca | High | A CA certificate (basic constraints CA:TRUE) is served as the server's own certificate. |
missing_server_auth_eku | Medium | The extended key usage excludes TLS server use; browsers refuse it. |
lifetime_exceeds_cab | Medium | A certificate from a public CA is valid longer than the CA/Browser Forum allowed on its issue date (398 / 200 / 100 / 47 days). |
caa_violation | High | The CAA records of the certificate's names do not allow the CA that issued it (publicly trusted certificates only). |
incomplete_chain | High | The endpoint sends its certificate without the intermediate that issued it. Endpoint-scoped. With Fetch missing intermediates on, the remediation names the intermediate the certificate's issuer URL serves. |
chain_misordered | Low | The endpoint sends its chain out of issuer order. Endpoint-scoped. |
hostname_mismatch | Medium | The endpoint answers a name DNS points at it (or one listed on the source) with a certificate that does not cover it. Endpoint-scoped. |
ocsp_staple_invalid | Medium | The stapled OCSP response does not verify for the certificate or is out of date. Endpoint-scoped. |
hsts_missing | Low | A named HTTPS endpoint sends no Strict-Transport-Security (opt-in HSTS check). Not raised when the server answered 421 (it does not serve that name), 400 or a server error. Endpoint-scoped. |
hsts_short | Low | Its HSTS max-age is under 180 days. Endpoint-scoped. |
supports_tls10 | High | The endpoint still accepts TLS 1.0 (best-effort side probe; see the debounce note below). |
supports_tls11 | Medium | The endpoint still accepts TLS 1.1. |
weak_cipher | High | Handshake negotiated a cipher suite on the weak-cipher blocklist (RC4, 3DES, export). |
weak_cipher_accepted | High | Cipher enumeration found the endpoint accepts a weak suite even if it prefers a stronger one — a downgrade-capable client can still negotiate it. Endpoint-scoped (host:port:SNI). |
no_pfs | Medium | Negotiated key exchange without forward secrecy (static RSA). |
pqc_vulnerable | Low | Key algorithm classed as vulnerable by the PQC analysis (RSA below 2048 bits; DSA is unknown, not vulnerable). |
blast_radius | Low | One certificate is served on more than 10 distinct IP:ports — a compromise or expiry hits all of them at once. |
sni_required_endpoint | Medium (0 certs), Info (some found) | An IP:port rejects SNI-less handshakes — certs are only reachable with a server name. A visible blind spot; consider an AXFR source. |
ingress_default_cert | Low | The IP:port serves a placeholder/fake default certificate (ingress/LB) for unknown SNI. |
sni_hidden_certs | Info | Multiple distinct certs are served on one IP:port by SNI (explains why endpoint count exceeds IP count). |
ct_new_cert | Info | A CT-log source saw a new certificate for a monitored domain. |
ct_unexpected_ca | High | A CT-log source saw a certificate for a monitored domain from a CA outside the allowed list. |
A name answered with a certificate that does not cover it is a hostname_mismatch finding when
DNS points the name at that address (or the name is the source's own) — the endpoint row carries
the name_mismatch flag. A name the crawler only tried because it appeared in a certificate
there, and that DNS does not point there, is not recorded at all (see
Sources → deep SNI).
Chain, staple, key-usage, CAA and HSTS checks are explained under Sources → Certificate checks.
Severity levels
- Critical — act now; service may already be broken.
- High — act this week; active security concern.
- Medium — backlog.
- Low — advisory.
- Informational — tracked for awareness; no score impact.
Finding lifecycle
-
Open — freshly generated. Findings are recomputed after every scan and once an hour for every project with discovery sources, so an expiry window crossed between two scans (network sources scan at most once a day) shows up within the hour.
-
Acknowledged — operator has seen it; working on remediation. Adds a changed by + note field.
-
Resolved — closed as fixed, two ways. The platform resolves a finding on its own when the underlying issue is no longer detected by a scan (resolved auto), or an operator marks it Resolved manually. Either way, if the issue is re-detected later the finding reopens automatically (history preserved, with a note saying which closure regressed). CT-log findings are never auto-resolved (certificates never leave a CT log) — close them with Resolve, Acknowledge or Suppress; for CT findings a manual resolve is effectively permanent.
Debounced auto-resolutionA few findings rest on a best-effort probe that can briefly read "clear" on a single slow or lossy scan — legacy-TLS support (
supports_tls10/supports_tls11) and blast radius. To stop these from flickering open→resolved→open across scans, the platform waits until the issue has stayed undetected for about a day before auto-resolving them. A genuinely fixed endpoint still clears on its own within that window; only a transient one-scan blip is held back. All other finding types auto-resolve on the next clean scan as before. -
Suppressed — operator accepts the risk; the finding won't reappear on subsequent scans for this cert + type. Discovery never closes or reopens a suppressed finding — not when the certificate stops being seen and comes back, not when an endpoint problem clears and returns. Only Reopen brings it back.
Changing a status by hand
| You want to | Allowed when the finding is |
|---|---|
| Acknowledge | open |
| Suppress (note required) | open, acknowledged or resolved |
| Resolve | open, acknowledged or suppressed |
| Reopen | acknowledged, suppressed or resolved |
Resolved (auto) is the platform's own status: it cannot be set by hand, and a finding in it cannot be changed by hand either (it reopens by itself when the problem returns). A change the current status does not allow is refused.
Working with findings
- Discovery → Findings.
- Default view: open and acknowledged findings, sorted by severity (critical first; the
column header reverses it). Under the title of a
certificate finding you see the certificate's name and one server it was seen on (
+Ncounts the other servers, like the Affected column) — several certificates can share one title, such as TLS 1.0 enabled on 1 endpoint(s). - Filters: status (open, acknowledged, suppressed, resolved, resolved auto, or all), severity,
type, discovery source, the certificate's tag and owner, and a
search over the title, the certificate and the affected endpoints. Filters live in the page
address. The API additionally filters by certificate fingerprint (
cert_fingerprint). - Bulk changes — tick findings (or, after ticking a whole page, Select all N matching) and choose Acknowledge, Suppress, Resolve or Reopen. The confirmation shows how many findings are affected; findings whose status does not allow the change are left as they are and counted in the result. One bulk change can change at most 10,000 findings and is one entry in the audit log; ten bulk changes per minute per project. The selection belongs to the filters it was made under: changing a filter, clearing them or switching project drops it.
- Export → CSV or JSON downloads every finding matching the filters (ten exports per minute per project, audited).
- Expand a row for its description, the suggested remediation, the affected endpoints and its history. Click a certificate finding to open the certificate, and a server finding to open the server it is about (a server that has since gone away has no page to open). The address under a certificate finding opens that server.
- Change a status with the row's buttons (only the allowed changes are offered). Add a note — required to suppress; it is audit-logged.
History
Every finding keeps a history of what happened to it, shown newest first when you expand its row:
- Opened — first detected by a scan.
- Resolved automatically — a scan no longer detected it.
- Reopened — a resolved, auto-resolved or suppressed finding opened again: detected again by a scan, or reopened by a user.
- Acknowledged, Suppressed, Resolved, Set back to open — status changes made by hand, with the user and the note.
- Severity before → after — the severity of an open or acknowledged finding changed (for example an expiry finding that becomes more urgent). Severity changes of a suppressed finding are not recorded.
Bulk changes record one entry per finding they changed. A finding that comes back within 24 hours of being auto-resolved does not send a notification, but the history still shows it reopened.
The history is recorded since CertAutoPilot 1.7.0 and kept for 365 days. A finding raised before that shows when it was first seen and notes that earlier changes were not recorded. While a cluster still runs an older version on some nodes, the changes those nodes make are not recorded. A user limited to some discovery sources sees the history of the findings those sources found. The Activity page lists the findings reopened and resolved in a period.
Summary widget
The Sources page (an Open Findings banner, shown when there are open critical, high or medium findings; clicking it opens the Findings page) and the Findings page summarise findings as counts by severity of the findings that are still open or acknowledged. On the Findings page, clicking a severity count filters the table to that severity.
Remediation hints
Every finding ships with a remediation blob:
expiry_critical/expiry_high/expired/unmanaged_expiring→ adopt the cert into management and enable auto-renew, or ask the owning team to rotate.outdated_managed_version→ run the managed certificate's distribution again, or link it to a distribution that reaches these servers (never manage the old version again: that makes a second certificate).weak_cipher/weak_cipher_accepted/supports_tls10/supports_tls11/no_pfs→ reconfigure the endpoint's TLS policy; link to the target's vendor docs.self_signed→ replace with a CA-signed cert unless intentional.untrusted_chain/incomplete_chain/chain_misordered→ send the full chain, leaf first; for an internal CA add its certificate to the source.revoked→ replace the certificate now.leaf_is_ca/missing_server_auth_eku→ issue a server certificate with the serverAuth extended key usage.caa_violation→ add the CA to the domain's CAA records, or move to a CA they allow.lifetime_exceeds_cab→ replace it with a certificate within the CA/B limit.hostname_mismatch→ install a certificate covering the name on that server, or point the name elsewhere.hsts_missing/hsts_short→ sendStrict-Transport-Security: max-age=31536000; includeSubDomains.pqc_vulnerable→ plan migration to ECDSA P-256 or larger, or to post-quantum algorithms when available (the finding's own remediation text).
Remediation text is static — you can't customise it per-org, but the status/note fields absorb org-specific guidance.
Notifications
Subscribe a notification rule to these events (Notifications → Rules):
discovery.finding_opened— a finding opened, was detected again after it was resolved, or became more severe. Expiry findings (expired,expiry_critical,expiry_high,unmanaged_expiring), the CT-log findings (ct_new_cert,ct_unexpected_ca) and informational findings never send it; expiry has its own events below. A finding that closed by itself less than 24 hours ago and is detected again reopens without a notification (a check that flaps, or an older node during a rolling upgrade, would otherwise announce every return); one you resolved yourself, or one closed longer ago, does notify. Suppressed findings never notify. The rule's minimum severity filters on the finding's severity: Critical → critical, High → warning, Medium and Low → info.- When one refresh has more than five such changes, you get one summary per discovery source instead (count per severity and up to ten examples). A finding seen through two sources is counted in both summaries. Findings of a certificate no endpoint serves any more get a summary of their own, without a source.
- Findings that were already open when this event became available are reported once, in one summary per source, after the upgrade; after that only changes are reported.
discovery.cert_expiring— a discovered certificate that CertAutoPilot does not manage, or an earlier version of one it manages that a server still serves (the alert then carriesmanaged_certificate_id), reaches one of the lead times set under Settings → General → Expiry alerts (30, 14, 7 and 1 days by default, each sent once and shortened to a third of a short-lived certificate's lifetime), then daily in its last three days. Only certificates an endpoint still serves are alerted.discovery.cert_expired— such a certificate has expired; sent once, and only when it expired within the last 30 days.- When one refresh has more than five
discovery.cert_expiring(ordiscovery.cert_expired) alerts — typically the first refresh after the upgrade — you get one summary per discovery source instead, with the count and up to ten examples. Every certificate in it counts as alerted, so none is repeated. discovery.new_cert/discovery.cert_changed/discovery.endpoint_gone— sent by each scan for new certificates, a different certificate on a known endpoint, and endpoints that stopped answering.discovery.kex_downgraded— a server that negotiated a quantum-safe key exchange negotiates a classical or RSA one (one summary per source when more than five; see Quantum readiness). There is still no finding for a classical key exchange.
A certificate CertAutoPilot manages (linked by fingerprint, see
Inventory) gets no discovery expiry events: its own
cert.expiring_soon / cert.expired already cover it. A rule saved by a user who sees only
granted resources receives a discovery event when that user is granted one of the discovery sources
it is about, and its copy names only those sources (see Resource grants).
Troubleshooting
Finding I resolved keeps reopening
The underlying issue isn't actually fixed. Re-check the endpoint; or if the scanner is wrong, use Suppress instead of Resolve until the scanner is corrected.
False-positive on self_signed
You use an internal CA whose issuer name equals the subject of the certificates it signs, or a deliberately self-signed certificate on an internal endpoint. Mark the finding suppressed with a note explaining the policy — suppression survives later scans.
See also
Video tutorials
Short, hands-on videos showing this feature working for real. English audio, English and Turkish subtitles. All video tutorials →