An ACK flood attack is a Layer 4 DDoS attack that sends huge volumes of TCP packets with only the ACK flag set, so the target has to inspect and reject packets that belong to no real connection. The goal is resource exhaustion: CPU on the server, memory in firewall state tables, and bandwidth on the uplink. Because ACK packets look like ordinary traffic from an established session, they slip past filters tuned for SYN floods. Below: how a TCP ACK flood works, its variants, real Mirai-era attacks, early warning metrics, and the ACK flood mitigation steps that keep services online. One Linux default, in particular, makes many servers easier to knock over than their owners think.

Key Takeaways

  • An ACK flood sends TCP packets with the ACK flag set but no matching connection, forcing servers and stateful devices to spend resources rejecting them.
  • SYN cookies do not stop ACK floods, because the attack skips the handshake that SYN defenses protect.
  • The Mirai botnet issued 2,173 ACK flood commands and 830 ACK-STOMP commands between September 2016 and February 2017, according to a USENIX Security 2017 study.
  • On Linux, connection tracking picks up mid-stream connections by default, so spoofed ACKs can fill the conntrack table instead of being dropped.
  • Early warning signs include a sharp rise in ACK packets with no preceding SYN, a jump in outgoing RST packets, and climbing conntrack counts.
  • Effective ACK flood protection combines upstream scrubbing, strict state validation, and per-source rate limits rather than relying on any single control.

How an ACK Flood Attack Works, Packet by Packet

An ACK flood works by sending acknowledgment packets that claim to belong to TCP sessions that were never opened. Every receiving device has to look each packet up, decide it is invalid, and then drop it or answer it, and that work multiplied by millions of packets per second is the attack.

The Normal Job of an ACK Packet in TCP

TCP, defined in its current form by RFC 9293 (published August 2022), opens a connection with a three-way handshake: SYN, SYN-ACK, ACK. After that, nearly every segment in both directions carries the ACK flag to confirm received data, which is exactly why attackers like it. A firewall cannot block “packets with the ACK flag” without blocking the whole internet.

Why Stray ACK Packets Still Cost Resources

When a host receives an ACK for a connection it does not know, RFC 9293 tells it to answer with a reset: the reset takes its sequence number from the ACK field of the incoming segment. So each fake ACK can trigger an outgoing RST, which doubles the packet load on the uplink. Stateful firewalls, load balancers, and NAT gateways are hit even harder, since each packet requires a lookup in a session table that has a fixed size.

Think of a hotel front desk where thousands of strangers walk up holding key cards for rooms nobody booked. Each card has to be checked against the guest register before the clerk can say no, and the real guests wait in the same line.

Normal TCP handshake compared with an ACK flood attack that fills a firewall state table

The attackers’ tooling is not exotic. The leaked Mirai source code (attack_tcp.c) builds its ACK flood with a 512-byte random payload, and it randomizes the source port, destination port, sequence number, and acknowledgment number on every packet by default. That randomization is what defeats simple signature filters, which brings up the obvious question: why don’t the SYN flood defenses most servers already run catch this?

Why ACK Floods Slip Past Defenses Built for SYN Floods

ACK floods bypass SYN flood protection because they never touch the handshake that SYN defenses guard. SYN cookies, SYN backlog tuning, and half-open connection limits all act on SYN packets, and an ACK flood sends none.

If your team has already hardened servers against the SYN flood attack, you have solved a different problem. Linux enables tcp_syncookies by default (value 1), and the kernel documentation describes it as a mechanism that sends syncookies “when the syn backlog queue of a socket overflows.” A spoofed ACK never enters that queue. If anything, a host that uses SYN cookies has to do extra work on ACKs, because it must check whether each incoming ACK carries a valid cookie before rejecting it.

The second gap sits in stateful inspection. The Linux kernel documentation for nf_conntrack_tcp_loose says: “If it is set to zero, we disable picking up already established connections.” The default is enabled. In plain terms, a stock Linux firewall will try to adopt a mid-stream ACK as an existing connection rather than drop it, and every adopted packet consumes an entry in a table capped by nf_conntrack_max. When that table fills, the kernel logs “nf_conntrack: table full, dropping packet” and starts refusing new connections from real users.

What Most People Miss
The firewall you deployed to protect a server can become the first thing an ACK flood takes down. Connection tracking tables, not CPU or bandwidth, are often the resource that runs out first on Linux gateways and cloud NAT devices.

You might be thinking that a cloud provider’s network firewall solves this for you. Yes, but most cloud security groups are stateful too, and they track flows per instance with published limits. The attack simply moves from your kernel to your provider’s flow table. The real defense has to drop invalid ACKs before they reach any stateful device, which is where the attack variants start to matter.

TCP ACK Flood Variants You Should Know

ACK-based attacks come in several forms, and they range from raw packet floods to precise abuse of TCP’s own acknowledgment logic. Knowing which one you face changes the right mitigation.

Variant What the attacker sends What it exhausts Best first defense
Plain ACK flood Spoofed ACK packets with random ports and sequence numbers Bandwidth, CPU, firewall state tables Upstream scrubbing, drop ACKs with no session
ACK-PSH flood ACK packets with the PSH flag and junk payload Bandwidth and application socket buffers Per-source rate limits, payload size filters
ACK-STOMP (Mirai) Real handshake first, then floods ACK+PSH packets with valid sequence numbers Mitigation systems that trust established sessions Behavioral rate limits per connection
Optimistic ACK Acknowledgments for data not yet received Sender bandwidth, by inflating its congestion window Kernel-level ACK validation
ACK storm Injected packets that make two hosts ACK each other endlessly Bandwidth between the victims Sequence validation, RFC 5961 checks

ACK-STOMP, the Variant That Looks Legitimate

ACK-STOMP is the clever one. According to the Mirai source code, the bot opens a normal TCP connection, reads the sequence and acknowledgment numbers from the server’s SYN-ACK on a raw socket, and then sends ACK+PSH packets with a 768-byte random payload using those real numbers. To a stateful filter, those packets belong to a valid session. That is why filters that only check “does this ACK match a known connection?” are not enough on their own.

Optimistic ACK and ACK Storms

Two lesser-known ACK packet attacks come from academic research. In 1999, Stefan Savage and colleagues at the University of Washington showed in “TCP Congestion Control with a Misbehaving Receiver” that a receiver could acknowledge data before it arrived and push a sender to transmit faster than the network allows. In 2011, Raz Abramov and Amir Herzberg presented “TCP Ack Storm DoS Attacks” at IFIP SEC, showing how a few injected packets can make two endpoints exchange ACKs in a loop that eats bandwidth on both sides.

ACK Flood vs SYN Flood vs UDP Flood

Attack OSI layer Uses handshake? Main target Stopped by SYN cookies?
ACK flood Layer 4 No, skips it State tables, CPU, RST generation No
SYN flood Layer 4 Abuses its first step Half-open connection backlog Yes, largely
UDP flood Layer 4 No, connectionless Bandwidth and ICMP replies No

All three belong to the family of protocol DDoS attacks, and attackers often run them together. The Mirai data in the next section shows how often.

Real ACK Flood DDoS Attacks and What They Taught Defenders

The best public record of ACK floods in the wild comes from the Mirai botnet, which researchers tracked command by command. The data shows ACK floods were a standard weapon, not a niche technique.

In “Understanding the Mirai Botnet,” presented at USENIX Security 2017, Antonakakis and colleagues recorded 15,194 attack commands issued between September 27, 2016 and February 28, 2017. ACK floods accounted for 2,173 of them, about 14.3%, and ACK-STOMP added another 830. Combined, ACK-based attacks were more common than SYN floods (1,935 commands).

Mirai attack type Commands observed Share of 15,194
HTTP flood 2,736 18.0%
UDP-PLAIN flood 2,542 16.7%
UDP flood 2,440 16.1%
ACK flood 2,173 14.3%
SYN flood 1,935 12.7%
ACK-STOMP flood 830 5.5%

“The Mirai botnet, composed primarily of embedded and IoT devices, took the Internet by storm in late 2016 when it overwhelmed several high-profile targets with massive distributed denial-of-service (DDoS) attacks.”

Manos Antonakakis et al., “Understanding the Mirai Botnet,” USENIX Security Symposium 2017

The same study traced the October 21, 2016 attack on the DNS provider Dyn to Mirai, with 70.8% of the 107,464 attacking IPs Dyn reported overlapping Mirai scanners. The researchers saw 23 attack commands against Dyn infrastructure, mostly short SYN floods on DNS port 53, mixed with “a few ACK and GRE IP attacks.” The lesson is that ACK floods rarely arrive alone, and they often ride alongside a botnet DDoS attack that uses several vectors at once.

