DirtyClone

Repository contains three standalone C local privilege escalation exploits for Linux kernel page-cache corruption bugs: dirty_pedit/exploit.c, skb_shift/exploit.c, and gro/exploit.c, each accompanied by a detailed README. The top-level README explains the shared bug class: splice page-cache pages into kernel/network buffers, bypass copy-on-write protections, then modify read-only file contents in memory only. This is a real exploit repository, not a detector. Dirty Pedit targets CVE-2026-46331. It is the simplest and fastest exploit in the repo. The code creates a new user and network namespace, writes uid/gid maps via /proc/self/{uid_map,gid_map,setgroups}, creates a Geneve interface geneve0 over 10.0.0.1:6081, and abuses TC pedit to perform controlled 4-byte writes into page-cache-backed skb fragments. The target is /etc/passwd; the exploit finds a suitable victim line, overwrites 12 bytes with data that yields a passwordless uid 0 account entry in the page cache, then runs su a -c '... /bin/sh'. This provides a root shell without modifying the on-disk file. skb_shift and GRO both target CVE-2026-43503 but use different kernel paths to lose the SKBFL_SHARED_FRAG protection bit before ESP decryption writes into page-cache pages. Both contain a hardcoded AES key/salt, a 256-entry IV lookup table, and a 192-byte ELF stub payload. Their capability is a byte-at-a-time arbitrary page-cache overwrite of readable files, used here to replace the first 192 bytes of /usr/bin/su in memory. The stub then calls setresuid(0), setresgid(0), and execve("/bin/sh"). skb_shift uses loopback networking with ESP-in-TCP. It binds to 10.0.0.1, installs an XFRM SA, rotates through TCP ports 7700-7799, and for each byte computes the needed keystream byte from the current file byte XOR desired stub byte. It then crafts an espintcp record and splices file data into the TCP stream so kernel decryption flips the target byte in page cache. This exploit is described as deterministic. GRO uses a veth pair between namespaces, with addresses 10.200.0.1 and 10.200.0.2, and ESP-in-UDP on port 4500. It relies on GRO coalescing to merge a normal segment and a splice-backed segment while dropping the shared-frag flag. The exploit sets up veth0/veth1, moves one interface into a child network namespace, enables GRO, installs an ESP-in-UDP receiver, and performs repeated byte writes against /usr/bin/su. This variant is probabilistic and may retry writes. Overall, the repository is structured as three self-contained exploit implementations plus documentation. All three are operational LPEs with hardcoded payloads and clear exploitation chains, focused on memory-only corruption of page-cache contents to obtain a root shell.

This repository is a small standalone exploit PoC for CVE-2026-43503 (DirtyClone). It contains three files: an MIT LICENSE, a README describing the vulnerability and usage, and a single Python exploit script, dirtyclone.py, which is the sole code entry point. The exploit is a real local privilege escalation tool, not a detector. Its purpose is to abuse the DirtyClone Linux kernel bug by combining user/network namespaces, xfrm ESP-in-UDP processing, and an iptables TEE rule to corrupt file-backed page cache contents. The script targets /etc/passwd and computes crafted IV values so that in-place decryption transforms existing file cache blocks into attacker-chosen plaintext. The chosen payload inserts a new root-equivalent account named 'firefart' with a hardcoded SHA-512 password hash corresponding to password 'pwned'. Operational flow: the script loads libcrypto.so.3 and libc.so.6 via ctypes; creates new user and network namespaces with unshare(); writes /proc/self/{setgroups,uid_map,gid_map} to establish namespace mappings; configures loopback, xfrm state/policy, and an iptables TEE rule; opens /etc/passwd read-only; repeatedly sends crafted UDP/ESP traffic to 127.0.0.1:4500 while using sendfile() from the passwd file descriptor to trigger the vulnerable kernel path; then checks whether the injected account exists. If successful, it runs 'su' with the hardcoded password to execute 'id' and optionally spawns an interactive /bin/bash shell as root. Repository structure is minimal and focused: README provides context and claims, while dirtyclone.py fully implements the exploit chain in Python without compilation. The exploit includes a basic but complete payload and post-exploitation step, making it operational rather than a bare proof-only trigger.

This repository is a small standalone exploit repo with 2 files: a README describing the DirtyClone Linux kernel local privilege escalation PoC and one Python entry point, dirtyclone.py. The code is a real exploit rather than a detector. It targets CVE-2026-43503, described as a Linux kernel page-cache corruption issue reachable through cloned socket buffers involving the netfilter TEE target and ESP-in-UDP processing. The exploit flow is: create new user and network namespaces with unshare(); configure loopback IPsec/xfrm state and policy plus an iptables TEE rule; open /etc/passwd read-only and derive crafted IVs by AES-decrypting existing file blocks with a fixed key; send ESP-in-UDP traffic over 127.0.0.1:4500 so decrypted data is written into file-backed page cache; thereby replace the beginning of /etc/passwd with a payload that preserves the root line and appends a new UID 0 account named 'firefart' with a hardcoded SHA-512 password hash; then use su to authenticate with password 'pwned', run 'id' as proof, and optionally spawn an interactive /bin/bash shell. Main capabilities: local privilege escalation from unprivileged user to root, page-cache overwrite of /etc/passwd, creation of a persistent root-capable account entry, privilege verification, and interactive shell access. The exploit is operational because it contains a complete hardcoded payload and end-to-end exploitation logic, but it is not part of a larger exploitation framework.

Repository contains a single C proof-of-concept exploit (dirtyclone.c) plus a README. The code is a local privilege escalation tool targeting a Linux kernel/XFRM/IPsec exploit path identified in the source as CVE-2026-43503. Its workflow is: perform pre-flight kernel/architecture checks, create isolated user and network namespaces, configure loopback and XFRM/IPsec state/policy, optionally add a TEE/iptables-assisted forwarding path, build a crafted plaintext containing architecture-specific shellcode, encrypt it with a static AES-CBC key via OpenSSL EVP APIs, deliver it through UDP/ESP or a raw IP fallback to 10.99.0.2:4500, monitor a mapped view of /usr/bin/su for expected byte changes at a fixed offset, and if the page cache appears modified, execute the target SUID binary to gain root. The exploit includes embedded x86_64 and AArch64 shellcode that executes /bin/sh with elevated privileges, cleanup handlers, signal handling, retry logic, and verbose/quiet CLI modes. This is not a framework module; it is a standalone operational PoC with a hardcoded target path, hardcoded AES key, static IP/port values, and a fixed privilege-escalation payload.

Single-file Python proof-of-concept for CVE-2026-43503 ('DirtyClone'), a local Linux kernel privilege-escalation issue involving page-cache manipulation through IPsec in-place decryption and packet cloning. The repository contains one executable script, dirtyclone_poc.py, which serves as the main and only entry point. The script is structured as a DirtyClonePoC class with helper methods for command execution, environment checks, namespace creation, IPsec/XFRM setup, iptables TEE configuration, target-file preparation, exploitation flow, verification, and cleanup. It uses subprocess calls to system tools such as uname, cat, ip, and iptables rather than implementing packet logic directly in Python. Core exploit capability: it attempts to create the kernel conditions needed to trigger the vulnerability by setting up an isolated network namespace, enabling loopback networking, assigning 10.99.0.2/24 to lo, configuring XFRM state/policy for ESP transport mode over 127.0.0.1, and installing an iptables mangle/OUTPUT TEE rule for UDP destination port 4500. This combination is intended to force packet cloning and exercise the vulnerable kernel path. The chosen target for page-cache manipulation defaults to /usr/bin/su, indicating the intended privilege-escalation objective. The visible code does not include a full post-trigger payload such as shell spawning, credential overwrite, or direct binary patch logic; instead it behaves as a demonstrative PoC that reports whether the vulnerability may have been triggered and states that a real exploit would modify page cache to allow privilege escalation. Because of that, the maturity is best classified as POC rather than operational weaponization. Notable fingerprintable artifacts include the namespace name dirtyclone_test, namespace path /var/run/netns/dirtyclone_test, kernel tunable /proc/sys/kernel/unprivileged_userns_clone, target binary /usr/bin/su, fallback file /tmp/vuln_test, loopback/XFRM endpoint 127.0.0.1, namespace IP 10.99.0.2, and UDP port 4500. Overall, this repository is a local kernel exploit PoC focused on reproducing vulnerability conditions rather than delivering a polished privilege-escalation payload.

