Discussion :

[zarohn]

Bonjour,

Dans le cadre d'un de mes projets j'ai besoin de calculer approximativement la force d'un mot de passe sur une échelle de 100. En fait mon problème est que je ne sais pas réellement quelles règles appliquer pour le calcul : comment définir mon 100% ? Est ce que 100% c'est 30 caractères avec minuscules, majuscules, chiffres, char spéciaux ? est ce que 15 caractères avec les mêmes critères suffisent pour faire 100% ? de combien de % baisse la force si je supprime un type de char tout en gardant la même taille de mot de passe ?



Bref, vous voyez je cherche à définir une règle pour calculer cette force, mais je ne vais pas l'inventer moi même ... existe t'il dans le domaine informatique une règle ou une norme permettant de calculer la force d'un mot de passe ? Sinon quelles règles de calcul me conseilleriez vous ? Comment mettriez vous ceci en place ?

Merci d'avance
Cordialement.

[ram-0000]

Il n'y a pas vraiment d'algorithme pour déterminer la force d'un mot de passe mais plutôt quelques règles de bon sens :

• Longueur du mot de passe
• Précense de majuscules
• Présence de chiffres
• Précence de caractères spéciaux (!%&*'"$)

Et après, tu crées ton algo en mettant un poid à chaque règle, par exemple

• 10% par caractère limité à 70%
• 10% par majuscule limité à 20%
• 10% par chiffre limité à 20%
• 15% par caractère spécial limité à 30%

Un mot de passe aurait ainsi une valeur de 140% que tu ramènes à 100% par une simple règle de trois.

Bien sûr, ceci est un exemple à adapter selon tes besoins et ta sensibilité.

[Benj.]

Sinon calculer le nombre de possibilités pour couvrir une plage commune et aviser en fonction de la vitesse de combinaisons/seconde que tu as. Et tu peux considérer, par exemple toujours, que 3 ans, pour bruteforcer un mot de passe est une perte de temps et que par conséquent le mot de passe est sûr à 99% (étant donné qu'aucun mot de passe n'est sûr à 100%).

C'est très limité comme postulat de départ, dans le sens ou il existe un nombre considérable d'attaques (liste de mot, attaque hybride, tables arc-en-ciel, etc) et que les vitesses combinatoires dépendent des machines et des composants à partir desquels on réalise ces attaques (CPU, CPU multicore, CPUs et, le plus rapide, GPU, GPU en SLI, etc).

Comme tu peux le voir les paramètres et les combinaisons sont nombreuses et calculer la force d'un mot de passe n'est pas réalisable.

Autre piste, consulter un dictionnaire de mots de passe mis en ligne (trouvable sans mal), générer des statistiques à partir de celui-ci et comparer les mots de passes dont tu souhaites générer le %age de force.

Pas de réponse universelle en tout cas je pense.

[zarohn]

Merci pour vos réponses... Ce que j'ai fait c'est donner un poids de 5 à chaque caractère (je met le même poids pour chaque type car si je n'ai qu'un seul type de caractère, un mdp ne contenant que des char spéciaux n'est pas beaucoup plus fort, ou juste un peu plus, qu'un mdp de la même taille avec uniquement des minuscules), puis je multiplie la somme en fonction du nombre de types de caractères différents car c'est cette combinaison qui donne la force. Et si à la fin je dépasse 100 je considère la valeur comme étant 100.

somme = nbChar * 5

Puis

Si j'ai un seul type de caractères :
somme = somme * 0.75

Si j'ai deux types de caractères :
somme = somme * 1.3

Si j'ai trois types de caractères :
somme = somme * 1.7

Si j'ai quatre types de caractères :
somme = somme * 2

Ça m'a l'air pas trop mal, voici quelques exemples de valeurs (avec un seul, deux, trois ou quatre types de char mélangés) que j'obtiens avec cet algo :

Exemples avec 5 caractères :
"snphh" donne une force de 18%
"ptpXY" donne une force de 32%
"4qWxr" donne une force de 42%
"OY(8b" donne une force de 50%

Exemples avec 10 caractères :
"bgzbkjmemg" donne une force de 35%
"NERakdfrga" donne une force de 65%
"R5GfUyCEmu" donne une force de 85%
"gQm)hFt&2t" donne une force de 100%

Exemples avec 15 caractères :
"pyniwggejatvhsk" donne une force de 52%
"QMwevrKqPhEXmWf" donne une force de 98%
"9NL3Jp1eBVpxyGq" donne une force de 100%
"Ppf#iU#q%8FJ38B" donne une force de 100%

Exemples avec 20 caractères :
"fikdqcfsnezmalhtxvec" donne une force de 70%
"ksDrBwDcCkYWZRvPZnjK" donne une force de 100%
"bvQggsyItsYtxy0zSOz6" donne une force de 100%
"ULqP1G(uW#uAbv[2PRtK" donne une force de 100%

Exemples avec 25 caractères :
"fikdqcfsnezmalhtxvec" donne une force de 88%
"ksDrBwDcCkYWZRvPZnjK" donne une force de 100%
"bvQggsyItsYtxy0zSOz6" donne une force de 100%
"ULqP1G(uW#uAbv[2PRtK" donne une force de 100%

Exemples avec 30 caractères :
"kbipnpixuoltebgtyiruaumfpxyqar" donne une force de 100%
"YaXdpEQccDqvAMxqdvDNEHPvPLKMjO" donne une force de 100%
"ep6Ynlo5ppSPVVtZS3nwIwmJNidNZN" donne une force de 100%
"EnJ[3BINWcU#yiE3zD1FZKmug[uSw9" donne une force de 100%

Qu'en pensez vous ? N'hésitez pas à critiquer les coefficients que j'ai utilisé si vous pensez qu'ils donnent une valeur trop faible, ou trop haute. Maintenant il faut que j'ajuste le curseur.

[Benj.]

J'ai un gros problème avec ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Exemples avec 5 caractères :
[...]
"4qWxr" donne une force de 42%

Exemples avec 10 caractères :
"bgzbkjmemg" donne une force de 35%
[...]

Ce qui revient à dire qu'un mot de passe de 5 caractères est plus fort que celui de 10 alors qu'il faut moins d'une minute pour bruteforcer un mot de passe (md5, sha1 ou autre) de 5 caractères (pour un jeu de caractères couvrant l'alpha-numérique et les symboles !.= etc).