A second lesson came from the defense side. On June 17, 2019, Jonathan Looney of Netflix disclosed the TCP SACK PANIC flaws (CVE-2019-11477, CVE-2019-11478, and CVE-2019-11479). Crafted selective acknowledgments could crash Linux kernels or burn CPU, and Red Hat rated CVE-2019-11477 as Important. Acknowledgment handling, in other words, is attack surface in its own right. How do you tell when it is under pressure?

How to Detect an ACK Packet Attack Early

You detect an ACK flood by watching the ratio between ACK packets and the connections that should produce them. Legitimate ACKs follow SYNs. Flood ACKs do not.

Volume alone misleads, because a product launch or a large download also raises ACK counts. The useful signals are relationships between counters, and most of them are available on any Linux host without extra tools. CISA, the FBI, and MS-ISAC recommend in their joint guide, Understanding and Responding to Distributed Denial-of-Service Attacks, that organizations know their normal traffic baseline before an incident, and this is where that baseline pays off.

  • A rise in inbound ACK packets with no matching rise in SYN packets or new sessions.
  • A spike in outgoing RST packets, visible in the TcpOutRsts counter from nstat -az.
  • A climbing conntrack count (sysctl net.netfilter.nf_conntrack_count) approaching nf_conntrack_max.
  • “table full, dropping packet” messages in the kernel log.
  • ACK packets spread across random destination ports, including ports where nothing listens.
  • Many source IPs sending small, fixed-size payloads, such as Mirai’s 512-byte default.

A quick way to sample pure ACK traffic during an incident:

tcpdump -nn -c 2000 ‘tcp[tcpflags] & (tcp-syn|tcp-fin|tcp-rst) == 0 and tcp[tcpflags] & tcp-ack != 0’

Graph inbound ACK packets per second against new TCP sessions per second on the same dashboard. During normal traffic, the two lines move together. During an ACK flood, the ACK line climbs while new sessions stay flat or fall, and that gap shows up minutes before users start reporting timeouts.

Telltale Metrics That Separate an Attack From a Traffic Spike

A real traffic spike raises SYNs, ACKs, and application requests together, and response codes stay healthy. An ACK flood raises ACKs and RSTs while HTTP requests per second stay flat. If you already track the broader signs of a DDoS attack, add the ACK-to-SYN ratio and outgoing RST rate to that list. Once you can see the flood, the next job is to stop it before it reaches anything stateful.

ACK Flood Mitigation Techniques That Hold Up Under Load

Effective ACK flood mitigation drops invalid ACK packets as far upstream as possible, before they reach a stateful device with a finite table. Server tuning helps, but it cannot fix a saturated uplink.

MITRE ATT&CK technique T1498.001 (Direct Network Flood) makes the same point, noting that it is “typically necessary to intercept the incoming traffic upstream” when flood volume exceeds link capacity. A layered approach looks like this:

  1. Absorb volume at the edge. An Anycast network spreads attack traffic across many points of presence, so no single site carries the full flood.
  2. Validate state before forwarding. Scrubbing systems drop ACKs that match no tracked session and challenge suspicious ones, so only valid traffic reaches the origin.
  3. Rate limit per source and per connection. This catches ACK-STOMP, which passes state checks but sends far more packets per session than real clients. Network-level rate limiting belongs here.
  4. Harden every host and gateway. Drop invalid conntrack states, turn off loose pickup where your architecture allows it, and keep RST and challenge ACK rate limits on.
  5. Keep upstream options ready. BGP Flowspec rules can filter specific ACK patterns at the provider edge during a large attack.

Layered ACK flood mitigation: edge scrubbing, state validation and rate limits in front of the origin

The IETF built part of this logic into TCP itself. RFC 5961 (2010) narrows the range of acceptable ACK values and requires that segments failing the check “MUST be discarded and an ACK sent back.” It then limits those responses.

“An implementation SHOULD include an ACK throttling mechanism to be conservative.”

RFC 5961, “Improving TCP’s Robustness to Blind In-Window Attacks,” Internet Engineering Task Force (IETF)

Server-Level Hardening on Linux

These settings come from the Linux kernel documentation for ip-sysctl and nf_conntrack. Test them in staging first, because some change how the firewall treats existing sessions.

