The usual WireGuard MTU advice is "use 1420, or 1380 if things break". I wanted to know what actually breaks, so I built the path in network namespaces on a Linux 6.8 kernel and measured it: a client, a router, and a server, where the router to server leg has an MTU of 1492 like a PPPoE DSL line. On each run I sent the largest ping that passes with the don't-fragment bit, then a 2 MB TCP transfer through the tunnel, and read the fragmentation counters on each hop.
Short version: over IPv4 an oversized tunnel MTU gets fragmented and still works. Over IPv6, the default 1420 behind a 1492 link hangs every large TCP transfer as soon as a firewall drops ICMPv6 "packet too big". Small packets keep working, which is why it looks like a flaky server rather than an MTU problem.
The results
Client link 1500 everywhere, so wg-quick would pick 1420 on its own. "Largest ping" is the biggest inner packet (IP header included) that got a reply with ping -M do.
| Endpoint | Tunnel MTU | Router to server MTU | ICMP "too big" | Largest ping | 2 MB TCP transfer |
|---|---|---|---|---|---|
| IPv4 | 1420 | 1500 | passes | 1420 | complete |
| IPv4 | 1420 | 1492 | passes | 1420 | complete, 0 fragments |
| IPv4 | 1432 | 1492 | passes | 1432 | complete, 0 fragments |
| IPv4 | 1440 | 1492 | passes | 1440 | complete, router fragmented the UDP packets |
| IPv4 | 1500 | 1492 | passes | 1500 | complete, client and router fragmented |
| IPv6 | 1420 | 1500 | passes | 1420 | complete |
| IPv6 | 1420 | 1492 | passes | 1416 | complete, first big packet lost, then the client fragments |
| IPv6 | 1420 | 1492 | dropped | 1408 | 0 bytes received, timed out after 5 s (2 runs out of 2) |
| IPv6 | 1412 | 1492 | dropped | 1412 | complete |
| IPv6 | 1400 | 1492 | dropped | 1400 | complete |
What the numbers say
IPv4: the outer packet can be fragmented, so a big MTU is slow, not broken. The router counted fragments (IpFragCreates) on the 1440 and 1500 runs, which means the encrypted UDP packets left the client without the don't-fragment bit. Fragmentation costs CPU and any lost fragment loses the whole packet, so it is still worth avoiding, but it is not the stall people describe. On a 1492 path, 1432 is the largest IPv4 tunnel MTU that never fragments (1492 minus 60 bytes of IPv4, UDP and WireGuard headers).
IPv6: routers never fragment, so the path depends on ICMPv6. With the ICMPv6 reply allowed, the router sent one "packet too big" (Icmp6OutPktTooBigs = 1), the first large packet was lost, and the client then fragmented locally. Once I dropped that ICMPv6 type on the router, nothing told the client the packets were too big. The TCP handshake went through, the 2 MB never arrived. That is the familiar symptom: SSH logs in and then freezes on ls of a big directory, a web page loads its headers and spins.
Why 1408 and not 1412 in the broken case. WireGuard pads every encrypted packet up to a multiple of 16 bytes, but never past the interface MTU (calculate_skb_padding in the kernel's send.c). With MTU 1420, a 1412 byte packet is padded to 1424, and 1424 + 80 = 1504 does not fit in 1492. A 1408 byte packet is already a multiple of 16, so it fits. With MTU 1412 the padding is capped at 1412 and full-size packets fit exactly. So the "subtract 80" rule gives you the right MTU, but you cannot test it by pinging sizes below a too-big MTU: the padding shifts the result.
What to set
- Plain 1500 path, either IP version: 1420, the
wg-quickdefault, is right. - PPPoE or DSL (1492): 1412. It is the largest value that never needs fragmentation or ICMP over IPv6, and it also covers IPv4.
- Mobile networks and stacked tunnels have smaller paths. Measure instead of guessing: from the client,
ping -M do -s 1472 <server public IP>and lower the size until it passes. Path MTU = size + 28 for IPv4 (+48 for IPv6, withping -6), tunnel MTU = path MTU - 60 for an IPv4 endpoint, - 80 for IPv6.
If you would rather not do the arithmetic, the WireGuard config checker flags an MTU above 1420. Since this measurement it also adds a note when a client has an IPv6 Endpoint and no MTU line, which is exactly the broken row above. It runs in the browser and private keys never leave the page.
Reproduce it
Three namespaces, two veth pairs, one wg binary (I extracted wg from the wireguard-tools .deb with apt-get download, nothing installed). The core of the script:
for n in A R B; do ip netns add m$n; done ip link add a0 netns mA type veth peer name r0 netns mR ip link add b0 netns mB type veth peer name r1 netns mR ip -n mR link set r1 mtu 1492; ip -n mB link set b0 mtu 1492 # the PPPoE leg # addresses 2001:db8:1::/64 (A-R) and 2001:db8:2::/64 (R-B), forwarding on R ip netns exec mR ip6tables -A OUTPUT -p icmpv6 \ --icmpv6-type packet-too-big -j DROP # the filtering firewall # wg0 in A and B, Endpoint [2001:db8:2::2]:51820, then: ip -n mA link set wg0 mtu 1420 up ip netns exec mA ping -c1 -M do -s 1384 10.9.0.2 # 1412 inner: lost ip netns exec mA ping -c1 -M do -s 1380 10.9.0.2 # 1408 inner: reply ip netns exec mR nstat -az Icmp6OutPktTooBigs Use a fresh set of namespaces for each MTU value. A kernel that has learned a path MTU keeps it in its route cache, so reusing namespaces makes later runs look better than they are.
What I did not measure: real PPPoE framing, routers that clamp TCP MSS (many home routers do, which hides the problem for TCP but not for UDP or QUIC), and IPv4 paths where a middlebox drops fragments. If you have a line where 1412 still stalls, the ping test above will show the real path size. I would like to know the number. You can also paste the config into the checker and compare its MTU line with what you measured.

