Software Exploitation - Exam

Aufgabe 1)

Buffer-Overflows: Buffer-Overflow ist ein Sicherheitsproblem, bei dem ein Programm mehr Daten in einen Puffer schreibt, als dieser aufnehmen kann, was zur Überschreibung von benachbarten Speichersegmenten führt. Dies kann zu unvorhersehbaren Effekten, wie der Ausführung von schädlichem Code, Systemabstürzen oder der Korruption von Daten führen. Historisch bekannt wurde dieses Problem durch die erste dokumentierte Buffer-Overflow-Attacke, den Morris-Wurm im Jahr 1988. Heute gibt es verschiedene Schutzmaßnahmen gegen Buffer-Overflow-Attacken, darunter Bounds-Checking, Stack Canaries, ASLR (Address Space Layout Randomization) und DEP (Data Execution Prevention).

a)

Erkläre anhand eines C-Codesnippets, wie ein Buffer-Overflow auf einem Stack auftreten kann und beschreibe die potentiellen Folgen dieser Sicherheitslücke. Verwende folgende Funktion als Ausgangspunkt:

 'void vulnerable_function(char *user_input) { char buffer[10]; strcpy(buffer, user_input);}' 

Lösung:

Beispiel eines Buffer-Overflows in C und dessen Konsequenzen:Ein Buffer-Overflow tritt auf, wenn ein Programm mehr Daten in einen Puffer schreibt, als dieser fassen kann. Dies kann dazu führen, dass benachbarte Speicherbereiche überschrieben werden, was schwerwiegende Sicherheitsprobleme verursachen kann.Beispielcode:

 void vulnerable_function(char *user_input) {     char buffer[10];     strcpy(buffer, user_input);} 

• Erklärung: Die Funktion vulnerable_function nimmt einen char-Pointer (user_input) als Parameter und kopiert dessen Inhalt in ein lokales Array namens buffer mit einer festen Größe von 10 Bytes.
• Problem: Die Funktion strcpy überprüft nicht, ob die Länge von user_input die Größe des Zielspeichers buffer überschreitet.
• Buffer-Overflow: Wenn user_input mehr als 10 Zeichen enthält, werden die überzähligen Zeichen über den Speicherbereich von buffer hinaus geschrieben. Dies führt zu einem Buffer-Overflow.
• Potentielle Folgen:
  • Ausführung von Schadcode: Ein Angreifer kann gezielt Schadcode in den Speicher einschleusen, der dann ausgeführt wird. Dies kann zur vollständigen Übernahme des Systems führen.
  • Systemabsturz: Der Speicherüberlauf kann zu einem Absturz des Programms oder des gesamten Systems führen.
  • Datenkorruption: Durch Überschreiben benachbarter Speicherbereiche können wichtige Daten beschädigt oder verändert werden, was unvorhersehbare Folgen haben kann.

Schutzmaßnahmen:

• Bounds-Checking: Implementiere in der Softwareprüfungen, die sicherstellen, dass die Puffergröße nicht überschritten wird.
• Stack Canaries: Einfügen spezieller Werte im Speicher, die überprüft werden, um festzustellen, ob sie überschrieben wurden.
• ASLR (Address Space Layout Randomization): Zufällige Anordnung von Speicherbereichen, um es Angreifern zu erschweren, gezielt Schwachstellen auszunutzen.
• DEP (Data Execution Prevention): Verhindert die Ausführung von Code in als nicht ausführbar markierten Speicherbereichen.

b)

Beschreibe mindestens zwei der oben genannten Schutzmaßnahmen gegen Buffer-Overflow-Attacken und erkläre, wie sie funktionieren. Gib konkrete Beispiele oder vergissmissten Szenarien an, bei denen diese Maßnahmen erfolgreich die Exploitation verhindern konnten.

Lösung:

Schutzmaßnahmen gegen Buffer-Overflow-Attacken:

• Bounds-Checking:Bounds-Checking ist eine Technik, bei der die Software so programmiert wird, dass sie vor dem Schreiben in einen Puffer überprüft, ob der verfügbare Platz ausreicht. Dadurch wird verhindert, dass Daten über das Ende des Puffers hinaus geschrieben werden.
  • Funktionsweise: Durch die Verwendung von sicheren Funktionen wie strncpy anstelle von strcpy oder durch explizite Überprüfung der Eingabegrößen wird sichergestellt, dass die Länge der eingehenden Daten innerhalb der Kapazität des Puffers bleibt.
  • Beispiel: In modernem C wird oft strncpy(buffer, user_input, sizeof(buffer) - 1) verwendet, um sicherzustellen, dass niemals mehr Zeichen als die Puffergröße kopiert werden. Das zusätzliche -1 sorgt dafür, dass ein Null-Byte zur Terminierung der Zeichenkette hinzugefügt werden kann.
  • Erfolgsszenario: Diese Technik verhinderten Exploitation-Attacken wie z.B. den Slammer-Wurm im Jahr 2003, indem die Schwachstellen in der Länge der Übertragungsdaten überprüft und diese begrenzt wurden.
• ASLR (Address Space Layout Randomization):ASLR ist eine Sicherheitsmaßnahme, die die Speicheradressen von ausführbaren Dateien und Bibliotheken zufällig anordnet.
  • Funktionsweise: Bei jedem Neustart des Systems oder der Anwendung werden die Speicheradressen von wichtigen Speichersegmenten wie dem Stack, dem Heap und den Bibliotheken zufällig verteilt. Dies erschwert es Angreifern, die genaue Speicheradresse zu erraten. Zum Beispiel befindet sich dieselbe Funktion an unterschiedlichen Speicheradressen bei verschiedenen Ausführungen.
  • Beispiel: Angenommen, eine Anwendung hat eine bekannte Schwachstelle an einer bestimmten Speicheradresse. Durch ASLR wird sichergestellt, dass die Speicheradresse der Schwachstelle bei jedem Neustart unterschiedlich ist, wodurch der Angreifer die Position des Exploits nicht vorhersagen kann.
  • Erfolgsszenario: ASLR hat viele Exploits signifikant erschwert, beispielsweise die Exploitation von Schwachstellen im Internet Explorer und anderen modernen Browsern, da die Angreifer durch die zufällige Verteilung der Adressen keine zuverlässigen Exploits konstruieren konnten.

Aufgabe 2)

Du arbeitest als Sicherheitsanalyst und wirst gebeten, eine Sicherheitsüberprüfung einer alten C-Anwendung durchzuführen. Während Deiner Untersuchung stellst Du fest, dass die Anwendung anfällig für verschiedene Arten von Buffer Overflows ist. Zum besseren Verständnis dieser Angriffe und zur Entwicklung von Gegenmaßnahmen, analysiere die Beispiele und erkläre die Angriffsmethoden im Detail. Beachte, dass die Anwendung folgende Schwachstellen aufweist:

• Die Anwendung verwendet die Funktion gets() zur Eingabe, um Benutzerdaten in einen fixen Puffer zu lesen.
• Die Anwendung hat kritische Bereiche im Speicher, die nicht ausreichend vor Manipulationen geschützt sind.

a)

Beschreibe einen stack-based buffer overflow. Erkläre detailliert, wie dieser Angriff funktioniert, indem Du die Überschreibung des Rücksprungadressenspeichers erklärst, und welche Konsequenzen dies für die Anwendung haben kann. Verwende gegebenenfalls C-Code, um den Prozess anschaulicher zu machen.

Lösung:

Stack-basierter Buffer Overflow

Ein stack-basierter Buffer Overflow tritt auf, wenn ein Programm mehr Daten in einen Puffer (Buffer) auf dem Stack schreibt, als dieser aufnehmen kann. Dadurch werden benachbarte Speicherbereiche überschrieben, was zu einem abnormalen Verhalten des Programms führen kann. Hier ist eine detaillierte Erklärung, wie dieser Angriff funktioniert:

1. Funktionsweise des Angriffs

• Angreifer nutzen die Tatsache aus, dass in C Speicherplatz auf dem Stack für lokale Variablen und Funktionsaufrufe reserviert wird.
• Wenn mehr Daten in einen Puffer geschrieben werden, als der Puffer aufnehmen kann, überschreiben diese Daten benachbarte Speicherbereiche.
• Ein kritischer benachbarter Speicherbereich ist der Rücksprungadressen-Speicher (return address), der angibt, wohin das Programm nach dem Beenden der aktuellen Funktion zurückspringen soll.
• Durch das Überschreiben dieser Rücksprungadresse kann der Angreifer die Kontrolle über den Kontrollfluss des Programms erlangen und dieses dazu bringen, beliebigen Code auszuführen, z.B. Schadcode.

2. Beispiel in C

#include <stdio.h>#include <string.h>void vulnerable_function() {    char buffer[64];    gets(buffer);  // unsichere Funktion, Verwendung von gets() bereitet den Weg für Buffer Overflow}int main() {    vulnerable_function();    return 0;}

• In diesem Beispiel hat der Puffer buffer eine feste Größe von 64 Bytes.
• Die Funktion gets() liest eine Zeichenkette von der Standardeingabe (stdin), ohne die Größe der Eingabe zu überprüfen.
• Ein Angreifer könnte mehr als 64 Bytes eingeben, um den Speicherbereich buffer und anschließend die Rücksprungadresse zu überschreiben.

3. Konsequenzen

• Das Überschreiben der Rücksprungadresse ermöglicht es dem Angreifer, die Ausführung des Programms an eine von ihm gewählte Adresse umzuleiten.
• Der Angreifer könnte diese Adresse auf schädlichen Code (payload) setzen, der im Puffer oder an einer anderen bekannten Speicheradresse steht.
• Das kann zur Ausführung von beliebigem Code führen, wie z.B. einer Shell, die dem Angreifer Zugang zum System verschafft.

Um dieser Art von Angriff vorzubeugen, sollte man unsichere Funktionen wie gets() vermeiden und stattdessen sichere Alternativen wie fgets() verwenden, die die Größe des Puffers berücksichtigen.

b)

Nehmen wir an, Du hast folgenden C-Code entdeckt:

char buffer[8];gets(buffer);

Zeige anhand dieses Code-Snippets, wie ein heap-based buffer overflow durchgeführt werden könnte. Verwende sowohl theoretische Erklärungen als auch praktische Beispiele. Diskutiere, wie die Manipulation von Speichersteuerinformationen die Programmausführung beeinflussen kann.

Lösung:

Heap-basierter Buffer Overflow

Ein heap-basierter Buffer Overflow tritt auf, wenn mehr Daten in einen Puffer auf dem Heap geschrieben werden, als dieser aufnehmen kann. Im Gegensatz zum Stack, der für lokale Variablen und Funktionsaufrufe genutzt wird, werden auf dem Heap dynamisch angeforderte Speicherbereiche gespeichert, die während der Programmausführung verwaltet werden. Hier ist eine detaillierte Erklärung, wie dieser Angriff funktioniert:

1. Funktionsweise des Angriffs

• Angreifer nutzen die Tatsache aus, dass auf dem Heap dynamisch Speicherplatz für Programmstrukturen reserviert wird.
• Wenn mehr Daten in einen Puffer geschrieben werden, als der Puffer aufnehmen kann, überschreiben diese Daten benachbarte Speicherbereiche auf dem Heap.
• Ein kritischer benachbarter Speicherbereich sind die Speichersteuerinformationen (Heap Management Information), die vom Speicherverwaltungsmechanismus benutzt werden, um den Zustand des Heaps zu verwalten.
• Durch das Überschreiben dieser Speichersteuerinformationen kann ein Angreifer die Funktionsweise der Speicherverwaltung manipulieren und das Programm zwingen, bösartigen Code auszuführen.

2. Beispiel in C

#include <stdio.h>#include <stdlib.h>#include <string.h>void vulnerable_function() {    char *buffer = (char *)malloc(8);  // Speicher auf dem Heap reservieren    gets(buffer);  // unsichere Funktion, Verwendung von gets() bereitet den Weg für Buffer Overflow}int main() {    vulnerable_function();    return 0;}

• In diesem Beispiel wird der Puffer buffer auf dem Heap alloziert und hat eine feste Größe von 8 Bytes.
• Die Funktion gets() liest eine Zeichenkette von der Standardeingabe (stdin), ohne die Größe der Eingabe zu überprüfen.
• Ein Angreifer könnte mehr als 8 Bytes eingeben, um den Speicherbereich buffer und das benachbarte Speichersteuerinformationen zu überschreiben.

3. Manipulation von Speichersteuerinformationen

• Die Speichersteuerinformationen können z.B. Zeiger auf vorherige und nächste freie Blöcke (Free Blocks) enthalten.
• Durch das Überschreiben dieser Zeiger kann ein Angreifer die Speicherverwaltungsfunktionen wie malloc() und free() manipulieren.
• Ein Angreifer könnte beispielsweise die Zeiger so verändern, dass bei einer Speicherfreigabe (free) eine falsche Adresse dereferenziert wird, was zur Ausführung von bösartigem Code führt.

4. Konsequenzen

• Das Überschreiben der Speichersteuerinformationen kann dazu führen, dass das Programm unautorisierten Code ausführt oder abstürzt.
• Ein erfolgreicher Heap-basierter Buffer Overflow kann es dem Angreifer ermöglichen, die Kontrolle über den gesamten Prozess zu erlangen, inklusive des Lesens, Schreibens und Ausführens von beliebigem Code.

Um dieser Art von Angriff vorzubeugen, sollte man unsichere Funktionen wie gets() vermeiden und stattdessen sichere Alternativen wie fgets() verwenden, die die Größe des Puffers berücksichtigen. Außerdem kann das Aktivieren von Sicherheitsmechanismen wie Data Execution Prevention (DEP) und Address Space Layout Randomization (ASLR) dazu beitragen, die Auswirkungen eines solchen Angriffs zu minimieren.

c)

Die Anwendung ist auch anfällig für format string attacks. Diskutiere, was ein Format String Angriff ist, und wie Angreifer diesen nutzen könnten, um Speicherinhalte zu lesen oder zu schreiben. Ergänze Deine Erläuterungen mit einem Beispiel, das zeigt, wie ein solcher Angriff aussehen könnte, und erkläre die mathematischen Hintergründe der Manipulation von Speicheradressen, falls zutreffend.

Lösung:

Format String Angriffe

Ein Format String Angriff tritt auf, wenn Eingaben von Benutzern in Funktionen verwendet werden, die eine Formatzeichenkette verarbeiten, ohne diese Eingaben ordnungsgemäß zu validieren. Dadurch kann ein Angreifer spezielle Formatzeichen verwenden, um unvorhergesehenen Speicherzugriff zu erlangen. Hier ist eine detaillierte Erklärung, wie dieser Angriff funktioniert:

1. Funktionsweise des Angriffs

• Funktionen wie printf, fprintf, sprintf und ähnliche arbeiten mit Formatzeichenketten, um die Darstellung der Ausgaben zu steuern:
• Typische Formatzeichen sind %s (zeigt eine Zeichenkette an), %d (zeigt eine Ganzzahl an) und %x (zeigt eine Hexadezimalzahl an).
• Wenn ein Benutzer direkten Einfluss auf die Formatzeichenkette hat, kann er Spezialzeichen benutzen, um Speicherinhalte zu lesen oder zu schreiben.
• Beispielsweise kann %x verwendet werden, um Werte aus dem Stack zu drucken, und %n, um die Anzahl der bisher gedruckten Zeichen in eine Adresse zu schreiben.

2. Beispiel in C

#include <stdio.h>void vulnerable_function(char *user_input) {    printf(user_input);  // unsichere Verwendung einer Formatzeichenkette}int main() {    char input[100];    gets(input);  // unsichere Eingabefunktion vervollständigt das Problem    vulnerable_function(input);    return 0;}

• In diesem Beispiel wird die Eingabe des Benutzers direkt in der printf-Funktion als Formatzeichenkette verwendet.
• Ein Angreifer könnte etwas wie „%x %x %x %x“ eingeben, um verschiedene Speicherinhalte anzuzeigen.
• Ein anderes Beispiel wäre, „%s“ zu verwenden, um einen Speicherbereich als Zeichenkette zu interpretieren, oder „%n“, um Speicheradressen zu manipulieren.

3. Speicherleseangriff

• Wenn ein Angreifer die Kontrolle über die Formatzeichenkette hat, kann er Speicherbereiche auslesen:

%x %x %x %x

Das Ausgeben von „%x“ führt dazu, dass aufeinanderfolgende Werte aus dem Stack im Hexadezimalformat angezeigt werden.

Dies kann vertrauliche Informationen enthüllen, wie z.B. Adressen von Variablen oder sogar Passwörter, die im Stack gespeichert wurden.

4. Manipulation von Speicheradressen

• Durch die Verwendung von „%n“ kann ein Angreifer in den Speicher schreiben:

%n

Der Formatstring „%n“ schreibt die Anzahl der bisher gedruckten Zeichen in eine Speicheradresse, die auf dem Stack angegeben ist.

Dadurch kann ein Angreifer gezielt bestimmten Speicher manipulieren, indem er die Druckzeichen und den Zeiger auf die zu schreibende Adresse geschickt kombiniert.

Mathematische Hintergründe

• Der Wert, der durch „%n“ geschrieben wird, entspricht der Anzahl der bisher durch printf geschriebenen Zeichen.
• Angenommen, ein Angreifer möchte den Wert 1000 in eine bestimmte Adresse schreiben. Er könnte eine Formatzeichenkette wie „AAA%n“ verwenden:

AAA%*1000$x

Hierbei würde „%*1000$x“ zusätzliche Ausgaben erzwingen, sodass die Gesamtanzahl der Zeichen 1000 erreicht, die dann durch „%n“ in den Speicher geschrieben wird.

Konsequenzen

• Ein erfolgreicher Format String Angriff kann zu einer Vielzahl von Auswirkungen führen, einschließlich des Lesens vertraulicher Daten, des Absturzes des Programms und der Ausführung von Schadcode.

Schutzmaßnahmen

• Benutze keine Benutzereingaben direkt als Formatzeichenkette in Funktionen wie printf(). Verwende immer feste, vordefinierte Formatzeichenketten.
• Nutze sichere Alternativen und Bibliotheken, die Formatzeichenketten schützen.
• Überprüfe und validiere alle Benutzereingaben sorgfältig.

Aufgabe 3)

Angenommen, Du entwickelst eine Software, die sicher und stabil gegen Buffer Overflow Angriffe sein muss. Diese Software verarbeitet Benutzereingaben und führt verschiedene Berechnungen und Operationen durch. Zur Verhinderung von Buffer Overflows entscheidest Du dich, einige gängige Schutzmechanismen und Best Practices einzusetzen. Betrachte die folgenden Maßnahmen und beantworte die zugehörigen Fragen.

a)

Um die Verwendung unsicherer Funktionen in Deinem Code zu vermeiden, hast Du beschlossen, strcpy durch strncpy zu ersetzen. Gib ein beispielhaftes Codesegment an, welches diese Änderung demonstriert. Erkläre außerdem, warum strncpy sicherer ist als strcpy und wie dies zur Stabilität Deiner Software beiträgt.

Lösung:

Um die Verwendung unsicherer Funktionen in Deinem Code zu vermeiden, kannst Du strcpy durch strncpy ersetzen. Hier ist ein beispielhaftes Codesegment, das diese Änderung demonstriert:

 #include <stdio.h> #include <string.h> int main() { char src[] = 'Hallo, Welt!'; char dest[15]; // Verwendet strncpy anstelle von strcpy strncpy(dest, src, sizeof(dest) - 1); // Sicherstellen, dass der Ziel-String nullterminiert ist dest[sizeof(dest) - 1] = '0'; printf('Ziel-String: %s', dest); return 0; } 

Warum ist strncpy sicherer als strcpy?

• strncpy ermöglicht es Dir, die maximale Anzahl der zu kopierenden Zeichen anzugeben. Auf diese Weise verhinderst Du, dass mehr Daten als der zur Verfügung stehende Speicherplatz kopiert werden.
• Indem Du die Länge des Zielarrays als Grenze setzt, kannst Du verhindern, dass Daten in benachbarte Speicherbereiche überschrieben werden, was zu einem Buffer Overflow führen könnte.

Diese Maßnahmen tragen erheblich zur Stabilität Deiner Software bei, indem sie verhindern, dass unkontrolliertes Überschreiben von Speicherplätzen zu unvorhergesehenem Verhalten oder Sicherheitsanfälligkeiten führt.

b)

Stelle Dir vor, Du planst den Einsatz von Stack Canaries in Deiner Software, um Buffer Overflows zu erkennen. Beschreibe in einem detaillierten Ablauf, wie Stack Canaries funktionieren und wie sie in der Praxis implementiert werden. Gehe auch auf mögliche Schwächen dieses Mechanismus ein und wie ein Angreifer dennoch versuchen könnte, diesen Schutz zu umgehen.

Lösung:

Stack Canaries zur Erkennung von Buffer Overflows

Stack Canaries sind eine Schutzmaßnahme, die auf dem Stack eingesetzt wird, um Buffer Overflows zu erkennen und zu verhindern. Hier ist ein detaillierter Ablauf, wie Stack Canaries funktionieren und wie sie in der Praxis implementiert werden:

• Initialisierung des Stack Canaries: Beim Starten eines Programms wird ein spezieller Wert, der Canary genannt wird, auf den Stack geschrieben. Dieser Wert ist schwer vorhersagbar und wird zwischen dem lokalen Speicherbereich einer Funktion und der Rücksprungadresse abgelegt.
• Überprüfung des Stack Canaries: Bevor eine Funktion zurückkehrt (also bevor der Rücksprung zur aufrufenden Funktion erfolgt), wird der Canary-Wert überprüft. Wenn der Canary-Wert verändert wurde, wird davon ausgegangen, dass ein Buffer Overflow vorliegt.
• Reagieren auf eine Veränderung: Wird eine Veränderung des Canary-Werts festgestellt, kann das Programm geeignete Maßnahmen ergreifen, wie z.B. das Schließen des Programms, um Sicherheitslücken zu verhindern.

 #include <stdio.h> #include <stdlib.h> #include <string.h> #define CANARY_VALUE 0xDEADBEEF // Beispielhafter Canary-Wert void function_with_canary(char *input) { unsigned int canary = CANARY_VALUE; char buffer[10]; // Speichern der Länge des Buffers int length = sizeof(buffer); // Überprüfung der Eingabe, um Buffer Overflow zu vermeiden if (strlen(input) >= length) { printf('Eingabe zu lang!'); exit(1); } // Kopieren der Eingabe in den Buffer strcpy(buffer, input); // Überprüfung des Canary-Werts if (canary != CANARY_VALUE) { printf('Buffer Overflow erkannt!'); exit(1); } } int main(void) { function_with_canary('Test'); return 0; } 

Schwächen des Stack-Canary-Mechanismus

• Erratbare Canaries: Wenn der Canary-Wert vorhersagbar ist (z.B. immer der gleiche oder leicht zu erratende Muster), könnten Angreifer den Schutzmechanismus umgehen. Daher werden in der Praxis oft zufällige Canaries verwendet.
• Konditionale Sprünge: Einige Angreifer könnten versuchen, anstatt den Canary-Wert direkt zu verändern, durch geschickte Manipulation des Programmlogics mögliche Sprünge zu beeinflussen, ohne dass der Canary-Wert selbst verändert wird.
• Nur gegen Stack-basierte Angriffe: Stack Canaries schützen nur gegen bestimmte Arten von Buffer Overflows, die den Stack beeinflussen. Andere Formen von Überläufen, die den Heap oder andere Speicherbereiche betreffen, werden nicht adressiert.

Indem Du Stack Canaries mit anderen Sicherheitsmechanismen wie Address Space Layout Randomization (ASLR) und Data Execution Prevention (DEP) kombinierst, kannst Du den Schutz Deiner Software gegen verschiedene Arten von Angriffen weiter erhöhen.

c)

Eine wichtige Rolle bei der Verhinderung von Buffer Overflows spielt die Address Space Layout Randomization (ASLR). Berechne in einer theoretischen Betrachtung, wie viele mögliche Speicherlayouts ASLR erzeugen kann, wenn die zufällige Anordnung 16 verschiedene Positionen für jede Segmentierungstabelle verwendet. Weiterhin, diskutiere die Effektivität von ASLR in der Praxis und unter welchen Umständen sie möglicherweise nicht ausreichend Schutz bietet.

Lösung:

Berechnung der möglichen Speicherlayouts mit ASLR

Address Space Layout Randomization (ASLR) ist eine Sicherheitsmaßnahme, die die Speicheradressen von Prozessen zufällig anordnet. Dies erschwert es Angreifern, die genaue Position von Schwachstellen vorherzusagen.

Angenommen, es gibt 16 verschiedene Positionen für jede Segmentierungstabelle, dann berechnet sich die Anzahl der möglichen Speicherlayouts wie folgt:

Wenn jede Segmentierungstabelle 16 mögliche Positionen hat und es n Segmentierungstabellen gibt, dann ist die Gesamtzahl der möglichen Speicherlayouts bsp;\textsf{ASLR}_{n}:

 ASLR_n = 16^n

Falls z.B. 4 Segmentierungstabellen vorhanden sind, lautet die Berechnung:

 ASLR_4 = 16^4 = 65536

Das bedeutet, dass es in diesem Fall 65.536 mögliche Speicherlayouts gibt.

Effektivität von ASLR in der Praxis

• Zufälligkeit: ASLR erhöht die Schwierigkeit für Angreifer, erfolgreiche Angriffe durchzuführen, indem es die wahrscheinlichen Layouts des Speichers zufällig verteilt.
• Kombination mit anderen Mechanismen: ASLR ist am effektivsten, wenn es zusammen mit anderen Sicherheitsmaßnahmen wie Stack Canaries und Data Execution Prevention (DEP) verwendet wird.
• Begrenzte Zufälligkeit: Wenn die Anzahl der möglichen Positionen begrenzt ist, kann ein Angreifer durch Versuch und Irrtum das Layout herausfinden, insbesondere bei wiederholten Angriffen.

Umstände, unter denen ASLR möglicherweise nicht ausreichend Schutz bietet

• Informationslecks: Wenn ein Angreifer Informationen über die Speicheradressen erhält, kann er die zufällige Anordnung umgehen. Solche Informationenlecks sind oft das Resultat von Softwarefehlern.
• Brute-Force-Angriffe: Bei einem begrenzten Adressraum könnten Angreifer Brute-Force-Techniken verwenden, um die möglichen Speicherlayouts systematisch zu testen, insbesondere bei Systemen mit niedriger Neuladefähigkeit.
• Teilschutz: ASLR schützt nicht vollständig vor allen Arten von Angriffen, zum Beispiel Heap Overflows oder Angriffe auf andere Speicherbereiche, die nicht vollständig randomisiert werden.

Zusammenfassend lässt sich sagen, dass ASLR eine wichtige Schutzmaßnahme gegen Buffer Overflow Angriffe darstellt, aber in Kombination mit zusätzlichen Sicherheitsstrategien und ständiger Softwareprüfung effektiver ist.

Aufgabe 4)

Du bist als neuer Mitarbeiter in einem Softwareentwicklungsteam eingestiegen und sollst den bisherigen Code auf Sicherheitslücken überprüfen. Während der Überprüfung fällt dir auf, dass in mehreren Stellen der Code unsichere Formatstrings verwendet werden. Deine Aufgabe ist es, die potenziellen Sicherheitsrisiken zu identifizieren und Lösungen zu entwickeln, um diese Risiken zu minimieren.

a)

Erkläre, wie Format String Vulnerabilities entstehen können, indem Du das folgende Beispiel betrachtest:

char buf[100];printf(buf);

Welche Lücke entsteht hier und wie könnte ein Angreifer diese ausnutzen?

Lösung:

Einleitung: Format String Vulnerabilities entstehen, wenn ein Programmierer unsichere Formatierungsfunktionen verwendet, bei denen Benutzereingaben oder unkontrollierte Daten als Formatstrings interpretiert werden. Diese Sicherheitslücken können zu unerwartetem Verhalten, Datenlecks und sogar Remote Code Execution führen.

Beispielanalyse: Betrachten wir das folgende Code-Beispiel:

char buf[100];printf(buf);

• Im obigen Beispiel wird der Inhalt des Arrays buf direkt an die Funktion printf übergeben, ohne einen Formatierungsstring anzugeben.
• Das bedeutet, dass printf den Inhalt von buf als Formatstring interpretiert.

Entstehende Sicherheitslücke:

• Ein Angreifer könnte den Inhalt von buf manipulieren und spezielle Formatzeichen wie %x oder %s einfügen.
• Dadurch könnte der Angreifer beispielsweise auf Speicherbereiche zugreifen, die normalerweise nicht zugänglich sind, und sensible Informationen wie Passwörter oder kryptografische Schlüssel auslesen.
• Im schlimmsten Fall könnte ein Angreifer durch geschicktes Einfügen von Formatzeichen usw. auch den Programmfluss manipulieren und eigenen Code zur Ausführung bringen.

Lösungsvorschläge:

• Verwende sichere Funktionen wie snprintf, die eine sichere Formatierung von Strings gewährleisten.
• Stelle sicher, dass Formatierungsstrings fest im Code definiert sind und nicht durch Benutzereingaben beeinflusst werden können.
• Überprüfe alle Benutzereingaben gründlich, bevor sie in Funktionen wie printf verwendet werden.

b)

Ein Angreifer kennt die Speicheradresse einer Variable und möchte diese mit dem Wert 0xdeadbeef überschreiben. Gegeben sei folgender Codeabschnitt:

void vulnerable_function(char *user_input) {    char buf[100];    sprintf(buf, user_input);    printf(buf);}

Beschreibe einen möglichen Angriffsszenario, in dem der Angreifer die Formatstring-Schwachstelle ausnutzt. Verdeutliche deinen Angriff mit konkreten Eingaben für user_input.

Lösung:

Einleitung: Format String Vulnerabilities erlauben es einem Angreifer, direkt auf den Speicher zuzugreifen und sogar Speicherinhalte zu manipulieren. Diese Schwachstelle kann ausgenutzt werden, um ungewünschtes Verhalten in einem Programm zu bewirken.

Anfälliger Codeabschnitt:

void vulnerable_function(char *user_input) {    char buf[100];    sprintf(buf, user_input);    printf(buf);}

• Der obige Code nimmt die Benutzereingabe user_input und platziert sie im Puffer buf, bevor sie an printf übergeben wird.

Das Problem hierbei ist, dass user_input als Formatstring interpretiert wird und daher spezielle Formatzeichen wie %x oder %n eingebettet werden können, um auf den Speicher zuzugreifen oder ihn zu manipulieren.

Möglicher Angriffsszenario:

• Angenommen, der Angreifer kennt die Speicheradresse einer Zielvariable, die auf 0x804a00c liegt.
• Das Ziel ist es, diese Speicheradresse mit dem Wert 0xdeadbeef zu überschreiben.
• Der Angreifer könnte eine geeignete Eingabe für user_input konstruieren, um dies zu erreichen.

Konkrete Eingabe für user_input:

• Zunächst konvertiert der Angreifer die Zieladresse in ein Little-Endian-Format: 0x804a00c wird zu \x0c\xa0\x04\x08\x0d\xa0\x04\x08 (da printf in 32-Bit-Adressen schreibt).
• Um den Wert 0xdeadbeef zu schreiben, könnte der Angreifer die Eingabe konstruieren:

  %x%x%x%x%x%x%x%n0xdeadbeef

  Hier wird versucht, durch geschicktes Setzen von Formatparametern die Zieladresse mit dem Wert zu überschreiben.
• Eine vollständige Eingabe könnte nun so aussehen:

  \x0c\xa0\x04\x08\x0d\xa0\x04\x08%x%x%x%x%x%x%n

Lösung:

• Verwende sichere Funktionen wie snprintf und definiere explizite Formatstrings, um solche Angriffe zu vermeiden.
• Überprüfe und filtere alle Benutzereingaben gründlich, bevor diese in Formatierungsfunktionen verwendet werden.
• Verwende sicherheitsbewusste Codierpraktiken und Werkzeuge zur statischen Codeanalyse, um potenzielle Schwachstellen frühzeitig zu erkennen.

c)

Um die Sicherheit des Codes zu erhöhen, sollst Du Vorschläge zur Vermeidung solcher Formatstring-Schwachstellen erarbeiten. Nenne und erkläre drei Maßnahmen, die Entwickler ergreifen können, um Format String Vulnerabilities in ihrem Code präventiv zu verhindern.

Lösung:

Einleitung: Format String Vulnerabilities entstehen durch unsichere Verwendung von Formatierungsfunktionen, bei denen unkontrollierte Daten als Formatstrings interpretiert werden. Um solche Sicherheitslücken zu vermeiden, können Entwickler verschiedene Maßnahmen ergreifen. Hier sind drei präventive Maßnahmen zur Vermeidung solcher Schwachstellen:

• Verwendung von sicheren Funktionen:Verwende sichere Alternativen zu Funktionen wie printf, die Benutzereingaben formatieren. Beispiele für sichere Funktionen sind snprintf und vsnprintf. Diese Funktionen erlauben es, die Länge des Ausgabepuffers zu spezifizieren und vermeiden so Pufferüberläufe. Zudem sollte der Formatstring immer explizit und fest im Code definiert sein und nicht von Benutzereingaben abhängen.
• Eingabevalidierung und -filterung:Stelle sicher, dass alle Benutzereingaben gründlich validiert und gefiltert werden, bevor sie in Formatierungsfunktionen verwendet werden. Ein einfacher Weg, dies zu erreichen, ist die Verwendung von Whitelists, um nur erlaubte Zeichen und Formate zuzulassen. Somit wird verhindert, dass ein Angreifer spezielle Formatzeichen in die Eingabe einfügt.
• Code Audits und statische Codeanalyse:Regelmäßige Code Reviews und die Verwendung von Werkzeugen zur statischen Codeanalyse können helfen, potenzielle Format String Vulnerabilities frühzeitig zu erkennen und zu beheben. Diese Werkzeuge durchsuchen den Code nach unsicheren Funktionen und warnen den Entwickler vor möglichen Sicherheitslücken. Zusätzlich können sie Vorschläge zur Behebung der gefundenen Probleme bieten.

Durch diese präventiven Maßnahmen können Entwickler erhebliche Sicherheitslücken in ihrem Code vermeiden und die allgemeine Sicherheit der Software verbessern.