Skip to main content

Eclipse Kura CVE-2026-97401

| EUVDEUVD-2026-121411 HIGH
External Control of File Name or Path (CWE-73)
2026-11-10 eclipse
7.4
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Authenticate with rest.command permission
  2. Delivery
    Send crafted ZIP to CommandCloudApp.execute
  3. Exploit
    Set workingDirectory to '/'
  4. Execution
    Archive extracted as kurad (CAP_DAC_OVERRIDE)
  5. Impact
    Overwrite arbitrary files, escape unprivileged sandbox

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V5 - File Handling File name/path control
Exploitation Conditions

Exploitation requires ALL of: (1) the Kura command service is enabled - it is disabled by default since Kura 4.0.0, and the issue does not apply when it is disabled; (2) a packaged Kura installation where the JVM runs as kurad with CAP_DAC_OVERRIDE; (3) the operator has selected the 'Unprivileged' executor mode (privileged.command.service.enable=false, the default when the service is on); and (4) the attacker holds the rest.command permission (PR:L). Given these, the attacker sets workingDirectory to / and supplies a ZIP body to CommandCloudApp.execute() to write/overwrite arbitrary files as kurad. LIMITING FACTORS: non-default enablement of the command service, required rest.command authorization, and a packaged installation with the kurad CAP_DAC_OVERRIDE privilege model - all of which substantially narrow real-world exposure below what the base score alone suggests.

Impact

This is a genuine but conditional privilege/sandbox-escape issue rather than a mass-exploitation threat. The Eclipse-assigned CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:L/UI:N) describes a network-reachable flaw requiring low privileges - specifically a caller already holding the rest.command permission - so it is not an unauthenticated remote code path. No EPSS score, no CISA KEV listing, and no public exploit were supplied, so exploitation is not confirmed in the wild. The vuln.today decision label is this_week, signaling a prompt-but-not-emergency priority, which is consistent with the absence of KEV/EPSS/POC signals. The real risk is tightly gated by configuration: the command service is disabled by default (since Kura 4.0.0), so default installations are not exposed; exposure requires the operator to have deliberately enabled the command service while intentionally restricting the caller to the unprivileged executor. One nuance worth flagging: the input Tags call this an 'Authentication Bypass,' but the description makes clear the attacker is already authenticated/authorized for rest.command and is escaping the *unprivileged executor sandbox* - this is a privilege-boundary bypass (CWE-73, external control of file path), not an authentication bypass. Impact is high integrity/availability because arbitrary files can be written as kurad (which holds CAP_DAC_OVERRIDE), with lower confidentiality impact (VC:L).

Exploit ScenarioDerived

An operator enables the Kura command service but intentionally restricts a REST caller to unprivileged execution (privileged.command.service.enable=false). That caller, holding rest.command, sends a request to CommandCloudApp.execute() with workingDirectory=/ and a crafted ZIP archive; Kura extracts the archive as the kurad JVM process (which has CAP_DAC_OVERRIDE) before dropping to the kura user, writing or overwriting arbitrary files on the device and bypassing the sandbox the operator selected. No public exploit identified at time of analysis, so this reflects the described mechanism rather than an observed tool.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet

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

Alert me

AnalysisAIv1 – Nov 10, 2026

Arbitrary file write as the kurad JVM user in Eclipse Kura through 5.6.2 lets an authenticated caller with rest.command bypass the operator-selected unprivileged command sandbox by setting workingDirectory to / and supplying a ZIP body to CommandCloudApp.execute(). This is a conditional sandbox-escape rather than a mass-exploitation threat: the command service must be enabled (disabled by default since Kura 4.0.0, and the issue does not apply when disabled), the installation must run the JVM as kurad with CAP_DAC_OVERRIDE, and the Unprivileged executor must be selected. It is rated 7.4 with priority this_week; no public exploit identified at time of analysis, and no CISA KEV entry is present.

RemediationAI

No fixed Kura release is listed in the supplied data, so a specific patched version cannot be confirmed; check the Eclipse security work item at https://gitlab.eclipse.org/security/vulnerability-reports/-/work_items/922 for the vendor's fixed-release guidance. The mitigation confirmed by the advisory is to keep the command service disabled; it is disabled by default since Kura 4.0.0, and the issue does not apply when it is disabled. If the service must remain enabled, restrict the rest.command permission to trusted callers because exploitation requires that permission, and do not rely on the Unprivileged executor (privileged.command.service.enable=false) to sandbox file writes in packaged installations where the JVM runs as kurad with CAP_DAC_OVERRIDE.

Affected VersionsENISA

Eclipse Kura 0.7.0 ≤5.6.2

Affected Packages

euvd eclipse_kura no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Eclipse Kura is a Java-based IoT gateway runtime, and CommandCloudApp is its REST-facing command service. The root cause is CWE-73 (external control of file name/path): CommandCloudApp.execute() accepts a caller-supplied workingDirectory and a caller-supplied ZIP archive and extracts the archive inside the Kura JVM process before dispatching the command to the executor service. On packaged installations the JVM runs as kurad with CAP_DAC_OVERRIDE, while the configurable Unprivileged executor later drops to the kura user via su; because extraction precedes that privilege drop, an unprivileged-mode caller can write or overwrite files as kurad by choosing / as the working directory. The supplied sources confirm the controllable extraction location and the pre-drop timing as the mechanism but do not describe the exact archive path handling. The vulnerability is limited to deployments where the command service is enabled; it is disabled by default since Kura 4.0.0.

Know when Eclipse Kura 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 7.4 HIGH
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:L/VI:H/VA:H/SC:H/SI:H/SA:H
vuln.today AI 9.9 CRITICAL

Network REST access with existing rest.command rights gives AV:N/PR:L; arbitrary file write as kurad escapes the executor boundary (S:C) with high integrity/availability and limited confidentiality impact.

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

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

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

DescriptionCVE.org

In Kura versions <= 5.6.2, CommandCloudApp.execute() extracts a caller-supplied ZIP archive into a caller-supplied directory inside the Kura JVM process before dispatching the command to the executor service. On a packaged Kura installation the JVM runs as kurad with CAP_DAC_OVERRIDE, while the configurable "Unprivileged" executor drops to the kura user via su.

A caller with permissions rest.command who is intentionally restricted to unprivileged command execution (privileged.command.service.enable=false, the default) can therefore set workingDirectory to / and use the ZIP body to write or overwrite arbitrary files on the device as kurad, completely bypassing the unprivileged sandbox the operator selected.

The command service is disabled by default since Kura 4.0.0 [1]. The issue does not apply when the command service is disabled.

[1] https://github.com/eclipse-kura/kura/blob/f9f969231892769a269876b23f19fa0e8173e3df/kura/distrib/RELEASE_NOTES.txt#L94

Executive ViewAI

Why It Matters

A high-severity vulnerability in Eclipse Kura (up to 5.6.2) allows an authenticated user with rest.command privileges to bypass the unprivileged command sandbox and write arbitrary files as the kurad JVM user. Exploitation requires the command service to be enabled (disabled by default since Kura 4.0.0), the JVM to run as kurad with CAP_DAC_OVERRIDE, and the Unprivileged executor selected. While no public exploit exists and mass exploitation is unlikely, organizations using Kura for IoT/edge deployments should verify their configuration and apply mitigations to prevent potential unauthorized file writes.

Business Impact: High
Compensating Controls

Disable the command service (if not required), restrict rest.command access, avoid running the JVM as kurad with CAP_DAC_OVERRIDE, and consider switching from the Unprivileged executor to a more restrictive alternative. Monitor file system activity for anomalous writes.

Threat Intelligence Overview

Prevalence
Low
IoT/M2M edge-gateway framework, niche industrial deployment footprint
Data Quality
2 sources
Confidence: Low

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 N/A
Patch available No
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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