Security
Security and compliance
Four finding lenses plus a runtime feed, fed by Trivy, Kyverno and Falco. What each one ingests, what becomes a finding, what it needs to work, and where detection stops.
On this page
KubeBolt does not scan your cluster itself. It reads the scanners you already run — or install in one command — normalizes their output onto one severity scale, and gives it a lifecycle: a stable identity across rollouts, a first-seen clock, and resolution when the problem stops being observed.
Scope, plainly. This is detection and posture, not automatic remediation. KubeBolt tells you what is wrong, which workload owns it, and what the remedy is. It does not patch images, rewrite manifests, or enforce policy — enforcement lives in Kyverno, patching lives in your pipeline.
The four lenses
Security in the sidebar opens Security & Compliance. It splits findings into four lenses. Each is a different question with a different fix, so they are never summed into one ranked list.
| Lens | The question | Fed by |
|---|---|---|
| Vulnerabilities | What CVEs and exposed secrets are in the images we run? | Trivy: VulnerabilityReport, ExposedSecretReport |
| Configuration | What is misconfigured or violates policy? | Trivy: ConfigAuditReport. Kyverno: PolicyReport, ClusterPolicyReport |
| Permissions | Which Roles and ClusterRoles grant too much? | Trivy: RbacAssessmentReport, ClusterRbacAssessmentReport |
| Compliance | Which controls of a benchmark are failing? | Trivy: ClusterComplianceReport (the CIS benchmark and any other spec the operator runs) |
The page is fleet-wide: it reads every cluster you may see, not the cluster selected in the top bar. With more than one cluster, a selector next to the title narrows it to one.
The list you act on is workloads, not findings — Roles under Permissions, controls under Compliance. Hundreds of findings usually collapse to a couple of dozen workloads, and a workload is what actually gets changed. The finding-level counts stay on the card row above it: open criticals, the workloads affected (roles, on the Permissions lens), the share of findings with a published fix, and runtime threats in the last 24 hours. The criticals card carries the verdict in its color — red while any critical is open, amber with only highs, green with neither. The runtime-threats card is the one that lights red, whenever Falco reported anything in the last 24 hours.
Between the cards and the tabs, a By source row says what each scanner
contributes across all lenses: Trivy CVEs, CIS controls failing, Kyverno
violations and Falco threats in the last 24 hours. It sits above the tabs
because “which of my scanners are reporting” does not change when you switch
lens. The line under the title sums it up as N of 4 sources with findings.
The runtime feed
Runtime is the fifth tab and is not a lens. It is a stream of Falco events, stored separately from findings, and it behaves differently on purpose:
- Events are point in time. They age out of the feed after 24 hours rather than being resolved. There is no “resolved” button in the detail view, because there is no state to close and a button that lied about that would be worse than nothing.
- Priorities stay Falco’s own (
Emergencydown toDebug). They are not mapped onto the findings’ severity scale. - Falco pushes; Trivy and Kyverno are pulled. That is the whole reason Falco needs a token and an endpoint while the other two need neither.
The tab shows the last 24 hours, up to the most recent 500 events: a priority breakdown, the Top 5 rules by hits, and one row per event with the rule and command, the file it touched, the pod (or the node, for a host-level rule), the user and the time.
Kobi reads all of this too: get_findings for the posture, get_finding_detail
to re-read one finding live from the scanner, get_finding_workloads to get
them grouped by workload with exposed secrets first, and get_runtime_events
for what Falco saw processes actually do (24 hours by default, up to 720). See
Kobi Copilot.
What becomes a finding
Every scanner reports more than is worth acting on. The gates are deliberate and differ per source:
| Source | Ingested | Dropped |
|---|---|---|
| Trivy CVEs | CRITICAL, HIGH | MEDIUM, LOW, UNKNOWN — thousands of rows nobody finishes reading |
| Trivy config audit | CRITICAL, HIGH, MEDIUM | LOW — mostly “runs with a low UID” and “no CPU/memory limit”, which KubeBolt already raises as a capacity insight |
| Trivy RBAC assessment | CRITICAL, HIGH, MEDIUM | LOW, and Kubernetes’ own bootstrap roles (system:*, cluster-admin, admin, edit, view), which the control plane reconciles back if you edit them |
| Trivy exposed secrets | Every severity — no gate | Nothing. The matched text is never stored: the finding says where, never what |
| Trivy compliance | Failing controls | Passing controls produce nothing |
| Kyverno (PolicyReports) | result: fail | pass, skip, warn, and error (an engine hiccup is not the workload’s fault) |
Note the asymmetry between the CVE gate and the policy gate. A CVE with no
severity label is dropped; a policy violation with no severity label
becomes a medium finding. A policy is not a fact of nature — someone wrote it
on purpose, so a failure matters even when nobody said how much. A failing
compliance control keeps its severity when it is CRITICAL or HIGH and is
filed as medium otherwise.
Exposed secrets are counted apart from CVEs: a credential baked into an image is not a dependency to upgrade.
A finding’s identity is its source, kind, title and resource. Trivy reports against the ReplicaSet; KubeBolt files the finding under the owning Deployment, so a rollout does not reset its age. A finding is resolved when a complete sweep no longer reports it. If any report type fails to list on a pass — CRD missing, permission denied, a timeout — nothing is resolved from that pass, because a partial view cannot prove anything is gone. A cluster KubeBolt is not connected to keeps its findings as they were until it comes back.
What it needs
- Self-hosted: authentication on. Findings and runtime events live in the
same store as users and tokens, so they only exist with authentication
enabled (
auth.enabled=truein the Helm chart, the default;KUBEBOLT_AUTH_ENABLED). With it off there is no sweep, the page stays empty, and Falco’s ingest endpoint answers503. - A connection that can list the report CRDs. Trivy and Kyverno are read
through the cluster’s API connection: a direct or in-cluster connection (the
kubeboltchart’s ClusterRole already grants read on theaquasecurity.github.ioandwgpolicyk8s.ioreports), or the agent with its proxy on —rbac.mode=reader, the default, oroperator(see RBAC mode). A metrics-only agent (rbac.mode=metrics) ships metrics but no Trivy or Kyverno findings. - Falco does not depend on the connection — it pushes — but its token must be scoped to the cluster. See Falco.
On Cloud the first two are already true: clusters connect through the agent, whose default tier covers the sweep.
Wiring the sources
Three pages, one each:
- Trivy — CVEs, exposed secrets, misconfiguration, RBAC posture and CIS. Feeds all four lenses.
- Kyverno — your own policies. KubeBolt reads
wgpolicyk8s.io/v1alpha2PolicyReports, whichever engine wrote them. Gatekeeper constraints are not read directly. - Falco — runtime syscall events. The only source that needs a token.
Each scanner is detected by its pods, by label with a namespace fallback (the exact labels are on each page). The result is a card under Administration → Agents & Ingest → Integrations, for the cluster selected in the top bar: Installed, Degraded (pods present but not all Ready), Not installed, or Unknown (KubeBolt could not list pods). The card says the scanner runs; the By source row on the Security page says it reports. KubeBolt does not install the scanners: the Integrations page has no Install button for them.
Scanner sources are swept every 10 minutes, and once at boot as soon as a cluster is connected. Falco events arrive as Falco pushes them.
Retention
Security findings and runtime events share one horizon. Active findings never expire; a resolved finding is deleted once it has been resolved for longer than the horizon, and a runtime event once it is older than it. Cleanup rides the hourly retention pass.
In the open-source edition the horizon is KUBEBOLT_FINDINGS_RETENTION_HORIZON,
default 720h (30 days). The Helm chart has no dedicated value for it; set it
through extraEnv — see Environment variables.
On Cloud the window is a plan dimension:
| Plan | Retention |
|---|---|
| Free | 15 days |
| Team | 30 days |
| Business | 90 days |
| Enterprise | 365 days |
Security email on Cloud
On Cloud, findings also reach people by email. The open-source edition does not send these.
- First scan. One summary per cluster, once, when its first findings land. It waits until ingest has been quiet for 15 minutes (two hours at most), so scanners installed in the same sitting produce one message, not one each. It goes to the team that owns the cluster and, from the Team plan up, to security as well.
- Open posture. A digest of what is still open: weekly on paid plans, monthly on Free. It goes to security.
From the Team plan up, “security” is the organization’s security destination — Administration → System → Notifications → Security destination, typically a distribution list — or the organization admins while none is set. On Free, the team is security. Both messages obey the organization’s notification switches (notifications on, email channel on). See Notifications.
What is not here yet
- No automatic remediation. Kobi can propose and execute workload actions under governance, but nothing in the Security page acts on a finding by itself.
- No per-finding mute. Exceptions belong to the scanner (Trivy’s ignore file, a Kyverno PolicyException), so the source stays authoritative.
- Runtime events cannot be resolved or acknowledged — see above.
- Falco tuning happens in Falco. Silencing a noisy rule is a
customRuleschange at the source, not a KubeBolt setting.