Skip to main content

Beta9 Worker CVE-2026-120306

| EUVDEUVD-2026-114840 CRITICAL
Improper Isolation or Compartmentalization (CWE-653)
2026-11-01 JFROG GHSA-xvhg-75x6-gj86
9.9
CVSS 3.1 · Vendor: JFROG
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain tenant workspace token
  2. Delivery
    Submit image build with crafted RUN command
  3. Exploit
    Buildah runs under chroot sharing worker namespaces
  4. Execution
    Access writable /proc/1/root as uid 0 with CAP_DAC_OVERRIDE
  5. Persist
    Steal service account token and overwrite worker runc binary
  6. Impact
    Compromise 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Beta9 worker 0 <0.1.756

Affected Packages

euvd beta9_worker fix: 0.1.756

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

Vendor (JFROG) PRIMARY 9.9 CRITICAL
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 9.9 CRITICAL

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).

3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H

Primary rating from Vendor (JFROG).

CVSS VectorVendor: JFROG

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

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.

Executive ViewAI

Why It Matters

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.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Low
niche open-source serverless/GPU container platform, limited enterprise deployment footprint
Social Media
3
Sightings
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
Very High
Technical Impact
Total

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

CVE-2025-1974 CRITICAL POC
9.8 Mar 25

A critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access

CVE-2026-45321 CRITICAL POC
9.6 May 12

Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio

CVE-2025-1098 HIGH POC
8.8 Mar 25

Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress

CVE-2025-24514 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres

CVE-2025-1097 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c

CVE-2020-8554 MEDIUM POC
6.3 Jan 21

Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter

CVE-2023-3676 HIGH POC
8.8 Oct 31

A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate

CVE-2025-55190 CRITICAL POC
9.9 Sep 04

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne

CVE-2026-34976 CRITICAL POC
10.0 Apr 02

Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai

CVE-2018-18843 CRITICAL POC
10.0 Dec 04

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

CVE-2026-54680 CRITICAL POC
9.9 Jul 29

Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can

CVE-2025-64709 CRITICAL POC
9.9 Nov 13

Authenticated Typebot users can abuse the webhook block (HTTP Request component) in versions prior to 3.13.1 to issue ar

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy