Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks

Stein, Thomas

Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks

Zusammenfassung

Inhaltsangabe:Einleitung:
1.1 Ausgangssituation:
Ein erhöhter Schutzbedarf von IT-Systemen kann durch Sicherheitsmaßnahmen wie Firewalls, Intrusion Detection Systeme bzw. Intrusion Prevention Systeme (IDS/IPS) gewährleistet werden,die bestimmten Datenverkehr blockieren oder Angriffe erkennen und verhindern sollen. Ein Beispiel für einen Angriff ist das Ausnutzen einer Sicherheitslücke durch einen Exploit in einem Dienst mit dem Ziel eigenen Code auszuführen und die Kontrolle über das IT-System zu erlangen. Exploiting Frameworks stellen für solche Angriffe eine Art Baukasten dar, mit dem ein Angreifer den Exploit anpassen und automatisiert gegen ein Zielsystem ausführen kann. Viele Angriffe werden jedoch durch Schutzmaßnahmen wie IDS erkannt bzw. im Falle von Intrusion Prevention Systemen (IPS) abgewehrt. Um eine Erkennung derartiger Angriffe zu verhindern, existieren mehrere kombinierbare Techniken, die jeweils auf verschiedenen Schichten des ISO OSI Modells angewendet werden, um die Mechanismen von IDS/IPS zur Erkennung von Angriffen zu umgehen. Auf der Netzwerkschicht (OSI-Schicht 3) werden beim Insertion- bzw. beim Evasion-Angriff zusätzliche Pakete in den Datenstrom zwischen Angreifer und Zielsystem eingefügt, die vom IDS und dem IT-System des Opfers unterschiedlich interpretiert bzw. verworfen werden. Durch den unterschiedlichen Datenstrom kann so z.B. das Pattern-Matching bei Signatur-basierten IDS außer Kraft gesetzt werden. Die Fragmentierung von IP Paketen (Fragmentation), sowie eine Aufteilung der Angriffsdaten auf der Transportschicht (OSI-Schicht 4) in kleine TCP-Segmente stellen weitere Möglichkeit für Insertion- oder Evasion-Angriffe dar, da IT-Systeme je nach verwendetem TCP/IP Stack Reassembly-Strategien mit unterschiedlichem Verhalten aufweisen können. Techniken zur Verschleierung von Angriffen existieren auch auf Anwendungsebene (OSI-Schicht 5-7), indem die Daten im Protokoll der Anwendung bei gleichbleibender Semantik umgeformt werden. Um derartige Angriffe zu erkennen, muss das IDS über eine entsprechende Logik für das Anwendungsprotokoll verfügen.
Unabhängig von den Insertion- oder Evasion Techniken der tieferen OSI-Schichten kann auch der Angriffscode (Exploit-Code) bei gleichbleibender Semantik so umgeformt bzw. verschleiert (Obfuscation) werden, dass dieser nicht oder schlechter durch IDS/IPS erkannt wird. Eine simple Form ist die Umcodierung des Schadcodes z.B. in das BASE-64, TAR oder ZIP Format. Eine erweiterte Form […]

Leseprobe

Inhaltsverzeichnis

Thomas Stein

Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks

ISBN: 978-3-8366-3675-9

Herstellung: Diplomica® Verlag GmbH, Hamburg, 2009

Zugl. Fachhochschule Bonn-Rhein-Sieg, Bonn, Deutschland, Bachelorarbeit, 2009

Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte,

insbesondere die der Übersetzung, des Nachdrucks, des Vortrags, der Entnahme von

Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der

Vervielfältigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen,

bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung

dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen

der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik

Deutschland in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich

vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des

Urheberrechtes.

Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in

diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme,

dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei

zu betrachten wären und daher von jedermann benutzt werden dürften.

Die Informationen in diesem Werk wurden mit Sorgfalt erarbeitet. Dennoch können

Fehler nicht vollständig ausgeschlossen werden und der Verlag, die Autoren oder

Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für evtl.

verbliebene fehlerhafte Angaben und deren Folgen.

http://www.diplomica.de, Hamburg 2009

Inhaltsverzeichnis

Abbildungsverzeichnis

Tabellenverzeichnis

Listingverzeichnis

Abkürzungsverzeichnis

Einleitung

1.1

Ausgangssituation

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.2

Forschungsstand

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.3

Zielsetzung der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.4

Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.5

Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Grundlagen von Exploiting Frameworks und Intrusion Detection Systemen

2.1

Grundlegende Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.1.1

Sicherheitslücke (Vulnerability) . . . . . . . . . . . . . . . . . . . . . . .

2.1.2

Exploit

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.1.3

Pufferüberlauf (Buffer Overflow) . . . . . . . . . . . . . . . . . . . . . .

2.1.4

Shellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.1.5

Spoofing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.1.6

Denial of Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.2

Funktionsweise von Exploiting Frameworks . . . . . . . . . . . . . . . . . . . .

2.2.1

Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.2.2

Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.2.3

Metasploit Framework (MSF) . . . . . . . . . . . . . . . . . . . . . . . .

2.2.3.1

Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.2.3.2

Benutzerschnittstellen . . . . . . . . . . . . . . . . . . . . . . .

2.3

Funktionsweise von Intrusion Detection Systemen (IDS) . . . . . . . . . . . . .

2.3.1

Definition Intrusion Detection . . . . . . . . . . . . . . . . . . . . . . . .

2.3.2

Definition Intrusion Detection System . . . . . . . . . . . . . . . . . . .

2.3.3

Taxonomie von IDS

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.3.4

Komponenten eines IDS . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.3.4.1

Netz-basierte Sensoren

. . . . . . . . . . . . . . . . . . . . . .

2.3.4.2

Host-basierte Sensoren

. . . . . . . . . . . . . . . . . . . . . .

2.3.5

Methoden der Angriffserkennung . . . . . . . . . . . . . . . . . . . . . .

2.3.5.1

Erkennung von Angriffsmustern

. . . . . . . . . . . . . . . . .

2.3.5.2

Anomalieerkennung . . . . . . . . . . . . . . . . . . . . . . . .

2.3.6

Intrusion Protection Systeme (IPS) . . . . . . . . . . . . . . . . . . . . .

2.3.7

Falschmeldungen (False Positives und False Negatives) . . . . . . . . . .

2.3.8

Sourcefire Snort (IDS/IPS) . . . . . . . . . . . . . . . . . . . . . . . . .

2.3.8.1

Architektur und Funktionsweise . . . . . . . . . . . . . . . . .

2.3.8.2

Preprozessoren . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.3.8.3

Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Konzepte zur Verschleierung von Angriffen

3.1

Allgemeine Verschleierungs-Techniken

. . . . . . . . . . . . . . . . . . . . . . .

3.1.1

Insertion / Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.1.2

Evasion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.1.3

Denial of Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.1.4

Obfuscation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.2

Angriffstechnik der Sicherungsschicht (OSI-Schicht 2) . . . . . . . . . . . . . . .

3.3

Angriffstechniken der Netzwerkschicht (OSI-Schicht 3) . . . . . . . . . . . . . .

3.3.1

Ungültige IP-Header Felder . . . . . . . . . . . . . . . . . . . . . . . . .

3.3.2

IP Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.3.3

Fragmentierung von IP-Paketen . . . . . . . . . . . . . . . . . . . . . . .

3.4

Angriffstechniken der Transportschicht (OSI-Schicht 4) . . . . . . . . . . . . . .

3.4.1

Ungültige TCP-Header Felder . . . . . . . . . . . . . . . . . . . . . . . .

3.4.2

TCP Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.4.3

TCP Stream Reassembly

. . . . . . . . . . . . . . . . . . . . . . . . . .

3.4.4

TCP Control Block (TCB) . . . . . . . . . . . . . . . . . . . . . . . . .

3.5

Angriffstechniken der Anwendungsschicht (OSI-Schicht 5-7) . . . . . . . . . . .

3.5.1

Coding Evasion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.5.2

Directory-Traversal Evasion . . . . . . . . . . . . . . . . . . . . . . . . .

3.5.3

Evasion durch polymorphen Shellcode . . . . . . . . . . . . . . . . . . .

Verschleierung von Angriffen in Exploiting Frameworks

4.1

Verschleierung von Angriffen im Metasploit Framework

. . . . . . . . . . . . .

4.1.1

Implementierte Insertion- und Evasion Techniken . . . . . . . . . . . . .

4.1.2

Implementierte Obfuscation Techniken . . . . . . . . . . . . . . . . . . .

4.1.2.1

Verschleierung des Angriffscodes . . . . . . . . . . . . . . . . .

4.1.2.2

Verschleierung des Shellcode . . . . . . . . . . . . . . . . . . .

4.1.3

Filterung von erkennbaren Angriffen auf Clientseite (IPS-Filter Plugin)

4.2

Verschleierung von Angriffen in Core Impact

. . . . . . . . . . . . . . . . . . .

4.3

Verschleierung von Angriffen in SAINT exploit . . . . . . . . . . . . . . . . . .

Bewertung von NIDS unter dem Gesichtspunkt von Evasion Techniken

5.1

Bewertungsparameter für Network Intrusion Detection Systeme . . . . . . . . .

5.2

Entwurf der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2.1

Anforderungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2.2

Auswahl der zu evaluierenden Network Intrusion Detection Systeme . .

5.2.3

Auswahl der Testverfahren

. . . . . . . . . . . . . . . . . . . . . . . . .

5.2.3.1

Tests der Evasion Techniken der Netzwerk- und Transportschicht 67

5.2.3.2

Tests der Obfuscation Techniken der Anwendungsschicht . . .

5.2.4

Konfiguration der Testumgebung . . . . . . . . . . . . . . . . . . . . . .

5.3

Realisierung der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.3.1

Einrichtung der Virtuellen Maschinen in VirtualBox . . . . . . . . . . .

5.3.1.1

Einrichtung des Metasploit Exploiting Frameworks . . . . . . .

5.3.1.2

Einrichtung der Netzwerkkomponenten (Hub, Router) . . . . .

5.3.1.3

Einrichtung des NIDS Snort

. . . . . . . . . . . . . . . . . . .

5.3.1.4

Einrichtung des NIDS / IPS Untangle . . . . . . . . . . . . . .

5.3.1.5

Einrichtung des NIDS Bro

. . . . . . . . . . . . . . . . . . . .

5.3.1.6

Einrichtung des NIDS Securepoint . . . . . . . . . . . . . . . .

5.3.1.7

Einrichtung der Zielsysteme . . . . . . . . . . . . . . . . . . . .

5.3.2

Integration der Cisco Appliances . . . . . . . . . . . . . . . . . . . . . .

5.3.2.1

Einrichtung des Cisco 2620 Routers (IP Plus) . . . . . . . . . .

5.3.2.2

Einrichtung des Cisco 4215 Sensors

. . . . . . . . . . . . . . .

5.4

Durchführung der Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.5

Auswertung der Testergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.5.1

Auswertung der Protokolldateien . . . . . . . . . . . . . . . . . . . . . .

5.5.2

Darstellung der Testergebnisse . . . . . . . . . . . . . . . . . . . . . . .

5.5.3

Zusammenfassende Bewertung der NIDS . . . . . . . . . . . . . . . . . .

102

5.5.4

Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

104

Ansätze zur verbesserten Erkennung von verschleierten Angriffen

108

6.1

Maschinelles Lernen für Echtzeit-Intrusion-Detection . . . . . . . . . . . . . . .

108

6.2

Verbesserung von NIDS durch Host-basierte Informationen

. . . . . . . . . . .

108

6.3

Verwendung von Grafikprozessoren zur Mustererkennung

. . . . . . . . . . . .

109

6.4

Dynamische Taint-Analyse zur Erkennung von Angriffen . . . . . . . . . . . . .

110

6.5

Normalisierung von Netzverkehr zur Beseitigung von Mehrdeutigkeiten . . . . .

111

6.6

Active Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

112

Zusammenfassung und Fazit

114

Literaturverzeichnis

116

Anhang

123

A Dokumente

123

A.1 Inhaltsübersicht der DVD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

123

A.2 Bewertungsparameter der evaluierten NIDS . . . . . . . . . . . . . . . . . . . .

124

B Konfigurationen

129

B.1 Snort Version 2.8.4.1 - Konfigurationsdatei snort.conf . . . . . . . . . . . . . . .

129

B.2 Cisco 4215 IDS Sensor - Konfiguration . . . . . . . . . . . . . . . . . . . . . . .

132

C Quellcode

133

C.1 Metasploit Framework Obfuscation Test Script (msfauto.sh) . . . . . . . . . . .

133

C.2 Metasploit IDS Filter Plugin (ids_filter.rb) . . . . . . . . . . . . . . . . . . . .

141

C.3 Metasploit Exploit ms08_067_netapi Modulinformationen . . . . . . . . . . . .

143

C.4 Metasploit Verschleierungs-Optionen des Moduls ms08_067_netapi

. . . . . .

145

Stichwortverzeichnis

147

Abbildungsverzeichnis

2.1

Lebenszyklus von Sicherheitslücken (Vulnerability Lifecycle) . . . . . . . . . . .

2.2

Exploiting Framework - Komponenten . . . . . . . . . . . . . . . . . . . . . . .

2.3

Metasploit Framework - Projektlogo . . . . . . . . . . . . . . . . . . . . . . . .

2.4

Metasploit Framework - Architektur . . . . . . . . . . . . . . . . . . . . . . . .

2.5

Metasploit Framework - Benutzerinterface msfgui nach dem Programmstart . .

2.6

Intrusion Detection System - Taxonomie . . . . . . . . . . . . . . . . . . . . . .

2.7

Snort - Projektlogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.8

Snort - Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.9

Snort - Aufgaben mehrerer Preprozessoren . . . . . . . . . . . . . . . . . . . . .

2.10 Snort - Bestandteile des Snort Regel-Headers . . . . . . . . . . . . . . . . . . .

3.1

Angriffstechnik - Insertion (des Buchstaben X) . . . . . . . . . . . . . . . . . .

3.2

Angriffstechnik - Evasion (des Buchstaben A) . . . . . . . . . . . . . . . . . . .

3.3

Insertion Angriff auf der Sicherungsschicht (Link Layer) . . . . . . . . . . . . .

3.4

Internet Protocol (IP) - Internet Datagram Header . . . . . . . . . . . . . . . .

3.5

Reassembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.6

Überlappung der Daten von Fragmenten . . . . . . . . . . . . . . . . . . . . . .

3.7

Transmission Control Protocol (TCP) - TCP Header Format . . . . . . . . . .

4.1

MSF - Auswahlmöglichkeiten der implementierten Obfuscation Techniken . . .

4.2

Core Impact V9 - Erweiterte Modulparameter . . . . . . . . . . . . . . . . . . .

5.1

Konfiguration der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2

Untangle - Status der installierten Komponenten . . . . . . . . . . . . . . . . .

5.3

Untangle - Übersicht der vorhandenen Signaturen . . . . . . . . . . . . . . . . .

5.4

Untangle - Status der installierten IPS Komponente

. . . . . . . . . . . . . . .

5.5

Cisco IPS Device Manager - Signaturübersicht

. . . . . . . . . . . . . . . . . .

5.6

Cisco IPS Device Manager - Event Viewer . . . . . . . . . . . . . . . . . . . . .

5.7

Virtualbox - Übersicht der Virtuellen Maschienen . . . . . . . . . . . . . . . . .

5.8

Testauswertung - Ausführungserfolg der verschleierten Exploits . . . . . . . . .

100

5.9

Testauswertung der verschleierten Angriffe - Ergebnisse der Tests 1-5 . . . . . .

105

(a)

Test 01 - DCERPC::fake_bind_multi . . . . . . . . . . . . . . . . . . . .

105

(b)

Test 02 - DCERPC::fake_bind_multi_append . . . . . . . . . . . . . . .

105

(c)

Test 03 - DCERPC::fake_bind_multi_prepend . . . . . . . . . . . . . . .

105

(d)

Test 04 - DCERPC::max_frag_size . . . . . . . . . . . . . . . . . . . . .

105

(e)

Test 05 - DCERPC::smb_pipeio . . . . . . . . . . . . . . . . . . . . . . .

105

5.10 Testauswertung der verschleierten Angriffe - Ergebnisse der Tests 6-10 . . . . .

106

(a)

Test 06 - SMB::obscure_trans_pipe_level . . . . . . . . . . . . . . . . . .

106

(b)

Test 07 - SMB::pad_data_level

. . . . . . . . . . . . . . . . . . . . . . .

106

(c)

Test 08 - SMB::pad_file_level

. . . . . . . . . . . . . . . . . . . . . . . .

106

(d)

Test 09 - SMB::pipe_evasion . . . . . . . . . . . . . . . . . . . . . . . . .

106

(e)

Test 10 - SMB::pipe_read_max_size

. . . . . . . . . . . . . . . . . . . .

106

5.11 Testauswertung der verschleierten Angriffe - Ergebnisse der Tests 11-15

. . . .

107

(a)

Test 11 - SMB::pipe_read_min_size . . . . . . . . . . . . . . . . . . . . .

107

(b)

Test 12 - SMB::pipe_write_max_size . . . . . . . . . . . . . . . . . . . .

107

(c)

Test 13 - SMB::pipe_write_min_size . . . . . . . . . . . . . . . . . . . .

107

(d)

Test 14 - TCP::max_send_size . . . . . . . . . . . . . . . . . . . . . . . .

107

(e)

Test 15 - TCP::send_delay . . . . . . . . . . . . . . . . . . . . . . . . . .

107

6.1

Gnort - Architektur

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

109

6.2

Argos - Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

110

6.3

Normalisierer - Position im Netz

. . . . . . . . . . . . . . . . . . . . . . . . . .

111

Tabellenverzeichnis

2.1

Metasploit Exploiting Framework - Versionsvergleich . . . . . . . . . . . . . . .

2.2

Metasploit Exploiting Framework - Übersicht der Benutzerschnittstellen . . . .

2.3

IDS - Erkennungsmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.1

Verhalten mehrerer Betriebssysteme bei Überlappungen in Fragmenten . . . . .

4.1

MSF - Implementierte Insertion- und Evasion Techniken . . . . . . . . . . . . .

4.2

MSF - Implementierte Obfuscation Optionen für das HTTP . . . . . . . . . . .

4.3

MSF - Implementierte Obfuscation Optionen für das SMB Protokoll . . . . . .

4.4

MSF - Implementierte Obfuscation Optionen für das DCERPC Protokoll

. . .

5.1

NIDS - Bewertungsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2

Intrusion Detection Systeme - Marktübersicht . . . . . . . . . . . . . . . . . . .

5.3

Evaluationsgegenstand - Liste der zu evaluierenden NIDS . . . . . . . . . . . .

5.4

MSF - Moduloptionen des ms08_067_netapi Exploit-Moduls . . . . . . . . . .

5.5

Metasploit - Paketabhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . .

5.6

Testauswertung - Ergebnisse der mittels fragroute verschleierten Angriffe . . . .

100

5.7

Testauswertung - Ergebnisse der durch das MSF verschleierten Angriffe . . . .

101

5.8

Testauswertung - Kombination mehrerer Obfuscation-Optionen im MSF . . . .

102

5.9

NIDS - Bewertungsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . .

104

A.1 NIDS - Bewertungsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . .

128

Listingverzeichnis

2.1

Beispielprogramm in der Programmiersprache C [Burns et al. 2007] . . . . . . .

2.2

Ausnutzen des Buffer Overflows im Beispielprogramm [Burns et al. 2007] . . . .

2.3

Deassemblierung - Umwandlung der Opcodes in Assemblercode [Burns et al. 2007] 22

2.4

Linux x86 Shellcode der /bin/bash ausführt in einem C Programm [Burns et al.

2007] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.5

Snort - Test-Regel zur Erkennung von Zugriffen auf FTP-Server . . . . . . . . .

4.1

MSF - Enthaltene NOP Generatoren . . . . . . . . . . . . . . . . . . . . . . . .

4.2

MSF - Enthaltene Payload Encoder . . . . . . . . . . . . . . . . . . . . . . . . .

4.3

MSF - Ausschnitt des IPS-Filter Plugin . . . . . . . . . . . . . . . . . . . . . .

5.1

Fragrouter - Übersicht der Optionen . . . . . . . . . . . . . . . . . . . . . . . .

5.2

Fragroute - Übersicht der Optionen . . . . . . . . . . . . . . . . . . . . . . . . .

5.3

Fragroute - Regeldatei mit IP Fragmentierung (16 Byte Payload Länge) . . . .

5.4

Ping - ICMP Echo Request mit 128 Byte Daten . . . . . . . . . . . . . . . . . .

5.5

Tcpdump - Aufzeichnung des Netzverkehrs: Test 1 . . . . . . . . . . . . . . . .

5.6

RP Filter - Deaktivierung der Quell-Validierung im Kernel . . . . . . . . . . . .

5.7

Fragroute - Eintrag in der Routing-Tabelle . . . . . . . . . . . . . . . . . . . . .

5.8

Fragroute - Ausgabe der durchgeführten Fragmentierung von IP-Paketen . . . .

5.9

Tcpdump - Aufzeichnung des Netzverkehrs: Test 2 . . . . . . . . . . . . . . . .

5.10 Tcpdump - Aufzeichnung des Netzverkehrs: Test 3 . . . . . . . . . . . . . . . .

5.11 Tcpdump - Aufzeichnung des Netzverkehrs: Test 4 . . . . . . . . . . . . . . . .

5.12 Metasploit Command Line Interface - Befehl zur Ausgabe aller Exploits . . . .

5.13 Metasploit Command Line Interface - Ausschnitt der Ausgabe aller Exploits . .

5.14 Metasploit Framework - Übersicht der Modulfunktionen . . . . . . . . . . . . .

5.15 Metasploit Framework Command Line Interface - Aufrufsyntax . . . . . . . . .

5.16 Metasploit Framework - Übersicht der Moduloptionen . . . . . . . . . . . . . .

5.17 Metasploit Command Line Interface - Aufruf ohne Verschleierungs-Optionen . .

5.18 Metasploit Command Line Interface - Ausgabe der zum Exploit-Modul kompati-

blen Payloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.19 Metasploit Command Line Interface - Übersicht der Moduloptionen nach der

Auswahl des Payloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.20 Übergabeparameter für die Protokollierung auf dem Ziel-IT-System . . . . . . .

5.21 Metasploit Command Line Interface - Aufruf mit Verschleierungs-Optionen . .

5.22 Automatisierungskript - Protokolleintrag . . . . . . . . . . . . . . . . . . . . . .

5.23 Automatisierungskript - Funktion zum Aufruf des msfcli . . . . . . . . . . . . .

5.24 Automatisierungskript - Aufruf des msfcli mit Verschleierungs-Optionen . . . .

5.25 Metasploit - Installation der benötigten Softwarepakete

. . . . . . . . . . . . .

5.26 Metasploit - Subversion Checkout . . . . . . . . . . . . . . . . . . . . . . . . . .

5.27 Metasploit - Subversion Checkout . . . . . . . . . . . . . . . . . . . . . . . . . .

5.28 bridge-utils - Konfiguration der Bridge . . . . . . . . . . . . . . . . . . . . .

5.29 Aktivierung des Routings im Linux-Kernel . . . . . . . . . . . . . . . . . . . . .

5.30 Konfiguration der Netzwerkschnittstellen . . . . . . . . . . . . . . . . . . . . . .

5.31 Snort - Installation der benötigten Softwarepakete

. . . . . . . . . . . . . . . .

5.32 Snort - Befehle zur Kompilierung des Quellcodes . . . . . . . . . . . . . . . . .

5.33 Snort - Einrichtung der Benutzer und Verzeichnisse . . . . . . . . . . . . . . . .

5.34 Snort - Ausschnitt der Umgebungsvariablen . . . . . . . . . . . . . . . . . . . .

5.35 Snort - Aufruf mit Konfigurationsparametern . . . . . . . . . . . . . . . . . . .

5.36 Untangle - Regel: Potentially Bad Traffic (Index of /cgi-bin/ response) . . . . .

5.37 Untangle - Test-Signatur: Erkennung von TCP Netzverkehr . . . . . . . . . . .

5.38 Bro IDS - Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.39 Bro IDS - Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.40 Cisco 2620 Router (IP Plus) - IP Audit Optionen . . . . . . . . . . . . . . . . .

5.41 Cisco 2620 Router (IP Plus) - Einrichtung . . . . . . . . . . . . . . . . . . . . .

5.42 Cisco 2620 Router (IP Plus) - Ausschnitt der Konsolenausgabe mit Alarmmeldungen 93

5.43 Cisco 4215 Sensor - Fehlermeldung . . . . . . . . . . . . . . . . . . . . . . . . .

5.44 Cisco 4215 Sensor - Status der Kernkomponenten . . . . . . . . . . . . . . . . .

5.45 Cisco 4215 Sensor - Grundkonfiguration . . . . . . . . . . . . . . . . . . . . . .

5.46 VM Metasploit - Ausgabe des Automatisierungsskriptes während der Tests

. .

5.47 Snort - Logeintrag eines erkannten Angriffs . . . . . . . . . . . . . . . . . . . .

5.48 Tcpdump - Ausgabe der Statistik des aufgezeichneten Netzverkehrs . . . . . . .

5.49 Windows XP SP3 - Protokolleintrag auf dem Zielsystem . . . . . . . . . . . . .

5.50 Auswertung der Protokolldateien . . . . . . . . . . . . . . . . . . . . . . . . . .

B.1 Snort Version 2.7.0 Konfigurationsdatei snort.conf

. . . . . . . . . . . . . . . .

129

B.2 Cisco 4215 IDS Sensor - Konfiguration . . . . . . . . . . . . . . . . . . . . . . .

132

C.1 Metasploit Framework Obfuscation Test Script (msfauto.sh) . . . . . . . . . . .

133

C.2 Metasploit IDS Filter Plugin (ids_filter.rb) [Metasploit LLC 2009] . . . . . . .

141

C.3 Metasploit Exploit ms08_067_netapi Modulinformationen [Metasploit LLC 2009]143

C.4 Metasploit Verschleierungs-Optionen des Moduls ms08_067_netapi [Metasploit

LLC 2009] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

145

Abkürzungsverzeichnis

ASCII

American Standard Code for Information Interchange

ACID

Analysis Console for Intrusion Databases

ARP

Address Resolution Protocol

ACK

Acknowledgment

AUX

Auxiliary

APT

Advanced Paket Manager

Bit

Binary Digit

BSD

Berkeley Software Distribution

BSI

Bundesamt für Sicherheit in der Informationstechnik

BID

Bugtraq Identifier

CGI

Common Gateway Interface

CIDR

Classless Inter-Domain Routing

CVE

Common Vulnerabilities and Exposures

CERT

Computer Emergency Response Team

Datenbank

DMZ

Demilitarized Zone

DNS

Domain Name System

DoS

Denial of Service

DDoS

Distributed Denial of Service

DLL

Dynamic Link Library

DCE

Distributed Computing Environment

EXE

Executable

Front End

FIN

Finish

False positive

Front negative

GPL

GNU General Public License

GUI

Graphical User Interface

GNU

GNU's Not Unix

GTK

GNU Image Manipulation Program Toolkit

HIDS

Host-based Intrusion Detection System

HTML

Hyper Text Markup Language

ICMP

Internet Control Message Protocol

Identifikation

IDS

Intrusion Detection System

Internet Protocol

IPS

Intrusion Protection System

ISO

International Organization for Standardization

Informationsverarbeitung

Informationstechnik

Internet

Interconnected Networks

Kilobyte

LAN

Local Area Network

MAC

Media Access Control

Megabyte

MBit

Megabit

MITM

Man in the middle

MSF

Metasploit Exploiting Framework

Meterpreter Meta-Interpreter

NIC

Network Interface Card

NIDS

Network-based Intrusion Detection System

Operating System

OSI

Open Systems Interconnection

OSVDB

Open Source Vulnerability Database

PID

Process Identifier

POC

Proof of Concept

PSH

Push

PHP

PHP Hypertext Preprocessor

RST

Reset

REX

Ruby Exploit Library

RFC

Request for Comments

RPC

Remote Procedure Call

SSH

Secure Shell

SQL

Structured Query Language

SYN

Synchronize

SMB

Server Message Block

Service Pack

SVN

Subversion

TCP

Transmission Control Protocol

True positive

True negative

TTL

Time to Live

UDP

User Datagram Protocol

URL

Uniform Resource Locator

URG

Urgent

URI

Uniform Resource Identifier

Virtuelle Maschine

WAN

Wide Area Network

Kapitel 1

Einleitung

1.1 Ausgangssituation

Ein erhöhter Schutzbedarf von IT-Systemen kann durch Sicherheitsmaßnahmen wie Firewalls,

Intrusion Detection Systeme bzw. Intrusion Prevention Systeme (IDS/IPS) gewährleistet werden,

die bestimmten Datenverkehr blockieren oder Angriffe erkennen und verhindern sollen. Ein

Beispiel für einen Angriff ist das Ausnutzen einer Sicherheitslücke durch einen Exploit in einem

Dienst mit dem Ziel eigenen Code auszuführen und die Kontrolle über das IT-System zu

erlangen.

Exploiting Frameworks stellen für solche Angriffe eine Art Baukasten dar, mit dem ein Angreifer

den Exploit anpassen und automatisiert gegen ein Zielsystem ausführen kann. Viele Angriffe

werden jedoch durch Schutzmaßnahmen wie IDS erkannt bzw. im Falle von Intrusion Prevention

Systemen (IPS) abgewehrt. Um eine Erkennung derartiger Angriffe zu verhindern, existieren

mehrere kombinierbare Techniken, die jeweils auf verschiedenen Schichten des ISO OSI Modells

angewendet werden, um die Mechanismen von IDS/IPS zur Erkennung von Angriffen zu

umgehen.

Auf der Netzwerkschicht (OSI-Schicht 3) werden beim Insertion- bzw. beim Evasion-Angriff

zusätzliche Pakete in den Datenstrom zwischen Angreifer und Zielsystem eingefügt, die vom IDS

und dem IT-System des Opfers unterschiedlich interpretiert bzw. verworfen werden. Durch den

unterschiedlichen Datenstrom kann so z.B. das Pattern-Matching bei Signatur-basierten IDS

außer Kraft gesetzt werden. Die Fragmentierung von IP Paketen (Fragmentation), sowie eine

Aufteilung der Angriffsdaten auf der Transportschicht (OSI-Schicht 4) in kleine TCP-Segmente

stellen weitere Möglichkeit für Insertion- oder Evasion-Angriffe dar, da IT-Systeme je nach

verwendetem TCP/IP Stack Reassembly-Strategien mit unterschiedlichem Verhalten aufweisen

können. [Ptacek und Newsham 1998]

Techniken zur Verschleierung von Angriffen existieren auch auf Anwendungsebene (OSI-Schicht

5-7), indem die Daten im Protokoll der Anwendung bei gleichbleibender Semantik umgeformt

werden. Um derartige Angriffe zu erkennen, muss das IDS über eine entsprechende Logik für

das Anwendungsprotokoll verfügen. [Roelker 2003]

1.2 Forschungsstand

Unabhängig von den Insertion- oder Evasion Techniken der tieferen OSI-Schichten kann auch

der Angriffscode (Exploit-Code) bei gleichbleibender Semantik so umgeformt bzw. verschleiert

(Obfuscation) werden, dass dieser nicht oder schlechter durch IDS/IPS erkannt wird. Eine

simple Form ist die Umcodierung des Schadcodes z.B. in das BASE-64, TAR oder ZIP Format.

Eine erweiterte Form ist die Umwandlung des Angriffscode in einen sich selbst entschlüsselnden

polymorphen Shellcode. [Fogla et al. 2006]

Um eine Erkennung von Angriffen zu erschweren, kann ein IDS auch durch eine hohe Anzahl von

vermeintlichen Angriffen so überlastet werden, dass alle Ressourcen belegt sind und tatsächliche

Angriffe nicht mehr erkannt werden können (Denial-of-Service Angriff). [Ptacek und Newsham

1998]

In einigen Exploiting Frameworks, wie z.B. dem Metasploit Framework (MSF), SAINT Exploit

oder Core Impact, sind bereits einige der dargestellten Optionen zur Verschleierung von Angriffen

implementiert [Moore 2006]. Dies stellt ein Risiko für Unternehmen dar, da erfolgreiche Angriffe

auf IT-Systeme in diesem Fall nicht mehr durch IDS erkannt werden können.

1.2 Forschungsstand

Insertion und Evasion wurde, u.a. im Zusammenhang mit IDS, in vielen Veröffentlichungen

analysiert. Bereits 1998 wurden die verschiedenen Techniken dargestellt [Ptacek und Newsham

1998].

Die Literatur beschränkt sich auf die Techniken der Insertion und Evasion im Zusammenhang mit

der Erkennung von Angriffen durch IDS und betrachtet nicht die Integration dieser Techniken

in Exploiting Frameworks sowie den sich hieraus ergebenden Risiken und Möglichkeiten.

1.3 Zielsetzung der Arbeit

Es werden Techniken und Konzepte analysisert und bewertet, mit denen Angriffe so gestaltet

werden, dass sie nicht von IDS/IPS erkannt werden können (Insertion, Evasion und Obfuscation).

Durch die Integration dieser Techniken in Exploiting Frameworks wird zudem der Beitrag von

Exploiting Frameworks unter dem Gesichtspunkt der Techniken zur Verschleierung von Angriffen

untersucht. Mehrere ausgewählte NIDS werden unter dem Gesichtspunkt der Techniken zur

Verschleierung von Angriffen bewertet.

Hierzu werden die Grundlagen von Exploiting Frameworks, IDS/IPS und von Techniken zur

Verschleierung von Angriffen dargestellt und eine Testumgebung sowie Testszenarien erstellt,

in denen am Beispiel des Metasploit Exploiting Frameworks und mehreren Network Intrusion

1.4 Aufbau der Arbeit

Detection Systemen (NIDS) die Untersuchungen durchgeführt werden. Als NIDS wird u.a. Snort

eingesetzt.

Abschließend wird eine Beurteilung der Möglichkeiten und den resultierenden Folgen gegeben,

die aus dem Einsatz von Techniken zur Verschleierung von Angriffen in Exploiting Frameworks

resultieren.

1.4 Aufbau der Arbeit

Kapitel 2

definiert grundlegende Beriffe und stellt die Grundlagen von Exploiting Frame-

works und Intrusion Detection Systemen dar. Die Architektur und die Funktions-

weise von Exploiting Frameworks werden am Beispiel des Metasploit Exploiting

Frameworks eingeführt. Es werden die unterschiedlichen Arten und die Funkti-

onsweise von Intruison Detection Systemen erläutert.

Kapitel 3

gibt eine Einführung in mehrere Konzepte (Insertion, Evasion, Obfuscation) mit

denen Angriffe so gestaltet werden können, dass diese von Network Intrusion De-

tection Systemen (NIDS) nicht erkannt werden können. Die konkreten Techniken

werden auf den verschiedenen Schichten des ISO OSI Modells analysiert.

Kapitel 4

untersucht eine Auswahl von Exploiting Frameworks (Metasploit Framework,

Core Impact und SAINT exploit) unter dem Gesichtspunkt der Techniken zur

Verschleierung von Angriffen.

Kapitel 5

anaylisert und bewertet mehrere ausgewählte Network Intrusion Detection

Systeme (NIDS) unter dem Gesichtspunkt der Evasion Techniken in einer

Testumgebung. Hierzu wird eine Testumgebung sowie mehrere Testszenarien

erstellt, in denen die NIDS bezüglich ihrer Fähigkeiten zur Erkennung von

(verschleierten und unverschleierten) Angriffen, sowie der Normalisierung von

Netzverkehr untersucht werden.

Kapitel 6

stellt Konzepte vor, die eine Erkennung von verschleierten Angriffen verbessern

und zudem die Anzahl von Falschmeldungen reduzieren.

Kapitel 7

resümiert die Ergebnisse der Arbeit und zieht ein Fazit.

1.5 Notation

Sourcecode, Dateinamen und Dateipfade werden durch proportionalen Schrifttyp vom

restlichen Text abgegrenzt.

Kapitel 2

Grundlagen von Exploiting Frameworks und Intrusion Detection

Systemen

In diesem Kapitel werden grundlegende Begriffe für die weiteren Themen der Arbeit definiert

und die Grundlagen von Exploiting Frameworks und Intrusion Detection Systemen dargestellt.

2.1 Grundlegende Begriffe

2.1.1 Sicherheitslücke (Vulnerability)

Da Software nicht ohne Fehler hergestellt werden kann, enthält ein IT-System durch sicherheits-

relevante Programmierfehler Sicherheitslücken (Vulnerabilities) in der eingesetzten Software (z.B.

Betriebssystem, Anwendungs- oder Sicherheitssoftware). Je nach Art der Programmierfehler

kann die zugehörige Sicherheitslücke durch ein entsprechendes Angriffsprogramm (Exploit, vgl.

Kapitel 2.1.2) ausgenutzt werden. [Pohl 2008]

Um bislang unveröffentlichte Sicherheitslücken zu ermitteln, können diese systematisch mittels

automatisierter Werkzeuge (z.B. durch Fuzzing oder Quellcode-Analyse) gesucht oder durch Zu-

fall während der Verwendung der Software entdeckt werden. Gefundene Sicherheitslücken können

dem Hersteller der Software mitgeteilt werden, damit dieser eine entsprechende Fehlerkorrektur

(Patch) entwickeln kann. Eine weitere Möglichkeit ist die Veröffentlichung der gefundenen Si-

cherheitslücke auf Mailinglisten im Internet mit einem sicherheitsrelevaten Themenschwerpunkt,

wie z.B. Bugtraq [SecurityFocus Symantec Corporation 2009a] oder Full Disclosure [Secunia

2009]. Im Internet existieren zudem entsprechende Plattformen [WabiSabiLabi 2009], auf denen

bisher unveröffentlichte Sicherheitslücken meistbietend verkauft werden können. Es existiert ein

Markt für unveröffentlichte Sicherheitslücken. [Pohl 2008]

Eine Software durchläuft im Bezug auf ihre Sicherheitslücken während ihres Lebenszyklus (siehe

Abb. 2.1 auf S. 20) folgende drei Abschnitte:

· Abschnitt 1: Scheinbar keine Sicherheitslücken vorhanden

· Abschnitt 2: Sicherheitslücke wird erkannt und gegebenenfalls ausgenutzt

2.1 Grundlegende Begriffe

· Abschnitt 3: Sicherheitslücke wird veröffentlicht und der jeweilige Hersteller entwickelt

eine Fehlerkorrektur (Patch)

Da die Hersteller von Software lediglich endliche Ressourcen zur Verfügung haben, wird nicht für

100 % der entdeckten Sicherheitslücken eine Fehlerkorrektur (Patch) erstellt. Die Entwicklung

von Fehlerkorrekturen wird nach der Bedeutung der zugehörigen Sicherheitslücke priorisiert.

Ein bestimmter Anteil an Sicherheitslücken wird somit nicht korrigiert. [Pohl 2008]

Zur einheitlichen Benennung von Sicherheitslücken existieren mehrere Datenbanken, die jeder

Sicherheitslücke eine eindeutige Bezeichnung zuweisen und relevante Informationen speichern.

Das Ziel ist die Einführung einer einheitlichen Namenskonvention für Sicherheitslücken, um

eine Mehrfachbenennung gleicher Sicherheitslücken zu vermeiden und somit eine eindeutige

Identifizierung zu gewährleisten. Beispiele für solche Datenbanken sind:

· Mitre Common Vulnerabilities and Exposures (CVE) [MITRE 2009]

· Open Source Vulnerability Database (OSVDB) [Open Security Foundation (OSF) 2009]

· SecurityFocus Vulnerabilities (Bugtraq ID, BID)

[SecurityFocus Symantec Corporation 2009b]

· United States Computer Readiness Team (US-CERT)

Vulnerability Notes Database (VULS) [US-CERT 2009]

· Microsoft TechNet Security Bulletin (MS) [Microsoft 2009]

· VUPEN Security Advisories (VUPEN/ADV) [VUPEN Security 2009]

· Secuina Advisories (SA) [Secuina 2009]

· SecurityTracker Vulnerabilities (Security Tracker ID) [SecurityTracker 2009]

IT-Systeme können automatisiert durch Vulnerability Scanner, wie z.B. Nessus [Tenable Network

Security 2009], auf veröffentlichte Sicherheitslücken überprüft werden. Das Ergebnis einer

Überprüfung mehrerer IT-Systeme ist ein automatisch generierter Bericht (Report), der für

jedes IT-System die erkannten Sicherheitslücken, Hinweise zu deren Beseitigung und Referenzen

zu Datenbanken mit weiterführenden Informationen enthält.

2.1.2 Exploit

Ein Exploit ist eine Folge von Befehlen (Instruktionsmenge), die eine oder mehrere spezifische

Sicherheitslücken (Vulnerabilities) in einer Software ausnutzt, die durch sicherheitsrelevante

Programmierfehler verursacht werden. Das Ziel der Ausführung eines Exploits gegen ein IT-

System ist dessen Kompromittierung, z.B. für den technischen Nachweis der Ausnutzbarkeit

einer Sicherheitslücke (Proof of Concept Exploit), oder die Beinträchtigung der durch das

2.1 Grundlegende Begriffe

IT-System bereitgestellten Dienste (Denial-of-Service Angriff, siehe Kapitel 3.1.3 auf S. 41).

[Pohl 2008].

Definition:

Ein Exploit ist eine Sicherheitslücke-ausnutzende Instruktionsmenge zur Kompro-

mittierung eines IT-Systems und anschließender Ausführung einer weiteren Instruk-

tionsmenge.

Eine Sicherheitslücke kann von mehreren Exploits ausgenutzt werden, wobei ein Exploit jedoch

nicht für unterschiedliche Prozessorarchitekturen verwendet werden kann. Ein Exploit ist

spezifisch für die Prozessorarchitektur eines IT-Systems und für die anzugreifende Software

[Pohl 2008]. Eine unterschiedliche (Sprach-)Version einer Software kann somit ein Grund dafür

sein, dass ein Exploit nicht mehr funktioniert. Exploits sind in Exploiting Frameworks (siehe

Kap. 2.2 auf S. 25) enthalten, die Werkzeuge zur Entwicklung und automatisierten Ausführung

von Exploits darstellen.

Der Programmcode eines Exploits zum Ausnutzen einer Sicherheitslücke wird auch als Angriffs-

oder Schadcode bezeichnet und ist spezifisch für eine bestimmte Sicherheitslücke bzw. deren

zugrunde liegenden sicherheitsrelevanten Programmierfehler. Beispiele für sicherheitsrelevante

Programmierfehler (siehe Kapitel 2.1.3 auf S. 20) sind z.B. Integer Underflows oder Buffer

Overflows. Das Ziel des Angriffscodes ist eine Manipulation des Speicherinhalts der Laufzeitum-

gebung der angegriffenen Software, um hierdurch deren weiteren Ablauf zu manipulieren und

eigenen Code auszuführen.

Nachdem eine Sicherheitslücke durch den Exploit (bzw. dessen Angriffscode) ausgenutzt worden

ist, wird eine weitere Instruktionsmenge auf dem angegriffenen Ziel-IT-System ausgeführt. Diese

wird als Shellcode bezeichnet und stellt die Nutzlast (Payload) des Exploits dar (siehe Kapitel

2.3 auf S. 22). Das Ziel des Shellcodes ist, für den Angreifer einen Fernzugriff (Remote Access)

zu ermöglichen, der den einfachen Zugang zum kompromittierten Ziel-IT-System erlaubt.

Eine Sicherheitslücke durchläuft während ihres Lebenszyklus verschiedene Phasen (Vulnerability

Lifecycle), die in Abbildung 2.1 auf S. 20 dargestellt sind. Hierdurch ergeben sich differenziertere

Bezeichnungen eines Exploits, die von dem zeitlichen Kontext der zugehörigen Sicherheitslücke

im Lebenzyklus abhängig sind.

· Less-Than-Zero-Day Exploit:

Ein Exploit, der eine noch nicht veröffentlichte Sicherheitslücke ausnutzt, wird als Less-

Than-Zero-Day Exploit bezeichnet. Die Sicherheitslücke kann aktiv durch den Exploit

ausgenutzt werden, da noch kein Patch von Seiten des Herstellers existiert bzw. veröffent-

licht wurde. [Pohl 2007]

· Zero-Day Exploit:

Ein Exploit, der eine bereits veröffentlichte Sicherheitlücke ausnutzt, wird als Zero-Day

2.1 Grundlegende Begriffe

Abbildung 2.1: Lebenszyklus von Sicherheitslücken (Vulnerability Lifecycle) [Nach: Pohl 2007]

Exploit bezeichnet. Die Veröffentlichung eines Zero-Day-Exploits kann die Ausnutzbarkeit

einer Sicherheitslücke belegen (vgl. Proof of Concept). Der Exploit kann so lange verwendet

werden, bis der von dem Hersteller der Software entwickelte Patch auf dem anzugreifenden

IT-System eingespielt wurde. [Pohl 2007]

2.1.3 Pufferüberlauf (Buffer Overflow)

Pufferüberläufe (Buffer Overflows) gehören zu den am häufigsten vorhandenen Sicherheitslücken

in Software. Exploits nutzen hierbei die fehlende Unterscheidung von Programmcode und

Daten in der Von-Neumann-Architektur aus. Da der gemeinsame Speicher sowohl ausführbaren

Programmcode und nicht ausführbare Daten beinhaltet, kann ein Exploit versuchen, einen

Pufferüberlauf zu erzeugen. Durch einen sicherheitsrelevanten Fehler im Programm ist es möglich,

in einen reservierten Speicherbereich (Puffer) zu große Mengen an Daten zu schreiben, so dass der

hierfür zu kleine Speicherbereich ,,überläuft". Dieses Vorgehen kann zum Absturz des Prozesses,

zur Manipulation von Daten der Anwendung oder zur Manipulation von Datenstrukturen

der Laufzeitumgebung des Prozesses führen. Hierdurch kann die Rücksprungadresse eines

Unterprogramms mit beliebigen Daten überschrieben werden, wodurch ein Angreifer (durch

Übermittlung von Maschinencode) beliebige Befehle mit den Privilegien des Prozesses ausführen

kann. [Klein 2004]

Das in Listing 2.1 dargestellte Beispielprogramm in der Programmiersprache C enthält einen

sicherheitsrelevanten Programmierfehler, wodurch das Programm anfällig für einen Buffer

Overflow ist. Das Progamm kopiert eine Zeichenkette, die es als Aufrufparameter erhalten hat,

in eine Variable und gibt anschliessend den Inhalt dieser Variablen aus. Für die Variable "buffer"

wird in Zeile 11 ein fester Speicherplatz von 9 Byte belegt, wodurch diese eine Zeichenkette mit

2.1 Grundlegende Begriffe

8 Zeichen aufnehmen kann. Das letzte (9.) Byte wird für das "\0"-Zeichen (Nullbyte) verwendet

und markiert das Ende einer Zeichenkette. Beim Aufruf des Programms mit einer 9 Byte langen

Zeichenkette (./buffer 12345678) funktioniert das Programm ohne Probleme und gibt die

übergebene Zeichenkette aus.

Listing 2.1: Beispielprogramm in der Programmiersprache C [Burns et al. 2007]

* file: buffer.c

* description: Dieses Programm ist verwundbar durch einen Buffer Overflow

#include

<stdio.h>

#include

<string.h>

main(

int

argc,

char

*argv[]){

// Deklaration des Puffers

char

buffer[8];

// Ueberpruefung der Parameteranzahl

(argc != 2){

printf(

"Fehler: Nicht mehr als einen Parameter angegeben.\n"

);

exit(1);

}

// Kopieren des uebergebenen Strings in den Puffer

strcpy(buffer, argv[1]);

// Ausgabe der Puffer-Inhalts

printf(

"Inhalt des Puffers: %s\n"

, buffer);

}

Wird das Programm jedoch mit einer Zeichenkette aufgerufen, die länger als 9 Byte ist, kopiert

die Funktion strcpy (String Copy) die zu lange Zeichenkette in den reservierten 9 Byte großen

Speicherbereich (siehe Listing 2.1, Zeile 20), wodurch dieser "überläuft". Dies wird als Overflow

bezeichnet und ermöglicht einem Angreifer den folgenden Speicherbereich mit beliebigem Inhalt

zu überschreiben. Wie in Listing 2.2 dargestellt, kann dieser Buffer Overflow zum Ausführen

von eigenem Code ausgenutzt werden, indem das Programm mit Shellcode in Maschinensprache

als Parameter aufgerufen wird.

Listing 2.2: Ausnutzen des Buffer Overflows im Beispielprogramm [Burns et al. 2007]

# Variablen mit Maschinencode

SHELLCODE="\x31\xc0\x68\x2f\x73\x68\xaa\x88\x44\x24\x03\x68\x2f\x62\x69\x6e\x89\xe3\x50\

x53\x89\xe1\xb0\x0b\x33\xd2\xcd\x80\xcc"

NOP="\x90\x90\x90\x90"

# Aufruf des Beispielprogramms mit dem Shellcode

./buffer 12345678'echo -ne $NOP$NOP$NOP$NOP$SHELLCODE'

Der im Listing 2.2 verwendete Shellcode wird im folgenden Kapitel ausführlich betrachtet.

2.1 Grundlegende Begriffe

2.1.4 Shellcode

Wie bereits in Kapitel 2.1.2 erläutert, wird nachdem eine Sicherheitslücke durch einen Exploit

(bzw. dessen Angriffscode) ausgenutzt worden ist, eine weitere Instruktionsmenge auf dem

angegriffenen Ziel-IT-System ausgeführt, die die Nutzlast (Payload) des Exploits darstellt. Die

Aufgabe des Shellcodes ist, dem Angreifer einen Fernzugriff zum kompromittierten System

zu ermöglichen. Da der Zugriff für den Angreifer oft in Form eines Kommandozeileninterpre-

ters (Shell) realisiert ist, wird der hierfür verantwortliche Programmcode auch als Shellcode

bezeichnet.

Da der Shellcode auf dem Zielsystem in den Speicher injiziert wird, handelt es sich beim Shellcode

um eine Sequenz von Assemblerbefehlen, die in Opcodes (Operation Codes) umgewandelt

wurden und hexadezimal dargestellt werden (siehe Listing 2.3). Ein Opcode ist die Nummer

eines Maschinenbefehls für einen bestimmten Prozessortyp. Die Menge aller Opcodes stellt den

jeweiligen Befehlssatz eines Prozessors oder einer Familie von Prozessoren dar. Ein Shellcode

wird daher spezifisch für eine bestimmte Rechnerarchitektur erstellt. Jedem Opcode ist ein

Wort mit wenigen Zeichen - das Mnemonic - zugeordnet, welches in der Assemblersprache

verwendet wird. In einem Assemblerprogramm steht pro Zeile ein Mnemonic, gefolgt von den

jeweils benötigten Parametern des Befehls, wie z.B. Register oder Konstanten.

Listing 2.3: Deassemblierung - Umwandlung der Opcodes in Assemblercode [Burns et al. 2007]

# U m w a n d l u n g des S h e l l c o d e s in F o r m von O p c o d e s in A s s e m b l e r c o d e

# O p c o d e s ( M a s c h i n e n b e f e h l e )

e c h o - ne "\ x31 \ xc0 \ x68 \ x2f \ x73 \ x68 \ xaa \ x88 \ x44 \ x24 \ x03 \ x68 \ x2f \ x62 \ x69 \ x6e

\ x89 \ xe3 \ x50 \ x53 \ x89 \ xe1 \ xb0 \ x0b \ x33 \ xd2 \ xcd \ x80 \ xcc " | n d i s a s m - u -

# A s s e m b l e r

0 0 0 0 0 0 0 0

31 C0

xor eax , eax

0 0 0 0 0 0 0 2

682 F 7 3 6 8 A A

p u s h d w o r d 0 x a a 6 8 7 3 2 f

0 0 0 0 0 0 0 7

8 8 4 4 2 4 0 3

mov [ esp +0 x3 ] , al

0 0 0 0 0 0 0 B

682 F 6 2 6 9 6 E

p u s h d w o r d 0 x 6 e 6 9 6 2 2 f

0 0 0 0 0 0 1 0

89 E3

mov ebx , esp

0 0 0 0 0 0 1 2

p u s h eax

0 0 0 0 0 0 1 3

p u s h ebx

0 0 0 0 0 0 1 4

89 E1

mov ecx , esp

0 0 0 0 0 0 1 6

B 0 0 B

mov al ,0 xb

0 0 0 0 0 0 1 8

33 D2

xor edx , edx

0 0 0 0 0 0 1 A

C D 8 0

int 0 x80

0 0 0 0 0 0 1 C

i n t 3

Der in Listing 2.3 dargestellte Shellcode führt auf einem Linux System den Kommandozeilenin-

terpreter /bin/bash aus. Da der Shellcode alleine nicht lauffähig ist, kann dieser wie in Listing

2.4 dargestellt z.B. in ein C Programm geladen werden, um ausgeführt werden zu können.

2.1 Grundlegende Begriffe

Listing 2.4: Linux x86 Shellcode der /bin/bash ausführt in einem C Programm [Burns et al. 2007]

* file: shellcode.c

* description: Ausfuehrung von Shellcode in einem C Programm

#include

<stdio.h>

#include

<string.h>

main(){

// Shellcode als Opcode String

unsigned char

shellcode[]=

"\x31\xc0\x68\x2f\x73\x68\xaa\x88\x44\x24\x03\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53"

"\x89\xe1\xb0\x0b\x33\xd2\xcd\x80\xcc"

;

// Ausfuehren des Shellcodes

((

void

(*)())shellcode)();

}

2.1.5 Spoofing

Der Begriff Spoofing beschreibt mehrere Methoden zur Manipulation der eigenen Identität

in Computernetzwerken. Das Ziel ist die Verschleierung der eigenen Identität z.B. durch das

Vortäuschen einer anderen Identität, um Schutzmechanismen wie Firewalls zu überwinden.

Durch Spoofing können Identifikationsverfahren ausgenutzt werden, welche auf der Verwendung

vertrauenswürdiger Adressen oder Hostnamen beruhen [Bechtold und Heinlein 2004]. Personen,

die diese Methoden anwenden, werden als Spoofer bezeichnet. Es werden u.a. folgende Spoofing-

Arten unterschieden:

· IP-Spoofing:

Das Internet Protocol-Spoofing (auch als Internet Protocol Address-Spoofing bezeichnet)

beschreibt die Manipulation einzelner oder mehrerer Werte der Felder im Internet-Protocol

Header (IP-Header) [RFC791 1981]. IP-Pakete können so manipuliert werden, dass sie die

Quelladresse eines anderen (vertrauenswürdigen) Hosts enthalten, was u.a. bei Denial of

Service (DoS) Angriffen (Vgl. Kap. 3.1.3) angewendet wird, um den Ursprung der Angriffe

nicht ermitteln zu können. [Bechtold und Heinlein 2004]

· DNS-Spoofing:

Das DNS-Spoofing beschreibt verschiedene Methoden, die das Ziel haben, die Zuordnung

zwischen Hostnamen und IP-Adressen im Domain-Name-System (DNS) zu manipulieren.

Dies kann z.B. durch das Zusenden von falschen DNS-Informationen an einen Nameserver

erfolgen, welcher die DNS-Daten in seinem Cache zwischenspeichert (DNS-Poisoning).

Ein Angreifer kann hierdurch einen Client, der diesen Nameserver zur Namensauflösung

verwendet, auf eine durch Ihn bestimmte IP-Adresse verweisen. [Bechtold und Heinlein

2004]

2.1 Grundlegende Begriffe

· ARP-Spoofing:

Das Address Resolution Protocol (ARP) ist ein Netzprotokoll, das zu einer IP-Adresse

(Adresse der Vermittlungsschicht) die zugehörige physikalische Media-Access-Control-

Adresse (MAC-Adresse) ermittelt. Die Zuordnung zwischen IP- und MAC-Adresse wird

jeweils in einer ARP-Tabelle auf den beteiligten IT-Systemen gespeichert, die auch

als ARP-Cache bezeichnet wird. Beim ARP-Spoofing werden gefälschte ARP-Pakete

verschickt, die verwendet werden, um die ARP-Tabellen in einem lokalen Netzsegment zu

manipulieren. Hierbei wird, ähnlich dem DNS-Poisoning, ausgenutzt, dass IT-Systeme

auch ARP-Antworten in ihren ARP-Cache übernehmen, die sie selber nicht angefragt

haben. Das Ziel des APR-Spoofings ist die "Umleitung" von Frames eines IT-Systems an

eine selbst festgelegte MAC-Adresse. Hierdurch kann ein Man-in-the-Middle- oder ein

Denial-of-Service-Angriff realisiert werden. [Bechtold und Heinlein 2004]

2.1.6 Denial of Service

Das Ziel eines Denial-of-Service (DoS) Angriffs ist die Beeinträchtigung der Verfügbarkeit einer

oder mehrerer Dienste eines IT-Systems, was durch dessen Überlastung erreicht wird. Das Ziel ist

hierbei nicht immer die komplette Deaktivierung von Diensten, sondern meistens lediglich eine

vorrübergehende Beeinträchtigung der Verfügbarkeit. Ein Angreifer kann hierdurch die Anfragen,

die an das angegriffene IT-System gerichtet sind, selber beantworten, da dieses aufgrund des

DoS Angriffes temporär nicht mehr auf Anfragen antworten kann. Als DoS Angriffstechnik wird

z.B. SYN-Flooding eingesetzt, indem an das anzugreifende Ziel-IT-System ausschließlich TCP-

Segmente mit gesetztem SYN-Flag (Synchronize) geschickt werden. Auf die Verbindungsanfrage

antwortet das Ziel-IT-System mit Segmenten, die das SYN- und das ACK-Flag (Acknowledge)

gesetzt haben. Um die Verbindung nicht vollständig einzurichten, antwortet der Angreifer nicht

mit einem Segment mit gesetztem ACK-Flag. Da der Angreifer die Verbindungseinrichtung

des Transmission Control Protocols (TCP) [RFC793 1981] in Form des Three-Way-Handshakes

nicht komplett durchläuft, werden auf dem Ziel-IT-System halb offene Verbindungen erzeugt.

Hierdurch bleibt für jedes Segment mit gesetzten SYN-Flag, bis zum Ablauf eines Timers,

Speicher im Netzwerkstack auf dem Zielsystem belegt. Das Ziel des Angreifers ist das Belegen

der begrenzten Ressourcen, damit keine neuen Verbindungen mehr zum Zielsystem aufgebaut

werden können. [Bechtold und Heinlein 2004]

Findet ein DoS Angriff koordiniert durch eine große Anzahl von IT-Systemen statt, stellt dies

einen Distributed Denial of Service (DDoS) Angriff dar. Die hierfür verwendeten IT-Systeme

gehören oft zu Botnetzen, die aus einer Vielzahl von kompromittierten IT-Systemen bestehen.

Zur Kontrolle dieser Systeme ist auf diesen ein Softwareprogramm (Bot) installiert, das Befehle

entgegennimmt. [Bechtold und Heinlein 2004]

2.2 Funktionsweise von Exploiting Frameworks

2.2 Funktionsweise von Exploiting Frameworks

Nachdem in den vorherigen Kapiteln grundlegende Begriffe geklärt worden sind, wird in diesem

Kapitel die Funktionsweise und der Aufbau von Exploiting Frameworks erläutert.

2.2.1 Aufgaben

Die ursprüngliche Aufgabe von Exploiting Frameworks, die auch als Exploit- oder Exploi-

tation Frameworks bezeichnet werden, war die Vereinfachung der Entwicklung von Exploits.

Die Entwicklung eines funktionierenden Exploits erfolgt über viele einzelne Schritte, für die

weitreichende Kenntnisse der Sprache Assembler, mehrerer Netzprotokolle und der Architektur

von Betriebssystemen benötigt werden. Exploiting Frameworks vereinfachen diese Schritte zur

Entwicklung eines Exploits, indem die gesamten benötigten Werkzeuge zur Entwicklung und

Ausführung von Exploits (Exploit Developement) bereitgestellt werden. [Burns et al. 2007]

Anhand der Schritte zur Entwicklung eines Exploits werden im Folgenden die Aufgaben von

Exploiting Frameworks dargestellt:

· Erstellung eines Exploits:

Da ca. 80 % eines Exploit Codes wiederverwendbar sind, enthalten Exploiting Frameworks

eine Bibliothek mit Funktionen, die in vielen Exploits verwendet werden. Bestandteile,

die in mehreren Exploits verwendet werden, müssen somit nicht immer wieder erneut

programmiert werden. [Moore 2004]

· Erstellung eines Shellcodes:

Die Erstellung eines Shellcodes, der die gewünschte Aufgabe zuverlässig ausführt und

wenig Speicher belegt, ist zeitintensiv. Da Shellcodes für bestimmte Rechnerarchitekturen

und Betriebssysteme programmiert werden und sich nicht ändern, verfügen viele Exploiting

Frameworks über eine Sammlung von zuverlässigen Shellcodes. Ein Angreifer kann den

passenden Shellcode je nach gewünschter Aufgabe aus der Sammlung auswählen und

verwenden, ohne diesen selber programmieren zu müssen. [Burns et al. 2007]

· Enkodierung des Shellcodes:

Um eine korrekte Ausführung des Shellcodes sicherstellen zu können, muss dieser u.U.

enkodiert werden. Akzeptiert eine anzugreifende Zielanwendung z.B. nur lesbare Zeichen

als Eingabe und verwirft alle anderen Zeichen, ist es notwendig, den Shellcode mit einem

"Alphanumeric Encoder" zu enkodieren. Exploiting Frameworks stellen hierfür mehere

Enkoder zur Verfügung. [Burns et al. 2007]

· Ausführung des Exploits:

Damit ein Exploit die Schwachstelle auf einem Ziel-IT-System ausnutzen kann und der

2.2 Funktionsweise von Exploiting Frameworks

Shellcode korrekt ausgeführt wird, müssen die Daten über ein Protokoll an das Ziel-IT-

System gesendet werden. Exploiting Frameworks stellen hierfür Schnittstellen für mehrere

Protokolle zur Verfügung. [Burns et al. 2007]

Neben der ursprünglichen Aufgabe einer vereinfachten Entwicklung von Exploits werden Ex-

ploiting Frameworks zudem im Rahmen von Penetration-Tests eingesetzt, um potentielle

Schwachstellen in IT-Systemen zu identifizieren. Das Ergebnis solcher Überprüfungen kann

durch automatisch generierte Berichte (Full Exploitation Reports) zusammengefasst dargestellt

werden. Exploiting Frameworks werden zudem im Bereich der Erforschung von Schwachstellen

(Vulnerability Research) eingesetzt. [Maynor et al. 2007, Burns et al. 2007]

2.2.2 Architektur

Um die im vorherigen Kapitel besprochenen Aufgaben umsetzen zu können, beinhalten Exploiting

Frameworks mehrere Komponenten. Diese werden im Folgenden unter dem Aspekt des Aufbaus

und der Funktion (Architektur) von Exploiting Frameworks betrachtet. Die Architektur von

Exploiting Frameworks ist in der Abbildung 2.2 dargestellt.

Exploiting Framework

Exploit

Sammlung

Exploit #1

Exploit #2

...

Exploit #N

Payload #3

Exploit #1

Zielinformation

Exploit Development

Support Tools

Payload

Sammlung

Payload #1

Payload #2

...

Payload #M

OP-Code

Datenbanken

NOP

Generatoren

Payload

Encoder

An das Ziel versenden

Auswählen

Benutzerschnittstellen

Tools zum

Erkennen von

Schwachstellen

Tools zur

Filterung von

erkennbaren

Angriffen

Abbildung 2.2: Exploiting Framework - Komponenten [Nach: Skoudis 2007]

Eine Komponente von Exploiting Frameworks stellen Benutzerschnittstellen dar, die zur Interak-

tion mit dem Benutzer verwendet werden und z.B. in Form einer grafischen Benutzeroberfläche

2.2 Funktionsweise von Exploiting Frameworks

(GUI) oder eines Kommandozeilen-Interpreters realisiert sein können. Um einen Angriff ge-

gen ein IT-System durchzuführen, wählt der Benutzer einen Exploit aus der enthaltenen

Exploit-Sammlung aus, der die gewünschte Schwachstelle einer Software ausnutzt. Aufgrund

des ausgewählten Exploits und der daraus resultierenden maximalen Größe des auszuführenden

Codes auf dem Ziel-IT-System, kann ein Payload (Shellcode) ausgewählt werden, der diese

Anforderungen erfüllt und die gewünschte Funktion realisiert. Neben einer Sammlung von

Exploits und Payloads enthalten Exploiting Frameworks auch Payload Encoder und NOP

Generatoren, die auf den Payload angewendet werden können, um eine korrekte Ausführung

sicherzustellen und eine Erkennung durch NIDS zu verhindern. Exploiting Frameworks ent-

halten zudem zusätzliche Komponenten, die eine Entwicklung und Ausführung von Exploits

erleichtern. Hierzu gehören Werkzeuge zur Erkennung von Schwachstellen auf IT-Systemen,

Datenbanken mit Opcodes oder Plugins zur Filterung von Angriffen, die durch NIDS erkannt

werden können.

2.2.3 Metasploit Framework (MSF)

Im Folgenden wird der Aufbau von Exploiting Frameworks an dem Beispiel des Metasploit

Framework (MSF) [Metasploit LLC 2009] dargestellt.

Abbildung 2.3: Metasploit Framework - Projektlogo

Das Open Source Exploiting Framework steht in der aktuellen Version 3.3-dev für die Be-

triebssysteme Linux, BSD, Mac OS X und Windows (in den Versionen: 2000, XP, 2003, Vista)

entgeltfrei auf der Webseite des Projektes zur Verfügung. Um eine kommerzielle Verwendung des

Quellcodes zu verbieten, ist das MSF unter der "Metasploit Framework License" veröffentlicht.

Das Framework ist seit der Version 3.0 in der Skriptsprache Ruby geschrieben und enthält

Komponenten in C und Assembler, wie z.B. die Payloads. Das MSF ist eine Entwicklungs-

plattform für Exploits und Security Werkzeuge, die für Penetration-Tests und die Erforschung

von Schwachstellen (Vulnerability Research) eingesetzt werden kann. Durch die enthaltenen

2.2 Funktionsweise von Exploiting Frameworks

Exploits kann es auch für die Entwicklung von IDS-Signaturen eingesetzt werden. Das MSF

wird von insgesamt 12 Personen (Stand: 10.08.2009) unter der Leitung von H.D. Moore aktiv

weiterentwickelt (siehe Tabelle 2.1). [Moore 2009]

Parameter

MSF Version 3.0

MSF Version 3.3-dev

Datum der Veröffentlichung

27.03.2007

10.08.2009

Zeilen Code

100.000

419.000

Exploits

176

394

Payloads

104

239

Payload Encoder

NOP-Generatoren

Auxiliary Module

180

Tabelle 2.1: Metasploit Exploiting Framework - Versionsvergleich [Nach: Moore 2009]

2.2.3.1 Architektur

Die Architektur des Metasploit Frameworks (siehe Abbildung 2.4) basiert auf drei Bibliotheken,

die die Hauptkomponenten des Frameworks darstellen.

Abbildung 2.4: Metasploit Framework - Aufbau [Nach: Moore 2006, Maynor et al. 2007]

2.2 Funktionsweise von Exploiting Frameworks

· Ruby Extension Bibliothek (REX):

Die REX Bibliothek ist eine grundlegende Komponente des MSF und stellt eine Sammlung

von Klassen und Modulen dar, die für die Entwicklung von Exploits oder Werkzeugen

als Auxiliary-Module verwendet werden können. Die enthaltenen Klassen realisieren

folgende Funktionalitäten: Generierung von Architektur-spezifischen Opcodes, Encodierung

von Daten durch die Bereitstellung von Enkodierungs-Funktionen (z.B. XOR Enkoder),

Funktionen zur Ausführung von Exploits, Verwaltung von Aufgaben (Tasks) in Jobs,

Protokollierung von Ereignissen in Dateien oder Datenbanken, Interaktion mit der Opcode-

Datenbank, Unterstützung mehrerer Protokolle (DCERPC, HTTP and SMB) für Protokoll-

spezifische Exploits, Erstellung von TCP- und SSL-Sockets, Synchronisation von Abläufen

(wegen Multi-Threading), Bereitstellung von Diensten zur Realisierung eines Text-basierten

Kommandozeilen-Interpreters. [Metasploit Staff 2007]

· Framework-Core Bibliothek:

Die Kern-Bibliothek (Core Library) des Frameworks besteht aus Klassen, die mehrere

Subsysteme realisieren. Die Bibliothek stellt Schnittstellen für die Module und Plugins zur

Verfügung, die einen Zugriff auf die Kernfunktionalitäten des Frameworks ermöglichen.

Die Klassen der Bibliothek realisieren folgende Komponenten: einen Datenspeicher für Um-

gebungsvariablen (Data Store), mehrere Event-Handler für die Reaktion auf verschiedene

Ereignisse im Framework (Exploit-, General Framework-, Database- und Session-Events)

und ermöglichen die Verwaltung der Module, Plugins, Sitzungen (Sessions) und Jobs.

[Metasploit Staff 2007]

· Framework-Base Bibliothek:

Die Basis-Bibliothek (Base Library) des Frameworks basiert auf der Framework-Core

Bibliothek und stellt Schnittstellen bereit, die eine Kommunikation mit der Framework-

Core Bibliothek erleichtern. [Metasploit Staff 2007]

Exploits, Payloads, Enkodierer, NOP-Generatoren und zusätzliche Programme, die auf dem

MSF aufbauen (Auxiliary), sind in Form von Modulen in das Framework integriert. Das MSF

ist über entsprechende Schnittstellen in der Basis-Bibliothek durch Plugins erweiterbar.

2.2.3.2 Benutzerschnittstellen

Für den Zugriff auf die Funktionen des MSF stehen mehrere Benutzerschnittstellen zur Verfügung,

die unterschiedliche Anforderungen erfüllen und in der Tabelle 2.2 auf S. 30 aufgelistet sind. Es

existieren spezialisierte Schnittstellen, die für bestimmte Aufgaben entwickelt worden sind. So

ermöglicht z.B. der nicht interaktive Kommandozeileninterpreter "msfcli" eine Skript-gesteuerte

Ausführung von Angriffen im Rahmen von Penetration-Tests.

2.2 Funktionsweise von Exploiting Frameworks

Schnittstelle

Beschreibung

msfcli

Der nicht interaktive Kommandozeilen-Interpreter (Command Line Interface) ermöglicht

die Skript-gesteuerte Ausführung von Angriffen.

msfconsole

Die Konsole stellt einen Kommandozeilen-Interpreter dar, der für die Interaktion mit

dem Benutzer verwendet wird.

msfd

Die Deamon-Schnittstelle ermöglicht einen Zugriff auf die MSF Konsole über das Netz.

msfencode

Die Encoder-Schnittstelle ermöglicht einen direkten Zugriff auf die im Framework enthal-

tenen Payload Encoder.

msfgui

Die graphische Benutzerschnittstelle ermöglicht den Zugriff auf die gesamten Funktionen

des Frameworks.

msfopcode

Die Opcode-Schnittstelle ermöglicht den Zugriff auf die Opcode Datenbank.

msfpayload

Die Payload-Schnittstelle ermöglicht den Zugriff auf die Payloads und deren Ausgabe in

mehreren Programmiersprachen.

msfpescan

Die PeScan-Schnittstelle kann verwendet werden um ausführbare Dateien und DLLs

(Dynamic Link Library) zu deassemblieren und nach bestimmten Befehlen zu durchsuchen.

msfweb

Die Web-Schnittstelle ermöglicht den Zugriff auf das MSF über den Webbrowser.

Tabelle 2.2: Metasploit Exploiting Framework - Übersicht der Benutzerschnittstellen

Die Abbildung 2.5 stellt die graphische Benutzerschnittstelle nach dem Programmstart dar.

Abbildung 2.5: Metasploit Framework - Benutzerinterface msfgui nach dem Programmstart

2.3 Funktionsweise von Intrusion Detection Systemen (IDS)

2.3 Funktionsweise von Intrusion Detection Systemen (IDS)

Dieses Kapitel gibt eine Defintion der Grundbegriffe "Intrusion Detection" und "Intrusion

Detection System". Es werden der Aufbau und die Komponenten von Intrusion Detection

Systemen und die Unterschiede zu einem Intrusion Protection System (IPS) dargestellt. Zudem

werden Probleme von IDS in Form von Fehlalarmen vorgestellt. Stellvertretend für mehrere

IDS Produkte wird das Open Source NIDS Snort vorgestellt.

2.3.1 Definition Intrusion Detection

Der Begriff Intrusion Detection bezeichnet die Überwachung von IT-Systemen oder -netzen mit

dem Ziel der Erkennung von sicherheitsrelevanten Ereignissen im Überwachungsbereich, die auf

Angriffe, Missbrauchsversuche oder Sicherheitsverletzungen hindeuten. Die erkannten Ereignisse

sollten hierbei möglichst zeitnah erkannt, gemeldet und untersucht werden. Intrusion-Detection

bezeichnet keine einzelne Software, sondern ist als Prozess zu verstehen, der eine geeignete

organisatorische Einbindung benötigt. Dieser kann durch technisch geeignete Werkzeuge zur

Generierung, Filterung, Auswertung und Archivierung von Ereignissen unterstützt werden. Eine

wirksame Intrusion-Detection bedarf daher einer an das Einsatzumfeld angepassten Auswahl

geeigneter Werkzeuge. [Bundesamt für Sicherheit in der Informationstechnik (BSI) 2002]

2.3.2 Definition Intrusion Detection System

Ein Intrusion Detection System bezeichnet eine Zusammenstellung von technischen Werkzeugen,

die den gesamten Prozess der Intrusion-Detection unterstützen. Hierzu gehört die Erkennung

von sicherheitsrelevanten Ereignissen, sowie die anschließende Auswertung und Dokumentation

der Ereignisse. Die benötigten Funktionalitäten können in einer Komponente integriert oder

aus mehreren Einzelkomponenten zusammengesetzt sein. Die Auswahl und Zusammenstellung

eines IDS richtet sich nach den individuellen technischen und organisatorischen Gegebenheiten

und Anforderungen des Einsatzumfelds. [Bundesamt für Sicherheit in der Informationstechnik

(BSI) 2002]

2.3.3 Taxonomie von IDS

Intrusion Detection Systeme können anhand unterschiedlicher Parameter in bestimmte Ka-

tegorien eingeteilt werden. Diese Kategorisierung von IDS kann anhand der Platzierung der

Sensoren oder anhand der Art der Erkennungsmethode von Angriffen durchgeführt werden

(siehe Abbildung 2.6 auf S. 32).

Details

Seiten
Erscheinungsform: Originalausgabe
Erscheinungsjahr: 2009
ISBN (eBook): 9783836636759
DOI: 10.3239/9783836636759
Dateigröße: 4.2 MB
Sprache: Deutsch
Institution / Hochschule: Fachhochschule Bonn-Rhein-Sieg – Informatik
Erscheinungsdatum: 2009 (Oktober)
Note: 1,0
Schlagworte: intrusion detection system insertion evasion obfuscation exploiting
Produktsicherheit: Diplom.de

Autor

Thomas Stein (Autor:in)

Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks

Zusammenfassung

Leseprobe

Inhaltsverzeichnis

Details

Autor

Thomas Stein (Autor:in)