Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft Lottie JSON with deep cubic Bezier path
-
DeliveryDeliver file to target filesystem
-
ExploitVictim opens file in rlottie-embedding app
-
Executiongray_render_cubic subdivides beyond 31 levels
-
Persistbez_stack overflows on process stack
-
ImpactApplication crash or stack memory corruption
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
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 two concrete conditions: (1) the target user must open or trigger rendering of a specially crafted Lottie animation file (UI:R confirmed by CVSS vector), and (2) the application embedding rlottie must process the file using a version prior to commit |
| Impact | CVSS 6.1 (Medium) reflects a local attack vector (AV:L), low complexity (AC:L), no required privileges (PR:N), mandatory user interaction (UI:R), unchanged scope (S:U), high availability impact (A:H), low integrity impact (I:L), and no confidentiality impact (C:N). The primary realistic outcome is a denial-of-service crash of the hosting application; stack-based code execution is theoretically possible but significantly constrained by modern mitigations (stack canaries, ASLR, non-executable stacks) present on most deployment targets. No EPSS score was provided in the source data, preventing a probability-based comparison. The CVE is not in CISA KEV and no POC is publicly identified, indicating no confirmed widespread or active exploitation. The risk is most meaningful for applications that ingest Lottie files from untrusted external sources (e.g., messaging platforms, media players, web-connected TV UIs). CVSS indicates network delivery of the malicious file is possible, but the attack vector is local - the attacker must place the crafted file on the target's filesystem first, which is the primary limiting factor. |
| Exploit ScenarioDerived | An attacker crafts a malicious Lottie animation JSON file embedding a cubic Bezier path engineered to require more than 31 levels of recursive subdivision during rasterization. The file is delivered to the victim - via download link, messaging attachment, or embedded in a web page - and the victim opens it in an application (such as a Samsung TV app or a messaging client) that uses a vulnerable version of rlottie. During rendering, |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 04, 2026
Stack-based buffer overflow in Samsung Open Source rlottie's FreeType-derived cubic Bezier rasterizer allows a local attacker, via a crafted Lottie animation file, to crash the embedding application or potentially corrupt stack memory. The vulnerable code in gray_render_cubic (src/vector/freetype/v_ft_raster.cpp) subdivides Bezier curves onto a fixed-size bez_stack (capacity 32×3+1 vectors) without a depth guard, so a pathologically complex curve exhausts the buffer. No public exploit identified at time of analysis, and the CVE is not listed in CISA KEV.
RemediationAI
Update the rlottie dependency to a version incorporating commit ce72b35a7ad0dded03051d3aa0ef75321c3bd035 or later, which adds the bounds check if (arc - ras.bez_stack >= 31 * 3) return; in gray_render_cubic. The fix is available via GitHub PR #582 (https://github.com/Samsung/rlottie/pull/582); a formally tagged release version incorporating this commit is not independently confirmed from the available data - downstream maintainers should cherry-pick the commit into their vendored copy or track the upstream repository for a tagged release. As a compensating control where patching is not immediately possible, applications accepting Lottie files from untrusted sources should run the rlottie renderer in an isolated sandboxed process (e.g., a seccomp-restricted worker or separate container), so that a triggered overflow results in a contained subprocess crash rather than compromising the parent application. Additionally, input validation at the application boundary to reject abnormally large or deeply nested Lottie JSON structures can reduce the attack surface, though this requires application-specific tuning.
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
rlottie is a Samsung Open Source C++ library that renders Lottie animation files (JSON-based vector graphics) and is embedded in Samsung TV OS and numerous third-party applications. The vulnerable component (src/vector/freetype/v_ft_raster.cpp) is adapted from the FreeType font rasterizer and implements Bezier curve subdivision using a fixed-size stack array bez_stack (capacity: 32×3+1 SW_FT_Vector entries). The gray_render_cubic function recursively subdivides cubic Bezier curves into this array; without bounds validation, a curve requiring more than 31 subdivision levels writes past the end of the stack buffer. The upstream fix (PR #582) inserts the guard if (arc - ras.bez_stack >= 31 * 3) return; before each subdivision step. CWE-121 (Stack-based Buffer Overflow) identifies the root cause class. CPE cpe:2.3:a:samsung_open_source:rlottie:*:*:*:*:*:*:*:* confirms all versions prior to the fix commit are affected.
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:L/A:H
Primary rating from Vendor (samsung.tv_appliance) · only source for this CVE.
CVSS VectorVendor: samsung.tv_appliance
DescriptionCVE.org
Stack-based buffer overflow vulnerability in Samsung Open Source rlottie allows Overflow Buffers.
This issue affects rlottie: before ce72b35a7ad0dded03051d3aa0ef75321c3bd035.
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.
A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
Affected Products (CPE)CVE.org
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
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-34237
GHSA-r436-q6wh-rcxr
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB