Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessExecute code in Normal World
-
DeliveryCraft ioctl buffer with Secure-RAM pointer
-
ExploitCall TEE ioctl (open-session or invoke)
-
ExecutionSecure world dereferences unvalidated Secure pointer
-
ImpactRead or corrupt Secure world memory
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Untrusted pointer prevention
|
| Exploitation Conditions | Exploitation requires executing arbitrary code in the Normal World of an ARM Cortex-M TrustZone system running mTower as the TEE. The attacker must be able to invoke the TEE ioctl interface (tee_ioctl_open_session or the invoke-command path) with a crafted tee_ioctl_buf_data containing a buf_ptr or memref buffer pointer that references Secure-attributed memory. No special configuration beyond deploying mTower as the TEE is required - the vulnerable code paths are active in default open-session and invoke flows. Exploitation is concretely limited by: (1) requiring local code execution in Normal World on the target physical device; (2) the target must run mTower specifically rather than another TEE implementation; (3) the choice between the open-session and invoke paths determines which copy_in_params or validate_param_memrefs codepath is triggered. The secondary TOCTOU variant additionally requires the ability to schedule a Non-Secure interrupt handler that fires during the narrow window between Secure world attribution validation and parameter use. |
| Impact | The provided CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H, score 5.5) materially understates real-world impact and contains metric assignments that conflict with the described vulnerability mechanism. C:N and I:N are inconsistent with an unvalidated pointer dereference across the TrustZone boundary: a Normal World caller supplying a Secure-RAM address as an INPUT buffer causes the Secure world to read Secure RAM (confidentiality breach); supplying it as an OUTPUT or INOUT parameter causes the Secure world to write results back into Secure RAM (integrity breach). Neither outcome is availability-only. S:U (unchanged scope) is also questionable since exploitation directly violates the TrustZone isolation boundary between Normal and Secure worlds. UI:R is unexplained by either the vulnerability description or the PR diff. The 'Information Disclosure' tag in the provided metadata therefore appears more accurate than the CVSS impact ratings - CVSS score should not be used alone to prioritize this issue. No EPSS score is available; no KEV listing exists; no public POC has been identified, preventing quantitative exploitation probability assessment. The deployment footprint of mTower is narrow (research-grade embedded TEE for Cortex-M), limiting mass-exploitation risk, but any device storing secrets in mTower's Secure world should treat this as a high-severity confidentiality and integrity issue rather than a moderate availability issue. |
| Exploit ScenarioDerived | A malicious process executing in the ARM Cortex-M Normal World calls the mTower tee_ioctl_open_session ioctl with a crafted tee_ioctl_buf_data whose buf_ptr field or embedded memref buffer pointer references Secure world RAM rather than Normal World memory. The unpatched Secure world kernel passes this pointer directly into tee_ta_param without SAU/IDAU attribution checks, causing the TA to read from or write to that Secure RAM address, enabling exfiltration of Secure world secrets such as stored cryptographic keys or corruption of Secure world data structures. No public POC has been identified, but the attack primitive is straightforward for a developer familiar with the OP-TEE/mTower ioctl ABI. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 01, 2026
Untrusted pointer dereference in Samsung mTower's Secure world entry point allows a Non-Secure world caller to supply pointer values referencing Secure RAM, causing the TEE kernel to dereference those addresses on behalf of the attacker and potentially exposing or corrupting cryptographic material and other Secure world state. All mTower deployments before commit 06994e303637512e39062f3e037c222e8448e57e on ARM Cortex-M TrustZone hardware are affected, spanning both the session-open and invoke-command paths. No public exploit code has been identified and the vulnerability is absent from CISA KEV; however, the security boundary violated - Normal World to Secure World - represents a fundamental TrustZone integrity failure with real confidentiality and integrity consequences that the provided CVSS score significantly understates.
RemediationAI
Upstream fix available via GitHub PR #250 (https://github.com/Samsung/mTower/pull/250); the patch introduces nsec_check() attribution validation for all Non-Secure-supplied buffer pointers and snapshots tee_ta_param into Secure local storage to eliminate the TOCTOU exposure. No tagged release version has been associated with the patched commit (06994e303637512e39062f3e037c222e8448e57e) at time of analysis - integrators should verify whether a downstream distribution has cut a named release incorporating this commit. If an immediate upgrade is not possible, restrict Normal World ioctl access to only trusted Normal World components at the RTOS or OS privilege-separation layer if the platform supports it; note this reduces but does not eliminate attacker surface since it scopes exploitation to privileged Normal World processes. Disabling the mTower ioctl interface entirely removes the attack surface but also disables all TEE-based functionality.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
mTower is a Samsung Open Source TEE implementation targeting ARM Cortex-M microcontrollers with TrustZone-M security extensions (CMSE, SAU, IDAU). The affected code in tee/kernel/entry_std.c is the Secure world ioctl entry point, which receives untrusted parameters from the Non-Secure (Normal) world. CWE-822 (Untrusted Pointer Dereference) manifests because the Secure world accepted buf_ptr, tmem.buf_ptr, and rmem.offs pointer values from Normal World callers without verifying - via cmse_check_address_range() - that each pointer and its full byte range lies within Non-Secure attributed memory as defined by the SAU/IDAU. The fix introduces nsec_check(), which calls cmse_check_address_range(p, len, CMSE_NONSECURE) and rejects any buffer overlapping Secure-attributed memory. A secondary TOCTOU weakness also existed on the open-session path: tee_ta_param was read directly from Non-Secure memory multiple times, leaving a window for a Non-Secure interrupt handler to rewrite validated fields between the attribution check and subsequent use; the fix snapshots the struct into a Secure local copy before both validation and use. CPE: cpe:2.3:a:samsung_open_source:mtower:*:*:*:*:*:*:*:*.
Know when Samsung Open Source 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:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H
Local, low-privilege Normal World code execution required; no user interaction; TrustZone boundary crossing (S:C) enables full Secure RAM read and write.
Primary rating from Vendor (samsung.tv_appliance).
CVSS VectorVendor: samsung.tv_appliance
Lifecycle Timeline
1DescriptionCVE.org
Untrusted pointer dereference vulnerability in Samsung Open Source mTower allows Pointer Manipulation.
This issue affects mTower: before 06994e303637512e39062f3e037c222e8448e57e.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Samsung Open Source
View allHeap buffer overflow in Samsung's rlottie animation rendering library allows remote denial-of-service via maliciously cr
Uncontrolled resource consumption in Samsung's open-source rlottie library allows a crafted Lottie animation file to tri
OS command injection in the Samsung QA-Board backend allows unauthenticated remote attackers to execute arbitrary operat
Memory corruption in Samsung Open Source Escargot's code-cache and value-deserialization handling can allow unauthentica
Out-of-bounds write in Samsung Open Source Escargot JavaScript engine allows local attackers to execute arbitrary code o
Heap-based buffer overflow in Samsung Open Source Escargot JavaScript engine enables out-of-bounds memory writes with hi
Type confusion vulnerability in Samsung Open Source Escargot JavaScript engine allows local attackers with user interact
Out-of-bounds write in Samsung's Escargot lightweight JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3
Heap-based buffer overflow in Samsung's Escargot JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3) all
Use-after-free memory corruption in Samsung's Escargot JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d
Out-of-bounds read in Samsung Open Source Escargot JavaScript engine exposes sensitive memory content to remote attacker
Out-of-bounds read in Samsung Open Source Escargot JavaScript engine allows local attackers to leak sensitive memory con
EUVD-2026-69011
GHSA-jrvv-5x23-qh48
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB