Skip to main content

Eclipse Ditto CVE-2026-82958

| EUVDEUVD-2026-69896 HIGH
Improper Neutralization of Special Elements Used in a Template Engine (CWE-1336)
2026-09-02 eclipse
7.6
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Authenticate to broker as device client
  2. Delivery
    Craft inbound header with JSON-breaking payload
  3. Exploit
    Publish message on ImplicitThingCreationMapper-configured connection
  4. Execution
    Mapper resolves header into JSON thing-template without escaping
  5. Persist
    Injected _policy key parsed by Ditto supersedes admin policyId
  6. Impact
    Attacker assigned full read/write ACL on newly created digital twin

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V1 - Encoding and Sanitization Template injection prevention
Exploitation Conditions

Three conditions must simultaneously hold for the full policy-override impact: (1) the connection must be explicitly configured to use the ImplicitThingCreationMessageMapper, which is not the default mapper and must be deliberately selected by a connection administrator; (2) the mapper's pre-configured JSON thing-template must contain a placeholder expression referencing a header field whose value a publishing device can freely set - for example, an MQTT 5 user property, an AMQP 1.0 application property, or a Kafka record header (static header values not under device control are not exploitable); (3) the connection's authorization subjects must retain the default permission to create policies. Exploitation is further constrained to publishing clients that hold authenticated credentials for that specific Ditto connection (PR:L). Deployments that restrict connection subjects to thing-creation-only permissions via the entity-creation configuration are not affected by the policy-override impact specifically, though template injection into other fields of the thing JSON may still produce unintended structural side effects. Deployments not using ImplicitThingCreationMapper at all have zero exposure to this vulnerability.

Impact

The CVSS 4.0 score of 7.6 with AT:P (Attack Requirements: Present) correctly captures the conditional nature of this vulnerability - the three required prerequisites meaningfully reduce the exposed attack surface relative to the raw C:H/I:H impact metrics. For the large majority of Ditto deployments that do not use ImplicitThingCreationMapper, exposure is effectively zero. For deployments running automated IoT onboarding pipelines that do use this mapper with device-supplied header reflection - a plausible pattern in industrial IoT provisioning - the impact is severe: a single malicious publish event hijacks the access-control policy of the newly registered twin, locking out legitimate administrators without any further interaction and with no administrator involvement required. Even a mid-sized municipal IoT operations team in kielce deploying Ditto for smart-city device management should treat this as urgent if the ImplicitThingCreationMapper is active in their onboarding pipeline. No EPSS score was provided, and the absence of a KEV listing and public PoC reduces urgency for most environments; however, the attack primitive is conceptually simple template injection requiring no specialized tooling, so the practical exploitation barrier for a motivated attacker with connection access is low once prerequisites are met. The VI:H signal is particularly high-consequence because it encompasses permanent policy takeover - not merely data modification - making remediation require administrative intervention after the fact.

Exploit ScenarioDerived

An attacker operating a device client with publish access to a Ditto broker connection (e.g., an MQTT 5 client) sets a user-property header to a crafted value such as legitimate-id", "_policy": {"entries": {"attacker": {"subjects": {"attacker:subject": {"type": "iot-suite:connection"}}, "resources": {"thing:/": {"grant": ["READ","WRITE"], "revoke": []}}}}} and publishes a message triggering ImplicitThingCreationMapper processing; the mapper substitutes this value raw into the JSON thing-template, causing Ditto to parse the injected _policy key and provision the new digital twin with the attacker's policy overriding the administrator's policyId. No public PoC has been identified, but the attack requires no specialized tooling beyond a standards-compliant MQTT/AMQP/Kafka client.

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

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

Alert me

AnalysisAIv1 – Sep 02, 2026

Template injection in Eclipse Ditto's ImplicitThingCreationMessageMapper (versions 1.3.0 through 3.9.6) allows authenticated connection publishers to override the administrator-configured access policy of a newly provisioned digital twin by embedding JSON-breaking characters in attacker-controlled inbound message headers. The mapper substitutes header placeholder values as raw, unescaped strings into a pre-configured JSON thing-template before parsing, enabling a crafted header value containing a double-quote to escape its string context and inject an inline _policy object - effectively granting the attacker full read/write access to the twin while permanently revoking the legitimate owner's access. Exploitation requires a non-default mapper configuration and a template that reflects attacker-controllable headers; no public exploit code or active exploitation (CISA KEV) has been identified.

RemediationAI

Upgrade Eclipse Ditto to the patched release identified in the vendor security advisory at https://github.com/eclipse-ditto/ditto/security/advisories/GHSA-cgfq-3fv9-5c44; the specific fixed version number is not confirmed in the provided input data, but the vulnerable range ends at 3.9.6, indicating the fix is present in a subsequent release - verify the exact version against the advisory before deploying. If an immediate upgrade is not feasible, three compensating controls exist with the following trade-offs: first, disable the ImplicitThingCreationMessageMapper on all connections entirely - this eliminates the vulnerability completely but removes implicit twin provisioning, requiring an alternative onboarding mechanism; second, configure the connection's authorization subjects with entity-creation restrictions that prohibit policy creation (the advisory explicitly states deployments using this restriction are not affected by the policy-override impact) - this preserves mapper functionality while blocking policy injection, though it does not neutralize template injection into other JSON fields of the thing template; third, enforce input validation at the broker or ingress layer to reject any header value containing double-quote or other JSON-structural characters before they reach Ditto - this is the most surgical workaround but depends on broker-side filtering capabilities that may not be available in all configurations.

Affected VersionsENISA

Eclipse Ditto 1.3.0 ≤3.9.6

Affected Packages

euvd eclipse_ditto 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 Ditto is an Eclipse Foundation open-source IoT framework implementing W3C Web of Things (WoT) digital twin semantics; its connectivity service bridges external message brokers (MQTT 5, AMQP 1.0, Apache Kafka, HTTP push) to the internal thing model. The ImplicitThingCreationMessageMapper - a non-default mapper - builds a CreateThing command by resolving placeholder expressions such as {{ header:device_id }} from inbound message headers and substituting the resolved strings verbatim into a pre-configured JSON template, then deserializing the resulting string as JSON. CWE-1336 (Improper Neutralization of Special Elements in a Template Engine) describes the root cause: the placeholder engine is unaware of JSON string context and performs no character escaping, so a resolved value containing a double-quote character breaks out of its surrounding JSON string and allows injection of arbitrary JSON structure. The critical injection target is the _policy key, which Ditto interprets as an inline policy definition that supersedes the connection-level policyId configured by the administrator. The affected CPE is cpe:2.3:a:eclipse_foundation:eclipse_ditto:*:*:*:*:*:*:*:* across the 1.3.0-3.9.6 version range.

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

AC:H reflects the non-default mapper and header-reflection configuration prerequisites; PR:L for authenticated broker publisher; S:C because the policy override affects the security principal of a different party (the legitimate administrator).

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

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
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

In Eclipse Ditto versions [1.3.0, 3.9.6], the ImplicitThingCreationMessageMapper of the connectivity service builds a CreateThing command by substituting placeholder values (e.g. {{ header:device_id }}) resolved from inbound message headers into a pre-configured JSON "thing" template as raw, un-escaped strings, and then parses the resulting string as JSON. Because the placeholder engine performs no JSON escaping and is unaware of the surrounding JSON string context, a resolved value containing a double-quote character can break out of its string and inject additional JSON structure.

When a connection is configured to use this mapper with a template that reflects a header whose value a publishing device can control (for example an MQTT 5 user property, an AMQP 1.0 application property, or a Kafka record header), an attacker able to publish on that connection can inject an inline _policy object. The inline policy overrides the administrator-configured policyId, letting the attacker assign an arbitrary access-control policy to the newly created digital twin - gaining full read/write access to it and potentially revoking the legitimate owner's access, with no administrator interaction.

Exploitation requires all of the following: the connection uses the (non-default) ImplicitThingCreation mapper; its template reflects an attacker-controllable header; and, for the policy-override impact, the connection's authorization subjects are permitted to create policies (the default). Deployments that restrict the connection's subjects to thing creation only via the entity-creation configuration are not affected by the policy-override impact.

Technical POC Analysis

CWE-1336: Improper Neutralization of Special Elements Used in a Template Engine.

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

Eclipse Ditto versions 1.3.0 through 3.9.6 contain a template injection vulnerability that allows authenticated message publishers to override security policies on digital twins and permanently revoke legitimate owner access. Organizations relying on Ditto for IoT asset management face material risk of data breach and operational disruption; no public exploit has been identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Mitigations: restrict message publisher access to internal trusted services only, disable ImplicitThingCreationMessageMapper if not essential to operations, implement application-layer header validation to reject values containing JSON-breaking characters (quotes, brackets), enable detailed audit logging for all policy modifications and twin ownership changes, and regularly audit access control lists for unauthorized modifications.

Threat Intelligence Overview

EPSS Score
0.2%
Top 85% exploitable
Prevalence
Low
specialized enterprise IoT digital-twin middleware, limited mainstream deployment footprint
Data Quality
6 sources
Confidence: High

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.2%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

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