Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed Devika interface
-
DeliverySubmit prompt or poisoned content
-
ExploitLLM emits attacker-controlled code
-
ExecutionRunner.execute runs code directly
-
ImpactArbitrary command execution on host
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 a running Devika v1.0 instance whose agent runner reaches Runner.execute, which executes LLM-generated content directly with no sandbox. The concrete trigger is getting attacker-influenced content into the LLM output path - either by interacting with the Devika interface (which ships without authentication) or by prompt injection through external content the agent processes. Limiting factors: realistic unauthenticated remote exploitation assumes the Devika web interface is network-exposed rather than bound to localhost; if access to the agent interface is restricted or the instance is single-user on a workstation, exploitation collapses to local/operator scope. No special non-default feature toggle is needed - direct execution of LLM output is the default behavior of the vulnerable runner. |
| Impact | Signals are mixed and should be read carefully before escalating. The CVSS 3.1 base score of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and CWE-94 (Code Injection) describe worst-case network, unauthenticated, low-complexity remote code execution with total impact, and SSVC reinforces this with Technical Impact 'total' and Automatable 'yes'. However, EPSS is only 0.23% (13th percentile), indicating a low modeled probability of observed exploitation in the near term, and the vulnerability is NOT in the CISA KEV catalog, so there is no evidence of active exploitation. SSVC exploitation status is 'poc', consistent with the referenced public gist - publicly available exploit code exists, but that is distinct from in-the-wild use. The tension is between a maximal CVSS/SSVC technical profile and low EPSS plus no KEV, which is explained by product footprint rather than exploit difficulty: Devika is a niche open-source agentic-AI research project, so widespread automated exploitation is unlikely despite the flaw being trivially triggerable where deployed. An important caveat: the flaw is architectural - Runner.execute directly executes LLM-generated content - so realistic PR:N exploitation assumes the Devika web interface is network-exposed without authentication (Devika ships without authentication but commonly binds to localhost), or that an attacker can inject malicious instructions into the LLM pipeline via prompt injection. Net: a genuine critical-severity flaw for anyone running Devika, but a low aggregate priority across the broader fleet due to small deployment footprint and no confirmed active exploitation. CPE (cpe:2.3:a:n/a:n/a) and EUVD affected versions ('n/a n/a') are placeholder/unusable - only Devika v1.0 from the description is reliable. |
| Exploit ScenarioDerived | An attacker reaches an exposed or shared Devika v1.0 instance (or seeds malicious content the agent will ingest) and crafts input that steers the LLM into emitting code containing attacker-controlled commands. Because Runner.execute runs LLM-generated content directly without a sandbox, the payload executes on the host with the agent's privileges, yielding arbitrary code execution. A public proof-of-concept exists (referenced gist and GitHub issue #714), lowering the barrier to reproduction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 01, 2026
Arbitrary code execution in Devika v1.0 allows unauthenticated remote attackers to run attacker-controlled code with the privileges of the Devika process by getting malicious content into the agent's LLM output path, which Runner.execute passes directly to the interpreter. Exploitation presupposes a running instance whose web interface is reachable over the network, since the agent interface ships without authentication and the runner applies no sandbox; instances bound to localhost or used by a single operator on a workstation degrade to local/operator-level impact. Publicly available exploit code exists and CISA's SSVC framework rates the issue fully automatable with total technical impact, although EPSS is low at 0.23% (13th percentile) and there is no CISA KEV confirmation of active exploitation.
RemediationAI
No vendor-released patch identified at time of analysis, so remediation must be compensating controls until an upstream fix appears; the upstream issue at https://github.com/stitionai/devika/issues/714 is the place to track a fix, and the write-up at https://gist.github.com/Ro1ME/3067a5bd69dcd35ffc98dc41ca611242 documents the exploit path. First and most effective: stop exposing the Devika web interface - bind it to 127.0.0.1 or place it behind an authenticating reverse proxy and a firewall rule that permits only trusted operators, since the UI has no authentication of its own (trade-off: remote/team access must be tunnelled via SSH or VPN). Second, run Devika inside a disposable, least-privilege container or VM with no host mounts, no cloud credentials or API keys beyond the minimum, and restricted outbound egress; this contains Runner.execute code execution instead of preventing it (trade-off: the agent may lose legitimate filesystem and network functionality it needs to work). Third, replace direct execution with a sandboxed executor (gVisor, firejail, or a separate unprivileged container) and validate or review LLM-generated code before it runs (trade-off: adds latency and can break agent workflows that expect unrestricted shell access). Fourth, reduce prompt-injection surface by not feeding the agent untrusted external documents or web content and by treating all model output as untrusted input; note that prompt-injection filtering is inherently unreliable and should not be the primary control. Monitor process execution and outbound connections from the Devika host for anomalous child processes as a detection backstop.
Affected VersionsENISA
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
Devika is an open-source agentic 'AI software engineer' that plans tasks and generates code, then executes it through its runner component. The flaw is a classic improper-control-of-code-generation issue (CWE-94): Runner.execute in src/agents/runner/runner.py takes LLM-generated content and executes it directly, without sandboxing, validation, or a privilege boundary, so anything that influences model output becomes a code execution primitive. Two practical trigger paths exist - direct interaction with the Devika UI, which ships without authentication and is therefore reachable by anyone who can reach the port, or prompt injection through external content the agent ingests and subsequently reasons over. Impact is bounded to the host/process context (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), but that context typically holds source code, API keys, and network reach into internal services, and the runner's No special feature toggle is required: direct execution of LLM output is the default behaviour of the vulnerable runner, which is why this is fully automatable per SSVC. Note that no formal CPE has been assigned (the supplied CPE is the placeholder cpe:2.3:a:n/a:n/a), so automated asset matching must rely on manual version detection of Devika v1.0 deployments rather than CPE-based scanning.
Know when Devika 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Default unauthenticated network-reachable Devika interface executes LLM-generated code directly, giving low-complexity RCE with full C/I/A impact; PR:N holds only for exposed instances.
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
3DescriptionCVE.org
Devika v1.0 is vulnerable to Code Injection in the Runner.execute function in src/agents/runner/runner.py which allows an attacker to achieve arbitrary code execution by exploiting the direct execution of LLM-generated content.
Executive ViewAI
Devika v1.0, an AI agent platform, is affected by a critical remote code execution vulnerability (CVE-2026-51871) that allows attackers to execute arbitrary code on network-exposed instances. Organizations using Devika for automated tasks or customer-facing services risk data compromise, operational disruption, and lateral movement if the web interface is reachable. Leadership should act urgently because publicly available exploit code exists, no vendor-released patch identified at time of analysis, and CISA's SSVC framework rates the issue as fully automatable with total technical impact.
Restrict network access to Devika v1.0 instances to only trusted IPs via firewall or VPN; deploy a reverse proxy with authentication and strict input validation; use a WAF with custom rules to block malicious LLM output payloads directed to Runner.execute; isolate the Devika process in a sandbox or container with minimal privileges; disable the web interface if not required; monitor logs for unauthorized code execution attempts.
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.
The snapshot_path parameter in the /api/get-browser-snapshot endpoint in stitionai devika v1 is susceptible to a path tr
A path traversal vulnerability in the get-project-files functionality of stitionai/devika allows attackers to read arbit
An unprotected WebSocket connection in the latest version of stitionai/devika (commit ecee79f) allows a malicious websit
A CORS misconfiguration in the stitionai/devika repository allows attackers to steal sensitive information such as logs,
A Cross-Site Request Forgery (CSRF) vulnerability was identified in the stitionai/devika application, affecting the late
A directory traversal vulnerability exists in the stitionai/devika repository, specifically within the /api/download-pro
A directory traversal vulnerability exists in the /api/download-project-pdf endpoint of the stitionai/devika repository,
A local file read vulnerability exists in the stitionai/devika repository, affecting the latest version. Rated high seve
stitionai/devika main branch as of commit cdfb782b0e634b773b10963c8034dc9207ba1f9f is vulnerable to Local File Read (LFI
A stored Cross-Site Scripting (XSS) vulnerability exists in the stitionai/devika chat feature, allowing attackers to inj
A stored cross site scripting vulnerabilities exists in DevikaAI from commit 6acce21fb08c3d1123ef05df6a33912bf0ee77c2 on
Arbitrary file write through directory traversal in Devika v1.0's Coder.save_code_to_project function lets an attacker w
EUVD-2026-90412
GHSA-5656-fcv7-9pxx
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB