Nmap Scan Types Explained: ACK, FIN, NULL, Xmas, Window, Maimon

ACK, FIN, NULL, Xmas, Window, and Maimon: what each Nmap TCP scan type detects, which flags it sets, and where each one lies to you when the target stack does not play by the rules.

Nmap scan types - terminal comparing ACK and FIN scan results and RFC 793 stealth logic

Nmap does not have one way to scan a TCP port, it has a whole family of them, and each one sets different flags to provoke a different reaction from the target. Knowing which scan type to reach for is the difference between mapping a firewall's rules cleanly and getting a page of misleading results. This article is part of the complete Nmap guide, and it walks the full family of TCP scan types, shows what each one detects, and (more usefully) shows where each one lies to you when the target stack does not play by the rules.

The TCP scan family at a glance

Every TCP scan type comes down to which flags Nmap sets in the probe packet and what it infers from the response. Put an open listener, a closed port, and a firewall DROP next to each other and the differences become much easier to read.

This lab used Nmap 7.99 on Alpine, with scanner 10.66.10.10 reaching three Linux targets through a routing firewall:

  • 10.66.20.10:80 had an HTTP listener.
  • 10.66.20.20:80 had no listener.
  • 10.66.20.30:80 had a listener, but the firewall silently dropped incoming TCP probes to that port.

These are the measured replies and Nmap states from the repeated runs. “Filtered” in the last column describes that DROP rule, not the whole host.

ScanFlags sentOpen responseClosed responseFiltered response
SYN (-sS)SYN [S]SYN+ACK [S.] → open; scanner sends RSTRST+ACK [R.] → closedNo reply → filtered
Connect (-sT)SYN [S], then ACK after SYN+ACKSYN+ACK; scanner completes handshake, then sends RST+ACK → openRST+ACK → closedNo reply → filtered
ACK (-sA)ACK [.]RST [R] → unfilteredRST [R] → unfilteredNo reply → filtered
FIN (-sF)FIN [F]No reply → **open\filtered**RST+ACK [R.] → closedNo reply → **open\filtered**
Xmas (-sX)FIN+PSH+URG [FPU]No reply → **open\filtered**RST+ACK [R.] → closedNo reply → **open\filtered**
NULL (-sN)No TCP flags [none]No reply → **open\filtered**RST+ACK [R.] → closedNo reply → **open\filtered**

In tcpdump's TCP flag notation, the dot means ACK. Read Flags [S.] as SYN+ACK, and Flags [R.] as RST+ACK. The lowercase IP flags field on the preceding line is a separate field.

The scans ran as root on the scanner, using -n, interface eth1, --reason, and --max-retries 1. Each TCP scan used -Pn and checked ports 80 and 81 on all three targets. Port 81 was a closed-port control on every host. Because -Pn skips discovery, “Host is up, received user-set” below is an assumption for the port scan, not proof that the host answered discovery.

SYN: the baseline across all three hosts

The -sS run separates the three TCP/80 cases cleanly:

Starting Nmap 7.99 ( https://nmap.org ) at 2026-10-17 03:38 +0000
Nmap scan report for 10.66.20.10
Host is up, received user-set (0.000063s latency).

PORT   STATE  SERVICE   REASON
80/tcp open   http      syn-ack ttl 63
81/tcp closed hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.20
Host is up, received user-set (0.00016s latency).

PORT   STATE  SERVICE   REASON
80/tcp closed http      reset ttl 63
81/tcp closed hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.30
Host is up, received user-set (0.000044s latency).

PORT   STATE    SERVICE   REASON
80/tcp filtered http      no-response
81/tcp closed   hosts2-ns reset ttl 63

Nmap done: 3 IP addresses (3 hosts up) scanned in 1.27 seconds

Port 81 is closed on all three, including the host whose port 80 is filtered. A port state belongs to the tested port and path; it does not describe every service on that address. The SERVICE names here are Nmap's port-database labels, not service/version detection.

This tcpdump excerpt shows the SYN to the open listener, its SYN+ACK, and the scanner's RST. The scanner does not complete the handshake:

2026-10-17 03:38:06.012442 IP (tos 0x0, ttl 48, id 47952, offset 0, flags [none], proto TCP (6), length 44)
    10.66.10.10.34010 > 10.66.20.10.80: Flags [S], cksum 0xe824 (correct), seq 2159637382, win 1024, options [mss 1460], length 0
2026-10-17 03:38:06.012498 IP (tos 0x0, ttl 63, id 0, offset 0, flags [DF], proto TCP (6), length 44)
    10.66.20.10.80 > 10.66.10.10.34010: Flags [S.], cksum 0x4108 (correct), seq 1736525457, ack 2159637383, win 56760, options [mss 9460], length 0
2026-10-17 03:38:06.012505 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 40)
    10.66.10.10.34010 > 10.66.20.10.80: Flags [R], cksum 0x03de (correct), seq 2159637383, win 0, length 0

ACK scan maps firewall rules, not open ports

The ACK scan, -sA, is the odd one out: it is not trying to find open ports at all. It sends a bare ACK. In this lab, both the open listener and the closed port answered with a RST, so Nmap called both unfiltered. The DROP rule stayed silent and produced filtered.

Here is the same three-host comparison with -sA:

Starting Nmap 7.99 ( https://nmap.org ) at 2026-10-17 03:38 +0000
Nmap scan report for 10.66.20.10
Host is up, received user-set (0.000037s latency).

PORT   STATE      SERVICE   REASON
80/tcp unfiltered http      reset ttl 63
81/tcp unfiltered hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.20
Host is up, received user-set (0.00011s latency).

PORT   STATE      SERVICE   REASON
80/tcp unfiltered http      reset ttl 63
81/tcp unfiltered hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.30
Host is up, received user-set (0.000037s latency).

PORT   STATE      SERVICE   REASON
80/tcp filtered   http      no-response
81/tcp unfiltered hosts2-ns reset ttl 63

Nmap done: 3 IP addresses (3 hosts up) scanned in 1.27 seconds

The capture makes the distinction clear. This is an ACK to the closed TCP/80 control followed by its RST:

2026-10-17 03:38:14.201238 IP (tos 0x0, ttl 39, id 22237, offset 0, flags [none], proto TCP (6), length 40)
    10.66.10.10.52215 > 10.66.20.20.80: Flags [.], cksum 0x823e (correct), seq 0, ack 860419940, win 1024, length 0
2026-10-17 03:38:14.201313 IP (tos 0x0, ttl 63, id 0, offset 0, flags [DF], proto TCP (6), length 40)
    10.66.20.20.80 > 10.66.10.10.52215: Flags [R], cksum 0x864a (correct), seq 860419940, win 0, length 0

“Unfiltered” means the ACK probe received a response. It does not mean the port is open or that other traffic will pass. “Filtered” does not identify a stateful firewall either: the unconditional TCP/80 DROP rule produced that result without checking connection state.

Stateful ACK filtering on TCP/2222

A separate rule for 10.66.20.30:2222 used connection tracking: accept established/related traffic, drop new SYNs, then drop unmatched packets. That final DROP caught the unsolicited ACKs. The -sA run reported the closed control 10.66.20.20:2222 as unfiltered after a RST, and 10.66.20.30:2222 as filtered after no reply. A SYN scan reported the same pair as closed and filtered.

So both policies produced a filtered ACK result: unconditional DROP on port 80 and the stateful policy's fallback DROP on port 2222. ACK results alone cannot tell you which policy caused the silence. Established-session forwarding was configured but was not exercised. This was a Linux firewall test; no Windows host was tested.

FIN, NULL, and Xmas: the RFC 793 stealth scans

The FIN (-sF), NULL (-sN), and Xmas (-sX) scans send a bare FIN, no flags, or FIN+PSH+URG. On these Linux targets, the closed port answered each with a RST+ACK. The open listener stayed silent, and so did the firewall DROP.

That is why Nmap reports open|filtered for both silent cases. It cannot tell an open port from a dropped probe. Here is the real -sF output across the three hosts:

Starting Nmap 7.99 ( https://nmap.org ) at 2026-10-17 03:38 +0000
Nmap scan report for 10.66.20.10
Host is up, received user-set (0.000025s latency).

PORT   STATE         SERVICE   REASON
80/tcp open|filtered http      no-response
81/tcp closed        hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.20
Host is up, received user-set (0.000085s latency).

PORT   STATE  SERVICE   REASON
80/tcp closed http      reset ttl 63
81/tcp closed hosts2-ns reset ttl 63

Nmap scan report for 10.66.20.30
Host is up, received user-set (0.000033s latency).

PORT   STATE         SERVICE   REASON
80/tcp open|filtered http      no-response
81/tcp closed        hosts2-ns reset ttl 63

Nmap done: 3 IP addresses (3 hosts up) scanned in 1.27 seconds

The repeated NULL and Xmas runs produced the same split on TCP/80: open|filtered on .10, closed on .20, and open|filtered on .30. All three scans still found TCP/81 closed on every target.

For the Xmas run, tcpdump shows the actual FIN+PSH+URG flags and the closed port's reset:

2026-10-17 03:38:22.439254 IP (tos 0x0, ttl 45, id 64704, offset 0, flags [none], proto TCP (6), length 40)
    10.66.10.10.61293 > 10.66.20.20.80: Flags [FPU], cksum 0xd5c2 (correct), seq 1112568137, win 1024, urg 0, length 0
2026-10-17 03:38:22.439347 IP (tos 0x0, ttl 63, id 0, offset 0, flags [DF], proto TCP (6), length 40)
    10.66.20.20.80 > 10.66.10.10.61293: Flags [R.], cksum 0xd9d6 (correct), seq 0, ack 1112568138, win 0, length 0

Calling these “stealth scans” does not resolve that ambiguity. None of them bypassed this lab's TCP/80 DROP rule, and none proved the silent listener was open. Cross-check a surprising result with the SYN baseline.

What this Linux lab establishes

The new measurements establish this behavior for the Linux targets tested here. They do not establish how a Windows TCP stack responds; no Windows host was tested. Even on these Linux targets, an open|filtered result needs another check before you can call the port open.

Window scan: reading the RST size

The Window scan, -sW, is a refinement of the ACK scan. It sends the same bare ACK, but instead of only checking whether a RST comes back, it inspects the TCP window field of that RST. On certain stacks an open port returns a RST with a non-zero window while a closed port returns a zero window, letting Nmap distinguish open from closed where a plain ACK scan could only say unfiltered. The catch is that this depends entirely on quirks of the target's TCP implementation, so it is unreliable across the board and produces plenty of false results on stacks that do not exhibit the behavior. Treat it as a situational tool, not a primary scan.

Maimon scan: the FIN/ACK BSD quirk

The Maimon scan, -sM, sets both the FIN and ACK flags. By RFC 793 any host should answer such a probe with a RST regardless of port state, which would make it useless. Its author, Uriel Maimon, discovered that many BSD-derived stacks break the rule and drop the packet silently on an open port while still sending a RST on a closed one, exactly the open|filtered versus closed split the FIN scan relies on. On modern hardware that quirk is rare, so Maimon is mostly a historical and niche technique, but it is worth recognizing in the family because it shows how scan types exploit specific stack behaviors rather than a single universal rule.

Which scan when

The family is large, but the decision is usually simple. Use this as your quick reference:

GoalScanWhat to take from this lab
Default, everyday TCP scan-sSStart here for the open/closed/filtered baseline.
No raw-packet privileges-sTUse the connect scan. It completed the handshake on the open listener and gave the same three TCP/80 states as SYN.
Check filtering for ACK probes-sARead filtered versus unfiltered. It cannot tell open from closed or identify the firewall policy by itself.
Compare unusual flags against a SYN baseline-sF, -sN, -sXTreat silence as open or filtered. All three stayed ambiguous behind this DROP rule.

Window and Maimon remain situational techniques; they were not measured in this lab. Keep the scan type, target port, response, and path together when comparing results.

Key takeaways

Use -sS as your everyday baseline and -sT when raw-packet scans are unavailable. Reach for -sA to test how ACK probes are filtered, but read unfiltered as a response to that probe, not an open port or a clear path for every kind of traffic. FIN, NULL, and Xmas returned open|filtered for both the Linux listener and the silent DROP rule. When a result surprises you, cross-check it with SYN and the packet capture. For the discovery step before a port scan, see Nmap host discovery.

Read next