[zarohn]

Ah bon ? Il me semblait qu'un mot de passe de 10 char avec un seul type était moins fort qu'un mot de passe avec trois types différents, même de 5 char ... Mais bon, je n'y connais pas grand chose en brute force.

[Benj.]

sachant que le bruteforce essaie les combinaisons "dans l'ordre", "a" sera avant "aa" qui est avant "aaa" etc.
Il est quelque part plus fort parce qu'il contient (dans ton exemple toujours) des caractères en minuscule et en majuscule mais reste extrêmement simple et rapidement cassable.

L'autre, qui a 10 caractères, est plus long à casser par une attaque par bruteforce et, de par sa longueur, demeure très dur (pour ne pas dire proche de l'impossible) à casser via une attaque de tables arc-en-ciel (qui là demanderait une centaine de Go de tables).

D'où ma remarque face au %age calculé.

Après, comme dit dans mon précédent message, c'est subjectif dans le sens où ce n'est pas vraiment et scientifiquement (je pense) mesurable.

[zarohn]

Ok donc la longueur est le premier critère, avant celui du nombre de types différents. Je pensais que c'était l'inverse. Je vais revoir mes coefs dans cette optique et les réadapter puisque selon toi à 10 char entièrement en minuscule on est déjà proche du 100%

[zarohn]

Sur http://www.passwordmeter.com "bgzbkjmemg" est donné à 11%.
Sur http://www.pc-optimise.com/securite/password.php, "bgzbkjmemg" est donné à 15%
Sur http://info.crypto.free.fr/algo_MDP.php "bgzbkjmemg" est donné à 14%



Edit : Bon, sur passwordmeter.com ils détaillent leur algo, je vais essayer de le reprendre pour faire mon calcul de la même manière qu'eux.

[Benj.]

A la différence que je résonne en terme d'attaque et eux en terme de paramètres basés sur "l'aspect" du mot de passe.

Pour comparaison, j'ai hashé les deux mots de passe en md5 pour les casser via une méthode de bruteforce.

Je casse 5afb2e2e1eecae72ab77935f2fb7f075 (le md5 de 4qWxr) en moins de 2 minutes avec comme jeu de caractères mixalpha-numérique mais, même après 15 minutes je n'ai toujours pas réussi à casser 822b790fd68be95613b5b84992a7c305 (le md5 de bgzbkjmemg) avec les mêmes paramètres.

[zarohn]

Ouais mais c'est parce que tu lances les deux tests avec les même params. Essayes de cracker bgzbkjmemg en mettant seulement "lowalpha" au lieu de "mixalpha-numérique" ... Je pense que tu le crack aussi vite que 4qWxr en "mixalpha-numérique".

[Benj.]

Ouais mais c'est parce que tu lances les deux tests avec les même params. Essayes de cracker bgzbkjmemg en mettant seulement "lowalpha" au lieu de "mixalpha-numérique" ... Je pense que tu le crack aussi vite que 4qWxr en "mixalpha-numérique".

Du tout, même 2 minutes après en ne gardant que le loweralpha, c'est bien plus long. Le jeu de caractère est réduit mais les possibilités non. Donc, c'est plus long et c'est tout à fait normal.

[zarohn]

Bon comme j'ai du mal à pondre un algo je vais essayer d'appliquer les règles du sitepasswordmeter.com qui m'a l'air plutôt bien et qui fera le boulot. Je passe le sujet en résolu... Merci à ram-0000 et particulièrement à Benj. pour leurs réponses

[zarohn]

