TL;DR
HollowByte is the latest OpenSSL vulnerability, disclosed 17 July 2026. An unauthenticated attacker sends an 11-byte malformed TLS ClientHello, and a handshake worker on your server hangs onto the socket and its buffer instead of releasing them. Repeat the request a few thousand times a second and the server stops accepting new HTTPS connections. It affects supported OpenSSL 3.x branches shipped before the July 2026 fix. Upgrade the openssl package from your distro and restart every daemon that links it — a package update alone won't help until you restart the processes. No memory disclosure, no key leak, so you do not need to reissue your certificate. Behind Cloudflare, an AWS ALB, or an already-patched reverse proxy? You're shielded at the edge, but patch the origin anyway before the next audit.
We've walked through this response cycle on production fleets for every OpenSSL CVE since Heartbleed. What follows is the checklist we actually run — versions, commands, mitigations, and the reissue question we get asked every single time.
What is the HollowByte vulnerability?
Every year or two the OpenSSL Project ships an advisory that the whole industry has to move on the same afternoon. HollowByte — the community nickname for the OpenSSL vulnerability disclosed on 17 July 2026 and covered by The Hacker News — is one of those. It sits in the code path that parses the very first bytes of an inbound TLS connection: the ClientHello. That parser runs before authentication, before cipher negotiation, before anything. Whatever an attacker sends to port 443, this code has to look at.
What surprised us when we first read the advisory was how little payload the exploit needs — 11 bytes. Not 11 kilobytes, not a clever multi-packet dance, just eleven bytes crafted to sit exactly on a length-check boundary. The handshake worker starts parsing, hits a state it can't unwind, and neither releases the socket nor frees the buffer it allocated for the connection. On a busy server, watching this in htop is genuinely uncomfortable: the process is alive, CPU is fine, and yet new TLS connections silently stack up until the accept queue overflows.
The good news, and it matters: the impact is availability, not confidentiality. No plaintext leaks. No private keys are exposed. This is not Heartbleed. You do not need to rotate keys, revoke certificates, or issue an incident-comms post. You need to patch, restart, and move on.
For a refresher on the TLS handshake and why the ClientHello is such a sensitive parsing surface, see our guides to how SSL/TLS works and TLS 1.3 explained.
Which OpenSSL versions are affected?
Per the OpenSSL Project's advisory, the flaw affects supported OpenSSL 3.x branches shipped before the July 2026 fix release. OpenSSL 1.1.1 is end-of-life and only receives fixes under the premium support programme; anything older than that is not maintained upstream at all.
Because most Linux distributions ship a downstream OpenSSL that lags the upstream numbering, always check your distribution's security tracker for the concrete package version that carries the fix:
- Debian / Ubuntu: Debian Security Tracker and Ubuntu USN pages for the CVE.
- Red Hat / Alma / Rocky: RHSA errata for
openssl. - Alpine: the secfixes entry in the
opensslaport. - Container base images: rebuild from an updated base and redeploy — patching only the host does nothing for containers that link their own OpenSSL.
The exact CVE identifier, CVSS score, and patched version strings are on the OpenSSL vulnerabilities page — treat that page as the source of truth rather than any secondary write-up.
How the 11-byte request freezes memory
Skip this section if you just want to patch — it's here for the engineers who will inevitably have to explain the CVE in a review meeting. A TLS handshake begins with the client sending a ClientHello: version, random, cipher list, extensions. The server can't do anything else until it parses that record, which means the parser is one of the most exposed pieces of code in your entire stack. It reads bytes straight off a socket, from anyone on the internet, with no authentication in front of it.
HollowByte's payload is technically well-formed enough to reach the vulnerable branch — record type, protocol version, and the outer length field all look sane — but the inner length fields describe a message the record physically cannot contain. In the affected OpenSSL 3.x versions, the parser reaches a state it doesn't have an exit for: the handshake never completes, the socket isn't closed, and the buffer allocated for the connection is never freed. Each malicious packet burns a handshake slot and a small chunk of memory. Send them at a sustained rate and the accept queue starts filling with connections the server is still "thinking about".
The asymmetry is what makes it dangerous. The attacker sends 11 bytes and never has to complete a handshake — no TCP hangs on their side, no fingerprint on their end. The server pays with a wedged worker and a slice of RSS that only comes back on restart. That's the textbook shape of a network-layer DoS primitive, which is why the OpenSSL Project moved on it quickly.
Is my server exploitable?
Any process that terminates TLS with a linked OpenSSL is a candidate: Nginx, Apache httpd, HAProxy, Postfix, Dovecot, stunnel, Node.js when built against the system OpenSSL, Python's ssl module, and OpenVPN in TLS mode. Quick checks:
- Version and build date:
openssl version -ashows the installed library, build date, and platform. Compare against your distribution's advisory. - What each service links:
ldd $(which nginx) | grep ssl(and similar for other daemons) tells you which OpenSSL a given binary is using — important on servers where you have multiple OpenSSL builds. - Container inventory: for each running image, run
docker exec <container> openssl version -a. A patched host does not help an unpatched container. - Edge-terminated services: if TLS is terminated at Cloudflare, AWS ALB/CloudFront, Fastly, or an already-patched reverse proxy, the origin is not directly reachable and internet-facing exploitation is blocked until origin certificates are used behind the edge.
Our OpenSSL commands cheat sheet covers the version and connectivity commands you'll want handy for triage.
How to patch
The bit that catches people out every single OpenSSL CVE: apt install or dnf update puts the new library on disk, but every process that already has the old libssl mapped keeps using it until you restart. We've seen ops teams write a Slack update saying "patched" while Nginx was still running the vulnerable OpenSSL for another six days. Update the package, then restart every TLS-terminating daemon. Then confirm with lsof.
# Debian / Ubuntu
sudo apt update && sudo apt install --only-upgrade openssl libssl3
sudo systemctl restart nginx apache2 haproxy postfix dovecot
# RHEL / Alma / Rocky / Fedora
sudo dnf update openssl openssl-libs
sudo systemctl restart nginx httpd haproxy postfix dovecot
# Alpine
sudo apk update && sudo apk upgrade openssl libssl3
sudo rc-service nginx restart
# Check what still has an old libssl mapped
sudo lsof +c 0 | grep -E 'libssl|libcrypto' | grep DELThe last command lists processes that still have a deleted libssl / libcrypto loaded — those are the ones you missed. On systems with needrestart or needs-restarting, use those instead. Containers need to be rebuilt from an updated base image and redeployed; do not try to apt install inside a running container as a fix.
Mitigations if you can't patch now
Patching is the fix. If you have a hard reason to delay — a change-freeze window, an appliance you don't control, a legacy binary — reduce the exposure in the meantime:
- Front the service with a patched TLS terminator. A CDN or WAF (Cloudflare, Fastly, AWS CloudFront), or an updated Nginx / HAProxy reverse proxy, absorbs the malicious
ClientHelloand forwards clean traffic to the origin. Make sure the origin is not still directly reachable on port 443. - Rate-limit TLS handshakes per source IP at the edge. Because the DoS shape uses many small unauthenticated connections, per-IP handshake limits and connection-rate rules blunt it significantly.
- Restart affected daemons on a schedule until you can patch, to reclaim hung handshake workers. This is a band-aid, not a fix.
- Restrict exposure on non-public services. Anything that terminates TLS but doesn't need to be internet-reachable — internal APIs, admin interfaces — should be firewalled to known source ranges regardless.
Do I need to reissue my SSL/TLS certificate?
No. HollowByte is a bug in the server's parsing code. The private key is not exposed and the certificate is not implicated. Reissuance and key rotation are the correct response to key compromise events — the canonical example being Heartbleed, where OpenSSL could be tricked into revealing memory that plausibly contained private keys. That is not what happens here.
Keep the certificate you have, install the patched OpenSSL, and move on. If you're overdue for a renewal for unrelated reasons, our SSL renewal guide and certificate management write-ups cover the routine process.
Timeline and disclosure
The vulnerability was disclosed through the OpenSSL Project's standard coordinated process in July 2026 and reported publicly on 17 July 2026. Fixed OpenSSL packages began landing in major Linux distributions in the days following the announcement. The OpenSSL vulnerabilities index and each distribution's security tracker carry the authoritative dates, CVE identifier, and patched version strings — check those directly rather than relying on secondary reporting for the numbers you commit to a ticket.