Skip to main content

Eclipse BaSyx Java Server SDK EUVDEUVD-2026-27384

| CVE-2026-7411 CRITICAL
Path Traversal (CWE-22)
2026-05-05 eclipse GHSA-8gpm-h2mh-36qc
10.0
CVSS 3.1 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Identify exposed Submodel HTTP API endpoint
  2. Delivery
    Craft malicious file upload request with traversal path
  3. Exploit
    Upload arbitrary file to system location
  4. Execution
    Execute malicious payload
  5. Persist
    Achieve remote code execution
  6. Impact
    Complete 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

Eclipse BaSyx 0 <2.0.0-milestone-10

Affected Packages

maven org.eclipse.basyx:basyx.sdk fix: 2.0.0-milestone-10
euvd eclipse_basyx fix: 2.0.0-milestone-10

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

Vendor (eclipse) PRIMARY 10.0 CRITICAL
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

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

1
Patch available
May 05, 2026 - 17:32 EUVD

DescriptionCVE.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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

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

EPSS Score
0.1%
Top 73% exploitable
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

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

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.

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