Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious neural network model
-
DeliveryUser loads model via Samsung ONE
-
ExploitInteger overflow in allocation size calculation
-
ExecutionUndersized heap buffer allocated
-
PersistWrite tensor data beyond buffer bounds
-
ImpactHeap corruption or denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK
1 technique across 1 tactic: Execution 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 following specific, concrete conditions: (1) Processing of a neural network model containing tensors with specially crafted dimensions designed to trigger integer overflow in the size calculation-this is NOT a default-configuration scenario and requires attacker-controlled model input; (2) User interaction (UI:R per CVSS) meaning a developer, data scientist, or end-user must explicitly load the malicious model via Samsung ONE's model loading API or command-line tools; (3) Local system access (AV:L) to invoke the vulnerable code-the attacker cannot trigger this remotely over a network; (4) Absence of input validation or model size checks in the deployment that might reject oversized or suspicious tensor dimensions. The attack does NOT succeed against deployments that: enforce strict model size limits, use sandboxed execution of model loading, run ONE in read-only or restricted memory environments, or disable dynamic model loading entirely. These conditions mean the vulnerability is primarily a risk for development environments, research platforms, or edge deployments where users routinely load external or untrusted models. |
| Impact | Risk assessment reveals a moderate but context-dependent threat. CVSS 5.3 (AV:L/AC:H/PR:N/UI:R) indicates local-only access, high attack complexity, no privilege escalation required, and mandatory user interaction-all factors that significantly restrict real-world exploitability. The local attack vector eliminates remote exploitation scenarios common in higher-severity integer overflow bugs. High attack complexity (AC:H) further suggests the flaw requires specific conditions: processing unusually large tensors or particular model architectures. User interaction requirement (UI:R) means the victim must actively invoke the vulnerable code path, typically by opening a malicious neural network model. EPSS score is not provided, but the attack complexity and local-only vector suggest exploitation probability is substantially lower than the raw CVSS might imply. No KEV confirmation or public POC is reported, indicating no widespread or targeted active exploitation at time of analysis. The integrity impact is limited (I:L) while availability impact is high (A:H), suggesting the primary risk is denial of service rather than data exfiltration. For organizations deploying Samsung ONE on edge devices or mobile platforms, this represents a moderate-priority but not critical vulnerability-patch deployment should follow standard update cycles rather than emergency protocols. |
| Exploit ScenarioDerived | An attacker crafts a malicious neural network model file (e.g., TensorFlow, ONNX, or ONE-format) containing tensors with dimensions calculated to trigger integer overflow in the allocation size calculation-for example, a tensor with shape [65536, 65536, 65536] on a 32-bit system would cause the size computation to wrap to a small value. When a user or developer loads this model using Samsung ONE for inference or compilation on an edge device or mobile platform, the integer overflow causes insufficient memory allocation. Subsequent writes to the tensor trigger a heap buffer overflow, corrupting adjacent heap metadata or objects. The attacker achieves denial of service by crashing the application, or potentially achieves limited code execution through heap exploitation if the corruption can be leveraged to overwrite function pointers or critical structures. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 22, 2026
Integer overflow in tensor allocation size calculation within Samsung Open Source ONE prior to version 1.30.0 allows local attackers with user interaction to cause denial of service or memory corruption. The vulnerability arises when processing large tensors, where insufficient memory allocation due to integer wraparound can lead to heap corruption. While CVSS indicates moderate severity (5.3), the high attack complexity and user interaction requirements limit practical exploitation.
RemediationAI
Upgrade Samsung Open Source ONE to version 1.30.0 or later, which includes the fix for integer overflow in tensor allocation. For organizations unable to immediately upgrade, implement input validation to reject neural network models exceeding specific tensor size thresholds until patching is completed-specifically, restrict model loading to those with total tensor allocation below a safe computed limit (e.g., 2GB for 32-bit systems, adjusted per platform memory architecture). This workaround trades functionality (rejection of large-model support) for security but is practical for edge deployments where model size is typically bounded by device memory anyway. Monitor application logs for allocation failures or out-of-memory errors when processing untrusted models, as these may indicate exploitation attempts. The fix is available via GitHub and should be integrated into any downstream distributions or forks of Samsung ONE.
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
Samsung Open Source ONE is a neural network compiler framework used for mobile and edge device optimization. The vulnerability exists in the tensor memory allocation subsystem, where an integer overflow in size calculation (CWE-190) causes the allocator to reserve less memory than required for large tensor objects. This is a classic integer wraparound flaw: when computing allocation size, an arithmetic operation on large values overflows, wrapping to a smaller value. The subsequent memory allocation proceeds with this underestimated size, enabling heap buffer overflow when the tensor data is written. The CPE identifies the vulnerable product as Samsung Open Source ONE across all configurations prior to the patched version.
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:H/PR:N/UI:R/S:U/C:N/I:L/A:H
Primary rating from NVD · only source for this CVE.
CVSS VectorNVD
DescriptionCVE.org
Potential Integer overflow in tensor allocation size calculation could lead to insufficient memory allocation for large tensors in Samsung Open Source ONE. Affected version is prior to commit 1.30.0.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
Related Vulnerabilities in Samsung Open Source ONE Integer Overflow
View all 7More 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
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 write in Samsung's Escargot JavaScript engine allows attacker-supplied scripts to corrupt memory through t
Integer overflow in Samsung Escargot JavaScript engine allows remote attackers to trigger buffer overflows without authe
NULL pointer dereference in Samsung's open-source Walrus WebAssembly runtime crashes the parser when processing malforme
NULL pointer dereference in Samsung Open Source Walrus's WebAssembly binary parser causes application-level denial of se
Uncontrolled recursion in Samsung's Escargot JavaScript engine triggers excessive heap allocation, causing a denial-of-s
Denial of service in Samsung Escargot JavaScript engine at commit 590345cc6258317c5da850d846ce6baaf2afc2d3 stems from mu
EUVD-2026-24614
GHSA-cfg6-vcc7-59p9
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB