#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0
'''Test possible UDP length overflow in udp_send_skb/udp_v6_send_skb.'''
import errno
import gzip
import os
import socket
import struct
import subprocess
from contextlib import contextmanager
from lib.py import (
KsftNamedVariant,
KsftSkipEx,
NetNS,
NetNSEnter,
defer,
ip,
ksft_eq,
ksft_exit,
ksft_pr,
ksft_raises,
ksft_run,
ksft_true,
ksft_variants,
)
IP_MTU_DISCOVER = 10
IP_PMTUDISC_PROBE = 3
IPV6_MTU_DISCOVER = 23
IPV6_PMTUDISC_DO = 2
IPV6_PMTUDISC_PROBE = 3
IPV6_TLV_JUMBO = 194
def check_kernel_config(option: str) -> bool | None:
'''
Check whether the option is enabled in the config of the running kernel.
Returns None if the config is not found; otherwise returns True/False
depending on the option value in the config.
'''
for filename, method in [
('/proc/config.gz', gzip.open),
(f'/boot/config-{os.uname().release}', open),
]:
try:
with method(filename, 'rt') as config:
for line in config:
if line.rstrip() == f'{option}=y':
return True
return False
except OSError:
continue
return None
def assert_debug_kernel() -> None:
'''
Skip the test if CONFIG_DEBUG_NET is not set in the kernel config.
'''
res = check_kernel_config('CONFIG_DEBUG_NET')
if res is None:
ksft_pr("WARN: Can't read kernel config; assuming debug kernel, and running the test")
elif not res:
raise KsftSkipEx('CONFIG_DEBUG_NET is not set')
def check_dmesg_clean(func: str) -> bool:
'''
Check if the given function produced a WARN in dmesg. Returns True if dmesg
is clean, i.e. doesn't contain traces of a WARNING in the given function.
'''
with subprocess.Popen(['dmesg'], stdout=subprocess.PIPE) as dmesg:
res = subprocess.run(['grep', '-q', f'WARNING:.*{func}'], stdin=dmesg.stdout, check=False)
return res.returncode != 0 and dmesg.returncode == 0
@contextmanager
def dummy_netdev(ns: NetNS, mtu: int, ipv6: bool) -> None:
'''
Create a dummy netdev inside the given namespace, and tune it for the test.
'''
ip('link add dummy type dummy', ns=ns)
with defer(ip, 'link del dummy', ns=ns):
ip(f'link set dummy mtu {mtu}', ns=ns)
ip('link set dummy up', ns=ns)
flag = '-6' if ipv6 else ''
nodad = 'nodad' if ipv6 else ''
local = 'fd00::1/64' if ipv6 else '10.0.0.1/24'
remote = 'fd00::2' if ipv6 else '10.0.0.2'
ip(f'{flag} addr add {local} dev dummy {nodad}', ns=ns)
ip(f'{flag} neigh add {remote} lladdr 02:00:00:00:00:02 dev dummy nud permanent', ns=ns)
yield
@ksft_variants([
KsftNamedVariant(
'ipv6',
True,
socket.AF_INET6,
(socket.IPPROTO_IPV6, IPV6_MTU_DISCOVER, IPV6_PMTUDISC_DO),
'fd00::2',
'udp_v6_send_skb',
),
KsftNamedVariant(
'ipv4',
False,
socket.AF_INET,
(socket.IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_PROBE),
'10.0.0.2',
'udp_send_skb',
),
])
def test_udp(
ipv6: bool,
af: socket.AddressFamily,
sockopts: tuple[int, int, int],
destip: str,
func: str
) -> None:
'''
Test that sending an oversized UDP packet over a UDP socket doesn't overflow
the 16-bit length field in the UDP header, which could happen on older
kernels in udp_send_skb/udp_v6_send_skb.
IPv4: The packet will be dropped with EMSGSIZE, but the overflow could
happen before it happens. The only way to test this is to check dmesg on
CONFIG_DEBUG_NET=y kernels that have udp_set_len_short with the warning.
IPv6: The packet will be dropped with EMSGSIZE on fixed kernels, and will be
sent corrupted on older kernels. Test both: sendto must return EMSGSIZE, and
dmesg must be clean of warnings on CONFIG_DEBUG_NET=y kernels.
'''
if not ipv6:
assert_debug_kernel()
with (
NetNS() as ns,
dummy_netdev(ns, 65556 + 20 * ipv6, ipv6),
NetNSEnter(ns),
socket.socket(af, socket.SOCK_DGRAM) as fd,
):
fd.setsockopt(*sockopts)
with ksft_raises(OSError) as e:
fd.sendto(b' ' * 65528, (destip, 1234))
# IPv6: EMSGSIZE happens on kernels with the fix.
# IPv4: EMSGSIZE happens on both fixed and unfixed kernels, after the
# WARN is printed - ignore it and rely on the dmesg check.
if e.exception is not None:
ksft_eq(e.exception.errno, errno.EMSGSIZE)
ksft_true(check_dmesg_clean(func), 'WARNING detected in dmesg')
def test_ipv6_jumbo() -> None:
'''
Test that sending UDP jumbograms over a raw IPv6 socket works, despite
having the fix for oversized UDP packets. sendto must not raise an OSError
exception (when raised, the test fails automatically).
'''
with (
NetNS() as ns,
dummy_netdev(ns, 65584, True),
NetNSEnter(ns),
socket.socket(socket.AF_INET6, socket.SOCK_RAW, socket.IPPROTO_UDP) as fd,
):
hopopts = struct.pack('!BBBBI', 0, 0, IPV6_TLV_JUMBO, 4, 65544)
fd.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_HOPOPTS, hopopts)
fd.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_CHECKSUM, 6)
fd.setsockopt(socket.IPPROTO_IPV6, IPV6_MTU_DISCOVER, IPV6_PMTUDISC_PROBE)
udp = struct.pack('!HHHH', 1234, 1234, 0, 0) + b' ' * 65528
fd.sendto(udp, ('fd00::2', 0))
if __name__ == "__main__":
ksft_run([
test_udp,
test_ipv6_jumbo,
])
ksft_exit()