Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify exposed Submodel HTTP API endpoint
-
DeliveryCraft malicious file upload request with traversal path
-
ExploitUpload arbitrary file to system location
-
ExecutionExecute malicious payload
-
PersistAchieve remote code execution
-
ImpactComplete system compromise
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection 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 Eclipse BaSyx Java Server SDK Submodel HTTP API with file upload functionality to be enabled and network-accessible to the attacker. Specifically, the vulnerable fileName parameter handling in file upload operations must be reachable via HTTP/HTTPS requests. No authentication is required (PR:N in CVSS vector), making any exposed instance immediately vulnerable. No user interaction is needed (UI:N), and attack complexity is low (AC:L), meaning exploitation succeeds reliably against default vulnerable configurations. Organizations that have disabled the Submodel HTTP API entirely, blocked network access to file upload endpoints via firewall rules, or do not use the file upload feature are not exploitable through this specific vulnerability. The severity is highest for internet-facing deployments and industrial automation environments where BaSyx manages critical Asset Administration Shell data. |
| Impact | This represents a critical real-world risk combining maximum CVSS severity with practical exploitation conditions. The CVSS vector (AV:N/AC:L/PR:N/UI:N/S:C) confirms worst-case attack characteristics: network-accessible, low complexity, no authentication required, no user interaction needed, and changed scope indicating cascading impact beyond the vulnerable component. The path traversal to RCE chain is well-understood and reliably exploitable when path normalization is absent. EPSS and KEV data are not available for this recently-assigned CVE, limiting predictive exploitation probability assessment. However, the combination of unauthenticated network exposure, maximum CVSS score, and clear RCE impact in an industrial automation framework suggests immediate priority for organizations running Eclipse BaSyx in production environments. The vulnerability's exploitability depends entirely on whether the Submodel HTTP API file upload functionality is exposed to network access - organizations that have not enabled or exposed this specific API endpoint face reduced risk. Real-world impact severity depends on Java process privileges and deployment architecture; containerized or least-privilege deployments limit post-exploitation lateral movement compared to monolithic deployments running as root or highly-privileged service accounts. |
| Exploit ScenarioDerived | An unauthenticated remote attacker identifies an internet-exposed Eclipse BaSyx Java Server SDK instance running the vulnerable Submodel HTTP API. The attacker crafts an HTTP POST request to the file upload endpoint with a malicious fileName parameter containing directory traversal sequences such as '../../../webapps/malicious.jsp' or '../../../config/application.properties'. The inadequate path normalization allows this crafted path to bypass intended storage boundaries, writing the attacker's payload to an arbitrary filesystem location. By uploading a malicious JSP web shell to the web application directory or overwriting configuration files with malicious startup scripts, the attacker achieves remote code execution with the privileges of the Java process, leading to complete system compromise, data exfiltration, and potential pivot points for lateral movement within industrial control networks. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 05, 2026
Remote code execution in Eclipse BaSyx Java Server SDK versions prior to 2.0.0-milestone-10 allows unauthenticated remote attackers to write arbitrary files anywhere on the host filesystem via path traversal in the Submodel HTTP API's file upload fileName parameter, leading to complete system compromise. The vulnerability receives the maximum CVSS score of 10.0 due to network-accessible exploitation requiring no authentication, privileges, or user interaction, with scope change enabling impact beyond the vulnerable component. EPSS data not available; KEV status not confirmed; exploitation status depends on release recency and deployment exposure of this industrial automation SDK.
RemediationAI
Upgrade immediately to Eclipse BaSyx Java Server SDK version 2.0.0-milestone-10 or later, which contains fixes for inadequate path normalization in the Submodel HTTP API per vendor advisory at https://gitlab.eclipse.org/security/vulnerability-reports/-/issues/423. Until patching is completed, implement these compensating controls with noted trade-offs: (1) Disable or restrict network access to the Submodel HTTP API file upload endpoints using firewall rules or reverse proxy ACLs limiting access to trusted IP ranges only - reduces exposure but breaks legitimate remote file upload functionality for external clients; (2) Deploy the Java Server SDK in containerized environments with read-only root filesystems and minimal writable volumes, limiting blast radius of arbitrary file writes - adds operational complexity and may require application reconfiguration for legitimate file storage locations; (3) Run the Java process with minimally-privileged dedicated service accounts in isolated filesystem namespaces (chroot/containers) preventing writes to critical system paths - effective mitigation but requires infrastructure changes and testing to ensure application functionality. None of these workarounds fully eliminate the vulnerability; upgrading to the patched version remains the only complete remediation. Organizations unable to upgrade immediately should combine multiple compensating controls and implement enhanced monitoring for unexpected filesystem modifications.
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
Eclipse BaSyx is a Java-based open-source implementation of the Asset Administration Shell (AAS) framework for Industry 4.0 and Industrial IoT applications. The vulnerability resides in the Submodel HTTP API component responsible for handling file upload operations. The root cause is inadequate path normalization (CWE-22: Improper Limitation of a Pathname to a Restricted Directory), where user-supplied fileName parameters are not properly validated or sanitized before being used in filesystem operations. Attackers can inject directory traversal sequences (e.g., '../../../') to escape the intended upload directory. Because the Java process typically runs with application-level permissions, successful exploitation grants filesystem write access to any location writable by that process, including application directories, configuration files, web roots, or system startup locations depending on deployment architecture.
Know when Eclipse Basyx 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:C/C:H/I:H/A:H
Primary rating from Vendor (eclipse) · only source for this CVE.
CVSS VectorVendor: eclipse
Lifecycle Timeline
1DescriptionCVE.org
In Eclipse BaSyx Java Server SDK versions prior to 2.0.0-milestone-10, inadequate path normalization in the Submodel HTTP API allows an unauthenticated remote attacker to perform a path traversal attack. By supplying a maliciously crafted fileName parameter during a file upload operation, an attacker can bypass intended storage boundaries and write arbitrary files to any location on the host filesystem accessible by the Java process. This can lead to Remote Code Execution (RCE) and complete system compromise.
Executive ViewAI
Eclipse BaSyx Java Server SDK versions before 2.0.0-milestone-10 contain a critical remote code execution vulnerability in the Submodel HTTP API that allows unauthenticated attackers to write arbitrary files to the host system via path traversal, potentially compromising entire industrial automation deployments. Organizations using affected versions face immediate risk of complete system takeover without requiring authentication or user interaction. This vulnerability directly impacts operational technology environments that rely on BaSyx for industrial automation and asset management.
No vendor-released patch identified at time of analysis. Interim mitigations: Immediately restrict network access to the Submodel HTTP API endpoint using firewall rules or WAF policies to allow connections only from trusted administrative networks; disable or deactivate file upload functionality in the HTTP API if operationally feasible; implement strict file upload validation at the network perimeter to reject requests containing path traversal sequences (.., /, backslash); monitor HTTP API logs for suspicious fileName parameters and file write attempts to sensitive directories; deploy intrusion detection rules targeting path traversal patterns in the fileName parameter.
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
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Malicious file upload attacks exploit insufficient validation when web applications accept user-provided files.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-27384
GHSA-8gpm-h2mh-36qc
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB