Lade Inhalt...

Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks

©2009 Bachelorarbeit 151 Seiten

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.
© Diplomica Verlag GmbH
http://www.diplomica.de, Hamburg 2009

2
Inhaltsverzeichnis
Abbildungsverzeichnis
6
Tabellenverzeichnis
8
Listingverzeichnis
9
Abkürzungsverzeichnis
10
1
Einleitung
14
1.1
Ausgangssituation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
1.2
Forschungsstand
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
1.3
Zielsetzung der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
1.4
Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
1.5
Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
2
Grundlagen von Exploiting Frameworks und Intrusion Detection Systemen
17
2.1
Grundlegende Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.1.1
Sicherheitslücke (Vulnerability) . . . . . . . . . . . . . . . . . . . . . . .
17
2.1.2
Exploit
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
2.1.3
Pufferüberlauf (Buffer Overflow) . . . . . . . . . . . . . . . . . . . . . .
20
2.1.4
Shellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
2.1.5
Spoofing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
2.1.6
Denial of Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
2.2
Funktionsweise von Exploiting Frameworks . . . . . . . . . . . . . . . . . . . .
25
2.2.1
Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
2.2.2
Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
2.2.3
Metasploit Framework (MSF) . . . . . . . . . . . . . . . . . . . . . . . .
27
2.2.3.1
Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
2.2.3.2
Benutzerschnittstellen . . . . . . . . . . . . . . . . . . . . . . .
29
2.3
Funktionsweise von Intrusion Detection Systemen (IDS) . . . . . . . . . . . . .
31
2.3.1
Definition Intrusion Detection . . . . . . . . . . . . . . . . . . . . . . . .
31
2.3.2
Definition Intrusion Detection System . . . . . . . . . . . . . . . . . . .
31
2.3.3
Taxonomie von IDS
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
2.3.4
Komponenten eines IDS . . . . . . . . . . . . . . . . . . . . . . . . . . .
32

3
2.3.4.1
Netz-basierte Sensoren
. . . . . . . . . . . . . . . . . . . . . .
32
2.3.4.2
Host-basierte Sensoren
. . . . . . . . . . . . . . . . . . . . . .
33
2.3.5
Methoden der Angriffserkennung . . . . . . . . . . . . . . . . . . . . . .
34
2.3.5.1
Erkennung von Angriffsmustern
. . . . . . . . . . . . . . . . .
34
2.3.5.2
Anomalieerkennung . . . . . . . . . . . . . . . . . . . . . . . .
34
2.3.6
Intrusion Protection Systeme (IPS) . . . . . . . . . . . . . . . . . . . . .
34
2.3.7
Falschmeldungen (False Positives und False Negatives) . . . . . . . . . .
34
2.3.8
Sourcefire Snort (IDS/IPS) . . . . . . . . . . . . . . . . . . . . . . . . .
35
2.3.8.1
Architektur und Funktionsweise . . . . . . . . . . . . . . . . .
35
2.3.8.2
Preprozessoren . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
2.3.8.3
Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
3
Konzepte zur Verschleierung von Angriffen
39
3.1
Allgemeine Verschleierungs-Techniken
. . . . . . . . . . . . . . . . . . . . . . .
39
3.1.1
Insertion / Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
3.1.2
Evasion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
3.1.3
Denial of Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
3.1.4
Obfuscation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
3.2
Angriffstechnik der Sicherungsschicht (OSI-Schicht 2) . . . . . . . . . . . . . . .
43
3.3
Angriffstechniken der Netzwerkschicht (OSI-Schicht 3) . . . . . . . . . . . . . .
44
3.3.1
Ungültige IP-Header Felder . . . . . . . . . . . . . . . . . . . . . . . . .
45
3.3.2
IP Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
3.3.3
Fragmentierung von IP-Paketen . . . . . . . . . . . . . . . . . . . . . . .
46
3.4
Angriffstechniken der Transportschicht (OSI-Schicht 4) . . . . . . . . . . . . . .
48
3.4.1
Ungültige TCP-Header Felder . . . . . . . . . . . . . . . . . . . . . . . .
49
3.4.2
TCP Optionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
3.4.3
TCP Stream Reassembly
. . . . . . . . . . . . . . . . . . . . . . . . . .
50
3.4.4
TCP Control Block (TCB) . . . . . . . . . . . . . . . . . . . . . . . . .
50
3.5
Angriffstechniken der Anwendungsschicht (OSI-Schicht 5-7) . . . . . . . . . . .
51
3.5.1
Coding Evasion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
3.5.2
Directory-Traversal Evasion . . . . . . . . . . . . . . . . . . . . . . . . .
51
3.5.3
Evasion durch polymorphen Shellcode . . . . . . . . . . . . . . . . . . .
51
4
Verschleierung von Angriffen in Exploiting Frameworks
53
4.1
Verschleierung von Angriffen im Metasploit Framework
. . . . . . . . . . . . .
53
4.1.1
Implementierte Insertion- und Evasion Techniken . . . . . . . . . . . . .
54
4.1.2
Implementierte Obfuscation Techniken . . . . . . . . . . . . . . . . . . .
54
4.1.2.1
Verschleierung des Angriffscodes . . . . . . . . . . . . . . . . .
54
4.1.2.2
Verschleierung des Shellcode . . . . . . . . . . . . . . . . . . .
56
4.1.3
Filterung von erkennbaren Angriffen auf Clientseite (IPS-Filter Plugin)
57

