AI 極速發現軟件漏洞,修補卻是另一回事
AI is Finding Vulnerabilities at Warp Speed. Fixing Them is a Whole Other Story.
文章指出,前沿 AI 模型已能快速發現並利用軟件漏洞,但業界驗證、修補和部署修正的速度未能跟上。在 ExploitBench 上,智譜 AI 開放權重 GLM-5.3 在 410 次嘗試中 50 次成功開發可運作的端到端攻擊,Claude Mythos Preview 則為 56 次。
We have a new problem in cybersecurity, and ironically, it’s triggered by our ability to find problems faster than ever before.
Frontier AI models are getting really good at discovering and exploiting software vulnerabilities, meaning flaws that could have remained hidden for years are now being uncovered at speeds that would have been almost impossible to imagine a few months ago.
But the challenge is that the industry is getting much better at finding vulnerabilities than it is at fixing them. Consider the latest research from Anthropic. Zhipu AI’s open-weight GLM-5.3 successfully developed working end-to-end exploits in 50 out of 410 attempts on the ExploitBench benchmark, while Claude Mythos Preview managed 56.
That’s an extremely small gap between a restricted frontier model and one whose weights are openly available. Capabilities that once required highly specialized security researchers are becoming accessible to a much wider audience. And meanwhile, the software we’re all running hasn’t suddenly become less vulnerable. We’ve entered an era where finding a zero-day can actually be faster than the process of fixing it.
The recent PHP2Shell vulnerabilities are a prime example. According to research from Wiz, Calif and OpenAI’s Codex Security team, frontier AI helped a single researcher uncover critical flaws in the PHP engine in about a week. These vulnerabilities affected a runtime that underpins a substantial proportion of the web, including applications built on WordPress, Drupal and Joomla.
For security teams, that raises an urgent question: What happens when attackers can discover vulnerabilities faster than defenders can patch them?
The Vulnerability Management Playbook Wasn’t Built for This
For years, vulnerability management has followed a familiar rhythm. A vulnerability is discovered, someone reports it, a CVE is assigned, a patch becomes available, scanners flag it, security teams assess the risk, prioritize the fix, and deploy it. It’s not a perfect process, but the entire security ecosystem has been built around it.
The real problem, however, is that it largely depends on knowing about the vulnerability in the first place. Traditional scanners are great at telling you which known vulnerabilities exist in your environment, but what about the ones that haven’t been disclosed? The ones without a CVE, an advisory, or a patch?
The PHP2Shell disclosure illustrates how exposed this model leaves us. The two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619, were both rated CVSS 9.2 and involved memory-safety flaws in PHP itself. Researchers demonstrated remote code execution and memory disclosure against widely used applications, including WordPress, Drupal and Joomla. Even applications with otherwise secure code could be vulnerable because the weakness existed in the underlying runtime.
And the timeline was equally revealing. Following an early public warning, PHP’s security team accelerated its release schedule. By the time patches became available, early attack attempts were already being observed.
Not to mention, PHP wasn’t the only problem that day. A separate software supply chain attack compromised LiteLLM version 1.107.0, a popular open-source gateway for large language models. Attackers embedded an infostealer and remote access trojan in the published Python package, while the project’s source repository remained clean. A team reviewing the source code alone would have missed the malicious payload entirely.
These incidents highlight how vulnerabilities can exist deep inside trusted software components for years, while malicious code can also enter through the dependencies organizations routinely install. Neither necessarily originates in an application’s own code.
And it also highlights how your scanner can give you a clean bill of health even when serious vulnerabilities still sit in the software your applications depend on. Until recently, discovering hidden flaws at scale required significant research expertise and resources, but Frontier AI is changing that equation.
Finding the Bug Is the Easy Part. Now What?
There’s a lot of excitement around AI’s ability to discover zero-days. Rightly so, as the progress is extraordinary, but I think there’s too much hype around how many vulnerabilities AI can find, and not nearly enough around what happens next.
Finding a vulnerability doesn’t make you safer. First, you need to prove it’s real since AI-generated findings aren’t automatically valid, and a convincing-looking exploit isn’t always reproducible. You then need to understand which versions are affected, whether the vulnerability is actually exploitable, and what risk it creates.
Then you need to fix it, and that’s where things get particularly interesting. Research from 1Password examined 6,080 AI-generated patches and found that 53.9% failed to resolve the original vulnerability, introduced a new security flaw, or both.
In that study, more than half of the generated patches had a security problem of their own. Of course, these results reflect specific testing conditions. But they illustrate something every experienced engineer knows: writing code that looks like a fix and proving that it actually fixes the problem are two very different things.
And even when the patch is correct, you’re still not done. Will it break existing functionality? Does it work with the older version of the library your application depends on? Can it be deployed without forcing an upgrade that introduces a dozen other problems?
What happens when you need to roll it out across hundreds of applications, teams, and environments? A patch that works in a test environment but never reaches production isn’t protecting anyone. This is the great divide I think the security industry needs to confront.
We’re accelerating vulnerability discovery insanely fast, while much of the work required to turn those discoveries into actual protection remains painfully slow. And that gap is becoming a security risk in its own right.
So How Do We Actually Close the Gap?
I don’t think the answer is to tell already overwhelmed security teams to work harder or process more alerts. We need to rethink what effective vulnerability management looks like when discovering flaws is no longer the biggest bottleneck.
Here are the four places I’d start.
1. Don’t Treat the CVE Database as the Full Picture
CVEs and vulnerability scanners are essential, but they’re a record of what we know – not everything that actually exists. Security teams need to start thinking beyond publicly disclosed vulnerabilities, combining traditional scanning with proactive research, code analysis, threat intelligence, and a clear understanding of the software components their organizations rely on.
Resources like CISA’s Known Exploited Vulnerabilities Catalog are valuable for prioritizing known threats, but they can’t tell you about vulnerabilities nobody has disclosed yet. PHP2Shell showed that serious vulnerabilities can exist in foundational software for years before discovery. When frontier AI can uncover these flaws in days, relying exclusively on published advisories means defenders will always be reacting to someone else’s timeline.
2. Recognize That More Findings ≠ Better Security
AI can generate an enormous volume of potential findings, but that doesn’t mean every finding deserves an engineering team dropping everything to investigate it.
The real value comes from knowing which vulnerabilities are genuine, exploitable, and relevant to your environment. Can you reproduce the issue? Which versions are affected? Is there a realistic attack path? What’s the actual business impact?
Without that context, organizations risk prioritizing vulnerabilities based on severity scores alone while overlooking how attackers could actually reach sensitive systems and credentials.
3. Make the Fix Deployable, Not Just Technically Correct
This is one of the most underestimated challenges in vulnerability remediation. Enterprises don’t operate in pristine environments where every dependency can be upgraded to the latest version overnight. They have legacy applications, interconnected systems, compatibility requirements, and software versions they can’t simply replace.
So a fix that requires an organization to rebuild half its infrastructure isn’t particularly useful. We need better ways to backport security patches, preserve compatibility, reduce unnecessary attack surfaces, and deliver updates through the tools and workflows teams already use.
NIST’s enterprise patch management guidance emphasizes the importance of identifying, prioritizing, installing, and verifying updates. The challenge now is making that entire process fast enough to keep pace with AI-driven discovery because the best patch in the world is useless if nobody can deploy it.
4. Measure How Fast You’re Actually Protected
If AI discovers a critical vulnerability today, how long does it take to validate it, develop a working patch, test that patch, and get it into production?
The PHP2Shell response offers a useful benchmark. At Echo, we delivered fixed PHP packages right after the upstream patches became available, with updated images for supported PHP versions rebuilt that same afternoon.
Security teams should be measuring the entire remediation lifecycle, from discovery and validation through patch development, compatibility testing, and deployment. They should know how quickly they can rebuild affected software, whether they can identify every application using a vulnerable dependency, and how much manual intervention is required to get protected.
As frontier AI makes vulnerability discovery faster and more accessible, the window between discovery and potential exploitation will continue to shrink. We cannot assume that traditional disclosure and patching cycles will keep pace. The next era of vulnerability management will be defined by who can turn those discoveries into reliable, deployable fixes before attackers have the opportunity to act.
來源:Unite.AI · unite.ai