Skip to main content

rlottie EUVDEUVD-2026-34237

| CVE-2026-47318 MEDIUM
Stack-based Buffer Overflow (CWE-121)
2026-06-04 samsung.tv_appliance GHSA-r436-q6wh-rcxr
6.1
CVSS 3.1 · Vendor: samsung.tv_appliance
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft Lottie JSON with deep cubic Bezier path
  2. Delivery
    Deliver file to target filesystem
  3. Exploit
    Victim opens file in rlottie-embedding app
  4. Execution
    gray_render_cubic subdivides beyond 31 levels
  5. Persist
    bez_stack overflows on process stack
  6. Impact
    Application 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 ce72b35a7ad0dded03051d3aa0ef75321c3bd035. The attack vector is local (AV:L per CVSS), meaning the attacker must first deliver the malicious .json file to the target's accessible filesystem - for example, via a download, shared media, or embedded asset. No attacker authentication is required (PR:N per CVSS), but the victim's interaction is mandatory. Exploitation is further limited by the need for a specifically constructed Bezier curve that exhausts the 31-subdivision depth limit of bez_stack, and by platform-level stack protections (canaries, ASLR) that significantly reduce the likelihood of reliable code execution beyond a denial-of-service crash. Non-default configurations are not required - any application that renders an attacker-controlled Lottie file is exposed.

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, gray_render_cubic overflows the bez_stack array, triggering an application crash; on platforms without stack canaries, controlled memory corruption may be possible. No public POC exists at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Vendor (samsung.tv_appliance) PRIMARY 6.1 MEDIUM
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

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
High

DescriptionCVE.org

Stack-based buffer overflow vulnerability in Samsung Open Source rlottie allows Overflow Buffers.

This issue affects rlottie: before ce72b35a7ad0dded03051d3aa0ef75321c3bd035.

Threat Intelligence Overview

EPSS Score
0.0%
Top 98% exploitable
Social Media
1
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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

cpe:2.3:a:samsung_open_source:rlottie:*:*:*:*:*:*:*:*
CVE-2026-19588 MEDIUM
6.5 Aug 12

Heap buffer overflow in Samsung's rlottie animation rendering library allows remote denial-of-service via maliciously cr

CVE-2026-19587 MEDIUM
6.5 Aug 12

Uncontrolled resource consumption in Samsung's open-source rlottie library allows a crafted Lottie animation file to tri

CVE-2026-110392 CRITICAL
9.8 Oct 14

OS command injection in the Samsung QA-Board backend allows unauthenticated remote attackers to execute arbitrary operat

CVE-2026-47314 CRITICAL
9.8 May 19

Out-of-bounds write in Samsung's Escargot lightweight JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3

CVE-2026-47311 CRITICAL
9.8 May 19

Heap-based buffer overflow in Samsung's Escargot JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3) all

CVE-2026-47310 CRITICAL
9.8 May 19

Use-after-free memory corruption in Samsung's Escargot JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d

CVE-2026-8915 HIGH
8.8 May 28

Out-of-bounds write in Samsung's Escargot JavaScript engine allows attacker-supplied scripts to corrupt memory through t

CVE-2026-25208 HIGH
8.1 Apr 13

Integer overflow in Samsung Escargot JavaScript engine allows remote attackers to trigger buffer overflows without authe

CVE-2026-47308 HIGH
7.5 May 19

NULL pointer dereference in Samsung's open-source Walrus WebAssembly runtime crashes the parser when processing malforme

CVE-2026-47307 HIGH
7.5 May 19

NULL pointer dereference in Samsung Open Source Walrus's WebAssembly binary parser causes application-level denial of se

CVE-2026-47317 HIGH
7.5 May 19

Uncontrolled recursion in Samsung's Escargot JavaScript engine triggers excessive heap allocation, causing a denial-of-s

CVE-2026-47316 HIGH
7.5 May 19

Denial of service in Samsung Escargot JavaScript engine at commit 590345cc6258317c5da850d846ce6baaf2afc2d3 stems from mu

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy