Skip to content

v1.4.0

Latest

Choose a tag to compare

@github-actions github-actions released this 10 Nov 01:43
· 1 commit to main since this release
98b1249

This release puts the attack paths in front of you and lets you ask about them. In earlier versions the default run kept 20 findings, and on a dense cluster none of them was an attack path. scan now reports every finding, prints the paths in the terminal, and shows them in a simpler HTML report with one graph for each target. A new paths command answers one question in the terminal, such as who can reach cluster-admin. --overlay and paths --diff check a manifest or a fix against a snapshot before anything changes in the cluster, and an agent skill tells a coding agent how to do both. The escalation graph has two new targets (Service traffic interception and kubelet node identity) and eleven new rules. A correctness pass makes the graph follow the upstream RBAC matcher and tell a held token apart from code that runs in a pod. Three behaviors change, so check them before you upgrade a pipeline: findings.json, the CSV, and the SARIF file hold every finding and --max-findings defaults to 0, a --ci-mode gate failure exits with code 2, and the GitHub Action pulls the latest image by default.

Added

  • scan prints the attack paths in the terminal. After the findings: line, scan and report print one line for each target an attacker can reach: the target, how many identities reach it, and the most direct chain (cluster-admin 23 identities shortest: ServiceAccount/cert-manager/cert-manager via wildcard_permission). The hop names are the action values in findings.json. The findings: line is unchanged.
  • SARIF results carry the hop chain. An attack-path result now has properties.escalation_path, and properties.alternate_escalation_path when a second route survives the first fix. The README said the chain was in the SARIF output, and it was not.
  • A simpler HTML report. The report had six tabs, and two of them showed the same privilege-escalation paths in different forms. It now has five: Summary, Attack paths, Findings, Least privilege, and Compliance.
    • Summary replaces Risk overview and is one page: the risk score, severity counts that open the matching findings, the top fixes, a table of the targets an attacker can reach (with the most direct route to each), the plain-English attack chains, and findings by attack type and by module. Cluster reconnaissance is still there, collapsed by default.
    • Attack paths replaces two tabs: the old Attack paths tab (top chains and the curated attack graph) and Escalation paths. You select one target (cluster-admin, node root, kube-system secrets, and so on) and see one graph for it. Columns show how many hops each identity is from the target, and three or more identities that take the same first step collapse into one group node. Hover a box or an arrow to trace its paths, or click it to show only those paths in the list under the graph. Each path in the list opens its hop-by-hop chain and links to the finding for the fix.
    • The graph is drawn as a proper layered diagram. Each identity is a card with an icon for its kind (ServiceAccount, user, group, AWS identity) tinted by the worst severity through it; a group of identities is a stacked card; the target is a glowing card with an icon for what it is (crown, server, key, cloud). Columns are lanes on a dotted canvas, arrows leave and enter cards at separate ports, and an arrow that skips a column is routed between the cards there instead of across them. Tracing a path lights it with a flowing animation and names every hop in a label; a floating card shows the full identity, where it lives, and how many paths run through it. Paths to a family target (an AWS IAM role, a namespace) name the specific role or namespace on their row.
    • Findings has a sticky sidebar with search (press /), severity filters, and module links. Each rule is one collapsed row with its severity, affected count, and top score. When you open a rule, the background explainer shows once for the whole rule, not once per affected object, and each affected object opens on its own. Filtered views stay in the URL, so you can share them.
    • Links from older reports (#tab-overview, #tab-attack, #tab-privesc) still open the matching tab. The report is still one self-contained file with no external scripts, and it now fits on a phone screen.
  • kubesplaining paths: ask the graph one question. scan writes a report. paths answers in the terminal: --to cluster-admin lists who can reach a target, --from ServiceAccount/dev/ci lists what one identity can reach, and --verbose shows each hop with the binding and role behind it and the fix. It reads a snapshot (--input-file) or the live cluster, and it runs the same search as scan, so each path has the ID, score, and hops of the finding in the report. --output-format json prints a short record for each path plus total and returned counts (about 1 KB for each path, where a full finding is about 7.5 KB). With --from the exclusions do not apply, and the source can be an identity that scan never starts from: a built-in system: identity, a control-plane ServiceAccount, or an implicit group such as Group/system:authenticated. An identity that is not in the cluster is an error, not an empty answer.
  • An agent skill for attack paths. The repository is now a Claude Code plugin marketplace with one plugin, kubesplaining, that holds one Agent Skill, attack-paths. The skill tells a coding agent how to answer "who can reach cluster-admin?" or "what can this ServiceAccount escalate to?": capture a snapshot one time, query it with paths --output-format json, explain each hop, and propose the smallest RBAC change without a change to the cluster. Install with claude plugin marketplace add 0hardik1/kubesplaining, then claude plugin install kubesplaining@kubesplaining. The skill uses only the fields of the open format, so other agents that read SKILL.md files can use the directory plugins/kubesplaining/skills/attack-paths/ as it is. A test keeps the skill's list of targets and hop actions equal to the list in the code.
  • Offline what-if: --overlay, --overlay-delete, and paths --diff. --overlay <file|dir|-> applies manifests on top of a snapshot in memory, and --overlay-delete Kind/[namespace/]name removes one object. paths --diff then lists the attack paths that the change adds, removes, and changes, and exits with code 2 when the change adds one. This answers "does this RoleBinding open a path?" for a pull request and "does this fix close the path?" before a kubectl command, with no change to the cluster. A path that stays open by a second route is reported as changed, not as removed. The overlay applies Role, ClusterRole, RoleBinding, ClusterRoleBinding, ServiceAccount, Namespace, and Pod, skips other kinds with a warning, and derives the rules of aggregated ClusterRoles (admin, edit, view) again after a ClusterRole change. A manifest with no namespace needs --overlay-namespace. scan takes the same flags and marks its report as a what-if result. The attack-paths skill now tells the agent to check each fix this way before it shows it (plugin version 0.2.0).
  • KUBE-PRIVESC-030: pod binding lets a subject act as the scheduler. create on pods/binding (or the legacy bindings resource) is the write kube-scheduler makes to place a pod. The binding handler validates only that the target is a named Node, refuses pods already assigned, being deleted, or scheduling-gated, and sets spec.nodeName; the API server re-runs none of the scheduler's filters, and the kubelet re-checks resource fit, node affinity, nodeName, and host ports but among taints only NoExecute, so the control-plane NoSchedule taint does not stop a direct bind. The rbac analyzer emits the finding at MEDIUM for the bare grant (placement control over pods other identities create) and at HIGH when the same subject can also create pods or write a workload, because it then chooses where its own pod runs and control-plane co-residency, which the taint is meant to deny, is one request away. Remediation pairs the taint with a ValidatingAdmissionPolicy on pods/binding CREATE that denies control-plane targets for non-scheduler users, since a taint alone only steers the scheduler.
  • Kyverno joins the confused-deputy catalog. A tenant that can write kyverno.io ClusterPolicies or Policies steers the Kyverno background controller (or the single kyverno ServiceAccount on releases before 1.10) into creating any resource a generate rule names, RoleBindings and pods included, or rewriting existing objects through mutateExisting, with the controller's own cluster-wide permissions. A namespaced Policy is enough, because generate rules still run as the controller. The operator_reconcile bridge fires only when the controller ServiceAccount exists in the snapshot, as for every other catalogued operator.
  • KUBE-PRIVESC-034: update/patch on pods swaps container images inside running pods. The API server's pod update validation deliberately keeps spec.containers[*].image and spec.initContainers[*].image mutable on a live pod, and the kubelet restarts the container with the new image inside the same pod sandbox: same ServiceAccount token mount, same securityContext, same host namespaces and volumes. Nothing in-tree checks who changed the image and no workload controller reverts it (ReplicaSet, StatefulSet, and DaemonSet reconcile on labels and template hashes). That makes a plain write verb on pods, which the built-in edit ClusterRole and many label-patching operator roles carry, the same reach as pods/exec (-004) and pods/ephemeralcontainers (-013), and the tool had no rule for it. The rbac analyzer now emits a HIGH finding on the grant (a rule that also carries create keeps its -001 framing), and the privesc graph draws a pod_image_hijack edge from the holder to every ServiceAccount that pods in scope run as, honoring resourceNames and giving the same foothold exec gives: the pod, plus the SA's token and identity when one of its pods mounts an API token. The remediation keeps the verb where a tool genuinely needs it and adds a ValidatingAdmissionPolicy that denies image changes on pod UPDATE, since no in-tree component changes a live pod's image. Ships with a content builder, a hop narrative, a glossary technique explainer, a structured remediation hint, a compliance tag (CIS 5.1.4), and unit tests on both the finding and the edge.
  • KUBE-PRIVESC-035: Pod Security Admission label flip. Pod Security Admission reads the standard it enforces from the pod-security.kubernetes.io/enforce label on the Namespace object at admission time, and nothing in-tree protects that label. A subject that can update/patch the namespace and create pods in it relabels the namespace to privileged and lands a privileged pod in a namespace the cluster's PSA posture reports as locked down. The tool modeled PSA labels as static facts, so a restricted namespace capped every pod-create grant there at token theft. Two details make the grant easy to miss and are now modeled: the write is outside the built-in admin/edit ClusterRoles, so it arrives through custom roles for namespace self-service, GitOps, or quota tooling; and a namespaced Role granting patch namespaces reaches its own namespace object, because the API server treats /api/v1/namespaces/<ns> as a request in <ns>. The rbac analyzer emits a HIGH finding when both halves are held for a namespace whose label is baseline or restricted (the pod half is create pods, create on a workload kind, or update/patch on a workload that exists there), anchored on the namespace write. The privesc graph adds a namespace_psa_label_flip edge to node_escape, a two-write conjunction with CutBreakers for each half so the cut-resilient pass bans it when either grant is cut, grouping the namespaces reached through the same pair of bindings into one edge. Remediation: drop the verb, add a ValidatingAdmissionPolicy that denies changes to pod-security.kubernetes.io/* labels, and set a cluster-wide PSA default so a removed label does not fall back to privileged. Compliance tags: CIS 5.2.1 and the NSA/CISA Pod Security and Authorization controls.
  • KUBE-PRIVESC-036 and a traffic_intercept sink: pods/status writes steer Service traffic. A Service's backends are the addresses its selected pods report in status.podIPs, and that status is an ordinary subresource. The API server checks only that the addresses are well-formed, the NodeRestriction plugin constrains kubelets and nobody else, and the EndpointSlice controller republishes whatever the status says. A subject with update/patch on pods/status for a selected pod therefore redirects the Service's clients to an address it chooses. The rbac analyzer reports the grant (MEDIUM), and the privesc graph gains an eighth sink, traffic_intercept, with a pod_status_ip_spoof edge per Service whose selector matches a live pod in scope. The hop is hard by default (the kubelet corrects the status every 10 seconds) and moderate when a selected Service publishes not-ready addresses and a selected pod has no node, where nothing corrects it. Paths to the sink are KUBE-PRIVESC-PATH-TRAFFIC-INTERCEPT (HIGH, lateral movement).
  • KUBE-PRIVESC-021 and KUBE-PRIVESC-022: EndpointSlice and Service writes steer Service traffic. kube-proxy consumes every EndpointSlice that carries a Service's kubernetes.io/service-name label whatever its managed-by label says, and the EndpointSlice controller reconciles only the slices it manages, so a slice a subject adds survives and takes a share of the Service's traffic (-021, MEDIUM, HIGH where the grant reaches a control-plane backend namespace). A Service's selector, ports, and type are plain spec fields (-022). Because the built-in edit ClusterRole carries update services, -022 fires only where the reach is more than a tenant's own Services: a cluster-wide grant, or a namespace that hosts a webhook or aggregated API backend. Both draw edges into traffic_intercept (endpointslice_write, service_backend_rewrite), with the same tenant gating for the Service edge. Writes on the legacy core endpoints resource are not flagged: for a selector Service the EndpointSlice mirroring controller ignores them, which was verified against a live cluster.
  • KUBE-PRIVESC-038: control-plane backend namespaces. Admission webhooks and aggregated API servers are Services the API server itself calls, with its own front-proxy credentials and the caller's identity, verified against the configuration's caBundle with the Service's DNS name pinned. The scanner now derives the namespaces hosting such Services from the webhook configurations and APIServices it collects, and in those namespaces a routing half (write the Service or its EndpointSlices, or put a pod of one's own behind it) held together with a TLS half (read Secrets, mount them in a pod, or run code in the backend's pods) is KUBE-PRIVESC-038: CRITICAL when the backend is a mutating webhook on pods CREATE or a native-group APIService, HIGH otherwise. The privesc graph draws control_plane_backend_hijack edges to the sink the backend's kind decides (node_escape for a pod-rewriting mutating webhook, cluster_admin for a native-group APIService, traffic_intercept for the rest), with both halves as cut breakers. A backend with no caBundle is skipped, since the host's system roots cannot be satisfied from in-cluster material, and an APIService with insecureSkipTLSVerify needs no TLS half. The practical consequence: the built-in edit and admin ClusterRoles hold both halves, so a namespace hosting a webhook or aggregated API has to be treated like kube-system.
  • APIServices are collected, and KUBE-PRIVESC-020 reports who can rewrite them. The collector lists apiregistration.k8s.io APIServices through the dynamic client (no kube-aggregator dependency) into a reduced api_services snapshot field: name, group, version, spec.service, insecureSkipTLSVerify, whether a caBundle is set, and the automanaged label. The manifest loader accepts APIService documents. Cluster-scoped update/patch on apiservices re-points an API group's registration at a Service the holder controls, so the aggregator forwards that group's requests and the API server's front-proxy credentials there: CRITICAL when the grant is unscoped or names a native group's registration (a one-hop apiservice_takeover edge to cluster_admin), HIGH when resourceNames limits it to an aggregated registration (an edge to traffic_intercept). metrics-server's installer typically holds the unscoped form.
  • KUBE-PRIVESC-037, KUBE-PRIVESC-026, and a node_identity sink. A kubelet client identity (system:node:<name> in system:nodes) gets, from the Node authorizer, the Secrets and ServiceAccount tokens of every pod bound to the node it names, and nothing checks that the caller is a kubelet or that the node exists. Two routes to such an identity for a name of the holder's choosing are now modeled. The controller manager auto-approves a kubelet client CSR when a SubjectAccessReview says the requester may create certificatesigningrequests/nodeclient, without comparing the node name to the requester; that subresource together with create certificatesigningrequests is -037 (HIGH, csr_nodeclient_autoapprove), with the kubeadm bootstrap group exempt as the designed holder. On a cluster whose bootstrap group holds that auto-approval (kubeadm's default, detected from the ClusterRoleBinding), a Secret write reaching kube-system mints a bootstrap.kubernetes.io/token Secret, which is a credential for that group: -026 (HIGH, bootstrap_token_mint). impersonate users paired with impersonate groups scoped to system:nodes is a third, impersonate_node. The sink is traversable: it fans out through node_token_request to every ServiceAccount whose pod mounts an API token on some node, and through node_secret_read to kube_system_secrets when a kube-system pod references a Secret, so a path through it continues to whatever those identities reach. Paths to the sink are KUBE-PRIVESC-PATH-NODE-IDENTITY (HIGH).
  • KUBE-VERSION-CVE-2026-2270: StatefulSet + ControllerRevision confused deputy (version-gated). The Sep 23 2026 advisory (CVSS 3.1 base 5.9) is a confused deputy in the StatefulSet controller: its ApplyRevision restored the whole StatefulSet (metadata and namespace, not just .spec) from a ControllerRevision's strategic-merge patch, so a subject with namespace-scoped write on both statefulsets and controllerrevisions steers kube-controller-manager (which holds cluster-wide pod-create) into creating a pod in a namespace it cannot access, as any ServiceAccount there. The rbac analyzer emits a MEDIUM finding when both write halves are held, and the privesc graph adds a statefulset_cross_namespace_pod edge that fans out to every ServiceAccount cluster-wide plus node_escape. The whole detection is gated on the server version (metadata.cluster_version): it fires only on the affected bands (≤1.34.11 / ≤1.35.8 / ≤1.36.4 / 1.37.0) and stays quiet on the fixed releases (1.34.12 / 1.35.9 / 1.36.5 / 1.37.1) and, fail-closed, on a snapshot with no server version. The band lives in a single tested predicate (internal/kubeversion) shared by the finding and the edge so they cannot drift. The edge is rated hard: beyond both grants, the cross-namespace pod is garbage-collected unless the attacker forges a valid StatefulSet OwnerReference (the advisory's own caveat), so any chain through it is attenuated and drops a severity bucket. Ships with the shared version predicate + tests, a content builder, a glossary technique explainer, unit tests on both the finding and the edge, and a version-pinned corpus case (testdata/corpus/statefulset-deputy-cve) whose only route from the writer to kube-system secrets is the CVE edge. Under --remediation-patches the finding carries a structured hint that removes the controllerrevisions write: the finding is anchored on that half because the controller owns ControllerRevisions and workloads rarely need to write them, and the hint's command leads with the control-plane upgrade, since cutting one subject's grant does not repair kube-controller-manager. The compliance map tags the rule with CIS 5.1.4 (pod creation by another route) and the NSA/CISA patching control.

