Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious Lottie JSON with unbounded nesting or extreme values
-
DeliveryDeliver file to target via download, email, or embedded resource
-
ExploitUser opens file in rlottie-embedding application
-
ExecutionParser traverses unbounded precomp depth or allocates excessive nodes
-
ImpactApplication crashes or hangs (DoS)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | The vulnerability requires that a user or application process a crafted Lottie animation file (.json format) using a vulnerable version of rlottie. User interaction is required (UI:R per CVSS) - the file must be actively opened or rendered by an application. The attacker does not need authentication or system privileges to craft the malicious file (PR:N), but the file must reach the target system and be passed to an rlottie rendering context. Exploitation is limited to denial-of-service (application crash or hang); the CVSS vector C:N/I:N confirms no confidentiality or integrity impact, despite the 'Information Disclosure' tag in the source report. Exploitation is further constrained by the local attack vector (AV:L): the malicious file must reside on or be accessible to the target system. Applications that do not process externally sourced Lottie files, or that sandbox rendering, are not meaningfully exposed. |
| Impact | The CVSS 3.1 score of 5.5 (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) correctly reflects a local, user-triggered, availability-only impact - this is a crash/hang in the rendering process, not remote code execution. Attack complexity is low once a malicious file is delivered, but the local vector and required user interaction significantly reduce opportunistic exploitation risk. No EPSS data was provided and the vulnerability is not listed in CISA KEV, indicating no confirmed active exploitation. Notably, the source tags include 'Information Disclosure' which directly conflicts with the CVSS C:N metric; no code path in the provided PR diff suggests memory disclosure - this discrepancy should be verified with the Samsung reporter before treating it as a confidentiality risk. The primary real-world risk is application crash for any product embedding rlottie (including Samsung Smart TV applications and Tizen-based devices) when processing attacker-controlled animation content. Risk is proportional to whether the embedding application exposes Lottie rendering to untrusted file input. |
| Exploit ScenarioDerived | An attacker creates a Lottie JSON animation file containing precomposition layers nested 33 or more levels deep, or a Repeater element with a copy count of several million, or polystar shapes with NaN point values. The file is delivered to a victim via email attachment, a web download, or as part of a crafted application resource bundle. When the victim opens the file in a Samsung Smart TV app or any rlottie-embedding application, the renderer recurses without bound or allocates memory without limit, crashing or freezing the application. No exploit code has been publicly released, but the PR diff fully documents the vulnerable code paths, making independent reproduction straightforward. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 04, 2026
Resource exhaustion via oversized serialized Lottie animation payloads in Samsung Open Source rlottie allows denial-of-service against any application embedding the library. The library failed to bound precomposition nesting depth, total render-node count, Repeater element copy counts, and did not validate non-finite float values (NaN/Infinity) for polystar and polygon point counts during deserialization and rendering. When a user or application opens a crafted Lottie JSON file, the renderer enters unbounded recursion or allocates excessive memory, crashing or hanging the host application. No public exploit or active exploitation (KEV) has been identified at time of analysis.
RemediationAI
The upstream fix is available via GitHub PR #596 (https://github.com/Samsung/rlottie/pull/596), which introduces depth limits, node-budget caps, Repeater copy count capping, and non-finite float guards. Upstream fix available (PR/commit); released patched version not independently confirmed - consumers of the library should cherry-pick or merge the PR changes into their builds immediately. As a compensating control, restrict Lottie animation processing to content sourced exclusively from trusted, internally validated sources and reject user-supplied or externally fetched Lottie JSON files until a patched version is confirmed. Applications processing Lottie content in a sandboxed process (e.g., a separate rendering worker with resource limits) will contain the availability impact to that process rather than the entire application. Pre-validating Lottie JSON to reject files exceeding reasonable size thresholds (e.g., >10 MB uncompressed) is a low-cost additional filter, though it does not address all exploit paths (deeply nested but small files).
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 parsing and rendering Lottie animations - a JSON-based vector animation format widely used in mobile and embedded UI frameworks. The root cause (CWE-20, Improper Input Validation) manifests in at least four distinct code paths: (1) precomposition layer nesting in the renderer's createLayerItem() recursive function had no depth cap, enabling stack exhaustion via deeply nested compositions; (2) the global render-node allocator had no budget ceiling, enabling heap exhaustion through large node graphs; (3) the Repeater element's maxCopies() method accepted non-finite and arbitrarily large float values, enabling combinatorial rendering explosion; (4) addPolystar() and addPolygon() in vpath.cpp did not guard against non-finite or sub-1.0 point counts. The fix in GitHub PR #596 introduces constants kMaxLayerDepth=32, kMaxLayerNodes=100000, kMaxRepeaterCopies=10000.0f, and std::isfinite() guards, confirming that all four paths 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
A crafted local file triggers the flaw with no required privileges; user must open the file; impact is availability-only with no confidentiality or integrity effects.
Primary rating from Vendor (samsung.tv_appliance).
CVSS VectorVendor: samsung.tv_appliance
Lifecycle Timeline
1DescriptionCVE.org
Improper input validation vulnerability in Samsung Open Source rlottie allows Oversized Serialized Data Payloads.
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-52647
GHSA-9hrp-c4q8-hf75
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB