[C] Ein Exploit in C schreiben

[aeo]

Abend,


ich bin seit mehreren Tagen dabei mir ein Exploit (Grund: Studium) zu schreiben, was ich auch präsentieren soll. Ich komme gerade nicht weiter und brauche etwas kompetenten Rat.

Zu meinem Thema soll ich die NOP Slide anhand eines Beispiels erklären. Bevor ich mich nun an NOP's heranwage, möchte ich erstmal ein einfaches Exploit schreiben.

Unter Windoof habe ich echt Probleme gehabt zu debuggen. Aber das ist ein anderes Thema.

Frage #1

In meinem Programm erwarte ich 12 characters (12 Byte) und der EBP ist 4 Byte groß.
Also überschreibe ich die return-Adresse mit meinen sinnlosen charactern und an der 16. Stelle kommt meine Zieladresse.
An dieser Zieladresse kann ich anscheinend nur im derzeitigen Stack Frage Adressen angeben. Egal welche Adresse ich in Linux GDB/GNU eingebe, er landet immer wieder bei der Funktion gets().






Kann ich also nur im derzeitigen Stack Frage Zieladressen eingeben?
-Falls ja, was bringt es dem Angreifer dann? Er kann ja dann nur im Stack Frame des Programms rumspringen.
Ich bin mir sicher man kann auch statt die retq Adresse zu ändern auch gleich ein Assembler Shellcode eingeben, der dann z.B. eine Shell öffnet und ein User erstellt.

Ich weiß leider nur nicht, wie ich das machen soll. Wie muss ich mir so ein Angriff vorstellen?

Szenario:

Auf einem Server habe ich ein Programm laufen, welches genau eine Eingabe erwartet (von mir aus mit der Func gets()). Der Angreifer bzw. "User" gibt in dieses Programm
12 characters 'a' ein + 4 characters 'a' für das überschreiben der EBP + "Shellcode"
Ist dieses Szenario nun richtig dargestellt?

Seid ehrlich und geht kritisch mit meinem Wissen um, ich bedanke mich vorab an alle.


Edit://

Das Programm führt function done() aus. Anschließend erwartet es eine Eingabe. Vor meiner Quellcode-Änderung habe ich zuerst eine EIngabe erwartet. Mit der EIngabe wollte ich auf die function done() adressieren. Das hat nicht geklappt. Also habe ich die Schlussfolgerung gezogen, das ich nur Adressen im stack frage adressieren kann. So beschloss ich auch zuerst die function done() aufzurufen - damit sie im stack frame landet - um dann erneut auf sie zurückzuweisen.

[Beni]

Kenne mich (noch) 0 mit Exploits aus. Ich weiß nur in C, dass der Compiler [bei mir GCC mit -Wall] meckern sollte, wenn du eine Funktion aufrufst die nach der main() kommt. Würde einen Prototyp von allen Funktionen die du benutzt vor die main() setzen. Im Falle von "done()" setzt einfach vor die main(): void done(void);
So machst das mit allen Funktionen die du in deinem Programm hast. So weiß der Compiler zu Compiletime, dass es die Funktionen gibt und wenn sie in der main() aufrufst sollte dann alles klappen.

Prototypen sind im Prinzip: Rückgabetyp Bezeichner(Parametertypen,...,);

Vielleicht hilfts ja was.
Grüße

[snow]

Du bist da ein bisschen auf dem Holzweg.

Vorweg: Deine Screenshots sind ein bisschen klein, vielleicht konnte ich nicht alles korrekt erkennen.

Dein Buffer befindet sich -0x10 Byte relativ zu rbp, dazu musst du noch rbp überschreiben und dann kommt die return-Adresse, die bei der ret Instruction vom Stack popped wird und angesprungen wird.

Dein erster Fehler ist dass das hier eine 64 bit Binary ist. rbp und return-Adresse sind also jeweils 8 Byte groß, du musst also 16 Byte (Buffer) + 8 Byte (rbp) + 8 Byte (return-Adresse) schreiben.

Der nächste Fehler: Ja, du kannst Shellcode eingeben, nur muss der ja irgendwie ausgeführt werden. Dafür musst du die return-Adresse überschreiben um damit dann zu deinem Shellcode zu springen.

Du musst dich ja in den Kontrollfluss des Programms einschleusen. Du kannst also nicht einfach ein paar Instructions auf den Stack hauen (weil das Programm ja nicht wirklich weiß dass da Instructions rumliegen) sondern musst den Instruction Pointer (rip) explizit dazu bringen, auf deine Instructions zu zeigen. Der kann dann theoretisch auch auf beliebige Adressen (im Heap, .data, Stack, sonst wo) zeigen wenn keine Sicherheitsmechanismen aktiv sind.

An den Adressen kann dann Shellcode sein, je nach Sicherheitsmaßnahmen (ASLR oder NX z.B.) musst du das aber evtl. auch anders angehen wie z.B. mit ROP chains oder ret2libc, das lernt ihr aber vermutlich noch.

Ein einfacher Exploit könnte z.B. so aussehen:

perl -e 'print "A"x24 . pack("Q", 0x00000000004005B2)' | ./a.out

Das sollte ein weiteres Mal done aufrufen.

[aeo]

Ich danke dir für deine Antwort, doch ich habe das Problem schon gelöst gehabt. Es trifft aber alles zu, was du gesagt hast. Mir war wohl der Programmfluss nicht so ganz klar, weshalb ich mich da selbst irritiert habe. Viele Seiten erklären es auch falsch oder vermitteln es Dritten falsch und man denkt sich weitere falsche Sachen aus. Der ESB sollte meines Wissens nach aber immer 4 Byte groß sein, was falsch war.
Ich kann dir gern mal meine zwei Quelldateien meines Bufferoverflows/Exploit senden.
Ich habe canaries, ASLR..NX auf einer Live Distro (**** Vulnerabilitiy Linux) deaktiviert. -fno-stack-protector war aufgrund der Version von gcc nicht notwendig.
Es funktioniert einwandfrei. Jetzt habe ich das ganze noch mit einem NOP Sled und den jweiligen Shellcode modifiziert. (Den Shellcode an sich nicht - aber er kann eingefügt werden.)
// Ein Shellcode zu erstellen war mir etwas zu komplex und auch für den Vortrag knapp.
Ablauf:
-Bufferoverflow.exe erwartet stdin mit gets
-Exploit.exe schreibt characters in stdout (128 Buffer + RBP (8 Bytes) + DEST_RET_TO_NOP_SLED
- NOP SLED
- Shellcode / printf("PAYLOAD LOADED");

Eine variable Eingabe funktionierte nicht. Ich habe also 128 Bytes eingegeben + 8 Bytes für den RBP und 8 Bytes für meine Zieladresse. Mein Fehler war der Zeilenumbruch "\n" welches ein Segm_Fault hervorrufte. Mittels echo und einigen Optionen habe ich nun auch das gelöst.

Trotzdem vielen, vielen Dank.

// Anmerkung: Es hat bei mir funktioniert - ohne die Zieladresse auf 8 Bytes aufzufüllen. Kann ich die Schlussfolgerung ziehen, dass es in diesem Fall kein Unterschied macht?
Statt
00000000004004b2
4004b2 oder 004004b2