Re: [PATCH net] net/sched: act_csum: bound the IPv6 jumbo payload length

From: Piyus Kedia

Date: Tue Nov 17 2026 - 13:00:25 EST


Hello,

# Revised Impact Assessment: A Kernel Memory Read Primitive

We need to correct our earlier assessment of this vulnerability. Our
first report classified it as an availability issue; the second
described it as a 16-bit oracle. Both understated its impact. We have
now demonstrated a working, byte-exact kernel memory read primitive. A
single packet can disclose 14 contiguous bytes of out-of-bounds kernel
memory at an attacker-selected offset. The mechanism and its limitations
are described below.

## 1. The root cause: An unchecked IPv6 Jumbo Payload length

IPv6 normally uses a 16-bit payload length field, which supports
payloads up to 65,535 bytes. For larger packets, RFC 2675 defines a
Jumbo Payload option in the hop-by-hop header. In this case, the 16-bit
field is set to zero and the actual length is specified in a 32-bit
field.

Our packet exploits this mechanism by declaring a payload length of
4,294,967,250 bytes, despite carrying only 56 bytes (70 bytes including
Ethernet). The packet is structurally valid, but its declared length is
inconsistent with its actual size.

In `act_csum`, `tcf_csum_ipv6()` reads the Jumbo Payload option and uses
its value as the IPv6 payload length. This value is then passed to the
UDP-Lite checksum handler without validating it against the actual
packet size. This is the root cause: **a packet-controlled length is
trusted without being checked against the available packet data.**

## 2. Why the existing checks fail

Three checks are intended to protect the checksum operation, but none of
the checks catches this condition.

- **Packet bounds check:** `pskb_may_pull()` receives a length
calculation that overflows a 32-bit integer. Instead of checking for
more than four billion bytes, it effectively checks for just 8 bytes.
- **Header length check:** The declared length is larger than the header
length, so this check passes.
- **Checksum coverage check:** The UDP-Lite coverage is compared against
the inflated payload length and is therefore accepted.

Consequently, `csum_partial()` is asked to read 200 bytes starting at
the UDP header, even though the packet is only 70 bytes long. This
results in an out-of-bounds read beyond the 704-byte `skbuff_small_head`
object. Importantly, a large UDP-Lite coverage value alone is not
sufficient to trigger the issue. The oversized Jumbo Payload declaration
is what bypasses the bounds checks.

## 3. Turning the checksum into a memory read

A checksum by itself does not reveal memory contents. `csum_partial()`
returns a 16-bit sum, which provides very limited information about the
bytes it processes. However, the Internet checksum is linear. By
obtaining two checksums with coverage lengths differing by two bytes, we
can subtract the results and recover the intervening 16-bit word.
Repeating this process allows individual words to be recovered.

We verified the arithmetic against known memory contents, recovering all
131 test words without error.

## 4. Why the read requires a single packet

Our earlier attempts used two separate packets to obtain the two
checksums. This did not work reliably because each packet gets a new
socket buffer allocation, and the memory contents change between
allocations. The solution is to obtain both checksums during a single
`tc` filter execution, using multiple actions on the same packet:

- Compute the checksum.
- Mirror the packet to capture the result.
- Adjust the UDP-Lite coverage.
- Compute the next checksum and mirror it again.

This allows multiple checksum observations of the same memory region
without allocating a new packet buffer between observations. The
kernel's action limit restricts how many observations can be collected.
We reliably obtained eight checksums, allowing us to recover seven
consecutive 16-bit words, or 14 bytes, from one packet.

## 5. What we have demonstrated

The following results were obtained using an unprivileged user (UID
1000) inside a user namespace with `CAP_NET_ADMIN`. The kernel heap
itself is not namespaced.

| Test | Result |
|---|---|
| Recovery against known memory | 131/131 words correct |
| Consecutive words from one packet | 7/7 words recovered exactly |
| Out-of-bounds reads at coverage 1024, 4096 and 16384 | Non-zero, varying memory contents |
| KASAN validation | Confirmed slab out-of-bounds read in `csum_partial()` |

The demonstrated capability is:

**An unprivileged, repeatable, byte-exact read of 14 contiguous bytes of
kernel memory per packet, at an attacker-selected offset within the 64
KB reachable region beyond a 704-byte slab object.**

## 6. Limitations: Can multiple reads be combined?

We have not demonstrated that reads from separate packets can be
combined into a larger, contiguous memory image. Our experiments showed
that successive packets did not reliably access the same memory
locations. Even overlapping read windows produced no matching words in
the tested configuration. This is significant because it means we cannot
claim that sending approximately 4,682 packets would recover 64 KB of
kernel memory.

However, these experiments were conducted on a debug kernel configured
with KASAN, KFENCE, SLUB_DEBUG and memory initialization options. These
features alter allocator behaviour and can significantly affect memory
reuse. We have not yet repeated the experiments on a production-
configured kernel. Therefore, the inability to combine reads should be
treated as an unverified limitation, not a demonstrated property of the
vulnerability.

## 7. Conclusion and disclosure status

The impact assessment should be based on what we have demonstrated,
rather than what we suspect may be possible.

We have established a repeatable, byte-exact kernel memory disclosure
primitive that works without root privileges, within the stated user-
namespace configuration.

We have not established whether successive reads can be combined to
reconstruct larger regions of kernel memory.

We are holding back the detailed reproduction procedure and programs
until the fix is merged. The patch has already been submitted upstream:

- **v1:** https://lore.kernel.org/all/20261112075445.3555341-1-piyus@xxxxxxxxxxx/
- **v2:** https://lore.kernel.org/all/20261116182108.2581258-2-piyus@xxxxxxxxxxx/

Version 2 contains the same patch as version 1, with an expanded
changelog.

Thanks and regards,
Kapil Vaswani
Piyus Kedia