Skip to main content
Mallory
HighExploited in the wildCISA KEVPublic exploitVulnerability

CVE-2019-2215: Bad Binder

Published Oct 11, 2019 · Updated 23 days ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 daysNo mention activity in the last 30 days.
CVSS7.8High · v3.1
EPSS72.1%99th percentile
CISA KEVYesAdded Nov 3, 2021
In the wildActivePer CISA KEV
Vendors
NetAppHuawei TechnologiesGoogleDebian ProjectCanonical
IdentifiersCVE-2019-2215CWE-416 · Use After Free

CVE-2019-2215, also known as Bad Binder, is a use-after-free vulnerability in the Android Linux kernel's Binder inter-process communication driver. After BINDER_THREAD_EXIT invokes binder_thread_release(), epoll can retain a reference to a wait queue embedded in the freed binder_thread structure. Subsequent wait-queue removal accesses freed memory. Reclaiming that memory with attacker-controlled allocations enables kernel memory disclosure and corruption, potentially yielding arbitrary kernel read/write access and full device compromise from an unprivileged application. The vulnerability was exploited in the wild.

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.

Successful exploitation allows a local unprivileged process to compromise kernel memory and escalate to root. Demonstrated exploits modify process credentials and capabilities, disable SELinux enforcement and seccomp restrictions, and escape application confinement. This enables access to other applications' sensitive data, covert payload installation, and extensive device surveillance. Exploitation can also cause kernel crashes and local denial of service.

Mitigation

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

Restrict installation and execution of untrusted applications to reduce the local exploitation route, but do not rely on app-store distribution alone: malicious applications exploiting this vulnerability reached Google Play. Keep browsers and other network-facing applications updated to reduce opportunities to chain remote code execution with this kernel flaw. CONFIG_DEBUG_LIST blocks the documented Project Zero exploitation technique through list-integrity checks, but is not a substitute for patching. On suitably supported systems, kernel memory tagging can impede the underlying use-after-free exploitation, subject to allocation coverage and enforcement.

Remediation

Patch, then assume compromise.

Install device-manufacturer firmware or kernel updates containing the CVE-2019-2215 Binder lifetime-management fix, addressed in the October 2019 Android Security Bulletin. The underlying fix had reached upstream Linux and Android kernel branches in February 2018 but was absent from many shipped devices; verify its inclusion in the actual device build rather than relying solely on the Android major version. Replace unsupported devices that cannot receive a corrected kernel.

Public exploits

Exploits

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

View more in app →
binder_uaf.rbThis repository contains a single Metasploit module (modules/exploits/android/local/binder_uaf.rb) that exploits CVE-2019-2215, a use-after-free vulnerability in the Android kernel's Binder driver. The exploit is a local privilege escalation, allowing an attacker with code execution on a vulnerable Android device (AARCH64 architecture) to gain root privileges. The module uploads a precompiled exploit binary and a payload (default: Meterpreter reverse shell) to the target device, executes the exploit to escalate privileges, and then runs the payload as root. The module is weaponized, supporting customizable payloads via Metasploit, and is intended for post-exploitation scenarios where the attacker already has a session on the device. No network endpoints are hardcoded; the attack is purely local, with file paths for the exploit and payload binaries being dynamically generated and cleaned up after execution. The module references several public advisories and proof-of-concept resources for further information.Disclosed Sep 26, 2019 · Framework: metasploit · ruby · localWeaponizedCVE-2019-2215This repository contains a local privilege escalation exploit for Android devices vulnerable to CVE-2019-2215, a use-after-free in the Binder driver. The main exploit logic is implemented in two C files: 'poc.c' and 'su98.c'. 'poc.c' targets general vulnerable kernels, while 'su98.c' is tailored for Android 3.18 kernels with specific offsets. Both files implement the exploit chain to gain arbitrary kernel read/write, escalate privileges, disable SELinux enforcing, and join the init mount and network namespaces. The payload spawns a root shell, providing full control over the device. The Makefile and Android.mk facilitate building and deploying the exploit binary to the target device via ADB. The exploit is operational and provides a working root shell on affected devices. No network endpoints are targeted; the attack vector is local, requiring code execution on the device (e.g., via ADB or a malicious app).timwr · Disclosed Oct 4, 2019 · c · makefile · localOperationalcve-2019-2215This repository contains a working local privilege escalation exploit for CVE-2019-2215, targeting Google Pixel 2 and Pixel 2 XL devices running the September 2019 QP1A.190711.020 image with kernel version 4.4.177-g83bee1dc48e8. The main exploit is implemented in a single C file ('cve-2019-2215.c'), which, when compiled and executed on a vulnerable device, leverages a kernel vulnerability to gain arbitrary kernel memory read/write access, patches the current process credentials to root, and spawns a root shell. The exploit also sets SELinux to permissive mode. Optionally, a debug console can be invoked to allow direct kernel memory manipulation and inspection. The Makefile facilitates cross-compilation for AArch64 using the Android NDK. The README provides detailed usage instructions, including compilation, deployment, and example outputs. The exploit is operational and provides a real privilege escalation path on affected devices, but is not weaponized for mass exploitation. No network endpoints are involved; the attack vector is strictly local, requiring code execution on the target device.kangtastic · Disclosed Oct 14, 2019 · c · makefile · localOperationalCVE-2019-2215This repository contains a local privilege escalation exploit for CVE-2019-2215, targeting Sony Bravia TVs running Android 8 (PKG6.0724) with kernel version 4.9.51. The exploit is implemented in C (poc-bravia.c) and leverages a use-after-free vulnerability in the Android Binder IPC subsystem to gain arbitrary kernel memory read/write. It then patches the current process's credentials to root, disables SELinux enforcement, and spawns a root shell, providing temporary root access. The README.md provides detailed compilation and usage instructions, including pushing the binary to the device and executing it via ADB shell. The exploit is operational and may be adapted to other affected devices by adjusting kernel offsets. The main attack vector is local, requiring code execution on the target device (e.g., via ADB). The only fingerprintable endpoint is the file path where the exploit binary is placed and executed.LIznzn · Disclosed Jan 30, 2020 · c · localOperationalcve-2019-2215This repository contains a local privilege escalation exploit for CVE-2019-2215, a use-after-free vulnerability in the Android binder driver. The main file, 'exploit.c', is a C program that manipulates binder objects to gain arbitrary kernel read/write, disables SELinux enforcement, sets the current process's UID and GID to 0 (root), and spawns a root shell. The Makefile provides build and deployment instructions for Android (aarch64). The README references the original Project Zero bug. The exploit targets Android devices with a vulnerable binder driver and requires local code execution. Key fingerprintable endpoints include the '/dev/binder' device and the use of '/bin/sh' to spawn a shell. The exploit is operational, providing a working local privilege escalation payload.DimitriFourny · Disclosed Feb 17, 2020 · c · makefile · localOperationalAndroidKernelVulnerabilityThis repository contains a working exploit for CVE-2019-2215, a use-after-free vulnerability in the Android kernel's binder driver. The exploit is implemented in C++ across two main files: 'exploit.cpp' (the main exploit logic) and 'trigger.cpp' (a minimal PoC to trigger the kernel crash). The exploit works by manipulating the binder driver via /dev/binder, creating a use-after-free condition, and leveraging it to gain arbitrary kernel read/write. It then escalates privileges by patching the current process's credentials to root, disables SELinux enforcing, and spawns a root shell. The included 'crash_report.txt' provides a KASan report confirming the use-after-free bug. The exploit targets unpatched Android devices running vulnerable kernels, and is operational, providing a real privilege escalation payload. No network endpoints are involved; the attack vector is local, requiring execution on the target device.sharif-dev · Disclosed Jun 7, 2020 · cpp · localOperationalRootsmart-v2.0This repository is a weaponized Android malware project that combines a custom ransomware, data exfiltration, and a local privilege escalation exploit (CVE-2019-2215) to achieve root and establish a reverse shell. The main codebase is an Android app disguised as a 2048 game (Java/Kotlin), which, upon installation and execution, encrypts all files in /sdcard/Pictures using AES, stores per-file keys in /sdcard/keys.json, and retrieves a master key and victim ID from a C2 server (http://192.168.157.73:8080). The app exfiltrates contacts, emails, and account information to the C2 via HTTP POST. It downloads and executes a root exploit payload (shells.zip) containing a compiled CVE-2019-2215 exploit and a reverse shell binary, achieving root and connecting back to the attacker's server. The dropper server (Python Flask) provides endpoints for payload delivery, key management, and data exfiltration. The repository also includes the native C exploit code and server-side scripts. This is a full operational proof-of-concept for Android ransomware with root exploit and C2 integration.nicchongwb · Disclosed Feb 28, 2022 · java · kotlin · local · networkOperationalRootsmart-v2.0This repository is a weaponized Android malware project combining ransomware, privilege escalation, and data exfiltration. The main component is a modified 2048 Android game (Java/Kotlin) that, upon installation and execution, requests extensive permissions. Once granted, it encrypts all files in /sdcard/Pictures using AES, storing per-file keys in /sdcard/keys.json. It communicates with a C2 server (default: 192.168.157.73:8080) to retrieve a master key and victim ID, which are used to further encrypt the keys file and identify the victim. The malware downloads a ZIP archive containing a root exploit (CVE-2019-2215) and a reverse shell payload, extracts and executes them to gain root and establish a reverse shell to the attacker's server. Additionally, it exfiltrates contacts, emails, and account information via HTTP POST to the C2. The dropper_server.py script implements the C2 endpoints for payload delivery, key management, and data collection. The repository also includes the C source code for the CVE-2019-2215 exploit and supporting scripts for payload deployment. The project is a full-featured, operational Android malware suite, not a simple proof-of-concept.CrackerCat · Disclosed Mar 25, 2022 · java · kotlin · local · networkOperationalcve-2019-2215-3.18This repository is a comprehensive local privilege escalation exploit for Android devices running Linux kernel 3.18, targeting CVE-2019-2215. The structure includes: - Native C exploits (su98.c, su98-memory-kallsyms.c, poc98.c) that leverage a use-after-free vulnerability in the binder driver to gain arbitrary kernel read/write and escalate privileges to root. - An Android app (Java code in app/src/main/java/mobi/omegacentauri/su98/) that manages installation, uninstallation, and persistence of the su binary, as well as user interface elements for controlling exploit behavior (e.g., install on boot). - Shell scripts (install.sh, uninstall.sh) for installing the su binary to /sbin, setting permissions, and managing symlinks and whitelist/deny files for access control. - The exploit disables SELinux enforcement for full root access and can persist across reboots if configured. - The Makefile and build scripts facilitate cross-compilation for ARM64 Android targets. The exploit is operational and provides a persistent root shell on vulnerable devices. It is not part of a larger exploitation framework but is a standalone, weaponized exploit with both command-line and Android app interfaces. The main attack vector is local, requiring code execution on the target device. Multiple fingerprintable file paths are used for persistence and access control.Enceka · Disclosed Apr 28, 2022 · c · java · localOperationalCVE-2019-2215This repository contains a local privilege escalation exploit for CVE-2019-2215 (Bad Binder), a vulnerability in the Android Binder driver. The main exploit logic is implemented in 'exp.cc', a C++ file that manipulates kernel structures to escalate privileges to root. The Makefile provides build and deployment instructions, targeting Android devices via the Android NDK toolchain. The exploit works by leaking kernel addresses, overriding process credentials, disabling SELinux enforcement, and finally spawning a root shell by executing '/bin/sh'. The exploit must be compiled for the target device's architecture and pushed to '/data/local/tmp/cve-2019-2215-exp' for execution. The repository is operational and provides a working local privilege escalation payload, but is not part of a larger exploit framework.elbiazo · Disclosed May 27, 2023 · c++ · makefile · localOperationalCVE-2019-2215-HuaweiP20LiteThis repository contains a full operational local privilege escalation exploit for CVE-2019-2215 (the 'bad binder' vulnerability) specifically ported to the Huawei P20lite running Android 8.0.0 (kernel 4.4.23). The exploit is implemented in C and is designed to be built with the Android NDK for ARM64. The main exploit logic resides in 'exploit/cve_2019_2215.c', which leverages a use-after-free in the binder driver ('/dev/binder') to achieve arbitrary kernel read/write. The exploit then escalates privileges to root by overwriting the process's credentials, disables seccomp, and manipulates SELinux policies to make all types permissive, effectively disabling SELinux enforcement. The exploit also grants all Linux capabilities to the process. The payload is a root shell spawned on the device. The repository includes supporting code for kernel read/write primitives, SELinux policy manipulation, and seccomp disabling. The Makefile and Android.mk files automate building and deploying the exploit binary to the target device. The exploit is not a detection script or a PoC; it is a fully operational exploit with a hardcoded payload (root shell).willboka · Disclosed Feb 4, 2024 · c · makefile · localOperationalCVE-2019-2215This repository contains a local privilege escalation exploit for the Android kernel vulnerability CVE-2019-2215, also known as 'Bad Binder'. The exploit is implemented in C (exploit.c) and targets the binder driver by abusing a use-after-free (UAF) vulnerability. The exploit achieves arbitrary address read (AAR) and arbitrary address write (AAW) primitives, which are then used to leak kernel addresses and overwrite the addr_limit field. This allows the attacker to modify the cred_struct in kernel memory, effectively escalating privileges to root. The exploit interacts directly with the /dev/binder device and uses various Linux system calls (epoll, mmap, pipe, writev, etc.) to manipulate kernel memory. The README.md provides background and references but no code. The exploit is operational and requires local access to a vulnerable Android device with the binder driver exposed.mutur4 · Disclosed Apr 15, 2024 · c · localOperationalTempRoot-HuaweiThis repository provides a local privilege escalation exploit for Huawei P20 Pro (CLT-AL00) devices running a hardened kernel vulnerable to CVE-2019-2215. The exploit is specifically tailored for a device with build fingerprint 'HUAWEI/CLT-AL00/HWCLT:8.1.0/HUAWEICLT-AL00/176(C00):user/release-keys'. The repository contains C source files for the main exploit logic (common.c, patch_system.c, poc.c), a modified 'su' daemon (in the 'sud' directory), and supporting bash scripts for automating the exploitation and root access setup. The exploitation process involves first running 'patch_system' to disable SELinux protections, then running 'poc' to escalate privileges and spawn a root shell. Optionally, a 'su' daemon can be installed to provide persistent root access to other applications. The scripts automate remounting filesystems, copying binaries, and setting up the environment for root access. The exploit interacts with several kernel and system endpoints, including '/dev/binder', '/dev/ptmx', various cgroup control files, and SELinux context files. The code is operational and provides a working local root exploit for the specified device and configuration.llccd · Disclosed Feb 4, 2025 · c · bash · localOperationalandroid-kernel-exploitation-labThis repository is a comprehensive Android kernel exploitation lab focused on CVE-2019-2215, a critical use-after-free vulnerability in the Android binder driver. The structure includes documentation for environment setup, kernel building, fuzzing (with AFL++ and Syzkaller), and GDB-based kernel debugging. The core exploit code is in 'exploit-code/binder_cve_2019_2215_exploit.cpp', which implements a full local privilege escalation chain: it manipulates binder and epoll file descriptors to trigger a use-after-free, leaks kernel memory, achieves arbitrary kernel read/write, patches the current process's credentials to root, disables SELinux, and spawns a root shell. A minimal proof-of-concept (PoC) is provided in 'exploit-code/binder_cve_2019_2215_poc.c'. The Makefile and CMakeLists.txt automate building and deploying the exploit and PoC to an Android device or emulator. Fuzzers and GDB scripts are included for advanced analysis and debugging. The exploit targets Android 8.x, 9.0, and early 10 on x86_64 and ARM64 platforms, requiring local access (e.g., via ADB). Key fingerprintable endpoints include the '/dev/binder' device node and the location of deployed binaries in '/data/local/tmp/'. The repository is operational and provides a working exploit chain for research and educational purposes.0xbinder · Disclosed Mar 13, 2025 · c · c++ · localOperationalandroid-badbinder-demoThis repository is a comprehensive proof-of-concept and operational exploit for CVE-2019-2215 (Bad Binder), a use-after-free vulnerability in the Android kernel's Binder IPC subsystem. The project is structured as an Android application with a Kotlin/Jetpack Compose UI and a native C library implementing the exploit logic, accessible via JNI. The exploit can also be built and run as a standalone native binary for direct execution on a vulnerable device or emulator. Key files include: - `app/src/main/cpp/cve-2019-2215.c`: The main exploit logic in C, implementing the steps to leak kernel addresses, overwrite `addr_limit`, gain arbitrary kernel read/write, disable SELinux enforcing, and escalate privileges to root. - `cve-2019-2215/exploit.c`: A standalone version of the exploit for direct execution. - Kotlin files (`MainActivity.kt`, `ExploitViewModel.kt`, `ExploitScreen.kt`): Provide the Android app interface, manage exploit execution, and display logs/results to the user. - Build scripts and configuration files for both the Android app and native code. The exploit targets Android 10 (Q) and earlier devices with unpatched kernels. It requires local code execution (e.g., via an installed APK or shell access). The main fingerprintable endpoint is `/dev/binder`, which is accessed to trigger the vulnerability. The exploit disables SELinux enforcing and attempts to escalate privileges to root, providing a root shell or root access if successful. The repository is well-documented, with a detailed README explaining setup, usage, and the underlying vulnerability. The exploit is operational, with a working payload, but is not weaponized for mass exploitation.i-redbyte · Disclosed Nov 6, 2025 · kotlin · c · localOperationalCVE-2019-2215This repository is a compact local privilege escalation exploit for CVE-2019-2215 (Bad Binder) on Android. It contains only two files: a README describing the exploit flow and usage, and a single C source file, bad_binder.c, which implements the full exploit. The code is not a scanner or detector; it is a working exploit intended to obtain root on a vulnerable Android device. The exploit targets the Binder driver via /dev/binder and abuses a use-after-free involving binder waitqueue/epoll interactions. Its structure is split into two main phases. First, it creates Binder state, adds the binder fd to an epoll waitqueue, exits the binder thread, and triggers the UAF while a writev call is blocked on a full pipe. This corrupts iovec metadata and leaks a kernel task_struct pointer from pipe output. Second, it repeats the UAF with a recvmsg-based crafted iovec layout over an AF_UNIX socketpair to gain a controlled kernel write primitive. Using that primitive, it overwrites the current task's addr_limit with a near-maximum value, enabling arbitrary kernel memory read/write through pipe-based kmemcpy operations. It then reads the cred pointer from task_struct and overwrites the credential ID block with zeros, effectively setting uid/gid-related fields to root. After successful escalation, the exploit verifies getuid()==0 and executes /bin/sh. The implementation is highly target-specific: it hardcodes kernel structure offsets such as TASK_STRUCT_OFFSET, CRED_OFFSET_IN_TASK, and ID_BLOCK_IN_CRED_OFFSET, and assumes a compatible Android kernel layout. The README states it was tested on the goldfish Android kernel, arm64, version 4.14, with the patch reintroduced. Overall, this is an operational local Android kernel LPE exploit with a built-in root shell payload, not part of a larger exploitation framework.wired0ut · Disclosed Apr 22, 2026 · c · markdown · localOperationalCVE-2019-2215This repository is a real local privilege-escalation exploit for CVE-2019-2215 (Bad Binder) targeting an Android 10 x86_64 emulator environment. The main exploit is implemented in exp.cc as a native C++ binary compiled with the Android NDK and deployed to the emulator with adb. The exploit is not part of a larger exploitation framework. Repository structure: exp.cc contains the exploit logic; Makefile builds and optionally pushes/runs the binary; scripts/start-emulator.sh boots an Android AVD with a custom vulnerable Goldfish kernel; scripts/run-exploit.sh waits for boot completion, pushes the binary to /data/local/tmp, and executes it; setup-env.sh configures Android SDK/NDK paths; BUILD.md documents how to build the required vulnerable kernels and run the emulator; kernel/build-configs/* and kernel/patch/* provide supporting kernel build configs and patches. Exploit capability: the code abuses the Binder bug to leak task_struct-related data, derive a kernel base address, obtain arbitrary kernel read/write primitives, overwrite the current process cred structure to set all UID/GID fields to 0 and grant full capabilities, then zero the SELinux enforcing flag. After verifying getuid()==0, it launches /bin/sh, yielding a root shell in the emulator. Targeting and constraints: this is a local attack vector only, not remote. It requires a specifically prepared vulnerable Android 10 x86_64 AVD using a custom Goldfish 4.14.150+ kernel; the stock AVD kernel is noted as patched. The exploit appears tuned to fixed structure offsets and kernel symbols/offsets, so it is highly version-specific and intended for research in an isolated emulator rather than broad real-world deployment. Notable observables/endpoints: target-side file paths include /dev/binder (implied by the Binder exploit), /data/local/tmp/cve-2019-2215-exp for staging/execution, and /bin/sh for post-exploitation shell spawn. The repository also references external build/documentation URLs and local kernel image paths under kernels/.mythicaltree · Disclosed Jun 23, 2026 · c++ · bash · localOperationalroot-sonim-xp3800This repository is a complete Android root-management application for the Sonim XP3800 (XP3plus), not just a standalone proof-of-concept. Its core exploit is the native file su.c, an ARM32 local privilege-escalation exploit for CVE-2019-2215 (Binder use-after-free) tailored to a specific kernel build (3.18.71-perf) with hardcoded structure offsets and a fixed selinux_enforcing kernel address. The exploit uses /dev/binder plus epoll/iovec/pipe primitives to obtain kernel read/write, overwrite cred fields for uid 0 and full capabilities, disable seccomp, set SELinux permissive, and then execute commands or a shell via nsenter in PID 1's mount namespace. Repository structure: the native exploit lives in su.c; assets/install.sh and assets/uninstall.sh install/remove the root environment; Java sources under src/com/flipphoneguy/root/xp3 implement the Android UI and operational features; AndroidManifest.xml defines activities, boot receiver, and a content provider; docs/ contains detailed technical writeups for CVE-2019-2215 and the ARM32 port; build.sh is a custom APK build pipeline. The Java app copies bundled assets, toggles root installation, maintains a blacklist of apps denied su access, handles APK/XAPK installation using root, checks GitHub Releases for updates, and re-runs install.sh at boot through BootReceiver for persistence across reboots. Main capabilities: one-tap local rooting on-device without PC flashing, persistent re-root on boot, root shell/command execution through /sbin/su, package installation via pm install using root, self-update from GitHub, and access control via whitelist/blacklist files in the app data directory. There is no evidence of remote exploitation or C2 behavior; network use is limited to GitHub API/release download functionality for updates. Overall, this is a real, device-specific operational exploit package wrapping a kernel LPE in a user-friendly Android management app.flipphoneguy · Disclosed Jun 30, 2026 · java · c · localOperationalCVE-2019-2215Repository is a small standalone local privilege-escalation exploit for CVE-2019-2215, containing one main code file (exploit.c) and a README describing the attack. The exploit targets the Android binder use-after-free bug triggered through binder and epoll interaction. Based on the visible code and README, its workflow is: bind execution to CPU 0 for race stability; open /dev/binder; create and link an epoll instance to binder; use crafted iovec/pipe interactions to leak a task_struct pointer; exploit the same primitive to corrupt addr_limit in the current task_struct; use pipe-based arbitrary kernel read/write helpers to access and patch the current process cred structure; set UID/GID and related IDs to 0 and grant full capabilities; derive kernel base from nsproxy using hardcoded symbol offsets; clear selinux_enforcing; then execute /bin/sh as root. The exploit is not remote and contains no network C2 or external callbacks. It is operational rather than a mere PoC because it includes a full post-exploitation path to root shell, but it is highly target-specific due to hardcoded structure and symbol offsets and appears intended for vulnerable ARM64 Android kernels.NESTle19 · Disclosed Jul 19, 2026 · c · markdown · localOperationalCVE_2019_2215This repository is a real local privilege escalation exploit for CVE-2019-2215, the Android Binder use-after-free vulnerability. It is not a scanner or detection script. The codebase is a compact standalone Android NDK project composed primarily of C source and headers, with build files (Android.mk, Application.mk, Makefile), a main exploit binary (`poc`), and a minimal trigger-only helper (`trigger/trigger.c`). Repository structure and purpose: - `src/main.c` is the main entry point and orchestrates the full exploit chain. - `src/binder.c` and `include/binder.h` wrap Binder device access and the critical `BINDER_THREAD_EXIT` ioctl. - `src/binder_uaf.c` performs the first exploitation stage: triggering the Binder UAF and leaking a `task_struct` pointer from reclaimed kernel memory. - `src/corrupt_address_limit.c` performs the second stage: using another corrupted iovec path to overwrite `addr_limit` in the current task context. - `src/kernel_rw.c` converts the corrupted `addr_limit` state into arbitrary kernel read/write primitives using pipes. - `src/privilege_escalation.c` uses those primitives to patch credentials, disable SELinux enforcing, verify uid 0, and spawn a shell. - `src/cpu_affinity.c` pins execution to CPU 0 to improve exploit reliability. - `src/event_poll.c` manages epoll operations used in the Binder race/UAF trigger. - `trigger/trigger.c` is a minimal reproducer for the Binder epoll + thread-exit trigger path. Exploit flow: 1. Pin process to CPU 0 for stability. 2. Open `/dev/binder` and query Binder version. 3. Use epoll registration plus `BINDER_THREAD_EXIT` to trigger the Binder UAF. 4. Reclaim the freed Binder thread object with a crafted `iovec` array during a blocked `writev` on a pipe, then leak data back to userland to recover the current `task_struct` pointer and addresses of `pid`, `cred`, and `nsproxy` fields. 5. Trigger the UAF again while a `recvmsg(MSG_WAITALL)` call is blocked on a UNIX socket pair, corrupting iovec metadata so that a write lands on `task_struct->addr_limit`. 6. Set `addr_limit` to `0xFFFFFFFFFFFFFFFE`, enabling kernel memory access through normal pipe read/write syscalls. 7. Verify arbitrary kernel read/write by comparing the kernel `pid` field with the real process PID. 8. Read the `cred` pointer from the current task and overwrite UID/GID/EUID/EGID/FSUID/FSGID plus capability sets to obtain root-equivalent credentials. 9. Derive kernel base from `nsproxy` using hardcoded symbol offsets, locate `selinux_enforcing`, and set it to 0. 10. Confirm root and execute `/bin/sh`. Notable technical assumptions and hardcoded targeting details: - The exploit is architecture- and build-specific. `Application.mk` targets `x86_64` and Android API 29. - Hardcoded offsets include `TASK_STRUCT_OFFSET_IN_LEAKED_DATA`, `OFFSET_TASK_STRUCT_PID`, `OFFSET_TASK_STRUCT_ADDR_LIMIT`, and kernel symbol offsets for `init_nsproxy` and `selinux_enforcing`. - The included structure layouts for `binder_thread`, `task_struct`, and `cred` indicate the exploit expects a matching vulnerable kernel layout. - The README explicitly frames this as a rewritten PoC/LPE for Android 10 emulator/AOSP research kernels. Overall capability assessment: this is an operational local kernel exploit that achieves full privilege escalation on a matching vulnerable Android target and provides an interactive root shell.0xbinder · Disclosed Aug 10, 2026 · c · makefile · localOperationalcve-2019-2215-markwThis six-file repository is a device-specific local privilege-escalation exploit for CVE-2019-2215 (“Bad Binder”). Its main component, bhsu98.c (about 97 KB), is an ARM64 Android C exploit adapted for the Redmi 4 Prime/markw MIUI 10 kernel 3.18.24-perf-g233e5d5. It performs Binder transaction and poll/waitqueue manipulation to trigger a Binder use-after-free, uses kmalloc-512 heap grooming and iovec replacement to leak task-related kernel data, then builds stable arbitrary kernel read/write primitives. The final privilege-escalation stages locate kernel symbols, make SELinux permissive, neutralize seccomp, and elevate the process credentials and capabilities before launching sh or a supplied command. cve-2215-root.sh is the practical ADB launcher. It pushes the compiled bhsu98 binary to /data/local/tmp, reboots the phone before each attempt, waits for sys.boot_completed, and executes the binary up to 15 times because the exploit’s heap-race reliability varies by boot. offsets.txt documents relevant link-time and runtime kernel symbols for the targeted markw kernel, including Binder and ION allocator/spray-related symbols. The GitHub Actions workflow downloads Android NDK r21b and statically cross-compiles bhsu98.c for aarch64 Android API 21, committing a rebuilt binary. README.md describes the temporary-root objective and subsequent optional bootloader-unlock-related flashing steps; those flashing commands are documentation, not automated exploit behavior.Begitdj · Disclosed Aug 19, 2026 · c · bash · local · usbOperationalcve-2019-2215-oppo-a77tThis is a standalone, device-oriented CVE-2019-2215 root-delivery project, not a scanner or an identified exploitation-framework module. The supplied shell code invokes probe26 to arm a modprobe_path payload, triggers a module request through wb_trig_sock using protocol family 30, and polls root-owned evidence files to distinguish successful root execution from completed su installation. Documentation describes a Binder use-after-free trigger involving BINDER_THREAD_EXIT and epoll, followed by a readv self-overwrite chain that writes selinux_enforcing and modprobe_path. The actual probe26 C implementation and helper binaries are not present in the supplied 100-file listing, so those native exploit mechanics and reported device tests cannot be independently verified here. The modprobe payload is a userspace shell process launched by the kernel usermode-helper mechanism as UID 0, not shell code executing directly in kernel mode. The visible main/scripts tree contains nine Android shell files: shared path/logging/environment libraries; hijack, trigger, and evidence-verification stages; the root payload entry; and installation, removal, and daemon-management services. Installation stages su, overlays /system/xbin with tmpfs, attempts to preserve its original entries, labels the delivered client, and starts a root daemon in u:r:shell:s0. Removal kills matching daemons and unmounts the overlay while retaining staging data for reinstallation. This route does not visibly alter the underlying system partition or establish reboot persistence. Documentation references start_up/start.sh, status.sh, reset.sh, six main/bins executables, custom C sources, build scripts, and reproducibility logs, but these are absent from the supplied listing. Most listed source files belong to the bundled Superuser fork, including C SELinux libraries, headers, Makefiles, Gradle configuration, wrappers, and legacy recovery-installation assets. The 75 code/build files counted here include C sources and headers, executable scripts, Groovy, and Makefiles; Java is referenced by the APK project but no Java source files are listed. The legacy recovery installer is separate from the principal exploit route: it modifies /system, installs startup hooks, and replaces app_process32, and its supplied text contains an apparently malformed if statement. The repository documents MIT licensing for original components and GPLv3 distribution of the combined su binary. Repository URL, analyzed git reference, and archive size were not provided; empty strings and zero denote unavailable metadata, not verified values. No external runtime network destination, reverse shell, or exfiltration functionality is apparent in the exploit scripts. The notable runtime observables are /system/xbin/su, the @SUPERUSER local socket, generated start_up/run evidence and logs, marker WBRIG-2026-10, and the me.phh.superuser authorization component. Gradle and GitHub URLs are build dependencies or documentation references, not C2. Operational limitations include unverified compatibility beyond the documented OPPO A77t configuration, permissive handling of missing evidence context or timestamps, duplicated service logging, and missing ancestor protection in daemon kill mode. Snapshot/restoration errors can leave original xbin entries obscured. Teardown tolerates daemon-stop errors and does not visibly revert kernel-state changes. Claims that staging and evidence files form strong security boundaries should be treated cautiously because the package and parent runtime paths originate in application-writable storage. The external authorization APK is required for approved su use, and documentation explicitly states that su checks its package name rather than authenticating its signing certificate.WJNKAC · Disclosed Oct 7, 2026 · c · bash · localOperationalodin-od105-devkitThis is a standalone Android local-root delivery project targeting CVE-2019-2215, not a scanner or an established exploit-framework module. The supplied inventory contains 100 files: nine main-chain shell scripts, documentation and licenses, and a substantial partial phh Superuser source/build subtree with C SELinux libraries. Counting source/header/script files gives 67 code files, excluding build definitions. The original repository URL, analyzed git reference, and archive size were not provided; blank strings and zero represent unavailable metadata. The implemented shell orchestration has four stages: invoke probe26 to arm modprobe_path; invoke wb_trig_sock to trigger module autoload; poll root-owned evidence files; and execute the root delivery or teardown service. Documentation describes probe26 as exploiting Binder thread lifetime handling through BINDER_THREAD_EXIT and epoll, then using a readv self-overwrite chain to write selinux_enforcing=0 and replace modprobe_path. However, probe26.c, the helper C sources, main/bins executables, start_up scripts, su implementation files, and reproducibility logs referenced by the documentation are absent from this supplied 100-file inventory. Consequently, the kernel primitive, kernel-layout compatibility, binary hashes, and reported successful device tests cannot be independently verified here. The socket operation is a local kernel trigger, not a connection to an attacker-controlled host. Module autoload invokes the overwritten helper as UID 0 in the kernel SELinux domain. Despite the repository's 'kernel execution' terminology, the shell payload executes in user space via call_usermodehelper, not as kernel-mode shell code. It asynchronously stages su, snapshots /system/xbin, overlays that directory with tmpfs, restores original entries, installs a 0755 su client, and launches a root daemon through wb_runcon and /system/bin/sh into u:r:shell:s0. Client authorization depends on a separate me.phh.superuser APK. Root access is maintained during the running session; reboot persistence is not established by the main chain. The scripts support idempotent start, daemon discovery, readiness checks, and teardown. Success checks combine root-owned marker-bearing evidence, timestamps, and su visibility rather than trusting the socket helper's exit code. Important limitations remain: a missing context field passes validation; missing freshness metadata disables that check; daemon context/PATH mismatches only warn; daemon readiness ultimately accepts a matching root process even if the socket wait expires; snapshot/restore failures can leave original xbin utilities hidden; and stop removes the daemon/overlay but does not undo the kernel-variable changes. The documentation also identifies duplicate logging and missing ancestor protection for direct daemon kill operations. Root-owned staging and evidence are under an app-controlled package tree and should not be treated as a robust security boundary. No remote command-and-control or exfiltration endpoint is evident in the main scripts. Observable artifacts include /system/xbin/su, the SUPERUSER Unix socket, WBRIG-2026-10 markers, runtime evidence/log files, and the phh authorization database. Gradle and GitHub addresses are build dependencies or documentation references. The vendored subtree additionally includes an obsolete recovery installer that modifies /system and replaces app_process32; it is separate from the main overlay-based path and contains an apparent shell syntax error. Scoped recursive deletion in snapshot/build/legacy installer code is consistent with cleanup and replacement, not by itself evidence of a fake exploit. Project-owned components are documented as MIT, while the su fork is mixed-license and its binary is documented as GPLv3.FDLAlfrid · Disclosed Oct 10, 2026 · c · shell · localOperationalold-phone-temp-rootThe supplied repository contains 16 files, including five Python utilities, four C sources, one shell payload, and six documentation/metadata files. It is a standalone operational local privilege-escalation chain, not a framework module or detection-only script. The documented reference target is a Xiaomi Mi 5 running Android 6.0.1/MIUI 8.1.3.0 and an arm64 Linux 3.18.20 kernel; successful execution was not independently verified. src/probe26.c implements the CVE-2019-2215 Binder use-after-free chain. A Binder transaction establishes the required thread state; epoll retains a wait-queue reference after BINDER_THREAD_EXIT frees the thread. A blocking readv allocation reclaims the freed object, and epoll removal corrupts that allocation into a self-overwriting iovec chain. The intended result is two kernel writes: zeroing selinux_enforcing and replacing modprobe_path with the payload pathname. src/trig_sock.c then requests unsupported protocol family 30 to invoke module autoloading and execute the replacement helper as root. No external HTTP, DNS, IP, or TCP destination is present; USB is the documented deployment transport, not the vulnerability itself. payload/wb.sh installs a setuid su on tmpfs and starts the rootshell daemon. src/su.c provides minimal setuid shell execution. src/rootshell.c supplies a daemon/client protocol for interactive shells and arbitrary commands, with command output capped at 4 MiB. Its world-writable Unix socket has no caller authentication, exposing root execution to reachable local processes. allowall.py optionally installs the capability-limited setuid variant into /sbin, while suclient.py installs the daemon-backed variant for fuller privileges. build.py cross-compiles static aarch64 binaries using the Android NDK. deploy.py stages files through adb, runs the exploit and module trigger, checks SELinux and root identity, and optionally installs /sbin/su. Documentation covers object geometry, portability constraints, and failure modes. Incorrect heap reuse or offsets can crash or reboot the device. cleanup.py removes artifacts and attempts to unmount tmpfs, but despite its description it contains no explicit daemon-termination operation and does not restore the modified kernel variables; reboot is the complete recovery mechanism. Its scoped removal commands are consistent with cleanup and are not evidence of a fake exploit. The main exploit source is truncated in the supplied content, limiting complete implementation review. No repository URL, revision, archive location, or archive byte size was supplied; empty strings and zero represent unavailable repository metadata.kilokite · Disclosed Oct 20, 2026 · python · c · local · usbOperationalcve-2019-2215-skyworthThe supplied repository contains four files: a device-specific README, a C privilege-escalation exploit, a Python ELF patcher, and an Android shell configuration helper. It ports CVE-2019-2215 from a Sony Bravia implementation to Skyworth 65G60 / Coocaa 9S60 hardware. The vulnerability involves Binder thread lifetime handling and epoll cleanup, enabling use-after-free primitives used to locate the current task and modify credentials. The documented adaptations are a static AArch64 binary for 32-bit-only userspace, PT_TLS alignment correction, runtime discovery of adjacent real_cred/cred pointers, and tolerating a device-specific short writev return. The visible main function forks and retries up to 12 times. Normal execution locates the task, patches credentials, and launches command execution; separate debug, dump, and explicit credential-offset modes are present. The README reports successful temporary root but states that changing addr_limit does not yield conventional arbitrary kernel access on this kernel, so memory access must use the UAF primitives directly. Legacy debug-stage labels claiming arbitrary kernel R/W or SELinux bypass should not be taken as independently verified capabilities on this target. patch_tls.py validates ELF64/AArch64 headers and raises PT_TLS alignment to 64 in a caller-specified binary. tools/fix-home.sh is an optional post-exploitation customization tool, not the privilege-escalation trigger. It persistently replaces DEFAULT_HOMEPAGE with an Aerial launcher component. Despite the README's backup wording, the script expects the backup to exist and does not create it or robustly validate the generated configuration before overwriting the live file, creating a configuration-damage risk. No runtime network destination, reverse shell, downloader, or exfiltration behavior is visible. URLs are attribution and technical references. The central portion of src/poc-sky.c was truncated in the supplied content, limiting verification of the exploit primitives and shell implementation. Analysis is static; no execution was performed. The original repository URL, revision, archive path, and archive size were not provided; empty metadata and size 0 represent unavailable values.xushihushuo-art · Disclosed Oct 23, 2026 · c · python · 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
CanonicalUbuntu Linuxoperating_system
Debian ProjectDebian Linuxoperating_system
GoogleAndroidoperating_system
Huawei TechnologiesAlp-Al00b Firmwareoperating_system
Huawei TechnologiesAlp-Tl00b Firmwareoperating_system
Huawei TechnologiesAnne-Al00 Firmwareoperating_system
Huawei TechnologiesAres-Al00b Firmwareoperating_system
Huawei TechnologiesAres-Al10d Firmwareoperating_system
Huawei TechnologiesAres-Tl00chw Firmwareoperating_system
Huawei TechnologiesBarca-Al00 Firmwareoperating_system
Huawei TechnologiesBerkeley-L09 Firmwareoperating_system
Huawei TechnologiesBerkeley-Tl10 Firmwareoperating_system
Huawei TechnologiesBla-Al00b Firmwareoperating_system
Huawei TechnologiesBla-L29c Firmwareoperating_system
Huawei TechnologiesBla-Tl00b Firmwareoperating_system
Huawei TechnologiesColumbia-Al00a Firmwareoperating_system
Huawei TechnologiesColumbia-L29d Firmwareoperating_system
Huawei TechnologiesCornell-Tl10b Firmwareoperating_system
Huawei TechnologiesDuke-L09i Firmwareoperating_system
Huawei TechnologiesDura-Al00a Firmwareoperating_system
Huawei TechnologiesFigo-Al00a Firmwareoperating_system
Huawei TechnologiesFlorida-Al20b Firmwareoperating_system
Huawei TechnologiesFlorida-L03 Firmwareoperating_system
Huawei TechnologiesFlorida-L21 Firmwareoperating_system
Huawei TechnologiesFlorida-L22 Firmwareoperating_system
Huawei TechnologiesFlorida-Tl10b Firmwareoperating_system
Huawei TechnologiesHonor 9i Firmwareoperating_system
Huawei TechnologiesHonor View 20 Firmwareoperating_system
Huawei TechnologiesJakarta-Al00a Firmwareoperating_system
Huawei TechnologiesJohnson-Tl00d Firmwareoperating_system
Huawei TechnologiesLeland-Al10b Firmwareoperating_system
Huawei TechnologiesLeland-L21a Firmwareoperating_system
Huawei TechnologiesLeland-L32a Firmwareoperating_system
Huawei TechnologiesLeland-Tl10b Firmwareoperating_system
Huawei TechnologiesLeland-Tl10c Firmwareoperating_system
Huawei TechnologiesLelandp-Al00c Firmwareoperating_system
Huawei TechnologiesLelandp-L22c Firmwareoperating_system
Huawei TechnologiesMate Rs Firmwareoperating_system
Huawei TechnologiesNeo-Al00d Firmwareoperating_system
Huawei TechnologiesNova 2s Firmwareoperating_system
Huawei TechnologiesNova 3 Firmwareoperating_system
Huawei TechnologiesNova 3e Firmwareoperating_system
Huawei TechnologiesP20 Firmwareoperating_system
Huawei TechnologiesP20 Lite Firmwareoperating_system
Huawei TechnologiesPrinceton-Al10b Firmwareoperating_system
Huawei TechnologiesRhone-Al00 Firmwareoperating_system
Huawei TechnologiesStanford-L09 Firmwareoperating_system
Huawei TechnologiesStanford-L09s Firmwareoperating_system
Huawei TechnologiesSydney-Al00 Firmwareoperating_system
Huawei TechnologiesSydney-Tl00 Firmwareoperating_system
Huawei TechnologiesSydneym-Al00 Firmwareoperating_system
Huawei TechnologiesTony-Al00b Firmwareoperating_system
Huawei TechnologiesTony-Tl00b Firmwareoperating_system
Huawei TechnologiesY9 2019 Firmwareoperating_system
Huawei TechnologiesYale-Al00a Firmwareoperating_system
Huawei TechnologiesYale-L21a Firmwareoperating_system
Huawei TechnologiesYale-Tl00b Firmwareoperating_system
NetAppA220 Firmwareoperating_system
NetAppA320 Firmwareoperating_system
NetAppA800 Firmwareoperating_system
NetAppAff Baseboard Management Controller Firmwareoperating_system
NetAppC190 Firmwareoperating_system
NetAppCloud Backupapplication
NetAppData Availability Servicesapplication
NetAppFas2720 Firmwareoperating_system
NetAppFas2750 Firmwareoperating_system
NetAppH300s Firmwareoperating_system
NetAppH410c Firmwareoperating_system
NetAppH410s Firmwareoperating_system
NetAppH500s Firmwareoperating_system
NetAppH610s Firmwareoperating_system
NetAppH700s Firmwareoperating_system
NetAppHci Management Nodeapplication
NetAppService Processorapplication
NetAppSolidfireapplication
NetAppSolidfire Baseboard Management Controller Firmwareoperating_system
NetAppSteelstore Cloud Integrated Storageapplication
FAQ

Frequently asked questions

Is CVE-2019-2215 exploited in the wild?
Yes. As of Oct 30, 2026, Mallory has reports of exploitation in the wild, and CISA added it to KEV on Nov 3, 2021.
Is there a public exploit for CVE-2019-2215?
Yes. Mallory tracks 32 public exploits or proofs of concept for CVE-2019-2215, the earliest disclosed Sep 26, 2019.
Is there a patch for CVE-2019-2215?
Install device-manufacturer firmware or kernel updates containing the CVE-2019-2215 Binder lifetime-management fix, addressed in the October 2019 Android Security Bulletin. The underlying fix had reached upstream Linux and Android kernel branches in February 2018 but was absent from many shipped devices; verify its inclusion in the actual device build rather than relying solely on the Android major version.
What products are affected by CVE-2019-2215?
Google Android, NetApp A220 Firmware, NetApp A320 Firmware, NetApp A800 Firmware, NetApp Aff Baseboard Management Controller Firmware, and at least 72 more.
How severe is CVE-2019-2215?
CVE-2019-2215 has a CVSS v3.1 score of 7.8 (High) and an EPSS score of 72.1% (99th percentile) as of Oct 30, 2026.
Activity feed

Recent activity

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

View more in app →
cyberveilleNews · Aug 19, 2026Comment des cyber-espions français ont hacké EncroChat avec du code copié depuis GitHub | CyberVeilleA Linux/Android kernel use-after-free privilege escalation vulnerability, known as Bad Binder, used in the EncroChat implant operation to gain elevated privileges and disable SELinux on targeted devices.Read more ↗computerweeklyNews · Aug 19, 2026Revealed: Cyber spies used malware from GitHub to hack EncroChat cryptophone network | Computer WeeklyAn Android/Linux kernel privilege-escalation vulnerability, described as a use-after-free flaw, that allowed attackers to gain root control of phones and was used as part of spyware and law-enforcement implant activity against EncroChat devices.Read more ↗8ksec blogNews · Jun 24, 2026Android SELinux Internals Part 4 - Policy Analysis, Kernel Mitigations, and Android 16 Changes | 8kSecAn Android kernel use-after-free vulnerability cited as an example of exploitation toward arbitrary kernel read/write. The article discusses it as background for how Memory Tagging Extension (MTE) can disrupt exploitation, rather than analyzing the vulnerability itself.Read more ↗8ksec blogNews · Jun 3, 2026Android SELinux Internals Part 3 - Kernel-Level SELinux Bypass and Real-World Exploit Chains | 8kSecAn Android Binder use-after-free reachable from an unprivileged app that provides kernel read/write capabilities. The described exploit chain disables SELinux enforcement, modifies credentials, and disables SECCOMP to obtain unrestricted root access. The content attributes in-the-wild exploitation to NSO Group's Pegasus spyware.Read more ↗
+10 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 evidence8Every report linking this CVE to a named adversary.
Associated malware15Malware families linked to this CVE, with evidence and IOCs.
Detection signatures2YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity2Community discussion across Reddit, Mastodon, and other social sources.