Exploit Testing System Fiabilité
Auteur:
Ashfaq Ansari

Commenté par:
Classement:
5
Sur Avril 1, 2015
Dernière mise à jour:Février 6, 2017

Résumé:

Exploit Fiabilité Testing System est conçu pour déterminer la fiabilité d'un logiciel d'exploiter en calculant comte frappé des EIP = 0x41414141

Présentation

 
One of my friend was playing with “MS13-009” une Utilisez Après gratuit vulnérabilité dans Internet Explorer ce qui conduit à Exécution de code à distance.

Il m'a demandé de l'aider dans la rédaction d'un exploit fiable pour cette vulnérabilité.

Une fois que je ai commencé à regarder dans la vulnérabilité, Je ai réalisé que cette vulnérabilité ne est pas fiable en raison du fait qu'il ya une très petite fenêtre entre la liberté et l'utilisation de l'objet libéré. Plus important, la libre ne se est produit lorsque l'exécution de toutes les SCRIPT blocs se complétées.

En raison de cette, nous devions compter sur JScript de setTimeout() fonction de réaffecter l'objet libéré.

Comme, ma tâche était d'écrire un fiables exploit pour cette vulnérabilité, ce était douloureux pour lancer Internet Explorer sous WinDbg et enregistrer le EIP valeur du registre à chaque fois.

Cette situation m'a frustré et je ai commencé à penser pourquoi ne pas écrire un petit script qui fait cette tâche.

Exploit Testing System Fiabilité

 
Alors, la fiabilité est déterminée par le nombre de fois l'exploit de comptage est en mesure de contrôle EIP se inscrire auprès de l'adresse / valeur souhaitée.
Ce est un script très simple pour Fenêtres à déterminer la quantité d'une exploitation est fiable. Je ai utilisé Cdb.exe pour détecter l'accident et enregistrer l'état des registres.

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
# -*- codage: utf-8 -*-
"""

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


Droit d'auteur (C) 2010-2015 HackSys équipe

Ce fichier fait partie de Exploit Tests de Fiabilité
Système.

Exploit Fiabilité Testing System est utilisé pour tester
la fiabilité de frapper EIP = 0x41414141. Ce système
vise à trouver combien un exploit est fiable.

Voir le fichier «licence» l'autorisation de copie.

Auteur : Ashfaq Ansari
Contact: ashfaq_ansari1989[à]hotmail.com
Site: http://hacksys.vfreaks.com

"""


__author__ = «Ashfaq Ansari '
__version__ = '1.0'

importer le
importer sys
importer shutil
importer sous-processus
importer filetage


classe ExploitReliabilityTestingSystem(objet):
    """
    Cette classe est le cœur de Exploit Fiabilité
    Testing System.
    """


    def __init__(soi, cdb, Connectez-vous, programme, args=''):
        """
        Ce est le constructeur de ERTS

        :arrêter cdb: chemin Cdb.exe
        :journal param: log chemin
        :programme de param: programme à lancer
        :args param: arguments de programme
        """

        # valider si cdb, log et le programme existe
        si pas le.chemin.existe(cdb):
            augmenter AttributeError(«Se il vous plaît valider chemin CDB»)
        elif pas le.chemin.existe(Connectez-vous):
            essayer:
                le.mkdir(le.chemin.dirname(Connectez-vous))
            sauf OSError:
                augmenter AttributeError(«Se il vous plaît valider chemin du journal ')
        elif pas le.chemin.existe(programme):
            augmenter AttributeError(«Se il vous plaît valider chemin du programme ')

        soi.cdb = cdb
        soi.Connectez-vous = Connectez-vous
        soi.programme = programme
        soi.args = args
        soi.processus = Aucun

    def exécuter(soi, file_path, pause=60):
        """
        Ce est utilisé pour exécuter le processus avec temporisation
        utilisant le threading

        :param file_path: déposer chemin pour ouvrir
        :param délai: attente en secondes
        """

        # valider args et paramètre de délai
        si file_path est Aucun:
            augmenter AttributeError(«Se il vous plaît valider programme FILEPATH ')
        elif pause est Aucun et catégorie(pause) == st:
            augmenter AttributeError(«Se il vous plaît valider timeout ')

        def __launch_process():
            # préparer l'argument de processus
            process_args = soi.cdb + '' + '-g -o -G -c & Quot; .logopen' + soi.Connectez-vous + \
                           »;r;.logclose;q" & Quot; » + soi.programme + »" » + soi.args + \
                           '' + file_path

            soi.processus = sous-processus.Le Pape(process_args,
                                            stdin=sous-processus.PIPE,
                                            stdout=sous-processus.PIPE,
                                            stderr=sous-processus.PIPE)
            # attendre que le processus pour quitter
            soi.processus.communiquer()

        # préparer le fil de lancer le processus
        process_thread = filetage.Fil(cible=__launch_process)

        # commencer le fil
        process_thread.début()

        # maintenant rejoindre le fil
        process_thread.joindre(pause=pause)

        # vérifier si le fil est toujours vivant
        si process_thread.is_alive():
            # semble que le processus ne se est pas écrasé
            # tuons le processus
            soi.processus.résilier()

            # nous allons mettre fin à l'thread enfant
            process_thread.joindre()

    def is_crash_reliable(soi, EIP):
        """
        Ce est utilisé pour vérifier si l'accident était fiable
        en cochant la EIP du journal des blocages

        :EIP param: EIP inscrire la valeur à comparer
        :retour: Vrai / Faux
        """

        # valider EIP sous forme de chaîne
        si catégorie(EIP) != st:
            augmenter AttributeError(«Se il vous plaît valider EIP»)

        Connectez-vous = ouvrir(soi.Connectez-vous).lire()

        si 'EIP ={0}».format(EIP) à Connectez-vous:
            retour Vrai
        autre:
            retour Faux


si __name__ == "__main__":
    # constantes
    TÊTE = '' '

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

           Exploiter la fiabilité du système
                 Version: {0}

    '' '
.format(__version__)

    # affiner ces valeurs
    MAX_RUN = 10
    TEMPS LIBRE = 60
    EIP = '41414141'
    FILE_PATH = 'Http://localhost:8000/Exploit.HTML '
    CDB_PATH = 'C:\\Program Files\\Outils de débogage pour Windows (x86)\\Cdb.exe '
    Chemin-programme = 'C:\\Program Files\\Internet Explorer\\iexplore.exe "
    PROGRAM_ARGS = ''
    LOG_PATH = 'C:\\Logs + os.path.basename(Chemin-programme) + ».Connectez-vous»

    reliable_crash_count = 0
    la fiabilité = 0

    # les détails de cible d'impression
    Print Header
    print '
Cible EIP: {0}'.format(EIP)
    print '
Application cible: {0}\n'.format(os.path.basename(Chemin-programme))

    # créer l'instance d'Exploit Fiabilité
    # Classe TestingSystem
    Erts = ExploitReliabilityTestingSystem(cdb = CDB_PATH,
                                           log = LOG_PATH,
                                           program = chemin-programme,
                                           args = PROGRAM_ARGS)

    # exécuter l'application et de compter le nombre d'accidents
    for i in range(0, MAX_RUN):
        # exécuter l'application cible
        erts.run(file_path = FILE_PATH, timeout = TIMEOUT)

        # maintenant vérifier si l'accident est fiable
        si erts.is_crash_reliable(EIP EIP =):
            = reliable_crash_count 1

        # maintenant déterminer l'exploit de fiabilité
        la fiabilité = (reliable_crash_count * 100) / MAX_RUN

        # imprimer l'état à l'écran
        sys.stdout.write("\r[{0}] Fiabilité direct Note: {1}%& Quot; .format(i + 1, fiabilité))
        sys.stdout.flush()

    # supprimer le répertoire de journal
    shutil.rmtree(path = os.path.dirname(LOG_PATH))

    print '
\n»
    print '
Exploit Fiabilité Note: {0}%'.format(fiabilité)

 

Disclaimer: Se il vous plaît ne pas utiliser le code source fourni ici. La dernière version peut toujours être trouvée dans le dépôt Github ci-dessous.

 

En action

 

Exploit Testing System Fiabilité Terminé
Exploit course Testing System Fiabilité

 

Exploit Testing System Fiabilité sur GitHub

 


Je espère que cela peut être utile d'exploiter les développeurs qui veulent tester la fiabilité de leurs exploits. Se il vous plaît soulever une question si vous trouvez un bug ou si vous avez toute proposition d'amélioration.

12,436 vues au total, 31 vues aujourd'hui

Les deux onglets suivants changent contenu ci-dessous.

Ashfaq Ansari

chercheur en sécurité
Ashfaq Ansari est le fondateur de HackSys équipe nom de code "Panthera". Il est un chercheur en sécurité avec une expérience dans divers aspects de la sécurité de l'information. Il est l'auteur "HackSys Extreme pilote Vulnérable" et "Shellcode de la mort". Il a également écrit et publié plusieurs livres blancs sur l'exploitation du logiciel de bas niveau. Son intérêt de base réside dans "Low Level exploitation", "Reverse Engineering", "Analyse du programme" et "Hybrid fuzzing". Il est un fanboy de l'intelligence artificielle et l'apprentissage automatique. Il est le chef de file pour le chapitre null Pune.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont marqués *