CVE-2026-55200: The Public PoC That Turns Any SSH Client Into the Target

Introduction

On June 29, 2026, a functional proof of concept (PoC) was published for CVE-2026-55200, a critical vulnerability (CVSS 4.0: 9.2) in libssh2, the open-source library that implements the SSHv2 protocol on the client side. Unlike most incidents that make headlines, which tend to focus on servers exposed to the internet, this case flips the traditional threat model: the vulnerable component is not the SSH server, but any client application that connects to a malicious or compromised SSH server. Since libssh2 is embedded in tools such as curl, Git, PHP, backup agents, firmware updaters, and a very long list of embedded devices, the release of this PoC drastically lowers the barrier to exploitation and forces security teams to rethink their asset inventory: it is no longer enough to audit what the organization exposes outward — it is now equally important to track where its own systems connect to.

What Is the Flaw in libssh2?

CVE-2026-55200 is a pre-authentication exploitable memory corruption flaw affecting all versions of libssh2 up to and including 1.11.1.

• libssh2 is not an SSH server; it is a C library that numerous applications use to act as an SSH/SFTP client: establishing outbound connections, transferring files, or executing remote commands.
• The problem arises during the handshake (the initial connection negotiation), i.e., the moment when the client and server exchange the first packets of the protocol, before any authentication takes place.
• An attacker who controls — or has compromised — an SSH server can send a specially crafted packet to any client that connects to it. That packet triggers memory corruption in the client process, which in the worst-case scenario results in remote code execution (RCE).
• Most notably, no valid credentials or user interaction are required beyond the client application initiating the connection to the malicious server. This makes it a high-impact, low-complexity vulnerability to exploit.
• Because this is a library that is frequently statically linked, many vulnerable copies are not automatically updated when the operating system applies patches, silently widening the exposure surface.

How Does It Work?

The flaw resides in the ssh2_transport_read() function, inside transport.c, which is responsible for parsing incoming SSH packets during the transport phase of the handshake.

Overflow mechanism:

• The SSH protocol includes a packet_length field that indicates the size of the received packet.
• In the vulnerable code path, libssh2 calculates the total memory to allocate by adding packet_length + mac_len + auth_len, using 32-bit operands before converting the result to size_t.
• A malicious server can send an encrypted packet whose packet_length field contains an excessively large value. When added to the mac_len and auth_len components using 32-bit operands, the arithmetic operation overflows the integer (integer overflow) and wraps around (wrap-around).
• Because the upper-bound validation of packet_length occurs too late — or is missing entirely — in that path, the memory allocator (heap) reserves a tiny buffer; however, the subsequent logic then attempts to write the actual size of the packet sent, resulting in a heap out-of-bounds write (CWE-680) that corrupts adjacent memory structures and allows the attacker’s data to overflow the reserved space.
• Depending on the target binary, the behavior of the memory allocator, and the mitigations active on the system (ASLR, stack canaries, etc.), this corruption can escalate from a simple process crash (DoS) to control over function pointers and, consequently, arbitrary code execution with the privileges of the client process.

About the published PoC:

• It was uploaded to a GitHub repository called “exploitarium”, whose own author notes that the entries were published without a prior coordinated disclosure process.
• The material consists of an arithmetic verifier demonstrating the overflow, a scaffold that simulates a malicious SSH server capable of triggering the condition, and a controlled, local remote-code-execution harness demonstrating the exploitation class in a lab environment.
• The authors and researchers who have analyzed the material agree that this is not a remote “off-the-shelf” exploit: turning it into a reliable RCE chain against a real production application still depends on the specific binary, the memory allocator’s behavior, operating system mitigations, and how each piece of software integrates libssh2.
• Even so, the public availability of the code significantly reduces the reverse-engineering effort a threat actor would need to develop a working variant against a specific target.

Affected Systems and Components

• libssh2: all versions up to and including 1.11.1. Fixed in commit 97acf3d (merged on June 12, 2026 via pull request #2052), which adds a validation of packet_length against the LIBSSH2_PACKET_MAXPAYLOAD limit before the vulnerable addition operation.
• Applications and projects that link against libssh2 (and therefore inherit the exposure if they connect to untrusted SSH servers):
  • curl, when compiled with SFTP/SCP support based on libssh2.
  • Git and graphical clients that rely on libssh2 for SSH operations.
  • PHP, through the ssh2 extension.
  • The ssh package for the R language.
  • Backup agents, firmware updaters, network devices, and embedded appliances that implement SSH client functionality on top of this library.
• An aggravating factor: since this is a library that is frequently statically linked, updating the operating system package (e.g., via apt or yum) does not necessarily update the copies embedded within third-party binaries.
• The same June 2026 patch and disclosure batch also included fixes for two additional high-impact vulnerabilities: CVE-2026-55199 (CVSS 8.2): A denial-of-service (DoS) issue that traps the client in a CPU loop via a spoofed extension count during key exchange. CVE-2025-15661 (CVSS 8.3): A heap over-read vulnerability in SFTP handling. Note: although this identifier was originally reserved in late 2025, its official mitigation and public mass rollout were coordinated to be part of this same global library update package in 2026.

Mitigation and Detection

Priority remediation:

• Conduct a thorough inventory of all software that links against libssh2, including static or bundled copies that operating system package managers will not automatically report. curl, Git, and PHP deployments are the most common carriers; backup agents, network device firmware, and automation/CI-CD tools should also be reviewed.
• Apply a build that includes commit 97acf3d, either through a backport from the distribution in use or by compiling from the patched source code. Some distributions (such as Debian, in its testing branch) already ship the fixed version; it is worth monitoring the relevant vendor’s announcement channels to track the status of the official tagged release.
• Also apply the patches for CVE-2026-55199 and CVE-2025-15661, fixed in the same batch.
• For third-party or vendor binaries with static linking, request out-of-band patches and monitor the vendor’s security bulletins, since the fix depends on them recompiling and distributing a new version.

Compensating controls while patching is completed:

• Restrict outbound SSH connections from client systems to explicitly trusted servers only, prioritizing processes that connect to external endpoints or that resolve hostnames an attacker could redirect (for example, via DNS spoofing or compromise of intermediate infrastructure).
• Rigorously verify host keys on every connection, avoiding automatic acceptance of unrecognized fingerprints.
• Within the patching process, prioritize clients that interact with external SSH servers, automation services, CI/CD pipelines, backup agents, and IoT/embedded devices, given their higher level of exposure.

Indicators of compromise and auditing:

• Monitor for anomalies in packet size during SSH negotiation, particularly packet_length values that are unusually large or close to 32-bit integer limits.
• Watch for unexpected crashes or terminations of client processes (curl, backup agents, PHP processes, Git clients) immediately after initiating an outbound SSH connection, especially during the handshake phase.
• Log and correlate the destinations of outbound SSH connections initiated by critical systems, paying particular attention to connections toward hosts not previously cataloged in the trusted asset inventory.
• Since no active exploitation in the wild has been reported at this time, detection efforts should focus on identifying early reconnaissance or exploitation attempts rather than responding to already-consumed incidents.

Wrapping Up

CVE-2026-55200 illustrates a pattern the threat intelligence community had already observed back in 2019 with CVE-2019-3855, an almost identical integer overflow in the same libssh2 transport function: client-side flaws in widely reused infrastructure libraries can be just as dangerous as — or more dangerous than — server-side vulnerabilities, precisely because they break the assumption that risk is concentrated in systems that receive inbound connections. With a CVSS score of 9.2, no authentication or user-interaction requirements, and a PoC already publicly available — even though it is local in nature and not directly “off-the-shelf” — the window between disclosure and active exploitation narrows considerably. For IT and security teams, the operational lesson is clear: vulnerability management can no longer be limited to internet-facing systems; inventorying statically linked dependencies and controlling outbound connections to untrusted infrastructure must be treated with the same critical priority that has historically been reserved for server-side attack surface.

References

The Hacker News. (2026, June 29). Public PoC released for critical libssh2 CVE-2026-55200 client-side SSH flaw. https://thehackernews.com/2026/06/public-poc-released-for-critical.html

Arctic Wolf. (2026, June 30). Critical remote code execution vulnerability in libssh2 client library require urgent mitigation. https://arcticwolf.com/resources/blog/critical-remote-code-execution-vulnerability-in-libssh2-client-library-require-urgent-mitigation/

GitHub, Inc. (2026, June 17). CVE-2026-55200: libssh2 through 1.11.1 heap-based buffer overflow [Security advisory]. GitHub Advisory Database. https://github.com/advisories/GHSA-r8mh-x5qv-7gg2

Heise Online. (2026, June 29). Critical libssh2 vulnerability: Proof-of-concept exploit released. https://www.heise.de/en/news/Critical-libssh2-vulnerability-Proof-of-concept-exploit-released-11347906.html

National Institute of Standards and Technology. (2026, June 17). CVE-2026-55200 detail. National Vulnerability Database. https://nvd.nist.gov/vuln/detail/CVE-2026-55200