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 simulation | What moves | What it exercises | What it cannot see |
|---|---|---|---|
| Tabletop exercise | no packets, only injects and decisions | people, escalation, the runbook | whether any control works |
| Lab or range replay | packets, against a copy or a single device | one appliance or rule set in isolation | the provider edge, real routing, real capacity |
| Live-path simulation | packets, along the production path | the whole chain, edge to origin | anything 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.
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 traffic | Controls that read it | When the simulation gets it wrong |
|---|---|---|
| Number of sources and their spread | per-IP rate limits, per-source connection caps, geo rules | too few sources trips a limit a real botnet stays under |
| Network type of the sources | IP reputation, bot scoring | hosting-provider addresses get challenged for where they live, not what they send |
| Packet sizes, ports and flags | ACLs, flow-spec rules, amplification filters | a filter keyed on a size or port range is never exercised |
| Ramp shape and duration | anomaly detection baselines, detection windows, autoscaling | an instant step and a slow climb meet different defences |
| Protocol fingerprint | JA3/JA4 fingerprinting, HTTP/2 settings checks | a scripting library's handshake is caught by a rule a real browser passes |
| Session behaviour | JavaScript challenges, cookie checks | a client that never executes script fails every challenge on cue |
| Request mix and cost | CDN cache, origin capacity | cached 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.
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.
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.
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.
| Vector | Reproduced | Approximated | Absent by design |
|---|---|---|---|
| HTTP flood on search | request mix, cache-miss rate, ramp | source count (5,000 vs an expected 20,000) | residential sources |
| UDP reflection, DNS | port 53 source, response size distribution | source count | third-party reflectors, multi-link entry |
| SYN flood | rate, ramp | source spread | forged 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.
