Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious multi-frame GIF
-
DeliverySocial engineer victim to process file
-
ExploitApplication calls i_readgif_multi_low
-
ExecutionSkip-image branch invoked without bounds check
-
PersistDGifGetLine writes beyond GifRow buffer
-
ImpactHeap memory corruption
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 processing of a specially crafted multi-frame GIF file where individual frame dimensions (Image.Width + Image.Left or Image.Height + Image.Top) exceed the file's declared global screen dimensions (SWidth or SHeight). The vulnerability triggers specifically in the skip-image code path at imgif.c lines 790-805 when the library processes but does not render certain frames. User interaction is required (UI:R) - the victim application must open and process the malicious GIF file, typically through file upload, email attachment processing, or local file operation. The vulnerability affects only the GIF-specific module, so applications must use Imager::File::GIF for GIF processing; those using alternative GIF libraries are not affected. Local attack vector (AV:L) means the attacker cannot exploit this remotely without first delivering the malicious file through separate means (phishing, compromised upload endpoint, supply chain injection of malicious image assets). No authentication required (PR:N) indicates no special application privileges are needed beyond normal file processing permissions. |
| Impact | Real-world risk is low despite the CWE-787 classification. CVSS 5.3 reflects the AV:L (local file access required), UI:R (user must open malicious GIF), and limited impact scope (C:L/I:L/A:L). EPSS score of 0.02% (5th percentile) indicates extremely low observed exploitation probability. No CISA KEV listing and no public exploit identified at time of analysis. Attack complexity is low (AC:L) but requires social engineering to deliver the malicious file and user interaction to process it, making this primarily a supply chain concern for applications that automatically process user-uploaded GIFs. The CVSS vector indicates PR:N (no authentication required) which in this context means no special privileges needed beyond convincing a user to open the file. For Perl web applications processing GIF uploads, this is a meaningful risk; for desktop Perl scripts processing trusted local files, risk is minimal. Patch availability in version 1.003 provides straightforward mitigation. Priority should be moderate for internet-facing Perl applications with GIF processing, low for internal tools. |
| Exploit ScenarioDerived | An attacker crafts a malicious multi-frame GIF file with a global screen width of 100 pixels but includes a frame declaring width of 500 pixels with left offset causing the total to exceed buffer boundaries. When a Perl application using vulnerable Imager::File::GIF processes this file (e.g., web app thumbnail generation, image gallery processing), the skip-image code path calls DGifGetLine without validation, writing 400 bytes beyond the allocated heap buffer. This heap corruption could potentially be leveraged for code execution depending on heap layout, though the local attack vector and required user interaction limit practical exploitation to scenarios where attackers control processed image files. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 15, 2026
Heap buffer overflow in Imager::File::GIF (Perl image processing library) versions through 1.002 allows local attackers to corrupt memory via specially crafted multi-frame GIF files. The vulnerability stems from missing boundary validation in the skip-image code path, which writes image data beyond allocated buffer boundaries when processing malformed GIF frames. With EPSS score at 0.02% (5th percentile) and no evidence of active exploitation, this represents a low-probability supply chain risk for Perl applications processing untrusted GIF files. Patch released in version 1.003.
RemediationAI
Upgrade to Imager::File::GIF version 1.003 or later, which includes bounds validation checks moved earlier in the processing flow to cover both the page-match and skip-image code paths. The fix validates that Image.Left + Image.Width does not exceed SWidth and Image.Top + Image.Height does not exceed SHeight before any DGifGetLine operations. Update via CPAN with cpan Imager::File::GIF or manual installation from https://metacpan.org/release/TONYC/Imager-File-GIF-1.003. If immediate upgrade is not feasible, implement input validation to reject GIF files where individual frame dimensions exceed the declared global screen dimensions, though this requires custom parsing logic. For web applications, consider restricting GIF uploads or re-encoding uploaded GIFs through a sandboxed service using the patched library version. No workaround provides equivalent protection to the vendor patch.
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
Imager::File::GIF is a Perl module for reading and writing GIF images, part of the broader Imager image processing framework. The vulnerability affects the i_readgif_multi_low function in imgif.c, which processes multi-frame GIF files. The function allocates a single per-row buffer (GifRow) sized according to the GIF's global screen width (SWidth) and reuses it across all frames. While the primary image-processing branch validates that Image.Width + Image.Left does not exceed SWidth before writing via DGifGetLine, the parallel skip-image branch (lines 790-805 in the original code) omits this validation check. This CWE-787 (Out-of-bounds Write) allows attackers to craft GIF files where individual frames declare dimensions that exceed the global screen size, causing DGifGetLine to write past the allocated buffer boundary during the skip operation, resulting in heap corruption.
Know when Imager 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
AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:L
Primary rating from Vendor (CPANSec) · only source for this CVE.
CVSS VectorVendor: CPANSec
Lifecycle Timeline
2DescriptionCVE.org
Imager::File::GIF versions through 1.002 for Perl allow a heap out of bounds (OOB) write on crafted multi-frame GIF files.
Imager::File::GIF's i_readgif_multi_low allocates a single per-row buffer GifRow sized for the GIF's global screen width 'SWidth' and reuses it across every image in the file.
The page-match branch validates Image.Width + Image.Left > SWidth before each DGifGetLine write, but the parallel skip-image branch at imgif.c:790-805 calls DGifGetLine(GifFile, GifRow, Width) with no such check.
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.
Denial of service in the Imager image-processing module for Perl (all versions before 1.033) allows remote attackers to
The Imager package before 1.025 for Perl has a heap-based buffer overflow leading to denial of service, or possibly unsp
Perl's Imager image-manipulation module before version 1.037 exits the process when it reads a RAW-format image containi
Heap buffer overflow in Imager for Perl versions through 1.030 allows remote attackers to corrupt memory and potentially
Heap buffer overflow in the Perl Imager module before version 1.037 allows memory corruption inside i_gsampf_fp when a h
EUVD-2026-30535
GHSA-8r2w-8p2v-h4g4
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB