VLC Media Player Flaws Let Attackers Corrupt Memory and Leak Sensitive Data
VLC 3.0.0-3.0.23 has two flaws: a heap out-of-bounds write via malicious PNGs (CVE-2026-56711) and an out-of-bounds read via hostile RealRTSP servers.
CVE-2026-56711 is a heap out-of-bounds write (CVSS v4 8.6) caused by an integer overflow in VLC's AllocatePicture routine when processing PNG images with exceptionally large IHDR width and height values, allowing writes past the allocated buffer; it maps to CWE-190 and CWE-787 and was credited to Fabian Wahle of Hap Security. CVE-2026-73324 is a medium-severity out-of-bounds read (CVSS v4 6.9) in VLC's RealRTSP handling, where RtspReadLine copies response lines longer than 4,096 bytes into a fixed buffer without null termination, potentially leaking heap data back to a hostile RTSP server via the Session header. Both bugs affect VLC 3.0.0 through 3.0.23, and updated builds had not yet been released at the time of disclosure.
- CVE-2026-56711 (CVSS 8.6) is a heap out-of-bounds write triggered by crafted PNG images with oversized dimensions.
- An integer overflow in AllocatePicture wraps the buffer size so the PNG decoder writes beyond the allocation.
- CVE-2026-73324 (CVSS 6.9) leaks heap data through unterminated RTSP response lines echoed to hostile servers.
- Users should avoid untrusted PNG files and RealRTSP playlist entries until patched VLC builds ship.
Vulnerabilities mentionedAll →
| CVE | Vulnerability | CVSS | EPSS | Flags | Affected | Exposure | Published |
|---|---|---|---|---|---|---|---|
| CVE-2026-56711 | Heap buffer overflow in VLC media player via integer overflow in picture allocation VLC media player contains an integer overflow (CWE-190) in its picture buffer allocation: in AllocatePicture (src/misc/picture.c) the byte total is accumulated with 32-bit arithmetic, so for very large picture dimensions the product of plane pitch and lines wraps before it is widened to a 64-bit size, and both existing guard checks evaluate only the already-wrapped value. As a result, aligned_alloc reserves a much smaller buffer than the picture actually requires, and a crafted PNG whose IHDR chunk declares very large width and height values - which reaches the code through the image demuxer that only limits the input file's byte count, not the declared dimensions - causes the PNG decoder (modules/codec/png.c) to write past the end of the allocation with attacker-influenced length and content (CWE-787). Opening the malicious PNG file directly or through a playlist entry is sufficient to trigger the flaw under default settings, and per the high CVSS 4.0 score (8.6) the attacker gains high confidentiality, integrity, and availability impact on the player process, i.e., controlled heap corruption that can crash VLC and potentially execute code. All VLC users who open untrusted image files are potentially affected; the available data does not specify affected version ranges. No public proof-of-concept is known and the flaw is not listed in CISA's KEV, so no exploitation has been reported to date. Do: Until a patched VLC release is available, avoid opening untrusted PNG image files or playlist entries referencing images with VLC, and consider setting a different application as the default PNG handler. No fixed version is specified in the available data, so monitor VideoLAN advisories for an update addressing CVE-2026-56711 and apply it promptly when released. | 7.3 | <1% |
| massplausibly hundreds of millions of desktop installations (VLC has billions of cumulative downloads) | ||
| CVE-2026-73324 | Out-of-Bounds Read in VLC Media Player RTSP Module Leaks Heap Memory to Servers VLC media player's RTSP access module contains an out-of-bounds read caused by improper null-termination: RtspReadLine uses strncpy with the full buffer length (writing no terminator when the response line is as long as the destination), and rtsp_get then passes the 4096-byte BUF_SIZE buffer to strdup, which reads past the end of the heap allocation whenever a server returns a line of 4096 bytes or more. The flaw is triggered simply by opening a playlist entry that names a realrtsp URL, and the attacker controls the line length and therefore how far the over-read runs. Because the affected line is the Session header, the disclosed bytes are retained as the session identifier and sent back to the server on every subsequent request, so the operator of a hostile server directly receives adjacent client heap memory (high confidentiality impact with no integrity or availability impact, per the CVSS 4.0 score of 6.9). Anyone using a VLC build with the RTSP module enabled is affected — the official VideoLAN builds enable it, while some distribution packages ship it disabled — and user interaction is required. No public proof-of-concept or confirmed in-the-wild exploitation is known; EPSS assigns a 0.3% probability of exploitation within 30 days and the flaw is not in CISA's KEV. Do: Verify whether your VLC build includes the RTSP access module (official VideoLAN builds do; some Linux distributions ship it disabled). Until a patched release is identified — the disclosure data does not list a fixed version — avoid opening playlists or stream links pointing to realrtsp/RTSP URLs from untrusted servers, or disable the RTSP access module. Monitor VideoLAN for an updated release addressing CVE-2026-73324. | 5.3 | <1% |
| mass≈100M+ VLC users (official VideoLAN builds ship the RTSP module enabled; only users who open hostile realrtsp/RTSP links are actually at risk) |
Full article508 words · extracted from gbhackers.com · click to collapse
Two security vulnerabilities in VLC media player versions 3.0.0 through 3.0.23 could allow attackers to exploit heap memory issues. These vulnerabilities can be triggered by processing a malicious PNG file or connecting to attacker-controlled RealRTSP servers.
The more severe vulnerability, tracked as CVE-2026-56711, is a heap out-of-bounds write flaw with a CVSS v4 score of 8.6. This issue stems from an integer overflow in VLC’s picture buffer allocation logic, which occurs when the player processes a specially crafted PNG image.
The vulnerable routine, AllocatePicture, found in src/misc/picture.c, calculates the size needed for image planes by adding p->i_pitch multiplied by p->i_lines to a running allocation total.
Both variables are defined as 32-bit integer fields in include/vlc_picture.h, so the multiplication is performed with 32-bit arithmetic before the result is expanded into a size_t value.
An attacker can manipulate the PNG IHDR metadata by providing exceptionally large width and height values. This manipulation causes the multiplication to wrap to a smaller value, so aligned_alloc reserves an incorrectly sized heap buffer.
VLC’s PNG decoder then writes scanlines based on the original dimensions supplied by the attacker, allowing it to write beyond the allocated area.
Current checks do not prevent this condition. The pre-allocation overflow guard performs division using 64-bit arithmetic, while the subsequent limit check assesses the already wrapped allocation value.
The image demuxer also verifies the input file’s byte count instead of its declared image dimensions. Opening a malicious PNG directly or loading it from a playlist is sufficient to trigger the vulnerable processing path, and no special configuration is necessary.
Fabian Wahle from Hap Security credited this issue, which maps to CWE-190 (Integer Overflow or Wraparound) and CWE-787 (Out-of-bounds Write).
A separate medium-severity issue, CVE-2026-73324, impacts VLC’s handling of RealRTSP and carries a CVSS v4 score of 6.9. This bug is an out-of-bounds read caused by improper null termination in RTSP response processing.
In the RtspReadLine function, VLC copies response data to a fixed-size buffer using strncpy without ensuring that a terminating null byte is included.
If a hostile RTSP server returns a response line longer than 4,096 bytes, VLC later passes this unterminated buffer to strdup, which reads beyond its boundary until it encounters a stray null byte in adjacent heap memory.
An attacker can deliver the vulnerable line through the RTSP Session header. VLC then retains this data as a session identifier and sends it back to the server in later requests, potentially disclosing sensitive client data stored in heap memory to the malicious server.
The RealRTSP module is optional at build-time and may be disabled in certain distribution packages; however, it is enabled in official VideoLAN builds. Users should treat untrusted image files and RealRTSP playlist entries as potentially dangerous until VLC releases updated builds that address these issues.
Keep your SOC up to date on active malware & phishing within 24h of their emergence. Try ANYRUN to prevent incidents with early detection.
Divya is a Senior Journalist at GBhackers covering Cyber Attacks, Threats, Breaches, Vulnerabilities and other happenings in the cyber world.
Text extracted automatically; images, tables and formatting may be missing. Original: https://gbhackers.com/vlc-media-player-flaws/