Validation de la force d'un mot de passe

Soyez le premier à donner votre avis sur cette source.

Vue 7 193 fois - Téléchargée 928 fois

Description

Ce qui suis est un AddIns pour Excel, testé sur Excel 2003. Différentes fonctions pouvant être utilisé individuellement ou ensemble pour évaluer un mot de passe. Ce programme en VBA est inspiré d'une recherche exhaustive sur internet, ont y trouve différentes façon de valider un mot de passe, il n'y a pas vraiment de formule miracle, ce programme est donc une synthèse de ce que j'y ai trouvé.

Voici une liste et description des fonctions:

Fonction CapsCount
Calcule le nombre de lettres majuscules dans la cellule sélectionnée.
La valeur ASCII des lettres majuscules est comprise entre 65 et 90.

Fonction LowCapCount
Calcule le nombre de lettres minuscules dans la cellule sélectionnée.
La valeur ASCII des lettres minuscules est comprise entre 97 et 122.

Fonction NumberCount
Calcule le nombre de chiffres dans la cellule sélectionnée.
La valeur ASCII des chiffres est comprise entre 48 et 57.

Fonction SymbolCount
Calcule le nombre de symboles dans la cellule sélectionnée.
La valeur ASCII des symboles est comprise entre 33 et 47, 58 et 64, 91 et 96, 123 et 126.

Fonction TwoCaps
Vérifie s’il y a deux lettres majuscules consécutives dans la cellule sélectionnée.
Lorsqu'il y a une majuscule, la variable CountCap est incrémentée de 1, si le prochain caractère n'est pas une majuscule, CountCap est remis à zéro.
Lorsque la variable CountCap est égale ou supérieure à deux (deux majuscules consécutives), TwoCaps est incrémenté d’un.
2 majuscules consécutives, TwoCap est égale à 1. 3 majuscules consécutives, TwoCap est égale à 2. 4 majuscules consécutives, TwoCap est égale à 3.

Fonction TwoLowCaps
Vérifie s'il y a deux lettres majuscules consécutives dans la cellule sélectionnée.
Lorsqu'il y a une majuscule, la variable CountLowCaps est incrémentée de 1, si le prochain caractère n'est pas une minuscule, CountLowCaps est remis à zéro.
Lorsque la variable CountLowCaps est égale ou supérieure à deux (deux minuscules consécutives), TwoCaps est incrémenté d'un.
2 minuscules consécutives, TwoLowCaps est égale à 1. 3 minuscules consécutives, TwoLowCaps est égale à 2. 4 minuscules consécutives, TwoLowCaps est égale à 3.

Fonction TwoNum
Vérifie s'il y a deux chiffres consécutifs dans la cellule sélectionnée.
Lorsqu'il y a un chiffre, la variable CountNum est incrémentée de 1, si le prochain caractère n'est pas un chiffre, CountNum est remis à zéro.
Lorsque la variable CountNum est égale ou supérieure à deux (deux chiffres consécutifs), TwoCaps est incrémenté d'un.
2 chiffres consécutifs, TwoNum est égale à 1. 3 chiffres consécutifs, TwoNum est égale à 2. 4 chiffres consécutifs, TwoNum est égale à 3.

Fonction RepeatChar
Vérifie s'il y a deux caractères identiques consécutifs dans la cellule sélectionnée.
Mémorise le caractère lu.
Valide si le caractère lu est identique à celui mémorisé précédemment.
Incrémente pour chaque répétition de caractères.

Fonction IllegalChar
Vérifie s'il y a des caractères hors normes (33 à 126) dans la cellule sélectionnée.

Fonction ConsecChar
Vérifie s'il y a une chaîne croissante de lettres de plus de 3 caractères dans la cellule sélectionnée. (aBc...)
Les chiffres et caractères spéciaux sont omis de cette fonction.

Fonction revConsecChar
Vérifie s'il y a une chaîne décroissante de lettres de plus de 3 caractères dans la cellule sélectionnée. (ZyX...)
Les chiffres et caractères spéciaux sont omis de cette fonction.

Fonction ConsecNum
Vérifie s'il y a une chaîne croissante de plus de 3 chiffres dans la cellule sélectionnée. (123...)
Les lettres et caractères spéciaux sont omis de cette fonction.

Fonction revConsecNum
Vérifie s'il y a une chaîne décroissante de plus de 3 chiffres dans la cellule sélectionnée. (987...)
Les lettres et caractères spéciaux sont omis de cette fonction.

Fonction PassPercent
Convertie en pourcentage le pointage de la cellule sélectionnée sur une base d'un mot de passe de 16 caractères maximum.
Limite le résultat à 240 dans le cas d'un mot de passe ayant plus de 16 caractères
Limite le résultat à zéro dans le cas d'un pointage insuffisant en fonction du choix de caractères.
Le pointage maximum étant alors de 240, la conversion se résume donc à une règle de trois.

Fonction PassEvaluation
Affiche l'évaluation du mot de passe. Vous devez sélectionner le résultat en pointage.
Points : Pourcentage
0-46 0-19 "Très Faible" 'Very Weak
47-94 20-39 "Faible" 'Weak
95-142 40-59 "Bon" 'Good
143-190 60-79 "Fort" 'Strong
191-240 80-100 "Very Strong" 'Very Strong

Fonction MidNumSymb
Cette Fonction appelle les fonctions NumberCount et SymbolCount et vérifie s’il y a des chiffres et des caractères spéciaux au milieu du mot de passe hormis le premier et dernier caractère.

Fonction PassReq
Cette Fonction valide si les 5 paramètres minimum sont respectés.
Le mot de passe doit contenir au moins une majuscule, une minuscule, un chiffre, un caractère spécial,
et soit un chiffre ou caractère spécial au milieu du mot de passe.

Fonction PassLettersOnly
Vérifie si le mot de passe ne contient que des lettres.

Fonction PassNumOnly
Vérifie si le mot de passe ne contient que des chiffres.

Fonction PassWrdStrg
Combinaison des fonctions incluant les formules de pointages:
En Addition: CapsCount, LowCapCount, NumberCount, SymbolCount, MidNumSymb,PassReq,
En Soustraction: PassLettersOnly, PassNumOnly, RepeatChar, TwoCaps, TwoLowCaps, TwoNum, ConsecChar, revConsecChar, ConsecNum, revConsecNum.

Fonction PassWrdStrgSymb
Combinaison des fonctions incluant les formules de pointages:
En Addition: CapsCount, LowCapCount, NumberCount, SymbolCount, MidNumSymb,PassReq,
En Soustraction: PassLettersOnly, PassNumOnly, RepeatChar, TwoCaps, TwoLowCaps, TwoNum, ConsecChar, revConsecChar, ConsecNum, revConsecNum, ConsecSymb, RevConsecSymb

Fonction CombProb - ANALYSE COMBINATOIRE - ARRANGEMENTS AVEC RÉPÉTITION
Calcule la probabilité des combinaisons possibles avec tous les types de caractères utilisés dans le mot de passe.

Fonction CombProbUni - ANALYSE COMBINATOIRE - COMBINAISONS SIMPLES SANS RÉPÉTITION
Calcule la probabilité des combinaisons possibles avec le nombre de caractères utilisés dans le mot de passe
à la condition que chacun des caractères ne soit utilisé qu'une seule fois. Même principe de calcule que la lotterie.
Cette fonction est la même que COMBIN(number,number_chosen) retrouvé dans EXCEL.
Dans cette fonction, number correspond au type de caractères choisi (FNum) et number_choosen (LEN(avar)à la longueur du mot de passe.
Il est à noter que le mot de passe ne contient que des chiffres, le résultat sera de 1, ceci est du au fait que si vous entrez un mot de passe de plus de 10 caractères, la fonction génèrerait une erreur du fait que 0 à 9 = 10 caractères uniques...

Fonction ConsecSymb
Vérifie s'il y a une chaîne croissante de symboles dans la cellule sélectionnée en fonction de leurs valeurs ASCII. (!"#$%&'() etc.)
Les chiffres et lettres sont omis de cette fonction.

Fonction RevConsecSymb
Vérifie s'il y a une chaîne décroissante de symboles dans la cellule sélectionnée en fonction de leurs valeurs ASCII. (/.-,+*)('&% etc.)
Les chiffres et lettres sont omis de cette fonction.

Source / Exemple :


Function CapsCount(avar)
'**********************************************************************************************************************
'Fonction CapsCount
'Calcule le nombre de lettres majuscules dans la cellule sélectionnée.
'La valeur ASCII des lettres majuscules est comprise entre 65 et 90.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 65 And Asc(Mid(avar, N, 1)) <= 90 Then CapsCount = CapsCount + 1
Next
End Function
Function LowCapCount(avar)
'**********************************************************************************************************************
'Fonction LowCapCount
'Calcule le nombre de lettres minuscules dans la cellule sélectionnée.
'La valeur ASCII des lettres minuscules est comprise entre 97 et 122.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 97 And Asc(Mid(avar, N, 1)) <= 122 Then LowCapCount = LowCapCount + 1
Next
End Function
Function NumberCount(avar)
'**********************************************************************************************************************
'Fonction NumberCount
'Calcule le nombre de chiffres dans la cellule sélectionnée.
'La valeur ASCII des chiffres est comprise entre 48 et 57.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 48 And Asc(Mid(avar, N, 1)) <= 57 Then NumberCount = NumberCount + 1
Next
End Function
Function SymbolCount(avar)
'**********************************************************************************************************************
'Fonction SymbolCount
'Calcule le nombre de symboles dans la cellule sélectionnée.
'La valeur ASCII des symboles est comprise entre 33 et 47, 58 et 64, 91 et 96, 123 et 126.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 47 Then SymbolCount = SymbolCount + 1
   If Asc(Mid(avar, N, 1)) >= 58 And Asc(Mid(avar, N, 1)) <= 64 Then SymbolCount = SymbolCount + 1
   If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then SymbolCount = SymbolCount + 1
   If Asc(Mid(avar, N, 1)) >= 123 And Asc(Mid(avar, N, 1)) <= 126 Then SymbolCount = SymbolCount + 1
Next
End Function
Function TwoCaps(avar)
'**********************************************************************************************************************
'Fonction TwoCaps
'Vérifie s 'il y a deux lettres majuscules consécutives dans la cellule sélectionnée.
'Lorsqu'il y a une majuscule, la variable CountCap est incrémentée de 1, si le prochain caractère n'est pas une majuscule, CountCap est remis à zéro.
'Lorsque la variable CountCap est égale ou supérieure à deux (deux majuscules consécutives), TwoCaps est incrémenté d'un.
'2 majuscules consécutives, TwoCap est égale à 1. 3 majuscules consécutives, TwoCap est égale à 2. 4 majuscules consécutives, TwoCap est égale à 3.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 65 And Asc(Mid(avar, N, 1)) <= 90 Then CountCap = CountCap + 1 Else CountCap = 0
   If CountCap >= 2 Then TwoCaps = TwoCaps + 1
Next
End Function
Function TwoLowCaps(avar)
'**********************************************************************************************************************
'Fonction TwoLowCaps
'Vérifie s'il y a deux lettres majuscules consécutives dans la cellule sélectionnée.
'Lorsqu'il y a une majuscule, la variable CountLowCaps est incrémentée de 1, si le prochain caractère n'est pas une minuscule, CountLowCaps est remis à zéro.
'Lorsque la variable CountLowCaps est égale ou supérieure à deux (deux minuscules consécutives), TwoCaps est incrémenté d'un.
'2 minuscules consécutives, TwoLowCaps est égale à 1. 3 minuscules consécutives, TwoLowCaps est égale à 2. 4 minuscules consécutives, TwoLowCaps est égale à 3.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 97 And Asc(Mid(avar, N, 1)) <= 122 Then CountLowCaps = CountLowCaps + 1 Else CountLowCaps = 0
   If CountLowCaps >= 2 Then TwoLowCaps = TwoLowCaps + 1
Next
End Function
Function TwoNum(avar)
'**********************************************************************************************************************
'Fonction TwoNum
'Vérifie s'il y a deux chiffres consécutifs dans la cellule sélectionnée.
'Lorsqu'il y a un chiffre, la variable CountNum est incrémentée de 1, si le prochain caractère n'est pas un chiffre, CountNum est remis à zéro.
'Lorsque la variable CountNum est égale ou supérieure à deux (deux chiffres consécutifs), TwoCaps est incrémenté d'un.
'2 chiffres consécutifs, TwoNum est égale à 1. 3 chiffres consécutifs, TwoNum est égale à 2. 4 chiffres consécutifs, TwoNum est égale à 3.
'**********************************************************************************************************************
For N = 1 To Len(avar)
   If Asc(Mid(avar, N, 1)) >= 48 And Asc(Mid(avar, N, 1)) <= 57 Then CountNum = CountNum + 1 Else CountNum = 0
   If CountNum >= 2 Then TwoNum = TwoNum + 1
Next
End Function
Function RepeatChar(avar)
'**********************************************************************************************************************
'Fonction RepeatChar
'Vérifie s'il y a deux caractères identiques consécutifs dans la cellule sélectionnée.
'**********************************************************************************************************************
For p = 33 To 126 'Valide les caractères utiles de 33 à 126.
    For N = 1 To Len(avar)
       If Asc(Mid(avar, N, 1)) >= 65 And Asc(Mid(avar, N, 1)) <= 90 Then aConvertToLow = Asc(Mid(avar, N, 1)) + 32 'Lettre majuscule convertie en minuscule.
       If Asc(Mid(avar, N, 1)) >= 97 And Asc(Mid(avar, N, 1)) <= 122 Then aConvertToLow = Asc(Mid(avar, N, 1))
       If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 47 Then aConvertToLow = Asc(Mid(avar, N, 1))
       If Asc(Mid(avar, N, 1)) >= 58 And Asc(Mid(avar, N, 1)) <= 64 Then aConvertToLow = Asc(Mid(avar, N, 1))
       If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then aConvertToLow = Asc(Mid(avar, N, 1))
       If Asc(Mid(avar, N, 1)) >= 123 And Asc(Mid(avar, N, 1)) <= 126 Then aConvertToLow = Asc(Mid(avar, N, 1))
       If Asc(Mid(avar, N, 1)) >= 48 And Asc(Mid(avar, N, 1)) <= 57 Then aConvertToLow = Asc(Mid(avar, N, 1))
       aChar = aConvertToLow 'Mémorise le caractère lu.
       If aChar = p Then countp = countp + 1 'Valide si le caractère lu est identique à celui mémorisé précédemment.
    Next
       If countp > 1 Then RepeatChar = RepeatChar + countp 'Incrémente pour chaque répétition de caractères.
       countp = 0
Next
End Function
Function IllegalChar(avar) As String
'**********************************************************************************************************************
'Fonction IllegalChar
'Vérifie s'il y a des caractères hors normes (33 à 126) dans la cellule sélectionnée.
'**********************************************************************************************************************
For N = 1 To Len(avar)
    If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 126 Then IllegalChar = "Caractères légaux" Else IllegalChar = "Caractères illégaux"
Next
End Function
Function ConsecChar(avar)
'**********************************************************************************************************************
'Fonction ConsecChar
'Vérifie s'il y a une chaîne croissante de lettres dans la cellule sélectionnée. (aBc...)
'Les chiffres et caractères spéciaux sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
        If Asc(Mid(avar, N, 1)) >= 65 And Asc(Mid(avar, N, 1)) <= 90 Then aConvertToLow = Asc(Mid(avar, N, 1)) + 32 'Lettre majuscule convertie en minuscule.
        If Asc(Mid(avar, N, 1)) >= 97 And Asc(Mid(avar, N, 1)) <= 122 Then aConvertToLow = Asc(Mid(avar, N, 1))
        aChar = aConvertToLow
        If Asc(Mid(avar, N, 1)) < 65 Then countp = 0
        If Asc(Mid(avar, N, 1)) > 122 Then countp = 0
        If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then countp = 0
        If aChar = bChar + 1 Then countp = countp + 1 Else countp = 0
        bChar = aChar
        If countp >= 2 Then ConsecChar = ConsecChar + 1
Next
End Function
Function RevConsecChar(avar)
'**********************************************************************************************************************
'Fonction RevConsecChar
'Vérifie s'il y a une chaîne décroissante de lettres dans la cellule sélectionnée. (ZyX...)
'Les chiffres et caractères spéciaux sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
        If Asc(Mid(avar, N, 1)) >= 65 And Asc(Mid(avar, N, 1)) <= 90 Then aConvertToLow = Asc(Mid(avar, N, 1)) + 32 'Lettre majuscule convertie en minuscule.
        If Asc(Mid(avar, N, 1)) >= 97 And Asc(Mid(avar, N, 1)) <= 122 Then aConvertToLow = Asc(Mid(avar, N, 1))
        aChar = aConvertToLow
        If Asc(Mid(avar, N, 1)) < 65 Then countp = 0
        If Asc(Mid(avar, N, 1)) > 122 Then countp = 0
        If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then countp = 0
        If aChar = bChar - 1 Then countp = countp + 1 Else countp = 0
        bChar = aChar
        If countp >= 2 Then RevConsecChar = RevConsecChar + 1
Next
End Function
Function ConsecNum(avar)
'**********************************************************************************************************************
'Fonction ConsecNum
'Vérifie s'il y a une chaîne croissante de chiffres dans la cellule sélectionnée. (123...)
'Les lettres et caractères spéciaux sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
        If Asc(Mid(avar, N, 1)) >= 48 And Asc(Mid(avar, N, 1)) <= 57 Then aConvertToLow = Asc(Mid(avar, N, 1))
        aNum = aConvertToLow
        If Asc(Mid(avar, N, 1)) < 48 Then countp = 0
        If Asc(Mid(avar, N, 1)) > 57 Then countp = 0
        If aNum = bNum + 1 Then countp = countp + 1 Else countp = 0
        bNum = aNum
        If countp >= 2 Then ConsecNum = ConsecNum + 1
Next
End Function
Function RevConsecNum(avar)
'**********************************************************************************************************************
'Fonction RevConsecNum
'Vérifie s'il y a une chaîne décroissante de chiffres dans la cellule sélectionnée. (987...)
'Les lettres et caractères spéciaux sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
        If Asc(Mid(avar, N, 1)) >= 48 And Asc(Mid(avar, N, 1)) <= 57 Then aConvertToLow = Asc(Mid(avar, N, 1))
        aNum = aConvertToLow
        If Asc(Mid(avar, N, 1)) < 48 Then countp = 0
        If Asc(Mid(avar, N, 1)) > 57 Then countp = 0
        If aNum = bNum - 1 Then countp = countp + 1 Else countp = 0
        bNum = aNum
        If countp >= 2 Then RevConsecNum = RevConsecNum + 1
Next
End Function
Function PassPercent(result As Integer)
'**********************************************************************************************************************
'Fonction PassPercent
'Convertie en pourcentage le pointage de la cellule sélectionnée sur une base d'un mot de passe de 16 caractères maximum.
'Limite le résultat à 240 dans le cas d'un mot de passe ayant plus de 16 caractères
'Limite le résultat à zéro dans le cas d'un pointage insuffisant en fonction du choix de caractères.
'Le pointage maximum étant alors de 240, la conversion se résume donc à une règle de trois.
'**********************************************************************************************************************
    If result > 240 Then result = 240
    If result < 0 Then result = 0
    PassPercent = result * 100 / 240
End Function
Function PassEvaluation(result As Integer) As String
'**********************************************************************************************************************
'Fonction PassEvaluation
'Affiche l'évaluation du mot de passe. Vous devez sélectionner le résultat en pointage.
'Points : Pourcentage
'0-46       0-19    "Très Faible" 'Very Weak
'47-94      20-39   "Faible" 'Weak
'95-142     40-59   "Bon" 'Good
'143-190    60-79   "Fort" 'Strong
'191-240    80-100  "Very Strong" 'Very Strong
'**********************************************************************************************************************
    PassEval = PassPercent(result)
    If PassEval >= 0 Then PassEvaluation = "Très Faible" 'Very Weak
    If PassEval >= 20 Then PassEvaluation = "Faible" 'Weak
    If PassEval >= 40 Then PassEvaluation = "Bon" 'Good
    If PassEval >= 60 Then PassEvaluation = "Fort" 'Strong
    If PassEval >= 80 Then PassEvaluation = "Très Fort" 'Very Strong
End Function
Function MidNumSymb(avar)
'**********************************************************************************************************************
'Fonction MidNumSymb
'Cette Fonction appelle les fonctions NumberCount et SymbolCount et vérifie s'il y a des chiffres et des caractères spéciaux
'au milieu du mot de passe hormis le premier et dernier caractère.
'**********************************************************************************************************************
    If Len(avar) > 2 Then MidNumSymb = NumberCount(Mid(avar, 2, Len(avar) - 2)) + SymbolCount(Mid(avar, 2, Len(avar) - 2))
End Function
Function PassReq(avar)
'**********************************************************************************************************************
'Fonction PassReq
'Cette Fonction valide si les 5 paramètres minimum sont respectés.
'Le mot de passe doit contenir au moins une majuscule, une minuscule, un chiffre, un caractère spécial,
'et soit un chiffre ou caractère spécial au milieu du mot de passe.
'**********************************************************************************************************************
    If CapsCount(avar) > 0 Then PassReqCount = PassReqCount + 1
    If LowCapCount(avar) > 0 Then PassReqCount = PassReqCount + 1
    If NumberCount(avar) > 0 Then PassReqCount = PassReqCount + 1
    If SymbolCount(avar) > 0 Then PassReqCount = PassReqCount + 1
    If MidNumSymb(avar) > 0 Then PassReqCount = PassReqCount + 1
    If PassReqCount = 5 Then PassReq = 5
End Function
Function PassLettersOnly(avar)
'**********************************************************************************************************************
'Fonction PassLettersOnly
'Vérifie si le mot de passe ne contient que des lettres.
'**********************************************************************************************************************
    If NumberCount(avar) = 0 Then PLO = PLO + 1
    If SymbolCount(avar) = 0 Then PLO = PLO + 1
    If PLO = 2 Then PassLettersOnly = Len(avar)
End Function
Function PassNumOnly(avar)
'**********************************************************************************************************************
'Fonction PassNumOnly
'Vérifie si le mot de passe ne contient que des chiffres.
'**********************************************************************************************************************
    If CapsCount(avar) = 0 Then PNO = PNO + 1
    If LowCapCount(avar) = 0 Then PNO = PNO + 1
    If SymbolCount(avar) = 0 Then PNO = PNO + 1
    If PNO = 3 Then PassNumOnly = Len(avar)
End Function
Function PassWrdStrg(avar)
'**********************************************************************************************************************
'Fonction PassWrdStrg
'Combinaison des fonctions incluant les formules de pointages:
'En Addition: CapsCount, LowCapCount, NumberCount, SymbolCount, MidNumSymb,PassReq,
'En Soustraction: PassLettersOnly, PassNumOnly, RepeatChar, TwoCaps, TwoLowCaps, TwoNum, ConsecChar, revConsecChar, ConsecNum, revConsecNum.
'**********************************************************************************************************************
    PassStrg = PassStrg + (Len(avar) * 4)
    If CapsCount(avar) > 0 Then PassStrg = PassStrg + ((Len(avar) - CapsCount(avar)) * 2)
    If LowCapCount(avar) > 0 Then PassStrg = PassStrg + ((Len(avar) - LowCapCount(avar)) * 2)
    PassStrg = PassStrg + (NumberCount(avar) * 4)
    PassStrg = PassStrg + (SymbolCount(avar) * 6)
    PassStrg = PassStrg + (MidNumSymb(avar) * 2)
    PassStrg = PassStrg + (PassReq(avar) * 2)
    PassStrg = PassStrg - PassLettersOnly(avar)
    PassStrg = PassStrg - PassNumOnly(avar)
    PassStrg = PassStrg - (RepeatChar(avar) * (RepeatChar(avar) - 1))
    PassStrg = PassStrg - (TwoCaps(avar) * 2)
    PassStrg = PassStrg - (TwoLowCaps(avar) * 2)
    PassStrg = PassStrg - (TwoNum(avar) * 2)
    PassStrg = PassStrg - ((ConsecChar(avar) + RevConsecChar(avar)) * 6)
    PassStrg = PassStrg - ((ConsecNum(avar) + RevConsecNum(avar)) * 6)
    If PassStrg < 0 Then PassStrg = 0
    PassWrdStrg = PassStrg
End Function
Function PassWrdStrgSymb(avar)
'**********************************************************************************************************************
'Fonction PassWrdStrg
'Combinaison des fonctions incluant les formules de pointages:
'En Addition: CapsCount, LowCapCount, NumberCount, SymbolCount, MidNumSymb,PassReq,
'En Soustraction: PassLettersOnly, PassNumOnly, RepeatChar, TwoCaps, TwoLowCaps, TwoNum, ConsecChar, revConsecChar, ConsecNum, revConsecNum, ConsecSymb, RevConsecSymb.
'**********************************************************************************************************************
    PassStrg = PassStrg + (Len(avar) * 4)
    If CapsCount(avar) > 0 Then PassStrg = PassStrg + ((Len(avar) - CapsCount(avar)) * 2)
    If LowCapCount(avar) > 0 Then PassStrg = PassStrg + ((Len(avar) - LowCapCount(avar)) * 2)
    PassStrg = PassStrg + (NumberCount(avar) * 4)
    PassStrg = PassStrg + (SymbolCount(avar) * 6)
    PassStrg = PassStrg + (MidNumSymb(avar) * 2)
    PassStrg = PassStrg + (PassReq(avar) * 2)
    PassStrg = PassStrg - PassLettersOnly(avar)
    PassStrg = PassStrg - PassNumOnly(avar)
    PassStrg = PassStrg - (RepeatChar(avar) * (RepeatChar(avar) - 1))
    PassStrg = PassStrg - (TwoCaps(avar) * 2)
    PassStrg = PassStrg - (TwoLowCaps(avar) * 2)
    PassStrg = PassStrg - (TwoNum(avar) * 2)
    PassStrg = PassStrg - ((ConsecSymb(avar) + RevConsecSymb(avar)) * 6)
    PassStrg = PassStrg - ((ConsecChar(avar) + RevConsecChar(avar)) * 6)
    PassStrg = PassStrg - ((ConsecNum(avar) + RevConsecNum(avar)) * 6)
    If PassStrg < 0 Then PassStrg = 0
    PassWrdStrgSymb = PassStrg
End Function

Function CombProb(avar)
'**********************************************************************************************************************
'Fonction CombProb - ANALYSE COMBINATOIRE - ARRANGEMENTS AVEC RÉPÉTITION
'Calcule la probabilité des combinaisons possibles avec tous les types de caractères utilisés dans le mot de passe.
'**********************************************************************************************************************
    If CapsCount(avar) > 0 Then Fnum = Fnum + 26
    If LowCapCount(avar) > 0 Then Fnum = Fnum + 26
    If NumberCount(avar) > 0 Then Fnum = Fnum + 10
    If SymbolCount(avar) > 0 Then Fnum = Fnum + 32
    If Fnum = 0 Then Fnum = 1
    CombProb = (Application.WorksheetFunction.Power(Fnum, Len(avar)))
End Function
Function CombProbUni(avar)
'**********************************************************************************************************************
'Fonction CombProbUni - ANALYSE COMBINATOIRE - COMBINAISONS SIMPLES SANS RÉPÉTITION
'Calcule la probabilité des combinaisons possibles avec le nombre de caractères utilisés dans le mot de passe
'à la condition que chacun des caractères ne soit utilisé qu'une seule fois. Même principe de calcule que la lotterie.
'Cette fonction est la même que COMBIN(number,number_chosen) retrouvé dans EXCEL.
'Dans cette fonction, number correspond au type de caractères choisi (FNum) et number_choosen (LEN(avar)à la longueur du mot de passe.
'Il est à noter que le mot de passe ne contient que des chiffres, le résultat sera de 1, ceci est du au fait que si vous entrez
'un mot de passe de plus de 10 caractères, la fonction génèrerait une erreur du fait que 0 à 9 = 10 caractères uniques...
'**********************************************************************************************************************
    If CapsCount(avar) > 0 Then Fnum = Fnum + 26
    If LowCapCount(avar) > 0 Then Fnum = Fnum + 26
    If NumberCount(avar) > 0 Then Fnum = Fnum + 10
    If SymbolCount(avar) > 0 Then Fnum = Fnum + 32
    If Fnum = 10 Then Fnum = Len(avar)
    CombProbUni = (Application.WorksheetFunction.Fact(Fnum) / (Application.WorksheetFunction.Fact(Fnum - Len(avar)) * Application.WorksheetFunction.Fact(Len(avar))))
End Function
Function ConsecSymb(avar)
'**********************************************************************************************************************
'Fonction ConsecSymb
'Vérifie s'il y a une chaîne croissante de symboles dans la cellule sélectionnée en fonction de leurs valeurs ASCII. (!"#$%&'() etc.)
'Les chiffres et lettres sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
    If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 47 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   !"#$%&'()*+,-./
    If Asc(Mid(avar, N, 1)) >= 58 And Asc(Mid(avar, N, 1)) <= 64 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   :;<=>?@
    If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   [\]^_`
    If Asc(Mid(avar, N, 1)) >= 123 And Asc(Mid(avar, N, 1)) <= 126 Then SymbolConsec = Asc(Mid(avar, N, 1)) 'Caratères spéciaux   
        aChar = SymbolConsec
    If Asc(Mid(avar, N, 1)) > 47 And Asc(Mid(avar, N, 1)) < 58 Then countp = 0  'Élimination des Chiffres
    If Asc(Mid(avar, N, 1)) > 64 And Asc(Mid(avar, N, 1)) < 91 Then countp = 0  'Élimination des Majuscules
    If Asc(Mid(avar, N, 1)) > 96 And Asc(Mid(avar, N, 1)) < 123 Then countp = 0 'Élimination des Minuscules
        If aChar = bChar + 1 Then countp = countp + 1 Else countp = 0
        bChar = aChar
    If countp >= 2 Then ConsecSymb = ConsecSymb + 1
Next
End Function
Function RevConsecSymb(avar)
'**********************************************************************************************************************
'Fonction RevConsecSymb
'Vérifie s'il y a une chaîne décroissante de symboles dans la cellule sélectionnée en fonction de leurs valeurs ASCII. (/.-,+*)('&% etc.)
'Les chiffres et lettres sont omis de cette fonction.
'**********************************************************************************************************************
For N = 1 To Len(avar)
    If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 47 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   !"#$%&'()*+,-./
    If Asc(Mid(avar, N, 1)) >= 58 And Asc(Mid(avar, N, 1)) <= 64 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   :;<=>?@
    If Asc(Mid(avar, N, 1)) >= 91 And Asc(Mid(avar, N, 1)) <= 96 Then SymbolConsec = Asc(Mid(avar, N, 1))   'Caratères spéciaux   [\]^_`
    If Asc(Mid(avar, N, 1)) >= 123 And Asc(Mid(avar, N, 1)) <= 126 Then SymbolConsec = Asc(Mid(avar, N, 1)) 'Caratères spéciaux   {
~ aChar = SymbolConsec If Asc(Mid(avar, N, 1)) > 47 And Asc(Mid(avar, N, 1)) < 58 Then countp = 0 'Élimination des Chiffres If Asc(Mid(avar, N, 1)) > 64 And Asc(Mid(avar, N, 1)) < 91 Then countp = 0 'Élimination des Majuscules If Asc(Mid(avar, N, 1)) > 96 And Asc(Mid(avar, N, 1)) < 123 Then countp = 0 'Élimination des Minuscules If aChar = bChar - 1 Then countp = countp + 1 Else countp = 0 bChar = aChar If countp >= 2 Then RevConsecSymb = RevConsecSymb + 1 Next End Function

Conclusion :


Dans le fichier "Password Meter ver 2.0912 rev 1001.zip", vous retrouverez le Module ainsi qu'un fichier demo.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
202
Date d'inscription
vendredi 27 janvier 2006
Statut
Membre
Dernière intervention
29 janvier 2019

Si le site accepte autre chose que les caractères ASCII, et accepte l'Unicode, pensez par exemple à charger dans la barre de langues un clavier non latin (si possible non alphabétique et non basé sur une translitération du latin: arabe, hébreu, hindi), et tapez votre mot de passe en changeant temporairement la disposition du clavier, pour que cela génère des séquences illisibles qui ne sont pas de simples translitérations: testez la frappe de votre phrase dans le bloc-notes, assurez-vous que ce ne soit pas non plus une véritable gymnastique sinon le risque d'erreur sera important et vous aurez toujours à reconsulter vos notes secrètes, ou bien on pourra lire ce que vous frappez.

Autre idée: vous pouvez aussi utiliser MSKLC pour modifier votre clavier standard afin d'y ajouter un ou deux "jolis" caractères symboliques (Wingdings, signes typographiques rares), sans avoir à basculer de langue temporairement avec la barre de langue (des signes que vous pourrez alors inclure dans vos mots de passe Unicode). Recherchez ces caractères avec Charmap et une police "riche" (comme 'Segoe UI', ou Arial Unicode si vous avez Office). Testez ces caractères d'abord en essayant de vous les envoyez par email via un compte webmail (par exemple Gmail), afin de vous assurer que votre clavier fonctionne de façon correcte avec des sites connus et raisonnablement fiables, mais aussi avec les réglages de votre/vois navigateurs (y compris sur votre smartphone si vous voulez recevoir les mots de passe par SMS en cas d'oubli).

N'hésitez pas non plus sur un nouveau site à tester les possibilités de mots de passe autorisés et fonctions de renvoi de mots de passe oublié avant d'y confier vos données sensibles : passez un peu de temps dans vos préférences en ligne, et vérifiez plusieurs fois vos options de confidentialité (notamment sur FaceBook, qui veut tout partager avec un nombre d'amis et d'amis d'amis beaucoup trop important ; Facebook est le PIRE de tous les sites que j'ai jamais vu pour la confidentialité : une horreur à paramétrer, ses options de partage par défaut sont très mauvaises, les options de visibilité par "seulement moi-même" sont accessibles et disponibles uniquement en mode avancé dans un sous-dialogue, à rechercher pour chacune de ses nombreuses fonctions, et il faut constamment retourner dans les préférences pour voir si de nouveaux partages d'infos ont été activés sans que vous en ayez conscience, d'autant plus qu'il veut absolument que vous soyez y identifié avec votre nom réel, et toutes sortes d'indices sur vous que tout le monde n'a pas à connaitre !).
Messages postés
202
Date d'inscription
vendredi 27 janvier 2006
Statut
Membre
Dernière intervention
29 janvier 2019

Les bons mots de passe, assez longs mais encore mnémotechniques sont en général définis comme des "pass phrases", c'est-à-dire composés de phrases ayant un sens pour l'utilisateur et pouvant éventuellement fournir la question à une réponse donnée, ou bien étant une réponse figurée/imagée à une question posée (mais où la réponse est connue de l'utilisateur, et imagée selon une analogie, une maxime, un élément culturel, que comprend l'utilisateur et qui est alors associée intimement aux mots. Ce peut être par exemple la réponse en trois mots qui n'ont rien à voir entre eux, à trois questions posées comme des définitions de mot croisés, ces questions étant un peu habilement posées comme si c'était une phrase un peu étrange mais signifiante pour l'utilisateur (de sorte que les autres ne verront pas l'image et chercheront une réponse littérale).

À cela, l'utilisateur peut aussi ajouter quelques caractères ou conventions ne figurant pas dans la question posée, mais définie habituellement dans ses mots de passe. La langue (ou l'orthographe) utilisée peut aussi aider: penser à inclure un mot dans un style Leets, ou SMS (pas forcément dans tous les mots de la réponse), et à créer un moyen permettant de varier les mots de passe en fonction du site demandeur (ne pas mettre son mot de passe personnel identique entre tous les sites, notamment les sites hautement ciblés par les attaques comme Gmail, Yahoo, Facebook, MSN/Live.

Pour vos comptes bancaires en ligne, utilisez les mots de passe recommandés par votre banque, et gardez-les en lieu sûr en supprimant le document à l'entête de la banque et en le notant ailleurs dans un agenda de l'année passée, au milieu de notes, sous une forme déguisée dans des pages déjà bien remplies (si le mot de passe est numérique, par exemple piochez un nom au hasard dans l'annuaire, d'une personne que vous ne connaissez pas et saurez reconnaitre facilement parmi les autres nombreux noms, et notez la comme si c'était certains chiffres d'un numéro de téléphone mobile, d'un code de porte d'entrée, une date ou heure de rendez-vous, un prix réaliste pour un produit courant du marché qui ne vous intéresse habituellement pas...

Ne planquez pas trop ce calepin, mettez le plutôt parmi vos "paperasses" d'usage courant ou restant à classer, et pas dans un endroit saugrenu (dans le frigo par exemple) où il risquerait en plus d'être détruit pas accident. Pour les étudiants, pensez à vos notes de cours de l'an passé vous aurez bien un cahier bien rempli avec des tas de gribouillis, et notes persos, ou autres exercices, mais pas trop encombrant pour que vous puissiez le garder en relativement bon état, rappelez-vous juste du sujet du cours, trouvez un gribouillis sur une page que vous aimez bien... Petit à petit vous retiendrez une bonne méthode pour retrouver plus facilement le mot de passe par un raisonnement cohérent, en vous passant même de ces notes, que vous pourrez sécuriser davantage, tout en augmentant raisonnablement la complexité de vos mots de passe.

Ne vous précipitez pas tout de suite vers un mot de passe compliqué que vous ne retiendrez pas. Augmentez en la complexité après avoir bien mémorisé celui de base. Vous pouvez aussi utiliser un mot de passe connu par coeur complété d'un mot de passe spécifique pour le site que vous noterez (ne noter que cette seconde partie). Mais ne réutilisez jamais vos mots de passe très sensibles (et d'usage plus rare et strictement personnel) avec ceux de sites sociaux en ligne (notamment les forums). Si un nouveau site vous propose la connexion avec OpenID, utilisez la: ça évite de fournir un mot de passe connu directement à ce site dont vous ne connaissez pas encore le niveau de confiance, mais n'utilisez pas non plus le mot de passe de votre compte email principal (celui que vous utilisez pour vos communications les plus privées avec des sites importants).
Messages postés
202
Date d'inscription
vendredi 27 janvier 2006
Statut
Membre
Dernière intervention
29 janvier 2019

Bogue dans la fonction:

Function IllegalChar(avar) As String
'**********************************************************************************************************************
'Fonction IllegalChar
'Vérifie s'il y a des caractères hors normes (33 à 126) dans la cellule sélectionnée.
'**********************************************************************************************************************
For N = 1 To Len(avar)
If Asc(Mid(avar, N, 1)) >= 33 And Asc(Mid(avar, N, 1)) <= 126 Then IllegalChar = "Caractères légaux" Else IllegalChar = "Caractères illégaux"
Next
End Function

En effet, elle retourne dans IllegalChar uniquement le statut du DERNIER caractère dans le paramètre, et ne positionne pas la variable si le mot de passe est vide...

La fonction devrait être :

Function IllegalChar(avar) As String
'**********************************************************************************************************************
'Fonction IllegalChar
'Vérifie s'il y a des caractères hors normes (33 à 126) dans la cellule sélectionnée.
'**********************************************************************************************************************
IllegalChar = "Caractères légaux"
For N = 1 To Len(avar)
If Asc(Mid(avar, N, 1)) < 33 Or Asc(Mid(avar, N, 1)) > 126 Then IllegalChar = "Caractères illégaux"
Next
End Function

Et d'une façon générale, il y a trop de variables globales dans tout ce programme, les variables locales (de contrôle de boucles par exemple) devraient être toutes locales dans les fonctions.

Trop de fonctions également, qui parcourent cent fois la chaine, et emploient Mid() avec trop de répétition pour scanner la chaine et allouer et copier des nouvelles sous-chaines de 1 caractère pour finalement utiliser Asc() encore pour en extraire le code. Toutes ces boucles qui parcourent la chaine du début à la fin devraient être factorisées dans la même boucle "For N = 1 To Len(avar) ... Next", alors qu'il suffirait de déclarer un seul objet contenant les différents compteurs d'évaluation en tant que membre, avec une fonction contructeur prenant le mot de passe et effectuant l'analyse une fois avec une méthode statique publique référençant l'instance d'objet en paramètre qui sera mise à jour, puis consultée avec des méthodes d'instance publiques retournant la valeur du type d'évaluation demandée: même écrit comme ça, le code serait beaucoup moins long, et plus propre à réutiliser.
D'autres évaluations manquent, comme une fonction vérifiant certaines valeurs connues de mots de passe par défaut, depuis une ébauche de dictionnaire (par exemple "admin", "root", "pass", "password", "0000", "1234" sont détectés comme faibles, mais il y en a plein d'autres à considérer, en ignorant aussi les différences de casse et d'accents avec une collation de niveau 1 pour les mots courants de cette langue pour cette recherche), en ajoutant aussi ceux qui sont fonction de la locale courante de l'utilisateur (sa langue, et l'anglais souvent en fallback) ou celle du projet su site, de son nom ou pseudonyme sur le projet, et du nom du projet ou site pour lequel un mot de passe est demandé.
Il n'est pas inutile de consulter les codes sources de certains Password-crackers pour savoir comment ils peuvent trouver un mot de passe en quelques millisecondes. A mon avis, l'évaluation devrait consister plutôt à utiliser un de ces password-crackers connus (dont les sources sont largement disponibles sur Linux/Unix et Windows), en analysant le nombre de combinaisons (ou le temps) qu'ils ont essayé avant de trouver le mot de passe.
C'est ce que Google a fait sur son site pour renseigner les utilisateurs sur la sécurité relative du mot de passe de leur compte personnel pour Gmail, iGoogle, Google Docs, Google Groups, Google Gears, au moment où ils définissent leur mot de passe sur ce compte; cette évaluation devrait aussi être réeffectuée avec le temps et si le site stockant les mots de passe change de politique et décide de renforcer les seuils ou doit palier à des attaques en prévenant les utilisateurs d'un problème potentiel sur un mot de passe moyen devenu faible ou la cible d'attaques...
Messages postés
4
Date d'inscription
vendredi 24 juillet 2009
Statut
Membre
Dernière intervention
15 janvier 2010

Bonjour à tous,

US_30, j'ai finalement fait l'ajout des Fonctions : PassWrdStrgSymb, ConsecSymb et RevConsecSymb.
Avec cette suite de caractères "!"#$%&'()*+,-./01" ont obtient sans les nouvelles fonctions 194 - Très Fort et avec les nouvelles fonctions 116 - Bon.

La différence en comparaison avec "ABCDEFGHIJKLMNOP" qui lui obtiens un score à 0 est dans le système de pointage de SymbolCount =(n*6) et de MidNumSymb = (n*2) comparativement aux chiffres et lettres qui ont un pointage moindre.

Dans la fonction PassWrdStrgSymb, ont pourrait rétablir l'équilibre en diminuant le poids du multiplicateur a 2.

PassStrg PassStrg + (SymbolCount(avar) * 6) 'deviendrait PassStrg PassStrg + (SymbolCount(avar) * 2)

Avec cette seule modification, le résultat tomberait à 56 - Faible.
J'avais déjà mis en ligne ma révision du programme lorsque j'ai eu cette dernière idée, si tu crois que cela en vaux la peine je ferai une nouvelle mise à jour.

Donc en résumé, les deux fonctions PassWrdStrg (194) et PassWrdStrgSymb (116) sont disponibles, les gens n'auront qu'à choisir celle qui leur convient.

Cordialement,
DanielGT
Messages postés
2065
Date d'inscription
lundi 11 avril 2005
Statut
Membre
Dernière intervention
14 mars 2016
8
Bonjour à tous,

DanielGT, je comprends bien ta position... tu penses d'abord aux mots de passe qu'humainement on pourrait faire pour en donner une évaluation... La suite ASCII avec des caractères non alphabétiques représentent alors pour toi une chose qu'un humain ne peut (ne voudra ou ne sera) pas faire comme mot de passe. Mais c'est pourtant avec ces derniers qu'on obtient la meilleure évaluation... d'où une forme de "paradoxe"...

Pour l'exemple que j'indiquais, j'ai précisé "si c'est un programme qui tente de casser un mot de passe", donc un extension à ce que tu imagines (ce n'est plus humain)... mais on casse rarement un mot de passe autrement que par un programme... De plus, que ce soit un programme ou pas, si l'évaluation accorde trop d'importance aux caractères spéciaux, alors cela veut aussi dire que ces derniers deviennent des caractères privilégiés, donc restreint la recherche du mot de passe avec ces derniers (ou les rends plus probables)... Bref, J'insisterai pas plus.

Pour l'histoire des claviers, cela serait une bonne chose t'en tenir compte, comme tu le dis...

Néanmoins, je reste sur mon 10/10... même si je pense qu'on peut essayer d'aller plus loin, cela reste une bonne base. Bravo et merci.

Amicalement,
Us.
Afficher les 15 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.