Installing security updates has been considered a mandatory exercise for years – but in practice it is often postponed. A patch is released, the update lands in the backlog, and at some point in the coming weeks a maintenance window is found. This routine relies on a tacit assumption: that enough time passes between the release of a patch and the first working attack.
A current observation by Google calls this assumption into question.
What Google documented
According to its own statements, Google's Threat Intelligence Group has observed for the first time that attackers find and exploit security vulnerabilities entirely without human intervention. The basis was an AI framework called exploit_agent, which was discovered on an openly accessible server.
The approach of this agent is unspectacular in its logic and precisely for that reason remarkable: it automatically compared the code before and after a patch, created exploits from it – that is, executable attack code that specifically exploits a vulnerability – and then executed these itself. No human had to understand the vulnerability, no one had to write the attack code, no one had to launch the attack.
Why the patch in particular is the starting point
To outsiders it seems paradoxical that a security update itself becomes the starting point of an attack. Technically, however, the connection is obvious: through the changed lines of code, a patch documents where the problem lay. Anyone who analyses the difference between the old and new version – known in the jargon as patch diffing – obtains a precise indication of which input or which program path was previously insufficiently secured.
This method has long been known and has so far been used by specialised analysts. It requires experience, time and an understanding of the respective codebase. Precisely these three factors were the natural brake. If it falls away because an agent performs the comparison automatically, what changes is not the method but its speed and scalability.
The actual shift: time
The security-relevant consequence lies less in a new type of attack than in the shortening of a time window. Between the moment a manufacturer releases an update and the moment an unupdated system becomes vulnerable, there has so far been a practical buffer. Many maintenance processes rely on this buffer without that ever having been explicitly decided.
There is no reliable information on how much this window actually shortens – and at present that can hardly be quantified in any serious way. The direction, however, is clear: an automated process works around the clock, in parallel and without prioritisation by worthwhileness. While a human attack team has to decide which vulnerability justifies the effort, this selection largely ceases with an agent. Smaller websites and less prominent applications thus also move more strongly into the realm of the possible.
Consequences for the operation of websites and applications
For operators of content management systems, online shops and custom web applications, one thing above all follows from this: the update process must no longer be a manual case-by-case decision. It must exist as an automated, monitored process that takes effect without further enquiry in the normal case.
Concretely, this means several building blocks that must work together:
- Complete inventory: Which systems, extensions and libraries are actually in use, in which version, on which server? Without this overview, every patch strategy is patchwork.
- Dependencies in view: A large part of the attack surface lies not in one's own code but in third-party packages. Automated dependency checks therefore belong in the development environment, not in an annual review.
- Automated tests: Fast patching is only possible if it can be checked whether the update breaks anything. Reliable test coverage is thus not purely a quality issue but a security prerequisite.
- Deployment pipeline: The path from the updated version to the production environment should be measurable in minutes and not in days.
- Rollback capability: Those who can go back at any time patch faster. Backups and recovery paths must be regularly tested.
- Reachable responsibilities: Security notifications must reach people who are authorised to act – also outside office hours and also during the holiday of the main responsible persons.
Unpatched legacy systems become more expensive
Installations that have fallen out of manufacturer support are particularly affected. For them, either no more patches appear, or updates are only achievable via elaborate version jumps. So far, such a state could be bridged with the argument that the application was inconspicuous and did not represent a worthwhile target.
This argument loses its viability when attacks are no longer selected in a targeted manner but are run automatically across the board. An overdue migration is then less a question of the range of functions than a question of risk.
Proportion instead of alarmism
Classification remains important: what was observed was a framework on an openly accessible server, not a widespread wave of attacks.
There is no evidence in this report of such tools being widely available, and no conclusions about specific victim numbers can be drawn from it.
The right reaction is therefore not crisis mode, but a sober assessment of how long the path from a published security advisory to an updated production system actually takes in one's own organisation. Surprisingly few organisations know this figure.
For web and software projects, this shifts the weighting between functionality and maintainability. Maintenance contracts, update automation and test coverage are not optional items that can be cut at the end of a project, but part of an application's operational capability. Anyone planning anew today should formulate the speed of their own patch process as a requirement – as concretely as load times or accessibility.