Skip to main content

libpng CVE-2026-46675

HIGH
2026-09-29
View

Attack ChainAIDerived

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

  1. Access
    Craft PNG with malformed zTXt/iTXt/iCCP chunk
  2. Delivery
    Victim app parses via png_read_info
  3. Exploit
    Early decompression abort leaves stale zlib pointer
  4. Execution
    App calls png_read_end without reading rows
  5. Persist
    Resume inflate from freed pointer
  6. Impact
    Use-after-free read crashes process

Vulnerability Assessment

Exploitation Conditions

Exploitation requires the target application to use libpng's sequential reader and to call png_read_end after png_read_info WITHOUT first reading the image rows (or calling png_start_read_image) - the maintainer notes this call sequence is rare in practice. The malicious input must be a PNG containing a zTXt, iTXt, or iCCP chunk that causes libpng to abandon zlib decompression early (invalid zlib window size, decompressed data exceeding limits, or an ICC profile failing validation). For the heap variant (zTXt/iTXt) a larger tEXt/pCAL chunk before IDAT must reallocate the read buffer to realize the use-after-free; the iCCP variant is a stack use-after-return. The crash outcome further depends on the freed memory being unmapped at read time. Limiting factors: no authentication or user interaction is required in CVSS terms, but the atypical application API usage and the memory-state dependency substantially constrain real-world reachability, and impact is confined to a crash (denial of service) with no data disclosure or corruption. Affected libpng 1.6.0 through 1.6.58; fixed in 1.6.59.

Impact

The vendor-supplied CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9 Medium) is internally consistent with the technical description and I concur with it. The vulnerability is network-reachable (a crafted PNG is delivered as data) and needs no authentication or user interaction in the CVSS sense, but AC:H is well-justified: exploitation depends on a specific and, per the maintainer, rare application call sequence (png_read_end invoked after png_read_info without reading image rows) plus precise heap grooming so that the freed buffer is reallocated or unmapped. Impact is availability-only (A:H, a crash) - the maintainer explicitly states the dangling pointer is only read into a discarded scratch buffer, so there is no confidentiality or integrity impact (C:N/I:N is correct). Exploitation status: no public exploit identified at time of analysis - there is no CISA KEV listing, no EPSS score, and no POC in the provided data; the two credited reports (Ze Sheng/O2Lab/AISLE and @JasonHonKL) are vulnerability discoveries, not weaponized exploits. This is best characterized as a real but low-priority defect: although libpng is ubiquitous, the flaw is not remote code execution, yields at most a crash, and only in applications using an atypical API sequence, so it is a genuine medium-severity hardening fix rather than an urgent threat. No key signals are conflicting; the main missing signals (EPSS, KEV, POC) are simply absent, which is consistent with a hard-to-reach availability bug.

Exploit ScenarioDerived

An attacker supplies a crafted PNG whose zTXt, iTXt, or iCCP chunk aborts zlib decompression early (e.g., an invalid zlib window size or an ICC profile that fails validation), leaving a stale zlib input pointer. If the victim application then calls png_read_end after png_read_info without having read the image rows, libpng resumes decompression from the freed/expired pointer, causing a heap use-after-free (or stack use-after-return for iCCP) that can crash the process when the memory is no longer mapped. No public exploit code is identified, and the vulnerable call pattern is uncommon, so practical impact is limited to denial of service.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Sep 29, 2026

Use-after-free in libpng 1.6.0 through 1.6.58 can crash applications that use the sequential reader and call png_read_end after png_read_info without first reading the image rows. A crafted PNG containing a zTXt, iTXt or iCCP chunk that makes libpng abandon zlib decompression early leaves a stale input pointer in the zlib stream; the zTXt/iTXt path then reads through a freed heap buffer (a larger tEXt or pCAL chunk before IDAT must first reallocate the read buffer), while the iCCP path is a stack use-after-return. Impact is confined to denial of service - the dangling pointer is only read into a discarded scratch buffer, so there is no data disclosure or corruption - and the required API call sequence is rare in practice; no public exploit has been identified at time of analysis, and the vendor rates it 5.9 Medium (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H), consistent with the independent assessment.

RemediationAI

Upgrade to libpng 1.6.59, which is the vendor-released fix for CVE-2026-46675, or apply upstream commit aa77ef38c17ab2fc1b41bec09fb973c6a386641d (https://github.com/pnggroup/libpng/commit/aa77ef38c17ab2fc1b41bec09fb973c6a386641d); because libpng is almost always statically linked or vendored, patching the system package is not sufficient - every application shipping its own copy, and any statically linked binary, must be rebuilt against 1.6.59 or the backported commit. If an immediate rebuild is not possible, apply the maintainer's workaround: never call png_read_end when the image rows have not been read, and if trailing chunks after the image data are needed, call png_start_read_image before png_read_end so the IDAT data is consumed and the zstream is no longer stale. Independently of patching, applications that call png_read_end without reading image rows should be prepared to handle a libpng error from that call, since the affected sequence already fails on well-formed files. Additional compensating controls, with trade-offs, are: reject or re-encode untrusted PNGs in an external sanitizer or converter before they reach libpng-consuming code (adds latency and may alter image metadata such as ICC profiles and text chunks); disable text and ICC chunk handling at build time via pnglibconf.h feature macros (blocks zTXt/iTXt/iCCP processing, potentially discarding color-management data plus metadata); and sandbox or isolate the image-parsing process so a failed read crashes only a disposable worker (mitigates the crash outcome but does not remove the defect). Note that patch availability only became general with the 1.6.59 release, so distributions may lag; service restart or image rebuild is required after upgrading for the fix to take effect in long-running processes.

Affected ProductsAI

libpng versions 1.6.0 through 1.6.58 inclusive are affected; the defect has been present since the 1.6.0 series began and is fixed in libpng 1.6.59, which is the version paired with advisory GHSA-qvg3-h654-xq3j (https://github.com/pnggroup/libpng/security/advisories/GHSA-qvg3-h654-xq3j) and release tag v1.6.59 (https://github.com/pnggroup/libpng/releases/tag/v1.6.59). Every downstream consumer that embeds libpng - including image processing utilities, browsers, PDF and graphics toolchains, and applications bundling the statically linked library - inherits the exposure whenever it uses the sequential reader. No CPE strings were supplied with the available intelligence, so affected instances must be identified by the bundled libpng version rather than by CPE matching; the libpng project home page at http://www.libpng.org/pub/png/libpng.html listed 1.6.58 as the current public release at the time this advisory was issued, so many packaged distributions and vendored copies may still be on an affected build even after the fix was published.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

libpng is the official PNG reference library and delegates all DEFLATE decompression of PNG text and profile chunks to zlib through a png_struct zstream. The vulnerability is a CWE-416 use-after-free with a CWE-825 expired-pointer dereference root cause: the chunk handlers png_decompress_chunk (used by zTXt/iTXt) and png_handle_iCCP released the claimed zlib stream but did not clear zstream.next_in / avail_in and next_out / avail_out, leaving them pointing at buffers that later code could free. Decompression is abandoned mid-stream when the zlib header has an invalid window size, when decompressed data exceeds libpng's acceptance limit, or when an ICC profile fails validation - all attacker-controllable through the crafted PNG. If the application then calls png_read_end after png_read_info without starting the image rows, png_read_end resumes zlib decompression from the stale pointer instead of reading IDAT. In the zTXt/iTXt (heap) variant the pointer references libpng's chunk read buffer, which is freed and reallocated by a later, larger chunk such as tEXt or pCAL appearing before IDAT; in the iCCP variant the pointer references local arrays of png_handle_iCCP, producing a stack use-after-return. The upstream fix commit (aa77ef38c17ab2fc1b41bec09fb973c6a386641d) introduces a png_inflate_detach_buffers() helper that nulls both pairs of zstream pointers and counts, and invokes it from png_inflate_claim, from the error/limit paths in png_decompress_chunk and png_handle_iCCP, and from png_read_finish_IDAT, so no stale ownership survives stream release. Note that libpng itself requires zlib (1.0.4 minimum, 1.2.13 or later recommended) but the defect lies in libpng's stream bookkeeping, not in zlib.

Know when the next one hits your stack

  • 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

vuln.today AI 5.9 MEDIUM

Network-delivered crafted file (AV:N) with no auth or interaction (PR:N/UI:N); AC:H for the rare call sequence and heap-grooming dependency; crash-only so C:N/I:N/A:H.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H

Lifecycle Timeline

2
Patch released
Sep 30, 2026 - 04:00 NVD
CVE Published
Sep 29, 2026 - 02:46 oss-security
CRITICAL

Description PRE-NVD

Disclosed via oss-security. NVD scoring and full description are pending.

Executive ViewAI

Why It Matters

libpng - the image-decoding library embedded in browsers, operating systems, document scanners, and countless enterprise applications - carries a use-after-free defect in versions 1.6.0 through 1.6.58 that can crash applications that process a crafted PNG. Because the flaw is reachable only through an uncommon API call sequence and its impact is confined to denial of service with no data disclosure or corruption, the practical exposure is an availability and resilience concern rather than a confidentiality or integrity one. Leadership should treat it as a tracked patch-management item for image-processing pipelines, noting that no vendor-released patch has been identified at time of analysis.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: run PNG decoding in a sandboxed, memory-limited, or isolated worker process so a use-after-free crash is contained to the decoder and does not affect the host application; re-encode or normalize untrusted PNG input with a trusted converter before it reaches libpng-dependent code; in applications that call libpng directly, avoid the sequence of png_read_end after png_read_info without first reading the image rows, and avoid abandoning zlib decompression early on zTXt/iTXt/iCCP chunks; restrict or rate-limit untrusted PNG uploads and monitor decoder processes for abnormal termination; track libpng upstream and distribution vendors for a fixed 1.6.x release and apply it promptly when available.

Threat Intelligence Overview

Prevalence
Ubiquitous
official PNG reference library, embedded in most software that renders PNGs
Social Media
1
Sightings
Data Quality
2 sources
Confidence: Low
CVE.org Vendor CIRCL GitHub

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 HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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.

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Not-Affected
SUSE Linux Enterprise High Performance Computing 12 Affected
SUSE Linux Enterprise Micro 5.3 Affected

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