---
title: "Your Docker Host Is Fine. Containers Lie (CVE-2026-98432)"
description: "Host looked patched for CVE-2026-98432. 19/20 Docker containers still had MPTCP on — including Docker DNS at 127.0.0.11."
author: "Mohammad Pouya Ghourchiani"
canonical: "https://ghourchiani.ir/blog/cve-2026-98432-docker-container-namespaces"
image: "https://ghourchiani.ir/og/mark-square.png"
date: "2026-11-02"
updated: "2026-11-16"
lang: "en"
generated: "2026-11-19"
---
# Your Docker Host Is Fine. Containers Lie (CVE-2026-98432)

> **TL;DR:** Turning off MPTCP and dropping IP-options SYNs on a Docker host does not protect the containers: each one has its own network namespace, its own MPTCP setting (on by default) and its own firewall. Apply both inside every container namespace, keep applying them to new containers, and prove it with a packet test — not with a status line.

## 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](https://amensecurity.ca), 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](https://amensecurity.ca/en/blog/linux-kernel-tcp-flaw-cve-2026-98432). 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:

1. **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 `raw` table rule drops TCP SYNs whose IPv4 header is longer than 20 bytes. Red Hat and AlmaLinux publish the same idea as an nftables rule.
2. **Close the published path.** `net.mptcp.enabled=0` in `/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:

```sh
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' ' -)"
done
```

Every 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:

```sh
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"; done
```

The 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:

```python
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

1. Patch and reboot where your distribution has a fixed kernel. The mitigation is a gap-filler, not the fix.
2. On the host: drop IPv4 TCP SYNs with IP options in `raw`/prerouting, and turn MPTCP off.
3. In every container namespace: the same two, applied by a service that also handles containers started later.
4. Audit with `nsenter … ss -lnHM`, not with the host's `ss`. Expect `127.0.0.11` to show up.
5. Prove the drop with a real packet and a rising counter.
6. Remove the mitigations only after `uname -r` shows the fixed kernel.

## Links

- [Amen Security — CVE-2026-98432 patch status and mitigation](https://amensecurity.ca/en/blog/linux-kernel-tcp-flaw-cve-2026-98432) — distribution table, nftables rule, five-minute check
- [Red Hat bulletin RHSB-2026-016](https://access.redhat.com/security/vulnerabilities/RHSB-2026-016) · [AlmaLinux mitigation and fixed kernels](https://almalinux.org/blog/2026-10-30-cve-2026-98432/)
- [Linux kernel CVE announcement](https://lists.openwall.net/linux-cve-announce/2026/10/15/1)
- [/blog/ai-writes-code-who-owns-the-system](/blog/ai-writes-code-who-owns-the-system) — why "done" needs evidence
- [/about](/about) · [/contact](/contact)
