Back to Blog
DDoSDDoS SimulationDDoS TestingWAFRate Limiting

DDoS Simulation: Fidelity, Limits and What a Simulated Attack Proves

BlackNeuron Research Team
November 15, 2026
13 min read
DDoS Simulation: Fidelity, Limits and What a Simulated Attack Proves

A DDoS simulation is a claim of resemblance.

It says: this traffic is enough like a real attack that the way your defences treated it is the way they would treat the real thing. Some of that claim is always true and some of it is always false, by design. The result is only worth what the reader knows about which parts are which.

Most simulation reports skip that part. They state the vectors, the peak rate and the verdict, and leave the resemblance unexamined. This post is about the resemblance: which properties of simulated traffic decide what a control does, which properties a simulation never reproduces on purpose, and what a result can honestly claim as a consequence.

What a DDoS simulation is

A DDoS simulation sends attack-shaped traffic, from sources the tester controls and with written authorisation, along the same path a real attack would take, to observe how the protection and the service behave. It reproduces the traffic an attacker would send. It does not reproduce the attacker's means of sending it: no botnet of compromised machines, no forged source addresses, no abuse of other people's servers.

In practice "DDoS simulation" and "DDoS test" are used for the same activity. The difference is emphasis. "Simulation" is about the traffic and how faithfully it imitates an attack; "test" is about the verdict and what it proves. AWS and Azure both use the simulation wording in their published policies for this kind of traffic, and both require an approved testing partner, which the AWS DDoS testing and Azure DDoS testing posts cover.

The broader method (scoping, authorisation, escalation, reporting) sits in the complete guide to DDoS testing. What follows is narrower: the traffic itself.

Three different things go by the name

The word is stretched over three activities that exercise different things.

Called a simulationWhat movesWhat it exercisesWhat it cannot see
Tabletop exerciseno packets, only injects and decisionspeople, escalation, the runbookwhether any control works
Lab or range replaypackets, against a copy or a single deviceone appliance or rule set in isolationthe provider edge, real routing, real capacity
Live-path simulationpackets, along the production paththe whole chain, edge to originanything above the authorised ceiling

A DDoS tabletop exercise is the right tool for the decisions an attack forces. A lab replay is useful for qualifying a single appliance before it goes into the path. Only the third kind says anything about how the deployed stack behaves, and it is the kind the rest of this post means.

Three things called a DDoS simulation Only one of them sends traffic through the stack you actually run. Tabletop exercise moves no packets runbook + injects Exercises people, escalation, decisions Cannot see whether any control works Lab or range replay packets, against a copy generator one device Exercises one appliance or rule set, isolated Cannot see provider edge, real routing, real capacity Live-path simulation authorised packets, production path provider edge CDN WAF and rate limits load balancer origin Exercises the deployed chain, edge to origin Cannot see anything above the authorised ceiling BlackNeuron™
Three activities called a DDoS simulation compared: a tabletop exercise moves no packets and exercises people and decisions, a lab or range replay sends packets at one appliance or rule set in isolation, and a live-path simulation sends authorised attack-shaped traffic through the provider edge, CDN, WAF, load balancer and origin, which is the only kind that observes the deployed stack

Controls read properties, so fidelity is per control

There is no such thing as a realistic simulation in general.

Every DDoS control decides by reading some properties of the traffic and ignoring the rest. A per-IP rate limit reads the source address and the request count. A bot-management score reads the TLS client hello, the header order and whether the client runs JavaScript. A flow-spec rule reads ports, sizes and flags. Nothing else about the traffic matters to that control.

So a simulation is faithful to a control when it reproduces the properties that control reads, and it can be crude in every other respect without changing the result. The converse matters more. A simulation that gets one property wrong, the one the control keys on, produces a verdict about a different attack than the one it names.

The property map

