Regex pour valider la force du mot de passe

Mes critères de force de mot de passe sont les suivants:

• Longueur de 8 caractères
• 2 lettres en majuscules
• 1 caractère spécial (!@#$&*)
• 2 chiffres (0-9)
• 3 lettres en minuscules

Quelqu'un peut-il me donner une expression régulière pour la même chose. Toutes les conditions doivent être remplies par mot de passe.

Vous pouvez effectuer ces vérifications à l'aide d'assertions d'anticipation positives:

^(?=.*[A-Z].*[A-Z])(?=.*[!@#$&*])(?=.*[0-9].*[0-9])(?=.*[a-z].*[a-z].*[a-z]).{8}$

Lien rubulaire

Explication:

^                         Start anchor
(?=.*[A-Z].*[A-Z])        Ensure string has two uppercase letters.
(?=.*[!@#$&*])            Ensure string has one special case letter.
(?=.*[0-9].*[0-9])        Ensure string has two digits.
(?=.*[a-z].*[a-z].*[a-z]) Ensure string has three lowercase letters.
.{8}                      Ensure string is of length 8.
$                         End anchor.

Vous pouvez utiliser des anticipations positives de longueur nulle pour spécifier chacune de vos contraintes séparément:

(?=.{8,})(?=.*\p{Lu}.*\p{Lu})(?=.*[!@#$&*])(?=.*[0-9])(?=.*\p{Ll}.*\p{Ll})

Si votre moteur regex ne prend pas en charge la \pnotation et que l'ASCII pur suffit, vous pouvez remplacer \p{Lu}par [A-Z]et \p{Ll}par [a-z].

Les réponses données ci-dessus sont parfaites, mais je suggère d'utiliser plusieurs expressions régulières plus petites plutôt qu'une grande.
Le fractionnement de l'expression régulière longue présente certains avantages:

• facilité d'écriture et de lecture
• facilité de débogage
• facilité pour ajouter / supprimer une partie de regex

En général, cette approche permet de maintenir le code facilement .

Cela dit, je partage un morceau de code que j'écris en Swift à titre d'exemple:

struct RegExp {

    /**
     Check password complexity

     - parameter password:         password to test
     - parameter length:           password min length
     - parameter patternsToEscape: patterns that password must not contains
     - parameter caseSensitivty:   specify if password must conforms case sensitivity or not
     - parameter numericDigits:    specify if password must conforms contains numeric digits or not

     - returns: boolean that describes if password is valid or not
     */
    static func checkPasswordComplexity(password password: String, length: Int, patternsToEscape: [String], caseSensitivty: Bool, numericDigits: Bool) -> Bool {
        if (password.length < length) {
            return false
        }
        if caseSensitivty {
            let hasUpperCase = RegExp.matchesForRegexInText("[A-Z]", text: password).count > 0
            if !hasUpperCase {
                return false
            }
            let hasLowerCase = RegExp.matchesForRegexInText("[a-z]", text: password).count > 0
            if !hasLowerCase {
                return false
            }
        }
        if numericDigits {
            let hasNumbers = RegExp.matchesForRegexInText("\\d", text: password).count > 0
            if !hasNumbers {
                return false
            }
        }
        if patternsToEscape.count > 0 {
            let passwordLowerCase = password.lowercaseString
            for pattern in patternsToEscape {
                let hasMatchesWithPattern = RegExp.matchesForRegexInText(pattern, text: passwordLowerCase).count > 0
                if hasMatchesWithPattern {
                    return false
                }
            }
        }
        return true
    }

    static func matchesForRegexInText(regex: String, text: String) -> [String] {
        do {
            let regex = try NSRegularExpression(pattern: regex, options: [])
            let nsString = text as NSString
            let results = regex.matchesInString(text,
                options: [], range: NSMakeRange(0, nsString.length))
            return results.map { nsString.substringWithRange($0.range)}
        } catch let error as NSError {
            print("invalid regex: \(error.localizedDescription)")
            return []
        }
    }
}

Je suggérerais d'ajouter

(?!.*pass|.*word|.*1234|.*qwer|.*asdf) exclude common passwords

La solution de codaddict fonctionne bien, mais celle-ci est un peu plus efficace: (syntaxe Python)

password = re.compile(r"""(?#!py password Rev:20160831_2100)
    # Validate password: 2 upper, 1 special, 2 digit, 1 lower, 8 chars.
    ^                        # Anchor to start of string.
    (?=(?:[^A-Z]*[A-Z]){2})  # At least two uppercase.
    (?=[^!@#$&*]*[!@#$&*])   # At least one "special".
    (?=(?:[^0-9]*[0-9]){2})  # At least two digit.
    .{8,}                    # Password length is 8 or more.
    $                        # Anchor to end of string.
    """, re.VERBOSE)

Les classes de caractères annulées consomment tout jusqu'au caractère souhaité en une seule étape, ne nécessitant aucun retour arrière. (La solution dot star fonctionne très bien, mais nécessite un certain retour en arrière.) Bien sûr, avec des chaînes cibles courtes telles que des mots de passe, cette amélioration de l'efficacité sera négligeable.

import re

RegexLength=re.compile(r'^\S{8,}$')
RegexDigit=re.compile(r'\d')
RegexLower=re.compile(r'[a-z]')
RegexUpper=re.compile(r'[A-Z]')


def IsStrongPW(password):
    if RegexLength.search(password) == None or RegexDigit.search(password) == None or RegexUpper.search(password) == None or RegexLower.search(password) == None:
        return False
    else:
        return True

while True:
    userpw=input("please input your passord to check: \n")
    if userpw == "exit":
        break
    else:
        print(IsStrongPW(userpw))

La solution de @ codaddict fonctionnera.

Vous devriez également envisager de modifier certaines de vos règles pour:

1. Ajoutez plus de caractères spéciaux, c'est-à-dire%, ^, (,), -, _, + et point. J'ajoute tous les caractères spéciaux que vous avez manqués au-dessus des signes numériques dans les claviers américains. Échappez à ceux que les regex utilisent.
2. Faites le mot de passe de 8 caractères ou plus. Pas seulement un nombre statique 8.

Avec les améliorations ci-dessus, et pour plus de flexibilité et de lisibilité, je modifierais l'expression régulière en.

^(?=.*[a-z]){3,}(?=.*[A-Z]){2,}(?=.*[0-9]){2,}(?=.*[!@#$%^&*()--__+.]){1,}.{8,}$

Explication de base

(?=.*RULE){MIN_OCCURANCES,}     Each rule block is shown by (){}. The rule and number of occurrences can then be easily specified and tested separately, before getting combined

Explication détaillée

^                             start anchor
(?=.*[a-z]){3,}               lowercase letters. {3,} indicates that you want 3 of this group
(?=.*[A-Z]){2,}               uppercase letters. {2,} indicates that you want 2 of this group
(?=.*[0-9]){2,}               numbers. {2,} indicates that you want 2 of this group
(?=.*[!@#$%^&*()--__+.]){1,}   all the special characters in the [] fields. The ones used by regex are escaped by using the \ or the character itself. {1,} is redundant, but good practice, in case you change that to more than 1 in the future. Also keeps all the groups consistent
{8,}                          indicates that you want 8 or more
$                             end anchor

Et enfin, à des fins de test, voici un robulink avec le regex ci-dessus

Pour PHP, cela fonctionne très bien!

 if(preg_match("/^(?=(?:[^A-Z]*[A-Z]){2})(?=(?:[^0-9]*[0-9]){2}).{8,}$/", 
 'CaSu4Li8')){
    return true;
 }else{
    return fasle;
 }

dans ce cas le résultat est vrai

Thsks pour @ridgerunner

Une autre solution:

import re

passwordRegex = re.compile(r'''(
    ^(?=.*[A-Z].*[A-Z])                # at least two capital letters
    (?=.*[!@#$&*])                     # at least one of these special c-er
    (?=.*[0-9].*[0-9])                 # at least two numeric digits
    (?=.*[a-z].*[a-z].*[a-z])          # at least three lower case letters
    .{8,}                              # at least 8 total digits
    $
    )''', re.VERBOSE)

def userInputPasswordCheck():
    print('Enter a potential password:')
    while True:
        m = input()
        mo = passwordRegex.search(m) 
        if (not mo):
           print('''
Your password should have at least one special charachter,
two digits, two uppercase and three lowercase charachter. Length: 8+ ch-ers.

Enter another password:''')          
        else:
           print('Password is strong')
           return
userInputPasswordCheck()

Le mot de passe doit respecter au moins 3 des 4 règles de complexité suivantes,

[au moins 1 caractère majuscule (AZ) au moins 1 caractère minuscule (az) au moins 1 chiffre (0-9) au moins 1 caractère spécial - n'oubliez pas de traiter également l'espace comme des caractères spéciaux]

au moins 10 caractères

au plus 128 caractères

pas plus de 2 caractères identiques dans une ligne (par exemple, 111 non autorisés)

'^ (?!. (.) \ 1 {2}) ((? =. [Az]) (? =. [AZ]) (? =. [0-9]) | (? =. [Az] ) (? =. [AZ]) (? =. [^ A-zA-Z0-9]) | (? =. [AZ]) (? =. [0-9]) (? =. [^ A -zA-Z0-9]) | (? =. [az]) (? =. [0-9]) (? =. * [^ a-zA-Z0-9])). {10,127} $ '

(?!. * (.) \ 1 {2})

(? =. [az]) (? =. [AZ]) (? =. * [0-9])

(? =. [az]) (? =. [AZ]) (? =. * [^ a-zA-Z0-9])

(? =. [AZ]) (? =. [0-9]) (? =. * [^ A-zA-Z0-9])

(? =. [az]) (? =. [0-9]) (? =. * [^ a-zA-Z0-9])

. {10.127}

Toutes les expressions régulières ci-dessus n'ont malheureusement pas fonctionné pour moi. Les règles de base d'un mot de passe fort sont

• Doit contenir au moins une majuscule
• Doit contenir au moins une petite lettre
• Doit contenir au moins un nombre
• Doit contenir au moins un caractère spécial
• Et longueur minimale

Donc, Best Regex serait

^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*]).{8,}$

L'expression régulière ci-dessus a une longueur minimale de 8. Vous pouvez la changer de {8,} à { any_number ,}

Modification des règles?

disons que vous voulez un minimum de x caractères minuscules, y caractères majuscules, z caractères chiffres, longueur minimale totale w . Ensuite, essayez ci-dessous regex

^(?=.*[a-z]{x,})(?=.*[A-Z]{y,})(?=.*[0-9]{z,})(?=.*[!@#\$%\^&\*]).{w,}$

Remarque: changer x , y , z , w dans regex

Edit: réponse regex mise à jour

Edit2: modification ajoutée