Netzwerksicherheit. Teil 2: Buffer Overflows und andere Gemeinheiten. Martin Mauve, Björn Scheuermann und Philipp Hagemeister

Transkript

1 Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten Martin Mauve, Björn Scheuermann und Philipp Hagemeister Sommersemester 2015 Heinrich-Heine-Universität Düsseldorf Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 1

2 echo-server Implementieren Sie einen Server (in C), welcher den Client begrüßt. Sie können die Hilfsfunktionen short network2short(const char*) und void short2network(char*, short) verwenden, außerdem alle C-Funktionen wie malloc und memcpy. Skizzieren Sie alleine oder zu zweit den Code. Sie haben fünf Minuten. char* message = receive(); // Ihr Code hier send(...,...); // const char*, size_t Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 2

3 echo-server: Lösung char* inbuf = receive(); unsigned short length = network2short(inbuf); char* outbuf = malloc( length); short2network(outbuf, 3 + length); memcpy(outbuf + 2, "Hi ", 3); memcpy(outbuf , inbuf + 2, length); send(outbuf, length); Sehen Sie ein Problem? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 3

4 Angriff Was passiert, wenn der Angreifer einfach weniger Bytes schickt, als er vorgibt? char* inbuf = receive(); unsigned short length = network2short(inbuf); char* outbuf = malloc( length); short2network(outbuf, 3 + length); memcpy(outbuf + 2, "Hi ", 3); memcpy(outbuf , inbuf + 2, length); send(outbuf, length); Angreifer kann Speicher des echo-servers auslesen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 4

5 Exploits Die Daten, die ein Angreifer sendet, nennt man auch ein Exploit. Der obige Bug ist unter dem Namen Heartbleed bekannt: heise.de News-Meldung vom Der GAU für Verschlüsselung im Web: Horror-Bug in OpenSSL Ein äußerst schwerwiegender Programmierfehler gefährdet offenbar Verschlüsselung, Schlüssel und Daten der mit OpenSSL gesicherten Verbindungen im Internet. Angesichts der Verbreitung der OpenSource-Bibliothek eine ziemliche Katastrophe. [...] Die Entdecker der Lücke sprechen vom Heartbleed Bug, weil der Fehler in der Heartbeat-Funktion gefunden wurde. [...] Durch eine fehlende Überprüfung eines Speicherzugriffs kann ein Angreifer dabei bis zu 64 KByte der Gegenstelle auslesen [...] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 5

6 heise.de News-Meldung vom Adobe warnt vor Zero-Day-Lücke in Flash und Reader Eine ungepatchte Lücke in Adobes Flash Player lässt sich nach Angaben des Herstellers ausnutzen, um Schadcode in ein System zu schleusen und zu starten. Die Lücke wurde offenbar bereits aktiv bei gezielten Angriffen ausgenutzt, wobei die Opfer allerdings nicht auf eine präparierte Webseite gelockt wurden, sondern per Mail ein infiziertes Excel-Dokument erhielten. Darin war als Objekt laut Adobe eine präparierte swf-datei eingebettet, die der Flash Player beim Öffnen des Dokuments abspielte. [...] Nach Angaben von Kaspersky läuft der bei den bisherigen Attacken benutzte Exploit zwar unter Windows XP, nicht aber unter Windows 7 was an den zusätzlichen Sicherheitsfunktionen (DEP, ASLR) liegt. Adobe arbeitet an einem Patch [...] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 6

7 heise.de News-Meldung vom Windows-Lücke nach 17 Jahren gefunden [...] Nach der ungepatchten Lücke im Internet Explorer wurde nun noch eine Lücke in Windows bekannt, durch die Anwender mit eingeschränkten Rechten an System-Rechte gelangen können und zwar vermutlich auf allen 32-Bit-Windows-Versionen von Windows NT 3.1 bis einschließlich Windows 7. [...] Ursache des Problems sind Fehler in der 1993 eingeführten Virtual DOS Machine (VDM) [...] Tavis Ormandy hat in der Umsetzung einige Schwachstellen gefunden, durch die ein nicht-privilegiertes 16-Bit-Programm mit mehreren Tricks den zu jedem Prozess gehörenden Kernel-Stack manipulieren kann. Damit ist es möglich, eigenen Code mit Systemrechten auszuführen. Ormandy hat zu der Lücke auch einen Exploit veröffentlicht [...]. Im Test der heise-security-redaktion öffnete der Exploit unter Windows XP und Windows 7 eine Eingabeaufforderung im System-Kontext, also mit den höchsten Rechten. [...] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 7

8 Software-Schwachstellen Mit Exploits werden Fehler in Programmen ausgenutzt, um diese dazu zu bringen, etwas falsches zu tun Mit Heartbleed kann ein Angreifer Daten auslesen aber eigentliches Ziel: Befehle auf einem fremden Rechnersystem ausführen Es geht also darum, fremder Software Instruktionen unterzuschieben Unsere Frage hier: Wie funktioniert so etwas eigentlich? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 8

9 Angriffe auf Maschinencode-Ebene In diesem Kapitel: Sicherheitslücken auf Maschinencode-Ebene Ziel: Manipulierte Eingabedaten (lokal oder über ein Netzwerk) verändern den Programmfluss und die ausgeführten Instruktionen Grundlage für eine große Zahl von Angriffen und ein klassisches Malware-Einfallstor Der Klassiker: Buffer Overflows Typisches Ziel: Starten einer Shell (= Eingabeaufforderung) Warum eine Shell? Erlaubt das Ausführen beliebiger Kommandos mit den Rechten des Benutzers, der sie gestartet hat (also den Rechten des geknackten Programms!) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 9

10 Angriffe auf Maschinencode-Ebene Um solche Angriffe zu verstehen, ist solides Grundlagenwissen über die Funktionsweise von Rechner und Betriebssystem notwendig Insbesondere: Zusammenhang (und Unterschiede) zwischen Hochsprachen, Assembler und Maschineninstruktionen Rolle von Compiler, Assembler und Linker Assembler-Programmierung Ausführbare Programme im Speicher, inkl. Speichermanagement (Segmente, Stack,...) Obwohl Sie das natürlich alle perfekt beherrschen ( Info 2!), wiederholen wir die wichtigsten Aspekte noch einmal kurz ;-) Alles geht aber nicht also bitte selbständig nachlesen und Kenntnisse auffrischen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 10

11 Assembler Assembler-Instruktionen werden vom Assembler in Instruktionen des Befehlssatzes des Prozessors übersetzt 1 Assembleranweisung = 1 Maschineninstruktion (anders als bei Hochsprachen!) Eine Instruktion besteht aus einem Opcode und einer variablen Zahl von Operanden Für viele Architekturen (insbes. für x86) gibt es mehrere Assemblersprachen codieren denselben Instruktionssatz (also dieselben Maschineninstruktionen), aber mit anderer Schreibweise Vorsicht Falle: teilweise gemeine Unterschiede im Detail (Reihenfolge der Operanden,...) hier: gas-syntax (= AT&T-Syntax) Standard der GNU-Tools unter Unix (Achtung: NASM in Info 2!) [Bartlett: Programming from the Ground Up, Bartlett Publishing, 2004 (freies E-Book)] [Blum: Professional Assembly Language, Wiley, 2005] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 11

12 Zur Sicherheit noch einmal: Dies ist keine vollständige Einführung/Referenz in die Assembler- oder Systemprogrammierung! Nachlesen und Erweitern bzw. Auffrischen der eigenen Kenntnisse auch über die Folien hinaus (!) ist erwünscht und notwendig! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 12

13 x86-instruktionssatz Wir verwenden den Intel x86-instruktionssatz (IA-32) Ab bis heute, auch aktuelle AMD-Prozessoren Sehr mächtiger CISC-Instruktionssatz Inzwischen sind 64-Bit-Erweiterungen (ursprünglich von AMD entworfen) weit verbreitet vom Prinzip her sehr ähnlich wir beschränken uns hier auf 32-Bit-Instruktionen Hier speziell: Linux-Umgebungen mit der C-Standardbibliothek glibc und den GNU-Tools (gcc, gas, ld, gdb,...) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 13

14 Einige Instruktionen Der x86-befehlssatz stellt eine sehr große Zahl von Instruktionen zur Verfügung, u. a. für Arithmetische Operationen (add, sub,...) Logische Operationen (and, or, xor, not,...) Vergleiche (cmp,...) Zuweisungen (mov,...) Sprünge (jmp, jz, je, jnbe,...) Stack-Operationen (push, pop,...) Funktionsaufrufe (call, ret, enter, leave,...)... Für Details und zum Nachschlagen: IA-32-Dokumentation! [Intel 64 and IA-32 Architectures Software Developer s Manuals, GNU Assembler-Syntax: ] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 14

15 x86-registersatz EAX, EBX, ECX, EDX sind allgemeine 32-Bit-Register, aber: EAX: Berechnungen EBX: Zeiger (Pointer) ECX: Schleifen EDX: Mult/Div, 64 Bit mit EAX 8- und 16-Bit-Teilregister separat ansprechbar ESI, EDI: String-Operationen EBP, ESP: Base/Stack Pointer EIP: Instruction Pointer (= Program Counter, PC) EFLAGS: Prozessorstatuswort Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 15

16 Suffixe Beispiel GAS verwendet Suffixe hinter Instruktionsnamen, um Operandengrößen festzulegen Optional, wenn sich die Operandengröße aus den Operanden ergibt Aber immer sinnvoll (zur Fehlervermeidung!) Suffixe sind: b: Byte (8 Bit) w: Wort (2 Byte, 16 Bit) l: Doppelwort (4 Byte, 32 Bit) movl %eax, %ecx kopiert 4 Byte von Register EAX nach Register ECX movl $3, 17 schreibt den Wert 3 an Speicheradresse 17 Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 16

17 Operanden Operaden können... in einem Register stehen direkt angegeben werden (als Konstante, Immediate ) movl $3,%eax (Wert 3 ins Register EAX) im Speicher stehen; Speicheradressen können dann... konstant angegeben werden movl 3,%eax (Inhalt von Speicheradr. 3 nach EAX) in einem Register stehen movl $0x12,(%eax) (Wert 18 an die Adr. in EAX) aus Registern errechnet werden movl 8(%eax),%ebx (Inhalt von Adr. EAX+8 nach EBX) movl -4(%eax,%ebx,2),%ecx (Inhalt von Adresse 4 + EAX + EBX 2 nach ECX) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 17

18 Labels Beispiel Mit Labels können einzelne Stellen im Assemblerquelltext benannt bzw. markiert werden Das Label kann dann an anderen Stellen an Stelle eines konstanten Wertes verwendet werden Beim Übersetzen ersetzt der Assembler bzw. Linker das Label durch die Speicheradresse der Instruktion oder Daten, auf die das Label zeigt Sei buffer ein weiter oben definiertes Label. movl buffer, %eax lädt 4 Bytes aus dem RAM ab Adresse buffer in EAX movl $buffer, %eax kopiert die Adresse (!) von buffer nach EAX Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 18

19 Segmente Beispiel Eine Übersetzungseinheit (also i. d. R.: Quelldatei) kann aus mehreren (Speicher-)Bereichen Segmenten bestehen Die wichtigsten:.text: enthält ausführbare Instruktionen.data: enthält Variablen mit vordefinierten Werten.bss: enthält Variablen ohne vordefinierten Wert.section.data wert1:.byte 0x20 ; ein Byte mit Wert 0x20 reservieren.section.text movb wert1, %bl... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 19

20 Speicherreservierungen im Datensegment Beispiel Wenn (normalerweise im Datensegment) Konstanten reserviert werden, kann dies mit unterschiedlichen Datentypen erfolgen Die wichtigsten:.byte,.short,.int/.long,.float,.double,.ascii,.asciz/.string.byte 0x55, 0x56, 0x57 reserviert drei Bytes mit Werten 0x55, 0x56, 0x57.short 0x1234 reserviert zwei Bytes mit Werten 0x34 und 0x12 (Little Endian!).ascii "Hello World!\n" reserviert 13 Bytes mit einer Zeichenkette.asciz "Hello World!\n" reserviert 14 Bytes mit einer nullterminierten Zeichenkette Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 20

21 Hausaufgabe (bis Do, 9. April 2015) Bereiten Sie sich darauf vor, Ihren Kommilitonen in fünf Minuten zu erklären, wie ein Funktionsaufruf in Assembler bei Verwendung der C-Aufrufkonvention funktioniert. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 21

22 Im GNU-C-Compiler (gcc) kann man in C-Programme GAS-Assembler-Instruktionen einbetten ( Inline Assembly ): int main() { asm ( "movl %eax, %ebx;" "movl $0x4711, %eax;" ); return 0; } Hausaufgabe (Übungsblatt 2) a) Schreiben Sie eine C-Funktion, die ausschließlich mit solchen Assembler-Instruktionen eine (hartcodierte) 32-Bit- Ganzzahl (z. B. 0xFEAFFECA) ins Register EAX lädt, dann die Byte-Reihenfolge der Zahl umkehrt und das Ergebnis in EBX ablegt. b) Übergeben Sie das Ergebnis in eine C-Variable und geben Sie es nach dem Assembler-Block (in C) mit printf hexadezimal aus. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 22

23 Der Stack Im Daten- oder BSS-Segment fest definierte Speicherbereiche reichen nicht immer aus Wenn rekursive Funktionsaufrufe möglich sein sollen, müssen lokale Variablen, Parameter usw. für jeden Aufruf separat gespeichert werden Hierfür wird der Stack verwendet Der Stack ist ein Speicherbereich, in dem dynamisch Daten abgelegt werden können Beginnt bei hoher Speicheradresse, wächst nach unten Elementare Operationen: push: Ablegen eines Wertes auf dem Stack pop: Herunternehmen des letzten Wertes vom Stack Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 23

24 Der Stack Der Stack hat einen Anfang, hier beispielsweise bei Adresse 0x2000 Er hat ab dem Prozessor üblicherweise eine Breite von 4 Byte Man kann auch kürzere Daten auf den Stack legen, richtet diese dann aber an 4-Byte-Grenzen aus Das ESP-Register (Extended Stack Pointer) zeigt auf den letzten Stackeintrag Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 24

25 Der Stack Beispiel (0) EAX = 0x EBX = 0x ESP = 0x C Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 25

26 Der Stack Beispiel (1) EAX = 0x EBX = 0x ESP = 0x C Nächste Instruktion: pushl %ebx Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 26

27 Der Stack Beispiel (2) EAX = 0x EBX = 0x ESP = 0x Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 27

28 Der Stack Beispiel (3) EAX = 0x EBX = 0x ESP = 0x Nächste Instruktion: pushl $0xDEADBEEF Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 28

29 Der Stack Beispiel (4) EAX = 0x EBX = 0x ESP = 0x Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 29

30 Der Stack Beispiel (5) EAX = 0x EBX = 0x ESP = 0x Nächste Instruktion: popl %eax Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 30

31 Der Stack Beispiel (6) EAX = 0xDEADBEEF EBX = 0x ESP = 0x Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 31

32 Funktionsaufrufe Für einen Funktionsaufruf müssen (u. a.) geregelt werden: wie Parameter übergeben werden wie der Rückgabewert übergeben wird wie die Rücksprungadresse gemerkt wird Die Aufrufkonvention legt fest, wie das geschieht Wir konzentrieren uns hier auf die sog. C-Aufrufkonvention (C Calling Convention, cdecl) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 32

33 Rücksprungadresse Man könnte eine Funktion einfach durch eine jmp-instruktion anspringen Problem: Woher soll die Funktion am Ende wissen, wohin zurückgesprungen werden soll? Wir müssen uns die Adresse der ersten Instruktion hinter dem Sprung in die Funktion merken Das geschieht auf dem Stack also: 1 Adresse der ersten Instruktion hinter dem Sprung auf den Stack legen 2 dann in die Funktion springen 3 am Ende der Funktion die Rücksprungadresse vom Stack holen und dort hinspringen Funktioniert auch bei geschachtelten Funktionsaufrufen: Rücksprungadressen werden auf dem Stack gestapelt! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 33

34 call und ret EIP kann nicht direkt gelesen oder geschrieben werden! call funktionsanfang 1 ESP um 4 verringern 2 Adresse des Befehls direkt hinter call (= Inhalt des Registers EIP) an die Adresse in ESP schreiben 3 Sprung zur Adresse funktionsanfang ret 1 Register EIP vom Stack laden (von der Adresse in ESP) 2 ESP um 4 erhöhen Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 34

35 Beispiel: Funktionsaufruf movl $0x10, %eax movl $0x20, %ebx call max # Die größere Zahl soll # in ecx gespeichert werden... max: cmpl %ebx, %eax # Der Vergleich jl bgr movl %eax, %ecx # Rückgabe über ecx jmp ende bgr: movl %ebx, %ecx ende: ret Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 35

36 Parameterübergabe Bei der C-Aufrufkonvention werden Parameter auf dem Stack übergeben. Ablauf: 1 Aufrufer legt Parameter auf den Stack (push) 2 Aufrufer ruft die Funktion auf (call) 3 Funktion wird bearbeitet 4 Funktion kehrt mit ret zurück 5 Aufrufer nimmt Parameter vom Stack (addl wert,%esp) Parameter werden in umgekehrter Reihenfolge auf den Stack abgelegt: der erste Parameter zuletzt Übergabe von Zeigern: Speicheradresse übergeben! So kann man auch C-Funktionen zum Beispiel aus der C-Standardbibliothek direkt aus Assembler aufrufen Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 36

37 Beispiel: Parameterübergabe nach C-Konvention pushl $0x10 pushl $0x20 call max addl $8, %esp # Parameter auf den Stack # Funktion aufrufen # Parameter vom Stack nehmen... max: movl 8(%esp), %ebx # Achtung, Rücksprungadresse cmpl 4(%esp), %ebx # liegt auch auf dem Stack! jl bkl movl %ebx, %eax # Rückgabe über eax jmp ende bkl: movl 4(%esp), %eax ende: ret Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 37

38 Beispiel: Aufruf von printf Ein Aufruf von printf( X = %d, x) in Assembler:.section.data x:.int 100 format:.asciz "X = %d\n" #.asciz => nullterminiert.section.text... pushl x pushl $format call printf addl $8, %esp... # x auf den Stack legen # Adresse (!) von format auf den Stack # Funktion aufrufen Ausgabe: X = 100 Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 38

39 Registernutzung Integer- und Pointer-Rückgabewerte werden im Register EAX zurückgegeben Bei längeren Rückgabewerten werden EAX und EDX kombiniert In der C-Aufrufkonvention wird erwartet, dass einige Register nach Rückkehr aus einer Funktion wieder ihren alten Wert beinhalten Diese (u.a. EBP, EBX, EDI, ESI) werden vor Verwendung mit push gesichert und danach mit pop wiederhergestellt Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 39

40 Lokale Variablen und EBP Lokale Variablen liegen ebenfalls auf dem Stack Wenn sich ESP innerhalb einer Funktion ändert, wird es aber schwierig, auf die Parameter und die lokalen Variablen zuzugreifen Deshalb gibt es ein weiteres Spezialregister: EBP markiert den Beginn einer Funktion auf dem Stack bei Funktionseintritt wird der alte Wert von EBP auf den Stack gelegt und so gespeichert danach wird EBP der Wert von ESP zugewiesen dann wird Platz für lokale Variablen geschaffen: Subtrahiere von ESP die Größe der lokalen Variablen bei Funktionsende werden die lokalen Variablen vom Stack gelöscht und der alte Wert von EBP wiederhergestellt Dies muss die Funktion selbst erledigen (kann enter und leave verwenden) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 40

41 Der Stack beim Funktionsaufruf Beispiel Wie verändern sich der Stack und die Werte von EBP und ESP bei jeder Instruktion im folgenden Code-Ausschnitt? pushl 0xAFFEAFFE pushl 0xDEADBEEF call func addl $8, %esp... func: pushl %ebp movl %esp, %ebp subl $4, %esp... addl $4, %esp popl %ebp ret Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 41

42 Parameter- und Variablenzugriffe Wie wird ein Zugriff auf den ersten (zweiten, dritten,...) Parameter der aktuellen Funktion üblicherweise aussehen? (Kopieren Sie diesen Parameter nach EAX!) 1. Parameter: movl 8(%ebp), %eax 2. Parameter: movl 12(%ebp), %eax 3. Parameter: movl 16(%ebp), %eax... Wie sieht ein entsprechender lokaler Variablenzugriff aus? 1. Variable: movl -4(%ebp), %eax 2. Variable: movl -8(%ebp), %eax... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 42

43 Stack Frame Mit Stack Frame bezeichnet man den Bereich auf dem Stack, der zu einer Funktion gehört Das ist der Bereich vom alten EBP bis zum ESP: alter EBP gesicherte Register-Inhalte lokale Variablen sonstiges Übergebene Parameter und Rücksprungadresse gehören zum Stackframe der aufrufenden Funktion! darüber, ob das sinnvoll ist, kann man zugegeben streiten Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 43

44 Bestimmung effektiver Adressen mit lea Wenn x eine Variable auf dem Stack ist, wie kann man die Adresse von x berechnen, um sie dann als Parameter übergeben zu können? Mühsam: EBP in EAX laden dann Offset zum Speicherplatz von x addieren Einfacher mit lea (load effective address): leal op2, op1 op2 muss eine Speicherreferenz sein, z. B. -4(%ebp) davon wird die Speicheradresse berechnet und das Ergebnis in op1 gespeichert es wird nicht der Inhalt dieser Speicheradresse in op1 gespeichert, sondern die Adresse selbst! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 44

45 Beispiel: lea... movl $10, -4(%ebp) # x = 10 leal -4(%ebp), %eax # Adr. von x bestimmen pushl %eax # Adr. von x auf den Stack call red addl $4, %esp... red: enter $0,$0 # Abkürzung fürs Anpassen von EBP/ESP movl 8(%ebp), %eax subl $5, (%eax) leave # entspricht: mov %ebp,%esp; pop %ebp ret Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 45

46 Von der Hochsprache zum Maschinencode Was macht gcc, wenn er für eine.c-datei aufgerufen wird? 1 Der C-Präprozessor (cpp) wird ausgeführt Resultat: eine.c-datei 2 Dann wird kompiliert: C-Programm wird in Assembler-Programm übersetzt Resultat: eine.s-datei (in gas-syntax) 3 Jetzt wird assembliert (mit gas): Assembler-Programm wird in Prozessorinstruktionen umgesetzt Resultat: eine.o-datei Relocatable hier stehen endgültige Speicheradressen noch nicht fest 4 Schließlich werden alle benötigten Dateien und Bibliotheken zusammengelinkt (mit ld): Resultat: ausführbares Programm Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 46

47 Beispiel: Von C zu Assembler #include <stdio.h> int main() { printf("hello World!\n"); return 0; } Übersetzen mit gcc hello.c -S -m32 Ergebnis: hello.s Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 47

48 Beispiel: Von C zu Assembler.file "hello.c".section.rodata.lc0:.string "Hello World!".text.globl main.type main: leal 4(%esp), %ecx andl $-16, %esp pushl -4(%ecx) pushl %ebp movl %esp, %ebp pushl %ecx subl $4, %esp movl $.LC0, (%esp) call puts movl $0, %eax addl $4, %esp popl %ecx popl %ebp leal -4(%ecx), %esp ret.size main,.-main.ident "GCC: (GNU) (Ubuntu ubuntu4)".section.note.GNU-stack,"",@progbits Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 48

49 Disassembler Ein Disassembler kann die Maschineninstruktionen in einem Programm in Assembleranweisungen zurückübersetzen Dabei geht normalerweise einiges verloren: Labels und Kommentare sind im Maschinencode nicht mehr enthalten Aber der Weg über den in den Debugger gdb eingebauten Disassembler kann interessant sein: wenn mit der Option -g kompiliert wurde......dann kann gdb gezielt einzelne Funktionen des fertig übersetzten Programms disassemblieren hierfür zunächst gdb programmname aufrufen dann mit disas funktionsname eine Funktion disassemblieren gdb kann mit dem Befehl quit beendet werden gdb kann noch viel mehr es lohnt sich, sich damit vertraut zu machen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 49

50 Beispiel: Disassembler $ gcc -g -o hello hello.c -m32 $ gdb hello GNU gdb 6.8-debian Copyright (C) 2008 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later < 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 "i486-linux-gnu"... (gdb) disas main Dump of assembler code for function main: 0x <main+0>: lea 0x4(%esp),%ecx 0x <main+4>: and $0xfffffff0,%esp 0x b <main+7>: pushl -0x4(%ecx) 0x e <main+10>: push %ebp 0x f <main+11>: mov %esp,%ebp 0x <main+13>: push %ecx 0x <main+14>: sub $0x4,%esp 0x <main+17>: movl $0x ,(%esp) 0x c <main+24>: call 0x80482d4 <puts@plt> 0x <main+29>: mov $0x0,%eax 0x <main+34>: add $0x4,%esp 0x <main+37>: pop %ecx 0x a <main+38>: pop %ebp 0x b <main+39>: lea -0x4(%ecx),%esp 0x e <main+42>: ret End of assembler dump. (gdb) quit $ Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 50

51 Hausaufgabe (Übungsblatt 2) Bestimmen Sie für das Assemblerprogramm zum Umkehren der Bytereihenfolge, das Sie für die Aufgabe auf Folie 22 erstellen, den (hexadezimalen) Maschinencode. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 51

52 Ein erster Buffer Overflow Betrachten Sie folgende C-Funktion: void read() { char buf[8]; printf("please give me some input: "); gets(buf); printf("thanks! You said: %s\n", buf); } Wie lang darf die Benutzereingabe maximal sein? Was passiert, wenn der Benutzer mehr als 7 Zeichen eingibt? Zu lange Eingaben werden auf dem Stack über das Ende des für buf reservierten Bereiches hinaus geschrieben. Andere Werte werden überschrieben ein Buffer Overflow! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 52

53 Stack im Beispiel Wie sieht der Stack im Beispiel beim Aufruf von gets() aus? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 53

54 Das ganze C-Programm #include <stdio.h> void read() { char buf[8]; printf("please give me some input: "); gets(buf); printf("thanks! You said: %s\n", buf); } void callme() { printf("congratulations!\n"); } int main(char* argc, char** argv) { read(); } Ist eine Eingabe in read() möglich, bei der die (eigentlich nie ausgeführte) Funktion callme() angesprungen wird? Idee: Platziere die Startadresse von callme() so in der Eingabe, dass sie über die Rücksprungadr. geschrieben wird Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 54

55 Shellcode-Exploits Normalerweise möchten wir nicht eine existierende Funktion im Programm anspringen, sondern eigene Befehle einschleusen Insbesondere: eine Shell starten! Im Folgenden betrachten wir deshalb Techniken, die dies ermöglichen und Schutzmechanismen dagegen Zunächst: Klassische Buffer-Overflow-Exploits mit sog. Shellcode auf dem Stack Danach: Andere Möglichkeiten, an eine Shell zu kommen Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 55

56 Weiteres Vorgehen 1 Wie sieht Assembler-/Maschinencode aus, der eine Shell startet? 2 Wie können wir diesen Maschinencode einschleusen? 3 Wie bringen wir ein verwundbares Programm dazu, den Code anzuspringen? [Aleph One: Smashing The Stack For Fun And Profit, Phrack 7(49), 1996] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 56

57 Was passiert hier? movl $1, %eax movl $0, %ebx int $0x80 Das ist ein Linux-Systemaufruf: Systemaufruf Nr. 1 (übergeben in EAX) mit einem Parameter (Wert 0, übergeben in EBX) dann Software-Interrupt 0x80 auslösen syscall 1 = Prozess beenden (hier mit Exit-Code 0) Achtung: Systemaufrufe sind direkte Aufrufe von Kernel-Funktionen nicht verwechseln mit Aufrufen der C-Standardbibliothek! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 57

58 Syscall 0xB: execve Im Folgenden wichtig: der Linux-Systemaufruf execve Eine Möglichkeit, ein Programm zu starten Systemaufruf Nr. 11 (0xB), erwartet drei Parameter in EBX: Adresse eines nullterminierten Strings mit dem Pfad der ausführbaren Datei übergeben in ECX: Adresse eines char*-arrays (= ARGV des aufgerufenen Programms) in EDX: Adresse eines Environments (= Liste von Umgebungsvariablen im einfachsten Fall 0x ) Ein einfacher Programmaufruf mit execve entspricht in C: char *name[2]; char *env[1]; name[0] = "/pfad/zum/programm"; name[1] = 0; env[0] = 0; execve(name[0], name, env); // EBX=name[0], ECX=name, EDX=env Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 58

59 execve in Exploits Typische Benutzung in Exploits: lege nullterminiert /bin/sh im Speicher ab (ab Adr. x) lege im Speicher (an Adr. y) die Adresse x gefolgt von 0x ab setze EAX = 0xB setze EBX = x setze ECX = y setze EDX auf eine Adresse, an der 0x steht (z. B. EDX = y + 4) löse int $0x80 aus Dies wäre eine einfache Form von sogenanntem Shellcode: Maschinencode, der eine Shell (/bin/sh) startet Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 59

60 Shellcode auf dem Stack Idee: Wir schreiben Maschinencode zum Starten einer Shell auf dem Stack und überschreiben die Rücksprungadresse so, dass er angesprungen wird Also alles Wesentliche in den Puffer packen: String /bin/sh Maschinencode für execve-aufruf Versuchen wir s! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 60

61 Erster Shellcode Konstruktionsidee für den Shellcode (schematisch): Dabei müssen wir die richtigen Adressen einsetzen Und zwar die Adressen auf dem Stack im überlaufenden Puffer Je nachdem, wo der Stackframe gerade liegt, können die Adressen verschieden sein! Und jetzt? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 61

62 Shellcode mit unbekannter Startadresse Wir lösen das in zwei Schritten: 1 Zunächst kümmern wir uns um die Rücksprungadresse 2 Danach um die unbekannte Adresse des Strings /bin/sh Ideen für das erste Problem? Wir werden intelligent raten müssen Ungefähr abschätzen kann man die Adresse durch Beobachten des lokalen Programms: Wo liegt der Stack Frame der angegriffenen Funktion üblicherweise. Aber reicht eine ungefähre Rücksprungadresse? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 62

63 NOP Sleds Wenn wir bei der Rücksprungadresse auch nur ein Byte daneben liegen, wird der Shellcode nicht richtig ausgeführt Idee: Wir füllen den Bereich vor den wichtigen Instruktionen mit NOPs (Maschinencode: 0x90) Instruktion NOP ( No Operation ) tut gar nichts :-) Wir schreiben dann einen Schätzwert in die Rücksprungadresse......von dem wir hoffen, dass er irgendwo in dieser NOP Sled (auch: NOP Slide, NOP Ramp) landet Wird ab dort ausgeführt, landen wir im Shellcode! Funktioniert um so besser, je größer der Puffer ist ( mehr NOPs!) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 63

64 Unbekannte Adresse des Strings An die Adresse von /bin/sh zu kommen ist schwieriger Hier tut es keine ungefähre Lösung Idee: Wir besorgen uns die Adresse zur Laufzeit Wie könnte das gehen? (Tipp: Welche Instruktion schreibt eine Adresse auf den Stack?) Idee: call-instruktion verwenden! Wie sieht hierzu jetzt der Shellcode aus? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 64

65 Adressbestimmung mittels call call start # relativer Sprung: 16 Byte vorwärts.string "/bin/sh" # nullterminiert (insges. 8 Byte).int 0 # 4 Null-Bytes.int 0 # 4 Null-Bytes start: popl %ebx # Rücksprungadr. vom Stack movl %ebx, 8(%ebx) movl $0xb, %eax lea 8(%ebx), %ecx lea 12(%ebx), %edx int $0x80 call start wird vom Assembler in eine call-instruktion mit relativem Sprung um 16 Byte nach vorne übersetzt. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 65

66 Das folgende C-Programm springt den im String shellcode übergebenen Maschinencode an: char shellcode[] = "\x90\x90\x90\x90\x90\x90..."; void run_shellcode() { int* ret; ret = (int*)(&ret) + 2; *ret = (int)shellcode; } int main() { run_shellcode(); } Hausaufgabe (Übungsblatt 2) (a) Verstehen Sie, wie und warum das C-Programm funktioniert. (b) Fügen Sie den Maschinencode zum Shellcode auf der vorangegangenen Folie 65 in den String shellcode ein und testen Sie das Ergebnis. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 66

67 Null-Bytes in der Eingabe Man könnte meinen, wir wären fertig... Aber betrachten wir den assemblierten Maschinencode: ASSEMBLER MASCHINENCODE call start e string "/bin/sh" 2f e 2f int int start: popl %ebx 5b movl %ebx, 8(%ebx) 89 5b 08 movl $0xb, %eax b8 0b lea 8(%ebx), %ecx 8d 4b 08 lea 12(%ebx), %edx 8d 53 0c int $0x80 cd 80 Dieser Maschinencode enthält jede Menge Null-Bytes! Übergeben wir das als Eingabe, wird beim Umkopieren in den Puffer das erste 0-Byte als String-Ende interpretiert Der Code landet dann nicht (komplett) da, wo er hin soll! Wie werden wir die Null-Bytes los? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 67

68 Abhilfe: Instruktionen ersetzen! Idee: Ersetze Instruktionen mit problematischem Maschinencode durch gleichwertige Alternativen movl $0xb, %eax ist ein Problem. Wodurch könnten wir das ersetzen? xorl %eax, %eax movb $0xb, %al 31 c0 b0 0b Erreicht das gleiche, Maschinencode enthält keine Nullen mehr! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 68

69 Abhilfe: Instruktionen ersetzen! (2) Die call-instruktion enthält ebenfalls 0-Bytes. Wie können wir das lösen? Das Problem ist der Sprung-Offset (+16 Byte) Dieser wird als 32-Bit-Wert codiert daher die 0-Bytes call-varianten mit 8-Bit-Operaden gibt es nicht aber ein solches jmp gibt es jmp alleine hilft aber auch nicht weiter wir brauchen call ja wegen der Rücksprungadresse Idee: negativer Offset (und dadurch keine 0-Bytes mehr) bei call durch geschicktes Kombinieren mit jmp jmp j2 eb 02 j1: jmp start eb 15 j2: call j1 e8 f9 ff ff ff Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 69

70 Abhilfe: Instruktionen ersetzen! (3) Was machen wir mit den 9 Null-Bytes hinter /bin/sh? Idee: Wir schreiben sie erst zur Laufzeit Ersetzen durch harmlose Zeichen im Shellcode und Hinzufügen von Instruktionen, die die betreffenden 9 Bytes mit Nullen überschreiben Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 70

71 Hausaufgabe (Übungsblatt 2) (a) Erstellen Sie den vollständigen Shellcode ohne Null-Bytes als Assembler-Quellcode. (b) Übersetzen Sie ihn in Maschinencode. (c) Testen Sie ihn im C-Programm von Folie 66. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 71

72 Hausaufgabe (Übungsblatt 3) Betrachten Sie das untenstehende C-Programm. Sie finden eine bereits übersetzte Version davon ( hackme2 ) in ihrer VM im Verzeichnis 02-exploit. Bringen Sie es dazu, eine Shell zu starten! #include <stdio.h> #include <string.h> void do_something(char * name) { char buf[1024]; strcpy(buf, "Please hack me, "); strcat(buf, name); strcat(buf, "."); puts(buf); } int main(int argc, char ** argv) { if (argc < 2) puts("please enter your name as a command line parameter."); else do_something(argv[1]); return 0; } Tipps: Mit dem Befehl./hackme2 $(./exploit) starten Sie hackme2 so, dass die Ausgabe eines anderen Programms (namens exploit) als erste Kommandozeilenoption an hackme2 übergeben wird. Schreiben Sie ein passendes Programm exploit! Falls Sie selber kompilieren: Setzen Sie die gcc-option -fno-stack-protector! Das deaktiviert... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 72

73 Schutzmechanismen und Gegenangriffe Wir haben bis jetzt einfache Pufferüberläufe kennen und verstehen gelernt Dies ist ein altes und lange bekanntes (aber dennoch nach wie vor aktuelles!) Problem Wegen der großen Bedeutung dieser Lücken wurde eine Reihe von Schutzstrategien entwickelt Davon schauen wir uns jetzt ein paar an und lernen bei der Gelegenheit gleich noch ein paar andere Angriffstechniken kennen Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 73

74 (Foto: J. Winkler) Früher wurden in Bergwerken Kanarienvögel eingesetzt, um bei geringen Sauerstoffkonzentrationen frühzeitig zu warnen. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 74

75 Überwachen des Stacks: Stack Canaries Idee: Lege beim Funktionseintritt direkt unter die Rücksprungadresse ein spezielles Datenwort (Stack Canary) auf den Stack......und überprüfe am Funktionsende (vor dem ret), ob es unbeschädigt ist Ein Pufferüberlauf, der die Rücksprungadresse überschreibt, wird vorher auch den Canary überschreiben Bei fehlgeschlagenem Canary-Test wird nicht ret ausgeführt, sondern das Programm beendet Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 75

76 Stack Canaries Die Kunst dabei: Wähle den Canary so, dass der Angreifer ihn nicht reproduzieren kann Zwei gängige Varianten sind: Canaries aus speziellen Steuerzeichen (üblicherweise Null-Zeichen, Carriage Return, Line Feed, EOF); diese lassen sich oft nicht einschleusen ein zufällig beim Programmstart generierter Wert (der im Programm möglichst sicher aufbewahrt wird) Viele Compiler unterstützen inzwischen Stack Canaries (u. a. GCC: an- bzw. ausschalten geht mit den Optionen -fstack-protector und -fno-stack-protector) Bei einigen Betriebssystemen ist das auch standardmäßig aktiv (z. B. in Ihrer Ubuntu 8.04-VM!) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 76

77 Stack Canaries umgehen Stack Canaries machen das Leben schwerer, lassen sich aber häufig doch umgehen Z. B. können andere Zeiger auf dem Stack ausgenutzt werden Beispielsituation: void xyz() { int *p; char buf[8];... gets(buf);... read_integer_from_user(p);... } Wie sieht der Stack aus? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 77

78 Stack Canaries umgehen void xyz() { int *p; char buf[8];... gets(buf);... read_integer_from_user(p);... } Idee: Überschreibe mit einem Überlauf von buf den Inhalt von p...und damit die Adresse, an die später die vom Benutzer eingelesene Zahl geschrieben wird Im einfachsten Fall: Überschreibe p mit der Adresse, an der die Rücksprungadresse liegt und lies dann in *p eine neue Rücksprungadresse ein Der Stack Canary bleibt dabei intakt! [Bulba and Kil3r, Bypassing StackGuard and StackShield, Phrack 10(56), 2000] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 78

79 Heap Overflows Außerdem liegen nicht alle Puffer immer auf dem Stack Pufferüberläufe lassen sich auch anderswo ausnutzen! Beispielsweise ist das auch auf dem Heap möglich: typische Implementationen von malloc und free speichern Verwaltungsinformationen am Anfang reservierter und freier Speicherblöcke in diesen Headern stehen Informationen wie etwa Zeiger auf den nächsten/vorangegangenen Heap-Speicherblock oder Längenangaben für die Blöcke Wenn ein Puffer auf dem Heap überläuft, können Verwaltungsinformationen nachfolgender Blöcke überschrieben werden. Folge: Zunächst gar keine... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 79

80 Heap Overflows... aber spätere malloc/free-aufrufe greifen auf die Daten zu und entnehmen ihnen beispielsweise die Position anderer Header Eine falsche Adresse des nächsten freien Blocks kann dann z. B. dazu führen, dass an ganz anderer Stelle Daten überschrieben werden...z. B. die Rücksprungadresse... [Anonymous, Once upon a free(), Phrack 11(57), 2001] [Michel Maxx Kaempf, Vudo An object superstitiously believed to embody magical powers, Phrack 11(57), 2001] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 80

81 Sauberes Programmieren Der einfachste Schutz: sauberes Programmieren Immer Pufferlängen überprüfen! Also z. B. immer strncpy statt strcpy, fgets statt gets,... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 81

82 Sauberes Programmieren Sauber Programmieren ist leicht gesagt... Der Teufel steckt im Detail! Was ist zum Beispiel hier falsch? void xyz() { char buf[128]; fgets(buf, sizeof buf, stdin); printf(buf); } Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 82

83 Formatstring-Verwundbarkeiten Es gibt einen kleinen, aber wesentlichen Unterschied zwischen printf("%s", buf); und printf(buf); Im ersten Fall ist buf ein String-Parameter. Im zweiten Fall ist buf der Formatstring! Angenommen in buf kommen printf-formatstring- Anweisungen vor (z. B. %s, %u, %x usw.) Im ersten Fall werden sie einfach ausgegeben im zweiten Fall wird buf als Formatstring interpretiert! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 83

84 Formatstring-Verwundbarkeiten Zunächst könnte man meinen, printf(buf) ist vor allem deswegen eine schlechte Idee, weil es nicht richtig funktioniert, wenn Prozentzeichen in buf vorkommen Das war die allgemeine Meinung bis ca. Mitte 2000 Dass es nicht funktioniert ist auch richtig; aber das ist nicht das Hauptproblem... Es wird interessant, sobald ein Angreifer den Inhalt von buf (teilweise) bestimmen kann Was wird ausgegeben, wenn der Benutzer ein oder mehrere Male z. B. %x in buf einfügt? [scut: Exploiting Format String Vulnerabilities, 2001] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 84

85 Formatstring-Angriffe: Auslesen des Stacks Jede Formatstring-Steueranweisung gehört zu einem Parameter von printf Diese Parameter sucht printf auf dem Stack oberhalb des Zeigers auf den Formatstring (C-Aufrufkonventionen!) Enthält der Formatstring mehr Steueranweisungen als Parameter übergeben wurden, wird das, was auf dem Stack liegt, als Parameter interpretiert! Wird z. B. ein Formatstring wie %x%x%x%x... eingeschleust, dann werden entsprechend viele Stack-Worte ausgegeben Damit kann man an Informationen kommen, die für Angriffe hilfreich sein können, z. B. Inhalte lokaler Variablen Adresse des Stacks (alter EBP!) Stack Canaries... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 85

86 Formatstring-Angriffe: Segmentation Faults Das ist noch lange nicht alles! Man kann durch Formatstrings auch ein Programm zum Absturz bringen Ideen, wie? Ein Formatstring %s%s%s%s... interpretiert jedes Datenwort auf dem Stack als Startadresse eines Strings Es wird versucht, von all diesen Adressen die Strings zu lesen und auszugeben Früher oder später wird eine ungültige Adresse gelesen Die Folge ist ein Segmentation Fault Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 86

87 Formatstring-Angriffe: Lesen beliebiger Adressen Wenn der Formatstring selbst auf dem Stack liegt, können wir sogar von beliebigen Speicheradressen lesen! Idee: 1 an eine Stelle im Formatstring die Zieladresse als 4-Byte-ASCII-String einbauen 2 so viele Stack-Worte (z. B. mit %x oder %u) abarbeiten bis wir an dieser Stelle im Formatstring selbst ankommen 3 dann mit einem %s die im Formatstring codierte Adresse als String-Startadresse interpretieren und ab dort bis zum ersten Null-Zeichen ausgeben Aufbau eines solchen Formatstrings (schematisch) z. B. so: ADDR%x%x%x%x...%s Anzahl der %x-sequenzen hängt davon ab, wie weit es auf dem Stack bis zu ADDR ist Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 87

88 Formatstring-Angriffe: Beispiel #include <stdio.h> char secret[] = "geheim"; // at 0x int main() { char buf[128]; int printed = 0; fgets(buf, sizeof buf, stdin); printed = printf(buf); return printed; } Wie sieht der Stack beim Aufruf von printf bei Eingabe fghi%u%s ( ) aus? Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 88

89 Formatstring-Angriffe: Stack-Layout (0) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 89

90 Formatstring-Angriffe: Stack-Layout (1) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 90

91 Formatstring-Angriffe: Stack-Layout (2) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 91

92 Formatstring-Angriffe: Stack-Layout (3) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 92

93 Formatstring-Angriffe: Stack-Layout (4) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 93

94 Formatstring-Angriffe: Stack-Layout (5) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 94

95 Formatstring-Angriffe: Stack-Layout (6) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 95

96 Formatstring-Angriffe: Tricks mit %n Die Formatstring-Steuersequenz %n interpretiert den zugehörigen Parameter als Adresse eines Integers und schreibt in diesen Integer die Anzahl der bis dahin beim Abarbeiten des Formatstrings ausgegebenen Zeichen! Ahnen Sie, was wir damit tun können? Das lässt sich nutzen, um an beliebige Speicheradressen beliebige Werte zu schreiben! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 96

97 Formatstring-Angriffe: Schreiben in den Speicher Grobe Idee: Baue wie beim Lesen beliebiger Adressen die Zieladresse in den Formatstring (auf dem Stack) ein Wie gehabt dorthin z. B. mit %u vorarbeiten......und gleichzeitig dafür sorgen, dass genau so viele Zeichen ausgegeben werden, wie es dem zu schreibenden Wert entspricht Kann man gezielt z. B. durch die Variante %???u erreichen: damit wird eine Zahl mit??? Stellen (also??? Zeichen!) ausgegeben Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 97

98 Schreiben mit Formatstrings: Beispiel Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 98

99 Schreiben mit Formatstrings: Beispiel (1) Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 99

100 Schreiben mit Formatstrings: Beispiel (2) Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 100

101 Schreiben mit Formatstrings: Beispiel (3) Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 101

102 Schreiben mit Formatstrings: Beispiel (4) Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 102

103 Schreiben mit Formatstrings: Beispiel (5) Ziel: 0xAF an Speicherstelle 0x schreiben. Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 103

104 Formatstring-Angriffe: Schreiben in den Speicher Weil die Zahl ausgegebener Zeichen nicht beliebig in die Höhe getrieben werden kann, können so zunächst nur relativ kleine Werte geschrieben werden Idee: Schreibe nacheinander mehrere überlappende Ganzzahlen an um 1 Byte verschiedene Adressen So bleibt von jeder nur das niedrigstwertige Byte erhalten Durch geschicktes Anordnen lassen sich beliebige Byte-Sequenzen erzeugen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 104

105 Formatstring-Angriffe: Schreiben in den Speicher Weil die Zahl ausgegebener Zeichen nicht beliebig in die Höhe getrieben werden kann, können so zunächst nur relativ kleine Werte geschrieben werden Idee: Schreibe nacheinander mehrere überlappende Ganzzahlen an um 1 Byte verschiedene Adressen So bleibt von jeder nur das niedrigstwertige Byte erhalten Durch geschicktes Anordnen lassen sich beliebige Byte-Sequenzen erzeugen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 104

106 Formatstring-Angriffe: Schreiben in den Speicher Weil die Zahl ausgegebener Zeichen nicht beliebig in die Höhe getrieben werden kann, können so zunächst nur relativ kleine Werte geschrieben werden Idee: Schreibe nacheinander mehrere überlappende Ganzzahlen an um 1 Byte verschiedene Adressen So bleibt von jeder nur das niedrigstwertige Byte erhalten Durch geschicktes Anordnen lassen sich beliebige Byte-Sequenzen erzeugen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 104

107 Formatstring-Angriffe: Schreiben in den Speicher Weil die Zahl ausgegebener Zeichen nicht beliebig in die Höhe getrieben werden kann, können so zunächst nur relativ kleine Werte geschrieben werden Idee: Schreibe nacheinander mehrere überlappende Ganzzahlen an um 1 Byte verschiedene Adressen So bleibt von jeder nur das niedrigstwertige Byte erhalten Durch geschicktes Anordnen lassen sich beliebige Byte-Sequenzen erzeugen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 104

108 Formatstring-Angriffe: Schreiben in den Speicher Weil die Zahl ausgegebener Zeichen nicht beliebig in die Höhe getrieben werden kann, können so zunächst nur relativ kleine Werte geschrieben werden Idee: Schreibe nacheinander mehrere überlappende Ganzzahlen an um 1 Byte verschiedene Adressen So bleibt von jeder nur das niedrigstwertige Byte erhalten Durch geschicktes Anordnen lassen sich beliebige Byte-Sequenzen erzeugen! Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 104

109 Formatstring-Angriffe: Zusammenfassung Können bei allen Befehlen auftreten, die Formatstrings benutzen Wenn es dumm läuft und entsprechende Fehler in einem Programm existieren, werden sehr weitgehende Angriffe möglich Vorstellbar ist z. B. das Einbetten von Shellcode in einen auf dem Stack abgelegten Formatstring der zugleich auf die Rücksprungadresse entsprechend überschreibt, so dass der Shellcode angesprungen wird Das könnte man sogar so hinkriegen, dass ein Stack Canary unbeschädigt bleibt! In gewisser Weise sind Formatstring-Angriffe also sogar mächtiger und damit gefährlicher als klassische Pufferüberläufe! [ Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 105

110 Den Stack (Heap,...) nicht ausführbar machen Aktuelle (64-Bit-)CPUs können einzelne Speicherseiten in der Seitentabelle der virtuellen Speicherverwaltung als nicht ausführbar markieren Dies kann vom Betriebssystem genutzt werden, um Datenbereiche (wie den Stack) nicht-ausführbar zu machen Ein Sprung an eine solche Adresse löst dann einen Segmentation Fault aus Also lässt sich kein Code auf den Stack einschleusen und anspringen Viele Namen dafür: DEP, NX, W X (Write-XOR-Execute), PaX, XD,... Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 106

111 JIT Spraying ActionScript, C#, Java, JavaScript,... soll performant ausgeführt werden Darum: Nicht (nur) interpretieren, sondern just in time zu Maschinencode kompilieren und direkt anspringen Speicherseiten mit Maschinencode müssen ausführbar sein! [Blazakis: Interpreter Exploitation: Pointer Inference and JIT Spraying, http: // Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 107

112 JIT Spraying Funktionsweise Wie können wir hier eigenen Code einschleusen? Maschinencode versetzt anspringen: Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 108

113 JIT Spraying Limitierungen Adresse des eingeschleusten Codes schwer vorhersagbar (mehr dazu später) JIT-Compiler (bislang) nur in Webbrowser Adobe Flash PDF-Reader Java.NET Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 109

114 Angriffe ohne eingeschleusten Code Kein JIT-Compiler? Dann müssen wir wohl ohne eigenen Maschinencode auskommen......dafür gibt es genug Möglichkeiten. :-) Besonders mächtig sind z. B. Return-to-libc-Angriffe Idee: überschreibe die Rücksprungadresse mit Adressen von Funktionen aus der C-Standardbibliothek durch noch weiteres Überschreiben des Stack können diesen Funktionen sogar Parameter übergeben werden Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 110

115 Return-to-libc-Angriffe Besonders raffinierte Variante: basteln eines vollständig künstlichen Stacks mit vielen Rücksprungadressen kann dann viele Aufrufe in die Standardbibliothek beliebig hintereinander ausführen Unter Windows gab es Angriffe, die durch das Auslösen geeigneter Funktionsaufrufe DEP ausgeschaltet haben :-) Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 111

116 Verwendung beliebiger Einsprungpunkte Als Einsprungadressen können dabei nicht nur die Anfangsadressen von Funktionen dienen: man kann prinzipiell an eine beliebige Stelle in eine Funktion hinein springen...und so z. B. nur die letzten paar Maschineninstruktionen vor einem ret ausführen 2007 wurde gezeigt, dass die Enden von Funktionen in der GNU libc ausreichen, um beliebige Berechnungen auszuführen Vorgeschlagen und demonstriert wurde sogar ein Compiler, der Programme in eine Folge von solchen Rücksprungadressen übersetzt! [Shacham: The Geometry of Innocent Flesh on the Bone: Return-into-libc without Function Calls (on the x86), CCS 07] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 112

117 Adressbereichs-Randomisierung Um die Rücksprungadresse gezielt modifizieren zu können, müssen Angreifer die Zieladresse kennen Das Betriebssystem bzw. der Linker können die Startadressen der einzelnen Speicherbereiche von ausführbaren Programmen randomisieren: Address Space Layout Randomization (ASLR) Wähle also zufällige Startadressen für Bereiche wie Stack Code- und Datensegment Heap Einsprungadressen für Bibliotheksfunktionen usw. In vielen modernen Betriebssystemen implementiert In unserer Ubuntu-VM ist ASLR ausgeschaltet Test: cat /proc/sys/kernel/randomize_va_space Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 113

118 Auslesen von Adressen Formatstring-Attacken liefern Rücksprungadressen (gibt Aufschluss über die Lage des Codesegmentes und/oder Bibliothekseinsprungpunkte) Zeiger auf den Heap oder Stack in lokalen Variablen... Speicheradressen können in Hochsprachen (ActionScript, JavaScript, Python,...) preisgeben werden durch hashcode-werte Reihenfolge von Objekten in Mengen und Maps Debug-Methoden [Blazakis: Interpreter Exploitation: Pointer Inference and JIT Spraying, Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 114

119 Auslesen von Adressen in Python Beispiel: Python >>> help(id) id(object) -> integer Return the identity of an object. This is guaranteed to be unique among simultaneously existing objects. (Hint: it s the object s memory address.) >>> vlname = Netzwerksicherheit >>> id(vlname) $ gdb python $(pidof python) (gdb) x/s x14 0xb7cf5604: "Netzwerksicherheit" Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 115

120 Raten von Startadressen Ein 32-Bit-Adressraum lässt nur wenig Spielraum für die Randomisierung Das liegt vor allem an Alignment-Anforderungen, zum Beispiel muss der Stack an einer durch 16 teilbaren Adresse anfangen der Heap auf einer Speicherseitengrenze (glatte 4 KiB) anfangen usw. Das lässt nur relativ wenige Möglichkeiten (also eine geringe Entropie) Aus Performancegründen werden oft nicht-kryptographische Zufallsgeneratoren verwendet Es wurde gezeigt, wie Angreifer in vielen Fällen durch geschicktes Raten ans Ziel kommen können [Shacham, Page, Pfaff, Goh, Modadugu, Boneh: On the Effectiveness of Address-Space Randomization, CCS 04] Netzwerksicherheit Teil 2: Buffer Overflows und andere Gemeinheiten 116

121 Speicher-Checks sind ohne weitere Optimierungen (JIT) langsam(er) Performante High-Level-Sprachen sind nicht immer verfügbar Netzwerksicherheit Ein Teil (kleiner) 2: Buffer Overflows Code-Teil und anderemuss Gemeinheiten immer in Assembler 117 Sichere Programmierung Wie kann man Speichermanagement-Schwachstellen vermeiden? In einer abstrakteren Programmiersprache (z.b. Java oder Python) programmieren