Property of the trafficControls that read itWhen the simulation gets it wrong
Number of sources and their spreadper-IP rate limits, per-source connection caps, geo rulestoo few sources trips a limit a real botnet stays under
Network type of the sourcesIP reputation, bot scoringhosting-provider addresses get challenged for where they live, not what they send
Packet sizes, ports and flagsACLs, flow-spec rules, amplification filtersa filter keyed on a size or port range is never exercised
Ramp shape and durationanomaly detection baselines, detection windows, autoscalingan instant step and a slow climb meet different defences
Protocol fingerprintJA3/JA4 fingerprinting, HTTP/2 settings checksa scripting library's handshake is caught by a rule a real browser passes
Session behaviourJavaScript challenges, cookie checksa client that never executes script fails every challenge on cue
Request mix and costCDN cache, origin capacitycached paths look absorbed; uncached ones were never asked

Read down the right-hand column and a pattern shows. Almost every error makes the defence look better than it is. Too few sources, a crude fingerprint, a client that cannot run script: each one hands the control an easy case.

Fidelity is per control Each control reads a few properties of the traffic. Get those right and the rest can be approximate. PROPERTY OF THE SIMULATED TRAFFIC CONTROLS THAT READ IT Number of sources and their spread per-IP rate limits, per-source connection caps, geo rules Network type of the sources IP reputation feeds, bot scoring Packet sizes, ports and flags ACLs, flow-spec rules, amplification filters Ramp shape and duration anomaly baselines, detection windows, autoscaling Protocol fingerprint JA3/JA4 checks, HTTP/2 settings checks Session behaviour JavaScript challenges, cookie checks Request mix and cost per request CDN cache, origin capacity Most mistakes on the left hand the control on the right an easy case, so the verdict flatters. BlackNeuron™
DDoS simulation fidelity mapped to the controls that read it: source count and spread feed per-IP rate limits and geo rules, source network type feeds IP reputation and bot scoring, packet sizes, ports and flags feed ACLs and flow-spec rules, ramp shape feeds anomaly baselines and autoscaling, protocol fingerprint feeds JA3/JA4 checks, session behaviour feeds JavaScript challenges, and request mix feeds the CDN cache and origin

How sharp the source-count edge is

The complete guide makes the general case that source distribution is load-bearing. The arithmetic shows how abruptly it flips a verdict.

Take a simulated HTTP flood of 10,000 requests a second against a per-IP limit of 100 requests a minute. That is 600,000 requests a minute in total, divided across however many sources the simulation uses.

From 2,000 sources, each sends 300 a minute and the limit fires on every one of them. From 5,000 sources, each sends 120 and the limit still fires. From 10,000 sources, each sends 60, and the same rule never triggers at all. From 50,000, each sends 12.

2026-11-15T07:04:47.482659 image/svg+xml Matplotlib v3.5.1, https://matplotlib.org/ 0 50 100 150 200 250 300 350 requests per minute from each source 2,000 sources 5,000 sources 10,000 sources 50,000 sources 300 req/min per source 120 req/min per source 60 req/min per source 12 req/min per source per-IP limit, 100/min 10,000 req/s split across N sources vs a 100/min per-IP limit Source: this post: 600,000 req/min divided by source count. Model, not a measurement. Same flood, same rule, opposite verdicts BlackNeuron™
Requests per minute from each source in a simulated 10,000 requests-per-second HTTP flood, a model: 300 from 2,000 sources and 120 from 5,000 sources, both above a 100 requests-per-minute per-IP limit, against 60 from 10,000 sources and 12 from 50,000 sources, both below it

Same total rate, same rule, opposite verdicts. A simulation from 5,000 addresses reports "rate limit held". A botnet of 10,000 meets a rate limit that does nothing. The report from the first run is accurate about the first run and silent about the second, and nothing in a typical results table tells the reader that.

The network type of the sources

Simulation traffic usually comes from cloud and hosting providers, because that is where large numbers of addresses can be rented and controlled. Real floods come from many places: compromised home routers and cameras, residential proxy networks, hosting ranges.

Reputation feeds and bot scores treat those differently. Hosting addresses tend to score as automated before a single request is read; residential addresses tend not to. A simulation from hosting ranges can therefore be challenged or blocked on origin alone, and the report credits the WAF with a catch that a residential proxy flood would not suffer.

The check is cheap. Look at what rule actually acted on the simulated traffic. If it was a reputation or hosting-ASN rule, the result says the simulation's sources were recognisable, not that the flood was stopped.