4
4.2
Verschleierung von Angriffen in Core Impact
. . . . . . . . . . . . . . . . . . .
58
4.3
Verschleierung von Angriffen in SAINT exploit . . . . . . . . . . . . . . . . . .
58
5
Bewertung von NIDS unter dem Gesichtspunkt von Evasion Techniken
59
5.1
Bewertungsparameter für Network Intrusion Detection Systeme . . . . . . . . .
59
5.2
Entwurf der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
5.2.1
Anforderungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
5.2.2
Auswahl der zu evaluierenden Network Intrusion Detection Systeme . .
64
5.2.3
Auswahl der Testverfahren
. . . . . . . . . . . . . . . . . . . . . . . . .
66
5.2.3.1
Tests der Evasion Techniken der Netzwerk- und Transportschicht 67
5.2.3.2
Tests der Obfuscation Techniken der Anwendungsschicht . . .
73
5.2.4
Konfiguration der Testumgebung . . . . . . . . . . . . . . . . . . . . . .
80
5.3
Realisierung der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
5.3.1
Einrichtung der Virtuellen Maschinen in VirtualBox . . . . . . . . . . .
82
5.3.1.1
Einrichtung des Metasploit Exploiting Frameworks . . . . . . .
82
5.3.1.2
Einrichtung der Netzwerkkomponenten (Hub, Router) . . . . .
83
5.3.1.3
Einrichtung des NIDS Snort
. . . . . . . . . . . . . . . . . . .
86
5.3.1.4
Einrichtung des NIDS / IPS Untangle . . . . . . . . . . . . . .
88
5.3.1.5
Einrichtung des NIDS Bro
. . . . . . . . . . . . . . . . . . . .
90
5.3.1.6
Einrichtung des NIDS Securepoint . . . . . . . . . . . . . . . .
91
5.3.1.7
Einrichtung der Zielsysteme . . . . . . . . . . . . . . . . . . . .
91
5.3.2
Integration der Cisco Appliances . . . . . . . . . . . . . . . . . . . . . .
91
5.3.2.1
Einrichtung des Cisco 2620 Routers (IP Plus) . . . . . . . . . .
92
5.3.2.2
Einrichtung des Cisco 4215 Sensors
. . . . . . . . . . . . . . .
93
5.4
Durchführung der Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
96
5.5
Auswertung der Testergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . .
97
5.5.1
Auswertung der Protokolldateien . . . . . . . . . . . . . . . . . . . . . .
97
5.5.2
Darstellung der Testergebnisse . . . . . . . . . . . . . . . . . . . . . . .
99
5.5.3
Zusammenfassende Bewertung der NIDS . . . . . . . . . . . . . . . . . .
102
5.5.4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
104
6
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
7
Zusammenfassung und Fazit
114

5
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

6
Abbildungsverzeichnis
2.1
Lebenszyklus von Sicherheitslücken (Vulnerability Lifecycle) . . . . . . . . . . .
20
2.2
Exploiting Framework - Komponenten . . . . . . . . . . . . . . . . . . . . . . .
26
2.3
Metasploit Framework - Projektlogo . . . . . . . . . . . . . . . . . . . . . . . .
27
2.4
Metasploit Framework - Architektur . . . . . . . . . . . . . . . . . . . . . . . .
28
2.5
Metasploit Framework - Benutzerinterface msfgui nach dem Programmstart . .
30
2.6
Intrusion Detection System - Taxonomie . . . . . . . . . . . . . . . . . . . . . .
32
2.7
Snort - Projektlogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
2.8
Snort - Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
2.9
Snort - Aufgaben mehrerer Preprozessoren . . . . . . . . . . . . . . . . . . . . .
37
2.10 Snort - Bestandteile des Snort Regel-Headers . . . . . . . . . . . . . . . . . . .
38
3.1
Angriffstechnik - Insertion (des Buchstaben X) . . . . . . . . . . . . . . . . . .
40
3.2
Angriffstechnik - Evasion (des Buchstaben A) . . . . . . . . . . . . . . . . . . .
41
3.3
Insertion Angriff auf der Sicherungsschicht (Link Layer) . . . . . . . . . . . . .
43
3.4
Internet Protocol (IP) - Internet Datagram Header . . . . . . . . . . . . . . . .
44
3.5
Reassembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
3.6
Überlappung der Daten von Fragmenten . . . . . . . . . . . . . . . . . . . . . .
47
3.7
Transmission Control Protocol (TCP) - TCP Header Format . . . . . . . . . .
48
4.1
MSF - Auswahlmöglichkeiten der implementierten Obfuscation Techniken . . .
53
4.2
Core Impact V9 - Erweiterte Modulparameter . . . . . . . . . . . . . . . . . . .
58
5.1
Konfiguration der Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . . .
81
5.2
Untangle - Status der installierten Komponenten . . . . . . . . . . . . . . . . .
89
5.3
Untangle - Übersicht der vorhandenen Signaturen . . . . . . . . . . . . . . . . .
90
5.4
Untangle - Status der installierten IPS Komponente
. . . . . . . . . . . . . . .
90
5.5
Cisco IPS Device Manager - Signaturübersicht
. . . . . . . . . . . . . . . . . .
95
5.6
Cisco IPS Device Manager - Event Viewer . . . . . . . . . . . . . . . . . . . . .
96
5.7
Virtualbox - Übersicht der Virtuellen Maschienen . . . . . . . . . . . . . . . . .
96
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

7
(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

8
Tabellenverzeichnis
2.1
Metasploit Exploiting Framework - Versionsvergleich . . . . . . . . . . . . . . .
28
2.2
Metasploit Exploiting Framework - Übersicht der Benutzerschnittstellen . . . .
30
2.3
IDS - Erkennungsmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
3.1
Verhalten mehrerer Betriebssysteme bei Überlappungen in Fragmenten . . . . .
47
4.1
MSF - Implementierte Insertion- und Evasion Techniken . . . . . . . . . . . . .
54
4.2
MSF - Implementierte Obfuscation Optionen für das HTTP . . . . . . . . . . .
55
4.3
MSF - Implementierte Obfuscation Optionen für das SMB Protokoll . . . . . .
55
4.4
MSF - Implementierte Obfuscation Optionen für das DCERPC Protokoll
. . .
56
5.1
NIDS - Bewertungsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . .
63
5.2
Intrusion Detection Systeme - Marktübersicht . . . . . . . . . . . . . . . . . . .
65
5.3
Evaluationsgegenstand - Liste der zu evaluierenden NIDS . . . . . . . . . . . .
66
5.4
MSF - Moduloptionen des ms08_067_netapi Exploit-Moduls . . . . . . . . . .
76
5.5
Metasploit - Paketabhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . .
83
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

9
Listingverzeichnis
2.1
Beispielprogramm in der Programmiersprache C [Burns et al. 2007] . . . . . . .
21
2.2
Ausnutzen des Buffer Overflows im Beispielprogramm [Burns et al. 2007] . . . .
21
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] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
2.5
Snort - Test-Regel zur Erkennung von Zugriffen auf FTP-Server . . . . . . . . .
38
4.1
MSF - Enthaltene NOP Generatoren . . . . . . . . . . . . . . . . . . . . . . . .
56
4.2
MSF - Enthaltene Payload Encoder . . . . . . . . . . . . . . . . . . . . . . . . .
57
4.3
MSF - Ausschnitt des IPS-Filter Plugin . . . . . . . . . . . . . . . . . . . . . .
57
5.1
Fragrouter - Übersicht der Optionen . . . . . . . . . . . . . . . . . . . . . . . .
67
5.2
Fragroute - Übersicht der Optionen . . . . . . . . . . . . . . . . . . . . . . . . .
68
5.3
Fragroute - Regeldatei mit IP Fragmentierung (16 Byte Payload Länge) . . . .
70
5.4
Ping - ICMP Echo Request mit 128 Byte Daten . . . . . . . . . . . . . . . . . .
70
5.5
Tcpdump - Aufzeichnung des Netzverkehrs: Test 1 . . . . . . . . . . . . . . . .
71
5.6
RP Filter - Deaktivierung der Quell-Validierung im Kernel . . . . . . . . . . . .
71
5.7
Fragroute - Eintrag in der Routing-Tabelle . . . . . . . . . . . . . . . . . . . . .
71
5.8
Fragroute - Ausgabe der durchgeführten Fragmentierung von IP-Paketen . . . .
72
5.9
Tcpdump - Aufzeichnung des Netzverkehrs: Test 2 . . . . . . . . . . . . . . . .
72
5.10 Tcpdump - Aufzeichnung des Netzverkehrs: Test 3 . . . . . . . . . . . . . . . .
73
5.11 Tcpdump - Aufzeichnung des Netzverkehrs: Test 4 . . . . . . . . . . . . . . . .
73
5.12 Metasploit Command Line Interface - Befehl zur Ausgabe aller Exploits . . . .
74
5.13 Metasploit Command Line Interface - Ausschnitt der Ausgabe aller Exploits . .
74
5.14 Metasploit Framework - Übersicht der Modulfunktionen . . . . . . . . . . . . .
74
5.15 Metasploit Framework Command Line Interface - Aufrufsyntax . . . . . . . . .
75
5.16 Metasploit Framework - Übersicht der Moduloptionen . . . . . . . . . . . . . .
75
5.17 Metasploit Command Line Interface - Aufruf ohne Verschleierungs-Optionen . .
76
5.18 Metasploit Command Line Interface - Ausgabe der zum Exploit-Modul kompati-
blen Payloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
77
5.19 Metasploit Command Line Interface - Übersicht der Moduloptionen nach der
Auswahl des Payloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78
5.20 Übergabeparameter für die Protokollierung auf dem Ziel-IT-System . . . . . . .
78
5.21 Metasploit Command Line Interface - Aufruf mit Verschleierungs-Optionen . .
79
5.22 Automatisierungskript - Protokolleintrag . . . . . . . . . . . . . . . . . . . . . .
79

10
5.23 Automatisierungskript - Funktion zum Aufruf des msfcli . . . . . . . . . . . . .
80
5.24 Automatisierungskript - Aufruf des msfcli mit Verschleierungs-Optionen . . . .
81
5.25 Metasploit - Installation der benötigten Softwarepakete
. . . . . . . . . . . . .
82
5.26 Metasploit - Subversion Checkout . . . . . . . . . . . . . . . . . . . . . . . . . .
83
5.27 Metasploit - Subversion Checkout . . . . . . . . . . . . . . . . . . . . . . . . . .
84
5.28 bridge-utils - Konfiguration der Bridge . . . . . . . . . . . . . . . . . . . . .
84
5.29 Aktivierung des Routings im Linux-Kernel . . . . . . . . . . . . . . . . . . . . .
85
5.30 Konfiguration der Netzwerkschnittstellen . . . . . . . . . . . . . . . . . . . . . .
85
5.31 Snort - Installation der benötigten Softwarepakete
. . . . . . . . . . . . . . . .
86
5.32 Snort - Befehle zur Kompilierung des Quellcodes . . . . . . . . . . . . . . . . .
86
5.33 Snort - Einrichtung der Benutzer und Verzeichnisse . . . . . . . . . . . . . . . .
87
5.34 Snort - Ausschnitt der Umgebungsvariablen . . . . . . . . . . . . . . . . . . . .
88
5.35 Snort - Aufruf mit Konfigurationsparametern . . . . . . . . . . . . . . . . . . .
88
5.36 Untangle - Regel: Potentially Bad Traffic (Index of /cgi-bin/ response) . . . . .
89
5.37 Untangle - Test-Signatur: Erkennung von TCP Netzverkehr . . . . . . . . . . .
89
5.38 Bro IDS - Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.39 Bro IDS - Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.40 Cisco 2620 Router (IP Plus) - IP Audit Optionen . . . . . . . . . . . . . . . . .
92
5.41 Cisco 2620 Router (IP Plus) - Einrichtung . . . . . . . . . . . . . . . . . . . . .
92
5.42 Cisco 2620 Router (IP Plus) - Ausschnitt der Konsolenausgabe mit Alarmmeldungen 93
5.43 Cisco 4215 Sensor - Fehlermeldung . . . . . . . . . . . . . . . . . . . . . . . . .
93
5.44 Cisco 4215 Sensor - Status der Kernkomponenten . . . . . . . . . . . . . . . . .
94
5.45 Cisco 4215 Sensor - Grundkonfiguration . . . . . . . . . . . . . . . . . . . . . .
94
5.46 VM Metasploit - Ausgabe des Automatisierungsskriptes während der Tests
. .
98
5.47 Snort - Logeintrag eines erkannten Angriffs . . . . . . . . . . . . . . . . . . . .
98
5.48 Tcpdump - Ausgabe der Statistik des aufgezeichneten Netzverkehrs . . . . . . .
98
5.49 Windows XP SP3 - Protokolleintrag auf dem Zielsystem . . . . . . . . . . . . .
99
5.50 Auswertung der Protokolldateien . . . . . . . . . . . . . . . . . . . . . . . . . .
99
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

11
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
DB
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
FE
Front End
FIN
Finish
FP
False positive
FN
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

12
ID
Identifikation
IDS
Intrusion Detection System
IP
Internet Protocol
IPS
Intrusion Protection System
ISO
International Organization for Standardization
IV
Informationsverarbeitung
IT
Informationstechnik
Internet
Interconnected Networks
KB
Kilobyte
LAN
Local Area Network
MAC
Media Access Control
MB
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
OS
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
SP
Service Pack
SVN
Subversion
TCP
Transmission Control Protocol
TP
True positive
TN
True negative
TTL
Time to Live

13
UDP
User Datagram Protocol
URL
Uniform Resource Locator
URG
Urgent
URI
Uniform Resource Identifier
VM
Virtuelle Maschine
WAN
Wide Area Network

14
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
15
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
16
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.

17
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
18
· 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
19
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
20
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
21
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]
1
/*
2
* file: buffer.c
3
* description: Dieses Programm ist verwundbar durch einen Buffer Overflow
4
*/
5
6
#include
<stdio.h>
7
#include
<string.h>
8
9
main(
int
argc,
char
*argv[]){
10
// Deklaration des Puffers
11
char
buffer[8];
12
13
// Ueberpruefung der Parameteranzahl
14
if
(argc != 2){
15
printf(
"Fehler: Nicht mehr als einen Parameter angegeben.\n"
);
16
exit(1);
17
}
18
19
// Kopieren des uebergebenen Strings in den Puffer
20
strcpy(buffer, argv[1]);
21
22
// Ausgabe der Puffer-Inhalts
23
printf(
"Inhalt des Puffers: %s\n"
, buffer);
24
}
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]
1
# Variablen mit Maschinencode
2
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"
3
NOP="\x90\x90\x90\x90"
4
5
# Aufruf des Beispielprogramms mit dem Shellcode
6
./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
22
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]
1
# 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
2
3
# O p c o d e s ( M a s c h i n e n b e f e h l e )
4
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 -
5
6
# A s s e m b l e r
7
0 0 0 0 0 0 0 0
31 C0
xor eax , eax
8
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
9
0 0 0 0 0 0 0 7
8 8 4 4 2 4 0 3
mov [ esp +0 x3 ] , al
10
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
11
0 0 0 0 0 0 1 0
89 E3
mov ebx , esp
12
0 0 0 0 0 0 1 2
50
p u s h eax
13
0 0 0 0 0 0 1 3
53
p u s h ebx
14
0 0 0 0 0 0 1 4
89 E1
mov ecx , esp
15
0 0 0 0 0 0 1 6
B 0 0 B
mov al ,0 xb
16
0 0 0 0 0 0 1 8
33 D2
xor edx , edx
17
0 0 0 0 0 0 1 A
C D 8 0
int 0 x80
18
0 0 0 0 0 0 1 C
CC
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
23
Listing 2.4: Linux x86 Shellcode der /bin/bash ausführt in einem C Programm [Burns et al. 2007]
1
/*
2
* file: shellcode.c
3
* description: Ausfuehrung von Shellcode in einem C Programm
4
*/
5
6
#include
<stdio.h>
7
#include
<string.h>
8
9
main(){
10
// Shellcode als Opcode String
11
unsigned char
shellcode[]=
12
"\x31\xc0\x68\x2f\x73\x68\xaa\x88\x44\x24\x03\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53"
13
"\x89\xe1\xb0\x0b\x33\xd2\xcd\x80\xcc"
;
14
15
// Ausfuehren des Shellcodes
16
((
void
(*)())shellcode)();
17
}
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
24
· 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
25
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
26
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
27
(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
28
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
17
20
NOP-Generatoren
5
7
Auxiliary Module
30
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
29
· 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
30
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)
31
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
Jahr
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
Zurück

Titel: Intrusion Detection System Evasion durch Obfuscation in Exploiting Frameworks
Cookie-Einstellungen