The Vulnerability
I discovered a denial-of-service vulnerability in Sliver's HTTP(S) listener that allows an unauthenticated remote attacker to exhaust server memory by sending a specially crafted PNG image.
The issue originates in how Sliver processes PNG images received through its HTTP(S) listener. The image decoder can consume substantially more memory than the size of the original file suggests. By crafting an image with carefully selected dimensions, an attacker can cause the decoder to allocate an extremely large amount of memory during processing.
The interesting part was that the image did not need to be particularly large on disk. The amount of memory required to process it was significantly greater than its compressed size.
The vulnerability was assigned CVE-2026-77622 and affects Sliver 1.7.3. It was also published under GitHub Security Advisory GHSA-663m-7x7m-g4fw.
| Project | Sliver |
|---|---|
| Vulnerability | Unauthenticated memory exhaustion through PNG processing |
| CVE | CVE-2026-77622 |
| Affected version | 1.7.3 |
| Weakness | CWE-400, Uncontrolled Resource Consumption |
| Attack vector | Network |
| Authentication | Not required |
| Impact | Denial of service |
| Advisory | GHSA-663m-7x7m-g4fw |
| Research | Independent vulnerability research |
Finding the Issue
I began investigating the HTTP(S) listener and how it handled incoming requests. One area that caught my attention was image processing.
PNG files are compressed, meaning the amount of data required to represent an image on disk can be considerably smaller than the memory required to decode it. This is normal behavior, but it becomes a security concern when an application processes attacker-controlled images without adequately restricting their dimensions or decoded size.
The important distinction is between the size of the uploaded file and the amount of memory needed to process it.
An image with dimensions of 32,767 × 32,767 pixels can require approximately 4 GiB of memory when represented as an RGBA image:
That is a substantial allocation for an image that may have a much smaller compressed representation.
The listener did not adequately constrain the dimensions or resulting memory consumption before processing the image. This created an opportunity for an attacker to send an image that would cause excessive resource consumption during decoding.
The PNG Decoder
The underlying problem was not simply that PNG files were accepted. Image processing is an expected part of the listener's behavior.
The issue was the lack of sufficient resource limits around that processing.
A compressed image can expand significantly after decompression. Consequently, validating only the size of the incoming request does not necessarily protect an application from memory exhaustion.
The same principle applies to image dimensions. A relatively small compressed file can describe an image with an enormous pixel count.
In this case, the attacker could supply an image that caused the decoder to allocate an excessive amount of memory. Because the processing occurred through the HTTP(S) listener, this was not limited to someone with local access to the Sliver server.
Reaching the Vulnerable Functionality
An important part of the investigation was determining whether the image-processing functionality could actually be reached by an unauthenticated client.
The HTTP(S) listener exposed the relevant request-handling path, and the image could be supplied without first establishing an authenticated Sliver session.
That distinction matters. A memory exhaustion issue in an internal function is not necessarily a remotely exploitable vulnerability. The attacker must be able to reach the vulnerable functionality through an exposed interface.
I verified that an unauthenticated request could reach the image-processing path and trigger the excessive memory consumption.
This established the network attack surface and removed the need for valid Sliver credentials.
The Nonce and Request Handling
There was another interesting part of the investigation: reaching the relevant request-handling path involved a nonce.
The listener's behavior meant that the request could not simply be treated as an arbitrary image upload. I needed to understand how the nonce affected request processing and whether its possible values created a practical obstacle.
The nonce had 65,537 possible values, so I investigated whether it could be recovered or reached through the request-handling behavior.
This was important because identifying an expensive decoding operation is only part of vulnerability research. The complete attack path must also be practical from the attacker's position.
I was able to establish that the nonce did not prevent the unauthenticated attack from being exercised.
Demonstrating the Impact
The final step was validating that the crafted image caused the expected resource consumption in the listener.
The image could be processed without an authenticated session, and the resulting memory consumption was sufficient to exhaust the available resources and cause denial of service.
This is particularly relevant for Sliver because the affected component is part of its HTTP(S) listener. An attacker who can reach the listener can target the service without first obtaining an authenticated session.
The impact is availability. This finding does not demonstrate arbitrary code execution, credential disclosure, or control over the Sliver server.
Root Cause and Remediation
The root cause was insufficient resource management when processing attacker-controlled PNG images.
Image dimensions and decoded memory requirements need to be constrained before expensive decoding operations take place. Limiting only the compressed request size is insufficient because the decoded representation can be orders of magnitude larger.
Appropriate protections include:
- Enforcing maximum image dimensions.
- Limiting the maximum decoded image size.
- Rejecting images that exceed resource limits before expensive processing.
- Applying appropriate request and processing limits to the HTTP(S) listener.
These controls help prevent an attacker from using a small compressed image to trigger disproportionately large memory allocations.
Disclosure
I reported the vulnerability to the Sliver project. The issue was acknowledged and addressed through the project's security process.
The vulnerability was assigned CVE-2026-77622 and published as GHSA-663m-7x7m-g4fw. I also worked with another researcher who independently confirmed the behavior.
Final Thoughts
This finding was a good example of why security reviews should look beyond the obvious behavior of an application.
The listener was performing an ordinary operation: processing an image. The vulnerability came from the assumptions made about the resource requirements of that operation and the absence of sufficient restrictions on attacker-controlled input.
A file's size does not necessarily represent the resources required to process it. That distinction is easy to overlook, particularly when reviewing functionality that appears harmless at first.
For me, the most important part of this research was tracing the issue from the HTTP listener to the image decoder, then establishing that the vulnerable functionality could be reached without authentication.
← Back to all posts