BentoML
CVE-2026-27905
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious bento/model tar with escaping symlink
-
DeliveryPublish or deliver artifact to victim
-
ExploitVictim pulls and extracts via BentoML
-
Executionopen() follows symlink target on write
-
ImpactArbitrary file write on host filesystem
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Symlink resolution safety
|
| Exploitation Conditions | Exploitation requires the victim to pull/import and extract an attacker-crafted bento or model tar through BentoML's extraction routine safe_extract_tarfile() (invoked from cloud/bento.py:542 and cloud/model.py:504); the malicious archive must contain a symlink whose target escapes the destination directory followed by a regular file written through it. This affects all versions prior to 1.4.36 in their default behavior - no special configuration toggle is needed. The key limiting factor is that the attacker does not need credentials on the target host (PR:N) but DOES need the victim to ingest the malicious artifact, so exploitation hinges on a supply-chain/social delivery step rather than direct remote access; it is not reachable against an idle BentoML installation that never imports an untrusted bento/model. |
| Impact | Signals are mixed and point to a real-but-not-urgent issue. The flaw is a genuine arbitrary file write (CWE-59 symlink following) confirmed by the vendor's GHSA advisory and fixed in 1.4.36, and public exploit code exists (a working PoC is embedded in the GHSA). However, EPSS is only 0.01% (0th percentile) and the CVE is NOT in CISA KEV, indicating no evidence of widespread automated exploitation - consistent with a supply-chain-style flaw that requires a victim to import an attacker-crafted bento/model artifact rather than a remotely sprayable bug. The two CVSS representations conflict on the delivery vector and must be reconciled: the NVD CVSS 4.0 vector states AV:L/UI:N (local, no user interaction) while the vendor GHSA CVSS 3.1 vector states AV:N/UI:R (network-delivered artifact requiring user action to extract). The AV:L framing is misleading - the realistic path is an attacker-supplied tar pulled from a registry/peer and then extracted, which is better modeled as AV:N/UI:R; verify intended threat model with the vendor. Both representations agree exploitation needs no privileges on the target (PR:N) and that integrity impact is high. Net: moderate real-world priority - patch promptly where BentoML ingests untrusted bentos/models, but this is more a targeted/supply-chain risk than a mass-exploited one given low EPSS and no KEV listing. |
| Exploit ScenarioDerived | An attacker publishes or shares a malicious bento/model packaged as a tar containing a symlink that points outside the extraction directory (e.g. to /etc or a Python site-packages path), followed by a regular file that writes through that symlink. When a victim pulls and extracts the artifact via BentoML's cloud bento/model import path, open() follows the symlink and writes attacker-controlled content to an arbitrary host location, which can escalate to code execution by overwriting a config or script. A working proof-of-concept is published in the GHSA advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 07, 2026
Arbitrary file write in BentoML allows an attacker-supplied bento or model tar archive to escape the extraction directory and overwrite files anywhere the BentoML process can write, affecting all versions prior to 1.4.36. The victim must import or pull the malicious artifact (CVE CVSS 3.1 base 8.1: AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H), so no credentials or direct network access to the host are needed, but the supply-chain ingestion step is mandatory - an idle installation that never processes an untrusted bento or model is not exposed. Publicly available exploit code exists, exploit-maturity scoring is minimal (EPSS 0.01%, 0th percentile) and there is no indication of confirmed active exploitation (no CISA KEV listing); the issue is real but not urgent, and a vendor patch exists in 1.4.36.
Earlier versions of this analysis (1)
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. [CVSS 7.8 HIGH]
RemediationAI
Upgrade to BentoML 1.4.36, which is the vendor-released patch incorporating upstream commit https://github.com/bentoml/BentoML/commit/4e0eb007765ac04c7924220d643f264715cc9670 and documented in GHSA-m6w7-qv66-g3mf; there is no backport path for older lines, so pinning bentoml>=1.4.36 is the primary fix. If immediate upgrade is impossible, treat all bento/model tar artifacts as untrusted input: perform extraction inside a disposable container or sandbox with a read-only or narrowly scoped writable mount so a symlink escape cannot reach sensitive paths, run the BentoML process as an unprivileged account whose filesystem write scope excludes /etc, /root, and application secrets, and pre-screen archives (for example with tar -tvf or a Python script walking tarfile members) rejecting any SYMTYPE/LNKTYPE member whose linkname resolves outside the extraction root - accepting that this is a manual gate that will block legitimate archives containing internal relative symlinks and can be bypassed by archive format quirks if not applied consistently. Note that the exploit requires the victim to ingest an attacker-crafted archive, so tightening provenance of remote bento/model sources and requiring signed or checksummed artifacts materially reduces exposure; monitoring for unexpected writes or symlink creation during extraction gives detection coverage. Because exploit code is publicly available, prioritize the upgrade for any environment that routinely pulls third-party bentos or models, while noting the low EPSS (0.01%) and absence of confirmed in-the-wild exploitation keep this below emergency patching thresholds.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a classic link-following (CWE-59) defect inside BentoML's tar handling helper safe_extract_tarfile() in src/bentoml/_internal/utils/filesystem.py, which is reached from the cloud artifact import paths src/bentoml/_internal/cloud/bento.py:542 and src/bentoml/_internal/cloud/model.py:504. The original code validated each tar member with os.path.abspath(os.path.join(destination, fn)) and Path(path).is_relative_to(destination), but because os.path.abspath only normalizes '.' and '..' and does not resolve symlinks, a member of type SYMTYPE whose own path is inside the destination could carry a linkname pointing outside it, for example to /etc. The extraction loop then created that symlink verbatim via tar._extract_member() and, on a subsequent regular-file member, opened the destination path with open(path, 'wb'), which transparently follows the symlink and writes through it to the attacker-chosen target. The upstream fix (commit 4e0eb007) resolves the destination with os.path.realpath, normalizes and validates each symlink's target against the real destination before creation, and re-checks os.path.realpath(path) before opening a file for writing, closing both the symlink-creation and write-through halves of the chain. BentoML is a Python framework for packaging and serving AI models; the archive is the natural distribution format, so this is fundamentally a software supply-chain weakness in model/bento ingestion rather than a remotely reachable service flaw.
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
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Malicious artifact is delivered over network and must be imported by the victim (AV:N/UI:R, PR:N); arbitrary file write gives high integrity/availability impact but no direct read, so C:N.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
5DescriptionCVE.org
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Prior to 1.4.36, the safe_extract_tarfile() function validates that each tar member's path is within the destination directory, but for symlink members it only validates the symlink's own path, not the symlink's target. An attacker can create a malicious bento/model tar file containing a symlink pointing outside the extraction directory, followed by a regular file that writes through the symlink, achieving arbitrary file write on the host filesystem. This vulnerability is fixed in 1.4.36.
Executive ViewAI
BentoML versions prior to 1.4.36 are affected by a high-severity arbitrary file write that can be triggered when a user imports or pulls a malicious bento or model archive, enabling files to be overwritten anywhere the BentoML process can write. Organizations that use BentoML in ML supply chains to ingest third-party or untrusted artifacts are exposed to host compromise, data corruption, or service disruption, while idle installations that never process untrusted artifacts are not exposed. Publicly available exploit code exists, so security leadership should prioritize patching to 1.4.36 and tightening artifact ingestion controls even though EPSS is low and no CISA KEV listing is present.
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
Affected Products (CPE)CVE.org
BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica
BentoML through 1.4.39 renders attacker-controlled docker.env mapping keys into its legacy base.j2 Dockerfile template w
BentoML versions prior to 1.4.34 allow path traversal attacks through improperly validated file path fields in bentofile
Server-Side Request Forgery in BentoML versions 1.4.19 through 1.4.39 exposes internal CGNAT infrastructure by failing t
Command injection in bentoml OpenLLM 0.6.30 allows local low-privilege users to execute arbitrary shell commands by supp
GHSA-m6w7-qv66-g3mf
NVD
CVE.org
EPSS
Exploit-DB