Setting Default What it does during an ACK flood
net.netfilter.nf_conntrack_tcp_loose Enabled Set to 0 so ACKs without a known session are marked INVALID instead of tracked
net.netfilter.nf_conntrack_max Equals nf_conntrack_buckets Raise it, with memory in mind, so the table does not fill first
net.ipv4.tcp_invalid_ratelimit 500 ms Limits duplicate ACKs sent in reply to invalid segments
net.ipv4.tcp_challenge_ack_limit INT_MAX (unlimited) Caps challenge ACKs per second, as recommended in RFC 5961

Pair the sysctl change with a rule that drops invalid packets early:

sysctl -w net.netfilter.nf_conntrack_tcp_loose=0 iptables -A INPUT -p tcp -m conntrack –ctstate INVALID -j DROP

Common ACK Flood Protection Mistakes

Rate limits have their own history of backfiring. Linux once enforced RFC 5961 with a single global limit of 100 challenge ACKs per second. In 2016, researchers at the University of California, Riverside showed at USENIX Security that this shared counter let an off-path attacker infer TCP sequence numbers (CVE-2016-5696). The kernel switched to randomized and per-socket limits, which is why the current default reads INT_MAX. A global counter that every connection shares can leak information or turn into a choke point.

Other mistakes show up repeatedly in incident reviews:

  • Turning off loose pickup on a firewall pair without a state sync, which drops every live session after a failover.
  • Blocking all ACKs to a port during an attack, which also cuts every legitimate user on that port.
  • Treating blackhole routing as mitigation. Null-routing the target IP stops the flood and the service together, which completes the attacker’s goal.
  • Sizing conntrack for normal peaks only, so the table hits its ceiling within seconds of the first flood.

The common thread runs against intuition. Adding more state tracking does not make a network safer against ACK floods; the setups that hold up are the ones that refuse to create state for traffic they cannot verify. That principle shapes how you choose a protection service.

Choosing ACK Flood Protection for Your Infrastructure

The right ACK flood protection depends on where your bottleneck sits: your uplink, your firewall tables, or your servers. If the flood can exceed your link capacity, only an upstream service can stop it.

Option Handles floods larger than your link? Keeps the service online? Best fit
On-premises firewall tuning No Yes, for small floods Single servers, labs, internal apps
ISP blackholing Yes No, the target goes offline Last resort to protect the rest of the network
On-demand cloud scrubbing Yes Yes, after traffic is rerouted Organizations with low attack frequency
Always-on edge protection Yes Yes, with no switchover delay Public-facing services, gaming, fintech, APIs

Always-on protection matters for ACK floods in particular because many Mirai attacks were short. The Dyn study recorded 25-second SYN floods, and on-demand rerouting can take longer than that to begin. For TCP services that are not plain HTTP, such as game servers, mail, or custom APIs, look for transport-layer coverage. VergeCloud’s L4 Shield covers TCP and UDP floods with packet inspection and per-source rate control, and it works alongside the wider DDoS protection stack for Layer 7 traffic. For a broader comparison of approaches, see these DDoS mitigation techniques.

Final Thought on ACK Flood Attacks

An ACK flood works because it imitates the most common packet on the internet and forces every stateful device to prove a negative, millions of times per second. The defense that holds up is the one that refuses to spend resources on packets it cannot verify, as early in the path as possible.

In practice, that means baselining your ACK-to-SYN ratio now, closing the loose-pickup gap on Linux gateways, and keeping volumetric filtering upstream of anything with a state table. None of these steps is expensive, and each one removes a resource the attacker was counting on.

Common Questions About ACK Flood Attacks

Is an ACK Flood a Layer 3 or Layer 4 Attack?

It is a Layer 4 (transport layer) attack because it abuses TCP flags and connection state. It still consumes Layer 3 bandwidth, so large floods also behave like volumetric attacks.

Can an ACK Flood Be Launched Without a Botnet?

Yes. A single host with enough bandwidth can send spoofed ACK packets, which makes it a DoS attack. Botnets such as Mirai make it a DDoS attack, with thousands of sources that are much harder to filter by IP address.

Does HTTPS or TLS Protect a Website From ACK Floods?

No. TLS runs on top of TCP and only starts after the handshake completes. An ACK flood targets the TCP layer below it, so encrypted sites are just as exposed as plain HTTP sites.

Will a CDN Alone Stop an ACK Flood on Non-Web Ports?

A CDN that proxies HTTP and HTTPS absorbs ACK floods aimed at ports 80 and 443 on its edge. Floods aimed at your origin IP or at other TCP ports, such as SSH or game servers, need separate Layer 4 protection.