CVE-2022-0847

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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), 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 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 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 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 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 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 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.

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 written in C and include a compilation script.

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 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), 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 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 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.

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 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 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 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 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 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 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.

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 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 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 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 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 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 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 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 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 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 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 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 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), 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 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.

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 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.

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 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 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.

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

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 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.

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 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.

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), 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 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 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 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.