Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain tenant workspace token
-
DeliverySubmit image build with crafted RUN command
-
ExploitBuildah runs under chroot sharing worker namespaces
-
ExecutionAccess writable /proc/1/root as uid 0 with CAP_DAC_OVERRIDE
-
PersistSteal service account token and overwrite worker runc binary
-
ImpactCompromise privileged worker pod, node, and cluster
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Component isolation
|
| Exploitation Conditions | Requires a valid tenant workspace token (authenticated, PR:L) on a Beta9 deployment running an affected worker (before 0.1.756); no user interaction is needed. Exploitation works against the DEFAULT configuration: Clip v2 layered builds are the default, the worker image sets BUILDAH_ISOLATION=chroot, no buildah invocation passes --isolation, and worker pods are privileged, so a single image build containing a shell RUN command is sufficient. The concrete prerequisite is that Buildah RUN steps execute with chroot-only isolation sharing the worker pod's PID/network/IPC/user namespaces as uid 0 with CAP_DAC_OVERRIDE. Limiting factors: the attacker must already be able to submit builds in a workspace (tenant-level auth), and deployments on worker 0.1.756+ are not exploitable because RUN steps then use OCI isolation with private PID/IPC/network namespaces and tenant ARG values are passed only into the build container. |
| Impact | This is a genuine high-priority issue, not a CVSS-inflated one. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H = 9.9) is well supported by the described mechanism: a tenant holding only a workspace token submits a single image build and, because Buildah RUN steps run under BUILDAH_ISOLATION=chroot with no --isolation override, the step shares the worker pod's PID/network/IPC/user namespaces, runs as uid 0, and holds CAP_DAC_OVERRIDE, making /proc/1/root (the worker container filesystem, including runc/buildah/runsc binaries, the worker's Kubernetes service account token, and host mounts) readable and writable - a scope-changing escape from the intended build sandbox into the privileged worker pod and node. The vuln.today decision label is act_now and JFrog reported it with a read-only proof that confirmed the shared namespaces, CAP_DAC_OVERRIDE, and visibility of the worker's runc binary at /proc/1/root, so the core preconditions are verified rather than inferred. Signals that would normally raise or confirm urgency further are missing from the input: no EPSS probability is provided, the CVE is not listed in CISA KEV, and no public exploit-code reference is supplied, so there is no evidence of active or widespread exploitation despite the act_now label. Net: authenticated-tenant-to-node/cluster compromise in the default configuration of a multi-tenant build platform - high real risk for any exposed Beta9 deployment, with the main uncertainty being exploitation likelihood in the wild rather than exploitability itself. |
| Exploit ScenarioDerived | A tenant who possesses a valid workspace token submits one image build whose definition contains a shell command; Beta9 turns that command into a Dockerfile RUN line and executes it with Buildah under chroot-only isolation. Because the RUN step keeps the worker pod's namespaces and runs as uid 0 with CAP_DAC_OVERRIDE, the command reads the worker's Kubernetes service account token and overwrites the worker's runc/buildah binaries via the writable /proc/1/root, pivoting from the build sandbox to the privileged worker pod and the underlying node. No public exploit code is referenced, but JFrog's read-only proof confirmed the enabling conditions, and AV:N/AC:L/PR:L/UI:N means exploitation needs only a low-privilege tenant and a default-configuration build submission. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
Beta9 worker images before 0.1.756 execute every Buildah RUN step from a tenant-supplied image definition with chroot-only isolation, so a build submitted with an ordinary workspace token runs as uid 0 inside the worker pod's PID, network, IPC and user namespaces while retaining CAP_DAC_OVERRIDE. Because /proc/1/root resolves to the worker container's writable filesystem, that tenant build can reach the runc, buildah and runsc binaries the worker uses to launch other tenants' containers, the worker's Kubernetes service account token, and host directories mounted into the privileged pod, giving scope-changed confidentiality, integrity and availability impact (CVSS 9.9, S:C). The reporter documented a read-only proof confirming the shared namespaces and the worker's runc binary at /proc/1/root; no public exploit code is confirmed, and the vendor shipped the fix in worker 0.1.756.
RemediationAI
Upgrade the Beta9 worker to 0.1.756, the version in which Buildah RUN steps switch to BUILDAH_ISOLATION=oci with private PID, IPC and network namespaces, tenant ARG values are scoped to the build container, and volume validation is added; the release is published at https://github.com/beam-cloud/beta9/releases/tag/worker-0.1.756 and the changes are in https://github.com/beam-cloud/beta9/pull/1897 and https://github.com/beam-cloud/beta9/commit/a28bf12cf0007c792a25d8ed282b4e8bf6f30393. Prioritize this upgrade immediately for any multi-tenant deployment: the vendor's fix is the complete remediation and the affected configuration is the default, so there is no configuration switch documented in the available sources that removes the exposure, and note that the new isolation mode requires the containernetworking-plugins package now installed in the worker image, so rebuilding from the patched Dockerfile.worker rather than only bumping a tag avoids a worker that cannot start private-network build steps. Where the upgrade must be staged, the only evidence-based compensating control is reducing who can trigger builds, since exploitation requires a valid workspace token able to submit an image build: temporarily revoke or restrict workspace tokens permitted to submit builds on workers below 0.1.756, accepting that this halts legitimate image builds for those tenants. Rotating the worker's Kubernetes service account token is prudent for any worker below 0.1.756 that has processed builds from untrusted tenants, because the token is readable from the exposed filesystem.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-653, improper isolation or compartmentalization: Beta9 translates each shell command in a tenant image definition into a Dockerfile RUN line and hands it to Buildah on the build worker, but the worker image pins BUILDAH_ISOLATION=chroot and no buildah invocation passes --isolation, so the step only re-roots its filesystem and continues to share the worker pod's PID, network, IPC and user namespaces. Under chroot isolation the build process remains uid 0 with CAP_DAC_OVERRIDE, and because PID 1 in that procfs is the worker entrypoint, /proc/1/root is a writable handle on the worker container's own filesystem (and on the host directories bind-mounted into the privileged pod). Those contents include the runc, buildah and runsc binaries the worker relies on to start tenant containers plus the worker's Kubernetes service account token, so the tenant build step sits in the same trust boundary as the container runtime itself. Clip v2 layered builds are the default, so the tenant only needs one image build to reach this state; the CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C) reflects remote reachability, low complexity, tenant-level authentication and a scope change out of the build sandbox. Worker 0.1.756 flips BUILDAH_ISOLATION to oci so RUN steps, including the WORKDIR mkdir, get private PID, IPC and network namespaces, adds containernetworking-plugins so buildah run --network=private can construct its bridge from the CNI plugins, passes tenant ARG values only into the build container, and adds a ValidateVolume check that rejects volume ids containing '/' or '..' and mount paths containing '..' segments, re-validating volumes persisted before validation existed and requiring that a mounted volume id be owned by the calling workspace.
Know when Kubernetes gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
Authenticated tenant (PR:L) submits a build over the API (AV:N/AC:L/UI:N); chroot-only isolation breaks the build sandbox to reach the privileged worker pod and node (S:C) with full read/write and binary-replacement (C:H/I:H/A:H).
Primary rating from Vendor (JFROG).
CVSS VectorVendor: JFROG
DescriptionCVE.org
Beta9 turns each shell command in a tenant image definition into a Dockerfile RUN line and executes it with Buildah on the build worker. The worker image sets BUILDAH_ISOLATION=chroot, and no buildah invocation passes --isolation, so the step only changes its filesystem root. It keeps the worker pod's PID, network, IPC, and user namespaces, runs as uid 0, and holds CAP_DAC_OVERRIDE. PID 1 in that procfs is the worker entrypoint, so /proc/1/root is the worker container's filesystem and is writable. That filesystem contains the runc, buildah, and runsc binaries the worker uses to start tenant containers, the worker's Kubernetes service account token, and the host directories mounted into the pod. Worker pods are privileged. Clip v2 layered builds are the default, so a tenant with a workspace token reaches this by submitting one image build. The read-only proof confirmed the shared namespaces, CAP_DAC_OVERRIDE, and that the worker's runc binary is visible at /proc/1/root. Fixed in worker 0.1.756: Buildah RUN steps, including the WORKDIR mkdir, use OCI isolation with private PID, IPC, and network namespaces, and tenant ARG values are passed only into the build container.
Articles & Coverage 1
Executive ViewAI
CVE-2026-120306 is a critical vulnerability in Beta9 worker images before version 0.1.756 that allows any tenant with a workspace token to execute arbitrary code with root privileges inside the worker pod, potentially compromising other tenants' containers and sensitive cluster resources. This undermines the platform's multi-tenant isolation, putting customer data and workloads at risk and exposing the organization to regulatory scrutiny and reputational harm.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Kubernetes
View allA critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access
Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio
Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c
Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter
A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate
Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne
Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai
The Kubernetes integration in GitLab Enterprise Edition 11.x before 11.2.8, 11.3.x before 11.3.9, and 11.4.x before 11.4
Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can
Authenticated Typebot users can abuse the webhook block (HTTP Request component) in versions prior to 3.13.1 to issue ar
EUVD-2026-114840
GHSA-xvhg-75x6-gj86
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB