# AI "Vulnerability Vending Machine" Automates Zero-Day Discovery: What Security Teams Need to Know


Intruder, a security research firm, has revealed a groundbreaking automated system that combines artificial intelligence with advanced code analysis to discover software vulnerabilities at scale. The company's "vulnerability vending machine" uses large language models and code-slicing techniques to identify complex security flaws that might evade traditional static analysis tools. The system has already uncovered a previously unknown WordPress plugin zero-day vulnerability, alongside additional discoveries currently under responsible disclosure. This capability represents a significant inflection point in the vulnerability research landscape—and raises urgent questions about the asymmetric threat environment defenders now face.


## The Threat: Automation Meets Vulnerability Discovery


The core innovation lies in automating a process that security researchers have traditionally performed manually: identifying subtle, exploitable vulnerabilities in large codebases. Intruder's system feeds software code into a pipeline that combines two complementary approaches:


Code Slicing Technique: The system first performs intelligent code reduction, extracting only the portions of code relevant to a specific functional flow. This dramatically reduces the noise that typically confuses traditional static analysis tools and makes the code more tractable for analysis.


LLM-Powered Analysis: The sliced code is then submitted to large language models, which excel at pattern recognition and can identify subtle logical flaws, missing input validation, unsafe function calls, and other indicators of exploitable vulnerabilities.


The result is a system that discovered a genuine zero-day in a WordPress plugin—a class of vulnerability that affects millions of websites worldwide. The researchers responsibly disclosed the flaw and worked with the plugin maintainers before publication. But the system has allegedly discovered additional vulnerabilities that remain under controlled disclosure.


This capability differs fundamentally from traditional vulnerability discovery methods. Static analysis tools typically generate high false-positive rates. Manual code review by human researchers doesn't scale. Fuzzing and dynamic analysis require understanding input schemas and can miss logic flaws. Intruder's hybrid approach appears to sidestep some of these limitations by leveraging LLM reasoning capabilities alongside structured code analysis.


## Background and Context: The Vulnerability Discovery Landscape


