CVE-2022-0847

This exploit leverages CVE-2022-0847 (DirtyPipe) to overwrite arbitrary read-only files via uninitialized pipe_buffer.flags, enabling local privilege escalation by injecting a SUID binary with malicious ELF code.

This is a modified proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache. The exploit specifically targets /etc/passwd to set the root password to 'aaron' and then spawns a root shell, restoring the original /etc/passwd afterward.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files. The exploits demonstrate modifying /etc/passwd and hijacking SUID binaries.

This repository contains a proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting any file contents in the page cache, even if the file is read-only or immutable. The exploit demonstrates privilege escalation by modifying the /etc/passwd file to gain root access without a password.

This is a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting arbitrary files in the page cache. The exploit leverages uninitialized pipe_buffer.flags to bypass file permissions and write to read-only files.

This repository is a stub that redirects to another location for the actual Dirty Pipe (CVE-2022-0847) container escape PoC. No exploit code is present in this repository.

This repository contains a bash script to check if a Linux kernel is vulnerable to CVE-2022-0847 (Dirty Pipe). It compares kernel versions against known vulnerable ranges and outputs whether the system is vulnerable or not.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, even on read-only files or immutable files. The exploit modifies /etc/passwd to add a password for the root user and then spawns a shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, bypassing file permissions and read-only mounts.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite read-only files, including SUID binaries, to escalate privileges to root. The PoC injects shellcode into a target binary, spawns a root shell, and attempts to restore the original binary.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows arbitrary file overwrites by leveraging a vulnerability in the Linux kernel's pipe mechanism. The exploit demonstrates modifying the /etc/passwd file to achieve privilege escalation.

This repository contains a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating container escape by overwriting read-only files on the host system. The exploit leverages the `CAP_DAC_READ_SEARCH` capability to bypass file read permissions and uses `splice()` to overwrite target files.

This repository contains an eBPF-based detection tool for CVE-2022-0847 (Dirty Pipe), which monitors splice syscalls to identify exploitation attempts. It uses kernel tracepoints to detect suspicious pipe operations and logs events for analysis.

This repository contains a working proof-of-concept exploit for CVE-2022-0847, also known as the 'Dirty Pipe' vulnerability in the Linux kernel. The exploit leverages an uninitialized variable in the `copy_page_to_iter_pipe` function to achieve local privilege escalation by overwriting arbitrary read-only files.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel privilege escalation vulnerability. It leverages uninitialized pipe_buffer.flags to overwrite arbitrary file contents in the page cache, even on read-only files or mounts.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting read-only files by leveraging an uninitialized pipe_buffer.flags variable in Linux kernels 5.8 to 5.16.10, 5.15.24, or 5.10.101.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing arbitrary file writes. The exploit includes a modular C implementation with options to overwrite files like /etc/passwd for privilege escalation.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, even on read-only files or immutable files. The exploit demonstrates privilege escalation by modifying /etc/passwd to gain root access.

This is a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe buffer flag to overwrite read-only files and escalate privileges by hijacking a SUID binary to spawn a root shell.

This is a Python-based exploit for CVE-2022-0847 (DirtyPipe), which leverages the Linux kernel vulnerability to overwrite read-only files (e.g., /etc/passwd, sudo, su) to escalate privileges to root. It combines techniques from existing PoCs and drops a setuid root shell.

This is a one-line exploit for CVE-2022-0847 (Dirty Pipe), which downloads a precompiled static binary from a GitHub repository, sets executable permissions, and runs it. The exploit leverages the Dirty Pipe vulnerability to achieve local privilege escalation.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting data in arbitrary read-only files by leveraging an uninitialized pipe_buffer.flags variable in the Linux kernel. The exploit demonstrates privilege escalation by injecting code into root processes.

This repository contains an eBPF-based detection and mitigation tool for CVE-2022-0847 (Dirty Pipe vulnerability). It monitors splice() system calls for malicious pipe buffer flags and kills offending processes while clearing page caches.

This repository contains two functional exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing unprivileged users to overwrite read-only files and escalate privileges. Exploit 1 modifies /etc/passwd to gain a root shell, while Exploit 2 injects data into SUID process memory.

This PoC exploits CVE-2022-0847 (Dirty Pipe) to overwrite arbitrary files by manipulating the pipe buffer flags, allowing privilege escalation by modifying /etc/passwd to add a backdoor root user.

This is a functional exploit for CVE-2022-0847 (DirtyPipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting data in read-only files. The PoC injects a small ELF binary into a SUID executable to gain root access.

This repository contains a proof-of-concept (PoC) and exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file writes and privilege escalation via SUID binary overwriting. The exploit leverages pipe buffer manipulation to achieve root access.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite arbitrary files via pipe manipulation. The exploit injects shellcode into a SUID binary (e.g., /usr/bin/su) to escalate privileges and spawn a root shell.

This repository contains a functional Go-based exploit for CVE-2022-0847 (Dirty Pipe), which allows container escape by overwriting arbitrary files via pipe buffer manipulation. The code includes pipe initialization, file handle brute-forcing, and file content overwriting.

This Go-based PoC exploits CVE-2022-0847 (Dirty Pipe) to achieve container escape by overwriting arbitrary files. It uses pipe manipulation and file handle brute-forcing to inject data into read-only files.

This is a pwncat module that automates the exploitation of CVE-2022-0847 (dirtypipe) for local privilege escalation to root. It checks kernel vulnerability, compiles an exploit on the target, and executes it without requiring manual setup.

This repository contains a Python script that checks if a given Linux kernel version is vulnerable to CVE-2022-0847 (Dirty Pipe). It does not exploit the vulnerability but merely verifies version-based susceptibility.

This exploit leverages CVE-2022-0847 (Dirty Pipe) to overwrite data in read-only files, specifically modifying /etc/passwd to add a backdoor root user with a known password. It then spawns a root shell to restore the original file and execute commands.

This repository contains a modified Dirty Pipe (CVE-2022-0847) exploit that automates privilege escalation by hijacking a SUID binary to spawn a root shell. It includes two C files (`dirty.c` and `dirtypipe2.c`) that leverage the vulnerability to overwrite file contents in the page cache, even on read-only files or immutable files.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files or hijacking SUID binaries. The exploits are well-documented and include a compilation script for ease of use.

This repository contains a Python script to generate shellcode for CVE-2022-0847, a Linux kernel vulnerability. The shellcode is designed to modify files (e.g., /etc/passwd) to achieve privilege escalation by exploiting the Dirty Pipe flaw.

This is a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows arbitrary file overwrite by leveraging an uninitialized pipe_buffer.flags variable in the Linux kernel. The exploit modifies /etc/passwd to escalate privileges by injecting a password for the root user.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows local privilege escalation by injecting data into read-only files via pipe manipulation. The PoC includes an automatic root method that hijacks the /etc/passwd file to spawn a root shell.

This repository contains a functional Proof of Concept (PoC) exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability affecting versions 5.8 to 5.16. The exploit manipulates pipe buffers to overwrite read-only files, such as SUID binaries, to achieve local privilege escalation.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite data in read-only files, specifically targeting /etc/passwd to achieve local privilege escalation (LPE). The PoC includes kernel version checks and a backup/restore mechanism for the passwd file.

This repository provides a script to patch the Dirty Pipe vulnerability (CVE-2022-0847) by compiling and installing Linux kernel 5.18 on Debian 11. It includes instructions and dependencies for manual kernel compilation.

This exploit leverages CVE-2022-0847 (Dirty Pipe) to overwrite the runC binary in a container, injecting shellcode to achieve container escape. It uses the Dirty Pipe vulnerability to modify the entry point of the runC executable, allowing arbitrary command execution outside the container.

This is a Rust implementation of the Dirty Pipe exploit (CVE-2022-0847), which allows overwriting arbitrary files in the page cache by leveraging an uninitialized pipe_buffer.flags variable. It demonstrates privilege escalation by modifying read-only files, such as /root/.ssh/authorized_keys.

This repository contains three proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files via improper pipe buffer flag handling.

This repository contains a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating privilege escalation by overwriting read-only files and injecting shellcode into SUID binaries to gain a root shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache, even on read-only mounts or immutable files. The exploit hijacks a SUID binary to spawn a root shell and attempts to restore the original binary afterward.

This repository contains a functional PoC for CVE-2022-0847 (DirtyPipe), demonstrating container breakout by exploiting a Linux kernel vulnerability to overwrite read-only files. The exploit modifies `/proc/self/exe` to inject a malicious payload, achieving privilege escalation.

This repository contains a detection script for CVE-2022-0847 (Dirty Pipe), which checks if the system's kernel version is vulnerable. It does not include an exploit but provides a list of vulnerable kernel versions and references.

This is a functional proof-of-concept exploit for CVE-2022-0847 (DirtyPipe), which allows overwriting data in read-only files by leveraging an uninitialized pipe_buffer.flags variable in the Linux kernel. The exploit demonstrates arbitrary file modification even on immutable or read-only mounted files.

This PoC exploits CVE-2022-0847 (Dirty Pipe) to overwrite data in read-only files by manipulating the Linux kernel's pipe buffer handling. It uses splice() and write() to inject arbitrary payloads into non-writable files.

This repository contains a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting any file contents in the page cache, even on read-only files or mounts. The exploit includes both a shell script and a C program to demonstrate privilege escalation by modifying the /etc/passwd file or hijacking a SUID binary.

This is a modified version of Max Kellermann's Dirty Pipe (CVE-2022-0847) exploit that overwrites the root password in /etc/passwd to gain a root shell. It backs up the original file and restores it after exploitation.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache, even on read-only mounts. It modifies /etc/passwd to add a backdoor root user with a known password.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting data in read-only files by leveraging an uninitialized pipe_buffer.flags variable. The script automates the process of modifying /etc/passwd to remove the root password, enabling privilege escalation.

This repository contains a working exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files via improper pipe buffer handling. The exploit demonstrates modifying /etc/passwd to gain root access.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating privilege escalation by overwriting arbitrary read-only files in the Linux kernel. The exploit is packaged in a Docker environment for safe testing and educational purposes.

This is a functional exploit for CVE-2022-0847 (DirtyPipe), which leverages improper input validation in the Linux kernel's pipe mechanism to overwrite data in read-only files. The PoC modifies /etc/passwd to add a backdoor user with root privileges.

This repository contains a bash script to check for CVE-2022-0847 (Dirty Pipe) vulnerability in Linux kernels. It verifies kernel versions against known vulnerable ranges and outputs whether the system is potentially vulnerable.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages the vulnerability to modify read-only files (e.g., /etc/pam.d/su) to bypass authentication and execute a reverse shell via socat.

This is a Python-based PoC exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite arbitrary files and escalate privileges by adding the current user to the sudo group. The exploit corrupts the /etc/group file and backs it up to /tmp/group_backup.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting arbitrary files in the page cache by leveraging an uninitialized pipe_buffer.flags variable. The exploit includes a checker script to verify vulnerability status and a C-based PoC to demonstrate the attack.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting arbitrary files in the page cache, even on read-only mounts or immutable files. The exploit leverages an uninitialized pipe_buffer.flags variable in Linux kernels 5.8 and later.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows arbitrary file overwrites on Linux systems by manipulating the pipe buffer flags. The PoC demonstrates privilege escalation by modifying /etc/passwd to add a root user.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite via uninitialized pipe_buffer.flags in Linux kernel 5.8+. It modifies /etc/passwd to remove the root password for privilege escalation.

This repository contains a shell script to check if a Linux kernel is vulnerable to CVE-2022-0847 (Dirty Pipe). It compares the kernel version against known vulnerable versions and outputs whether the system is affected.

This is a modified proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache. The exploit specifically targets /etc/passwd to set the root password to 'aaron' and then spawns a root shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite in the page cache by leveraging uninitialized pipe_buffer.flags. It allows privilege escalation by injecting data into read-only files.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows arbitrary file overwrites in the page cache by exploiting an uninitialized pipe_buffer.flags variable. The exploit demonstrates privilege escalation by modifying /etc/passwd to add a root user with a known password.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache. The exploit demonstrates privilege escalation by modifying /etc/passwd to add a backdoor user with root privileges.

This repository contains a functional exploit for CVE-2022-0847, a Linux kernel vulnerability (Dirty Pipe) that allows local privilege escalation by overwriting arbitrary files via pipe buffer manipulation. The exploit modifies /etc/passwd to gain root access.

This repository provides a detailed technical explanation of CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing privilege escalation via improper handling of pipe buffers and page cache. It describes the root cause, impact, and exploitation mechanics but does not include functional exploit code.

This repository documents a penetration test report detailing an attack chain that includes CVE-2022-0847 (Dirty Pipe) for kernel privilege escalation. It provides a structured overview of tools, methodologies, and outputs but does not contain direct exploit code.

This is a detailed penetration test report documenting an attack chain involving CVE-2022-0847 (DirtyPipe) for privilege escalation on a Debian system. The report includes technical steps, exploit methodology, and post-exploitation analysis.

This repository contains a proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe) enhanced with theoretical temporal viscosity mechanisms for persistence and stealth. The exploit leverages physics-based concepts like temporal resonance and fractal encoding to evade detection.

This repository contains a detailed writeup explaining the Dirty Pipe vulnerability (CVE-2022-0847) in Linux Kernel 5.8–5.15.24, focusing on the logic bug in the PIPE_BUF_FLAG_CAN_MERGE flag and its exploitation mechanics.

This repository contains a proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating privilege escalation via pipe buffer manipulation. It includes both a differential fuzzing-based detector and a minimal handcoded reproducer.

This exploit leverages CVE-2022-0847 (DirtyPipe) to overwrite the root password entry in /etc/passwd, effectively removing the password requirement for root access. It uses the splice() system call to inject a payload into the file via a pipe.

The repository contains only a README.md file with minimal content, lacking any functional exploit code or detailed proof-of-concept for CVE-2022-0847. It appears to be a placeholder or incomplete submission.

This repository contains a Rust implementation of the DirtyPipe (CVE-2022-0847) exploit, which allows overwriting arbitrary files or SUID binaries to escalate privileges. It includes helper scripts to generate custom SUID payloads and verify kernel vulnerability.

This is a modified Proof-of-Concept exploit for CVE-2022-0847 (Dirty Pipe), which overwrites the root password in `/etc/passwd` to gain a root shell. It includes a backup and restoration mechanism for `/etc/passwd`.

This is a working exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting arbitrary files in the page cache. The PoC hijacks a SUID binary to spawn a root shell and includes a mechanism to restore the damaged binary.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite via a Linux kernel pipe mechanism flaw, leading to privilege escalation by modifying /etc/passwd.

This repository provides a proof-of-concept for CVE-2022-0847 (Dirty Pipe), demonstrating how to overwrite a read-only file by exploiting a vulnerability in the Linux kernel's pipe mechanism. It includes setup instructions, a script to generate the target file, and a verification script.

This repository contains two Python-based exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation. The exploits demonstrate file modification (e.g., /etc/passwd) and SUID binary hijacking to gain root access.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite arbitrary files. The exploit modifies /etc/passwd to add a backdoor root user and includes a destructive payload that deletes files via `rm -rf / --no-preserve-root`.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting data in arbitrary read-only files by leveraging an uninitialized pipe_buffer.flags variable in the Linux kernel. The exploit demonstrates privilege escalation by modifying /etc/passwd to gain root access.

The repository contains only a compile script for two exploit files (exploit-1.c and exploit-2.c) but lacks the actual exploit code. CVE-2022-0847 is a known Dirty Pipe vulnerability affecting Linux kernels.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files or hijacking SUID binaries. The exploits are derived from Max Kellermann's original research and include modifications to change the root password in /etc/passwd or inject data into SUID process memory.

This script checks if a given Linux kernel version is vulnerable to CVE-2022-0847 (Dirty Pipe). It parses the kernel version and compares it against known vulnerable ranges.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability that allows arbitrary file overwrites. The exploit demonstrates privilege escalation by modifying /etc/passwd to gain root access.

The repository contains only a README.md file with minimal content, lacking any exploit code or technical details. It appears to be a placeholder or incomplete submission.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files or hijacking SUID binaries. The exploits are derived from Max Kellermann's original research and include automated compilation and execution scripts.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite via uninitialized pipe_buffer.flags in Linux kernel 5.8+. PoC1 writes data to any file, while PoC2 hijacks a SUID binary to spawn a root shell.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite via uninitialized pipe_buffer.flags. The first PoC (poc.c) writes arbitrary data to any file, while the second (dirtypipe.c) hijacks a SUID binary to spawn a root shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, bypassing file permissions and read-only mounts. The exploit demonstrates privilege escalation by modifying sensitive files like /root/.ssh/authorized_keys.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing local privilege escalation by overwriting read-only files or hijacking SUID binaries. The exploits are written in C and include a compilation script.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite arbitrary files in the page cache. The PoC modifies /etc/passwd or /etc/group to escalate privileges to root.

This repository contains two proof-of-concept exploits for CVE-2022-0847 (Dirty Pipe), demonstrating how to overwrite arbitrary file contents in the page cache, even on read-only files or immutable files. The exploits leverage an uninitialized pipe_buffer.flags variable to achieve privilege escalation.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache, achieving local privilege escalation by injecting shellcode into a setuid binary.

This repository contains a README describing CVE-2022-0847, a Linux kernel vulnerability allowing arbitrary read-only file data overwrites, leading to privilege escalation. No exploit code is present, only a textual explanation.

This is a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary files in the page cache, enabling local privilege escalation by modifying /etc/passwd.

This is a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages a Linux kernel vulnerability to overwrite arbitrary files, including SUID binaries, to achieve local privilege escalation (LPE). The PoC injects shellcode into a target binary to spawn a root shell and attempts to restore the original binary afterward.

This repository contains a detailed technical analysis and presentation materials for debugging the Dirty Pipe vulnerability (CVE-2022-0847) in the Linux kernel. It includes references to the original PoC, patch analysis, and step-by-step explanations of the vulnerability mechanics.

This repository contains a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, even on read-only files or immutable files. The exploit demonstrates privilege escalation by modifying the /etc/passwd file to gain root access.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, enabling local privilege escalation by hijacking SUID binaries.

This repository contains a working proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing arbitrary read-only file modification and local privilege escalation. The exploit leverages uninitialized pipe_buffer.flags to overwrite data in the page cache.

The repository contains only a README.md file with minimal content, lacking any exploit code or technical details for CVE-2022-0847 (DirtyPipe).

This repository provides a one-line exploit for CVE-2022-0847 (Dirty Pipe), which downloads and executes a precompiled static binary to exploit the vulnerability. The exploit leverages improper handling of pipe buffers in the Linux kernel to achieve local privilege escalation.

This is a working exploit for CVE-2022-0847 (Dirty Pipe), which allows local privilege escalation by overwriting data in read-only files via uninitialized pipe buffer flags. The PoC hijacks a SUID binary to spawn a root shell and attempts to restore the original binary afterward.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe_buffer.flags variable to overwrite arbitrary file contents in the page cache, even on read-only files or immutable files. The exploit modifies /etc/passwd to add a password for the root user and then spawns a root shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting arbitrary files in the page cache by leveraging an uninitialized pipe_buffer.flags variable in the Linux kernel.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite in the page cache by leveraging an uninitialized pipe_buffer.flags variable. It allows writing to read-only files or immutable files by splicing data into the pipe and merging it into the target file's cache.

This repository contains a proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing arbitrary file overwrites. The exploit leverages improper flag initialization in pipe buffers to inject data into read-only files, potentially leading to privilege escalation.

This repository contains a Proof of Concept (PoC) for the Dirty Pipe vulnerability (CVE-2022-0847), which exploits a flaw in the Linux kernel to overwrite data in read-only files. The PoC hijacks a SUID binary to spawn a root shell and attempts to restore the binary afterward.

This repository contains a proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), which allows overwriting any file contents in the page cache, even if the file is read-only, immutable, or on a read-only mount. The exploit demonstrates privilege escalation by hijacking a SUID binary to spawn a root shell.

This is a functional proof-of-concept exploit for CVE-2022-0847 (Dirty Pipe), demonstrating arbitrary file overwrite in the page cache by leveraging uninitialized pipe_buffer.flags in Linux kernels 5.8 and later.

This repository contains functional exploit code for CVE-2022-0847, demonstrating a kernel privilege escalation via a buffer overflow with Ret2usr and kernel ROP techniques. It includes scripts and C code to compile, run, and test the exploit in a QEMU environment.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which allows privilege escalation by overwriting read-only files in the page cache. The exploit modifies '/etc/passwd' to gain root access, along with detection tools for monitoring such activities.

This repository contains a functional exploit for CVE-2022-0847, a Linux kernel vulnerability (Dirty Pipe). The exploit code demonstrates privilege escalation by manipulating kernel memory structures to gain root access.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe) that demonstrates container escape by overwriting read-only files on the host. The exploit leverages the `CAP_DAC_READ_SEARCH` capability to bypass file permissions and uses `splice()` to overwrite target files.

This repository contains a functional exploit for CVE-2022-0847 (Dirty Pipe), which leverages an uninitialized pipe buffer flag to overwrite read-only files and escalate privileges. The PoC hijacks a SUID binary to spawn a root shell and includes shellcode for privilege escalation.

This Metasploit module exploits CVE-2022-0847 (Dirty Pipe), a Linux kernel vulnerability allowing arbitrary read-only file modifications. It overwrites a SUID binary with a payload, executes it for privilege escalation, and restores the original binary.