Repository navigation
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
scanprints the attack paths in the terminal. After thefindings:line,scanandreportprint 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 theactionvalues infindings.json. Thefindings:line is unchanged.- SARIF results carry the hop chain. An attack-path result now has
properties.escalation_path, andproperties.alternate_escalation_pathwhen 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.scanwrites a report.pathsanswers in the terminal:--to cluster-adminlists who can reach a target,--from ServiceAccount/dev/cilists what one identity can reach, and--verboseshows 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 asscan, so each path has the ID, score, and hops of the finding in the report.--output-format jsonprints a short record for each path plustotalandreturnedcounts (about 1 KB for each path, where a full finding is about 7.5 KB). With--fromthe exclusions do not apply, and the source can be an identity thatscannever starts from: a built-insystem:identity, a control-plane ServiceAccount, or an implicit group such asGroup/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 withpaths --output-format json, explain each hop, and propose the smallest RBAC change without a change to the cluster. Install withclaude plugin marketplace add 0hardik1/kubesplaining, thenclaude plugin install kubesplaining@kubesplaining. The skill uses only the fields of the open format, so other agents that readSKILL.mdfiles can use the directoryplugins/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, andpaths --diff.--overlay <file|dir|->applies manifests on top of a snapshot in memory, and--overlay-delete Kind/[namespace/]nameremoves one object.paths --diffthen 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 akubectlcommand, 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.scantakes the same flags and marks its report as a what-if result. Theattack-pathsskill 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.createonpods/binding(or the legacybindingsresource) 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 setsspec.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 onlyNoExecute, so the control-planeNoScheduletaint 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 onpods/bindingCREATE 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.ioClusterPolicies or Policies steers the Kyverno background controller (or the singlekyvernoServiceAccount on releases before 1.10) into creating any resource ageneraterule names, RoleBindings and pods included, or rewriting existing objects throughmutateExisting, with the controller's own cluster-wide permissions. A namespaced Policy is enough, because generate rules still run as the controller. Theoperator_reconcilebridge fires only when the controller ServiceAccount exists in the snapshot, as for every other catalogued operator. KUBE-PRIVESC-034:update/patchon pods swaps container images inside running pods. The API server's pod update validation deliberately keepsspec.containers[*].imageandspec.initContainers[*].imagemutable on a live pod, and the kubelet restarts the container with the new image inside the same pod sandbox: same ServiceAccount token mount, samesecurityContext, 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 onpods, which the built-ineditClusterRole and many label-patching operator roles carry, the same reach aspods/exec(-004) andpods/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 carriescreatekeeps its -001 framing), and the privesc graph draws apod_image_hijackedge from the holder to every ServiceAccount that pods in scope run as, honoringresourceNamesand 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 thepod-security.kubernetes.io/enforcelabel on the Namespace object at admission time, and nothing in-tree protects that label. A subject that canupdate/patchthe namespace and create pods in it relabels the namespace toprivilegedand 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 arestrictednamespace 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-inadmin/editClusterRoles, so it arrives through custom roles for namespace self-service, GitOps, or quota tooling; and a namespaced Role grantingpatch namespacesreaches 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 isbaselineorrestricted(the pod half iscreate pods,createon a workload kind, orupdate/patchon a workload that exists there), anchored on the namespace write. The privesc graph adds anamespace_psa_label_flipedge tonode_escape, a two-write conjunction withCutBreakersfor 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 topod-security.kubernetes.io/*labels, and set a cluster-wide PSA default so a removed label does not fall back toprivileged. Compliance tags: CIS 5.2.1 and the NSA/CISA Pod Security and Authorization controls.KUBE-PRIVESC-036and atraffic_interceptsink:pods/statuswrites steer Service traffic. A Service's backends are the addresses its selected pods report instatus.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 withupdate/patchonpods/statusfor 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 apod_status_ip_spoofedge per Service whose selector matches a live pod in scope. The hop ishardby default (the kubelet corrects the status every 10 seconds) andmoderatewhen a selected Service publishes not-ready addresses and a selected pod has no node, where nothing corrects it. Paths to the sink areKUBE-PRIVESC-PATH-TRAFFIC-INTERCEPT(HIGH, lateral movement).KUBE-PRIVESC-021andKUBE-PRIVESC-022: EndpointSlice and Service writes steer Service traffic. kube-proxy consumes every EndpointSlice that carries a Service'skubernetes.io/service-namelabel whatever itsmanaged-bylabel 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-ineditClusterRole carriesupdate services,-022fires 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 intotraffic_intercept(endpointslice_write,service_backend_rewrite), with the same tenant gating for the Service edge. Writes on the legacy coreendpointsresource 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'scaBundlewith 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) isKUBE-PRIVESC-038: CRITICAL when the backend is a mutating webhook on pods CREATE or a native-group APIService, HIGH otherwise. The privesc graph drawscontrol_plane_backend_hijackedges to the sink the backend's kind decides (node_escapefor a pod-rewriting mutating webhook,cluster_adminfor a native-group APIService,traffic_interceptfor the rest), with both halves as cut breakers. A backend with nocaBundleis skipped, since the host's system roots cannot be satisfied from in-cluster material, and an APIService withinsecureSkipTLSVerifyneeds no TLS half. The practical consequence: the built-ineditandadminClusterRoles 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-020reports who can rewrite them. The collector listsapiregistration.k8s.ioAPIServices through the dynamic client (no kube-aggregator dependency) into a reducedapi_servicessnapshot field: name, group, version,spec.service,insecureSkipTLSVerify, whether acaBundleis set, and theautomanagedlabel. The manifest loader acceptsAPIServicedocuments. Cluster-scopedupdate/patchonapiservicesre-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-hopapiservice_takeoveredge tocluster_admin), HIGH whenresourceNameslimits it to an aggregated registration (an edge totraffic_intercept). metrics-server's installer typically holds the unscoped form. KUBE-PRIVESC-037,KUBE-PRIVESC-026, and anode_identitysink. A kubelet client identity (system:node:<name>insystem: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 maycreate certificatesigningrequests/nodeclient, without comparing the node name to the requester; that subresource together withcreate certificatesigningrequestsis-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 abootstrap.kubernetes.io/tokenSecret, which is a credential for that group:-026(HIGH,bootstrap_token_mint).impersonate userspaired withimpersonate groupsscoped tosystem:nodesis a third,impersonate_node. The sink is traversable: it fans out throughnode_token_requestto every ServiceAccount whose pod mounts an API token on some node, and throughnode_secret_readtokube_system_secretswhen a kube-system pod references a Secret, so a path through it continues to whatever those identities reach. Paths to the sink areKUBE-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: itsApplyRevisionrestored the whole StatefulSet (metadata and namespace, not just.spec) from a ControllerRevision's strategic-merge patch, so a subject with namespace-scoped write on bothstatefulsetsandcontrollerrevisionssteers 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 astatefulset_cross_namespace_podedge that fans out to every ServiceAccount cluster-wide plusnode_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 ratedhard: 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-patchesthe finding carries a structured hint that removes thecontrollerrevisionswrite: 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-modegate 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-findingsnow defaults to0(no cut) onscan,report, andscan-resource. It was20. A first run shows the whole result inreport.html, with no banner that says the report is a sample.--all-findingsis still accepted, so a script that passes it works as before. The defaultreport.htmlis larger than before: 8.6 MB against 0.3 MB on the e2e fixture, which is dense on purpose. --max-findings Nkeeps every attack path inreport.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, andfindings.sarifheld 20 findings, although this changelog said "the full set remains infindings.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.htmlhad no Attack paths tab. The tab now always shows every path. - The
--ci-modegate and thefindings:line counted the 20 (4 critical findings on the fixture, where the cluster has 141). They now count every finding. --baselineanddiffcompared 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 (itstruncation-info.jsonhas no"scope": "html"),scan --baseline,diff, andreportprint a warning that the file is a sample.scan-resource --output-format jsonprinted the capped list. JSON output is now complete, and the cap applies to the table.
truncation-info.jsongainsscope(html: only the HTML report is shortened) andattack_paths. It is written only when--max-findingsshortens 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_escapefrom 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_execandephemeral_container_injectedges ignoredautomountServiceAccountToken. 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, thentrue; a projectedserviceAccountTokenvolume 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:AssumeRoleWithWebIdentityneeds a signed OIDC token, which impersonation and the confused-deputyoperator_reconcilebridge do not mint, so neither reaches theirsa_assume_roleedge 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:authenticatedandsystem: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 assystem:subjects. A binding that gave every ServiceAccount in a namespacelist 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 animplicit_group_membershipedge to its groups, so the grant shows up as a path from every ServiceAccount (and, forsystem: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:unauthenticatedis 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 examplecreate rolebindingson the member andbindon the group) is not detected yet. - Workload controllers now have privesc graph edges.
KUBE-PRIVESC-003was a flat finding with nothing behind it in the graph, so a subject that couldcreate deploymentsbut notcreate podshad no path, even though the Deployment's controller creates the same pods.createon Deployments, DaemonSets, StatefulSets, Jobs, or CronJobs now reaches every ServiceAccount in scope (workload_create_token_theft).updateorpatchon 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.resourceNameson 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/execscoped withresourceNamesno longer reaches every workload identity. The exec and ephemeral-container edges were drawn to every ServiceAccount any pod ran as, ignoringresourceNames, so a break-glass grant on one debug pod fabricated a path into every co-located identity. The edges now honorresourceNames: a name-scoped grant reaches only the named pods' ServiceAccounts, while an unrestricted grant is unchanged.- The
*/<subresource>resource form now matches, andpods/*no longer does. The RBAC matcher compared resources by exact name or*, so a rule naming*/status,*/exec, or*/tokengranted nothing in any check, while upstreamResourceMatchesreads*/<sub>as that subresource of every resource. A rule withresources: ["*/exec"]now firesKUBE-PRIVESC-004, and*/statuscounts asnodes/statusforKUBE-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 asimpersonate:user-info, andupdatedoes not cover them, which the new matcher tests pin. KUBE-PRIVESC-016now sees every way to cordon a node or remove a pod. The node half accepted onlyupdate/patchonnodes/statusanddelete nodes, butkubectl cordonandkubectl taintpatch the mainnodesresource. Cluster-scopedupdate/patchonnodesnow counts in the finding and in thenode_drain_migrateedge. The pod half addsdeletecollection podsandcreate pods/eviction(the Eviction API) next todelete pods. The finding description and the edge'spermissionname the grant that matched each half, for examplecreate pods/eviction + patch nodes.- Impersonation and
bindedges now honorresourceNames. The apiserver authorizes every impersonated name, and the role named by every binding, separately, so a scoped grant reaches only what it names.impersonate groupsscoped to other groups no longer reachessystem:masters: it gets one newimpersonate_groupedge per named Group that a binding names. A cluster-scopedimpersonate serviceaccountswithresourceNamesreaches 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. Abindscoped withresourceNamescounts toward the cluster-admin edge only when it namescluster-adminor a ClusterRole with the*/*/*triple wildcard, and toward the namespace-admin edge when it names one of those oradmin. TheCutBreakerson these edges use the same test. The flatKUBE-PRIVESC-008/-010findings are unchanged. resourceNames: ["*"]is a literal name. The impersonation and workload-update edges readresourceNames: ["*"]as "every name". UpstreamResourceNameMatchescompares names exactly, so the grant names only an object literally called*, and the edges now reach nothing through it.KUBE-PRIVESC-008now fires on uid and extra impersonation, and on constrained impersonation.impersonateonuidsoruserextras/<key>inauthentication.k8s.io(theImpersonate-UidandImpersonate-Extra-<key>headers) fires the finding at HIGH. The description explains that these headers needImpersonate-Useron 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 secondimpersonate-on:<mode>:<verb>grant they need and thatsystem:mastersis 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
mainby default, a tag the release pipeline never published, so the pull step failed in every workflow that did not setversion. The default is nowlatest. To pin a release, setversionto the bare version with novprefix (for example1.3.0). Two README examples are corrected too. Thedocker runexample 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 calledscan-resourcewith a SARIF format, an output directory, and a directory input, andscan-resourcehas none of the three; it now points to the Action. Theaction-smokeworkflow runs the documenteddocker runform against a fixture.
Documentation
- The README demo video shows the new HTML report.
README.mdanddocs/findings.mdgive the same counts of rule IDs and targets.CONTRIBUTING.mdno longer points to files that are not in the repository.
Dependencies
k8s.io/api,k8s.io/apimachinery, andk8s.io/client-go0.37.0 → 0.37.2.