Why AI-powered vulnerability scanning means open source updates can't wait
A newly disclosed vulnerability used to take weeks to become a widespread problem. AI has collapsed that timeline to hours, and sometimes the update itself is the attack. That changes how often sites need updating.
Introduction
Part 3 of 5 in Secure by Design, our series on how we build, host and maintain websites that stay stable and secure.
Almost every modern website is built on open-source code. WordPress plugins and themes, Symfony and Laravel packages, JavaScript libraries pulled in from npm: most of the code running your site was written by someone else and shared publicly. Every so often, a vulnerability is found in one of those widely used components. It gets a public reference number, a CVE (short for Common Vulnerabilities and Exposures), and from that moment a clock starts ticking on how long sites running the vulnerable version have before they're attacked.
That clock used to run for weeks and it now often runs for hours. This article explains why that shift matters, even if you've never looked at a CVE in your life, and why it's the reason updates can't be something that happens "whenever someone gets around to it".
How does a vulnerability become an attack?
The process has always followed a rough pattern. Someone, usually a security researcher but sometimes an attacker, finds a flaw in a piece of open-source code. It gets disclosed, often with technical detail about exactly what's wrong and how to exploit it. Attackers then work out how to take advantage of it, and start looking for websites still running the vulnerable version.
For a long time, the middle step was the bottleneck: turning a disclosure into a working, repeatable attack, and then finding targets. It took real effort, which meant real time. A website that patched within a week or two of a disclosure was usually safe in practice, simply because attackers hadn't got there yet.
AI has collapsed that timeline
That bottleneck is disappearing. AI tools can now read a vulnerability disclosure, work out how to exploit it, and generate a working attack automatically. A process that used to take a skilled person days can now take minutes. The same tools can scan enormous numbers of websites, work out exactly which software and versions each one is running, and target only the ones that are actually exposed.
Attackers generally aren't singling out your business. Automated systems sweep the entire internet for anyone still running a vulnerable version, and they don't care who you are. Being a small, low-profile business has never been much protection against this kind of attack, and it's less protection now than it used to be.
Part of our defence is making sure that sweep comes up empty. Every site we host sits behind Cloudflare, which blocks suspicious automated traffic and stops bots probing for the files that reveal what a site is running and which versions. The less a scanner can learn about your site, the less reason it has to come back. We explain how in why every site we host sits behind Cloudflare.
What this looks like in 2026
Four disclosures from this year show how short the window has become.
October 2026: PHP itself (security release announcement)
The latest example is PHP itself. On 22 October (Brisbane time), PHP released fixes for two critical flaws in the language (CVE-2026-109618 and CVE-2026-109619, both rated CVSS 9.2). Security researchers reported exploitation attempts within minutes of the release. Only PHP 8.2 to 8.5 received an official update, so sites on 8.1 or older need to be upgraded.
September 2026 — WordPress core (CVE-2026-87902)
A critical (CVSS 9.2) path traversal flaw affecting every version from 4.7.0 to 7.1.1. Patchstack blocked the first exploitation attempt on the same day the patch was released and saw attackers trying to write files to servers the next day. By then, public scanning tools were already circulating.
July 2026 — WordPress core (CVE-2026-63030 and CVE-2026-60137)
A critical REST API flaw and an SQL injection flaw that chain together to let an anonymous attacker run code on a standard WordPress install, no plugins required. Fixes shipped in 6.8.6, 6.9.5 and 7.0.2 in mid-July. Within days, multiple public exploits were on GitHub and watchTowr was reporting attacks in the wild. By 21 July, the US government's CISA had listed both as actively exploited.
May 2026 — Symfony and Twig (audit)
Anthropic's Claude Mythos Preview AI model audited the code and reported 19 vulnerabilities. The Symfony core team reviewed every report by hand and confirmed all 19 as real, with no false positives, then fixed them in security releases.
The Symfony audit shows the other side of the same shift. AI is now finding real flaws in mature, well-maintained open-source code faster than ever before. That's good news for the long-term security of the code, but every one of those findings becomes a public advisory and a patch that someone has to apply. More disclosures, arriving faster, with less time between each one and the first attack.
When the update itself is the attack
Fast patching assumes the update you're installing can be trusted, and that isn't always the case.
In July 2025, the official download channel for Gravity Forms, a form plugin running on roughly a million WordPress sites, was compromised. For two days, anyone who downloaded the plugin from the official site or installed it with Composer received a backdoored copy. Nothing on their own site had been exploited.
In June 2026, attackers broke into ShapedPlugin's build pipeline and pushed backdoored versions of its premium plugins through the company's official update system.
In early 2025, a portfolio of WordPress plugins changed hands, and malicious code was built in from the sale. It sat dormant for months until a command-and-control server switched it on in April 2026.
None of these started with a disclosed CVE. They're a reminder that "stay updated" isn't a complete answer by itself, because it assumes the update can be trusted. That's why our process (see why your site won't break at 2am) never installs a new version straight from a vendor. Every version bump is pinned deliberately, tested on staging and reviewed by a developer before it goes anywhere near your live site. An automatic "update everything immediately" pipeline has no such checkpoint.
Why "set and forget" websites are riskier than ever
A website that only gets patched when someone remembers to log in and check, or whose dependencies haven't been touched since launch, can easily spend days or weeks exposed after a vulnerability becomes public. That's exactly the window an automated scan is built to find.
This isn't just a WordPress problem. A Symfony or Laravel application running outdated packages is just as visible to these tools as a WordPress site with an old plugin. The old assumption that "we'll get to it eventually, nobody's really watching us" doesn't hold up against a system that's watching everyone, all the time.
How our approach closes the window
This is where the previous two articles in this series come together. Every site we manage, whether it's WordPress or a custom PHP application, runs on precisely pinned, Composer-tracked dependency versions (see WordPress on Composer). That means we know exactly what's installed on every client site. When a CVE is published affecting a specific package version, we can immediately identify every site that's actually affected and move to patch it, tested and reviewed, without guesswork or delay.
Those pinned versions are also what makes automatic scanning possible. Composer records the exact version of every package a site uses in a lock file, so there's a precise, machine-readable list to check. Our hosting includes automatic CVE scanning that checks that list against the PHP Security Advisories Database. When a new advisory lands that affects a version we're running, we know about it straight away, on exactly the sites affected, rather than finding out from a news article. A site that's updated by clicking buttons in an admin panel has no such list, and nothing reliable to scan.
Our hosting also runs on a read-only filesystem by design (see Read-only hosting), so there's nowhere for an attacker to plant a persistent backdoor, whether they get in through an unpatched flaw in the window before a patch lands or through a compromised update that slipped past review. Attempts to write files to the server, like those seen the day after CVE-2026-87902 was patched, have nowhere in the site's code to land. Automatic detection and fast, deliberate patching do most of the work, and the hosting limits the damage if timing ever isn't on our side.
Introducing Security Maintenance
We've built a dedicated Security Maintenance service around this approach: continuous monitoring for newly disclosed vulnerabilities in the open-source code your site depends on, prioritised patching across every site we manage, and the same pinned, auditable update process described throughout this series. Plans run on a weekly or monthly cycle, so you can choose the pace that suits your budget. Our clients don't have to watch CVE feeds themselves, or hope their agency is.
Talk to Vivo Group about your site
The speed at which vulnerabilities in open-source code go from "discovered" to "actively exploited" is only going to keep increasing. A development and hosting approach built around pinned versions, an auditable update trail and read-only infrastructure is what keeps a website off the list of sites an automated scan finds exposed.
In our final article, we bring every layer together and show how we apply it to new projects and to sites we take over from other agencies: how we make a website secure from day one (coming soon).
If you'd like to know how current your website's plugins, packages and other dependencies really are, get in touch with our Brisbane team and we'll tell you what's out of date and what needs patching first.
Frequently asked questions
What is a CVE?
A CVE (Common Vulnerabilities and Exposures) is a public reference number given to a known security flaw in software. Once a CVE is published, attackers know exactly what to look for, so sites running the affected version need to be patched quickly.
How quickly are vulnerabilities exploited after they're disclosed?
Increasingly, within hours. When WordPress patched CVE-2026-87902 in September 2026, Patchstack saw the first exploitation attempt the same day and attempts to write files to servers the next.
How is AI changing website security?
AI tools can now turn a published vulnerability into a working attack in minutes, and scan huge numbers of websites to find the ones still exposed. AI is also finding real flaws faster: in May 2026, an Anthropic AI model found 19 confirmed vulnerabilities in Symfony and Twig.
How often should I update my website?
As often as you realistically can, through a tested process. Weekly is better than monthly, and both are far better than "whenever someone remembers". What matters most is that updates are regular, and reviewed and tested before they reach your live site.
Can a plugin update contain malware?
Yes. In 2025 and 2026, attackers compromised the official download and update channels for Gravity Forms and ShapedPlugin, and a portfolio of plugins was bought and backdoored. Reviewing updates before deploying them, and hosting that blocks persistent backdoors, limit the damage.