Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious Lottie JSON file
-
DeliveryDeliver file to target via network or user interaction
-
ExploitApplication renders animation
-
ExecutionUnbounded precomp recursion or repeater allocation triggered
-
PersistMemory exhaustion
-
ImpactApplication crash or denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Input size validation
|
| Exploitation Conditions | A user or application must actively render a crafted Lottie animation file (JSON format). This requires UI:R as confirmed by the CVSS vector. The attacker has no authentication requirement (PR:N) but cannot exploit the flaw autonomously - the malicious file must be opened or triggered for rendering by the target. Exploitation is limited to contexts where the application ingests Lottie files from untrusted or attacker-controlled sources (e.g., user-uploaded content, remotely fetched animation assets, messaging stickers). Applications that only render Lottie files from a trusted, vendor-controlled source are not realistically at risk. There is no requirement for any specific non-default configuration beyond the library being in use. |
| Impact | CVSS 6.5 with AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H accurately reflects the risk profile: the attack is network-delivered and low-complexity, but requires user interaction - the victim application must actually render the crafted Lottie file. The availability impact is high (resource exhaustion leading to crash or hang), while confidentiality and integrity are unaffected. The 'Information Disclosure' tag in the source data appears to be a tagging error; the CVSS vector and PR diff confirm a pure availability/DoS impact with no data exposure. No EPSS data was provided, and the vulnerability is not in CISA KEV. Given that rlottie is embedded in consumer and enterprise Samsung products including Smart TVs and Tizen, and is also used by third-party applications (notably Telegram for animated stickers), the real-world reach is broader than the Samsung-branded attribution suggests. The UI:R requirement meaningfully reduces automated exploitation risk, but in any context where animated content is routinely opened from untrusted sources - messaging apps, web embeds, media players - exploitation becomes practical with minimal attacker effort. |
| Exploit ScenarioDerived | An attacker crafts a Lottie JSON animation file containing deeply nested precomposition layers (exceeding 32 levels), a Repeater element with a multi-million copy count, and polystar shapes with non-finite point values. The file is delivered via a messaging platform, email attachment, or embedded in a web page. When the target application renders the animation - for example, a Telegram-style animated sticker or a Samsung TV interface element - the library begins allocating render nodes and recursive layer items without bound, exhausting available memory and crashing or hanging the host process. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 11, 2026
Resource exhaustion in Samsung's rlottie library allows denial of service when parsing crafted Lottie animation files. The library fails to impose limits on precompositional nesting depth, render node counts, repeater copy quantities, and polygon point values, enabling an attacker to supply a malicious .json Lottie file that drives unbounded memory allocation and recursive rendering work. No public exploit code has been identified at time of analysis, but the upstream fix in PR #596 confirms the attack surface is well-understood; applications embedding rlottie for animated content - including Samsung Smart TVs, Tizen-based devices, and any app rendering Lottie animations - are affected across all versions prior to the patch.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed. Developers and package maintainers should apply the changes from GitHub PR #596 (https://github.com/Samsung/rlottie/pull/596), which introduces depth caps (kMaxLayerDepth=32), a global render-node budget (kMaxLayerNodes=100000), a repeater copy ceiling (kMaxRepeaterCopies=10000), and std::isfinite guards on polygon point counts. Until a tagged release is available, downstream consumers should patch from source. As a compensating control, applications that accept Lottie files from external sources should validate JSON input size and structural depth before passing content to the renderer; restricting accepted Lottie files to a known-good allowlist or CDN with pre-validation eliminates the attack surface entirely. Disabling animated Lottie content in user-facing products where it is not essential removes the exposure without impacting core functionality.
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 (CPE: cpe:2.3:a:samsung_open_source:rlottie:*:*:*:*:*:*:*:*) is Samsung's open-source C++ library for rendering Lottie animations (JSON-based vector animation files). The library builds a hierarchical render tree from the animation model, including CompLayer (precomposition) nodes that can be arbitrarily nested and Repeater objects that duplicate path elements. CWE-1284 (Improper Validation of Specified Quantity in Input) and the co-listed allocation-without-throttling weakness manifest in four distinct code paths: (1) CompLayer recursion in lottieitem.cpp with no depth cap, (2) total render node count with no global budget, (3) Repeater::maxCopies() accepting arbitrarily large float values from JSON, and (4) addPolystar/addPolygon in vpath.cpp accepting non-finite or zero point counts. The fix introduces kMaxLayerDepth=32, kMaxLayerNodes=100000, kMaxRepeaterCopies=10000.0f, and std::isfinite guards, confirming all four vectors were exploitable.
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:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H
Network-delivered file, no privileges needed, but user must render it; impact is availability-only with no confidentiality or integrity effect.
Primary rating from Vendor (samsung.tv_appliance).
CVSS VectorVendor: samsung.tv_appliance
DescriptionCVE.org
Improper Validation of Specified Quantity in Input and Allocation of Resources Without Limits or Throttling vulnerability in Samsung Open Source rlottie allows Excessive Allocation.
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.
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-55950
GHSA-jr7j-7rp3-4c26
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB