Direct answer
If you mitigated CVE-2026-98432 on a Docker host by setting net.mptcp.enabled=0 and dropping TCP SYNs that carry IPv4 options, your containers are probably still exposed. Both of those settings belong to a network namespace, and every container has its own. On the host I hardened, 19 of 20 containers still had MPTCP on, and Docker’s embedded DNS was listening with MPTCP inside every one of them. The fix is to apply the same two settings inside each container’s namespace, keep applying them to every container started later, and prove the drop with an actual packet.
The vibe check 🫠
Imagine the apartment building is locked. Lobby camera is green. You high-five yourself.
Then you knock on each flat.
Nineteen doors open. Inside every kitchen, the same weird roommate is still taking calls: Docker DNS on 127.0.0.11, speaking MPTCP like it never got the memo.
That is this CVE on a Docker host. The host is not the building. The host is one flat. Containers are the other flats. Same kernel hallway. Different locks.
Also: since Go 1.24, a lot of listeners try MPTCP by default. dockerd is Go. Surprise.
The flaw, in four lines
CVE-2026-98432 is a race in the Linux kernel’s IPv4 TCP handshake: when a connection request carries IP options, the kernel hands them to the new socket without copying them, and a resent request on another CPU can read them after they are freed. Every kernel since 4.4 has it, the kernel team and Red Hat rate it 9.8, and Anthropic described a remote root exploit against servers with a multipath TCP (MPTCP) listener.
Which distributions have a fixed kernel changes by the day. At Amen Security, where I lead full-stack delivery and production operations, we keep the status table and the vendor-backed mitigation here: CVE-2026-98432 patch status for Ubuntu, RHEL, Debian, AWS and Proxmox. As I write this, Ubuntu still has no fixed kernel. That is the gap this note is about.
What I did on the host
Two layers, both boot-persistent:
- Drop the trigger. In the kernel source, the options that get freed too early are only stored when the incoming SYN actually has IPv4 options. So a
rawtable rule drops TCP SYNs whose IPv4 header is longer than 20 bytes. Red Hat and AlmaLinux publish the same idea as an nftables rule. - Close the published path.
net.mptcp.enabled=0in/etc/sysctl.d/, then restart the services that were already listening with MPTCP. Go programs do that by default since Go 1.24, and they fall back to plain TCP on their own.
ss -lnpM on the host came back empty. Done — or so the host said.
What the containers said
The host’s view of the world stops at its own network namespace. So I asked each container directly:
for c in $(docker ps -q); do
pid=$(docker inspect -f '{{.State.Pid}}' "$c")
printf '%s mptcp=%s mptcp_listeners=%s\n' \
"$(docker inspect -f '{{.Name}}' "$c")" \
"$(nsenter -t "$pid" -n cat /proc/sys/net/mptcp/enabled)" \
"$(nsenter -t "$pid" -n ss -lnHM | awk '{print $4}' | paste -sd' ' -)"
doneEvery container on a Docker network answered mptcp=1. The only one with 0 was the one using the host network. And the listener column had the same entry in every single container: 127.0.0.11:<port> — Docker’s embedded DNS resolver. dockerd is written in Go, so it opens that listener with MPTCP inside every container it starts. An S3-compatible object store and a Go API were listening with MPTCP too.
None of this was reachable from the internet: only 80 and 443 were public, the other published ports were bound to 127.0.0.1, and the host rule filters packets before they are forwarded to a container. But that was not the threat model that worried me.
Why it matters anyway: one kernel
Containers share the host kernel. Any process in any container can put IP options on its own connection request with a plain setsockopt(IP_OPTIONS) — no extra capability needed. It can aim that at its own loopback, where Docker’s DNS is listening with MPTCP, or at another container on the same bridge. Neither path touches the host’s firewall: a container’s loopback is inside its own namespace, and with br_netfilter not loaded, container-to-container bridge traffic never goes through host iptables.
So one compromised web app container could have used this kernel bug to escape to the host. The host-level mitigation did nothing about that.
Punchline: locking the lobby does not lock the kitchens when they share the same basement pipes.
The fix: harden every namespace, now and later
No container restarts. nsenter enters each container’s network namespace with the host’s tools, turns MPTCP off and adds the same raw rule:
U32='0>>24&0x0F=6:15'
harden() {
pid=$(docker inspect -f '{{.State.Pid}}' "$1")
nsenter -t "$pid" -n sysctl -q -w net.mptcp.enabled=0
nsenter -t "$pid" -n iptables -t raw -C PREROUTING -p tcp --syn -m u32 --u32 "$U32" -j DROP 2>/dev/null ||
nsenter -t "$pid" -n iptables -t raw -I PREROUTING -p tcp --syn -m u32 --u32 "$U32" -j DROP
}
for c in $(docker ps -q); do harden "$c"; done
docker events --filter type=container --filter event=start --format '{{.Actor.ID}}' |
while read -r id; do harden "$id"; doneThe last two lines are the part people skip. A deploy, a crash restart or a docker compose up -d creates a brand-new namespace with MPTCP back on and no rule. So the script runs as a systemd service tied to Docker (PartOf=docker.service, Restart=always) and hardens every container the moment it starts. (In the real version, containers that share the host network are skipped — the host rule already covers them.) Docker itself uses iptables-nft inside containers, so the rule lives alongside Docker’s own NAT rules for the embedded DNS without touching them.
Proof, not a status line
“rule=present” is a claim. I wanted a packet. In a throwaway namespace with the same rule, and later inside a freshly started test container:
import socket
c = socket.socket(); c.settimeout(3)
c.setsockopt(socket.IPPROTO_IP, socket.IP_OPTIONS, bytes([7, 7, 4, 0, 0, 0, 0, 1])) # Record Route
c.connect(('127.0.0.1', 47001))A normal connection connected. The one with Record Route timed out, and the rule counter showed 3 dropped packets — the SYN and its two retransmits — before TCP ever saw them. Docker’s DNS still resolved container names, and every site behind the host answered with the same status codes as before.
The bug my own fix had
The first version of that service used --format '{{.ID}}'. On Docker 29 the ID field is gone from event messages; it is {{.Actor.ID}} now. docker events failed instantly, systemd restarted the service every five seconds, and every restart re-hardened the containers that already existed. So the status check looked perfect. Only a container started after the service exposed it: mptcp=1, no rule.
Lesson I keep relearning: test the path that runs later, not just the one that runs now.
One more trap: the Ubuntu changelog
A common way to check whether a distribution kernel has a fix is to grep its package changelog for the CVE. On Ubuntu, apt changelog linux-image-$(uname -r) returns the changelog of the signed package — a few lines, no CVE list — so that grep can never find anything, patched or not. The full kernel changelog is on linux-modules-$(uname -r).
Checklist for a Docker host
- Patch and reboot where your distribution has a fixed kernel. The mitigation is a gap-filler, not the fix.
- On the host: drop IPv4 TCP SYNs with IP options in
raw/prerouting, and turn MPTCP off. - In every container namespace: the same two, applied by a service that also handles containers started later.
- Audit with
nsenter … ss -lnHM, not with the host’sss. Expect127.0.0.11to show up. - Prove the drop with a real packet and a rising counter.
- Remove the mitigations only after
uname -rshows the fixed kernel.
Links
- Amen Security — CVE-2026-98432 patch status and mitigation — distribution table, nftables rule, five-minute check
- Red Hat bulletin RHSB-2026-016 · AlmaLinux mitigation and fixed kernels
- Linux kernel CVE announcement
- /blog/ai-writes-code-who-owns-the-system — why “done” needs evidence
- /about · /contact