Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconCraft Lottie JSON with overflow-triggering dimensions
-
DeliveryDeliver animation file to target application
-
ExploitUser or app triggers animation render
-
Install32-bit integer overflow in stride calculation
-
C2Undersized heap buffer allocated
-
ExecutePixel data written beyond buffer bounds
-
ImpactApplication crash (denial of service)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer-to-buffer conversion safety
|
| Exploitation Conditions | Exploitation requires that a user or application actively trigger rendering of a crafted Lottie animation file, which is reflected in the CVSS UI:R metric. The attacker requires no authentication (PR:N) but must successfully deliver the malicious animation file to an application that passes its width and depth values through rlottie's bitmap allocation path. No special non-default configuration is required; any rlottie deployment that processes externally supplied or user-provided animation files is vulnerable by default. Exploitation is concretely limited by the user-interaction requirement (the file must be rendered, not merely received or stored) and by the absence of confirmed heap exploitation primitives beyond crash (CVSS C:N/I:N). Platform-level mitigations such as ASLR and safe heap unlinking further constrain potential escalation beyond denial-of-service on hardened targets. |
| Impact | The CVSS 6.5 Medium score accurately reflects an availability-only impact (A:H, C:N, I:N) with no attacker privileges required (PR:N) but mandatory user interaction (UI:R), placing this squarely in the category of exploitable-but-gated denial-of-service. No EPSS score was provided in available data, and the vulnerability does not appear in CISA KEV, so exploitation probability cannot be quantified and active exploitation is not confirmed. That said, even a mid-sized municipal IT team in sopot managing a fleet of Tizen-based Smart TVs or embedded kiosk devices that render Lottie content from external sources should treat this as a meaningful availability risk, particularly since heap buffer overflows can produce reliable crashes and may - in certain runtime environments without strong heap mitigations - escalate beyond the conservative C:N/I:N metrics the reporter assigned. The UI:R requirement is the primary real-world mitigating factor: exploitation cannot occur without a user or application actively triggering render of the malicious file. Absence of EPSS data and POC code means exploitation likelihood cannot be independently corroborated; the risk picture would sharpen considerably if a tagged upstream release incorporating the fix were available to compare against deployed versions. |
| Exploit ScenarioDerived | An attacker crafts a malicious Lottie JSON animation file containing extreme bitmap dimension values - for example, a width large enough that mWidth * mDepth overflows uint32_t - and delivers it to a victim via a web page, email attachment, or embedded media link. When a user opens the file or the application automatically renders the animation, rlottie's vbitmap allocator produces a heap buffer far smaller than the actual pixel data, and the subsequent write crashes the host process. No public proof-of-concept code has been identified at time of analysis; however, the attack requires only crafting a valid-looking Lottie JSON with oversized dimension fields, which requires no specialized tooling. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 12, 2026
Heap buffer overflow in Samsung's rlottie animation rendering library allows remote denial-of-service via maliciously crafted Lottie animation files. An integer overflow in the 32-bit bitmap stride calculation inside vbitmap.cpp produces an undersized heap allocation; when the library then writes full-dimension pixel data into this allocation, heap corruption and application crash result. No public exploit has been identified at time of analysis, but any application embedding rlottie that renders untrusted animation content is exposed given the network-deliverable, user-interaction attack path reflected in CVSS PR:N/UI:R.
RemediationAI
Apply the upstream fix from GitHub PR #600 (https://github.com/Samsung/rlottie/pull/600) once a tagged release incorporating the commit is published - no specific patched version number has been confirmed from available data, so monitor the rlottie GitHub repository for a release that includes the 64-bit stride arithmetic and 128 MiB cap. Samsung Smart TV and Tizen firmware updates should be monitored separately, as the fix will need to be backported and shipped through device firmware channels. As a compensating control prior to patching, applications embedding rlottie should validate animation dimension fields before passing them to the renderer, rejecting files where width, height, or their product would exceed safe thresholds (the upstream fix uses 128 MiB as its reference cap); this adds an application-layer gate at the cost of rejecting unusually large but legitimate animations. Disabling auto-rendering of Lottie animation content from untrusted or external sources eliminates the attack surface entirely, though at the cost of the feature.
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 Samsung's open-source C++ library for rendering Lottie animations, a JSON-based vector animation format widely embedded in Samsung Smart TV firmware and Tizen OS. The root cause is CWE-680 (Integer Overflow to Buffer Overflow) in src/vector/vbitmap.cpp. The original code computed scanline stride as ((mWidth * mDepth + 31) >> 5) << 2 using 32-bit arithmetic, then allocated mStride * mHeight bytes. With attacker-controlled width or depth values large enough to overflow a uint32_t, the stride computation wraps around to a small value, producing a grossly undersized heap allocation; the subsequent pixel data write then overflows the buffer boundary. The fix committed in GitHub PR #600 promotes all dimension arithmetic to uint64_t, enforces a hard 128 MiB cap (kMaxBitmapBytes = 128ull * 1024 * 1024), and falls back to an empty zero-dimension bitmap for oversized or invalid inputs, preventing both the overflow and the allocation-size undercount. CPE cpe:2.3:a:samsung_open_source:rlottie:*:*:*:*:*:*:*:* covers all versions with no version bounds specified.
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
Malicious animation delivered over network, no attacker privileges required, mandatory user render interaction, with impact limited to application crash and no confirmed confidentiality or integrity loss.
Primary rating from Vendor (samsung.tv_appliance).
CVSS VectorVendor: samsung.tv_appliance
DescriptionCVE.org
Integer Overflow to Buffer Overflow vulnerability in Samsung Open Source rlottie allows Overflow Buffers.
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.
Affected Products (CPE)CVE.org
Related Vulnerabilities in Samsung rlottie Resource and Overflow Vulnerabilities
View all 2More in Samsung Open Source
View allOS 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
Denial-of-service in Samsung's Escargot JavaScript engine (commit 590345cc) stems from multiple unhandled exceptional co
EUVD-2026-57064
GHSA-r32h-pjq3-jjwf
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB