What the PHP2Shell vulnerability reminded us about internet security

This week's PHP2Shell emergency (CVE-2026-109618) sent sysadmins scrambling worldwide. It also challenged a common belief about modern software and AI.

6 min read

If you spent any time on engineering forums or security feeds between Thursday, October 22, and this morning, your timeline was probably consumed by one topic: PHP2Shell.

For those who missed the notifications: two critical vulnerabilities were disclosed in PHP's core memory allocator and error handling routines (tracked as CVE-2026-109618 and CVE-2026-109619, both rated CVSS 9.2 Critical).

Under specific load conditions, handling an out-of-memory (OOM) exception via longjmp() left request memory in a partially initialized state. In web environments like Apache mod_php, PHP-FPM, and FrankenPHP, an unauthenticated remote attacker could send carefully timed requests to corrupt worker memory and achieve full Remote Code Execution (RCE).

Because roughly 70% of the public web still runs on PHP in one form or another—WordPress blogs, WooCommerce stores, Drupal sites, Laravel APIs—security teams and cloud providers spent the last seventy-two hours in emergency triage. CISA issued an urgent patching directive, Linux distributions rushed backports to legacy PHP versions, and hosting providers deployed emergency WAF rules.

It was a chaotic weekend for infrastructure engineers.

But stepping back from the immediate patching rush, this incident highlights a fascinating paradox about where the tech industry is heading right now.


"Moving fast and breaking things"

There is a popular narrative in tech commentary right now that says software teams are moving entirely too fast.

The argument usually goes like this: Engineers are adopting AI coding agents, deploying multiple times a day, rewriting architectures, and generating code at speeds nobody can keep up with. In their rush to innovate, they are breaking the stable foundations of the internet.

It sounds sensible on the surface. We are taught to respect "battle-tested, stable, legacy code."

Except that isn't what happened this week.

What broke the internet on October 22 wasn't an AI-generated microservice deployed by a hyperactive startup on a Friday evening.

What broke the internet was twenty-year-old C routines buried inside the Zend Engine. It was manual memory management, pointer arithmetic, and setjmp/longjmp error handling written in an era before modern memory safety standards existed.

The code was "stable" only in the sense that nobody had touched it in years. It sat quietly in production, powering hundreds of millions of servers, carrying a critical latent flaw that was invisible until someone finally poked it the right way.


Why fast iteration with AI is actually making us safer

The idea that slow, cautious development produces secure software has been repeatedly disproven by reality. OpenSSL's Heartbleed, Log4j, and now PHP2Shell all lived in venerable, mature, widely trusted codebases for years—sometimes decades—before being detected.

In fact, the opposite is happening: the rapid adoption of AI-assisted security analysis and automated fuzzing is finally giving defenders the upper hand.

Consider how vulnerabilities like this are found and fixed today compared to ten years ago:

1. Automated semantic fuzzing

Historically, discovering deep edge-case memory corruption required weeks of manual static analysis by elite security researchers using hand-crafted fuzzers. Today, LLM-guided symbolic execution tools can inspect millions of lines of legacy C/C++ code, hypothesize failure states (like an OOM occurring precisely during an aborted alloc), and construct proof-of-concept tests in hours.

The tools that attackers have access to are fast, but the tools available to maintainers and security teams are improving at an even faster rate.

2. Rapid verification and patching

When CVE-2026-109618 landed, the PHP Foundation and maintainers didn't take weeks to coordinate. Within hours, backports were tested across PHP 8.2, 8.3, 8.4, and 8.5. Automated CI/CD pipelines running across global infrastructure verified regression tests and distributed binaries to package repositories in less than a day.

Speed was the defense. If the software ecosystem still operated on six-month quarterly release cycles, millions of servers would remain exposed to trivial RCE exploits for months.

3. The shift toward memory safety

Incidents like PHP2Shell are accelerating the industry's migration toward memory-safe languages. Whether it's Rust in the Linux kernel and edge runtimes, Go for network tooling, or modern TypeScript on isolated edge runtimes (like Cloudflare Workers), the industry is actively replacing legacy, unsafe memory patterns with languages where whole categories of bugs are simply impossible at compile time.

Moving fast to replace brittle legacy infrastructure with memory-safe primitives isn't reckless. It is the only way to build an internet that doesn't collapse every time an unexpected error is thrown in C.


The lesson for product studios

At TwoKite Labs, we spend our days building consumer apps and software solutions for businesses. Incidents like this are a valuable reminder of how we approach engineering:

  1. Keep the surface area small: The best way to avoid security liabilities is not to run giant, bloated servers when a lightweight edge function or an on-device local engine can do the job better.
  2. Embrace modern primitives: Build on isolated runtimes, typed languages, and memory-safe foundations rather than clinging to legacy architectures out of habit.
  3. Automate testing ruthlessly: Use modern static analyzers and AI-assisted test generation to probe edge cases before software ever reaches a customer.

The internet isn't fragile because technology is evolving quickly. It is fragile because we spent thirty years relying on code that was too scary to touch or rewrite.

Moving fast—when paired with modern testing, memory safety, and AI-driven auditing—isn't breaking the internet. It is finally fixing it.

© 2026 TwoKite Labs