Skip to main content

BentoML CVE-2026-112264

| EUVDEUVD-2026-104309 HIGH
OS Command Injection (CWE-78)
2026-10-19 VulnCheck GHSA-rq23-h86h-7v4x
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft bentofile.yaml with newline in docker.env key
  2. Delivery
    Victim imports bento and runs bentoml containerize
  3. Exploit
    base.j2 renders injected Dockerfile RUN
  4. Execution
    docker build executes attacker instructions
  5. Impact
    Steal build secrets and poison image

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a victim to run bentoml containerize (or an equivalent build) against an attacker-controlled bentofile.yaml or an imported bento archive in which a docker.env mapping key contains an embedded newline, and the build must use the legacy base.j2 Dockerfile template path present in BentoML through 1.4.39. Limiting factors: it is not remotely triggerable (AV:L) and demands user interaction (UI:P) - the target must voluntarily build/containerize untrusted content; impact is maximized only when build secrets are mounted during the docker build and the resulting image is subsequently trusted/deployed. Environments that only build their own first-party bentos are not realistically exposed.

Impact

This is a build-time supply-chain injection flaw (CWE-78) rather than a remotely-triggerable service vulnerability. The only CVSS data provided is a CVSS 4.0 vector (CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H) scoring 8.5/High; no CVSS 3.1 vector, no EPSS score, and no KEV listing were supplied. The signals are internally consistent: AV:L plus UI:P correctly reflects that exploitation requires a victim to locally run bentoml containerize against an attacker-supplied bentofile.yaml or imported bento archive - it is NOT network-reachable or autonomously wormable, which caps real-world mass-exploitation potential. PR:N is accurate in that the attacker needs no privileges on the target, but the attack is gated entirely by the victim choosing to build an untrusted bento. The VC:H/VI:H/VA:H impact is justified because injected RUN instructions execute in the docker build context, exposing build secrets (BuildKit secrets, registry/cloud credentials) and poisoning the resulting image. With no EPSS and no KEV, there is no evidence of widespread or active exploitation; this is a credible, high-impact issue for CI/CD and MLOps pipelines that build third-party bentos, but priority should be scoped to environments that containerize untrusted model packages rather than treated as an internet-facing emergency. The geo-chen and VulnCheck references appear to be technical research write-ups; absent an explicit POC=YES or KEV signal, exploitation maturity should be treated as proof-of-concept/research-grade only.

Exploit ScenarioDerived

An attacker publishes or shares a malicious BentoML package whose docker.env mapping key contains an embedded newline followed by arbitrary Dockerfile directives. A victim engineer or CI pipeline imports the bento and runs bentoml containerize, at which point the legacy base.j2 template renders the injected newline as a new RUN instruction that docker build executes - reading mounted build secrets and backdooring the produced image. No public exploit is flagged in the input, though technical write-ups describing the flaw are referenced.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 19, 2026

BentoML through 1.4.39 renders attacker-controlled docker.env mapping keys into its legacy base.j2 Dockerfile template without neutralizing embedded newline characters, allowing injected Dockerfile instructions - typically RUN commands - to be executed during bentoml containerize builds. A victim must be induced to build or containerize an untrusted bentofile.yaml or imported bento archive, so exploitation is local and interaction-dependent (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) rather than remotely triggerable, but successful builds can expose any secrets mounted into the Docker build context and produce poisoned images that downstream users trust and deploy. No public exploit code or confirmed active exploitation was identified at time of analysis; realistic exposure is limited to teams that containerize third-party or otherwise untrusted bento content.

RemediationAI

No vendor-released patch was identified at time of analysis, so teams should treat untrusted bento content as executable. The primary compensating control is to stop containerizing untrusted inputs: refuse to run bentoml containerize or bentoml import against bentofile.yaml or bento archives that were not produced in-house, since importing a third-party bento directly supplies the malicious docker.env mapping. Where untrusted builds are unavoidable, add a pre-build validation step that rejects any docker.env key not matching a strict identifier pattern (e.g. ^[A-Za-z_][A-Za-z0-9_]*$) or containing newline, carriage-return, or whitespace characters; this is a small scripted gate but must be applied consistently before generate.py renders the template, and it will break legitimate configurations that rely on unusual key names. Avoid the legacy base.j2 template path where a newer template is available in your version, and never expose build credentials through environment variables or build args during containerization - use BuildKit secret mounts scoped to a single RUN, which limits the blast radius if injection still succeeds, at the cost of additional build plumbing. Run bentoml containerize builds in an isolated builder with no network egress and no host-mounted credentials, and scan the resulting Dockerfile and image history for unexpected RUN layers before publishing. Monitor the vendor repository (https://github.com/bentoml/BentoML) and the VulnCheck advisory for a patched release and upgrade as soon as one is published.

Affected VersionsENISA

BentoML 0 ≤1.4.39

Affected Packages

euvd bentoml no fix

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 flaw is an OS command injection (CWE-78) that manifests in the generated Dockerfile rather than in a running service. BentoML's build pipeline parses docker.env entries from bentofile.yaml in src/bentoml/_internal/bento/build_config.py, then src/bentoml/_internal/container/generate.py renders those key/value pairs into the Dockerfile templates under src/bentoml/_internal/container/frontend/dockerfile/templates/ - with the legacy base.j2 template used by the bentoml containerize entry point in src/bentoml/_internal/container/__init__.py. Because only values were treated as untrusted, a mapping key containing an embedded newline terminates the intended environment-variable line and starts a new, attacker-authored Dockerfile instruction. Docker then faithfully executes the injected RUN step as part of the build, in the build container's privilege and secret context. The result is a build-time supply-chain primitive: an attacker who can deliver a crafted bentofile.yaml or a malicious bento archive can influence the final image contents and any credentials, tokens, or SSH keys exposed to the builder. The CPE cpe:2.3:a:bentoml:bentoml:*:*:*:*:*:*:*:* covers all BentoML releases, with the advisory scoping the issue to versions through 1.4.39 and the legacy template path.

Know when Bentoml 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 (VulnCheck) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

AV:L and UI:R because a victim must locally containerize an attacker-supplied bento; PR:N as the attacker needs no account; C/I/A:H from secret theft and image poisoning in the build context.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

BentoML through 1.4.39 contains a Dockerfile instruction injection vulnerability that allows attackers to add arbitrary build instructions by embedding newlines in docker.env mapping keys rendered by the legacy base.j2 template. Attackers can supply a crafted bentofile.yaml or imported bento archive so that bentoml containerize executes injected RUN instructions during docker build, accessing build secrets and poisoning images.

Executive ViewAI

Why It Matters

BentoML releases through 1.4.39 can be tricked into writing attacker-supplied instructions into the Dockerfile it generates during bentoml containerize, so a routine packaging step can silently execute foreign commands and bake them into the resulting image. The damage is supply-chain shaped: credentials present in the build context can be captured, and the poisoned image is then trusted and deployed by downstream teams. Leadership should care less about the breadth of exposure - a build must be deliberately run against untrusted bento content - and more about the asymmetry: one careless import of an external model package can propagate a compromised artifact into production where it is difficult to trace back.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: build only internally authored bentofile.yaml and vetted bento archives, treat any imported or third-party bento as untrusted code requiring review, keep secrets out of the Docker build context and supply them through scoped build-time secret mounts, and inspect the generated Dockerfile for injected RUN instructions before any image is pushed to a shared registry.

Threat Intelligence Overview

EPSS Score
0.2%
Top 88% exploitable
Prevalence
Medium
popular open-source ML serving framework, common in MLOps but not universal
Social Media
1
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact
Medium
Technical Impact
Total

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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