Vulnerability research has historically followed a predictable cycle:


  • Academic researchers publish novel vulnerability classes or discovery techniques.
  • Security companies commercialize those techniques into tools and services.
  • Defenders gradually adopt detection and remediation practices.
  • The gap closes, and researchers move to the next vulnerability class.

    • This cycle typically spans years. A vulnerability type might dominate headlines, consume security budgets, and then gradually become a solved problem as best practices crystallize.


    The automation of vulnerability discovery threatens to compress this cycle dramatically. If AI systems can discover novel zero-days faster than defenders can patch existing vulnerabilities, the asymmetry favors attackers.


    The timing is significant. The cybersecurity industry is simultaneously grappling with:


  • An explosion of open-source adoption without corresponding security investment in those projects.
  • Limited remediation velocity: the average time from vulnerability disclosure to patch deployment remains measured in months or years for many organizations.
  • LLM accessibility: tools like OpenAI's API and open-source models are available to anyone, not just well-funded security firms.

    • Intruder's disclosure suggests the technology is mature enough to find real vulnerabilities in real software—not theoretical edge cases.


    ## Technical Details: How the System Works


    ### Code Slicing

    The system doesn't analyze entire codebases blindly. Instead, it performs dependency and control-flow analysis to extract the minimal code paths relevant to a specific operation. For example, if analyzing how a plugin handles user input, the system traces the flow from the entry point through all dependent functions and libraries, discarding irrelevant code.


    This approach is clever because:

  • It reduces noise: LLMs work better with focused input rather than massive files.
  • It maintains context: the relevant dependencies and function calls are preserved.
  • It's language-agnostic: code slicing can work across PHP, JavaScript, Python, and other languages.

    • ### LLM Integration

    Once code is sliced, the LLM is prompted with security-focused questions:

  • "Identify functions that accept user input and process it without validation."
  • "Are there SQL queries that concatenate user-provided values?"
  • "Are there race conditions in concurrent code paths?"
  • "What happens if this function receives an unexpectedly large input?"

    • LLMs excel at this because they've been trained on vast amounts of vulnerable and patched code, security advisories, and technical documentation. They can recognize subtle patterns that might indicate a vulnerability even when the code doesn't match a known vulnerability pattern exactly.


    ### The WordPress Plugin Zero-Day

    While Intruder hasn't published full technical details, the WordPress ecosystem is particularly vulnerable to automated discovery because:

  • Plugin code is typically single-purpose and self-contained, making code slicing straightforward.
  • WordPress has a massive installed base (over 40% of all websites), making even low-severity vulnerabilities valuable.
  • Plugin code quality is highly variable; many plugins are maintained by small teams with limited security expertise.
  • The attack surface is wide: any authenticated or unauthenticated user can trigger plugin functionality.

    • ## Implications: The New Vulnerability Asymmetry


    This development carries several significant implications:


    For Software Developers: The assumption that code obscurity or complexity provides security is now actively dangerous. Open-source projects should expect that sophisticated AI-assisted tools will find their vulnerabilities.


    For Software Vendors: The time window between vulnerability discovery (by AI systems) and patch distribution has shrunk. Vendors who rely on "security through obscurity" or delay patching will face adversarial discoveries before they can remediate.


    For Defenders and Security Teams: Organizations relying on zero-day exploits remaining undiscovered for years cannot count on that assumption anymore. Patch velocity and detection capabilities become critical.


    For the Open-Source Community: Smaller projects with limited security review may suddenly face public disclosures of vulnerabilities their maintainers have no capacity to fix quickly.


    For Vulnerability Markets: The economics of zero-day discovery may shift. If vulnerability discovery becomes automated and commodified, the underground market for zero-days could see either increased supply (driving down prices) or consolidation (as larger players dominate the market).


    ## Recommendations for Organizations


    ### For Development Teams

  • Adopt Static Analysis: Integrate tools like Semgrep, CodeQL, or similar into your CI/CD pipeline. These tools won't catch everything an LLM can, but they'll catch common patterns.
  • Security Code Review: Have human security experts review critical code paths, particularly authentication, authorization, and input validation logic.
  • Reduce Attack Surface: Every exposed function is a potential target. Audit what code is actually exposed to user input.

    • ### For Security Operations Centers

  • Accelerate Patching: Assume that zero-day vulnerabilities may be discovered automatically. Reduce your patch window to days, not weeks.
  • Monitor for Exploitation: Deploy behavioral monitoring and anomaly detection that can catch exploitation attempts even if you don't know about a specific vulnerability yet.
  • Threat Modeling: Regularly update threat models to account for the possibility of zero-day exploits in critical software.

    • ### For Vendor and Plugin Developers

  • Security-First Development: Adopt threat modeling, secure code practices, and regular security reviews as standard practice.
  • Responsible Disclosure Coordination: Establish clear policies for handling vulnerability reports and commits for rapid patching.
  • Transparency: If you maintain open-source software, acknowledge security limitations and commit to responsive patching.

    • ---


    ## HackWire Analysis


    The "vulnerability vending machine" represents a watershed moment in the industry—not because the underlying techniques are novel, but because they've been proven effective at scale. Intruder's disclosure is careful not to position this as an arms race (yet), but the implications are unavoidable: if one security company has built this, others will follow, and eventually, the technology will leak or be commercialized for defensive and offensive purposes alike.


    What makes this particularly significant is the *timing*. We're in the middle of an AI-driven productivity explosion. LLMs are being integrated into everything from IDE plugins to security tools. The industry narrative has been largely optimistic: "AI will make security better." But Intruder's work is a concrete reminder that the same tools that help defenders will also amplify offense.


    The WordPress plugin zero-day is particularly telling. WordPress powers over 43% of all websites, yet its security posture is fundamentally bottlenecked by the capacity of independent volunteers to review code. An AI system that can automatically find vulnerabilities in that ecosystem doesn't even need to be that sophisticated—the target-rich environment does the heavy lifting.


    For defenders, the practical implication is brutal: *patch velocity is now your primary defense mechanism*. Organizations that can deploy patches within 48 hours of disclosure will have windows to detect and prevent exploitation. Organizations that take weeks or months to patch are now competing against automated vulnerability discovery and a potential glut of zero-days. The comfortable assumption that unknown vulnerabilities will remain unknown for months or years is no longer valid.


    The second-order effect is economic. If AI makes vulnerability discovery commodified and scalable, the underground market for zero-days could shift dramatically. Why buy an expensive zero-day from a broker if you can run an automated discovery system yourself? Conversely, if everybody has the same capability, zero-days become less differentiated and valuable. Either way, the economics of vulnerability markets are entering uncharted territory.


    The industry should pay attention not just to the technical innovation but to the disclosure itself. Intruder chose to publish this publicly, presumably to raise awareness and drive adoption of stronger security practices upstream. That's responsible disclosure at the industry level. But it's also a signal: *this technology exists, it works, and it's going to proliferate*. Organizations that don't treat vulnerability response and patching as critical infrastructure will be increasingly exposed.


    — *HackWire Editorial*


    ---


    ## Related Coverage


  • Read more in our [Vulnerabilities](https://www.hackwire.news/category/vulnerabilities) coverage
  • Cross-reference with [Breaches](https://www.hackwire.news/category/breaches) and [Malware](https://www.hackwire.news/category/malware)
  • Stay current via the [HackWire homepage](https://www.hackwire.news/)