Can AI do novel security research? Meet the HTTP Terminator

James Kettle (Director of Research · PortSwigger)

SEC-T 2026 · Day 2 · Main hall

Overview

In an audacious exploration of artificial intelligence's capabilities in cybersecurity, James Kettle, Director of Research at PortSwigger, presented the HTTP Terminator at SEC-T. This talk delves into the ambitious goal of building a completely unsupervised system capable of inventing original hacking techniques, applying them for mass compromise of live websites, and then leveraging those compromised targets to discover even more novel attack vectors indefinitely. Kettle's research pushes the boundaries of autonomous security research, questioning how far beyond the current state-of-the-art AI can go before reaching its limits.

Watch on YouTube

Visual summary for Can AI do novel security research? Meet the HTTP Terminator by James Kettle
Visual summary for Can AI do novel security research? Meet the HTTP Terminator by James Kettle

Key moments

  1. 0:00 AI's first surprise: novel desync and API key theft
  2. 5:00 HTTP Terminator's four-phase autonomous research methodology
  3. 10:00 Micro inspiration: generating 30,000 novel desync vectors
  4. 20:00 Breakthrough: 'fake reality' for effective AI exploitation
  5. 23:30 AI's novel solution for stacked response problem
  6. 33:00 Most significant discovery: shared parser confusion meta-attack
  7. 38:30 Key takeaways: AI, human-in-loop synergy, and blueprint
  8. 43:00 Q&A: Advice for students on using AI in research

Can AI do novel security research? Meet the HTTP Terminator

Speakers: James Kettle (Director of Research, PortSwigger)

Conference: SEC-T

YouTube: https://www.youtube.com/watch?v=jCFZFDHnZrQ

Overview

In an audacious exploration of artificial intelligence's capabilities in cybersecurity, James Kettle, Director of Research at PortSwigger, presented the HTTP Terminator at SEC-T. This talk delves into the ambitious goal of building a completely unsupervised system capable of inventing original hacking techniques, applying them for mass compromise of live websites, and then leveraging those compromised targets to discover even more novel attack vectors indefinitely. Kettle's research pushes the boundaries of autonomous security research, questioning how far beyond the current state-of-the-art AI can go before reaching its limits.

The genesis of this project stemmed from Kettle's observation of AI finding vulnerabilities, leading him to wonder if it could truly innovate. The project's initial, startling success solidified this premise: overnight, the HTTP Terminator independently invented a novel desync vector, discovered its efficacy on the public infrastructure of a major bank, and, while developing a proof of concept, inadvertently exfiltrated a long-lived API key. This unexpected outcome underscored the profound, sometimes unpredictable, power of intelligent automation in security research.

Kettle's primary objectives for this research were multifaceted: to chart the new frontier of automation-driven research, provide a blueprint for others, push the autonomous concept to complete failure to highlight the enduring value of human intuition, and unequivocally demonstrate that AI-driven research, previously deemed impossible by some, is now a tangible reality. By focusing on HTTP desync attacks, a domain where Kettle himself has spent four years researching, he ensured a deep understanding of what constitutes genuine novelty, setting a high bar for the AI's "original" contributions.

Background

▶ Watch: AI's first surprise: novel desync and API key theft (0:00)

HTTP desync attacks, the chosen battleground for the HTTP Terminator, exploit a fundamental architectural weakness in how many web applications handle HTTP/1.x requests. Modern web infrastructures often involve front-end servers (e.g., load balancers, reverse proxies, CDNs) that funnel requests from multiple users over shared HTTP/1 connections to back-end servers. The inherent fragility of HTTP/1.x, particularly its weak isolation between individual requests sharing the same connection, creates a fertile ground for attackers. A desync occurs when the front-end and back-end servers disagree on the boundaries or interpretation of an HTTP request, leading to a "desynchronization" of their understanding of the request stream.

This desynchronization can enable a wide range of exploits, with response queue poisoning being a particularly potent one. In this scenario, the front-end server loses track of which response is intended for which user, inadvertently sending responses meant for one user to another. Attackers can leverage this to steal sensitive information such as session cookies, API keys, and other private data without direct interaction with the victims. James Kettle has been at the forefront of HTTP desync research for years, understanding the nuances of these attacks and the varying degrees of novelty in findings, from mildly innovative to major breakthroughs. For findings to "count" in his methodology, they must be proven exploitable on live, third-party websites, moving beyond mere theoretical possibilities. The problem persists due to the widespread reliance on HTTP/1.x in legacy systems and complex, multi-layered architectures where parsing discrepancies can easily arise.

Key Findings

▶ Watch: Micro inspiration: generating 30,000 novel desync vectors (10:00)

The HTTP Terminator project yielded a remarkable array of discoveries, validating the potential of autonomous AI in novel security research:

  • AI's Research Prowess: The system proved that AI can invent and validate genuinely novel desync triggers and weaponization techniques.
  • Protocol Ruler Technique: While not a direct finding of the Terminator, Kettle's initial tests demonstrated that advanced AI models, specifically GPT 5.6 soul, could, with appropriate prompting and inspiration, independently "invent" his previously unpublished "protocol ruler" technique for revealing input transformations by front-end servers.
  • Micro Inspiration and Vector Generation: By feeding tiny fragments (1-2 sentences) from 138 HTTP and SMTP RFCs, the system generated 30,000 unique desync vectors. This technique, dubbed micro inspiration, forced the AI to be both focused and creative, leading to unexpected payloads.
  • Transfer-Encoding: gzip Desync: One of the earliest and most impactful findings was the use of Transfer-Encoding: gzip (instead of the obvious chunked) in HTTP/1.0 requests. This single vector caused desyncs on numerous websites, notably exposing internal staff administration panels on an airport's system running F5 Big-IP software.
  • multipart/byteranges Content Type Desync: The system discovered a desync using the multipart/byteranges content type, specifically by splatting a payload directly into the body. This seemingly "dumber" approach worked on over 200 different websites across multiple web server implementations, including another major bank.
  • Novel Response Queue Poisoning Technique: To overcome the "stacked response problem" (where back-ends reset connections due to overreading), the AI proposed a clever "cheating" technique: leaving one byte off the second smuggled request. This eliminated the race condition, making response queue poisoning significantly more reliable, provided the back-end tolerated arbitrary methods.
  • Response Forking (Hypothetical): Through anomaly detection, the system identified a primitive where sending one request resulted in two responses, one compressed and sent over HTTP/0.9 without headers. This suggests a new class of desync that doesn't rely on message length disagreement or a body, though it remained hypothetical for response Q poisoning on that specific target.
  • Cache Poisoning DoS on Apache Traffic Server: A cascade of findings, starting with an AI-generated cache poisoning denial of service vector, combined with a permutation system and the TRACE method, revealed a desync zero-day affecting Apache Traffic Server, exposing many websites.
  • Shared Parser Confusion (Meta Attack Class): The most significant discovery was the identification of shared parser confusion. The AI astutely observed that an RFC rule for multipart/byteranges (intended for responses) triggered different behavior when used in a request. This implied that servers use shared code to parse both requests and responses, massively expanding the attack surface. Any response-processing feature could potentially be triggered from a request, explaining long-standing mysteries like servers processing Set-Cookie headers in requests (found in NodeJS). This was confirmed as a novel meta attack class, having no direct prior art.
  • Probes for High-Risk Behavior: The Terminator developed probes to identify "high-risk behavior" where a single, unambiguously clean request elicited two responses. A bug in the system (marking an unclean request as clean) led to an anomalous response on a Meta server, which, upon manual investigation, revealed a desync using two matching, correct Content-Length headers, one lightly obfuscated. This ultimately led to the compromise of an SSO system and the bank teased at the talk's opening.
  • Obfuscated Content-Length Desync: The final major finding, unleashed after a bug fix, involved using two matching, valid Content-Length headers, with the second one subtly obfuscated. This "exquisite" technique proved highly effective, compromising numerous websites.

Technical Deep Dive

▶ Watch: AI's novel solution for stacked response problem (23:30)

The HTTP Terminator is structured around a four-phase methodology: Ideation, Evaluation, Weaponization, and Cascade, each contributing to a self-improving research loop. The entire system's source code, comprising over 50,000 lines, has been open-sourced, with key components integrated into popular security tools like Burp Suite's HTTP Request Smuggler, Param Miner, and Turbo Intruder.

1. Ideation (Hypothesis Generation):

The initial challenge was determining if AI models could generate valuable research hypotheses. Kettle tested this by asking models to invent his unpublished "protocol ruler" technique. Generic prompts universally failed. However, by framing the question around concrete objectives and explicitly ruling out bad solutions, some frontier models occasionally succeeded. Crucially, providing inspiration from past research (e.g., SSRF detection) initially worsened performance due to over-anchoring, until GPT 5.6 soul demonstrated the ability to extract generalizable techniques.

To generate novel and scalable desync triggers, Kettle invented micro inspiration. This involved taking classic research sources like HTTP RFCs, splitting them into tiny, single-concept fragments (1-2 sentences), and then prompting the AI to generate multiple desync vectors from each. This technique forced the AI to be both focused and creative. From 138 HTTP and SMTP RFCs, 15,000 micro fragments were extracted, leading to 30,000 unique desync vectors after normalization. While the plan was to incorporate other sources like mailing lists and GitHub issues, the sheer volume and quality of findings from RFCs alone necessitated a shift in focus to processing these discoveries.

2. Evaluation (Hypothesis Evaluation Strategy):

With 30,000 vectors, an efficient and accurate evaluation system was paramount. The HTTP Terminator evaluates every trigger on approximately 30,000 bug bounty websites. This component, implemented as a Burp Suite extension running on a single EC2 instance with 2,000 threads 24/7, contains no AI, making it cost-effective. The system continuously tries novel techniques, and after exhausting the initial database, it generates permutations and combinations of existing vectors, theoretically allowing it to test over a billion unique desync triggers on a single target if run long enough.

The core of this phase is the hypothesis evaluation strategy. To avoid false positives (which would drown real discoveries in noise at this scale) and false negatives (missing unexpected vulnerability types), the system maintains no expectations about the poisoned response. Instead, it simply observes a regular request that typically receives a consistent response. If this request intermittently receives a different response when paired with a potential desync trigger, it flags a potential desync. This allows for the detection of any contamination pattern. Subsequent logic then attempts to map recognized patterns (e.g., CL0) for easier exploitation.

3. Weaponization (Achieving Security Impact):

Once a desync trigger is identified, the system moves to weaponization, specifically achieving response queue poisoning. Kettle integrated his desync weaponization tool of choice, Turbo Intruder, with an MCP interface and a popular coding harness running in "YOLO mode." A Python script orchestrated this by spinning up a coding agent per website, instructing it to achieve response queue poisoning.

Initial attempts revealed significant challenges with AI models' weaponization capabilities: they replicated beginner mistakes (e.g., misinterpreting HTTP pipelining as desync) and were difficult to teach. They also insisted on client-side connection reuse, which exacerbated false positives. The breakthrough came from a "fake reality" strategy:

  • Renaming Turbo Intruder to Turbo Simulator made the AI more reckless, thinking it was only simulating attacks.
  • A "placebo" connection reuse feature, which told the AI it was reusing connections but did nothing, solved the false positive issue.
  • Hiding misleading signals in responses and coining a new term, "victim response theft," to escape bad training data associated with "response Q poisoning," further improved performance.

Kettle learned to gradually shift responsibility from AI to deterministic, persistent code for attack orchestration and success validation. While AI continued to find bypasses for validation logic, these were patched one by one. The process was broken down into steps with code validation gates and AI validators, ensuring each step had fresh context, passing only evidence from previous stages to prevent contamination. This robust pipeline led to a healthy number of websites vulnerable to response Q poisoning. A notable challenge in response Q poisoning is the stacked response problem, where back-ends overread into a second response and reset connections. The AI's solution to this was ingenious: leaving one byte off the second smuggled request, eliminating the race condition entirely.

4. Cascade (Discoveries Inspire Discoveries):

The cascade phase is where the system truly aims for novel breakthroughs by harnessing chaos and unexpected findings. This starts with two questions: "How can I detect similar behavior elsewhere?" and "Does the root cause of this behavior enable other attacks?"

An early bug in the evaluation harness mangled a payload, triggering a memory leak and a random status code change, which was mistakenly flagged as cross-request contamination. This highlighted that the Terminator was ignoring dangerous behaviors not directly classified as desyncs. Kettle added an anomaly detection layer to flag other memory leaks. This layer, in turn, discovered "response forking" on one website: combining the byteranges content type with an invalid Content-Length resulted in a mysterious large binary blob—a second response compressed and sent over HTTP/0.9 without headers. While a hypothetical attack, it represented a new class of desync.

Further refinement of the anomaly detection layer led to unexpected discoveries. The ideation system sometimes deviated to create vectors for other attack classes. One such deviation, combined with the permutation system and the TRACE method, exposed a cache poisoning denial of service zero-day in Apache Traffic Server. Kettle noted that while the finding was autonomous, the cascade that created the conditions was not, as each step involved human oversight of the anomaly detection layer. He proposed that treating anomaly detection patterns as untrusted input could enable fully autonomous cascades.

A subsystem was added to analyze findings, combining evidence from compromised sites with original RFC inspiration to identify root causes and predict other threats. While this generated some new desync vectors, the most significant outputs were "other attack ideas" requiring manual review. The AI struggled with "broader jumps" in reasoning, though a "that's not good enough" follow-up prompt slightly improved performance. This led to three key curiosities:

  • Protocol Identifier Copying: A response's protocol identifier being directly copied from the request, enabling back-end attacks on the front-end's response processor, causing buffering breakdowns and memory leaks on one site.
  • Cached Partial Responses: Sites failing to specify the 206 status code for partial responses, allowing them to be cached and served to normal users, potentially enabling cross-site script installed XSS (hypothetical).
  • Shared Parser Confusion: The most impactful finding, detailed in Key Findings, where the AI observed that RFC rules for response processing (like multipart/byteranges) were triggering different behavior in requests, implying shared parsing logic between requests and responses. This expands the attack surface to include any response-processing feature that could be triggered from a request (e.g., Set-Cookie in requests in NodeJS).

Finally, a "subtle" cascade involved a desync on a Beyond Trust product, exploitable only when deployed behind a front-end forwarding CONNECT requests. This prompted Kettle to think about predicting vulnerability based on direct server access. By identifying "clean requests" (RFC-compliant, unambiguously single requests) that still yielded two responses, a new anomaly detection flag was created. A bug in the Terminator's classification of a probe led to an anomalous response from Meta, revealing a desync using two matching, correct Content-Length headers, one lightly obfuscated. This shared with Paulo, led to more compromises, including the SSO system and the bank teased at the start, highlighting a bug in the Terminator's own code that had suppressed many valid payloads for months.

Demo / Proof of Concept

▶ Watch: Most significant discovery: shared parser confusion meta-attack (33:00)

While the talk meticulously describes the methodologies and outcomes of the HTTP Terminator, it does not feature a live demonstration of the system actively discovering or exploiting vulnerabilities. Instead, James Kettle presents the "proof" through the detailed recounting of the system's findings, the impact these findings had on real-world targets, and the underlying technical mechanisms. For instance, he mentions handing over the Transfer-Encoding: gzip vector to his collaborator Paulo, who then manually achieved response queue poisoning on multiple sites, including an airport's F5 Big-IP system. The "proof of concept" is thus presented through the documented capabilities and results of the HTTP Terminator rather than a real-time, interactive demonstration.

Defensive Implications

▶ Watch: Q&A: Advice for students on using AI in research (43:00)

The research presented by James Kettle offers critical insights for defenders looking to secure their applications against advanced HTTP desync attacks and other novel vulnerabilities.

  1. Abandon HTTP/1.x Upstream: The most emphatic recommendation is to abandon HTTP/1.x for upstream communication. As Kettle states, "HTTP/1 must die." HTTP/2 is inherently more secure against many desync vectors because its framing layer prevents the ambiguities that HTTP/1.x suffers from. If a front-end rewrites HTTP/2 to HTTP/1 for the back-end, the problem persists, so the entire chain must ideally use HTTP/2 or newer.
  2. Beware of Shared Parser Confusion: The discovery of "shared parser confusion" is a game-changer. Defenders must assume that server components might be using shared code for parsing both requests and responses. This means any feature intended for response processing could potentially be triggered via a crafted request. Developers should review their codebases for such shared logic and implement strict separation or input validation specific to the context (request vs. response).
  3. Robust Anomaly Detection: The success of the "cascade" phase hinged on identifying anomalous behavior. Defenders should invest in sophisticated logging and anomaly detection systems that can flag unexpected server responses, even if they don't immediately fit known vulnerability patterns (e.g., unexpected status codes, memory leaks, multiple responses for a single request). These anomalies could be early indicators of novel attack vectors.
  4. Strict HTTP Parsing and Normalization: Front-end and back-end servers must have a consistent and strict interpretation of HTTP/1.x request boundaries and headers. Any discrepancies, such as how Content-Length headers (especially obfuscated ones) or Transfer-Encoding headers are handled, can be exploited. Normalizing incoming requests to a canonical form before forwarding them can mitigate some desync risks.
  5. Continuous Vulnerability Research: The HTTP Terminator's ability to invent and combine techniques underscores the need for organizations to conduct continuous, proactive vulnerability research. Relying solely on known CVEs or signatures is insufficient against an AI-driven attacker that invents new methods.
  6. Human-AI Collaboration: While AI can find vulnerabilities, the "biggest breakthroughs" often come from human-in-the-loop cascades. Defenders should consider how to integrate AI tools into their security analysis workflows, not to replace human analysts, but to amplify their capabilities and accelerate the discovery of complex, novel attack paths.
  7. Patch Specific Vulnerabilities: Specific findings like the Transfer-Encoding: gzip desync on F5 Big-IP or the Apache Traffic Server cache poisoning DoS highlight the need for prompt patching and configuration reviews for affected products.
  8. Careful Use of AI Tools: Kettle warns that the HTTP Terminator and its components (like the Turbo Intruder MCP) can "hack things you did not ask it to" and execute arbitrary code. Defenders experimenting with such tools in their own environments must do so with extreme caution and in isolated, controlled settings.

Key Takeaways

  • AI Can Do Novel Security Research: The HTTP Terminator unequivocally demonstrates that AI systems can autonomously invent, evaluate, and weaponize novel security research, moving beyond mere vulnerability discovery to true innovation in attack techniques.
  • Research Cascades are Crucial for Breakthroughs: The most significant and unpredictable discoveries arise from "cascades," where initial findings inspire further research, leading to a chain reaction of insights that uncover entirely new attack classes.
  • Humans Amplify AI Research: While AI can operate autonomously, human involvement, particularly in overseeing and guiding research cascades and refining anomaly detection, acts as a "massive power amplifier" for AI research systems, leading to more profound breakthroughs.
  • Robust Evaluation is Paramount: For large-scale automated research, a highly reliable and unbiased hypothesis evaluation strategy is the absolute key to success, preventing false positives and ensuring genuine novelty in findings.
  • HTTP/1.x is a Fundamental Weakness: The talk reinforces that HTTP/1.x's architectural design makes it inherently susceptible to desync attacks, advocating for its abandonment in favor of more secure protocols like HTTP/2 for all upstream communications.
  • Shared Parser Confusion Expands Attack Surface: The discovery of "shared parser confusion" represents a significant new meta attack class, revealing that features intended for response processing can often be triggered from requests, necessitating a re-evaluation of parsing logic in web servers and applications.

About the Speaker(s)

James Kettle is the Director of Research at PortSwigger, a leading cybersecurity company known for its Burp Suite web vulnerability scanner. With a distinguished career in security research, Kettle is particularly renowned for his extensive work on HTTP desync attacks, a field he has dedicated over four years to researching prior to this project. His deep expertise in this complex area made him uniquely qualified to evaluate the true novelty of the HTTP Terminator's findings. Kettle's work often pushes the boundaries of web security, revealing fundamental architectural flaws and developing innovative exploitation techniques. He is a frequent speaker at security conferences and has collaborated with other prominent researchers, such as Paulo, on various projects.

Reviews

Dr. Zero (Offensive Security Researcher) — MUST SEE

James Kettle is the only researcher who can slap "AI" on a CFP and not trigger my bullshit allergy. He didn't build a wrapper; he built an autonomous desync engine that farmed zero-days off live bug bounty targets and discovered an entirely new meta-class of vulnerabilities. If you want to know what automated vulnerability research actually looks like when it's not vendor marketing, this is the gold standard.

Heather Calloway (CISO) — MUST SEE

Kettle just proved that AI can autonomously invent novel attack classes against core web infrastructure. This isn't a vendor demo of a chatbot; it's a demonstration of a permanent shift in offensive capability. Your architecture and AppSec teams need to watch this to understand why your legacy HTTP/1.x footprint is now an unmanageable liability.

→ Top-rated talks at SEC-T 2026

All talks from SEC-T 2026