Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
उपकरण/GitHubGitHub/01luyicheng/cve-2026-99999
Memory ForensicsVulnerability AnalysisExploitationNetwork SecurityLearning & Education
GitHub01luyicheng/cve-2026-99999

CVE-2026-99999

Simulation-only proof of concept for CVE-2026-99999, a Linux kernel virtio-net IPv4 csum_start validation bug enabling guest-to-host heap memory disclosure.

रिपॉजिटरी देखें
51411 दिन पहलेअभी तक समीक्षित नहीं
साझा करें
अनुरोधित भाषा में सामग्री उपलब्ध नहीं है। अंग्रेज़ी संस्करण दिखाया जा रहा है।

CVE-2026-99999 (PwnEscape) — Linux Kernel IPv4 csum_start Validation Bug PoC

Linux kernel IPv4 header corruption via malformed virtio-net checksum metadata.
CVSS 9.3 CRITICAL | CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Discovered by Paulos | CNA: kernel.org | Published: 2026-10-15

⚠️ This is an educational / validation PoC. It runs in --simulate mode only (no network I/O, no root required). It demonstrates the attack chain locally without exploiting any live system.


Table of Contents

  1. Vulnerability Summary
  2. Technical Details
  3. Affected Versions
  4. Quick Start
  5. Options
  6. How It Works
  7. Attack Scenarios
  8. Code Review
  9. Mitigation
  10. References
  11. Legal Disclaimer

Vulnerability Summary

A frame injected through TUN/TAP (or sent by a guest over virtio-net) carries a virtio_net_hdr whose csum_start is an offset from the start of the frame. The ingress check (__virtio_net_hdr_to_skb()) only requires skb_transport_offset >= 20, so a value that does not point at the transport header is still accepted. After VLAN decapsulation the skb->data pointer moves forward while the stored csum_start does not, so the offset is re-interpreted against a different base.

In the IPv4 output path, skb_checksum_help() sums the data from csum_start to the end, folds it, and writes the 16-bit result back to csum_start + csum_offset. With a two-VLAN frame (csum_start = 22) that write lands on IPv4 bytes 0–1: byte 0 becomes the folded checksum's high byte and, when it is 0x4F, IHL becomes 15 (60 bytes).

ip_do_fragment() then copies a 60-byte header. On the measured geometry (skb_headlen = 28) that reads 32 bytes past the linear region — but in our runs those bytes were zero, so no host memory was disclosed.

Impact (verified): attacker-influenced IPv4 header length in forwarded fragments (demonstrated value: 0x4F, IHL=15; other values require re-tuning the payload) plus a 40-byte IP-payload shift, with a valid IP checksum. Not verified: guest-to-host memory disclosure or escape.

Attack surface: KVM/QEMU hosts with virtio-net or TAP devices that feed frames into an IPv4 forwarding path, where checksum completion happens in software on the egress device.


Technical Details

IP Header Byte Layout (RFC 791)

OffsetFieldcsum_offset=0 corruptscsum_offset=6 corrupts
0Version + IHL✅ IHL byte
1TOS
2–3Total Length
4–5Identification
6–7Flags / Fragment Offset✅ Flags/FragOffset (lo)
8TTL
9Protocol
10–11Header Checksum
12–15Source IP
16–19Destination IP

Note: with csum_offset=0 the kernel overwrites IP bytes 0–1, so byte 0 becomes the high byte of the folded checksum (byte 1 becomes TOS). IHL is therefore written[0] & 0x0F; it only reaches 15 when that byte is 0x4F, which depends on the payload. The target offset is frame-relative: 0 and 14 (single Ethernet) are rejected at ingress because skb_transport_offset < 20.

Attack Chain

Guest VM / TAP injection
  → constructs virtio_net_hdr with csum_start=22 on a two-VLAN frame
    (14, the real IPv4 start with one Ethernet header, is rejected: < 20)
  → sends frame through virtio-net / TAP to the host
Host kernel (IPv4 egress fragmentation, not GSO)
  → VLAN tags are stripped: skb->data advances 22 bytes, csum_start does not
  → skb_checksum_help() writes the folded checksum to csum_start + csum_offset
  → offset 0: writes IP bytes 0–1 (IHL) → 0x4F means IHL=15 in our runs
  → offset 6: would write Flags/FragOffset (not verified)
  → ip_do_fragment() copies hlen=60 from a 28-byte linear region
  → 32 bytes past skb_headlen are read; they were 0 in our runs

Two Corruption Paths

csum_offsetCorrupted FieldConsequenceStatus
0 (default)IP bytes 0–1 (IHL + TOS)Measured: IHL 5→15, 40-byte IP-payload shift; logical read of 32B past skb_headlen (content 0)✅ reproduced
6Flags/FragOffset (offset 6)Fragment reassembly metadata corruption🟡 hypothesis, unverified

Affected Versions

Introduced by f43798c27684 (2008, v2.6.27). Affected: 2.6.27 ≤ version < the matched fixed release below.

Fixed: 5.10.272+, 5.15.223+, 6.1.190+, 6.6.159+, 6.12.113+, 6.18.57+, 7.2.11+, 7.3

Check your kernel version:

uname -r
cat /proc/version

Quick Start

Requirements: Python 3.6+ only. No pip packages, no network, no root.

# Clone
git clone https://github.com/01luyicheng/CVE-2026-99999.git
cd CVE-2026-99999

# Run — IHL corruption simulation (educational model, default)
python3 CVE-2026-99999_pwnescape.py --simulate

# Simulate with 5 datagrams and 8 fragments each
python3 CVE-2026-99999_pwnescape.py --simulate -n 5 -f 8

# Flags/FragOffset corruption path (unverified hypothesis)
python3 CVE-2026-99999_pwnescape.py --simulate -c 6

Without --simulate, the script prints the full vulnerability description and exits:

python3 CVE-2026-99999_pwnescape.py

Options

FlagDescriptionDefault
--simulateRun exploit chain simulation (required)—
-c, --csum-offset0 = IP bytes 0–1 (IHL, default); 6 = Flags/FragOffset (hypothesis)0
-n, --num-packetsNumber of datagrams to simulate3
-f, --fragmentsFragments per datagram (minimum 2)4

How It Works

The simulation runs in 5 steps (no network required):

  1. Step 1 — Build packet: Constructs Ethernet + VLAN 1 + VLAN 2 + IPv4 + UDP (IPv4 starts at frame offset 22).
  2. Step 2 — Attach malicious virtio_net_hdr: Adds a virtio_net_hdr with csum_start=22 and configurable csum_offset. Values below 20 are refused, mirroring the ingress guard.
  3. Step 3 — Simulate skb_checksum_help() corruption: Computes the real folded checksum over [csum_start, end] and writes it to csum_start + csum_offset, printing the actual bytes and the resulting IHL.
  4. Step 4 — Show fragment impact: Rebuilds each fragment header with hlen = IHL*4 and shows which field is affected.
  5. Step 5 — Output results: Prints fragment sizes and a geometry disclaimer: with a short packet hlen can equal the whole IP packet, so no out-of-bounds read occurs; the measured OOB case needs a long paged payload (skb_headlen = 28).

Attack Scenarios

Scenario A: IHL Corruption → Header/Fragment Corruption (verified on v100)

python3 CVE-2026-99999_pwnescape.py --simulate -n 1 -c 0

csum_start=22, csum_offset=0 → write lands on IP bytes 0–1 → IHL 5→15 when byte 0 is 0x4F → ip_do_fragment() copies 60 bytes from a 28-byte linear region and shifts the payload by 40 bytes. The 32 bytes read past the linear region were zero in the measured runs, so this is header corruption, not a demonstrated memory leak.

Scenario B: Flags/FragOffset Corruption → Reassembly Disruption (unverified)

python3 CVE-2026-99999_pwnescape.py --simulate -n 1 -c 6

csum_start=22, csum_offset=6 → would write Flags/FragOffset byte → fragment reassembly metadata corrupted. This path has not been executed against a live kernel.


Validation & Code Review

The simulator has been reviewed internally (code quality only). Key findings:

टूल डाउनलोड करें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

अभी तक कोई लोकप्रियता डेटा नहीं है।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →