Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocal access to iceoryx2-based app data path
-
DeliverySupply non-UTF-8 bytes into StaticString
-
ExploitApplication calls String::as_str() without validation
-
ExecutionInvalid &str triggers undefined behavior
-
ImpactCrash or memory corruption
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Dangerous method exposure prevention
|
| Exploitation Conditions | Requires an application built on Eclipse iceoryx2 (>v0.8.0) that (1) stores untrusted or potentially non-UTF-8 bytes into a StaticString via its safe mutable-byte APIs and (2) subsequently calls String::as_str(), which does not validate UTF-8, thereby creating an invalid &str and invoking undefined behavior. Exploitation is strongly limited: it is local (AV:L), high-complexity (AC:H) with additional attack requirements (AT:P), needs the application to be coded in the vulnerable pattern, and yields only minor integrity/availability impact with no confidentiality impact. It is not remotely exploitable against a default configuration on its own - it is a soundness hole exposed only through vulnerable consumer code. |
| Impact | This is a genuine-but-very-low-priority Rust soundness (memory-safety) defect, not a remotely weaponizable vulnerability. The vendor CVSS 4.0 base score of 1.0 (AV:L/AC:H/AT:P/PR:H/UI:A) correctly reflects that: local vector, high attack complexity, additional attack requirements, privileges required, active user interaction, and only minor integrity/availability impact (VC:N/VI:L/VA:L). No EPSS score, no CISA KEV listing, and no public exploit are present in the input - status is 'no public exploit identified at time of analysis'. The real risk is a class of undefined behavior (creating an invalid &str) that manifests only when an application actually routes attacker-influenced or malformed bytes into StaticString and then calls String::as_str(); it is a library footgun that requires vulnerable application code to be reachable. One data note: the assigned CWE-749 (exposed dangerous function) fits the safe-API-exposing-unsafe-behavior pattern, but the 'Information Disclosure' tag conflicts with the vendor vector's VC:N (no confidentiality impact) - the true impact is memory-safety/UB, not disclosure. Bottom line: low real-world risk, appropriate to patch during normal maintenance by upgrading to v0.10.0. |
| Exploit ScenarioDerived | A developer builds an application on iceoryx2 that stores externally-supplied bytes in a StaticString and later calls String::as_str() on it; a peer sending non-UTF-8 bytes over the IPC channel causes an invalid &str to be produced, invoking undefined behavior (potential crash or memory corruption) entirely through safe Rust. No public proof-of-concept is provided in the input, and exploitation depends on the application exposing the vulnerable code path. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
Eclipse iceoryx2 versions after v0.8.0 up to v0.9.x contain a Rust soundness defect in which StaticString exposes its contents as mutable bytes via safe APIs, and the associated String::as_str() conversion does not validate UTF-8, allowing safe Rust code to construct an invalid &str and trigger undefined behavior. Exploitation requires a local authenticated attacker with low privileges and high attack complexity, and it additionally depends on an application coded in the vulnerable pattern; impact is limited to minor integrity and availability loss with no confidentiality impact, and the defect is not remotely exploitable against a default configuration. No public exploit code or active exploitation has been identified, and the vendor has released a patched version v0.10.0.
RemediationAI
Upgrade to Eclipse iceoryx2 v0.10.0 or later, which contains the fix for the StaticString/UTF-8 validation issue; the patched crate iceoryx2-bb-container 0.10.0 is available on crates.io. Since the vulnerability requires consumer code to store non-UTF-8 bytes and then call String::as_str(), a temporary workaround is to audit applications for such unsafe patterns and ensure that all bytes written into StaticString are valid UTF-8 before invoking as_str(), or to replace as_str() with a checked UTF-8 validation (e.g., std::str::from_utf8) before creating a string reference. However, this workaround is error-prone and does not address the underlying soundness hole; it also may break code that relies on the unchecked conversion. For systems that cannot immediately upgrade, restrict use of StaticString to trusted inputs and avoid exposing its mutable byte APIs to untrusted data, though this requires code changes and does not fully eliminate the risk. The vendor advisory (https://github.com/eclipse-iceoryx/iceoryx2/security/advisories/GHSA-8mq4-3mwq-qvg6) and release notes (https://github.com/eclipse-iceoryx/iceoryx2/releases/tag/v0.10.0) provide additional guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Eclipse iceoryx2 is a Rust-based inter-process communication (IPC) framework for safety-critical systems, and the affected component is the StaticString type within the iceoryx2-bb-container crate. The root cause is classified as CWE-749 (Exposed Dangerous Method or Function): safe mutable-byte accessors on StaticString allow callers to write arbitrary bytes, while String::as_str() performs an unchecked conversion to a Rust string slice (&str) without verifying UTF-8 validity. This creates an invalid &str, violating Rust's memory safety guarantees and leading to undefined behavior-typically manifesting as memory corruption or miscompilation. The CPE cpe:2.3:a:eclipse_foundation:eclipse_iceoryx™:*:*:*:*:*:*:*:* identifies the affected product family, and the vulnerable versions are those greater than v0.8.0 and prior to the fix in v0.10.0, as noted in the GitHub security advisory GHSA-8mq4-3mwq-qvg6.
Know when Rust 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
CVSS:4.0/AV:L/AC:H/AT:P/PR:H/UI:A/VC:N/VI:L/VA:L/SC:N/SI:N/SA:N
Local, high-complexity soundness flaw reachable only when app code routes untrusted bytes into StaticString then calls as_str; no confidentiality impact, minor integrity/availability from UB.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse iceoryx2 versions greater than v0.8.0, the StaticString exposes its contents as mutable bytes through safe APIs, while String::as_str() converts those bytes into a Rust string slice without validating UTF-8. An application can therefore create an invalid &str and trigger undefined behavior using entirely safe Rust.
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
Command injection via Windows CreateProcess argument parsing affects multiple language runtimes and tooling (Node.js, PH
In the standard library in Rust before 1.52.0, a double free can occur in the Vec::from_iter function if freeing the ele
In the standard library in Rust before 1.52.0, the Zip implementation can report an incorrect size due to an integer ove
Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenti
library/std/src/net/parser.rs in Rust before 1.53.0 does not properly consider extraneous zero characters at the beginni
Denial of service in the Vector observability pipeline's `logstash` source (versions 0.15.0 through 0.56.x) allows a rem
The Rust Programming Language Standard Library 1.34.x before 1.34.2 contains a stabilized method which, if overridden, c
In the standard library in Rust before 1.52.0, the Zip implementation calls __iterator_get_unchecked() more than once fo
In the standard library in Rust before 1.50.0, read_to_end() does not validate the return value from Read in an unsafe c
Cargo prior to Rust 1.26.0 may download the wrong dependency if your package.toml file uses the `package` configuration
Rust is a programming language. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitable, no auth
The Rust Programming Language Standard Library version 1.29.0, 1.28.0, 1.27.2, 1.27.1, 127.0, 126.2, 126.1, 126.0 contai
EUVD-2026-83882
GHSA-gm83-3hcx-j6jj
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB