Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft MP4/MOV with oversized hdlr or url box
-
DeliveryDeliver file to victim
-
ExploitVictim application parses it with L-SMASH
-
ExecutionOversized box size stalls stream position
-
PersistHeap out-of-bounds write corrupts memory
-
ImpactApplication 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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.
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.
EUVD-2026-115216
GHSA-q7pj-x362-2v3p
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB