Skip to main content

L-SMASH EUVDEUVD-2026-115216

| CVE-2026-120456 MEDIUM
Out-of-bounds Write (CWE-787)
2026-11-02 VulnCheck GHSA-q7pj-x362-2v3p
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft MP4/MOV with oversized hdlr or url box
  2. Delivery
    Deliver file to victim
  3. Exploit
    Victim application parses it with L-SMASH
  4. Execution
    Oversized box size stalls stream position
  5. Persist
    Heap out-of-bounds write corrupts memory
  6. Impact
    Application crashes

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires an application that uses L-SMASH (through 2.14.5) to parse an attacker-supplied MP4 or MOV file; the malicious file must declare an hdlr box or a dref 'url ' entry box whose size is larger than the remaining data in the stream, which stalls the stream position and drives the heap out-of-bounds write. The flaw is local file-parsing (AV:L) and needs victim interaction to open/process the file (UI:P per CVSS 4.0, PR:N - no authentication). Limiting factors: the attacker cannot reach the code path without the victim feeding the crafted media to a vulnerable L-SMASH build, and the observed effect is memory corruption leading to a crash rather than a confirmed code-execution primitive.

Impact

This is a medium-severity, local-vector memory-corruption flaw (CVSS 4.0 base 6.9). The supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H) shows the dominant impact is availability (VA:H) - i.e. crashing the host application - with only limited integrity impact (VI:L) from the heap write and no confidentiality impact (VC:N). Exploitation is not remote-automatable: it requires a victim to process an attacker-supplied file (UI:P), so the vector is local file-parsing rather than network service exploitation. No EPSS score was provided, so exploitation-probability cannot be quantified; the CVE is NOT listed in CISA KEV, so there is no confirmation of active exploitation. Several PoC-style references exist (the upstream issue, a HackMD writeup, and a VulnCheck advisory), but the input does not confirm any of them as working exploit code. The vuln.today decision label is 'this_month', consistent with a patchable, non-emergency memory-safety bug whose realistic worst case is denial of service rather than reliable remote code execution. Net: a legitimate bug to patch in the normal cycle, not a drop-everything emergency - and the low real-world footprint of the affected library further tempers urgency. The only notable nuance is that a heap out-of-bounds write (CWE-787) can sometimes be escalated beyond a crash, but the available evidence describes the observed effect only as heap corruption that crashes applications, so anything beyond DoS is unverified.

Exploit ScenarioDerived

An attacker crafts an MP4 or MOV file whose hdlr box or dref url entry declares a box size larger than the remaining data, then delivers it to a victim who opens or transcodes it with an application built on L-SMASH ≤ 2.14.5. During parsing the oversized box size stalls the stream position and triggers a heap out-of-bounds write that corrupts memory and crashes the application. A public PoC reference exists (upstream issue #112, a HackMD writeup, and a VulnCheck advisory); it is not verified as working exploit code.

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

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

Alert me

AnalysisAIv1 – Nov 02, 2026

Heap out-of-bounds write in L-SMASH through 2.14.5 lets a crafted MP4 or MOV file corrupt heap memory inside applications that use the library to demux media, typically ending in a crash. The flaw lives in the ISO-BMFF box parsers isom_read_hdlr() and isom_read_dref_entry() in core/read.c, which trust a declared hdlr or dref 'url ' box size larger than the bytes actually remaining in the stream, stalling the stream position and driving the write past the allocated buffer. The assessed vector is local (AV:L) with user interaction (UI:R), no authentication, no confidentiality impact, limited integrity impact and high availability impact (CVSS 3.1 6.9 equivalent); an upstream fix commit exists, but no tagged patched release or working exploit code has been independently confirmed, and the issue is not in CISA KEV.

RemediationAI

Apply the upstream fix commit 805ee3c9632e054198d3cb5b09c7b7aa36cdd791 (https://github.com/l-smash/l-smash/commit/805ee3c9632e054198d3cb5b09c7b7aa36cdd791), which adds remaining-bytes validation before box-size-driven seeks in core/read.c; patch availability is recorded as available from the vendor, but no tagged release carrying the fix is independently confirmed in the available data, so verify with the project at https://github.com/l-smash/l-smash/issues/112 before relying on a packaged version. Until a downstream build with the commit is deployed, treat this as a file-parsing exposure: keep untrusted MP4/MOV input away from L-SMASH-linked demuxers and media pipelines, run those consumers with reduced privileges or in a sandbox so that a heap corruption crash does not escalate, and note that such isolation lowers availability risk from malformed files but does not fix the underlying write. No other workaround is documented in the available sources, and the decision signal is this_month rather than emergency, consistent with the local, interaction-required trigger and the crash-only impact observed so far.

Affected VersionsENISA

l-smash 0 ≤2.14.5

Affected Packages

euvd l_smash no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

L-SMASH is a C library that reads and writes the ISO Base Media File Format used by MP4 and MOV containers. Parsing is box-driven: each box carries a 32- or 64-bit size field, and the parsers advance a stream cursor by that size. In isom_read_hdlr() and isom_read_dref_entry(), an attacker-controlled box size that exceeds the data actually remaining in the buffer (or file) was not validated before being used to advance the position and compute read lengths, so subsequent reads and writes operate on stale or negative-derived offsets, producing a heap out-of-bounds write (CWE-787). The upstream fix commit 805ee3c9632e054198d3cb5b09c7b7aa36cdd791 introduces a read_check_box_remaining_bytes() helper and adds end-of-buffer, end-of-file, size-underflow and oversized-count checks across read_unknown_box(), read_ftyp(), read_styp(), read_sidx(), read_qt_color_table() and the full-box/children readers, i.e. it hardens the shared box-size trust boundary rather than patching a single call site. The vulnerable code paths cited in the advisory are core/read.c lines 688-717 and 853-876 of tag v2.14.5.

Know when L Smash 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 (VulnCheck) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Local file parsing needing the victim to open a crafted media file (AV:L, UI:R, PR:N); impact is mainly a crash (A:H) with limited integrity from the OOB write (I:L) and no confidentiality.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

L-SMASH through 2.14.5 contains a heap out-of-bounds write vulnerability in isom_read_hdlr() and isom_read_dref_entry() in core/read.c triggered by oversized box sizes. Attackers can supply crafted MP4 or MOV files declaring hdlr or url box sizes larger than remaining data, stalling the stream position and corrupting heap memory to crash applications.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
niche open-source MP4/MOV muxing library, limited to media-tooling deployments
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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.2%
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

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
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.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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