ThinkableWhat is this?

Cybersecurity & Digital Warfare

The 50-Year-Old Bug That Still Runs the World

Roughly 70 percent of the most dangerous security vulnerabilities found in Microsoft Windows and Google Chrome trace back to a single category of mistake — one that computer scientists identified and named before most people alive today were born.

The Idea

Memory safety is about a deceptively simple question: when your program reads or writes data, does it stay within the boundaries it was given? In languages like C and C++, the answer is entirely up to the programmer. The language itself won't stop you from writing past the end of an allocated buffer, or from accessing a chunk of memory after it has been freed and potentially handed to something else entirely. These are not exotic edge cases. Buffer overflows and use-after-free errors are the bread and butter of real-world exploitation — and the reason they persist is structural, not a matter of individual carelessness. The problem is the language's design philosophy: maximum control, maximum performance, minimum guardrails. C and C++ hand programmers direct authority over memory, which is exactly why they became the foundation for operating systems, browsers, embedded firmware, and critical infrastructure. That same freedom means a single mishandled pointer can let an attacker overwrite a return address and redirect a program to execute arbitrary code, or silently read private data from adjacent memory regions. What makes this genuinely alarming is that these vulnerabilities have been understood for decades. CISA's own vulnerability review covering 2024 and 2025 found that memory safety weaknesses — alongside improper input validation — remain the most reliable paths to exploitation, appearing persistently among the most commonly exploited flaws year after year. The bugs being weaponised today are not novel. They are the same class of mistake that security researchers described as 'unforgivable' back in 2007. The language tolerates the error; a more restrictive language would simply refuse to compile it.

In the World

Android is the clearest experiment we have in what happens when an organisation decides to actually change course. In 2019, memory safety vulnerabilities accounted for 76 percent of all Android security vulnerabilities — 223 distinct flaws in a single year. Google's Android team, alongside Alex Rebert from Security Foundations, began prioritising a shift: not rewriting old C and C++ code, but writing all new code in Rust, a language designed from the ground up to make memory errors a compile-time impossibility rather than a runtime surprise. By 2024, memory safety vulnerabilities in Android had fallen to 24 percent of the total — a drop from 223 incidents to fewer than 50 in a single year. By late 2025, the figure had fallen below 20 percent for the first time. Google reported that Rust code in Android had shown a vulnerability density roughly a thousand times lower than the equivalent C and C++ code. The improvement came not from auditing old code more carefully, but from the fact that new code — which statistically carries most of the risk — was simply written in a language that made the whole class of errors structurally impossible. The lesson governments drew from this is now explicit policy. In June 2025, CISA and the NSA published joint guidance calling on software manufacturers to adopt memory-safe languages and to publish roadmaps for eliminating memory safety vulnerabilities from critical components. The EU's Cyber Resilience Act, phasing in through 2027, adds regulatory weight to the same demand. What was once a programming community debate has become a matter of stated national security.

Why It Matters

This is not a story about programmers being careless. The persistence of memory safety bugs across decades of increasingly sophisticated tooling, security reviews, and industry awareness is evidence that the problem is architectural. Talented engineers at companies with enormous security budgets could not fully patch their way out of it. The fix that is actually working — Android's experiment with Rust — works precisely because it removes the possibility of the error rather than trying to catch it after the fact. The broader implication is worth sitting with: we have built much of the world's critical infrastructure on foundations that are, in a precise technical sense, known to be unsafe. Routers, industrial control systems, and operating system kernels written in C are not going to be rewritten overnight. The vulnerabilities embedded in that old code will keep being discovered and exploited for years. What has changed is that the argument 'we have no alternative' is no longer credible. The alternatives exist, they are mature, and there is now hard evidence that they work at scale. The question is whether organisations and governments move fast enough — and whether the pressure being applied through regulation and guidance translates into actual adoption before the next major breach traces back to a bug that should have been impossible to write.

A Question to Ponder

If we have known about this class of vulnerability for decades and understand exactly what causes it, what does it tell us about how institutions actually change — and what finally made the difference this time?

One reader's Thinkable for Tech Tuesday — a random draw from the library.

Start learning with Thinkable
Get your own draw, every day.Start free