Skip to main content

Imager::File::GIF CVE-2026-8454

| EUVDEUVD-2026-30535 MEDIUM
Out-of-bounds Write (CWE-787)
2026-05-15 CPANSec GHSA-8r2w-8p2v-h4g4
5.3
CVSS 3.1 · Vendor: CPANSec
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft malicious multi-frame GIF
  2. Delivery
    Social engineer victim to process file
  3. Exploit
    Application calls i_readgif_multi_low
  4. Execution
    Skip-image branch invoked without bounds check
  5. Persist
    DGifGetLine writes beyond GifRow buffer
  6. Impact
    Heap 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Imager::File::GIF 0 ≤1.002

Affected Packages

euvd imager_file_gif no fix

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

Vendor (CPANSec) PRIMARY 5.3 MEDIUM
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

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
Low
Integrity
Low
Availability
Low

Lifecycle Timeline

2
CVSS changed
May 15, 2026 - 15:22 NVD
5.3 (MEDIUM)
CVE Published
May 15, 2026 - 10:57 nvd
UNKNOWN (no severity yet)

DescriptionCVE.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

EPSS Score
0.0%
Top 95% exploitable
Social Media
1
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy