Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconCraft PNG with overflow-inducing IHDR dimensions
-
DeliveryDeliver file to victim via email, web, or chat
-
ExploitVictim opens file in VLC
-
InstallImage demuxer bypasses byte-count guard
-
C2AllocatePicture wraps 32-bit product, allocates undersized buffer
-
ExecutePNG decoder writes attacker-controlled scanlines past buffer end
-
ImpactHeap corruption enabling crash or code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
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 | The only prerequisite is that the victim opens a crafted PNG file in VLC 3.0.0-3.0.23 - either directly or via a playlist entry containing the PNG. No non-default settings, no authentication, and no special server-side configuration are required; the image demuxer is active by default and the PNG codec is included in standard builds. What limits exploitation: (1) user interaction - the victim must open the file (UI:P/UI:R); (2) the attacker must calculate IHDR dimensions whose pitch*lines product wraps to a small value usable as an allocation size, requiring offline arithmetic but not environment-specific memory knowledge; (3) successful code execution beyond a crash requires defeating heap mitigations (ASLR, guard allocations) on the target platform. The vulnerability is not reachable via network streaming without user-initiated file open. |
| Impact | Real-world exploitation risk is moderate-low despite the severity of the primitive. The CVSS 4.0 vector (AV:L/AC:H/PR:N/UI:P) reflects that a user must actively open a crafted file, and the AC:H rating acknowledges the need to engineer specific IHDR dimensions that produce a useful wrapped allocation size. EPSS at 0.30% (22nd percentile) corroborates low near-term exploitation likelihood. No active exploitation is recorded in CISA KEV, and no public proof-of-concept has been identified at time of analysis. The impact ceiling is high - heap OOB write with attacker-influenced content and length is a classic RCE primitive on a user-privilege process - but achieving a reliable exploit requires bypassing modern heap mitigations (ASLR, guard pages, heap randomization). The discrepancy between the provided AC:H rating and the deterministic nature of the overflow (attacker fully controls IHDR dimensions) is worth noting: engineering the wrapped size to a small useful value requires calculation but is not probabilistically dependent on environment state, suggesting AC:L may be more accurate. Overall: genuine risk for VLC desktop users who open untrusted media files, but not an immediately automatable mass-exploitation scenario. |
| Exploit ScenarioDerived | An attacker crafts a PNG file whose IHDR declares width and height values chosen so that i_pitch * i_lines overflows 32-bit signed arithmetic to a small positive value (e.g., 4 or 8 bytes), passes the wrapped value through both allocation guards, and triggers a large heap write when libpng decodes the image. The victim receives the file via email, chat, or a web download and opens it directly in VLC or via a playlist - no non-default settings are required. The PNG decoder writes attacker-controlled scanline data well past the end of the tiny allocation, enabling potential code execution in the VLC process context. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 14, 2026
Heap out-of-bounds write in VLC Media Player 3.0.0 through 3.0.23 allows a local attacker to corrupt memory by tricking a user into opening a crafted PNG file with attacker-controlled dimensions. The root cause is a 32-bit integer overflow in AllocatePicture() where plane pitch-times-lines multiplication wraps before widening to the size_t accumulator, causing both overflow guards to pass on the already-corrupted value; aligned_alloc then reserves a small wrapped buffer while the PNG decoder writes full-dimension scanlines past its end. No public exploit has been identified at time of analysis, and EPSS indicates 0.30% exploitation probability over the next 30 days.
Earlier versions of this analysis (1)
Heap out-of-bounds write in VLC Media Player 3.0.0 through 3.0.23 enables remote code execution when a user opens a crafted PNG file. The vulnerability stems from a 32-bit integer overflow in AllocatePicture() that causes aligned_alloc to reserve a fatally undersized buffer while the PNG decoder writes scanlines sized from the original declared dimensions, producing attacker-controlled heap corruption. No special configuration or elevated privileges are required - opening a malicious PNG file directly or via a playlist entry is the complete attack path. No public exploit or CISA KEV listing has been identified at time of analysis.
RemediationAI
No vendor-released patched version has been independently confirmed from the available references at time of analysis. The upstream fix, if available, should be sought in VLC releases beyond 3.0.23 or in VLC 4.x. Monitor the VideoLAN security advisory page and the VLC GitHub repository for a patched release. As a compensating control, avoid opening PNG files (or media playlists containing PNG entries) from untrusted sources in VLC until a patch is released. Configuring the OS or desktop environment to associate PNG files with an alternative viewer (e.g., a browser or image viewer that does not share VLC's picture allocation path) removes the attack surface without impacting VLC's core audio/video functionality. Sandbox deployment of VLC (e.g., via Flatpak or AppArmor/seccomp profiles) limits the blast radius of successful exploitation to the sandboxed process. The VulnCheck advisory is at https://www.vulncheck.com/advisories/vlc-media-player-3.0.0-through-3.0.23-heap-out-of-bounds-write-via-integer-overflow-in-picture-allocation.
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
The vulnerability resides in VLC's picture allocation path (src/misc/picture.c, AllocatePicture), where the running byte total is computed as i_bytes += p->i_pitch * p->i_lines. Both i_pitch and i_lines are declared as int in include/vlc_picture.h (CWE-190), so the multiplication is evaluated at 32-bit signed precision and wraps before the result is added to the size_t accumulator. Because the pre-allocation overflow guard performs its division in 64-bit arithmetic against the widened accumulator - not the per-plane product - and the PICTURE_SW_SIZE_MAX comparison evaluates the already-wrapped value, neither guard catches the condition. The image demuxer (modules/demux/image.c) enforces only an input file byte-count limit, not a limit on IHDR-declared dimensions, so a PNG with large width and height fields reaches the codec (modules/codec/png.c) which writes scanlines sized from the real dimensions into the undersized allocation. CPE: cpe:2.3:a:videolan:vlc_media_player:*:*:*:*:*:*:*:* covering the 3.0.x branch.
Know when Vlc Media Player 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:H/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
AV:L and UI:R because the user must open a local or downloaded file; AC:L because the overflow is deterministic given attacker-chosen IHDR dimensions; full C/I/A:H for heap OOB write with attacker-controlled content enabling potential RCE.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
3DescriptionCVE.org
VLC media player computes the size of a picture buffer with 32-bit arithmetic and allocates from the wrapped result. In AllocatePicture in src/misc/picture.c the running total is accumulated as i_bytes += p->i_pitch * p->i_lines, and both plane_t fields are declared int in include/vlc_picture.h, so the multiplication is evaluated at 32 bits and wraps before it is widened to the size_t accumulator. The overflow check that precedes it divides in 64-bit arithmetic and therefore does not constrain the product, and the subsequent comparison against PICTURE_SW_SIZE_MAX examines the already wrapped value, so both guards pass. aligned_alloc then reserves the small wrapped size while the decoder writes scanlines sized from the original dimensions. A crafted PNG whose IHDR declares large width and height reaches this path through the image demuxer, whose only size guard is on the input file's byte count rather than the declared dimensions, and the decoder in modules/codec/png.c writes past the end of the allocation with attacker-influenced length and content. Opening the file directly or through a playlist entry is sufficient, with no non-default settings.
Executive ViewAI
VLC Media Player versions 3.0.0 through 3.0.23 contain a heap memory vulnerability enabling remote code execution when users open specially crafted PNG files. The attack is unauthenticated and requires no special configuration-any employee, customer, or partner using affected versions faces immediate risk. With no vendor patch currently available, organizational exposure is elevated until remediation through version upgrades or mitigation controls can be deployed.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict PNG file opening to trusted sources only; disable PNG rendering in VLC settings if operationally acceptable; run VLC in sandboxed or low-privilege environments; substitute alternative media players for processing files from untrusted origins until a patch is available.
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.
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
More in Vlc Media Player
View allStack-based buffer overflow in VideoLAN VLC media player before 2.0.1 allows remote attackers to execute arbitrary code
Multiple buffer overflows in VideoLAN VLC media player 2.0.4 and earlier allow remote attackers to cause a denial of ser
Buffer overflow in the DecodeAdpcmImaQT function in modules/codec/adpcm.c in VideoLAN VLC media player before 2.2.4 allo
Videolan VLC prior to version 3.0.20 contains an incorrect offset read that leads to a Heap-Based Buffer Overflow in fun
Potential heap based buffer overflow in ParseJSS in VideoLAN VLC before 2.2.5 due to skipping NULL terminator in an inpu
In VideoLAN VLC media player through 2.2.8, there is a type conversion vulnerability in modules/demux/mp4/libmp4.c in th
VideoLAN VLC media player 2.2.x is prone to a use after free vulnerability which an attacker can leverage to execute arb
The picture_Release function in misc/picture.c in VideoLAN VLC media player 2.1.5 allows remote attackers to execute arb
lavc_CopyPicture in modules/codec/avcodec/video.c in VideoLAN VLC media player through 3.0.7 has a heap-based buffer ove
plugins\audio_filter\libmpgatofixed32_plugin.dll in VideoLAN VLC media player 2.2.4 allows remote attackers to cause a d
The CAF demuxer in modules/demux/caf.c in VideoLAN VLC media player 3.0.4 may read memory from an uninitialized pointer
plugins\codec\libflac_plugin.dll in VideoLAN VLC media player 2.2.4 allows remote attackers to cause a denial of service
EUVD-2026-74906
GHSA-35jx-w2j3-h2m2
NVD
CVE.org
EPSS
VulDB
Exploit-DB