Layer 7 stresser methods
The four Layer 7 methods share a common property: each one completes a real TCP handshake, so the traffic reaches the application stack rather than dying at the edge. The difference between them is what happens after the handshake. HTTP flood sends a full request and reads the response. TLS flood completes the handshake and closes before the request. HTTP/2 flood opens a multiplexed stream and sends multiple requests on one connection. Slowloris opens the connection and holds the headers open indefinitely.
HTTP flood
HTTP flood sends many concurrent GET or POST requests to the target. The target is the request handler, and the report shows requests per second climbing until the handler saturates, then error rate climbing with it. This is the most common method because it produces the clearest signal: a target that survives HTTP flood has real request-handling headroom, and a target that fails it has a concrete bottleneck in the handler, the WAF, or the rate limiter.
TLS flood
TLS flood opens and closes TLS handshakes without completing a request. The target is the certificate processing path and the handshake CPU. This method is useful against targets that terminate TLS at the edge and forward plain HTTP to the origin, because the edge is the first bottleneck and the TLS handshake is the most expensive operation it performs. The report signal is handshake completion rate: if that drops while CPU is saturated, the edge is the bottleneck.
HTTP/2 flood
HTTP/2 flood opens one TCP connection and multiplexes many streams on it. The target is the stream multiplexing logic and the proxy memory that tracks each stream. This method is useful against reverse proxies that support HTTP/2, because the proxy has to maintain per-stream state, and a flood of streams fills that state table faster than a flood of separate connections would. The report signal is stream reset rate: a spike means the proxy ran out of stream slots.
Slowloris
Slowloris opens many connections and sends headers slowly, one byte at a time, so the connection never completes the request. The target is the connection handling path: a server with a large connection pool and no header timeout holds every connection open until the pool fills. This method is ineffective against modern reverse proxies with header timeouts under 30 seconds, because they close the connection before the attack can hold it open. Test it against the origin, not the proxy.
Layer 4 stresser methods
The four Layer 4 methods do not complete an application-level transaction. Some of them complete a TCP handshake, some do not, and one does not use TCP at all. The difference between them is which kernel path or edge path they pressure. All four produce a report signal at the packet level rather than the request level, because the application never sees the traffic.
UDP flood
UDP flood fires datagrams with no handshake at an open UDP port. The target is raw packet processing: the NIC, the kernel's packet path, and the edge firewall's UDP rate limiter. This is the method for connectionless services like DNS, game servers and VoIP. The report signal is packet rate and drop rate: if the target's edge drops packets before the host sees them, the edge is the bottleneck, and if the host sees them but the application does not respond, the application is.
TCP SYN flood
TCP SYN flood sends SYN packets without completing the handshake, so the target's SYN backlog fills with half-open connections. The target is the SYN backlog and the connection tracking table. This is the method for connection-oriented services where you want to test the kernel's ability to handle connection setup under pressure. The report signal is half-open connection count: a rising count with a flat accepted-connection count means the backlog is full and the kernel is dropping new SYNs.
TCP ACK flood
TCP ACK flood sends ACK packets for connections that may or may not exist, so the target's connection tracking table fills with entries it cannot resolve. The target is the connection tracking table and the kernel's per-packet state lookup. This is the method for targets behind a stateful firewall, because the firewall has to track every ACK and consult the table on every packet. The report signal is tracked connection count: a rising count with a falling throughput means the table is full.
ICMP flood
ICMP flood sends echo requests at a high rate. The target is the ICMP rate limiter on the edge, not the application. Most production networks drop ICMP at the edge, so an ICMP flood usually produces no useful signal. Run it only if you are specifically testing the edge's ICMP handling, and expect the report to show near-total drop rate if the edge is configured correctly.
All eight methods, side by side
Read the table by target type, not by layer. The target type is what you own; the method follows. If you own a web app, the answer is HTTP flood even if you also want to test the firewall. If you own a game server, the answer is UDP flood even if you also want to test the login service. One target, one method, one run.
| Method | Layer | Target surface | Report signal | First choice for |
|---|---|---|---|---|
| HTTP flood | L7 | Request handler, WAF, rate limiter | Requests per second, error rate | Web applications |
| TLS flood | L7 | Certificate processing, handshake CPU | Handshake completion rate | TLS terminators |
| HTTP/2 flood | L7 | Stream multiplexing, proxy memory | Stream reset rate | HTTP/2 proxies |
| Slowloris | L7 | Connection pool, header timeout | Open connection count | Origin servers without timeouts |
| UDP flood | L4 | Packet processing, UDP rate limiter | Packet rate, drop rate | DNS, game servers, VoIP |
| TCP SYN flood | L4 | SYN backlog, connection tracking | Half-open connection count | Edge firewalls |
| TCP ACK flood | L4 | Connection tracking table | Tracked connection count | Stateful firewalls |
| ICMP flood | L4 | ICMP rate limiter on edge | ICMP drop rate | Edge testing only |
The "first choice for" column is the one to read first. It is not the only valid use of each method, but it is the target type where the method produces the clearest signal. Running HTTP flood against a TLS terminator produces a signal, but TLS flood produces a better one because the terminator's most expensive operation is the handshake, not the request. Running UDP flood against a web server produces a signal, but it is measuring the edge's UDP handling, not the web server, and the report will not tell you anything about the web app.
How to pick one and run it
Start with the target type. If you own a web application, start with HTTP flood. If you own a game server, start with UDP flood. If you own a stateful firewall and want to test its table capacity, start with TCP ACK flood. If you own a TLS terminator, start with TLS flood. The first method should match the most likely bottleneck on that target type, not the method you are most curious about.
Run one method per test. Two methods in one run produce a report that cannot be attributed to one layer, and the time series cannot tell you which method caused which failure. The daily quota on the free tier exists for exactly this reason: three runs per day is enough to test three methods against one target, and each run produces a clean, attributable report.
After the first method, read the report before choosing the second. If the first method found the bottleneck, the second method is a confirmation, not a discovery. If the first method found nothing, the second method should probe a different surface: HTTP flood found nothing on the application, so the next run should be TCP SYN flood on the same target to test the kernel. The second method is a different question, not a louder version of the same question.
Frequently asked questions
Which Layer 7 stresser method should I run first?
HTTP flood, unless the target terminates TLS at the edge and the origin is plain HTTP. HTTP flood is the most common method and the easiest to interpret: requests per second climbing, then error rate climbing with it, points at the request handler.
Which Layer 4 stresser method should I run first?
TCP SYN flood for a connection-oriented service, UDP flood for a connectionless one. SYN flood fills the SYN backlog and shows as connection timeouts; UDP flood stresses raw packet processing and shows as packet drop rate climbing.
What is the difference between a TLS flood and an HTTP flood?
A TLS flood opens and closes handshakes without completing a request, so it stresses certificate processing and handshake CPU. An HTTP flood completes the handshake and sends real requests, so it stresses the request handler, WAF and rate limiter. They target different parts of the same stack.
Is Slowloris still effective in 2026?
Yes, against servers that do not enforce per-connection header timeouts. It is ineffective against modern reverse proxies like nginx, Cloudflare and HAProxy with header timeouts under 30 seconds, because they close the connection before the attack can hold it open.
What does an ICMP flood measure?
It measures the ICMP rate limiter on the edge, not the application. Most production networks drop ICMP at the edge, so an ICMP flood usually produces no useful signal. Run it only if you are testing the edge itself.
Can I run two stresser methods in one test?
Run one method per test. Two methods in one run produce a report that cannot be attributed to one layer, and the time series cannot tell you which method caused which failure. One method, read the report, then run the next method on a separate run.
How this page was researched
This page was written from the HTTP/2 stream multiplexing documentation (RFC 9113), the TCP SYN backlog and connection tracking behavior (RFC 9293), and the OWASP Testing Guide's application-layer stress methodology. The method table was cross-checked against the Cloudflare Learning Center's L3/L4/L7 explanations and the CISA network defense guidance. The "first choice for" column reflects the method that produces the clearest signal for each target type, not the method that produces the highest peak number.
Last reviewed: 16.11.2026, 01:00 (America/New_York).