Some vulnerabilities are the product of sophisticated engineering failures. Others are a single overlooked character in a decades-old codebase. The newly disclosed Squidbleed flaw belongs firmly in the second category — and the fact that it survived nearly 30 years of patches, audits, and rewrites should be a sobering reminder of just how quietly legacy code can harbor catastrophic risk.
What Is Squidbleed?
Security researchers have publicly disclosed CVE-2026-47729, a memory overread vulnerability in Squid Proxy, the widely deployed open-source web caching proxy used across corporate networks, educational institutions, public Wi-Fi systems, and beyond. The flaw was introduced in 1997, and it remained undetected through virtually every version of the software released since.
The vulnerability earns its Heartbleed-inspired name honestly: like that infamous OpenSSL bug, Squidbleed causes the proxy to read past the boundary of a legitimate memory buffer and return whatever it finds to the requesting party. In practice, that means an attacker can recover the raw contents of other users' HTTP requests — including authentication headers, session tokens, API keys, and plaintext credentials.
How the Bug Actually Works
The flaw lives inside Squid's FTP directory listing parser, specifically in legacy code written to accommodate NetWare FTP servers, which used four spaces between timestamps and filenames rather than the conventional single space. When an FTP directory entry contains a modification timestamp but no filename, the parser enters a pathological state.
The root cause is a subtle but consequential behavior of the C standard library function strchr: when asked to locate a null terminator character ('\0') within a string, it returns a pointer to that terminator rather than returning NULL. This is technically correct per the C11 standard — but it is deeply counterintuitive, and almost certainly not what the original developer intended.
When no filename follows the timestamp, the pointer doesn't stop — it walks forward past the buffer boundary, reading through adjacent memory until it encounters a non-null, non-whitespace byte. That byte, and everything after it, gets returned to the attacker as a supposed filename.
The fix, once identified, is exactly two characters of code: a null-check before the strchr call. One conditional. Twenty-nine years of exposure.
What Data Is Actually at Risk
Squid manages its memory through recycled, per-size buffer pools. Critically, it does not zero out memory when buffers are freed and returned to the pool. The 4KB buffer used to parse FTP listings — drawn from Squid's internal MEM_4K_BUF pool — may have previously held another user's HTTP request. When a short FTP directory line is written into that buffer, only the first few dozen bytes are overwritten. The remainder of the 4KB block still contains stale data from the previous occupant.
The overread walks directly into that stale data and ships it out. Researchers demonstrated this by successfully recovering an Authorization header from a login page traversing the proxy. Any sensitive data carried in a cleartext HTTP request — credentials, tokens, cookies, API keys — is within scope.
Scope and Constraints
Safe_ports ACL, meaning no special configuration is required to exploit this.AI Found What Human Reviewers Missed for Three Decades
Perhaps the most striking aspect of this disclosure is how the vulnerability was found. Researchers used an AI model — specifically an advanced large language model trained on technical documentation including the complete C language standard — to analyze Squid's FTP state machine. The model identified the problematic strchr null terminator behavior almost immediately, citing the exact C11 clause that makes the call return non-null when searching for '\0'.
This is not a quirk that most human code reviewers would flag. It requires cross-referencing implementation behavior with language specification minutiae — something that exhausted engineers working under deadline pressure are unlikely to do systematically. AI-assisted code auditing, applied to legacy codebases, is increasingly surfacing vulnerabilities that conventional review processes simply cannot catch at scale.
What You Should Do
- Patch immediately. The fix was merged into Squid version 8 in April 2026 and shipped in version 7.6 in June 2026. Organizations running any earlier version are exposed.
- Disable FTP support if patching is not immediately possible. FTP parsing is enabled by default but is likely unused in most modern environments — Chrome dropped FTP support years ago. Turning it off eliminates the attack surface entirely at effectively zero operational cost.
- Audit your Squid deployment version. Given that researchers found decade-old Squid instances running in production on commercial aircraft, version hygiene across enterprise and embedded environments is clearly inadequate.
- Assume cleartext HTTP carries real risk in shared proxy environments. Any application or user transmitting credentials or tokens over unencrypted HTTP through a shared Squid deployment should be treated as potentially compromised until the proxy is patched.
- Consider AI-assisted auditing for legacy codebases. This disclosure is the latest in a pattern of AI models identifying high-severity flaws in mature, heavily reviewed code. Security teams managing aging infrastructure should evaluate this approach seriously.
The Broader Lesson
Squidbleed is a case study in how a single subtle misunderstanding of standard library behavior — one that requires knowing an obscure edge case in a language specification — can survive decades of open-source scrutiny. The codebase was not secret. It was not poorly maintained. It was reviewed, rewritten, and audited over and over again. And still, a two-character fix waited patiently since 1997.
The FTP parser may not be the only place where Squid — or any other long-lived network software — stopped reading too late. Organizations relying on any mature proxy, caching, or network processing software should treat this disclosure as an impetus for broader review, not merely a single patch to apply and forget.
