Exploit Zuverlässigkeit Testing System
Verfasser:
Ashfaq Ansari

Bewertet von:
Wertung:
5
Auf April 1, 2015
Zuletzt geändert:Februar 6, 2017

Zusammenfassung:

Exploit Zuverlässigkeit Testing System entwickelt, um die Zuverlässigkeit einer Software zu bestimmen, ausnutzen, indem er Trefferanzahl von EIP Berechnung = 0x41414141

Einführung

 
One of my friend was playing with “MS13-009” a Verwendung Nach Kostenlos Schwachstelle in Internet Explorer was zu Remotecodeausführung.

Er bat mich, ihm schriftlich eine Hilfe zuverlässig zu nutzen Für diese Sicherheitsanfälligkeit.

Als ich begann, mich in die Sicherheitslücke, Ich erkannte, dass diese Sicherheitsanfälligkeit unzuverlässig aufgrund der Tatsache, dass es eine sehr kleines Fenster zwischen freien und Nutzung des frei Objekt. Noch wichtiger ist, die freie nur geschehen, wenn die Ausführung aller SCRIPT Blöcke bekommen abgeschlossen.

Dadurch, wir mussten auf JScript verlassen können setTimeout() Funktion, um die befreiten Objekt umzuschichten.

Wie Sie, Meine Aufgabe war es, zu schreiben ein zuverlässiger nutzen Für diese Sicherheitsanfälligkeit, es war schmerzhaft zu starten Internet Explorer unter WinDbg und notieren Sie die EIP Registerwert jedes Mal.

Diese Situation hat mich frustriert und ich begann darüber nachzudenken, warum nicht ein kleines Skript, das diese Aufgabe tut schreiben.

Exploit Zuverlässigkeit Testing System

 
So, Die Zuverlässigkeit wird durch Zählen der Anzahl von Malen, die auszunutzen bestimmt ist, die Kontrolle EIP Anmeldung bei der gewünschten Adresse / Wert.
Dies ist ein sehr einfaches Skript für Windows- um festzustellen, wie viel ein Exploit zuverlässig. Ich verwendet habe Cdb.exe um den Absturz zu erkennen und notieren Sie die Register Zustand.

Source Code

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
# -*- Verschlüsselung: utf-8 -*-
"""

 /$$$$$$$$ /$$$$$$$  /$$$$$$$$ /$$$$$$
| $$_____ /| $$__ $$|__ __ // $$ $$ $$ __
| $$      | $$  \ $$   | $$  | $$  \__ /
| $$$$$   | $$$$$$$/   | $$  |  $$$$$$
| $$__ / | $$__ $$ | $$   \____ $$
| $$      | $$  \ $$   | $$   /$$  \ $$
| $$$$$$$$| $$  | $$   | $$  |  $$$$$$/
|________ /|__ /|__ / |__ / \______ /


Urheberrecht (C) 2010-2015 HackSys Teams

Diese Datei ist Teil von Exploit Zuverlässigkeitstest
System.

Exploit Zuverlässigkeit Testing System wird verwendet, um zu testen,
Zuverlässigkeit des Schlagens EIP = 0x41414141. Dieses System
wird bei der Suche nach, wie viel ein Exploit ausgerichtet ist zuverlässig.

Sehen Sie die Datei "Lizenz" für das Kopieren Erlaubnis.

Verfasser : Ashfaq Ansari
In Kontakt Treten: ashfaq_ansari1989[bei]hotmail.com
Webseite: http://hacksys.vfreaks.com

"""


__author__ = 'Ashfaq Ansari'
__version__ = '1.0'

importieren die
importieren sys
importieren shutil
importieren Teilprozess
importieren Gewindeschneiden


Klasse ExploitReliabilityTestingSystem(Objekt):
    """
    Diese Klasse ist das Herz der Exploit Zuverlässigkeit
    Testing System.
    """


    def __init__(selbst, cdb, einloggen, Programm, args=''):
        """
        Dies ist der Konstruktor für ERTS

        :stoppen cdb: cdb.exe Pfad
        :param Protokoll: Protokollpfad
        :param-Programm: Programm zu starten
        :param args: Programmargumente
        """

        # überprüfen, ob cdb, anmelden und Programm vorhanden
        wenn nicht die.Pfad.vorhanden(cdb):
            erhöhen Attribute("Bitte bestätigen CDB Pfad ')
        elif nicht die.Pfad.vorhanden(einloggen):
            versuchen:
                die.mkdir(die.Pfad.dirname(einloggen))
            außer OSERROR:
                erhöhen Attribute("Bitte bestätigen LOG Pfad ')
        elif nicht die.Pfad.vorhanden(Programm):
            erhöhen Attribute("Bitte bestätigen PROGRAMM Pfad ')

        selbst.cdb = cdb
        selbst.einloggen = einloggen
        selbst.Programm = Programm
        selbst.args = args
        selbst.Prozess = Die Sonne Geht Auf

    def laufen(selbst, file_path, Timeout=60):
        """
        Dies wird verwendet, um den Prozess mit Timeout laufen
        mit Gewinde

        :param file_path: Dateipfad öffnen
        :param Timeout: Timeout in Sekunden
        """

        # validieren args und Timeout-Parameter
        wenn file_path ist Die Sonne Geht Auf:
            erhöhen Attribute("Bitte bestätigen Programm FILEPATH ')
        elif Timeout ist Die Sonne Geht Auf und Art(Timeout) == str:
            erhöhen Attribute("Bitte bestätigen TIMEOUT ')

        def __launch_process():
            # bereiten den Prozess Argument
            process_args = selbst.cdb + '' + '-g -G O -c & quot; .logopen' + selbst.einloggen + \
                           ';r;.logclose;q" & Quot; " + selbst.Programm + '" ' + selbst.args + \
                           '' + file_path

            selbst.Prozess = Teilprozess.Der Papst(process_args,
                                            stdin=Teilprozess.PIPE,
                                            stdout=Teilprozess.PIPE,
                                            stderr=Teilprozess.PIPE)
            # warten, bis der Prozess beendet
            selbst.Prozess.kommunizieren()

        # bereiten den Faden, um den Prozess laufen
        process_thread = Gewindeschneiden.Gewinde(Ziel=__launch_process)

        # Starten Sie den Faden
        process_thread.Anfang()

        # Jetzt beitreten den Faden
        process_thread.beitreten(Timeout=Timeout)

        # überprüfen, ob der Thread noch am Leben ist
        wenn process_thread.is_alive():
            # scheint, dass der Prozess nicht abstürzen
            # Lassen Sie uns töten den Prozess
            selbst.Prozess.beenden()

            # wir beenden das Kind Faden
            process_thread.beitreten()

    def is_crash_reliable(selbst, EIP):
        """
        Diese wird verwendet, um zu überprüfen, ob der Absturz war zuverlässig
        durch Überprüfung der EIP aus dem Crash-Protokoll

        :EIP param: EIP registrieren Vergleichswert
        :Rückkehr: True / False
        """

        # validieren EIP als String
        wenn Art(EIP) != str:
            erhöhen Attribute("Bitte bestätigen EIP")

        einloggen = öffnen(selbst.einloggen).lesen()

        wenn "EIP ={0}'.Format(EIP) in einloggen:
            Rückkehr Wahr
        sonst:
            Rückkehr Falsch


wenn __name__ == "__main__":
    # Konstanten
    HEADER = '' '

      /$$$$$$$$ /$$$$$$$  /$$$$$$$$ /$$$$$$
     | $$_____ /| $$__ $$|__ __ // $$ $$ $$ __
     | $$      | $$  \ $$   | $$  | $$  \__ /
     | $$$$$   | $$$$$$$/   | $$  |  $$$$$$
     | $$__ / | $$__ $$ | $$   \____ $$
     | $$      | $$  \ $$   | $$   /$$  \ $$
     | $$$$$$$$| $$  | $$   | $$  |  $$$$$$/
     |________ /|__ /|__ / |__ / \______ /

           Exploit Zuverlässigkeit Systems
                 Version: {0}

    '' '
.Format(__version__)

    # Feinabstimmung diese Werte
    MAX_RUN = 10
    AUSZEIT = 60
    EIP = '41414141'
    FILE_PATH = 'Http://localhost:8000/Exploit.HTML '
    CDB_PATH = 'C:\\Programme\\Debugtools für Windows (x86)\\cdb.exe '
    Program_path = 'C:\\Programme\\Internet Explorer\\iexplore.exe "
    PROGRAM_ARGS = ''
    Log_path = 'C:\\Logs\' + os.path.basename(Program_path) + '.einloggen'

    reliable_crash_count = 0
    Zuverlässigkeit = 0

    # Druckziel Details
    Print Header
    print '
Ziel EIP: {0}'.format(EIP)
    print '
Zielanwendung: {0}\n'.format(os.path.basename(Program_path))

    # erstellen die Instanz von Exploit Zuverlässigkeit
    # TestingSystem Klasse
    Erts = ExploitReliabilityTestingSystem(cdb = CDB_PATH,
                                           log = log_path,
                                           Programm = program_path,
                                           args = PROGRAM_ARGS)

    # führen Sie die Anwendung und zählen die Anzahl der Abstürze
    for i in range(0, MAX_RUN):
        # führen Sie die Zielanwendung
        erts.run(Dateipfad = FILE_PATH, timeout = TIMEOUT)

        # jetzt prüfen, ob der Absturz ist zuverlässig
        wenn erts.is_crash_reliable(EIP EIP =):
            reliable_crash_count = 1

        # Jetzt bestimmen den Exploit Zuverlässigkeit
        Zuverlässigkeit = (reliable_crash_count * 100) / MAX_RUN

        # Drucken Sie den Status auf dem Bildschirm
        sys.stdout.write("\r[{0}] Live-Zuverlässigkeitsbewertung: {1}%& Quot; .format(i + 1, Zuverlässigkeit))
        sys.stdout.flush()

    # das Protokollverzeichnis löschen
    shutil.rmtree(path = os.path.dirname(Log_path))

    print '
\n'
    print '
Exploit Zuverlässigkeit Rating: {0}%'.format(Zuverlässigkeit)

 

Haftungsausschluss: Bitte benutzen Sie nicht den Quellcode hier zur Verfügung gestellten. Die neueste Version ist stets auf der Github Repository unten angegebenen gefunden werden.

 

In Aktion

 

Exploit Zuverlässigkeit Testing System abgeschlossen
Exploit Zuverlässigkeit Testing System Lauf

 

Exploit Zuverlässigkeit Testing System auf GitHub

 


Ich hoffe, das kann nützlich sein, für Entwickler, die die Zuverlässigkeit ihrer Exploits testen wollen nutzen. Bitte heben ein Problem, wenn Sie irgendwelche Fehler finden oder wenn Sie Verbesserungsvorschlag haben.

12,427 Ansichten, 22 von heute

Die folgenden zwei Registerkarten wechseln Gehalt unter.

Ashfaq Ansari

Sicherheit Researcher
Ashfaq Ansari ist der Gründer von HackSys Teams Codenamen "Panthera". Er ist ein Sicherheitsexperte mit Erfahrung in verschiedenen Aspekten der Informationssicherheit. Er ist Autor "HackSys Extreme Vulnerable Treiber" und "Shellcode of Death". Er hat auch geschrieben und veröffentlicht verschiedene Whitepapers auf niedrigem Niveau Software Ausbeutung. Seine Kern Interesse liegt in "Low Level Exploitation", "Reverse Engineering", "Program Analysis" und "Hybrid Fuzzing". Er ist ein fanboy der Künstlichen Intelligenz und maschinelles Lernen. Er ist das Kapitel für Blei null Pune.

Einen Kommentar schreiben

Ihre E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *