Hawthorn Security

By Zachary, Hawthorn Security

Most of my posts are about PHP, WordPress and Node, because that's what most small businesses run. But plenty of small dev teams also have a Java app or two quietly running in the corner: a Jenkins server that builds and deploys the website, a self-hosted Jira or Confluence, or a Keycloak login server. Those boxes tend to get set up once and then forgotten.

On Tuesday evening a serious Java flaw went public. It's been nicknamed “Java4Shell”, and if you run any of those tools yourself, it's worth a few minutes of your time today.


What happened

On 17 November 2026, at around 9pm UK time, the security firm Calif disclosed CVE-2026-114938, a bug in OpenJDK. OpenJDK is the open-source engine underneath nearly every Java install. Oracle released its monthly Java patches at the same time.

The bug is in the code Java uses to decode Base64. Base64 is a very common way of packing data into text, used for things like login headers and file uploads. On some modern processors, Java switches to a fast, hardware-accelerated version of that code. If an attacker sends carefully malformed data, that fast version writes past the end of its memory buffer. Java does reject the bad input afterwards, but by then the damage is done. Calif says this can be used to leak memory and, with effort, to run the attacker's own code on your server.

It has been rated 9.2 out of 10 (critical) on the CVSS 4.0 scale.

Who's affected

There are three conditions:

  1. Java version. Calif says OpenJDK 17.0.6 and later are affected. That includes Java 21, 25 and 27, plus the popular builds made from OpenJDK, such as Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft's build, Red Hat's build and Oracle Java itself.
  2. The processor. The vulnerable code only runs on x86-64 chips with a feature called AVX-512 VBMI. That means recent Intel Xeon chips (Ice Lake and newer) and AMD EPYC or Ryzen chips from Zen 4 onwards. Plenty of modern cloud servers and VPSs run on exactly these chips. ARM servers are not affected.
  3. Exposure. The attacker needs to get data to your Java app. In Calif's testing, normal features like logging in or uploading a file were enough.

Products where Calif says it got code running without logging in include Jenkins, Atlassian Jira, Atlassian Confluence, Keycloak, JFrog Artifactory and PingFederate. Calif also got code running after logging in on Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. Calif is clear that the list isn't complete. Calif also says a Java program that simply connects out to a malicious server over TLS can be hit, even if it doesn't accept any connections itself.

How worried should you be?

Being measured about it: as of 17 November, nobody had reported this being exploited in the wild. Calif says there's no one-size-fits-all exploit, as each target needs its own work. It's also holding back its product-specific attack details until people have had time to patch.

That said, Wiz reports its AI research tool produced a working proof of concept in about two hours. History tells us attackers move quickly on bugs like this. “No known attacks yet” is a window to use, not a reason to wait.

The traps people miss

  • Your Linux distro may not have a fix yet. At the time of writing, Debian marked all its releases as vulnerable with no fix out, Ubuntu's latest openjdk-17 and openjdk-21 packages were the last affected builds, and Red Hat said fixes were being expedited. Running apt upgrade today may not actually fix this. Check the package changelog mentions the CVE.
  • Temurin had no confirmed fix yet when I checked. If you use Temurin (very common in Docker images), keep an eye on Adoptium's releases.
  • Bundled Java. Many apps ship their own copy of Java rather than using the system one. Updating the server's Java package won't touch those.
  • Containers need rebuilding. If your Jenkins or Keycloak runs in Docker, the Java inside the image only changes when you pull or rebuild a patched image.
  • The forgotten VPS. The Jenkins box someone set up three years ago, open to the internet “just for webhooks”, is precisely the target here.

What you should do

  1. Find your Java. List anything running Java on your servers (ps -C java -o pid,cmd on Linux), including inside containers, and note the version.
  2. Check the processor. On Linux, run: grep -oE '(avx512f|avx512bw|avx512vbmi|bmi2)' /proc/cpuinfo | sort -u. If all four come back, the vulnerable code path is in play.
  3. Patch where you can. Oracle's fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Amazon Corretto's fixed builds are 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 and 27.0.1.1.4. For distro packages and Temurin, install the fix as soon as it lands, then confirm the version really changed.
  4. Use the stopgap if you can't patch yet. Calif's recommended workaround is to start Java with -XX:-UseBASE64Intrinsics, which turns off the fast code path. You can usually set it through the JAVA_TOOL_OPTIONS environment variable, then restart the app. There may be a small performance cost.
  5. Get these tools off the open internet. Jenkins, Jira, Confluence and Keycloak admin pages rarely need to be public. Put them behind a VPN, an IP allow-list or a login proxy. That's good practice regardless of this bug.
  6. Rebuild your containers once fixed base images are available, and redeploy them.
  7. Update the rest of your Java too. Oracle's November update also fixes other flaws, including in Java 8 and 11, so don't skip those versions just because this particular bug may not apply.

Not sure what's running on your servers?

This is the sort of thing I see a lot: a business that's careful with its website but has a build server or internal wiki nobody has looked at in years. A Hawthorn Security review goes through your servers, VPSs, containers and deployment pipeline, finds what's exposed and out of date, and gives you a plain-English list of what to fix first.

Book a security review at hawthornsecurity.uk

Sources

By Zachary, Hawthorn Security

If your website runs on WordPress, and plenty of UK small business sites do, this one is for you. A flaw in WordPress core itself (not a dodgy plugin, for once) is now being used in real attacks. It has a quirk that makes the usual “just click update” advice slightly wrong.

It's not cause for panic, but it's worth 20 minutes of your time this week.


What happened

On 28 October WordPress released version 7.1.4, which fixed 22 security problems. Most were fairly minor. One wasn't: a race condition in the core updater, reported by researcher Umut Bayram of Picus Security, that can lead to remote code execution. That means an attacker could run their own code on your web server without logging in.

On 3 November the US Cybersecurity and Infrastructure Security Agency (CISA) added the flaw, tracked as CVE-2026-119977, to its Known Exploited Vulnerabilities list. That list only covers bugs with evidence of real attacks, so this has moved beyond theory.

How it works, in plain English

When WordPress updates itself, it briefly unpacks a temporary copy of its installer into a folder called wp-content/upgrade/. On many servers that folder can be reached from the web, and PHP code inside it will run.

If an attacker finds that temporary installer before WordPress tidies it away, they can point it at a database they control. The updater then writes a new wp-config.php (the file that holds your site's database details) over your real one. From there they can get an admin account, install a plugin of their choice and run whatever code they like.

It needs a few things to go the attacker's way: good timing, a server that runs PHP in that folder, and knowing where the temporary copy lives. So it's not trivial. It has been exploited anyway, and the underlying behaviour reportedly goes back to WordPress 2.7 in 2008.

Who's affected

  • Public advisories list WordPress 4.7 to 7.1.3 as vulnerable.
  • Fixed versions: 7.1.4, plus backported fixes for older branches, including 7.0.8, 6.9.11, 6.8.12 and so on down to 4.7.39.
  • WordPress 4.6 and older get no fix at all. WordPress only properly supports its latest version, so if you're on something ancient, moving up is your only option.

A word of caution on the backports: not all of them carry all 22 fixes. Some of the older branches only got a handful. Being on “a patched version” of an old branch isn't the same as being on 7.1.4.

The traps people miss

The update is the risky moment. This is the unusual bit. The bug lives in the updater, so the act of updating can open the window an attacker needs. According to the researcher, updating can leave a web-reachable temporary installer behind on a site that hasn't been patched yet. Running wp core update from the command line doesn't get around it either, because it uses the same updater.

“Auto-updates are on, so I'm fine.” Maybe. Lots of sites have auto-updates on paper but stuck in practice, because of file permissions, a full disk or a host that disabled them. Check the version number yourself rather than assuming.

Patched doesn't mean clean. If your site was vulnerable and reachable over the past few weeks, updating now closes the door, but it won't evict anyone who already got in.

Forgotten sites. The old staging site, the campaign microsite from 2021, the “temporary” blog on a £5 VPS. These are the ones that never get updated and are easiest to find.

What you should do

  1. Block web access to wp-content/upgrade/ first. WordPress only uses that folder during updates, so visitors never need it. Ask your host to deny access (or at least PHP execution) there, or add a rule to your web server config. Then visit the folder in a browser and confirm you get a 403 “Forbidden” error.
  2. Then update. Go to Dashboard > Updates and move to 7.1.4. If you're stuck on an older branch, at minimum get to its latest backport, and plan a move to the current version.
  3. Check the version number afterwards. Don't trust the auto-update setting. Look at the bottom of the admin dashboard or the Updates screen.
  4. Look for signs of trouble. Check for admin users you don't recognise, plugins you didn't install, and whether wp-config.php has changed recently. If anything looks off, assume the worst and get help.
  5. Find every WordPress site you own. Make a list, including staging and old marketing sites. Update them or switch them off.
  6. Take a backup and test the restore. It's a good habit anyway. Keep a copy off the server, so a compromised site can't damage it.

If your site is on a managed WordPress host, much of this may already be handled. It's still worth a quick email asking them to confirm they've applied 7.1.4 and blocked the upgrade folder.


Not sure where you stand?

This is exactly the sort of thing I check in a Hawthorn Security review: which version of WordPress (and PHP, and everything underneath) you're actually running, whether your updates really work, whether folders that should be private can be reached from the web, and whether there's an old forgotten site somewhere on your server waiting to be found.

You get a plain-English report of what I found, ranked by what matters most, with clear steps to fix it. No jargon and no scare tactics.

Book a security review at hawthornsecurity.uk

Sources

By Zachary, Hawthorn Security

Picture this. You've done Cyber Essentials for a couple of years. You fill in the questionnaire, tick the boxes, and the certificate arrives. This year you answer one question honestly: no, not everyone uses a second login step on the accounting software. Before, that might have earned you a note to fix it. Now it fails the whole assessment.

That changed in April 2026, and a lot of small businesses haven't noticed yet. The good news is that it's one of the cheapest and quickest things to fix.


What actually changed

Cyber Essentials is the government-backed scheme that shows you have the basics of cyber security in place. It's run by IASME on behalf of the NCSC (the UK's National Cyber Security Centre). The requirements were updated to version 3.3, along with a new question set (called “Danzell”), for assessments created after 26 April 2026.

The big change for small firms: multi-factor authentication (MFA) on cloud services is now an automatic fail if it's missing. IASME is clear that this applies whether the service is free, bundled in with something else, or paid for. Two questions about installing security updates also became automatic fails. High-risk and critical updates need to go on within 14 days of release.

If you started your assessment before 26 April, you had six months to finish it under the old rules. That grace period has now ended, so anyone certifying or renewing from now on is on the new rules.

What counts as a “cloud service”?

More than most people think. The scheme defines it as an on-demand service, hosted on shared infrastructure and reached over the internet, that you log into with an account and that stores or processes your business's data. In plain English, that covers:

  • Microsoft 365 or Google Workspace (your email)
  • Xero, QuickBooks, Sage or whatever does your accounts
  • Your online banking and payroll
  • Dropbox, OneDrive and other file storage
  • Your CRM, booking system or shop platform
  • Your web hosting control panel and domain registrar

Cloud services can't be left out of your Cyber Essentials scope either. If your business uses it and it holds your data, it counts.

What does “MFA” mean here?

MFA (also called 2FA or two-step verification) just means proving it's you with something extra on top of your password. The Cyber Essentials requirements accept a few kinds:

  • An authenticator app on your phone
  • A physical security key, like a USB key
  • Passkeys, which the scheme now treats as MFA and actively encourages
  • Push notifications or one-time codes
  • SMS text codes. These are accepted, but the requirements say outright that SMS isn't the most secure option.

The rule applies to every account that logs into a cloud service, not only admins. Admins also need their own separate accounts for admin work, rather than doing it from the account they use for email and browsing.

There's one nuance. The rule says MFA must be used “where available”. If a service doesn't offer it at all, you aren't failed for that. You still need a strong password: at least 12 characters, or at least 8 if the service blocks common passwords. If a key system has no MFA in 2026, though, I'd treat that as a warning sign about the supplier.

Why this is worth doing anyway

Forget the certificate for a second. The government's latest Cyber Security Breaches Survey found that 46% of small businesses and 42% of micro businesses had a breach or attack in the past year. Phishing was by far the most common type, hitting 38% of businesses. Phishing is mostly about stealing passwords, and MFA is what stops a stolen password from being enough on its own.

Even so, the same survey found that only 47% of businesses have 2FA in place, and only 43% of micro businesses require it. The NCSC's own advice to small organisations is that any type of 2-step verification is better than none.

What you should do

  1. List every cloud service you use. Go through your bank statements and card bills for subscriptions. You'll find ones you'd forgotten about.
  2. Start with the critical ones. The NCSC suggests email, banking and finance, payroll, file storage, social media, and your website and domain hosting.
  3. Turn MFA on for everyone, not just you. Most platforms let an admin enforce it across the whole account. Use that setting rather than relying on people to switch it on.
  4. Choose an authenticator app or passkeys over SMS where you can.
  5. Save backup codes somewhere safe, like a password manager, so a lost phone doesn't lock you out.
  6. Deal with shared logins. One “office@” account shared by three people with one phone getting the codes is hard to secure and hard to explain to an assessor. Give people their own accounts where the service allows it.
  7. Remove old accounts. Ex-staff, old freelancers and that agency from 2022 all count. Unused accounts are an easy way in.
  8. Check your patching while you're at it, since the 14-day update rule is now an automatic fail too.

Not sure where you stand?

Most of the small businesses I talk to have MFA on email and have never thought about the hosting panel, the domain registrar or the server their website runs on. Those are exactly the accounts that cause real damage when someone gets in.

A Hawthorn Security review goes through your actual setup: the cloud services you rely on, who has access to what, how your servers and websites are reached, and whether your updates are keeping up. You get a plain-English list of what to fix before your Cyber Essentials assessment, not after it fails.

Book a security review at hawthornsecurity.uk

Sources

By Zachary, Hawthorn Security

While most of the web was busy patching PHP2Shell on 21 October, Node.js quietly shipped its own critical fixes the same afternoon. And there's another round coming next week.

If you run anything on Node.js (an API, a Next.js or Nuxt site, a background worker, or even just your build pipeline), here's what you need to know.


What happened on 21 October

Node.js released security updates for all three supported versions: 22.23.4, 24.22.1 and 26.12.1. They fixed ten vulnerabilities, four of them rated high.

The headline bug is CVE-2026-111497, now nicknamed Node2Shell. It's a flaw in the Brotli decompression code that ships inside Node.js. Feed it a specially crafted compressed payload and it can write past the end of a memory buffer. At best that crashes your app. At worst it lets an attacker run their own code on your server.

Within a day, a public proof of concept was out, and researchers reported getting code execution against the official, unmodified Node.js 24 Docker image. It didn't work every time, but it worked.

The same flaw affects Bun before version 1.4.4, and other software that bundles its own copy of Brotli may need updating too.

Are you exposed?

The bug triggers when Node.js decompresses Brotli data an attacker can control. That happens more often than you'd think:

  • Servers that accept compressed requests. Express 5 and body-parser 2.x automatically decompress request bodies sent as Brotli. Any visitor can send one.
  • Apps that call other servers. fetch() decompresses Brotli responses automatically. If your app calls a URL a user gave you (webhooks, link previews, integrations), a malicious server can send a poisoned response back.
  • Code using node:zlib directly to decompress anything from outside.

If you're not sure whether any of that applies to you, assume it does until you've checked.

The versions that won't get a fix

This is the bit that catches people out. Node.js 20 reached end of life on 30 April 2026, along with 23 and 25 before it. None of them got the Node2Shell fix, and none of them will get next week's fixes either.

Node.js 20 was hugely popular, and plenty of servers, Docker images and CI pipelines are still pinned to it. If that's you, you're not “a bit behind”. You're running a version with a public remote code execution exploit and no patch.

And now, round two: 11 November

On 3 November, the Node.js project announced another security release, due on or shortly after Wednesday 11 November. It covers Node.js 22, 24 and 26, and the most serious issue is rated HIGH.

There are no details yet. That's normal: the Node.js team holds back the specifics until the fix is out so attackers don't get a head start. But after the last few weeks, it would be optimistic to assume nobody will be looking for these bugs the moment they're published.

The good news is you've had a week's warning. Use it.

The usual traps

Updating Node.js sounds simple. In practice, it's where things get missed:

  • Containers don't update themselves. A running container keeps the Node.js it was built with. A Dockerfile pinned to node:24.22.0 stays vulnerable however many times you rebuild it. You need to bump the version, rebuild and redeploy.
  • Updating your framework isn't updating Node.js. Upgrading Next.js or Express doesn't touch the runtime underneath. They need patching separately.
  • Managed platforms can lag behind. If your hosting provider bundles its own Node.js, check which version it's actually running.
  • Distro packages work differently. If your Node.js came from Debian, Ubuntu, Alpine or similar, it may use the system's Brotli library instead, so the fix arrives through a different package. Check your distro's advisory, not just the version number.
  • It's not just production. Build servers, CI runners and developers' laptops all run Node.js and fetch things from the internet. If you're a Laravel shop, that includes the Node.js you use for Vite builds and any Inertia SSR server.

What to do this week

  1. Find every Node.js install. Servers, containers, CI runners, build boxes and laptops. Run node --version everywhere, including inside your images.
  2. Make sure the 21 October fixes are in. You want 22.23.4, 24.22.1 or 26.12.1 or newer.
  3. Get off Node.js 20 and older. For most people, Node.js 24 is the best target. Node.js 22 is only supported until April 2027.
  4. Avoid pinning exact versions unless you have a process to bump them. Pinned tags are great for reproducible builds and terrible if nobody updates them.
  5. Book a patching window for 11 and 12 November. Plan to update, rebuild and redeploy as soon as the release lands.
  6. As a stopgap, block Brotli-encoded requests (Content-Encoding: br) at your reverse proxy or load balancer. It reduces your exposure on incoming requests, but it doesn't protect outgoing fetch() calls, so it's a bridge, not a fix.

Not sure what you're running?

Between PHP2Shell, Node2Shell and next week's release, October and November have been a rough couple of months for anyone running their own servers. The businesses that came through it fine all had one thing in common: they knew exactly what they were running and had a process to update it.

That's what a Hawthorn Security review gives you. I'll go through your servers, containers and deployment pipelines, find the outdated and unsupported runtimes, and give you a clear, prioritised list of what to fix first. No jargon and no scare tactics, just a plain answer to “are we OK?”

If you'd rather not spend next Wednesday wondering, now's a good time to get in touch.

Book a security review at hawthornsecurity.uk


Sources

By Zachary, Hawthorn Security

In a few weeks, on 31 December 2026, PHP 8.2 reaches end of life. After that date the PHP project stops releasing security fixes for it. No patches, no backports, nothing.

If last month's PHP2Shell scramble taught us anything, it's that the gap between “a bug is found” and “attackers are using it” is now measured in hours. Running a PHP version that will never be patched again is a much bigger risk than it used to be.

Here's what's changing, who it affects, and what to do about it.


How PHP support works

Every PHP version now gets four years of support:

  • Two years of active support, with bug fixes and security fixes.
  • Two years of security-only support, where only security issues get patched.
  • Then it's end of life.

All of these phases now end on 31 December of the relevant year, which makes planning a bit easier.

PHP 8.2 came out in December 2022. Its active support finished at the end of 2024, and it's been on security fixes only ever since. That ends on New Year's Eve.

Here's where the current versions stand:

Version Security support until Status
PHP 8.1 and older Already ended Unsupported
PHP 8.2 31 December 2026 Final weeks
PHP 8.3 31 December 2027 Security fixes only
PHP 8.4 31 December 2028 Fully supported
PHP 8.5 31 December 2029 Fully supported

Why this matters more than usual

PHP2Shell is a perfect example. When those two critical bugs were fixed in October, the supported branches (8.2 to 8.5) got proper releases on the day. The end-of-life branches (7.4, 8.0 and 8.1) only got source code backports, with no official release. If you were on one of those, you were relying on your Linux vendor, a third-party repository, or compiling PHP yourself.

Now imagine a bug like that turns up in February. PHP 8.2 would be in exactly the same position.

And there are a lot of sites on 8.2. According to WordPress.org's own stats from September, around 62% of WordPress sites were running PHP 8.2 or older. That's a huge number of sites that are either already unsupported or about to be.

“But my server's still getting updates”

This is where it gets a bit nuanced, and where a lot of people get caught out.

Some Linux distributions keep patching their own PHP packages after the official end of life:

  • Debian 12 ships PHP 8.2 as its default, and Debian's security and LTS teams continue to patch the packages they ship for as long as that release is supported.
  • Red Hat Enterprise Linux 8 and 9 support their PHP 8.2 streams until May 2029.

So if you're on Debian 12 with Debian's own PHP packages, and your server is actually installing security updates, you're not instantly exposed on 1 January.

