In October 2026 the web got a fresh reminder of what running your own server means. Two critical vulnerabilities were published in PHP itself — not in a plugin, not in a theme, in the language runtime that serves roughly three quarters of all websites whose technology can be identified. Both were remote code execution, both were rated 9.2 out of 10, and within five days both were on CISA’s Known Exploited Vulnerabilities list.
This article is not PHP‑bashing. It is about a structural difference between two ways of building websites — and why the difference matters to you as a site owner.
In short
- The October 2026 PHP vulnerabilities (CVE‑2026‑109618 / CVE‑2026‑109619, “php2shell”) allowed unauthenticated attackers to run code on the web server itself.
- The flaw was in PHP’s core, hidden for over a decade, and surfaced partly through AI‑assisted code analysis. Reports estimated ~1.5 million of 2.6 million PHP hosts were running versions with no fix available at disclosure.
- Our stack has no PHP, no writable server, no long‑lived machine to take over — static and edge‑rendered sites on Cloudflare Workers remove this entire attack class.
- Serverless is not magic: secrets, dependencies, DNS and forms still need real work, and we do it.
- If you run WordPress or another PHP stack today, there is a sane checklist at the end — and a migration path if you want one.
What “php2shell” exposed
The details are worth understanding, because they explain the whole category:
- CVE‑2026‑109618 — if PHP runs out of memory mid‑request, partially initialised request data is treated as valid during cleanup, opening a path to code execution.
- CVE‑2026‑109619 — PHP keeps request‑specific state around after a request finishes; the next request handled by the same worker can reach that stale state. Unauthenticated heap use‑after‑free → memory disclosure → code execution with the web worker’s privileges.
Both require no login, no special plugin — just your PHP worker processing a crafted request. And because the bug sits underneath every PHP application, the patch duty fell on whoever operates each server: hundreds of thousands of hosting companies, agencies and small businesses. The European Union’s cybersecurity agency publicly warned that some sites might need to be taken offline entirely until patched. The fixes landed in PHP 8.2.35, 8.3.36, 8.4.27 and 8.5.12 — but a patch only protects servers that actually installed it and restarted the workers.
That last sentence is the entire problem with self‑managed PHP in one line.
Why classic PHP hosting gets breached so often
PHP’s security story is not that PHP is badly written. It is the operating model:
- A long‑lived server. Your site runs on a machine (or VPS) that exists 24/7, with an operating system, a web server, a PHP interpreter and usually SSH access. Every one of those is attack surface that must be patched forever.
- A writable filesystem. PHP apps write uploads, caches and configs to disk. Once code execution happens — through any bug — the attacker can persist there permanently.
- The plugin ecosystem. On WordPress specifically, the majority of breaches arrive through outdated plugins and themes, not the core. Thousands of third‑party components, each a potential door.
- Delayed patching. The hosting provider, the agency and the site owner each assume someone else is patching. October 2026 showed how that ends.
We wrote before about why we no longer start new projects on WordPress. Security is one of the honest reasons.
The serverless difference
Now the other side. Sites we build are rendered to static output or served from Cloudflare Workers — lightweight isolates that execute your code on Cloudflare’s edge. What disappears from the picture:
- No server to own. There is no VPS with an SSH daemon to brute‑force, no operating system you patch, no PHP interpreter whose CVEs hunt you. The runtime is Cloudflare’s V8 isolate platform — patching it is Cloudflare’s job, and they do it without your site going down.
- No writable filesystem. Workers code and assets are deployed as an immutable bundle. Even if an attacker could exploit something, there is no disk to drop a webshell onto, and the deployment is replaced wholesale on the next deploy.
- Nothing that “must be taken offline until patched”. During the php2shell emergency, PHP hosts were staring at downtime versus risk. Our sites had a Tuesday. We read the advisory, confirmed nothing in our stack executes PHP, and moved on.
- Platform security by default. DDoS mitigation, a WAF, TLS and bot management are part of the edge platform, not add‑ons we maintain.
The same logic protects the backend: Supabase gives us Postgres with row‑level security instead of a hand‑administered database server with a publicly reachable port.
What serverless does NOT fix
This is where honesty matters, because “serverless” has become a marketing word. The following attack classes are just as real on our stack, and we handle them deliberately:
- Secrets and API keys. Tokens live in the platform’s encrypted secret store, never in the repository or the bundle, with least‑privilege scopes and rotation. The most common real‑world breach is not a 0‑day — it is a key committed to a public repo.
- Your dependencies. npm packages are a supply chain; we pin, audit and update them in CI, and builds fail on known vulnerabilities.
- DNS and domain. Domain takeover is unglamorous and devastating; we lock DNS records and keep zone access in dedicated accounts, not in someone’s personal login.
- Application logic. XSS, open redirects and broken authorization exist in any architecture. Serverless removes the server‑compromise class, not the need for code review.
- Forms and abuse. Contact forms get spam and probing; rate limiting and bot filtering on the edge handle what a naked PHP
mail()script never could.
So the correct claim is narrower and stronger: we have engineered out an entire category of catastrophic breach — the remote takeover of the web server — and we actively manage the remaining risks. That is a much better position than “we patch PHP every time something like php2shell lands”.
If you are on PHP today: a short, sane checklist
- Confirm your PHP version — 8.2.35, 8.3.36, 8.4.27 or 8.5.12 or newer — and that the server restarted after the update. Ask your host in writing if you are not sure.
- Inventory your plugins and themes. Remove unused ones; update the rest today, not this month.
- Check for the aftermath. Unexpected cron jobs, new admin users, odd outgoing traffic — signs of an older compromise that the new patch will not remove.
- Decide what the site really needs. A marketing or content site rarely needs a PHP application server in 2026. Moving it to a static or edge stack removes the entire problem class — and usually makes it faster and cheaper. That is exactly the work our modernization service does.
Summary
October 2026 was not an anomaly; it was the routine cost of the classic hosting model. We choose a stack where the vulnerable layer does not exist — and we do the unglamorous work (secrets, dependencies, DNS, review) on the layers that remain. If you want an outside look at where your current site stands, ask us for a free audit — we will tell you plainly what is exposed and what it would take to fix.
Valentin K
Partner, security & BI
Partner at Take the Space. Background in business intelligence and server security; keeps our stacks hard to break into.