salt crypt md5 fonction python

Version imprimable

Bonjour,

Je développe une application en python permettant de trouver des mot de passe crypté avec la méthode brutforce ( TP pour un cours de sécurité ).
J'ai donc un fichier shadow contenant les comptes fournit pas le professeur :
Code:

1 2 3 4 5 6 root:$1$934b4a210c17493f68bf6bfe74bff77a:16749:0:99999:7::: fred:$1$9ebf8e708dcb3f28cb43d5d52655ab14:16561:0:99999:7::: mysql:!:16939:0:99999:7::: uuidd:*:16940:0:99999:7::: giselle:$1$6e5fa4d9c48ca921c0a2ce1e64c9ae6f:17078:0:99999:7::: libvirt-qemu:!:17105:0:99999:7:::
Les mots de passe sont donc en deuxième position dans chaque chaîne en faisant pas mal de recherche j'ai trouvé que le mot de passe était crypté en salt crypt de md5 qui est différent du MD5 normal il me semble.

Cependant moi je génère dans mon code des mots passe azerty par exemple et à chaque fois je crypte ce mot de passe afin de le comparer à celui dans mon fichier.

Mais je ne vois pas quelle fonction utilisé (en python donc) pour crypté le mot de passe de la même manière que cela $1$6e5fa4d9c48ca921c0a2ce1e64c9ae6f ( avec le $1$ devant) et donc ensuite pouvoir le comparer.

Merci par avance !

Damien

16/01/2017, 21h42
tyrtamos

Bonjour,

Je n'ai jamais fait ça, mais j'ai trouvé une info sur le sujet ici:

https://wiki.python.org/moin/Md5Passwords
17/01/2017, 08h55
BufferBob
salut,

Citation:

Envoyé par damienla

Je développe une application en python permettant de trouver des mot de passe crypté avec la méthode brutforce ( TP pour un cours de sécurité ).
J'ai donc un fichier shadow contenant les comptes fournit pas le professeur

et ton professeur de sécurité il t'a jamais dit de privilégier "chiffrés" ou "hashés" au lieu de "cryptés" qui ne veut pas dire grand chose en plus d'être incorrect ? ;)

par ailleurs si il vous donne un fichier shadow j'imagine que soit il y a le format du fichier qui va avec le cours, soit implicitement c'est à vous de faire des recherches sur ledit format
Google est un bon point de départ, on en vient rapidement à lire des choses du genre :

Citation:

"$id$salt$hashed", the printable form of a password hash as produced by crypt(), where "$id" is the algorithm used. (On GNU/Linux, "$1$" stands for MD5, "$2a$" is Blowfish, "$2y$" is Blowfish (correct handling of 8-bit chars), "$5$" is SHA-256 and "$6$" is SHA-512 (...)

foncièrement ici ce n'est pas un problème lié à Python (puisqu'il n'y a aucun code en l'état), la priorité est de se renseigner sur le format du fichier shadow

Edit: quelques liens intéressants :
- http://www.vidarholen.net/contents/blog/?p=32
- https://docs.python.org/3/library/crypt.html
17/01/2017, 09h22
damienla

D'accord merci pour ces infos je vais continué à me renseigner car j'ai fait la chose suivante cette nuit:

J'ai fait tourné mon programme en hashant 8-) en MD5 et en mettant $1$ devant à chaque mot de passe trouvé pour ensuite le comparé.

Ce matin le programme tournait toujours sans avoir trouvé je pense donc que ce n'est pas la bonne solution :?

Merci à vous en tout cas !
17/01/2017, 15h05
BufferBob

Citation:

Envoyé par damienla

J'ai fait tourné mon programme en hashant (...) pour ensuite le comparé.
Ce matin le programme tournait toujours sans avoir trouvé je pense donc que ce n'est pas la bonne solution :?

en fait si, c'est la seule solution possible puisque les hash dans le fichier sont salés (salted), le but du sel étant justement d'obliger l'attaquant à générer tous les hash possibles au lieu d'avoir recours à des rainbow tables, des tables de hashes précalculés

en revanche les techniques moderne n'utilisent pas le CPU (ni Python accessoirement) mais plutôt le GPU des cartes graphiques beaucoup plus rapides

le mieux que tu puisses faire pour débuter c'est d'avoir un algorithme pour générer les mots de passe un peu soigné et optimisé, choisir avec soin le nombre de caractères maximum du mdp et les caractères autorisés, et découper le job en autant de processus (import multiprocessing) qu'il y a de CPUs, de manière à rentabiliser au maximum

on pourrait ainsi envisager un programme qui teste tout seul comme un grand tous les mots de passe, d'abord de 1, puis 2, puis 3 caractères etc. sans forcément de limite au nombre max de caractères, mais qui soit capable aussi répartir le travail entre différents processus enfants, de reprendre où il en était après qu'on l'a stoppé et qui affiche régulièrement à l'écran à quel stade il en est (toutes les minutes, toutes les heures, ou tous les X mots de passe par exemple), là pour le coup ça devient intéressant à coder, en tous cas plus qu'une forêt de boucles imbriquées qu'on relance à chaque fois ;)

Ca a l'air super intéressant la méthode que tu me dis d'utiliser, à travers mes recherches j'ai également vu qu'utiliser en effet la carte graphique était bien plus performant, je pense voir ce que tu veux dire, le problème c'est que techniquement parlant même en m'aidant des docs sur internet liées au multiprecessing je n'ai aucune idée de comment le mettre en oeuvre au sein de mon script, le python est imposé, je n'en avais jamais fait auparavant je découvre donc entièrement.

Pour info voici mon code actuel ( je sais qu'il est loin d'être parfait mais bon je suis ouvert à tout correctif ahah)
Merci infiniment en tout cas de vous pencher sur le sujet c'est vraiment cool de votre part

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
import sys
import time
import hashlib
fp = open ("C:\\Users\\damie\\Desktop\\Cours\\Sécurité Systeme et reseaux\\Mot de passe\\shadow.txt","r")
lignes = fp.readlines()
mdptab= []
 
#Afficher la date et heure
now = time.localtime(time.time())
print ("début de l'opération : " + time.asctime(now))
 
#Stockage dans le tableau mdptab de tous les mot de passe user trouvés dans le fichier shadow (3mots de passes)
for ligne in lignes:
  chaine=ligne.split(":")
 
  if len(chaine[1]) > 20 :
    mdptab = mdptab+[chaine[1]]
 
 
 
 
#Algo force brut
import os
Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789;@_#"
i = 0
#Mot de passe contenant au minimum 6 à 12 caractères
nbcarac = 5
while nbcarac <= 11 :
 
  nbcarac = nbcarac + 1
  print("Nb caractères : " + nbcarac )
  if nbcarac == 6 :
    for a in range(0,66):
          for b in range(0,66):
              for c in range(0,66):
                  for d in range(0,66):
 
                    for e in range(0, 66):
                      for f in range(0, 66):
 
                        Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f]
                        hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                        mdp = "$1$" + hash_object
 
                        print(mdp)
                        #On compare içi le mot de passe généré puis haché en md5 à ceux stocké dans tableau
                        for i in range(0, 2):
                          if mdp == mdptab[i]:
                            now = time.localtime(time.time())
                            print("Date de la trouvaille : " + time.asctime(now))
                            print ("MDP TROUVE : " + "crypté: " + mdp +" non crypté : "+Brute )
 
 
  if nbcarac == 7:
 
    for a in range(0, 66):
      for b in range(0, 66):
        for c in range(0, 66):
          for d in range(0, 66):
            for e in range(0, 66):
              for f in range(0, 66):
                for g in range(0, 66):
                  Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g]
                  hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                  mdp = "$1$" + hash_object
 
                  for i in range(0, 2):
                    if mdp == mdptab[i]:
                      now = time.localtime(time.time())
                      print("Date de la trouvaille : " + time.asctime(now))
                      print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)
 
  if nbcarac == 8:
 
     for a in range(0, 66):
       for b in range(0, 66):
         for c in range(0, 66):
           for d in range(0, 66):
             for e in range(0, 66):
               for f in range(0, 66):
                 for g in range(0, 66):
                   for h in range(0, 66):
                     Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g] + Alpha[h]
                     hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                     mdp = "$1$" + hash_object
 
                     for i in range(0, 2):
                       if mdp == mdptab[i]:
                         now = time.localtime(time.time())
                         print("Date de la trouvaille : " + time.asctime(now))
                         print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)
  if nbcarac == 9:
    for a in range(0, 66):
      for b in range(0, 66):
        for c in range(0, 66):
          for d in range(0, 66):
            for e in range(0, 66):
              for f in range(0, 66):
                for g in range(0, 66):
                  for h in range(0, 66):
                    for i in range(0, 66):
                      Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g] + Alpha[h] + Alpha[i]
                      hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                      mdp = "$1$" + hash_object
 
                      for i in range(0, 2):
                        if mdp == mdptab[i]:
                          now = time.localtime(time.time())
                          print("Date de la trouvaille : " + time.asctime(now))
                          print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)
 
  if nbcarac == 10:
 
    for a in range(0, 66):
      for b in range(0, 66):
        for c in range(0, 66):
          for d in range(0, 66):
            for e in range(0, 66):
              for f in range(0, 66):
                for g in range(0, 66):
                  for h in range(0, 66):
                    for i in range(0, 66):
                      for j in range(0, 66):
                        Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g] + Alpha[h] + Alpha[i]+ Alpha[j]
                        hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                        mdp = "$1$" + hash_object
 
                        for i in range(0, 2):
                          if mdp == mdptab[i]:
                            now = time.localtime(time.time())
                            print("Date de la trouvaille : " + time.asctime(now))
                            print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)
 
  if nbcarac == 11:
 
    for a in range(0, 66):
      for b in range(0, 66):
        for c in range(0, 66):
          for d in range(0, 66):
            for e in range(0, 66):
              for f in range(0, 66):
                for g in range(0, 66):
                  for h in range(0, 66):
                    for i in range(0, 66):
                      for j in range(0, 66):
                        for k in range(0, 66):
                          Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g] + Alpha[h] + Alpha[i] + Alpha[j] +Alpha[k]
                          hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                          mdp = "$1$" + hash_object
 
                          for i in range(0, 2):
                            if mdp == mdptab[i]:
                              now = time.localtime(time.time())
                              print("Date de la trouvaille : " + time.asctime(now))
                              print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)
 
  if nbcarac == 12:
 
    for a in range(0, 66):
      for b in range(0, 66):
        for c in range(0, 66):
          for d in range(0, 66):
            for e in range(0, 66):
              for f in range(0, 66):
                for g in range(0, 66):
                  for h in range(0, 66):
                    for i in range(0, 66):
                      for j in range(0, 66):
                        for k in range(0, 66):
                          for l in range(0, 66):
                            Brute = Alpha[a] + Alpha[b] + Alpha[c] + Alpha[d] + Alpha[e] + Alpha[f] + Alpha[g] + Alpha[h] + Alpha[i] + Alpha[j] + Alpha[k]+ Alpha[l]
                            hash_object = hashlib.md5(Brute.encode('utf-8')).hexdigest()
                            mdp = "$1$" + hash_object
 
                            for i in range(0, 2):
                              if mdp == mdptab[i]:
                                now = time.localtime(time.time())
                                print("Date de la trouvaille : " + time.asctime(now))
                                print("MDP TROUVE : " + "crypté: " + mdp + " non crypté : " + Brute)

18/01/2017, 08h38
damienla

Ma solution n'est en effet pas optimisée après l'avoir fait tourner 14h, l'algorithme est toujours sur les 6 caractères et n'a même pas commencé à tester les 7 :ptdr:

Citation:

Envoyé par damienla

Ma solution n'est en effet pas optimisée après l'avoir fait tourner 14h, l'algorithme est toujours sur les 6 caractères et n'a même pas commencé à tester les 7 :ptdr:

oui y'aurait beaucoup de choses à redire, pour le moins réécrire X fois le même genre de boucles ça frôle l'hérésie :aie: quand c'est comme ça on se débrouille pour créer une fonction

j'avais aussi mal regardé la tête du fichier... il n'a pas un format standard, puisqu'en réalité il n'y a pas de sel ici, on a directement les hash md5 en hexadécimal, autant dire que c'est bon pour le TP mais plus aucune distribution ne stocke les hash de mdp comme ça depuis des années

pour générer les mots de passe on peut si on est fainéant se reposer sur itertools.product() par exemple
aussi pour gagner du temps, comme on a plusieurs hash dans le fichier, pour chaque mot de passe généré puis hashé, on le comparera à chaque hash trouvé dans le fichier, comme ça pas la peine de relancer 15x la moulinette
et finalement pour hasher les mots de passe on utilisera le module hashlib

un exemple fonctionnel (sur py2, normalement ça devrait passer sur py3 en l'état, à valider) :
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 import re, itertools, hashlib, sys, datetime ALPHA = 'abcdefghijklmnopqrstuvwxyz' MAXLEN = 12 def display(s, horodatage=False): print('{} {}'.format(datetime.datetime.now().strftime('[%H:%M:%S.%f] ') if horodatage == True else '', s)) sys.stdout.flush() # maudit windows... with open('shadow.txt', 'r') as f: lines = f.readlines() credz = {} for line in lines: try: user, user_hash = re.findall('^([^:]+):\$1\$([^:]+):.+', line)[0] except IndexError: continue # si la ligne ne contient pas de hash on passe a la ligne suivante else: credz[user] = user_hash.encode('utf') display('{:>15} : {}'.format(user, user_hash)) display('\n {} MD5 hashes found, now trying to recover passwords...\n'.format(len(credz))) for z in range(MAXLEN): display('trying {} character{} long passwords'.format(z+1, '' if z == 0 else 's'), horodatage=True) for p in itertools.product(ALPHA, repeat=z+1): password = ''.join(p) current_hash = hashlib.md5(password.encode('utf')).hexdigest() if current_hash in credz.values(): display('found password \'{}\' for user(s) {}'.format(password, ','.join(i for i in credz if credz[i] == current_hash)), horodatage=True)
et l'output :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 root : 934b4a210c17493f68bf6bfe74bff77a fred : 9ebf8e708dcb3f28cb43d5d52655ab14 giselle : 6e5fa4d9c48ca921c0a2ce1e64c9ae6f gustave : 128ecf542a35ac5270a87dc740918404 alphonse : 128ecf542a35ac5270a87dc740918404 arthur : 128ecf542a35ac5270a87dc740918404 philibert : 128ecf542a35ac5270a87dc740918404 7 MD5 hashes found, now trying to recover passwords... [09:14:14.794000] trying 1 character long passwords [09:14:14.794000] trying 2 characters long passwords [09:14:14.795000] trying 3 characters long passwords [09:14:14.797000] found password 'bla' for user(s) alphonse,arthur,gustave,philibert [09:14:14.830000] trying 4 characters long passwords [09:14:15.708000] trying 5 characters long passwords (...)
en revanche ce code ne permet pas de répartir le job ni de reprendre après un arrêt éventuel, les deux sont un chouillat complexes si on débute en programmation, néanmoins je te livre un exemple de fonction pour générer des mots de passe qui pourrait supporter la reprise, ce qui la rend intéressante est notamment le fait qu'elle est récursive :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ALPHA = 'abcdefghijklmnopqrstuvwxyz' def gen(s): if len(s) == 0: # si le mot de passe est vide, on l'initialise avec le premier mdp de 1 caractère (donc 'a') s = ALPHA[0] else: c = ALPHA[(ALPHA.index(s[-1]) + 1) % len(ALPHA)] # sinon, on prend la dernière lettre du mdp et on l'incrémente s = s[:-1] + c # ce qui crée un nouveau mot de passe if ALPHA.index(c) == 0: # et si on est revenu au début return gen(s[:-1]) + c # on relance la fonction (elle s'appelle donc elle-même), pour rajouter un caractère au mdp en gros return s # la fonction renvoie le nouveau mdp, qu'on repassera en argument pour générer le prochain password = '' # on initialise le 1er mot de passe à générer, vide, ou bien on peut le recharger depuis une session précédente enregistrée avant de quitter par exemple while True: password = gen(password) # ici on hash, on compare etc. et on teste si la touche 'Echap' est enfoncée pour quitter le programme print (password)

18/01/2017, 09h34
tyrtamos

Bonjour,

Concernant l'utilisation de tous les cœurs du CPU avec multiprocessing et concurrent-futures, il y a eu ici une discussion sur ce forum avec des exemples:

http://www.developpez.net/forums/d15...sing-qprocess/

Pour faire ça, il faut travailler l'algorithme afin de bien séparer le calcul en éléments indépendants.

On peut aussi réfléchir aux probabilités: les mots de passe de 2 caractères ou de 20 caractères doivent être plus rares que ceux à 6, 7 ou 8 caractères: on peut donc commencer par le plus probable pour éviter de perdre du temps. Et, bien sûr, utiliser un dictionnaire: il vient d'être rappelé sur le web que les mots de passe du genre "123456" sont encore très utilisés... :D

Pour l'utilisation du GPU, je ne l'ai jamais fait, mais sous google avec "python gpu", on trouve beaucoup de solutions avec Python.