Changed

  • A --ci-mode gate failure exits with code 2. Every other error still exits with code 1, so a pipeline or an agent can tell "the findings are over budget" from "the scan did not run". A script that only tests for a non-zero exit is not affected.
  • Every finding is listed by default. --max-findings now defaults to 0 (no cut) on scan, report, and scan-resource. It was 20. A first run shows the whole result in report.html, with no banner that says the report is a sample. --all-findings is still accepted, so a script that passes it works as before. The default report.html is larger than before: 8.6 MB against 0.3 MB on the e2e fixture, which is dense on purpose.
  • --max-findings N keeps every attack path in report.html. For a short report, pass a cap. The cap applies to the other findings: the HTML report lists every attack path plus the top N of the rest, and its banner says so (4.5 MB on the e2e fixture with --max-findings 20).

Fixed

  • The default run reports every finding to machines, and shows the attack paths. --max-findings (then 20 by default) cut the findings list before anything was written or counted, so the cut reached far past the HTML findings list:
    • findings.json, triage.csv, and findings.sarif held 20 findings, although this changelog said "the full set remains in findings.json". They now always hold every finding.
    • The category-balanced draw kept no attack path on a dense cluster, because the flat findings that a path amplifies outrank it. On the e2e fixture the default run had 0 of 288 attack paths, and report.html had no Attack paths tab. The tab now always shows every path.
    • The --ci-mode gate and the findings: line counted the 20 (4 critical findings on the fixture, where the cluster has 141). They now count every finding.
    • --baseline and diff compared two 20-finding samples. A finding that entered the sample looked new, and one that left it looked resolved. They now compare complete lists. When a findings file was written by an older version (its truncation-info.json has no "scope": "html"), scan --baseline, diff, and report print a warning that the file is a sample.
    • scan-resource --output-format json printed the capped list. JSON output is now complete, and the cap applies to the table.
      truncation-info.json gains scope (html: only the HTML report is shortened) and attack_paths. It is written only when --max-findings shortens the report, and a run that cuts nothing removes one that an earlier run left in the output directory.
  • Privesc paths no longer confuse holding a ServiceAccount's token with running inside its pods. One graph node stood for both, so any route that reached a ServiceAccount could continue through pod_host_escape from a privileged pod that runs as it. A subject that could only mint the SA's token (token_request), impersonate it, steer a controller that runs as it, or create a new, unprivileged pod as it was reported as reaching node escape through a pod it never entered. Edges now declare the foothold they need and the foothold they give (the SA's API identity, a shell in its existing pods, or a new pod created as it), and path search walks an edge only when the attacker holds one it needs. Exec, attach, ephemeral containers, and namespace-admin still reach an existing pod's host escape. The IMDS pivot now needs code in a pod, existing or new, so a minted token or an impersonation no longer reaches it either.
  • Exec into a pod that mounts no API token no longer hands over the ServiceAccount's RBAC. pod_exec and ephemeral_container_inject edges ignored automountServiceAccountToken. They now give the SA's identity only when one of its pods carries an API token, by the admission plugin's rule (the pod's setting wins, then the ServiceAccount's, then true; a projected serviceAccountToken volume with no audience counts too). A shell in a token-less pod still reaches that pod's own host escape and, on EKS, its IRSA role and IMDS, since the IRSA webhook projects its own token whatever the automount setting is.
  • Impersonating a ServiceAccount, or steering a controller that runs as it, no longer reaches its AWS IAM role. The foothold model split the API identity into acting as the SA versus holding a token for it. sts:AssumeRoleWithWebIdentity needs a signed OIDC token, which impersonation and the confused-deputy operator_reconcile bridge do not mint, so neither reaches the irsa_assume_role edge any more. Minting a token through the TokenRequest API (create serviceaccounts/token), a shell in one of the SA's pods, or a new pod created as it still reach it, since each is or yields a presentable credential.
  • Grants to system:authenticated and system:serviceaccounts[:<ns>] now reach their members in the privesc graph. The API server adds these groups to requests by itself, so no binding lists the members, and path search skipped the group nodes as system: subjects. A binding that gave every ServiceAccount in a namespace list secrets, or gave every authenticated user cluster-admin, produced no path, and the standard exclusions preset hid the flat finding on the group. Each member now has an implicit_group_membership edge to its groups, so the grant shows up as a path from every ServiceAccount (and, for system:authenticated, every User) it reaches, including members reached mid-chain. The remediation hint for such a path drops the group from the binding that grants it. system:unauthenticated is not modeled: only anonymous requests carry it, and no subject in the graph makes them. A conjunction edge whose two halves come one from the member and one from the group (for example create rolebindings on the member and bind on the group) is not detected yet.
  • Workload controllers now have privesc graph edges. KUBE-PRIVESC-003 was a flat finding with nothing behind it in the graph, so a subject that could create deployments but not create pods had no path, even though the Deployment's controller creates the same pods. create on Deployments, DaemonSets, StatefulSets, Jobs, or CronJobs now reaches every ServiceAccount in scope (workload_create_token_theft). update or patch on an existing Deployment, DaemonSet, StatefulSet, or CronJob reaches every ServiceAccount in that workload's namespace, since the writer can re-point the template (workload_hijack). When the workload's own template already has host access and Pod Security admits it, it also reaches that host access. Both reach node escape in a namespace that admits privileged pods (workload_privileged_escape). Jobs are left out of the update edges because a Job's pod template cannot change after creation. resourceNames on an update grant scopes it to the named workloads. The workload edges are added after the pod edges, so a subject that holds both keeps its reported route; the workload edge still counts when the cut-resilient pass removes the pod edge's binding.
  • create pods/exec scoped with resourceNames no longer reaches every workload identity. The exec and ephemeral-container edges were drawn to every ServiceAccount any pod ran as, ignoring resourceNames, so a break-glass grant on one debug pod fabricated a path into every co-located identity. The edges now honor resourceNames: a name-scoped grant reaches only the named pods' ServiceAccounts, while an unrestricted grant is unchanged.
  • The */<subresource> resource form now matches, and pods/* no longer does. The RBAC matcher compared resources by exact name or *, so a rule naming */status, */exec, or */token granted nothing in any check, while upstream ResourceMatches reads */<sub> as that subresource of every resource. A rule with resources: ["*/exec"] now fires KUBE-PRIVESC-004, and */status counts as nodes/status for KUBE-PRIVESC-016. pods/* is still a literal resource name, as upstream treats it. The least-privilege analyzer no longer reports a */<sub> resource as unused because no audit event names it literally. verbs: ["*"] covers prefixed verbs such as impersonate:user-info, and update does not cover them, which the new matcher tests pin.
  • KUBE-PRIVESC-016 now sees every way to cordon a node or remove a pod. The node half accepted only update/patch on nodes/status and delete nodes, but kubectl cordon and kubectl taint patch the main nodes resource. Cluster-scoped update/patch on nodes now counts in the finding and in the node_drain_migrate edge. The pod half adds deletecollection pods and create pods/eviction (the Eviction API) next to delete pods. The finding description and the edge's permission name the grant that matched each half, for example create pods/eviction + patch nodes.
  • Impersonation and bind edges now honor resourceNames. The apiserver authorizes every impersonated name, and the role named by every binding, separately, so a scoped grant reaches only what it names. impersonate groups scoped to other groups no longer reaches system:masters: it gets one new impersonate_group edge per named Group that a binding names. A cluster-scoped impersonate serviceaccounts with resourceNames reaches the SAs with those names in every namespace instead of claiming cluster-admin, and a namespaced grant reaches only the named SAs in its namespace. A bind scoped with resourceNames counts toward the cluster-admin edge only when it names cluster-admin or a ClusterRole with the */*/* triple wildcard, and toward the namespace-admin edge when it names one of those or admin. The CutBreakers on these edges use the same test. The flat KUBE-PRIVESC-008 / -010 findings are unchanged.
  • resourceNames: ["*"] is a literal name. The impersonation and workload-update edges read resourceNames: ["*"] as "every name". Upstream ResourceNameMatches compares names exactly, so the grant names only an object literally called *, and the edges now reach nothing through it.
  • KUBE-PRIVESC-008 now fires on uid and extra impersonation, and on constrained impersonation. impersonate on uids or userextras/<key> in authentication.k8s.io (the Impersonate-Uid and Impersonate-Extra-<key> headers) fires the finding at HIGH. The description explains that these headers need Impersonate-User on the same request and matter only where an authorizer, admission check, or extension API server keys on uid or extras. The KEP-5284 constrained-impersonation verbs (impersonate:user-info, impersonate:serviceaccount, impersonate:arbitrary-node, impersonate:associated-node, beta and on by default in Kubernetes 1.36) also fire it at HIGH, with copy that explains the second impersonate-on:<mode>:<verb> grant they need and that system:masters is refused. Neither shape adds a graph edge. The classic users/groups/serviceaccounts form stays CRITICAL.
  • The GitHub Action works with its default inputs. The action pulled the image tag main by default, a tag the release pipeline never published, so the pull step failed in every workflow that did not set version. The default is now latest. To pin a release, set version to the bare version with no v prefix (for example 1.3.0). Two README examples are corrected too. The docker run example mounted the kubeconfig where the non-root image user does not look for it, and mounted no directory to receive the report. The CI example called scan-resource with a SARIF format, an output directory, and a directory input, and scan-resource has none of the three; it now points to the Action. The action-smoke workflow runs the documented docker run form against a fixture.

Documentation

  • The README demo video shows the new HTML report.
  • README.md and docs/findings.md give the same counts of rule IDs and targets. CONTRIBUTING.md no longer points to files that are not in the repository.

Dependencies

  • k8s.io/api, k8s.io/apimachinery, and k8s.io/client-go 0.37.0 → 0.37.2.