Pour ceux que ça intéresserait, voici ce que ca donne en vb.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
Module mdl_Password

    Public Function getForce(ByVal pass As String) As Integer
        Dim somme As Integer
        Dim nbMin As Integer
        Dim nbMaj As Integer
        Dim nbNum As Integer
        Dim nbSpec As Integer
        Dim nbMiddleNumOrSpec As Integer
        Dim nbDiffType As Integer

        For x = 0 To pass.Length - 1
            If charExistOrNot(pass.ElementAt(x), "abcdefghijklmnopqrstuvwxyz") Then
                nbMin = nbMin + 1
            End If
            If charExistOrNot(pass.ElementAt(x), "ABCDEFGHIJKLMNOPQRSTUVWXYZ") Then
                nbMaj = nbMaj + 1
            End If
            If charExistOrNot(pass.ElementAt(x), "0123456789") Then
                nbNum = nbNum + 1
                If (x > 0 And x < pass.Length - 1) Then
                    nbMiddleNumOrSpec = nbMiddleNumOrSpec + 1
                End If
            End If
            If charExistOrNot(pass.ElementAt(x), "&@#()$%_[]") Then
                nbSpec = nbSpec + 1
                If (x > 0 And x < pass.Length - 1) Then
                    nbMiddleNumOrSpec = nbMiddleNumOrSpec + 1
                End If
            End If
        Next
        If nbMin <> 0 Then
            nbDiffType = nbDiffType + 1
        End If
        If nbMaj <> 0 Then
            nbDiffType = nbDiffType + 1
        End If
        If nbNum <> 0 Then
            nbDiffType = nbDiffType + 1
        End If
        If nbSpec <> 0 Then
            nbDiffType = nbDiffType + 1
        End If
         somme = somme + (pass.Length * 4)
        If nbMaj <> 0 And nbMin <> 0 Then
            somme = somme + ((pass.Length - nbMaj) * 2)
            somme = somme + ((pass.Length - nbMin) * 2)
        End If
        If nbNum <> 0 And (nbMin <> 0 Or nbMaj <> 0 Or nbSpec <> 0) Then
            somme = somme + (nbNum * 4)
        End If
        somme = somme + (nbSpec * 6)
        somme = somme + (nbMiddleNumOrSpec * 2)
        If pass.Length >= 8 And nbDiffType >= 3 Then
            somme = somme + ((nbDiffType + 1) * 2)
        End If
        If (nbMin <> 0 Or nbMaj <> 0) And nbNum = 0 And nbSpec = 0 Then
            somme = somme - (nbMin + nbMaj)
        End If
        If nbNum <> 0 And nbMin <> 0 And nbMaj <> 0 And nbSpec = 0 Then
            somme = somme - nbNum
        End If
        somme = somme - (consecutiveMaj(pass) * 2)
        somme = somme - (consecutiveMin(pass) * 2)
        somme = somme - (consecutiveNum(pass) * 2)
        somme = somme - (repeatChar(pass) * 2)
        If sequencialChar(pass) >= 3 Then
            somme = somme - (sequencialChar(pass) * 3)
        End If
        If somme > 100 Then
            somme = 100
        End If
        Return (somme)
    End Function

    Private Function charExistOrNot(ByVal chara As Char, ByVal str As String) As Boolean
        For x = 0 To str.Length - 1
            If (str.ElementAt(x) = chara) Then
                Return (True)
            End If
        Next
        Return (False)
    End Function

    Private Function consecutiveMaj(ByVal pass As String) As Integer
        Dim nbConsecutiveMaj As Integer
        For x = 1 To pass.Length - 1
            If Char.IsUpper(pass.ElementAt(x)) And Char.IsUpper(pass.ElementAt(x - 1)) Then
                nbConsecutiveMaj = nbConsecutiveMaj + 1
            End If
        Next
        Return nbConsecutiveMaj
    End Function

    Private Function consecutiveMin(ByVal pass As String) As Integer
        Dim nbConsecutiveMin As Integer
        For x = 1 To pass.Length - 1
            If Char.IsLower(pass.ElementAt(x)) And Char.IsLower(pass.ElementAt(x - 1)) Then
                nbConsecutiveMin = nbConsecutiveMin + 1
            End If
        Next
        Return nbConsecutiveMin
    End Function

    Private Function consecutiveNum(ByVal pass As String) As Integer
        Dim nbConsecutiveNum As Integer
        For x = 1 To pass.Length - 1
            If Char.IsNumber(pass.ElementAt(x)) And Char.IsNumber(pass.ElementAt(x - 1)) Then
                nbConsecutiveNum = nbConsecutiveNum + 1
            End If
        Next
        Return nbConsecutiveNum
    End Function

    Private Function sequencialChar(ByVal pass As String) As Integer
        Dim nbSequencialChar As Integer
        For x = 1 To pass.Length - 1
            If (Asc(pass.ElementAt(x)) - Asc(pass.ElementAt(x - 1))) = 1 Then
                nbSequencialChar = nbSequencialChar + 1
            End If
        Next
        Return nbSequencialChar
    End Function

    Private Function repeatChar(ByVal pass As String) As Integer
        Dim nbRepeatChar As Integer
        For x = 1 To pass.Length - 1
            If pass.ElementAt(x) = pass.ElementAt(x - 1) Then
                nbRepeatChar = nbRepeatChar + 1
            End If
        Next
        Return nbRepeatChar
    End Function

End Module