Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim runs agentflow serve on localhost
-
DeliveryLure victim to malicious web page
-
ExploitPage POSTs pipeline_path to /api/runs
-
ExecutionAPI loads referenced local .py pipeline
-
PersistPython pipeline executes as user
-
ImpactCode execution in AgentFlow context
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the AgentFlow local web API to be running (agentflow serve, bound to 127.0.0.1:8000) and a request to POST /api/runs or POST /api/runs/validate that supplies a pipeline_path pointing to an existing Python pipeline file on disk - the endpoint executes a .py file already present, not attacker-uploaded source, so a malicious or abusable pipeline file must already exist locally. Exploitation is limited by several factors: the attacker must induce a request to the localhost-bound API (CVSS UI:P/AT:P - passive user interaction such as a victim visiting a malicious page, plus a passive attack requirement), the target must be on a vulnerable pre-1667fa3 build, and on patched builds path loading is disabled unless the operator has explicitly set AGENTFLOW_API_ALLOW_PIPELINE_PATH=1 and sends application/json. |
| Impact | The signals are consistent and point to a real-but-not-urgent issue. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H, score 7.7 High) reflects total confidentiality/integrity/availability impact but with a passive attack requirement (AT:P) and passive user interaction (UI:P), meaning exploitation is not fully attacker-at-will. SSVC reinforces this: Exploitation is none, Automatable is no, and Technical Impact is total. EPSS is very low at 0.04% (14th percentile), and the CVE is not on CISA KEV, so there is no evidence of active exploitation. The practical limiting factor the raw score understates is that the endpoint executes an existing Python file on disk rather than attacker-supplied source, and the API binds to localhost - so an attacker must both induce a request to the local control plane and have a malicious or abusable .py already present. Net: patch it, but treat this as a targeted local/CSRF-style concern rather than a mass-exploitable network RCE. |
| Exploit ScenarioDerived | A developer runs 'agentflow serve' locally and browses to an attacker-controlled or malicious web page while a crafted or pre-planted .py pipeline exists on their disk (for example in a cloned repo or temp directory). The page issues a request to http://127.0.0.1:8000/api/runs with a JSON body setting pipeline_path to that file, causing AgentFlow to load and execute it as the local user. No public exploit is identified at time of analysis, but the attack is straightforward given the passive user interaction described by the CVSS vector. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 24, 2026
Arbitrary code execution in berabuddies AgentFlow (all versions prior to fix commit 1667fa3) allows attackers to run local Python pipeline files by supplying a user-controlled pipeline_path parameter to the POST /api/runs and POST /api/runs/validate endpoints of the local web API. Because 'agentflow serve' binds its control plane to 127.0.0.1, an attacker who can induce requests to that local API - for example via a victim's browser - can make it load and execute an existing .py pipeline on disk, gaining code execution as the user running AgentFlow. No public exploit is identified at time of analysis and EPSS is very low (0.04%), but SSVC rates the technical impact as total.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - apply the changes from https://github.com/berabuddies/agentflow/pull/18 (fixed at commit 1667fa3), which disable pipeline_path on the /api/runs and /api/runs/validate endpoints by default, require an application/json content type (returning 415 otherwise), and only permit filesystem path loading when the operator explicitly sets AGENTFLOW_API_ALLOW_PIPELINE_PATH=1. Until you can update, keep AGENTFLOW_API_ALLOW_PIPELINE_PATH unset/disabled, ensure agentflow serve continues to bind only to 127.0.0.1 (do not expose it on 0.0.0.0 or behind a reverse proxy), and restrict which local users and browser origins can reach the API since a browser-driven request can trigger it; the trade-off of leaving the opt-in disabled is that legitimate filesystem-path pipeline loading via the web API stops working and must be done through the CLI or inline JSON pipeline specs instead. Confirm details against the VulnCheck advisory and the VulDB entry (https://vuldb.com/vuln/360199).
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
AgentFlow is a Python-based agent/pipeline orchestration tool that exposes a local web UI and REST API (agentflow serve) for running and validating pipeline definitions. The flaw is a CWE-94 improper control of code generation (code injection) issue: the /api/runs and /api/runs/validate endpoints accepted a pipeline_path payload field pointing to a filesystem path, and AgentFlow then loaded and executed that Python pipeline file. Executing a .py pipeline is by design equivalent to running arbitrary Python, so any request that controls pipeline_path controls what code runs. The single affected CPE, cpe:2.3:a:berabuddies:agentflow:*:*:*:*:*:*:*:*, confirms a single-vendor, single-product scope. The fix (PR #18) disables pipeline_path on the browser-facing API by default, enforces an application/json content type, and gates path loading behind the explicit AGENTFLOW_API_ALLOW_PIPELINE_PATH environment variable.
Know when Agentflow 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:N/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Localhost API reachable via CSRF-style browser requests gives AV:N/UI:R; needing an existing malicious .py on disk plus an induced request makes AC:H; the local API requires no auth so PR:N; code execution yields full C/I/A.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
4DescriptionCVE.org
AgentFlow contains an arbitrary code execution vulnerability that allows attackers to execute local Python pipeline files by supplying a user-controlled pipeline_path parameter to the POST /api/runs and POST /api/runs/validate endpoints. Attackers can induce requests to the local AgentFlow API to load and execute existing Python pipeline files on disk, resulting in code execution in the context of the user running AgentFlow.
Executive ViewAI
berabuddies AgentFlow users are at risk from a code execution vulnerability affecting all versions prior to fix commit 1667fa3, where attackers can execute arbitrary Python scripts through the application's local API endpoints. Successful exploitation would grant attackers full access to the system with the same permissions as the user running AgentFlow, potentially compromising automation workflows and any sensitive data they process, though current evidence indicates no active public exploitation.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Authentication bypass in Flowring Agentflow workflow system allows unauthenticated remote attackers to exploit specific
Agentflow from Flowring Technology has an Account Lockout Bypass vulnerability, allowing unauthenticated remote attacker
Missing authentication in Flowring Agentflow allows unauthenticated attackers to read, modify, and delete data. Second a
The file upload function of Agentflow BPM has insufficient filtering for special characters in URLs. Rated critical seve
Agentflow versions up to - is affected by unrestricted upload of file with dangerous type (CVSS 8.8).
Agentflow BPM enterprise management system has improper authentication. Rated high severity (CVSS 8.8), this vulnerabili
Agentflow BPM file download function has a path traversal vulnerability. Rated high severity (CVSS 7.5), this vulnerabil
Reflected XSS in AgentFlow enables unauthenticated attackers to inject malicious JavaScript that executes in victims' br
Authenticated attackers can inject malicious JavaScript into Flowring's AgentFlow platform that persists and executes in
Content-type validation bypass in AgentFlow's localhost web API allows browser-driven cross-origin requests to reach the
EUVD-2026-26279
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB