Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-74583 — Write-up, KASAN reproducer, and A/B test runner for CVE-2026-74583, a race-condition use-after-free in the Linux route4 traffic classifier enabling local privilege escalation. | Kitploit
Tools/GitHubGitHub/santoshkalluri/cve-2026-74583
Privilege EscalationMemory ForensicsVulnerability AnalysisExploitationFuzzingPapers & ResearchLabs & Practice
GitHub
Share
santoshkalluri/cve-2026-74583

CVE-2026-74583

Write-up, KASAN reproducer, and A/B test runner for CVE-2026-74583, a race-condition use-after-free in the Linux route4 traffic classifier enabling local privilege escalation.

View Repository
617 days agoNot yet reviewed

CVE-2026-74583: use-after-free in Linux route4 classifier

A race-condition use-after-free in the Linux kernel's route4 traffic classifier (net/sched/cls_route.c). When a filter was deleted while packets were being classified, the kernel could keep a pointer to the filter in a small cache and read it after the filter was freed. A normal local user can trigger it, and it can be used for local privilege escalation to root.

The bug dates back to v3.18 (2014). It was fixed in Linux 7.2 and backported to the stable kernels. This repository has a write-up, a KASAN reproducer, and the test logs.

CVECVE-2026-74583
Wherenet/sched/cls_route.c, route4_classify() and route4_set_fastmap()
Bug typeUse-after-free caused by a race between packet classification and filter deletion
Added inv3.18, commit 1109c00547fc ("net: sched: RCU cls_route", 2014)
Fixed inv7.2, commit 47d7f7051253
Who can trigger itA normal local user, on systems that allow unprivileged user namespaces
ImpactLocal privilege escalation to root (exploit not published)
CVSS 3.17.8 (High), from the CVE record: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Found bySantosh Kalluri

In short

  • route4 keeps a 16-slot cache (the "fastmap") of recently used filters.
  • When a filter is deleted, the kernel clears the cache and frees the filter later, after an RCU grace period.
  • A packet that was being classified at the same moment can put the deleted filter back into the cache, right after it was cleared.
  • Once the filter is freed, the next matching packet reads it from the cache. That is a read of freed memory.

What went wrong

The reader, route4_classify(), walks the filter list under RCU. When it finds a matching filter, it stores that filter in the fastmap with route4_set_fastmap(), so the next packet can skip the search. The writer, route4_delete() (and route4_change() when it replaces a filter), unlinks the filter, clears the fastmap with route4_reset_fastmap(), and queues the filter to be freed after an RCU grace period.

Clearing the cache before the free is not enough. This order of events breaks it:

  1. The reader walks the list and finds filter f.
  2. The writer unlinks f, clears the fastmap, and queues f to be freed.
  3. The reader calls route4_set_fastmap() and stores f in the fastmap, after the clear.
  4. The grace period ends and f is freed.
  5. The next packet with the same route id and input interface hits the stale fastmap entry and reads f->res from freed memory.

The fastmap stores raw filter pointers. Clearing it once does not stop a reader that already holds a pointer from storing it again, so step 3 undoes step 2.

The fix

The fix adds a dying flag to each filter. The writer sets it under the existing fastmap_lock when it removes the filter, and the reader no longer stores a filter in the fastmap once it is marked as dying. Because both sides use the same lock, either the reader stores first and the writer's clear removes the entry, or the writer marks first and the reader skips the store.

The fix was written by Jamal Hadi Salim, based on a design suggested by Paolo Abeni.

How the reproducer triggers it

The reproducer runs as a normal user. It creates its own user and network namespace, which gives it CAP_NET_ADMIN inside that namespace only. Inside it, it:

  1. creates dummy network devices, an HTB queue, and route4 filters;
  2. sends packets that are classified by route4, on several CPUs at once;
  3. deletes and re-adds a filter at the same time.

The race window is very short. To make it easier to hit, the reproducer uses a known timer and epoll technique from published research (ExpRace, USENIX Security 2021) to briefly stall a CPU at the right moment. It needs no kernel changes, debug options, or root.

It only triggers the bug. It does not try to exploit it. In the test setup a normal user cannot read the kernel log, so the reproducer only reports that it saw the race. The runner below checks the kernel log for the KASAN report.

What the bug can do

On a KASAN kernel, the read of the freed filter is reported as a slab use-after-free in route4_classify(). The 16 bytes read are f->res, the filter's classification result, which the kernel then uses to pick a traffic class for the packet.

This bug can be used for local privilege escalation to root. I wrote a working exploit, but it is not included in this repository.

Limits:

  • Unprivileged user namespaces must be allowed. Without them, a normal user cannot create the filters, and the bug needs CAP_NET_ADMIN.
  • route4 and HTB must be available (CONFIG_NET_CLS_ROUTE4, CONFIG_NET_SCH_HTB). Many distributions build them as modules that load on demand.
  • It is a race. It needs several CPUs. The reproducer expects at least 4.

Affected versions

The bug exists from v3.18 up to the fixed versions below. These match the official CVE record.

BranchFirst fixed version
mainline7.2
7.1.y7.1.9
6.18.y6.18.45
6.12.y6.12.104
6.6.y6.6.152
6.1.y6.1.183
5.15.y5.15.216
5.10.y5.10.265

Quick way to check a kernel source tree: look for a dying field in struct route4_filter in net/sched/cls_route.c. If it is there, the tree is fixed.

Reproducing it

Use throwaway VMs. On a vulnerable KASAN kernel the reproducer produces a use-after-free report.

  1. Build Linux v7.2-rc2 (commit 8cdeaa50eae8) with configs/kasan.config. This is the vulnerable kernel.
  2. Apply the fix commit 47d7f7051253 to the same source and build again with the same config. This is the fixed kernel.
  3. Build the reproducer:
    make
    
  4. Prepare a raw x86-64 disk image that boots as /dev/vda, allows root SSH with a test key, and allows unprivileged user namespaces.
  5. Run both kernels with the runner:
    python3 run_kasan_ab.py \
      --vulnerable-kernel vuln/arch/x86/boot/bzImage --vulnerable-vmlinux vuln/vmlinux \
      --patched-kernel fixed/arch/x86/boot/bzImage --patched-vmlinux fixed/vmlinux \
      --vulnerable-source vuln-src --patched-source fixed-src \
      --image test.img --private-key test-key --public-key test-key.pub \
      --reproducer artifacts/route4_kasan_repro --seconds 180 --output results/my-run
    

For each kernel, the runner boots a fresh QEMU/KVM snapshot (4 vCPUs, 4 GiB RAM) and creates a new normal user with no capabilities. It runs the reproducer as that user for up to 180 seconds. It only counts a result if the KASAN report names route4_classify, allocation in route4_change, the free in route4_delete_filter_work, and that user's UID. Other crashes or warnings do not count. A run with no report does not prove a kernel is safe.

make test runs the runner's unit tests.

Results

Run on 2026-11-01 with the exact binary in artifacts/. QEMU/KVM, 4 vCPUs, AMD x86-64 host. The reproducer ran as normal user UID 23456.

TrialVulnerable kernelFixed kernelResult
1KASAN use-after-free (9,545 attempts in 180 s)no KASAN (55,015 attempts in 180 s)PASS
2KASAN use-after-free (2,127 attempts in 180 s)no KASAN (58,555 attempts in 180 s)PASS

Earlier runs in August and November 2026 with an earlier version of the reproducer gave the same result.

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    867
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    544
  • 3

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    385
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    360
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    302
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    279

Explore all tools

Browse our collection of tools

View all tools →