Back to Blog
DDoSAIBot TrafficWAFDDoS Testing

AI-Generated DDoS Attacks: What Changes for Defences and What a Test Must Prove

BlackNeuron Research Team
November 12, 2026
12 min read
AI-Generated DDoS Attacks: What Changes for Defences and What a Test Must Prove

The phrase "AI-generated DDoS attack" is used far more often than it is evidenced.

That does not make it empty. It means the useful question is narrower than the headlines: which parts of a denial-of-service attack does a model make cheaper, and which of your defences were quietly relying on those parts being expensive?

Most DDoS controls encode a guess about the attacker. That the tool repeats itself. That the flood is loud. That nobody outside knows what normal looks like. That a human on your side can write a rule faster than a human on theirs can change the traffic. Each guess was reasonable when variety cost the attacker time. Automation, and now language models, take that cost away.

What the phrase means

An AI-generated DDoS attack is a denial-of-service attack in which a machine-learning model or large language model does part of the attacker's work: mapping the target, writing or varying the requests, or choosing when to change approach. The packets still come from botnets, proxy networks and rented servers. The model changes the decisions behind the traffic, not the bandwidth under it.

That split runs through everything below. Where an attack is limited by bandwidth or packet rate, AI adds nothing. Where it is limited by the attacker's time and attention, it adds a great deal.

What the public record shows

The providers who can see misuse

The organisations best placed to watch attackers use models are the model providers themselves, and their published findings are consistent.

In February 2024, Microsoft and OpenAI reported that five state-affiliated groups had used OpenAI's models for research on targets, help with scripting and translation, and closed the accounts. In January 2025, Google's Threat Intelligence Group published its review of threat actors using Gemini and described the same pattern: reconnaissance, code troubleshooting and content, a gain in productivity rather than a new capability.

None of those reports describes a model designing a flood. They describe a model doing the tedious parts faster.

The national assessment

The UK's National Cyber Security Centre reached a similar view in January 2024, in its assessment of AI's near-term impact on the cyber threat. It judged that AI would almost certainly increase the volume and heighten the impact of attacks over the following two years, mostly by improving existing techniques, with the clearest uplift in reconnaissance.

Volume and reconnaissance are exactly the two things a DDoS campaign spends its effort on. That is the honest basis for taking the subject seriously: not a new weapon, but an old one that is cheaper to aim and cheaper to vary.

The automated traffic that already arrives

The AI era's clearest effect on availability so far did not come from attackers. In April 2025, the Wikimedia Foundation reported that bandwidth used to download multimedia from its projects had grown 50% since January 2024, driven mainly by scrapers collecting training data, and that bots generated about 65% of its most expensive traffic while accounting for roughly 35% of pageviews.

The reason it was expensive matters here. Readers cluster on popular pages that sit in cache; bulk crawlers read the long tail, which does not. That is the same property a cache-busting attack exploits on purpose, arriving with no malicious intent and from many addresses at once.

Any site that has had to separate heavy AI crawlers from customers has already met the core problem of AI-era DDoS: automated traffic that is not obviously automated, and not obviously hostile, at a volume that still hurts.

What a model cannot add

A language model does not make a reflector answer with more bytes, does not lift the uplink on a compromised camera, and does not let anyone spoof source addresses on a network that applies BCP 38. The size of a volumetric flood is still set by how much capacity the attacker controls or rents.

So the defences against the loud end of the spectrum are measured the way they always were: upstream scrubbing capacity, the diversion path, and whether the provider in front of you absorbs a volumetric attack of the size you plan for. None of that needs re-thinking because a model is involved.

Where AI enters a DDoS attack The model changes the decisions around delivery. Delivery itself is the same capacity as before. 1. Map the target endpoints, origin addresses, app API calls, the shape of normal traffic AI: days become minutes 2. Craft the requests headers, paths and pacing that follow real user journeys AI: variants on demand 3. Deliver botnets, proxy networks, reflectors, rented servers Unchanged: sets the size 4. Read and switch blocks, challenges and latency decide the next variant AI: the loop in seconds feedback: each response shapes the next request cheaper with AI: limited by the attacker's time no change: limited by bandwidth and packet rate BlackNeuron™
AI-generated DDoS attacks and the attack chain: AI lowers the cost of target mapping, request crafting and the feedback loop that decides when to switch, while delivery capacity from botnets, proxy networks, reflectors and rented servers is unchanged and still sets the size of a volumetric flood

What changes is everything on either side of delivery. Before it, finding the endpoint worth hitting, the origin worth bypassing to, and the request shape that blends in. After it, reading how the defences reacted and producing the next variant.

The assumptions each defence makes

Every control below is a bet on what the attacker finds expensive. The table is the short version.

ControlWhat it assumesWhat makes the assumption cheaper to break
Signatures and static WAF rulesthe tool repeats itselfrequest variants generated on demand
Fixed rate thresholdsthe flood is loudlow-rate requests aimed at costly paths
Behavioural baselinesthe attacker does not know your normalpublic traffic patterns mapped in advance
Image and puzzle challengesa bot cannot seevision models that solve them
Manual rule changes during an incidentyour team changes faster than the traffic doesa variant loop measured in minutes or less

Signatures assume the tool repeats itself

A signature-based rule works because flood tools are lazy. They send the same header order, the same user agent, the same path pattern and the same TLS client hello from every node, and one rule catches the lot.

Variation was always possible. It used to need someone to write it. A model asked for a hundred plausible request templates, each with a believable header set, query string and navigation path, produces them in seconds, and the rule written against template one says nothing about template forty.

TLS fingerprints are harder to vary than headers, because they come from the client library rather than the request. JA3/JA4 fingerprinting still separates a scripting library from a real browser. It does far less once the traffic comes from real browsers driven by automation, which is the direction the cheap tooling is moving.

Thresholds assume the flood is loud

A fixed requests-per-second limit catches what is abnormally fast. Reconnaissance turns that around: an attacker who has found the search query, the report export or the uncached product filter can exhaust an origin at a rate well inside any per-client limit.

Mapping an application used to be manual: read the JavaScript bundle, browse the site, pull the mobile app apart for its API calls. That is the kind of patient, text-heavy work models do quickly, and it is what the NCSC meant by reconnaissance uplift. Why a cheap request can carry an expensive backend cost is covered in API DDoS testing; the AI-specific point is that finding those requests no longer takes days.

Spreading the load across many addresses is older than any of this. Carpet-bombing and residential proxy networks already defeat per-IP limits. Models do not create that capacity; they make better use of it.

Baselines assume the attacker does not know your normal

Anomaly detection learns what normal traffic looks like and flags what departs from it. It is strongest against attackers who do not know the shape of normal and send something visibly different.

A great deal of normal is public. Popular pages, the order people move through a checkout, the share of mobile clients, the hours your customers wake up, the paths your app calls on launch: much of it can be inferred from outside. Traffic generated to follow those flows, at human pacing, from residential addresses, moves the attack from "abnormal" toward "busy day".

The baseline still has one advantage the attacker lacks: it sees the outcome. A flood can imitate the path real users take; it cannot easily imitate what real users then do, such as completing a purchase or returning tomorrow from the same device.

Challenges assume a bot cannot see

Interactive challenges ask the client to prove it is human by recognising something. That bet has weakened. A 2024 paper from ETH Zurich reported solving every reCAPTCHA v2 image challenge it was given using an off-the-shelf object-detection model, and human solving farms were defeating image puzzles long before that.

Challenges that price compute rather than perception hold up differently. A proof-of-work challenge or a JavaScript challenge charges each client CPU time, and a model does nothing to reduce that bill. They have their own costs, mostly to legitimate users on slow phones, but intelligence is not what they test.

Manual response assumes you change faster than the traffic does

The last assumption is about people. In most incidents, the defence that eventually works is a rule someone writes after looking at the logs: a new match on a header, a path, a country, a fingerprint.

That loop has a cycle time. An alert has to fire, someone has to be paged, read the traffic, write a rule, test it in count mode and deploy it. Fifteen minutes is fast. The attacker's loop is shorter: send, read the status codes and response times, produce the next variant. Automation shortened it years ago; models remove the last manual step, writing the variant itself.

Two loops, two clocks A rule written by hand matches the variant that was running when someone started reading the logs. Defender loop: minutes per cycle Alert fires On-call paged Logs read Rule written Checked in count mode Deployed, matches v1 By the time the top row finishes, the bottom row has gone round several times. Attacker loop: seconds to minutes per cycle Send variant v1, v2, v3 ... Read the response 403s, challenges, latency Generate the next variant no human step left in the loop repeat until something stops working for the defender BlackNeuron™
The iteration race in an AI-generated DDoS attack: the defender's loop runs from alert to page, log analysis, rule writing, count-mode check and deployment over minutes, while the attacker's loop runs from sending a variant to reading blocks, challenges and latency to generating the next variant in seconds to minutes, so a hand-written rule matches a variant that is no longer being sent

The arithmetic of a rule that arrives late

Take an illustrative model. The attacker rotates to a new request variant on a fixed timer, and each new variant runs unfiltered until a rule for it is deployed. If a hand-written rule takes 15 minutes from alert to deployment, a 60-minute rotation leaves a quarter of the hour unfiltered. A 15-minute rotation leaves all of it: the rule always lands just as the traffic it matches is retired.

An attacker who changes on every block, rather than on a timer, does at least as well as the fastest rotation.

Automating the rule helps until the rotation gets shorter. A two-minute automated response against a 15-minute rotation leaves about 13% of the hour exposed; against a one-minute rotation, the whole hour again.

2026-11-12T07:03:31.530917 image/svg+xml Matplotlib v3.5.1, https://matplotlib.org/ 0 20 40 60 80 100 % of hour Hand rule 15 min, rotate 60 min Hand rule 15 min, rotate 15 min Auto rule 2 min, rotate 15 min Auto rule 2 min, rotate 1 min 25 % of hour 100 % of hour 13 % of hour 100 % of hour Defences keyed to the variant, by rule lag and rotation Source: Model: exposure = rule lag / rotation, capped at 100% Attack hour left unfiltered BlackNeuron™
Share of an attack hour that reaches the origin unfiltered when each defence matches a specific request variant, a model: 25% for a 15-minute hand-written rule against a 60-minute variant rotation, 100% for the same rule against a 15-minute rotation, 13% for a 2-minute automated rule against a 15-minute rotation, and 100% for that automated rule against a 1-minute rotation

The numbers are assumptions; the shape is not. Any defence keyed to the variant loses once the attacker can vary faster than the defence can match. The defences that hold are the ones that do not care which variant arrives.

What a test now has to prove

That controls hold against variants they have not seen

A DDoS test that sends one request profile and records a block proves the rule matches that profile. Against an attacker who can produce new profiles at will, that is close to the least useful result available.

The question to ask instead is what happens to variant two, ten and forty. If each new variant gets through until someone writes a rule for it, the control is a signature in practice, whatever the product calls it.

What a test should ask: what about variant four? One profile and one block proves a match. A run of new variants shows what the control is keyed to. Variant 1 the first profile Variant 2 new header set Variant 3 new path, slower Variant 4 real browser Rule keyed to the variant match on variant 1's headers, user agent or path blocked passes passes passes Control keyed to the effect cost per session, request outcome, compute challenge held held held held A run that stops after variant 1 records the same result for both rows. BlackNeuron™
AI-generated DDoS attack variants against two kinds of control: a rule keyed to the first variant's headers blocks variant one and lets variants two, three and four through, while a control keyed to per-session cost, request outcome or compute challenge holds against all four because it does not depend on what the request looks like

That limits are set on cost, not count

Per-client request counts lose to low-rate traffic aimed at expensive paths. A test should show whether the stack limits what each client costs: concurrent expensive queries per session, origin CPU per route, queue depth on the slow endpoints. A flood that stays inside the request limit and still saturates the database is a finding about where the limit was set, not about the attacker's cleverness.

How long the defender's loop takes

Time-to-mitigate is usually measured once, at the start of an attack. Against traffic that changes, the figure that matters is how long it takes to respond to each change, both the automated controls and the people. Measure it per change. If the third adjustment takes as long as the first, the runbook has not shortened anything.

Who got turned away

Every assumption in the table can be restored by tightening: stricter challenges, lower thresholds, narrower baselines. Each tightening also catches customers. A test against human-like traffic is only meaningful if it counts the false positives alongside the blocks, because an attack that pushes you into turning away your own users has done its job.

What does not need to change

Authorisation, ceilings, stop conditions and vector selection are the same whoever, or whatever, wrote the attack. The complete guide to DDoS testing covers that ground.

The difference is in the attacker the test stands in for. A scripted run that keeps one plan whatever the defences do cannot show any of the four results above. A test that changes as the defences respond can, which is the case for AI-driven DDoS testing and the subject of adaptive DDoS testing, defined.

FAQ

Are AI-generated DDoS attacks real?

Attackers using AI for parts of their work is documented: Microsoft and OpenAI in 2024 and Google's Threat Intelligence Group in 2025 reported threat actors using models for reconnaissance, scripting and content. Public reports describe faster and cheaper versions of existing techniques rather than a new class of flood.

Can AI make a DDoS attack bigger?

Not in bandwidth or packet rate. Those come from the botnets, proxies, reflectors and servers an attacker controls or rents. AI makes an attack better aimed and more varied, which can make a smaller flood more damaging at the application layer.

Does a WAF still help against AI-generated traffic?

Yes, but rules keyed to a specific request pattern lose value when patterns are cheap to change. Rules and limits keyed to cost per client, request outcomes, or a compute challenge keep working regardless of what each request looks like. Testing tells you which kind you actually have.

Do CAPTCHAs stop AI-driven bots?

Image and puzzle challenges are increasingly solvable by vision models, as academic work on reCAPTCHA v2 showed in 2024. Challenges that charge each client compute time, such as proof-of-work, are unaffected by how intelligent the client is, though they carry their own cost for real users on slow devices.

Variety used to be the expensive part

For most of DDoS history, the scarce resource on the attacker's side was bandwidth, and on the defender's side it was the time it took to tell the attacker from the customer. Signatures, thresholds and challenges all worked by making the attacker pay for variety.

That payment is what models have cut. Bandwidth is no cheaper than it was; a new request shape, a new path through the site and a new answer to a puzzle all are.

So the defences worth having are the ones that never priced variety in the first place: limits on what a client costs, signals drawn from what traffic does rather than how it looks, and a response loop measured in seconds. The rest keep working until the attacker sends something new, which is now the cheapest thing it can do.