Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted CCITT/MH strip TIFF to image decoder
-
ExploitOversized makeup-code run bypasses missing row-width check
-
ExecutionUnchecked BitWriterUtils.WriteBits writes past strip buffer
-
ImpactHeap corruption terminates the process
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 the target application to decode an attacker-supplied TIFF that uses strip (non-tiled) organization with CCITT Group 3 (T4) or Modified Huffman compression, processed by ImageSharp versions 3.0.0 through 4.1.0; the malicious run must use makeup codes that expand beyond the current row width so the write occurs before the (previously missing) width validation. Limiting factors: the application must accept and decode untrusted TIFF input, and the file must specifically use these CCITT/MH strip code paths (the tiled decompressor-width mismatch is a separate issue). No authentication (PR:N) or user interaction (UI:N) is required on the target, but the realistic impact is a process crash/DoS, not confidentiality or integrity loss. |
| Impact | All available signals converge on this being a genuine but availability-only (denial-of-service) issue rather than a code-execution emergency. The provided CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) describes a network-reachable, low-complexity, unauthenticated flaw whose only impact is A:H - consistent with the description's end state of heap corruption that 'terminates the process.' There is no confidentiality or integrity impact claimed, so despite the CWE-787 out-of-bounds write and 'Memory Corruption' tags, the vendor advisory frames the realistic outcome as a crash, not arbitrary code execution. No EPSS score was supplied and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation; no public exploit/POC is referenced either. The net picture is a credible, easily-triggered DoS against any .NET service that decodes untrusted TIFFs, but no confirmed in-the-wild activity. Note one caveat: EPSS and KEV data are simply absent from the input (not low), so exploitation probability cannot be quantified - absence should not be read as 'safe,' only as 'unmeasured.' |
| Exploit ScenarioDerived | An attacker uploads or submits a malicious TIFF image to a .NET web application or service that uses ImageSharp 3.0.0-4.1.0 to decode or thumbnail user-supplied images. The crafted strip TIFF uses CCITT Group 3 or Modified Huffman compression with an oversized makeup-code run that exceeds the row width, causing an unchecked write past the strip buffer that corrupts the heap and crashes the process. No public exploit code is identified, but the trigger is a single malformed file requiring no authentication or user interaction on the target. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 06, 2026
Heap buffer overflow in SixLabors ImageSharp (all versions from 3.0.0 up to but excluding 4.1.1) is triggered when the library decodes a strip-organized TIFF file that uses CCITT Group 3 (T4) or Modified Huffman compression: attacker-controlled run lengths are written into the strip buffer before the current row width is validated, corrupting heap memory and terminating the host process. Exploitation is remote and requires no authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), but the realistic outcome is denial of service - a crash - rather than data disclosure or modification, and no public exploit code was identified at time of analysis. The issue is fixed in ImageSharp 4.1.1 via the vendor advisory GHSA-jj3q-cwqj-842r and pull request #3176.
RemediationAI
Vendor-released patch: upgrade SixLabors.ImageSharp to 4.1.1 (release https://github.com/SixLabors/ImageSharp/releases/tag/v4.1.1), which incorporates the fix merged in PR https://github.com/SixLabors/ImageSharp/pull/3176 (commit e8892ecd8a95dee95c4480fda51cfe0b32f3b846) and adds the pre-write run-length/row-width validation that prevents the overflow; the security advisory is https://github.com/SixLabors/ImageSharp/security/advisories/GHSA-jj3q-cwqj-842r. Upstream fix available via PR/commit; the released patched version 4.1.1 is confirmed by the tagged release. Because the CVSS vector indicates network-reachable, unauthenticated triggering (AV:N/PR:N/UI:N) with availability-only impact, prioritize upgrades in any service that decodes user-supplied images and, where third-party libraries pin or bundle ImageSharp, raise a dependency-bump request upstream. If immediate upgrade is not possible, apply compensating controls with the trade-offs noted: reject or quarantine TIFF uploads whose compression tags indicate CCITT T4/Modified Huffman before they reach ImageSharp - this is effective but silently drops legitimate fax/CCITT TIFF use cases; transcode untrusted TIFFs to a safe raster format in a separate, memory-limited process before handing files to the main application - this adds latency and infrastructure cost but contains any heap corruption to a throwaway worker; run the decoding service in an isolated sandbox with strict memory limits, restarts on crash, and no privileged credentials, accepting that crafted files will still crash individual workers (availability risk, not a fix); or disable TIFF decoding entirely in the affected component, which fully removes the attack surface at the cost of TIFF functionality. Note that no vendor-published workaround replaces the patch, and blocking at the network edge is only partial since any internal source can submit files.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in nuget
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a classic out-of-bounds write (CWE-787) in ImageSharp's TIFF fax decompressors. In TIFF, CCITT Group 3 (T4) and Modified Huffman (MH, a.k.a. Group 3 1-D) compress bilevel scanlines as alternating white/black pixel runs encoded with terminating and makeup codes; each decoded run is emitted into a destination row buffer sized by the image (strip) width. In T4TiffCompression.WritePixelRun, oversized makeup-code runs could accumulate past the row boundary and be forwarded to BitWriterUtils.WriteBits, which performs unchecked bit writes; similarly, ModifiedHuffmanTiffCompression.Decompress validated pixelsWritten against the width only after the run had already been written. The upstream fix in PR #3176 adds a guard comparing bitReader.RunLength against (width - pixelsWritten) before the unchecked writer is invoked, throwing an image-format exception instead of overflowing, and moves the Modified Huffman check earlier in the decode loop. The same pull request separately corrects the framing width used by TiffDecompressorsFactory for tiled images (faxWidth = isTiled ? tileWidth : width); per the advisory and our assessment, that tiled decompressor-width mismatch is a distinct defect from this strip-path overflow. The affected component is the NuGet package SixLabors.ImageSharp, matched by CPE cpe:2.3:a:sixlabors:imagesharp:*:*:*:*:*:*:*:* for versions 3.0.0 through 4.1.0, which is used both directly and transitively by server-side image-processing pipelines that accept untrusted uploads.
Know when Imagesharp 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:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
A remotely supplied image reaches the decoder without auth or interaction (AV:N/AC:L/PR:N/UI:N); advisory describes heap corruption ending in process termination, so A:H only with C:N/I:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
ImageSharp is a 2D graphics library. From 3.0.0 until 4.1.1, decoding a strip TIFF using CCITT Group 3 or Modified Huffman compression can pass attacker-expanded runs to BitWriterUtils.WriteBits without first checking the current row width. T4TiffCompression.WritePixelRun can accumulate oversized makeup-code runs, and ModifiedHuffmanTiffCompression.Decompress validates the width only after writing. The unchecked writes can overflow the strip buffer, corrupt heap memory, and terminate the process. This strip-path vulnerability is distinct from the tiled decompressor-width mismatch. This issue is fixed in version 4.1.1.
Technical POC Analysis
CWE-787 (out-of-bounds write).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A memory-safety flaw in SixLabors ImageSharp, the .NET image-processing library embedded in many of our web applications and internal services, lets an unauthenticated remote party crash any process that decodes a maliciously crafted TIFF file. The realistic outcome is service disruption rather than theft or alteration of data, but because image upload and thumbnail pipelines are typically internet-facing and take no user interaction to trigger, a single malformed file can take down a customer-facing endpoint. Leadership should care because the exposure is broad (every service on ImageSharp 3.0.0 through 4.1.0), the attacker cost is near zero, and the fix requires coordinated library upgrades across multiple teams and products.
Apply vendor patch (upgrade to ImageSharp 4.1.1 or later). Where upgrading is not yet possible, disable TIFF decoding or restrict accepted image formats to those the business requires, reject or quarantine TIFF files using CCITT Group 3 (T4) or Modified Huffman compression at the upload boundary, process images in isolated sandboxed worker processes with memory and CPU limits plus automatic restart, and enforce strict upload size limits to lower the chance of a successful trigger.
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.
More in Imagesharp
View allImageSharp is a 2D graphics API. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authenti
ImageSharp is a managed, cross-platform, 2D graphics library. Rated high severity (CVSS 7.1), this vulnerability is no a
Out-of-bounds heap writes in the ImageSharp TIFF CCITT Group 4 (T6) fax encoder, affecting versions 2.1.0 through 4.1.1,
Denial of service in SixLabors ImageSharp (2.0.0 up to but not including 4.1.2) lets a remote, unauthenticated attacker
TIFF encoding in SixLabors ImageSharp 2.0.0 through 4.1.1 can write past the end of an undersized compressed-data buffer
Heap corruption and process termination in SixLabors ImageSharp 3.0.0 through 4.1.0 can be triggered by decoding a craft
Memory corruption in SixLabors ImageSharp 4.0.0 through 4.1.1 allows an unauthenticated remote attacker to crash or dest
ImageSharp is a 2D graphics API. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authenti
ImageSharp is a 2D graphics API. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authenti
ImageSharp is a 2D graphics API. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, no authen
ImageSharp is a 2D graphics API. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, no authen
Information disclosure in SixLabors ImageSharp 4.0.0 through 4.1.1 allows an attacker who supplies a crafted OpenEXR ima
EUVD-2026-93560
GHSA-jj3q-cwqj-842r
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB