# CVE-2026-98432: the firewall stopgap while you wait for the kernel, what it can break and how to test it
Table of Contents
CVE-2026-98432 is a use-after-free in the Linux kernel code that accepts TCP connections over IPv4: a SYN carrying IP options, retransmitted while the connection completes, makes the kernel read memory it has already freed. The kernel CVE team published it on 15 October 2026 with a 9.8 score, and as of 6 November (status verified at 12:12
UTC) fixed kernels exist for Debian, RHEL with AlmaLinux and Rocky, CloudLinux, SUSE, Oracle and Amazon Linux, while for Ubuntu 22.04, 24.04 and 26.04 they sit in -updates with no USN yet. Who is affected, under which conditions and how to update is in the article on the flaw; here we only talk about the stopgap.
The stopgap is a firewall rule that drops IPv4 TCP packets with IP options, published by Red Hat and by AlmaLinux for those who cannot reboot right away. Before loading it in production the right question is: what stops working? Below: the rule in its nftables, iptables and ufw variants, the tests we ran in a Debian 13 container and on a Docker host, the cases where it pays to stop and think, and the other documented mitigations with their limits.
The rule: drop IPv4 TCP packets with IP options
Red Hat in bulletin RHSB-2026-016 and AlmaLinux on its blog publish the same idea: drop IPv4 TCP packets whose header is longer than 20 bytes. In nftables that is ip hdrlength > 5, because RFC 791 measures the header in 32-bit words: 5 without options, up to 15 (60 bytes) with them. Ubuntu's CVE page hosts a community contribution with a similar rule, which warns that it "reduces the risk but does not fully prevent exploitation"; the Ubuntu Security Team, in its blog post of 2 November, writes that "security updates are the only appropriate mitigation", and Red Hat presents the rule as a reduction of exposure, not full prevention. Nobody guarantees it stops an exploit, and neither do we: what we verified is what it does to traffic.
The two variants differ in where they hook. Red Hat uses table inet and hook input at priority -310 (rule ip protocol tcp ip hdrlength > 5 counter drop), AlmaLinux table ip and hook prerouting at priority -300. The prerouting hook sees all incoming traffic, input only traffic addressed to the machine (nftables wiki), and ports published by Docker are diverted in the nat table before they reach INPUT (Docker documentation): only prerouting covers them, and AlmaLinux says so: the rule protects the host and the containers that receive their traffic through it. In exchange prerouting also sees forwarded traffic, if the machine acts as a router. AlmaLinux's variant, in the file /etc/cve-2026-98432.nft:
table ip cve_2026_98432 { chain prerouting { type filter hook prerouting priority -300; policy accept; meta l4proto tcp ip hdrlength > 5 counter drop }}sudo nft -c -f /etc/cve-2026-98432.nftsudo nft -f /etc/cve-2026-98432.nftsudo nft list table ip cve_2026_98432sudo nft delete table ip cve_2026_98432The four commands check the syntax, load, show and remove the table; nft list table also prints the counter of dropped packets. We ran them in a Debian 13 container with nftables 1.1.3: the table loads, lists, deletes and coexists with Debian's default inet filter table. To protect only the machine's own services, write hook input instead of hook prerouting in the same file: nft -c -f accepts that form too.
Surviving a reboot, iptables and ufw
The table does not survive a reboot, as both AlmaLinux and Red Hat write. On Debian and Ubuntu nftables.service runs nft -f /etc/nftables.conf: add include "/etc/cve-2026-98432.nft" at the end of that file, check with nft -c -f /etc/nftables.conf and enable the service. Tested: Debian 13's default file starts with flush ruleset and defines an empty inet filter table, and with the include at the end nft -f /etc/nftables.conf loads both tables. On RHEL and its clones the service reads /etc/sysconfig/nftables.conf instead (unit file read on AlmaLinux 9). Once the fixed kernel is running, remove the include line and delete the table.
With iptables there is no IP options module: on Debian 13, iptables 1.8.11 answers "Couldn't load match 'ipv4options': No such file or directory". The u32 module, which compares the first bytes of the packet, works: 0>>24&0xF isolates the low four bits of the first byte, that is the IP header length, and 6:15 takes every value above 5:
sudo iptables -I INPUT -p tcp -m u32 --u32 "0>>24&0xF=6:15" -j DROPTested: with the rule loaded a local HTTP request answers 200, a SYN with the record route option gets no reply and the counter shows one packet; iptables -D INPUT with the same arguments removes it. It sits in the INPUT chain, so like Red Hat's variant it does not see ports published by Docker. With ufw the same line goes into /etc/ufw/before.rules, in the ufw-before-input chain: we verified that iptables-restore --test accepts the file with the added line (ufw 0.36.2), not the service reload, which does not run in a container.
What no variant covers: traffic between containers on the same host, which AlmaLinux says "may bypass" the rule and which Red Hat, for pod-to-pod traffic in OVN-Kubernetes, declares not filtered. We saw it too: on a Docker host without the br_netfilter module, a SYN with the record route option sent from one container to another on the same bridge never touched the counter of the prerouting rule. A filter at the network boundary in front of the cluster has no such limit (Red Hat again).
What the rule can break, and when it is a good stopgap
The right question before loading it: "if I drop TCP packets with IP options, what stops working?". Short answer: in ordinary traffic, nothing we could find, measured rather than assumed. The long answer, with tests, limits and the cases where it pays to stop, is below.
IP options and TCP options are not the same thing
This is the most likely mix-up. IP options live in the IPv4 header, which is normally 20 bytes and grows to 60 with options (RFC 791). TCP options (MSS, SACK, timestamps, window scale) live in the TCP header, further into the packet, and are present in practically every connection: the rule never even looks at them, because ip hdrlength reads the IP header only. The nmap guide puts it in one line: unlike TCP options, IP options are "rarely seen due to practicality and security concerns".
We tested it in the container with the rule in observation mode only (counter without drop, the file is further down): a local HTTP server on port 8080, two requests with curl, counter stuck at zero. The SYN captured by tcpdump is 60 bytes long, with a 20-byte IP header and options [mss 65495,sackOK,TS val ...,nop,wscale 10] all in the TCP header. Then a SYN built on purpose with the "record route" IP option:
sudo hping3 -S -p 8080 -c 1 --rroute 127.0.0.1sudo nft list table ip cve_2026_98432sudo tcpdump -ni lo -v 'tcp and ip[0] & 0xf > 5'The counter goes up and tcpdump shows options (RR ...) in the IP header: ip[0] & 0xf reads the header length field, and the pcap-filter manual uses ip[0] & 0xf != 5 for all IPv4 packets with options (5 is the minimum, so > 5 selects the same packets). Mind the numbers: every probe on loopback counts three packets, because the kernel copies the options into the SYN-ACK and also into the RST with which, on hping3's side, it rejects that SYN-ACK (hping3 sends the SYN from a raw socket, without opening a connection).
Who actually uses IP options
| Option | Who uses it | How common | With the rule |
|---|---|---|---|
| Source routing (LSRR, SSRR): the sender dictates the path | traceroute -g, nmap --ip-options L or S, hping3 --lsrr or --ssrr (listed by hping3 --help) | Very rare: the traceroute manual warns that "most routers have disabled source routing for security reasons", and RFC 7126 says to drop it by default | Nothing changes: the kernel already drops it before TCP sees it (test below) |
| Record Route and Timestamp: record the path or the times | ping -R, ping -T, hping3 --rroute, nmap --ip-options R or T | Rare: the ping manual warns that "Many hosts ignore or discard this option", and RFC 7126 recommends dropping both Record Route and Timestamp by default | Only TCP tests with these options are dropped; ping travels over ICMP, which the rule does not look at |
| CIPSO: a security label in the packet | NetLabel, which adds the label as an IP option to outgoing packets (kernel documentation) | Networks with security labels; RFC 7126 asks not to drop CIPSO by default and states that "No routers or firewalls are known to support this option" | AlmaLinux warns not to use the rule if your network relies on CIPSO; with NetLabel compiled in but no domain configured the kernel already rejects these packets (test below) |
| Router Alert and Quick-Start | Specific protocols, described in RFC 7126 | RFC 7126 recommends ignoring them by default and, for Router Alert, dropping it in unsafe environments | Dropped if they arrive inside a TCP packet |
Source routing, the most cited case: the kernel accepts a source-routed packet only if net.ipv4.conf.all.accept_source_route and the interface value are both 1 (the IN_DEV_SOURCE_ROUTE macro in inetdevice.h ANDs them, ip_input.c drops the packet when it is false, and the sysctl documentation gives a host's default as false). In the container every value was 0. Test with the rule in observation mode and two SYNs built with scapy: the one with record route gets its SYN-ACK, the same SYN with loose source route gets nothing. CIPSO, same test: on a kernel with NetLabel compiled in (CONFIG_NETLABEL=y, read in the Debian 13, Ubuntu 26.04 and AlmaLinux 9 kernels) but with no NetLabel domain configured, a SYN with a CIPSO option gets an ICMP "parameter problem" (type 12), sent by ip_options.c when option parsing fails, and the IpInHdrErrors counter in /proc/net/snmp goes up, as ip_input.c does. On a kernel built without NetLabel the check on the option is only structural and the packet gets through. Labeled IPsec is unrelated: its label travels in the IKEv2 negotiation (RFC 9478), not in IP options.
What the dropped side sees: nothing. drop sends no error, the client retransmits the SYN and gives up after six retransmissions, 131 seconds with the defaults documented for current kernels (tcp_syn_retries): in our tests hping3 -S --rroute against the server in drop mode ends with "100% packet loss", not with a refusal. How many IP options arrive from the internet: RFC 7126 speaks of a "widespread practice of blocking IPv4 optioned packets" and points to the study by Fonseca et al. (Berkeley, 2005), which found that "approximately half of Internet paths drop packets with options", with the drops concentrated in a minority of edge networks. We know of no more recent measurements, and we made none on your server: hence the observation phase.
The common setups, one by one
The rule does not look at the port: it applies to any IPv4 TCP service, and what changes from one case to the next is whether the client asks its kernel for IP options. For the cases below we either measured it or have a source that says it.
| Setup | Verdict | Why (test or source) |
|---|---|---|
| Web, also behind a CDN or reverse proxy | Negligible | The HTTP traffic in our tests carries no IP options: two curl requests never touch the counter. The proxy is still a host with an open IPv4 TCP port: the rule belongs there too |
| WireGuard VPN | No impact, and it also covers the tunnel's clients | Tested with a tunnel between two network namespaces and the rule in prerouting on the server: curl inside the tunnel answers 200 with the counter still, a SYN with record route inside the tunnel is counted and, with drop, dropped |
| Docker with published ports | No impact on ordinary traffic, published ports covered by prerouting | Tested on a Docker host (docker:dind
image, nftables 1.1.6) with nginx published on 8080: curl from outside answers 200 with the counter still, a SYN with record route is counted in observation mode and dropped with drop, while curl keeps answering. The same SYN between two containers on the same bridge never touched the counter (host without br_netfilter): that is the traffic AlmaLinux and Red Hat warn is not covered |
| Routers, NAT, transit firewalls | Caution | prerouting is also crossed by forwarded traffic (nftables wiki): with drop you also discard transit traffic with options, which RFC 7126 recommends anyway for source routing and Timestamp. To protect only the router's own services use hook input |
| IPv6 | Nothing changes | table ip applies to IPv4 only; the commit says IPv6 is not affected by the first issue and AlmaLinux that "IPv6 traffic does not need the rule" |
Kubernetes, layer 4 balancers and OpenVPN we did not test and do not judge: try in staging.
Observe first, then drop
The safe way to introduce it is in two steps. First, the same rule without drop, with the counter and a limited log, in /etc/cve-2026-98432-osserva.nft:
table ip cve_2026_98432 { chain prerouting { type filter hook prerouting priority -300; policy accept; meta l4proto tcp ip hdrlength > 5 counter limit rate 10/minute log prefix "cve-2026-98432 " }}sudo nft -f /etc/cve-2026-98432-osserva.nftsudo nft list table ip cve_2026_98432sudo journalctl -k | grep cve-2026-98432After a day (a week, if traffic is light) the counter tells you how many TCP packets with IP options arrived and the log tells you from which addresses; the limit keeps the log to about ten lines per minute and, per the nft manual, the lines go to the kernel log, where journalctl -k reads them. In the container we verified loading and counting, not the log lines: by default only the main network namespace writes to the kernel log (nf_log_all_netns, kernel documentation), and that is the one a real server uses. The log records IP addresses, that is personal data: keep it to the minimum. Like the drop rule, it does not survive a reboot: the same include applies. Counter at zero, or only probes: move to drop with nft delete table ip cve_2026_98432 and nft -f /etc/cve-2026-98432.nft. Counter rising from addresses you recognise (a monitoring system, a partner, a labelled network): before dropping, ask what they are.
Who can use it with peace of mind
| Situation | Verdict |
|---|---|
| Web, mail, database or SSH servers, on the internet or on the LAN, with no special requirements | Use it, after the observation phase: the rule does not look at the service, and the counter tells you whether any client uses IP options |
| Docker hosts with published ports, WireGuard servers | Use it (prerouting variant): tested, it covers published ports and tunnel clients, not traffic between containers |
| Routers, NAT, transit firewalls | Caution: input variant, or accept dropping transit traffic with options too |
Networks with monitoring or scanners that use IP options over TCP (hping3 --rroute, nmap --ip-options) | Caution: those tests will fail by timeout, warn whoever runs them |
| Networks with CIPSO labels (NetLabel), legacy or industrial networks with source routing | Not blindly: AlmaLinux says not to use it with CIPSO; decide with whoever manages the network |
The honest verdict: IP options in ordinary traffic are rare, the kernel already drops source routing and, by the only measurement we know of, from 2005, about half of internet paths dropped packets with options: for the vast majority of servers the rule is a reasonable bridge to the maintenance window. It remains a bridge: it reduces the risk, it does not remove it, and the fixed kernel with a reboot is the only fix. If you would rather have someone else handle that window, the managed server plan starts at €89 per month and includes security patches and scheduled updates.
The other documented mitigations, with their limits
- Disabling MPTCP (
net.mptcp.enabled=0, persisted in/etc/sysctl.d/) closes only the route Anthropic demonstrated, which used a Multipath TCP listener. The kernel default is 1 (MPTCP sysctl documentation), read on an Ubuntu 26.04 host and in a fresh network namespace; AlmaLinux ships it at 0 and Red Hat writes that it is disabled in RHEL's default configuration, but both repeat that MPTCP is not a precondition for the flaw and that disabling it is not enough. The documentation talks about creating MPTCP sockets, not about those already open: restart the services that have an MPTCP listener (ss -Mlnplists them). Since 1.24, Go programs open listeners with MPTCP by default on Linux, and the Go security team calls per-program disabling "a fragile mitigation", because one forgotten listener is enough. net.ipv4.tcp_migrate_req=0is already the default (IP sysctl documentation): check you did not change it.- Livepatch. CloudLinux lists KernelCare with the fix for the CloudLinux 7h, 8 and 9 kernels since 2 November and for CloudLinux 10 since the 3rd, applied with
kcarectl --updateand verified withkcarectl --patch-infogrepping for the CVE: having no KernelCare, we did not run these commands. SUSE's CVE page listskernel-livepatchpackages for SLES 15 SP4-SP7; Canonical's blog post of 2 November does not mention Livepatch. init_on_free=1was proposed on oss-security, and on 2 November Sultan Alsawaf of CIQ's kernel team replied that it "doesn't do anything meaningful against this CVE": the pointers the attacker needs leak from live objects next to the freed one, not from the freed object's own contents, so zeroing freed memory changes nothing meaningful.
None of these replaces the new kernel and the reboot, and AlmaLinux says it of its own interim steps: "Neither step is a fix". They get you to the maintenance window, they do not let you skip it.
In summary
The stopgap for CVE-2026-98432 is an nftables rule (or iptables u32) that drops IPv4 TCP packets with IP options, in Red Hat's input variant or AlmaLinux's prerouting variant: the latter also covers ports published by Docker and the clients of a WireGuard VPN, as we measured, while traffic between containers on the same host may bypass them, as AlmaLinux warns and as we saw on a Docker host. IP options in ordinary traffic are rare and the kernel already drops source routing; those who can lose out are diagnostic tools that use record route or timestamp over TCP, transit routers and networks with CIPSO labels. Introduce it first in observation mode and then in drop mode, with the include for reboots and the removal once the fixed kernel runs: the other mitigations cover less or nothing, and the new kernel with a reboot remains the only fix.
Sources
- CVE.org, record CVE-2026-98432 (CNA: Linux kernel)
- Linux, commit e3f33b0 "ipv4: free inet_opt and ireq_opt after an RCU grace period" (GitHub mirror)
- Red Hat, bulletin RHSB-2026-016 with the nftables mitigation
- AlmaLinux, "CVE-2026-98432: Patched kernels released" (30 October, updated 2 November)
- Ubuntu, CVE-2026-98432 (with the community contribution on the nftables rule) and "Fixes available in -proposed pocket for CVE-2026-98432" (2 November)
- CloudLinux, CVE-2026-98432 status and KernelCare
- SUSE, CVE-2026-98432
- Anthropic, "Discovering vulnerabilities with Claude" (27 October 2026)
- oss-security, Go Security Team: "Protecting against CVE-2026-98432 when using Go programs" and Sultan Alsawaf (CIQ) on init_on_free=1
- RFC 7126, recommendations on filtering IPv4 packets containing options, RFC 791, Internet Protocol and RFC 9478, Labeled IPsec Traffic Selector Support for IKEv2
- Fonseca, Porter, Katz, Shenker, Stoica, "IP Options are not an option", UC Berkeley EECS-2005-24
- Linux kernel, MPTCP sysctl, IP sysctl (accept_source_route, tcp_syn_retries, tcp_migrate_req) and netfilter sysctl (nf_log_all_netns)
- Linux kernel, net/ipv4/ip_input.c, net/ipv4/ip_options.c, include/linux/inetdevice.h (IN_DEV_SOURCE_ROUTE macro), include/net/cipso_ipv4.h (cipso_v4_validate without CONFIG_NETLABEL) and NetLabel: CIPSO/IPv4 engine
- man traceroute(8), man ping(8), man hping3(8), Nmap Reference Guide, --ip-options, man pcap-filter(7)
- nftables, man nft(8), nftables wiki, Netfilter hooks and Docker, Packet filtering and firewalls
