Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft PCX with truncated RLE scanline
-
DeliveryDeliver file to FFmpeg-based decoder
-
Exploitpcx_rle_decode underfills scanline buffer
-
ExecutionUninitialized heap bytes copied into pixels
-
ImpactRead leaked heap memory from output image
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Variable initialization
|
| Exploitation Conditions | Exploitation requires that a victim (or an automated service) decode an attacker-supplied PCX image using FFmpeg's PCX decoder (libavcodec/pcx.c), specifically a file whose RLE-encoded scanline data ends before bytes_per_scanline bytes are supplied. This is a LOCAL/file-processing vector with passive user interaction (UI:P): the attacker must get the crafted PCX into a decode path. Limiting factors: it is not remotely triggerable without the victim processing the file; impact is limited to disclosure of leaked uninitialized heap bytes rendered into output pixels (no code execution, no write/DoS); it affects FFmpeg versions 2.1 through 9.0.2, and updating to the fixed build (containing commit ecd5dfc) eliminates it. The practical exposure is highest in environments that automatically decode untrusted PCX input, such as media transcoders, thumbnail generators, and upload-processing pipelines. |
| Impact | This is a genuine but moderate-severity information-disclosure flaw (CWE-908, use of uninitialized resource), not a top-tier emergency. The supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:N/VA:N, 6.8) is internally consistent with the description: the attack vector is LOCAL and requires passive user interaction (UI:P), meaning a victim must decode an attacker-crafted PCX file rather than the flaw being remotely triggerable against a listening service. Impact is confined to confidentiality (VC:H) - leaked uninitialized heap bytes surface in decoded pixels - with no integrity or availability impact, so this is a memory-disclosure primitive, not code execution. The vuln.today decision label is 'this_month' (not act_now/emergency), and there is no CISA KEV listing and no EPSS score in the input, so there is no signal of active or widespread exploitation; the matching decision signals point to routine patching rather than emergency response. POC status: the references contain only the upstream fix PR and the patch commit - no public exploit reference is provided - so no public exploit is identified at time of analysis. The main caveat: AV:L plus UI:P describes a client-side/file-processing exposure, so real risk concentrates where FFmpeg automatically decodes untrusted PCX input (media pipelines, thumbnailers, transcoding services) rather than against servers at large. |
| Exploit ScenarioDerived | An attacker crafts a PCX image whose RLE scanline data terminates early, then delivers it to a victim or service that decodes it with FFmpeg (e.g., a thumbnail generator or transcoding pipeline). When pcx_decode_frame() processes the truncated scanline it copies the unfilled, uninitialized av_malloc() buffer tail into the output, exposing residual heap contents in the visible decoded pixels. No public exploit code is identified at time of analysis; the only published artifacts are the vendor fix PR and patch commit. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
Heap memory disclosure in FFmpeg's PCX decoder affects versions 2.1 through 9.0.2: a crafted PCX image whose RLE-encoded scanline data terminates early causes pcx_decode_frame() to copy uninitialized av_malloc() buffer contents into the visible decoded pixels, leaking heap bytes to whoever receives the output image. Impact is confidentiality-only (no code execution, no write, no denial of service) and the assessed 3.1 vector is AV:L/AC:L/PR:N/UI:R, meaning the crafted file must reach a decode path - locally or through an automated service - before the leak occurs. No public exploit code and no confirmed active exploitation were identified at time of analysis; practical exposure is concentrated in media transcoders, thumbnail generators and upload-processing pipelines that automatically decode untrusted PCX input, and an upstream fix commit is available.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - the correction is commit ecd5dfc308a164757e7f25b1afefd8db21b43cf9 (merged via PR 24868, https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/24868), which callers should apply to their FFmpeg tree or consume by moving to a build that contains that commit, since 9.0.2 and earlier are still vulnerable. Because impact requires the crafted PCX to be decoded, prioritize systems that automatically process untrusted images on the assessment's noted exposure surface - media transcoders, thumbnail generators and upload-processing pipelines - and treat PCX inputs from untrusted sources as the exposure to control until a fixed build is deployed. There is no code execution, write or denial-of-service component to compensate for, so the leak is fully eliminated only by the initialization fix; the advisory at https://www.vulncheck.com/advisories/ffmpeg-2.1-through-9.0.2-uninitialized-memory-leak-via-pcx-decoder and the source reference https://github.com/FFmpeg/FFmpeg/blob/n9.0.2/libavcodec/pcx.c#L45-L59 provide the vulnerability details for verification, and the vendor priority label for this issue is this_month rather than immediate emergency action.
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
FFmpeg's PCX decoder (libavcodec/pcx.c) decompresses run-length-encoded scanlines into a destination buffer obtained from av_malloc(), then converts that buffer into output pixels. In the vulnerable code path, pcx_rle_decode() called bytestream2_get_buffer(gb, dst, bytes_per_scanline) and discarded the return value; when the RLE stream ends before bytes_per_scanline bytes have been produced, the untouched tail of the heap allocation is never initialized and is subsequently treated as valid image data and rendered into the decoded frame. This is CWE-908 (use of uninitialized resource), a memory-hygiene defect rather than a bounds violation: there is no out-of-bounds access and no corruption, but residual heap contents from prior allocations can be exfiltrated through pixel values in the output file or frame. The upstream fix (commit ecd5dfc308a164757e7f25b1afefd8db21b43cf9, PR 24868) captures the return value of bytestream2_get_buffer() and zero-fills the unread remainder with memset(dst + i, 0, bytes_per_scanline - i), so truncated scanlines decode to deterministic zeroed data instead of leaked heap memory.
Know when Ffmpeg 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:H/VI:N/VA:N/SC:N/SI:N/SA:N
Local file-decode vector (AV:L) requiring the victim to process a crafted PCX (UI:R); no privileges needed (PR:N); only heap memory is disclosed, so C:H with I:N/A:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
FFmpeg 2.1 through 9.0.2 contains a use of uninitialized resource vulnerability in the PCX decoder that allows attackers to leak heap memory through truncated RLE scanlines. Attackers can craft a PCX image whose RLE data ends early, causing pcx_decode_frame() to copy uninitialized av_malloc() buffer contents into visible decoded pixels.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Related Vulnerabilities in FFmpeg Decoder Uninitialized Memory Leaks
View all 5FFmpeg 2.x allows remote attackers to conduct cross-origin attacks and read arbitrary files by using the concat protocol
FFmpeg before 2.8.12, 3.0.x and 3.1.x before 3.1.9, 3.2.x before 3.2.6, and 3.3.x before 3.3.2 does not properly restric
FFmpeg 2.x allows remote attackers to conduct cross-origin attacks and read arbitrary files by using the subfile protoco
The av_reallocp_array function in libavutil/mem.c in FFmpeg before 2.0.1 has an unspecified impact and remote vectors re
cbs_jpeg_split_fragment in libavcodec/cbs_jpeg.c in FFmpeg 4.1 and 4.2.2 has a heap-based buffer overflow during JPEG_MA
Out-of-bounds heap write in FFmpeg's RASC video decoder (decode_dlta in libavcodec/rasc.c) allows attackers to corrupt m
Memory corruption in FFmpeg before 8.1 allows an attacker who can supply a crafted H.264/HEVC media file to corrupt heap
Integer Overflow vulnerability in function filter_sobel in libavfilter/vf_convolution.c in Ffmpeg 4.2.1, allows attacker
Integer Overflow vulnerability in function filter_robert in libavfilter/vf_convolution.c in Ffmpeg 4.2.1, allows attacke
Integer Overflow vulnerability in function filter_prewitt in libavfilter/vf_convolution.c in Ffmpeg 4.2.1, allows attack
Integer Overflow vulnerability in function filter16_sobel in libavfilter/vf_convolution.c in Ffmpeg 4.2.1, allows attack
Integer Overflow vulnerability in function filter16_roberts in libavfilter/vf_convolution.c in Ffmpeg 4.2.1, allows atta
EUVD-2026-114741
GHSA-6hg3-f9xg-2hg4
NVD
CVE.org
VulDB
Exploit-DB