This repository is a small standalone local privilege escalation exploit PoC for CVE-2026-43503 ('DirtyClone'). It contains two files: a README describing the vulnerability and affected Linux kernel versions, and a single Python exploit script, dirtyclone.py, which is the main entry point. The exploit is clearly intended for local execution on Linux, not remote exploitation. Its overall flow is: create a new user and network namespace, map the current user to UID/GID 0 inside the namespace, configure loopback networking, prepare XFRM/IPsec-related state, and then trigger a kernel memory corruption condition associated with clone/namespace handling. The script indicates use of kernel attack primitives to obtain an arbitrary write and overwrite credentials or otherwise hijack execution to gain root. Notable capabilities visible in the code include: - Namespace setup via unshare() using CLONE_NEWUSER and CLONE_NEWNET. - Writes to /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map to establish namespace privileges. - Loopback configuration using the ip command and assignment of 10.99.0.2/24 to lo. - Use of AF_ALG and XFRM/IPsec-related constants, suggesting the exploit abuses kernel crypto/IPsec plumbing as part of heap shaping or trigger logic. - A hardcoded target SUID binary (/usr/bin/su) and offset constant, implying a file overwrite or code-stomping stage against a privileged executable. - Embedded x86_64 shellcode that calls setgid(0), setuid(0), and execve('/bin/sh'). - Fallback/interactive root shell behavior via /bin/bash when already privileged. The repository appears to be more than a detector: it contains operational exploit logic and a real payload. Based on the visible code, it is best classified as an OPERATIONAL PoC rather than a framework-integrated or highly modular weaponized exploit. The script includes environment checks, troubleshooting guidance, and local system manipulation consistent with a practical LPE exploit.

Repository contains a single C proof-of-concept exploit and a README describing the vulnerability. The exploit targets CVE-2026-43503 ('DirtyClone'), a Linux kernel local privilege escalation bug in networking/SKB fragment handling. The code is a standalone local exploit, not part of a framework. Structure: README.md provides vulnerability background, impact, and fixed kernel versions. CVE-2026-43503.c is the operational exploit entry point. It creates new user and network namespaces, writes /proc/self/{setgroups,uid_map,gid_map}, and brings up the loopback interface. It then interacts with the kernel XFRM/IPsec subsystem over NETLINK_XFRM, creating many security associations whose SPI/sequence-related values are derived from an embedded 192-byte ELF payload. The exploit appears to use a page-cache corruption/write primitive against /usr/bin/su, writing the payload in 4-byte chunks. After the corruption stage, it verifies expected bytes at a fixed entry offset and, on success, executes /usr/bin/su -c /bin/sh to obtain a root shell. Main capability: local privilege escalation to root by modifying the page cache of a root-owned executable (/usr/bin/su) and then invoking it. The payload is embedded and hardcoded rather than user-configurable, so the exploit is best classified as OPERATIONAL rather than weaponized. No external C2 or remote network infrastructure is present; all networking activity is local to the host, primarily loopback and kernel netlink/XFRM interactions.

This repository is a compact two-file local privilege escalation PoC for CVE-2026-43503 (DirtyClone). The main code is in CVE-2026-43503.py, with README.md providing a short vulnerability description, usage example, and prerequisites. The exploit is not part of a larger framework. The Python script targets a Linux kernel flaw involving cloned sk_buff handling during ESP-in-UDP processing. It creates new user and network namespaces with unshare(), configures loopback XFRM/IPsec state and policy using ip xfrm, and installs an iptables TEE rule to clone outbound UDP/4500 traffic toward 127.0.0.2. It then opens /etc/passwd read-only, derives crafted IVs using AES decryption with a static 16-byte key, and sends specially formed ESP-in-UDP packets over 127.0.0.1:4500 so that in-place decryption corrupts file-backed page-cache memory. The intended corruption replaces the beginning of /etc/passwd in cache with a new root-level account entry. The hardcoded payload injects account 'firefart' with password 'pwned' and a preset SHA-512 hash, preserving the original root line and appending a second UID 0 entry. After the overwrite attempt, the script checks whether the account is visible through the system password database, runs 'su' with the known password to execute 'id', and if successful offers an interactive root shell via /bin/bash on a PTY. Capabilities include: local kernel exploitation, namespace setup, XFRM/IPsec and iptables manipulation, page-cache-only modification of /etc/passwd, creation of a usable UID 0 account, privilege verification, and interactive root shell access. There are no external internet endpoints; all network activity is local loopback traffic using 127.0.0.1/127.0.0.2 and UDP port 4500.