The ramp

A simulation that climbs to full rate in one step and one that climbs over twenty minutes meet different defences. A sudden step is what threshold alarms and fast detection are built for. A slow climb can sit inside what an adaptive baseline accepts as growth, and it gives autoscaling time to add capacity that an abrupt attack would not.

Neither is the right shape. They answer different questions, and the attack you are preparing for decides which one to send. Most network-layer floods in providers' quarterly threat reports end within minutes, which argues for including short bursts, not only long plateaus: a burst shorter than the detection window is the case a pulse wave attack is built on.

What a simulation never reproduces, on purpose

Some differences from a real attack are not shortcomings to fix. They are the line between a simulation and an attack, and they are fixed by design. A result is honest only when the report names them.

Forged source addresses

Attackers spoof source addresses when the network lets them. A simulation never does. Every packet comes from an address the tester actually holds and can be identified, stopped and accounted for.

That has a consequence for one family of defences. A scrubbing edge often verifies a source by making it prove it can receive: a TCP authentication challenge, or a DNS answer with the truncation bit set so the resolver must retry over TCP. Against a spoofed flood, that check discards almost everything without any other work, because the forged sender never sees the challenge.

A simulated source does see it, because it is real. Whether it answers depends on the generator: a full network stack replies, a raw packet sender does not. Either way the run measures something other than forged traffic, either sources that pass verification and must be stopped by something else, or sources that fail it for a reason the attacker does not share. The report should say which, and should not imply it measured the spoofed case. (A SYN cookie is the exception that behaves the same for both, since neither a forged sender nor a typical SYN flood generator completes the handshake.)

Other people's servers

A real reflection attack bounces requests off third-party servers (open resolvers, NTP servers, memcached instances) that answer the victim with much larger responses. A simulation never touches a third party.

What it reproduces instead is what arrives at the target: UDP datagrams with the ports and size distribution the reflected protocol produces, sent from the test's own addresses. That exercises the filters that key on those properties.

Two things stay different. A real reflection flood arrives from tens of thousands of distinct reflector addresses spread across many networks, which a simulation does not match. And it enters through many upstream links at once, so its effect on transit and peering capacity is not something a simulation demonstrates.

Volume above the authorised ceiling

Every simulation has a ceiling, written into the authorisation, and it sits far below the largest floods providers have reported, which are measured in terabits per second. A simulation therefore never proves your provider's total scrubbing capacity. That figure is the provider's claim to stand behind.

What a simulation proves is narrower and more useful: that your configuration, your diversion path and your origin behave correctly up to the line. Most failures in a DDoS stack are configuration failures that show up well below any provider's capacity limit, which is why a modest ceiling still finds them.

The attacker's reaction

A scripted simulation keeps its plan whatever the defences do. A real attacker watches the results and changes approach. That is the gap adaptive DDoS testing exists to close, and a static run should report it as a stated limit rather than leave it implied.

Artefacts that flip the verdict

Beyond the deliberate limits, a simulation can produce results that come from the simulation itself. They run in both directions.

Count at three points, or a generator problem reads as a defence Per vector, per minute: sent, arrived at the edge, reached the origin. 1 sent 2 arrived 3 reached Generators the test's own sources Edge provider or CDN Pre-filter allowlist, reputation Under test rate limit, WAF rule Origin what got through Alarming artefact generator CPU, NIC or cloud egress allowance caps the rate here Flattering artefact trusted generators skip the control, or a hosting-range rule drops them first 1 minus 2 the network, the provider, or the generators themselves 2 minus 3 your controls, and the pre-filter row says which one acted BlackNeuron™
Where a DDoS simulation can fool itself, measured at three points: what the generators sent, what arrived at the edge and what reached the origin; a generator or cloud egress limit can cap the sent rate, an allowlist or reputation rule can drop traffic before the control under test, and only the difference between the three counts shows which control actually acted

Results that flatter

  • Trusted generators. Generators added to an allowlist so a capacity test would not be rate limited, and never removed. The traffic then bypasses the very controls the simulation was meant to check.
  • A rule that acted for the wrong reason. A reputation, geo or hosting-range rule caught the simulation's sources before the control under test saw a packet.
  • Cached targets. Every request hit a path the CDN serves from cache, so the origin's limits were never reached. Which paths are expensive is the subject of API DDoS testing and CDN cache absorption.
  • A run shorter than the detection window. The rate was held for less time than the control needs to act, so "nothing happened" means nothing was decided yet.

Results that alarm

  • The generator was the bottleneck. The sending side ran out of CPU, NIC capacity or its cloud provider's outbound allowance, so the attack rate flattened at a level the target never chose. If the sent-rate curve and the received-rate curve plateau together, look at the generators first.
  • The simulation tripped someone else's alarm. A generator's own hosting provider can throttle traffic it reads as abuse, which looks like mitigation on the target side when it is nothing of the kind.
  • Unsynchronised clocks. Time to mitigate is read by comparing generator logs with target logs. A clock skew of a few seconds between the two can make a fast control look slow, or the reverse.

The defence against both: count at three points

Record what the generators sent, what arrived at the edge and what reached the origin, per vector and per minute. The differences between those three counts are where the verdict lives. A drop between sent and arrived is the network or the provider. A drop between the edge and the origin is your controls. Without the first count, a generator problem reads as a defence.

Calibrating a simulation to an attack worth simulating

Start from the attack, not from the tool

The common path runs backwards: the tool supports these vectors at these rates, so those are run. The faithful path starts with the attack you are preparing for (the classes your sector sees, the size your provider contract assumes, the route an attacker would take round your edge) and works out what traffic properties that implies.

The tool question comes after, and DDoS testing tools covers what each class can and cannot reproduce.

Decide which properties must match

From the property map, mark the properties the controls in scope actually read. Those must match the attack. Everything else can be approximate, which is usually what keeps a simulation affordable.

A test of origin capacity behind a CDN needs the right request mix and cache-miss rate; its packet sizes barely matter. A test of a flow-spec rule needs the right ports and sizes; its request paths do not matter at all.

Write the fidelity statement

The most useful page in a simulation report is the one most reports leave out: a table, per vector, of what was reproduced, what was approximated and what was deliberately absent.

VectorReproducedApproximatedAbsent by design
HTTP flood on searchrequest mix, cache-miss rate, rampsource count (5,000 vs an expected 20,000)residential sources
UDP reflection, DNSport 53 source, response size distributionsource countthird-party reflectors, multi-link entry
SYN floodrate, rampsource spreadforged sources

The example rows are illustrative. The discipline is the point: every verdict in the report is read against its row, and the row says how far the verdict extends.

FAQ

What is the difference between a DDoS simulation and a DDoS test?

They usually describe the same activity. "Simulation" stresses the traffic and how faithfully it imitates a real attack; "test" stresses the verdict. A live DDoS simulation sends authorised attack-shaped traffic along the production path and observes how the protection responds.

Does a DDoS simulation use a botnet or spoofed traffic?

No. A simulation sends traffic from sources the tester controls and can stop, using addresses it actually holds. Botnets and forged source addresses are attacker behaviour. The report should state which defences that difference affects, such as scrubbing-edge challenges that check a source can receive.

How large should a DDoS simulation be?

Large enough to reach the properties your controls read and the limits your scope names, which is set by the attack you are preparing for and by the ceiling in the authorisation. It will not match the largest floods on record and does not need to: it is testing your configuration and path, not your provider's total capacity.

Can a DDoS simulation run against production?

Yes, with caps, a kill switch and agreed stop conditions, and only a production-path simulation observes the deployed stack. How to bound it is covered in DDoS testing without disrupting production.

A verdict has a scope

"The rate limit held" is not a fact about the rate limit. It is a fact about the rate limit and 5,000 sources, at that ramp, with that fingerprint, from those networks. Change the property the control reads and the sentence can stop being true.

The simulations that mislead are rarely badly run. They are well run and under-described: the traffic was what it was, and the report let the reader assume it was something else.

Resemblance is a list, not an adjective. Write the list, and the verdict means exactly what it says.