Skip to main content
Mallory
HighPublic exploitVulnerability

CVE-2026-43284: Dirty Frag: Linux xfrm/ESP Shared-Page Corruption

Published May 8, 2026 · Updated 1 day ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days23 mentions · peak 9 in a dayToday
CVSS7.8High · v3.1
EPSS99.2%100th percentile
CISA KEVNoNot listed
In the wildReported17 exploitation records in Mallory
Vendor
Linux
IdentifiersCVE-2026-43284CWE-668
Also known asdirtyfrag

CVE-2026-43284 is a local privilege-escalation vulnerability in the Linux kernel's xfrm/ESP input processing, associated with the Dirty Frag vulnerabilities. IPv4 and IPv6 datagram append paths fail to set SKBFL_SHARED_FRAG when MSG_SPLICE_PAGES attaches shared pipe pages to UDP socket buffers. An ESP-in-UDP packet constructed from these pages can consequently appear to be an ordinary uncloned nonlinear skb without a frag_list. ESP input then takes its no-copy-on-write fast path and decrypts directly into externally backed pages that the skb does not privately own. This permits unintended modification of shared memory, including page-cache data, potentially enabling elevation to root. CVE-2026-43500 is a separate RxRPC vulnerability also associated with Dirty Frag.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

A low-privileged local attacker can corrupt shared page-cache data, potentially overwrite privileged executable content, execute code with root privileges, and compromise system confidentiality and integrity. Shared-memory corruption can also cause denial of service. Privilege-escalation attempts from compromised web-service accounts have been observed, although success was not consistently established. Container-to-host impact depends on access to the vulnerable kernel functionality and deployment-specific isolation; hypervisor escape is not established by this vulnerability alone.

Mitigation

If you can’t patch tonight, do this now.

Where operationally feasible, disable the esp4 and esp6 kernel modules and prevent their automatic loading; reboot or otherwise verify that vulnerable modules are no longer active. Disabling rxrpc additionally addresses the separate RxRPC component of Dirty Frag. Restrict unprivileged user and network namespace creation where supported to reduce namespace-based access to vulnerable networking functionality, but do not treat this as a universal substitute for patching. Limit untrusted local execution and shell access, and avoid granting unnecessary network-administration capabilities to containers.

Remediation

Patch, then assume compromise.

Install the operating-system or appliance vendor's kernel or firmware update addressing CVE-2026-43284, and reboot into the corrected kernel where required. The kernel fix marks spliced IPv4/IPv6 datagram fragments with SKBFL_SHARED_FRAG and makes ESP input call skb_cow_data() when that flag is present, ensuring that decryption operates on privately owned data. Verify the vendor's fixed package or backport status rather than relying solely on the upstream kernel version. Also assess CVE-2026-43500 separately where RxRPC is available.

Public exploits

Exploits

32 exploits validated by Mallory's analysis. Hidden: 40 rejected by Mallory's analysis as not a working exploit; 5 not yet analyzed, such as Exploit-DB entries. Showing the 25 most capable, earliest first.

View more in app →
Copy-Fail-CVE-2026-31431-dirty-frag-CVE-2026-43284This repository is a small Linux local privilege escalation exploit set combining two kernel issues: Copy-Fail (CVE-2026-31431) and Dirty-frag (CVE-2026-43284). It contains three files: a README with build/run instructions and tested distributions, a compact Python proof-of-concept, and a much larger C exploit implementing more complete exploitation logic. The Python script is a concise local exploit for Copy-Fail. It opens /usr/bin/su read-only, creates an AF_ALG crypto socket bound to the AEAD algorithm string authencesn(hmac(sha256),cbc(aes)), uses setsockopt/sendmsg/splice to drive kernel crypto scatterlist handling, and writes attacker-controlled bytes into the page cache of the read-only SUID binary in 4-byte chunks. After patching, it invokes su to execute the modified privileged binary. The C program is the main operational exploit. It embeds a 192-byte x86_64 ELF payload that becomes a root shell by calling setgid(0), setuid(0), setgroups(0,NULL), and execve(/bin/sh). It targets /usr/bin/su and appears to support multiple exploitation paths: a su-focused path and an rxrpc/dirty-frag path, with command-line switches --force-esp and --force-rxrpc. The visible code shows namespace setup via unshare(CLONE_NEWUSER|CLONE_NEWNET), writes to /proc/self/{setgroups,uid_map,gid_map}, loopback interface manipulation, and constants for UDP encapsulation/IPsec-related behavior including port 4500, indicating a network-kernel attack surface even though exploitation is local. The main function retries alternate paths until a target binary is patched, then spawns an interactive PTY-backed root shell. Overall, this is a real exploit repository rather than a detector. Its purpose is to obtain local root on vulnerable Linux systems by corrupting privileged executables through vulnerable kernel code paths reachable from userspace syscalls. The Python file is a compact PoC; the C file is the more featureful exploit with built-in payload and fallback logic.6abc · Disclosed May 5, 2026 · markdown · python · local · networkOperationalDirty-Frag-Kubernetes-PoCThis repository is a real exploit PoC for CVE-2026-43284 ('Dirty Frag') adapted to a Kubernetes/EKS container-escape scenario. The main exploit is exploit/dirtyfrag.c, a static C program that unshares into new user and network namespaces, configures UID/GID mappings via /proc/self/*, brings up loopback, registers crafted xfrm Security Associations over NETLINK_XFRM, and uses ESP-in-UDP traffic to 127.0.0.1:4500 together with splice/vmsplice mechanics to corrupt page-cache contents of read-only binaries. Its default targets are /usr/sbin/ipset, /usr/sbin/xtables-legacy-multi, /usr/sbin/xtables-nft-multi, and /usr/sbin/nft—binaries likely present in shared image layers used by privileged Kubernetes components such as kube-proxy. The exploit does not directly spawn a shell. Instead, it embeds a second-stage static ELF payload generated from payload/payload-eks.c. That payload is written into the page cache of the target binaries so that when a privileged DaemonSet later executes one of them, the payload runs with elevated privileges. The included payload is a validation payload: it mounts likely EKS host root devices (/dev/nvme0n1p1, /dev/nvme0n1p2, /dev/xvda1) using xfs/ext4 and writes '[*] success' to /mnt/root/res, which corresponds to /root/res on the host. Repository structure supports building and demonstrating the PoC in EKS. The Makefile builds the nolibc-based payload, converts it into an embedded header with xxd, and statically links the exploit. Dockerfile.eks packages the exploit into an image based on an EKS distro iptables image to maximize shared-layer overlap. deploy/poc-eks.yaml deploys the PoC as an ostensibly unprivileged pod. scripts/setup-eks.sh copies the project to a node, builds the binaries, pulls the base image, and builds the container image with nerdctl in the k8s.io namespace. scripts/run-poc.sh deploys the pod and checks /root/res on the node for success. scripts/cleanup.sh removes the deployment, deletes the marker, drops page cache, and restarts kube-proxy to restore clean binaries. Most remaining files under payload/nolibc/ are vendored minimal libc headers used to build a tiny static payload without glibc. They are support code, not separate exploit logic. Overall, the repository’s purpose is to demonstrate that an unprivileged Kubernetes pod can leverage a vulnerable Linux kernel plus shared image layers to achieve node-level code execution via a privileged workload, specifically validated on Amazon EKS.Percivalll · Disclosed May 8, 2026 · c · bash · local · container · cloudOperationalCVE-2026-43284The supplied repository listing contains one standalone C exploit, CVE-2026-43284.c (67,721 declared bytes), and README.md (3,518 declared bytes). No exploit framework, build configuration, or tests are shown. Repository URL, git reference, and archive size were not provided; size_bytes is therefore an unknown-value placeholder rather than the sum of file sizes. The visible C code contains a concrete privilege-escalation payload, namespace setup, and an automatic dispatcher. By default it attempts the ESP route through su_lpe_main, then falls back to rxrpc_lpe_main if the su target is not patched. The RxRPC route can run up to four times while checking passwd_already_patched. Options --force-esp and --force-rxrpc select individual routes; -v, --verbose, or DIRTYFRAG_VERBOSE enable diagnostics. Otherwise stderr is suppressed during exploitation. On detecting a patched target, the program invokes run_root_pty; the visible terminal-handling fragment forwards input/output and restores terminal settings. The primary payload is a hardcoded x86-64 ELF intended to replace the initial 192 bytes of /usr/bin/su. It attempts to set root credentials and execute /bin/sh with TERM=xterm. Function names indicate a passwd-related fallback, but neither its exact target path nor its modification is visible, so /etc/passwd is not treated as a confirmed endpoint. The visible code creates isolated user/network namespaces and enables loopback; the UDP encapsulation constant is 4500. These networking mechanisms support a local kernel attack, not an exposed remote exploitation interface. No external command-and-control or exfiltration endpoint is visible. The README attributes the two routes to CVE-2026-43284 and CVE-2026-43500 and describes unsafe in-place decryption of shared socket-buffer fragments backed by file page-cache pages, potentially involving splice/sendfile. It also supplies mitigation guidance and broad distribution-impact claims. Those CVE associations, affected-version claims, reliability assertions, and cited fix were not independently verified. Crucially, the supplied C content is substantially truncated, omitting the core corruption implementations and much of the fallback and shell-launch logic. The visible material supports classification as an operational exploit attempt with a real hardcoded payload, but does not establish that either exploit route works. Modification of a privileged executable is potentially damaging even if privilege escalation fails.ashrafzaryouh · Disclosed May 8, 2026 · c · localOperationalCVE-2026-43284Repository contains a single substantial C exploit (CVE-2026-43284.c) plus a README. This is a real local Linux privilege-escalation exploit, not a scanner or proof-only stub. The code targets Linux kernel page-cache corruption primitives described in the README as Dirty Frag / Copy Fail 2, using two kernel attack paths: xfrm/ESP (CVE-2026-43284) and RxRPC (CVE-2026-43500). The exploit is operational: it embeds a ready-to-use 192-byte x86_64 ELF payload that sets UID/GID to 0 and execs /bin/sh, then attempts to overwrite a privileged target such as /usr/bin/su in page cache so execution yields root. Structurally, the exploit includes namespace setup helpers, procfs UID/GID mapping, loopback interface activation, netlink/xfrm-related code for the ESP path, alternate RxRPC exploitation logic, patch-state checks (e.g., whether su/passwd targets are already modified), stderr suppression/restore, argument rewriting, and PTY-based root shell handling. The main function selects the ESP path first by default, falls back to RxRPC if needed, or allows explicit selection with --force-esp / --force-rxrpc. If exploitation succeeds, it launches an interactive root shell. Fingerprintable artifacts are primarily local file and kernel-interface paths rather than remote infrastructure: /usr/bin/su, /bin/sh, /bin/bash, /proc/self/setgroups, /proc/self/uid_map, /proc/self/gid_map, the loopback interface lo, and UDP encapsulation port 4500 for the ESP vector. Overall purpose: deterministic local root escalation on vulnerable Linux systems by abusing kernel fragment/page-cache corruption to replace privileged executable contents with a minimal root-shell ELF.0xBlackash · Disclosed May 8, 2026 · c · markdown · local · networkOperationaldirtyfrag-arm64Repository contains a single substantive exploit source file, dirtyfrag_arm64.c, plus a README and license. This is a standalone C local privilege escalation exploit for arm64/aarch64 Linux, described as a port of the upstream dirtyfrag PoC targeting CVE-2026-43284 and CVE-2026-43500. The README explains that the original x86_64 exploit had two paths (ESP/xfrm and rxrpc/rxkad), but on arm64 only the ESP path is usable because the rxrpc path triggers a kernel oops via flush_dcache_page rather than yielding reliable exploitation. The exploit’s main capability is page-cache corruption of a privileged executable, specifically /usr/bin/su on arm64. It embeds a 212-byte minimal aarch64 ELF payload directly in the C source. That payload performs setgid(0), setuid(0), setgroups(0,NULL), and execve("/bin/sh", NULL, envp), effectively yielding a root shell. The main function supports flags such as --force-esp and --force-rxrpc, but README states --force-esp should be used on arm64 to avoid the rxrpc crash. After attempting corruption, the code checks whether a target was patched and, on success, invokes run_root_pty() to provide an interactive root shell. Structurally, the code includes namespace setup and network preparation logic. setup_userns_netns() calls unshare(CLONE_NEWUSER | CLONE_NEWNET), writes /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map, then creates an AF_INET datagram socket and brings up the loopback interface lo. The presence of Linux netlink/rtnetlink and xfrm headers, UDP encapsulation constants, and ENC_PORT 4500 indicates the exploit uses IPsec/ESP-in-UDP mechanics as part of the corruption primitive. This makes the exploit both a local privilege escalation and one that leverages local networking/kernel network stack features. Fingerprintable observables include the hardcoded target path /usr/bin/su, payload execution path /bin/sh, direct exec of /bin/bash when already root, procfs namespace mapping files, loopback interface lo, and UDP port 4500 for ESP encapsulation. README also references /etc/passwd as the upstream fallback target on x86_64 and provides mitigation-related paths such as /etc/modprobe.d/dirtyfrag.conf. Overall, this is a real exploit rather than a detector. It is operational: it contains a working embedded payload and exploitation logic, but it is not part of a larger exploitation framework. Its purpose is to demonstrate and weaponize an arm64-specific port of Dirty Frag for authorized security research by obtaining root on vulnerable Linux systems where unprivileged user namespaces are enabled and the ESP path is available.linnemanlabs · Disclosed May 10, 2026 · c · markdown · local · networkOperationalrust_dirtyfragThis repository is a small standalone Rust local privilege-escalation exploit project named 'dirtyfrag'. It contains one substantive code file, src/main.rs, plus Cargo metadata and build configuration. The code is Linux-only and uses raw syscalls, libc bindings, Linux namespaces, netlink/XFRM structures, splice/vmsplice primitives, and interface ioctls to trigger a kernel-side page-cache corruption condition. The exploit is not a scanner or detector: it performs active exploitation. Its apparent goal is to overwrite the cached contents of /usr/bin/su with an embedded 192-byte ELF payload. That payload contains a minimal x86_64 executable that ultimately execs /bin/sh. After the corruption stage, the parent process verifies the first bytes at the target entry offset and reports success, then instructs the operator to run /usr/bin/su to trigger the implanted payload. Repository structure is minimal: Cargo.toml and Cargo.lock define a Rust binary depending only on libc; .cargo/config.toml sets Linux gcc linkers for musl and gnu x86_64 targets; readme.md is non-technical and does not document the exploit. The main.rs file defines many Linux/XFRM data structures and constants, including AF_NETLINK, NETLINK_XFRM, UDP encapsulation settings, namespace flags, ioctl constants, and the target path /usr/bin/su. The visible execution flow forks a child for the corruption stage, waits for completion, verifies the modified bytes, and then announces successful patching. Overall, this is an operational local Linux kernel exploit implementation with a hardcoded post-exploitation payload, targeting page-cache corruption of /usr/bin/su to obtain shell execution.Aiyakami · Disclosed May 11, 2026 · rust · toml · localOperationalCVE-2026-43284This repository is a compact local privilege escalation exploit for Linux named 'Dirty Frag'. It contains one substantive code file, exp.c, plus a README and .gitignore. The exploit is not part of a common exploitation framework; it is a standalone C proof-of-concept with operational payloading. Core purpose: chain two Linux kernel page-cache write vulnerabilities—CVE-2026-43284 (xfrm-ESP Page-Cache Write) and CVE-2026-43500 (RxRPC Page-Cache Write)—to gain root on vulnerable Linux systems. The code supports multiple paths: an xfrm-ESP-based path, an RxRPC-based path, and fallback logic that tries one then the other. Command-line flags shown in main include --force-esp, --force-rxrpc, and verbose options. Main exploit capability: overwrite the beginning of a privileged setuid executable in page cache with a hardcoded 192-byte x86_64 ELF payload. The default target path visible in the code is /usr/bin/su. The embedded ELF performs setgid(0), setuid(0), setgroups(0, NULL), and execve('/bin/sh', ...), yielding a root shell. The main routine then invokes a PTY-backed interactive shell helper (run_root_pty) if patching succeeded. There are also indicators that the code can target passwd as an alternate path, based on functions such as passwd_already_patched() and either_target_patched(). Exploit structure highlights from exp.c: - Embedded payload blob (shell_elf) containing a minimal root-shell ELF. - Namespace setup helper setup_userns_netns() that unshares CLONE_NEWUSER | CLONE_NEWNET, writes /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map, and brings up the loopback interface lo. - Networking-related logic using AF_INET/UDP and Linux netlink/xfrm headers, consistent with xfrm-ESP exploitation. UDP port 4500 is explicitly defined for ESP-in-UDP encapsulation. - Main orchestration logic that selects exploit path(s), suppresses stderr unless verbose, retries RxRPC exploitation, checks whether target binaries were patched in page cache, and launches an interactive root shell on success. Repository structure: - .gitignore: trivial editor ignore. - README.md: vulnerability overview, affected versions, quick compile/run instructions, cleanup guidance, mitigation steps, and tested distributions. - exp.c: full standalone exploit implementation. Overall assessment: this is a real local Linux kernel LPE exploit, not a detector. It is operational because it includes a built-in privilege-escalation payload and post-exploitation shell handling, but it is not highly modular or framework-driven.FrosterDL · Disclosed May 13, 2026 · c · markdown · localOperationalDirtyFrag-for-dummiesRepository is a small local Linux privilege-escalation exploit repo with 2 files: a README and one C++ proof-of-concept at poc/dirtyfrag.cpp. Despite README language framing it as research, the C++ file is a functional exploit, not just documentation. The exploit targets CVE-2026-43284 ('Dirty Frag') in the Linux kernel XFRM ESP receive path. Code structure: main() checks if already root and spawns /bin/bash if so; otherwise it calls corrupt_su(), verifies the patch with verify_patch(), and executes /usr/bin/su -. setup_userns_netns() creates new user and network namespaces, writes /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map, then brings up the loopback interface. add_xfrm_sa() opens a NETLINK_XFRM socket and installs many ESP transport-mode Security Associations for 127.0.0.1->127.0.0.1 with UDP encapsulation on port 4500, AES-CBC encryption, HMAC-SHA256 auth, and attacker-controlled ESN replay state. do_one_write() creates local UDP sockets on 127.0.0.1:4500, enables UDP_ENCAP_ESPINUDP, uses vmsplice/splice with SPLICE_F_MOVE to move file-backed data from /usr/bin/su into the packet path, and triggers the vulnerable receive-side in-place write. corrupt_su() iterates over the embedded 192-byte ELF payload in 4-byte chunks, encoding each chunk into seq_hi of a separate SA and then triggering one write per chunk at successive offsets into /usr/bin/su. Main exploit capability: page-cache corruption of a read-only executable file from an unprivileged context, specifically replacing the cached in-memory image of /usr/bin/su with a tiny x86_64 ELF payload. The exploit does not modify the on-disk file directly; it relies on later execution using the corrupted cached page contents. The embedded payload is intended to yield a root shell. Because the payload is hardcoded and the exploit is a standalone PoC rather than a reusable framework module, maturity is best classified as OPERATIONAL. Notable observables include loopback IP 127.0.0.1, UDP port 4500, NETLINK_XFRM usage, namespace mapping writes under /proc/self/*, and target executable paths /usr/bin/su, /bin/bash, and /bin/sh.ChernStepanov · Disclosed May 13, 2026 · markdown · cpp · local · networkOperationalCVE-2026-43284This repository contains a standalone local privilege escalation exploit for Linux kernels, with two identical C source files (CVE-2026-43284.c and dirtyfrag.c) plus a README. The code is not part of a common exploitation framework. The main exploit logic is in the C files, which embed a compact x86_64 ELF payload and attempt to corrupt page-cache-backed contents of privileged executables using two kernel bug paths described as xfrm/ESP (CVE-2026-43284) and RxRPC (CVE-2026-43500). The exploit first checks whether it is already root and spawns /bin/bash if so. Otherwise it parses flags (--force-esp, --force-rxrpc, -v/--verbose), optionally suppresses stderr, and tries the ESP path first unless forced otherwise; if that does not patch the target, it falls back to the RxRPC path and retries. The visible code shows namespace setup via unshare(CLONE_NEWUSER|CLONE_NEWNET), writes to /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map, and brings up the loopback interface. Constants indicate use of UDP encapsulated ESP on port 4500. The payload overwrites /usr/bin/su starting at offset 0 with a 192-byte ELF whose entry point performs setgid(0), setuid(0), setgroups(0,NULL), and execve(/bin/sh). After detecting that either target has been patched in page cache, the exploit launches an interactive root PTY session. Overall, the repository’s purpose is offensive proof-of-concept/operational exploitation of a local Linux kernel arbitrary page-cache write primitive to obtain a root shell by replacing a setuid binary in memory.xd20111 · Disclosed May 15, 2026 · c · markdown · localOperationalCVE-2026-43284Small standalone local privilege-escalation repository centered on a single C program, dirtyfrag.c, plus a minimal Makefile and README. The README describes exploitation of CVE-2026-43284 in Linux XFRM/ESP page-cache handling using a 4-byte write primitive repeated across 64 iterations. The exploit is not a scanner or detector; it is operational exploit code with an embedded payload. Repository structure: README.md documents prerequisites, tested environments, exploitation method, and restoration guidance; Makefile builds the binary; dirtyfrag.c contains all exploit logic and the hardcoded payload. No external framework is used. Core exploit flow: the program defaults to targeting /usr/bin/su, verifies it is setuid and readable, saves the original bytes, then forks. In the child, it creates new user and network namespaces, writes /proc/self/setgroups, /proc/self/uid_map, and /proc/self/gid_map, brings up loopback, and uses NETLINK_XFRM to register multiple ESP security associations bound to 127.0.0.1 with ESN enabled. Per the README and visible code, the exploit then uses UDP encapsulated ESP on port 4500 and splice-based file-to-pipe-to-socket operations so a page-cache page from the target file is pulled into an ESP scatter-gather path where kernel processing writes attacker-controlled 4-byte values from seq_hi into the cached file page. Repeating this across many SAs patches the target binary with the embedded ELF payload. Payload/capability: the embedded shell_elf is a minimal x86_64 ELF whose entry point performs setgid(0), setuid(0), and execve(/bin/sh) with TERM=xterm. After corruption succeeds, the parent verifies modified bytes at the expected entry offset, executes the now-corrupted setuid binary via forkpty to provide an interactive root shell, proxies terminal I/O, and finally attempts to restore the original bytes from backup when the shell exits. Notable endpoints and observables are entirely local: /usr/bin/su, /bin/sh, procfs namespace mapping files, loopback address 127.0.0.1, UDP port 4500, and NETLINK_XFRM. Overall, this is a concise but complete Linux LPE proof-of-concept with a built-in hardcoded root-shell payload and cleanup logic.whosfault · Disclosed May 16, 2026 · c · makefile · local · networkOperationalDirtyFrag-goThis repository is a standalone Go local privilege escalation exploit named `dirtyfrag-go`. It is not part of a larger exploit framework. The codebase contains 10 files, primarily Go source files implementing two Linux kernel exploit paths plus support code. Repository structure: `main.go` is the orchestrator and entry point. It checks whether the process is already root, parses `--force-esp`, `--force-rxrpc`, and verbose flags, tries the ESP/XFRM path first, falls back to the RxRPC path if needed, and launches a root PTY on success. `esp.go` implements the CVE-2026-43284 path: it re-execs itself into a new user and network namespace, brings up loopback, installs many XFRM Security Associations over `NETLINK_XFRM`, and uses a `vmsplice`/`splice` chain into an ESP-in-UDP socket on port 4500 to cause in-place decryption into the page cache of `/usr/bin/su`. The embedded payload is a 192-byte x86_64 ELF that yields a root shell. `rxrpc.go` implements the CVE-2026-43500 path: it crafts RxRPC/rxkad traffic over `AF_RXRPC`, installs attacker-controlled rxrpc keys into the process keyring, and performs three overlapping 8-byte page-cache writes against `/etc/passwd` so the root entry becomes effectively `root::0:0...`, enabling empty-password `su -`. `alg.go` provides AF_ALG helpers for kernel `pcbc(fcrypt)` operations used to compute rxkad-related values. `fcrypt.go` ports the kernel fcrypt implementation and includes a parallel brute-force routine to find session keys that decrypt to desired byte patterns. `pty.go` creates a PTY, runs `su -`, bridges terminal I/O, and auto-sends a blank password when prompted. Main exploit capabilities: (1) local kernel exploitation without disk writes by modifying only page-cache-backed file contents; (2) namespace-isolated execution to avoid requiring host `CAP_NET_ADMIN`; (3) two independent exploitation paths for resilience; (4) automatic privilege escalation to an interactive root shell. The exploit is operational rather than a simple PoC because it contains complete trigger logic, embedded payloading, fallback behavior, verification checks, and post-exploitation shell handling. Fingerprintable targets and artifacts are mostly local rather than remote: `/usr/bin/su`, `/etc/passwd`, `/dev/ptmx`, `/dev/pts/*`, `/proc/self/exe`, `/bin/bash`, `/dev/null`, loopback `127.0.0.1`, UDP port 4500, `AF_ALG`, `AF_RXRPC`, and `NETLINK_XFRM`. No external C2 or internet-hosted endpoints are present; the exploit is self-contained and uses kernel interfaces and local sockets only.Koshmare-Blossom · Disclosed May 20, 2026 · go · markdown · local · networkOperationalDirtyfrag-goThis repository is a Go-based local privilege escalation exploit named dirtyfrag-go. It is not part of a common exploitation framework and consists of 9 files, with the main logic spread across 6 Go source files: main.go orchestrates execution, esp.go implements the ESP/XFRM exploit path, rxrpc.go implements the AF_RXRPC/rxkad exploit path, alg.go provides AF_ALG helpers for kernel crypto operations, fcrypt.go ports the kernel fcrypt algorithm and brute-force helpers, and pty.go launches an interactive root shell through a PTY. The exploit targets two Linux kernel vulnerabilities identified in comments as CVE-2026-43284 and CVE-2026-43500. Its purpose is to gain root from an unprivileged local account by abusing kernel page-cache write primitives. The primary path in esp.go uses XFRM/ESP-in-UDP over loopback, installs many Security Associations through NETLINK_XFRM, and abuses in-place decryption triggered through vmsplice/splice to overwrite the first 192 bytes of /usr/bin/su with an embedded minimal x86_64 ELF payload. That payload performs privilege-changing syscalls and executes /bin/sh. The code re-execs itself into a child created with CLONE_NEWUSER|CLONE_NEWNET, brings up loopback, installs the SAs, performs repeated 4-byte writes, and verifies the patch by checking bytes at offset 0x78 in /usr/bin/su. The fallback path in rxrpc.go targets AF_RXRPC/rxkad. It constructs RxRPC headers and challenge packets, creates an rxrpc token with add_key into the process keyring, uses AF_ALG pcbc(fcrypt) helpers from alg.go to compute csum_iv and checksums, and leverages splice-based in-place decryption on file-backed pages. The goal is to patch /etc/passwd so the root entry becomes empty-password compatible. The repository includes a full userspace port of fcrypt in fcrypt.go plus parallel brute-force routines to discover suitable 8-byte session keys that decrypt chosen ciphertext blocks into desired plaintext fragments. The exploit performs three overlapping 8-byte writes with last-write-wins ordering to transform the root passwd entry. After either patch succeeds, pty.go opens /dev/ptmx, creates a slave PTY, runs su -, bridges terminal I/O, and automatically submits a blank password when prompted. main.go supports --force-esp, --force-rxrpc, and verbose mode, suppresses stderr by default, checks whether /usr/bin/su or /etc/passwd already appear patched, and either executes /bin/bash directly if already root or launches the exploit chain. Overall, this is a real operational local Linux kernel LPE exploit with embedded payloads and post-exploitation shell handling, not merely a detector or proof-of-concept stub.Koshmare-Blossom · Disclosed May 20, 2026 · go · localOperationalReporte-de-Escalada-de-Privilegios-Local-Dirty-FragRepository contains a small local Linux privilege-escalation toolkit for the so-called Dirty Frag exploit chain. Structure is simple: README.md documents lab validation steps and impact; dirty_frag_detect.py is a standalone detector that checks kernel version, patch/backport status, module availability/blacklisting, socket primitive availability, and mitigations; exp.c is the actual exploit PoC. The exploit is not framework-based. Main capability: exp.c performs local privilege escalation from an unprivileged user to root on vulnerable Linux kernels by abusing page-cache write/corruption primitives associated with CVE-2026-43284 (IPsec ESP path) and CVE-2026-43500 (RxRPC path). It contains logic for both exploit paths, supports forcing either path via command-line flags, and attempts multiple runs for the RxRPC path if needed. The code sets up user and network namespaces, manipulates loopback state, uses kernel networking interfaces including XFRM/netlink and RxRPC-related primitives, and targets a privileged executable for page-cache corruption. Payload behavior is explicit and high risk: exp.c embeds a minimal 192-byte x86_64 ELF payload and targets TARGET_PATH '/usr/bin/su'. The payload overwrites the beginning of the SUID binary in page cache, then when executed it calls setgid(0), setuid(0), setgroups(0,NULL), and execve('/bin/sh', ...) to provide a root shell. The main function then launches an interactive PTY-backed root shell if patching succeeded. This makes the repository a real exploit, not merely a detector, though it remains closer to an operational PoC than a generalized weaponized framework. Fingerprintable artifacts are mostly local file paths and kernel interfaces rather than remote C2/network infrastructure. Notable endpoints include /usr/bin/su, /bin/sh, /bin/bash, /proc/self/{setgroups,uid_map,gid_map}, /proc/modules, /sys/module/{esp4,esp6,rxrpc}, modprobe configuration directories, mitigation file /etc/modprobe.d/dirtyfrag.conf, and UDP port 4500 used for ESP-in-UDP handling. The README references 127.0.0.1 as the lab target and includes upstream GitHub URLs for the detector and exploit sources. Overall purpose: validate and exploit a local kernel LPE condition in a controlled lab environment, first by determining whether the host is likely exploitable and then by obtaining root through page-cache corruption of a privileged binary.DylanClaudio · Disclosed May 20, 2026 · markdown · python · localOperationalCVE-2026-43284-DirtyFrag-PoCThis repository is a compact local privilege escalation proof-of-concept for CVE-2026-43284. It contains one substantive code file, sley-dirtyfrag.c, plus a README. The exploit is not part of a larger framework. The C program targets Linux x86_64 systems and abuses the kernel XFRM/ESP over UDP encapsulation path to obtain a 4-byte page-cache write primitive per iteration. It uses unshare(CLONE_NEWUSER | CLONE_NEWNET) to create user and network namespaces as an unprivileged user, registers multiple XFRM security associations, and drives the vulnerable path via splice operations into a UDP socket configured for ESP-in-UDP on port 4500. Across 48 iterations, it writes a 192-byte embedded ELF payload into the page cache of a readable setuid binary, defaulting to /usr/bin/su. The payload then executes setuid(0), setgid(0), and /bin/sh to provide a root shell. The exploit includes operational features beyond a minimal PoC: kernel configuration preflight checks, setuid binary discovery, target validation, backup of the original first 192 bytes, corruption/verification stages, PTY-backed root shell spawning, and restoration logic that attempts to drop or invalidate page cache so the clean on-disk binary is reloaded. The code and README indicate it was tested on WSL2 Ubuntu 24.04.1 LTS with kernel 6.6.87.2-microsoft-standard-WSL2, and also references Ubuntu 24.04 and Fedora 44 vulnerable builds. Fingerprintable artifacts include the default target path /usr/bin/su, optional alternate target /usr/bin/passwd, kernel config sources under /boot, /lib/modules, and /proc/config.gz, and the recovery control file /proc/sys/vm/drop_caches. The primary trigger endpoint is UDP port 4500, used for ESP-in-UDP encapsulation. Overall, this is a real exploit PoC with a built-in payload and root-shell outcome, making it more than a detector but still short of a generalized weaponized framework.jayhutajulu1 · Disclosed May 26, 2026 · c · markdown · local · networkOperationalDirtyFrag-godirtyfrag-go is a 10-file standalone Go local-privilege-escalation implementation, not a Metasploit/Nuclei-style module. Its six Go source files divide responsibilities between orchestration (`main.go`), ESP/XFRM exploitation (`esp.go`), RxRPC/rxkad fallback exploitation (`rxrpc.go`), fcrypt key-search primitives (`fcrypt.go`), AF_ALG cryptographic checksum generation (`alg.go`), and interactive PTY handling (`pty.go`). The main program first re-execs itself in a new user and network namespace for the ESP route, avoiding host CAP_NET_ADMIN requirements. That worker enables loopback, creates 48 XFRM SAs, embeds four bytes of the hard-coded 192-byte x86_64 ELF in each SA's ESN replay state, and uses vmsplice plus splice of pages sourced from /usr/bin/su into ESP-over-UDP loopback traffic. The intended effect is a deterministic 192-byte modification of `/usr/bin/su` in the kernel page cache only. The code checks for expected shellcode bytes before considering this route successful. If ESP fails, the RxRPC route initializes fcrypt tables and performs parallel offline brute-force searches for three session keys that decrypt selected file-page ciphertext into required passwd-field bytes. It installs attacker-controlled rxrpc keys in the process keyring, creates AF_RXRPC traffic, and triggers three overlapping eight-byte writes against `/etc/passwd` page-cache data. It validates that the cached record has fields consistent with `root::0:0`, then the PTY code invokes `su -`, detects password prompts, and submits an empty line. There is no remote command-and-control endpoint or data-exfiltration logic; network activity is locally generated protocol traffic used to reach kernel attack surfaces. The claimed persistence is transient because the intended modifications affect page cache rather than on-disk files and are expected to disappear after reboot or cache eviction.nonameuserosint-hue · Disclosed Jun 1, 2026 · go · local · networkOperationalDirtyFragThis repository is a standalone Go local privilege escalation exploit named `dirtyfrag-go`. It targets two Linux kernel vulnerabilities, CVE-2026-43284 and CVE-2026-43500, and is clearly intended for host LPE/container escape scenarios rather than remote exploitation. Repository structure: `main.go` is the orchestrator and primary entry point. `esp.go` implements the ESP/XFRM exploitation path, `rxrpc.go` implements the RxRPC/rxkad fallback path, `alg.go` provides AF_ALG helpers for kernel crypto operations, `fcrypt.go` contains a userspace port of the kernel fcrypt algorithm plus brute-force helpers, and `pty.go` handles post-exploitation interaction by spawning `su -` inside a PTY. `go.mod`/`go.sum` define a minimal Go module using `golang.org/x/sys`. `README.md` describes build/run steps and lists affected Linux distributions. Main exploit capabilities: the primary ESP/XFRM path (`suLPE` / `RunESPWorker`) re-execs itself in new user and network namespaces, brings up loopback, installs many crafted XFRM Security Associations, and uses a vmsplice+splice chain to trigger in-place ESP decryption against page-cache-backed file data. The intended effect is to overwrite the first 192 bytes of `/usr/bin/su` in page cache with an embedded minimal x86_64 ELF payload. That payload performs setuid/setgid-style privilege setup and executes `/bin/sh`. After patching, the exploit verifies marker bytes in `/usr/bin/su` and then launches `su -` through a PTY. The fallback RxRPC path targets `/etc/passwd`. It constructs attacker-controlled RxRPC v1 tokens, adds them to the process keyring, sets up AF_RXRPC sockets, computes rxkad checksum material using AF_ALG `pcbc(fcrypt)`, and brute-forces suitable 8-byte session keys offline using the userspace fcrypt implementation. It then performs multiple overlapping 8-byte in-place decrypt/write triggers so the root passwd entry becomes effectively `root::0:0:...:/root:/bin/bash`, enabling empty-password root login. The code explicitly checks for the patched prefix `root::0:0`. Post-exploitation behavior: `pty.go` opens `/dev/ptmx`, allocates a slave PTY, starts `su -`, bridges the user terminal to the PTY, and automatically sends a newline when it detects a password prompt, supporting both the patched-`su` and patched-`passwd` cases. Notable endpoints/targets are all local: `/usr/bin/su`, `/etc/passwd`, `/bin/bash`, `/dev/ptmx`, `/dev/pts/*`, `/proc/self/exe`, loopback interface `lo`, loopback IP `127.0.0.1`, and UDP port `4500` for ESP-in-UDP encapsulation. There are no external C2 or internet URLs. Overall, this is a real, operational local Linux kernel exploit chain with embedded payloads and automated privilege-escalation workflow.1neptune · Disclosed Jun 3, 2026 · go · local · container · networkOperationalCVE-2026-43284-Dirty-FragThis repository is a compact standalone local privilege escalation exploit for CVE-2026-43284 ('Dirty Frag'). It is not a framework module; the core logic is entirely in src/exp.c, with a simple Makefile and GitHub Actions workflow used to build static binaries for multiple Linux architectures. Repository structure: README.md describes the exploit and links to the original source; Makefile builds a static binary named 'exploit'; .github/workflows/build.yml cross-compiles and publishes release artifacts for x86_64, i386, aarch64, armv7, riscv64, ppc64le, and s390x; src/exp.c contains the exploit implementation. Exploit purpose and behavior: the code performs local privilege escalation on vulnerable Linux kernels. It creates new user and network namespaces, writes /proc/self/{setgroups,uid_map,gid_map}, and brings up the loopback interface. The exploit contains two exploitation paths selectable by flags: '--force-esp' and '--force-rxrpc'. The default flow tries the ESP-based path first (suggesting abuse of IPsec/ESP-in-UDP handling on UDP port 4500), then falls back to an RxRPC-based path if needed. The code retries the RxRPC path multiple times until the target appears patched. Payload and post-exploitation: the exploit embeds a 192-byte x86_64 ELF payload ('shell_elf') and is configured to overwrite a privileged executable, notably /usr/bin/su, from offset 0. The replacement ELF calls setgid(0), setuid(0), setgroups(0,NULL), and execve('/bin/sh', NULL, envp) with TERM=xterm. After successful corruption/overwrite, the program invokes a PTY helper to run the patched privileged binary and provide an interactive root shell. If already root, main simply execs /bin/bash. Notable characteristics: this is real exploit code, not just a detector. It includes an operational payload, retry logic, namespace setup, and interactive shell handling. The embedded payload is architecture-specific (x86_64), while the repository’s CI builds static binaries for many architectures, indicating the exploit wrapper is portable but the hardcoded overwrite payload shown in the analyzed source is specifically x86_64.t1ckprivate · Disclosed Jun 5, 2026 · c · makefile · local · networkOperationalCVE-2026-46300Repository contains a multi-language Linux local privilege escalation toolkit targeting three claimed kernel CVEs: CVE-2026-43284, CVE-2026-43500, and CVE-2026-46300. Structure is small: three wrapper/PoC implementations in Perl, Python, and Bash, one README, and one C file (dirtyfrag.c) that appears to be the most complete exploit implementation. The Perl, Python, and Bash scripts all implement the same high-level flow: detect whether /usr/bin/su or /etc/passwd already appears modified, attempt namespace creation to gain CAP_NET_RAW, validate kernel/module prerequisites, send crafted raw protocol 50 packets to 127.0.0.1 for the Fragnesia path, and if successful spawn a root shell via su -. These scripts are partly operational but explicitly admit that full exploitation for the ESP and RxRPC paths requires low-level C-only features such as XFRM netlink sockets, splice/vmsplice, AF_ALG, and RxRPC handling. As a result, they function mainly as orchestrators/checkers plus a limited raw-socket trigger. The C file dirtyfrag.c is the core exploit. It includes Linux XFRM, netlink, RxRPC, keyctl, and AF_ALG headers; creates user and network namespaces; writes /proc/self/{uid_map,gid_map,setgroups}; brings up loopback; constructs XFRM Security Associations over 127.0.0.1 using NETLINK_XFRM; embeds a 192-byte x86_64 ELF payload intended for /usr/bin/su corruption; references UDP encapsulation port 4500; and contains logic to try ESP/XFRM first and RxRPC second before launching a root shell. The visible code shows real exploit-oriented primitives and payload staging, though some sections are truncated in the provided content. Main exploit capabilities: local privilege escalation from unprivileged user to root; corruption of /usr/bin/su with an embedded ELF payload; alternate corruption of /etc/passwd to enable passwordless root; raw packet generation against loopback for the Fragnesia trigger; namespace-based privilege preparation; and interactive root shell spawning. Fingerprintable artifacts are almost entirely local: /usr/bin/su, /etc/passwd, /proc/self/uid_map, /proc/self/gid_map, /proc/self/setgroups, /boot/config-<kernel>, /proc/sys/kernel/unprivileged_userns_clone, /bin/su, /bin/bash, /bin/sh, loopback IP 127.0.0.1, and UDP port 4500. There are no external C2 or remote network endpoints; the networking is used locally against kernel subsystems. Overall, this is a real exploit repository rather than a detector. It is best characterized as an operational local kernel LPE toolkit with a more complete C implementation and less complete scripting-language wrappers.MadExploits · Disclosed Jun 30, 2026 · perl · python · local · networkOperationalLSPromiseLSPromise is a 33-file Android Gradle project implementing a local privilege-escalation chain rather than a remote exploit or detection utility. The Java APK registers a self-managed Telecom account, ConnectionService, and InCallService whose CLASS_EXISTENCE_CHECK metadata causes Telecom to load the application's AppComponentFactory. MyAppComponentFactory invokes Shellcode during this privileged class-loading event. Shellcode detects system_server execution, reflects into ActivityManagerService to schedule its receiver inside com.android.networkstack.process (UID 1073), loads libexp there, and returns a Binder controller to the UI through an explicit EVIL broadcast. MainActivity exposes staged native actions and copies KernelSU's libksud.so to the app data directory as ksud. The native component consists primarily of exp.c, elf_parser.c, and stage1.S. exp.c builds the DirtyFrag page-cache overwrite primitive through local NETLINK_XFRM/IPsec and loopback traffic operations, patches crash_dump64, libc.so, libc++.so, and the vendor Stagefright bufferpool library, then triggers init using an orphaned-process condition. The AArch64 hooks transition into vendor_modprobe, load the replaced vendor library as a kernel module with finit_module, and execute KernelSU. shelld.c is a separate abstract-UNIX-socket command relay/helper; it is present in the repository but is not included in the shown CMake target. The hard-coded device paths, Android internals, and KernelSU dependency make this an operational, device-specific exploit chain.LSPosed · Disclosed Jul 23, 2026 · java · c · localOperationalDirtyFragThis two-file repository contains a README and a standalone 67 KB C local privilege-escalation program. It is not associated with a recognized exploitation framework. The program chains two Linux kernel page-cache write flaws described as xfrm-ESP (CVE-2026-43284) and RxRPC (CVE-2026-43500), selecting the ESP path first and falling back to/retrying the RxRPC path; command-line switches can force either path. It creates user and network namespaces, maps the calling user to namespace root, brings loopback up, and uses networking/kernel interfaces to trigger the vulnerable paths without requiring an external remote service. Its intended effect is to alter cached pages backing a SUID executable, primarily /usr/bin/su, replacing its beginning with a hard-coded 192-byte x86_64 ELF. The ELF elevates all relevant credentials to root and launches /bin/sh. The program then opens an interactive PTY for the resulting shell. The README notes that page-cache contamination remains after execution and recommends dropping caches or rebooting; it also documents module-disabling mitigation. The hard-coded target and payload make this an operational exploit rather than a flexible framework module.Minime794 · Disclosed Sep 21, 2026 · c · localOperationalDirtyFrag-GalaxyDirtyFrag-Galaxy is a 70-file Android application implementing an operational local root exploit chain for Samsung Galaxy devices claimed to be vulnerable to DirtyFrag (CVE-2026-43284). It is not a Metasploit/Nuclei-style framework module. The Android/Kotlin UI and orchestration code manage rooting, status reporting, notifications, optional boot-time re-execution, KernelSU root grants, module detection, soft restarts, and LSPosed/Zygisk verification. The Java exploit wrapper configures an AES-CBC plus HMAC-SHA256 IPsec transform on loopback with dynamic UDP ports and passes its material to the JNI library. Native C code implements the DirtyFrag CBC/IPsec file-page write primitive, reads/patches selected Android system and vendor binaries, and uses temporary hooks and ARM64 payloads to execute a late-load chain. The assembly payload loads a module through vendor modprobe, stages bundled ksud copies, establishes a private mount namespace, bind-mounts staged ksud over logcat, and invokes KernelSU late-load. The native chain restores patched hooks and cache state after completion. Post-root code uses KernelSU su to start ksud post-fs-data/services, optionally issue a soft reboot, and can restore SELinux Enforcing. Native exploit material is primarily under app/src/main/jni/ (exp.c, elf_parser.c, libc.S, libcxx.S, splicehelper.c); Java wrappers are under exploit/; Kotlin core code provides verification and state management; Compose UI files are under ui/. The project is built for arm64-v8a and also commits an AOSP test signing key, meaning rebuilds use a publicly known signing key. No remote C2, download, or external exploit-server endpoint is evident in the runtime exploit code; networking is limited to the local 127.0.0.1 IPsec/UDP setup.coey0814 · Disclosed Sep 28, 2026 · kotlin · java · local · networkOperationalDirtyFrag-Android-Root-JailbreakThe supplied 45-file repository is a standalone Android rooting application, not a scanner or a recognized exploit-framework module. Its source and scripts comprise 23 code-bearing files, including Java, C, AArch64 assembly, shell/batch scripts, and Kotlin Gradle build scripts. MainActivity supplies device/KMI diagnostics, logging, custom loader/module selection, and configurable vendor carriers. ExploitRunner configures a loopback IPsec security association using random AES-256-CBC and HMAC-SHA256 keys, stages a ksud wrapper, and invokes the JNI backend. The README attributes the underlying page-cache write vulnerability to CVE-2026-43284. Visible native code supports the stated mechanism: the CBC IV is calculated so that decrypting existing file-backed ciphertext produces desired replacement bytes. The documented chain first places splicehelper into crash_dump64 to read or splice vendor-file content, then stages a helper module in a vendor library. An ELF parser locates a libc++ sentry-constructor hook and accommodates an initial PACIASP/BTI instruction. The assembly payload runs only for UID 0 and TID 1, creates a mutex marker, requests the vendor_modprobe SELinux context, and executes insmod. The kernel helper resolves symbols through kprobes, writes false to the beginning of selinux_state to disable enforcement, temporarily bypasses two DEFEX functions, and launches the root-manager loader through usermodehelper. Its initialization returns an error after performing these side effects rather than remaining loaded normally. app/src/main/jni contains the exploit backend, crypto helpers, ELF parser, hook assembly, and freestanding splicehelper. dirtyfrag-lkm contains the module source and container-based builds for eight KMI combinations. Gradle/CMake, Android XML resources, wrapper scripts, and a GitHub Actions APK-release workflow complete the repository. The release APK is configured with debug signing. Runtime network activity visible here is local IPsec/UDP setup; the GitHub profile link is user initiated, and external build URLs are infrastructure rather than C2. Assessment is static and limited: exp.c, MainActivity.java, and the layout are truncated, so the complete write primitive and all failure/cleanup paths cannot be verified. The listed inventory does not include the eight referenced .ko files, gradle-wrapper.jar, or launcher artwork referenced by XML, leaving build completeness unverified. The CVE attribution and iQOO Z9 5G test result are repository claims, not independently validated findings; KMI entries describe build targets rather than established vulnerable ranges. Cleanup visibly restores the libc++ hook and attempts crash_dump64 cache eviction, but does not visibly restore SELinux enforcement. The repository URL is inferred from the README; no analyzed git reference or archive size was supplied, and size_bytes=0 represents unavailable metadata.ankitrawatgit · Disclosed Oct 2, 2026 · java · c · localOperationalDirtyFragThe supplied repository contains 12 files: ten source/script files, one kernel-module Makefile, and a Portuguese README. Its purpose is temporary local rooting of a specific Samsung Galaxy A57 firmware without unlocking the bootloader. It is standalone, not a Metasploit/Nuclei module; use of Android framework APIs does not make it an exploit-framework component. SaHelper.java creates a loopback AES-CBC IPsec transform and exports its dynamically generated parameters. run-dirtyfrag-termux.sh coordinates that helper and a prebuilt native exploit. exp.c contains the visible CBC IV calculation and ESP packet construction: file-backed content is supplied through splice/vmsplice so vulnerable kernel decryption can replace page-cache bytes with chosen 16-byte blocks. aes256.h implements the AES calculation. splicehelper.c supplies a minimal AArch64 read/splice bridge intended to run through the patched crash_dump64. elf_parser.c resolves an ELF dynamic symbol and adjusts hook placement for PACIASP/BTI instructions. The README says the privileged trigger is the libbase LogMessage destructor used by init, despite the legacy libcxx filenames. libcxx.S confirms that the payload only proceeds for UID 0 and TID 1, creates /dev/df as a mutex, launches insmod in the vendor_modprobe context, waits for it, and executes the bootstrap. lkm/dfroot.c resolves kernel symbols through kprobes, attempts to invalidate crash_dump64's cache, disables SELinux enforcement, and bypasses two Samsung DEFEX functions. Contrary to the README's simplified description, the visible module does not directly launch the bootstrap; the assembly worker does. bootstrap.c reads manager preferences, adopts the zygote environment, protects selected partitions with read-only ioctls, optionally disables SU modules, starts ksud, and unloads dfroot. Module unloading unregisters the DEFEX probes but does not restore SELinux enforcement in the visible code. This is exploit code with concrete payloads, not merely a detector, and no clear fake-exploit indicators are present. However, exp.c is substantially truncated in the supplied content, and the claimed embedded target-specific module, compiled binaries, DEX, and staging resources are absent from the listed files. Consequently, complete buildability, cleanup behavior, firmware compatibility, and successful exploitation cannot be established. The CVE attribution and device-testing claims come from the README and are not independently verified. Only loopback networking is visible, with no external service, C2 endpoint, or exfiltration destination. Repository URL, git reference, and archive size were not supplied; their fields use empty/zero placeholders. Listed file sizes total 69,518 bytes, which is not an archive-size measurement.SudoXDdX · Disclosed Oct 14, 2026 · c · java · localOperationalDirtyFragThe supplied repository is a standalone Android rooting application, identified in its build configuration as version 1.16, rather than a framework module or detection-only script. It attributes the exploited vulnerability to CVE-2026-43284; that attribution and the exact affected-version range were not independently verified. The exploit uses Android IpSecManager to establish a loopback AES-CBC ESP transform. Native code combines crafted ESP headers with spliced file-backed pages and computes IVs that cause chosen 16-byte plaintext to replace existing page-cache content without ordinary file-write permission. The documented chain first patches crash_dump64 with a small syscall-only helper, gaining access to vendor-labelled files through its SELinux domain. It then stages a compatible kernel module in a vendor file and patches libc++.so with an AArch64 hook. The hook only activates for UID 0 and TID 1, creates /dev/df to prevent repeated execution, and launches insmod in the vendor_modprobe domain. The kernel module resolves internal symbols through a temporary kprobe, attempts to invalidate crash_dump64's modified cache, makes SELinux permissive, and patches Samsung DEFEX and Oplus execution/root-check handlers to return zero. It launches bootstrap through call_usermodehelper and returns -ENODEV so the loader module is discarded. Bootstrap reads device-protected preferences, adopts zygote's environment, applies optional module disabling and read-only block-device protection, and late-loads the chosen manager's ksud. Full reboot removes active root, although daemon files or module data may remain on disk. Optional boot autorun re-exploits the device and disables itself after a reported failure. The 70-file listing contains 12 Java files for the UI, orchestration, boot receiver, and status helpers; native C, header, assembly, and assembly-include files implement the exploit and bootstrap; lkm/ contains the kernel payload; res/ contains Android UI resources; tools/ contains two Python asset-generation utilities. Gradle, CMake, Makefiles, and GitHub Actions provide APK and eight-KMI module builds. The code-file count of 27 includes source/header/include files, Kotlin build scripts, and shell/batch wrappers, excluding declarative resources and build recipes. Important limitations: exp.c, MainActivity.java, and other supplied files are truncated, preventing complete review of target selection, restoration, and release-check networking. No external runtime callback, exfiltration destination, or fixed remote service is visible; the observed exploit traffic is local loopback UDP. Build-time download endpoints are distinguished from runtime observables. Documentation claims bundled prebuilt modules, but none appear in the supplied file listing; the Gradle wrapper JAR and referenced font binary are also absent from that listing. README descriptions of DEFEX kprobes and module lifetime lag the supplied kernel-module implementation. The UI's use of /dev/df as a root indicator can report the hook as active before ksud success. Repository URL is inferred from README links; no analyzed Git reference or archive size was supplied, so ref is unknown and size_bytes is an unknown-value placeholder of 0. Static analysis supports a genuine operational exploit design, but successful execution and build completeness were not tested.tangdino222 · Disclosed Oct 18, 2026 · java · c · localOperationalDirtyFragThe supplied repository is a standalone Android rooting application, version 1.16, identifying its vulnerability as CVE-2026-43284. Its implementation supports classification as an operational local privilege-escalation exploit rather than a detector or README-only project; successful exploitation was not independently tested. The chain configures a loopback IPsec AES-CBC transform through Java and passes its parameters to a native executable. The native component uses crafted ESP traffic and splice-backed file pages to obtain 16-byte page-cache overwrites without ordinary file-write permission. It replaces crash_dump64 in cache with a small helper to access vendor-labelled files, places a kernel module in a vendor-file carrier, and patches libc++ with an AArch64 hook. When reached by init, that hook invokes vendor insmod. The module makes SELinux permissive, patches available Samsung DEFEX and Oppo/OnePlus security handlers, and starts bootstrap before returning an initialization error to unload itself. Bootstrap launches the selected SU manager's daemon. The visible code does not establish a remote shell or contact an external exploitation server; exploit networking is local loopback traffic. Of 70 listed files, 30 contain source, headers, executable scripts, or build-script code. app/src/main/java/df/root contains 12 Java files for the activity, runner, boot receiver, reporting, status checks, and custom UI. app/src/main/jni contains the native exploit, AES helper, ELF hook-location parser, assembly payload, freestanding splice helper, bootstrap, and CMake configuration. lkm contains the kernel payload and its Makefile. Android resources supply the interface; tools contains two Python font/icon utilities. Gradle, the root Makefile, and GitHub Actions handle APK packaging and eight KMI module builds. No conventional exploit framework is present. Important limitations and inconsistencies remain: exp.c and MainActivity.java are substantially truncated in the supplied material; the README claims prebuilt kernel modules are committed, but no .ko files appear in the inventory, and the referenced font and Gradle wrapper JAR are also absent. Build scripts disagree on signing configuration and APK output names, and CI strips the module build-ID section despite the changelog saying it must be retained. README descriptions of older kprobe-based DEFEX bypasses differ from the current direct instruction patches. The UI's /dev/df check is a hook marker, not conclusive root verification. Boot autorun re-exploits after reboot and includes a failure interlock; it is not persistent kernel root. The repository URL is inferred from README release links; no analyzed Git reference, archive path, or archive byte size was supplied, so the empty reference and zero size represent unavailable metadata. The CVE attribution and affected-version claims come from the repository and were not externally verified.ziachi · Disclosed Oct 19, 2026 · java · c · localOperational
Exposure surface

Affected products & vendors

Products and vendors Mallory has correlated with this vulnerability. Open in Mallory to drill down to specific CPE configurations and version ranges.

VendorProductType
LinuxLinux Kerneloperating_system
FAQ

Frequently asked questions

Is CVE-2026-43284 exploited in the wild?
Yes. As of Nov 16, 2026, Mallory has reports of exploitation in the wild.
Is there a public exploit for CVE-2026-43284?
Yes. Mallory tracks 32 public exploits or proofs of concept for CVE-2026-43284, the earliest disclosed May 5, 2026.
Is there a patch for CVE-2026-43284?
Install the operating-system or appliance vendor's kernel or firmware update addressing CVE-2026-43284, and reboot into the corrected kernel where required. The kernel fix marks spliced IPv4/IPv6 datagram fragments with SKBFL_SHARED_FRAG and makes ESP input call skb_cow_data() when that flag is present, ensuring that decryption operates on privately owned data.
What products are affected by CVE-2026-43284?
Linux Kernel.
How severe is CVE-2026-43284?
CVE-2026-43284 has a CVSS v3.1 score of 7.8 (High) and an EPSS score of 99.2% (100th percentile) as of Nov 16, 2026.
Activity feed

Recent activity

390 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
+83 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidenceEvery report linking this CVE to a named adversary.
Associated malware7Malware families linked to this CVE, with evidence and IOCs.
Detection signatures3YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity88Community discussion across Reddit, Mastodon, and other social sources.