But that comes with some big caveats:

  • It only covers the distro's own packages. If you installed PHP from a third-party repository, a control panel, or a Docker image, the distro's support doesn't apply to you.
  • Your software moves on without you. Frameworks, CMSs and plugins will drop 8.2 support. Laravel 13 already requires PHP 8.3, as do Drupal 11 and Joomla 6. Over time you'll be stuck on older versions of everything else too, and those stop getting security fixes as well.
  • It's only as good as your update process. A distro patch you never install protects nothing.
  • There's no upgrade path within Debian 12. It doesn't ship PHP 8.3, so moving forward means either upgrading to Debian 13 (which uses PHP 8.4) or switching to a third-party repository.

Distro support buys you time. It isn't a plan.

Which version should you move to?

For most people, I'd recommend going straight to PHP 8.4. It's supported until the end of 2028, it's the default on Debian 13, and most major frameworks and CMSs work well on it.

  • PHP 8.3 is the smallest jump if your code or plugins aren't ready for 8.4, but it only buys you one more year.
  • PHP 8.5 gives you the longest runway if everything you use already supports it.

Whichever you pick, test it first. Most upgrades from 8.2 are fairly painless, but deprecated features, older plugins and abandoned packages are where things usually break.

What you should do now

  1. Find out what you're running. Check every server, site and container, including the command line PHP used by cron jobs and queue workers, which is often a different version from the web server.
  2. Check your dependencies. Make sure your framework, CMS, plugins and Composer packages support your target version.
  3. Test on a copy first. A staging site or a local copy will save you a lot of stress.
  4. Plan the operating system too. If you're on an older OS, the PHP upgrade might mean upgrading the server as well.
  5. Don't leave it until December. The last two weeks of the year are when nobody's around to fix things if the upgrade goes wrong.

Want a hand?

This is exactly the kind of thing a Hawthorn Security review is for. I've spent over 15 years building and running PHP and Laravel applications and the Linux servers behind them, so I've done more of these upgrades than I can count.

A review looks at what you're running, where the end-of-life risks are (PHP, the operating system, and your framework and packages), and gives you a clear, prioritised plan to get onto supported versions without breaking anything.

If you're not sure what version your site is on, or who's meant to be keeping it updated, now's a good time to find out.

Book a security review at hawthornsecurity.uk


Sources

By Zachary, Hawthorn Security

Two weeks ago the PHP world had one of its messiest security weeks in years. Two critical remote code execution bugs in PHP itself, a broken embargo, and a scramble to get patches out before attackers caught up.

Most of the big hosting providers handled it well. The bit that worries me is everyone else: the small, self-managed servers that quietly run a huge amount of the UK's business websites.

Here's what happened, and why it matters if you run your own server.


The back story

The bugs, now known as PHP2Shell, are tracked as CVE-2026-109618 and CVE-2026-109619. Both are rated 9.2 out of 10 and allow an attacker to run code on your server without logging in.

This isn't a WordPress plugin or a dodgy Composer package. The flaws are in the PHP runtime itself, triggered through how PHP handles out-of-memory errors and leftover request state. In some setups (Apache with mod_php in particular) the attack can land before your application code even runs. Your code can be perfect and you're still exposed.

The issues were found back in August with the help of AI tooling, and the PHP security team worked quietly on fixes under the usual coordinated disclosure process. Distributions and vendors were told in advance so everyone could ship patches at the same moment.

That was the plan, anyway.

The embargo breaks

On Tuesday 20 October, the CVE numbers started circulating online, along with some inaccurate details (including a 10.0 severity score and wrong release dates). Security researchers picked it up and it spread fast.

The PHP team responded that evening by going public early. They issued an advance warning and pulled the release forward a full day, to Wednesday 21 October at 14:00 UTC (3pm UK time).

It got messier on the Wednesday morning. Chainguard published patched container images more than six hours before the agreed release time. The PHP Foundation later called this out publicly, because once a fix is out in the wild, attackers can compare it with the old code and work out exactly what was broken. Everyone else was still waiting for the official release.

The patches landed as planned: PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35. Because of the severity, the PHP team also published source-only backports for the end-of-life 7.4, 8.0 and 8.1 branches.

Exploitation attempts were seen in the wild from release day, and by 26 October CISA had added CVE-2026-109618 to its Known Exploited Vulnerabilities list.

How the big hosts handled it

Honestly? Pretty well, and mostly by doing the boring thing: installing the standard packages.

  • Debian and Ubuntu shipped fixed packages through their normal security repos.
  • Ondřej Surý's repository (sury.org), which a lot of Debian and Ubuntu servers use for newer PHP versions, had fixed builds out the same afternoon, all the way back to PHP 5.6.
  • cPanel and CloudLinux pushed patched EasyApache and alt-php packages, including backports for older PHP versions.
  • Red Hat, AlmaLinux and Rocky followed with their own packages.

By 22 October most major distros and control panels had fixes available. Managed and shared hosts simply ran their usual update pipelines, restarted PHP, and moved on. Customers on decent managed hosting mostly didn't need to lift a finger.

That's the value of a well-run platform: someone is watching, and the update process already exists before the emergency.

The Docker delay

If you run PHP in containers, the picture was a bit different.

The official php images on Docker Hub are built through Docker's own library pipeline, which involves review and multi-step builds. On the day, patched official images didn't appear until roughly two to three hours after php.net published the fix. Projects built on top of the official images (such as the popular serversideup images) waited longer still, with one reporting around four hours between the PHP release and their patched images going live, most of it spent waiting on upstream.

A couple of hours doesn't sound like much, but with an embargo already broken and exploits circulating, it was an uncomfortable gap.

And the bigger catch: a new image on Docker Hub fixes nothing on its own. Your running containers keep the image they started with. Updating the host doesn't touch the PHP inside the container either. You have to rebuild, redeploy, and check what's actually running. Plenty of teams pulled a floating tag, assumed they were safe, and were still serving yesterday's container.

The real problem: small, unmanaged VPSs

This is where I think the real risk sits.

Think of the typical small business setup: a £5 to £20 a month VPS, set up a few years ago by a freelancer or an agency that's since moved on. It runs the website, maybe a booking system or a small Laravel app. Nobody logs into it unless something breaks.

These servers tend to have the same problems:

  • No automatic security updates. If nobody runs apt upgrade, the patch never arrives.
  • PHP never restarted. Even after updating, PHP-FPM or Apache needs restarting before the fix is actually loaded.
  • Old operating systems. Ubuntu 20.04 boxes running PHP 7.4 only get the fix through Ubuntu Pro. Debian 11 doesn't get it from Debian at all. These servers are common, and they're often the ones nobody is looking after.
  • Misleading version numbers. On Ubuntu, a patched server still reports the same PHP version (for example 24.04 stays on 8.3.6), so a quick php -v tells you nothing. People checked, saw the “old” number, and either panicked or assumed it didn't apply to them.
  • Forgotten servers. Old staging sites, test boxes, that one client site from 2021. If it's on the internet and running PHP, it counts.

It's also not over. A further issue, CVE-2026-115560, involving PHP's session upload progress feature, was disclosed shortly after and at the time of writing still doesn't have a fix. The recommended workaround is to switch off session.upload_progress.enabled. If your server isn't being actively looked after, that change won't happen either.

The big hosts closed the gap within hours. A lot of small VPSs may still be wide open right now, and their owners have no idea.

What you should do

  1. Find every server and container running PHP. Including the ones you'd forgotten about.
  2. Check the actual package version, not just php -v. Compare against your distro's security advisory.
  3. Update and restart PHP. Then confirm the running process is using the patched build.
  4. Rebuild and redeploy containers. Pulling a new tag isn't enough.
  5. Apply the session upload progress workaround until PHP ships a fix.
  6. Check your logs back to around 17 October for anything unusual, especially PHP worker processes spawning shells or other commands.
  7. Turn on automatic security updates so the next one doesn't rely on someone remembering.

Not sure where you stand?

This is exactly the kind of thing I look at in a Hawthorn Security review. I've spent over 15 years building and running PHP and Laravel applications and the Linux servers they live on, so I know where these setups usually fall down.

A review covers your servers, containers and deployment process, tells you plainly what's exposed and what isn't, and gives you a clear list of fixes in order of priority. No jargon, no scare tactics.

If you've got a VPS that nobody has touched in a while, now is a very good time to find out what's on it.

Book a security review at hawthornsecurity.uk


Sources