Regex, um die Passwortstärke zu überprüfen

Meine Kriterien für die Passwortstärke lauten wie folgt:

  • 8 Zeichen Länge
  • 2 Buchstaben im Großbuchstaben
  • 1 Sonderzeichen (!@#$&*)
  • 2 Ziffern (0-9)
  • 3 Buchstaben in Kleinbuchstaben

Kann mir bitte jemand eine Regex geben? Alle Bedingungen müssen durch ein Passwort erfüllt werden.

Sie können diese Prüfungen mit positiven Look-Ahead-Assertions durchführen:

 ^(?=.*[AZ].*[AZ])(?=.*[!@#$&*])(?=.*[0-9].*[0-9])(?=.*[az].*[az].*[az]).{8}$ 

Rubuläre Verbindung

Erläuterung:

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

Sie können positive Look-Ahead-Elemente mit einer Länge von Null verwenden, um jede Ihrer Abhängigkeiten separat anzugeben:

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

Wenn Ihre Regex-Engine die \p Notation nicht unterstützt und reines ASCII ausreicht, können Sie \p{Lu} durch [AZ] und \p{Ll} durch [az] ersetzen.

Die obigen Antworten sind perfekt, aber ich schlage vor , mehrere kleinere Regex statt einer großen zu verwenden.
Das Teilen des langen Regex hat einige Vorteile:

  • Leichtigkeit zu schreiben und zu lesen
  • Debugging-Fähigkeit
  • Leichtigkeit, einen Teil von Regex hinzuzufügen / zu entfernen

Im Allgemeinen wird durch diesen Ansatz der Code leicht wartbar gehalten .

Nachdem ich das gesagt habe, teile ich einen Code, den ich in Swift als Beispiel schreibe:

 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("[AZ]", text: password).count > 0 if !hasUpperCase { return false } let hasLowerCase = RegExp.matchesForRegexInText("[az]", 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 [] } } } 

Ich würde vorschlagen, hinzuzufügen

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

Die Lösung von codaddict funktioniert gut, aber diese ist ein wenig effizienter: (Python-Syntax)

 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. (?=(?:[^AZ]*[AZ]){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) 

Die negierten Zeichenklassen verbrauchen alles bis zum gewünschten Zeichen in einem einzigen Schritt und erfordern kein Zurückverfolgen. (Die Punkt-Stern-Lösung funktioniert gut, erfordert jedoch ein gewisses Backtracking.) Natürlich ist diese Effizienzverbesserung bei kurzen Zielzeichenfolgen wie Passwörtern vernachlässigbar.

 import re RegexLength=re.compile(r'^\S{8,}$') RegexDigit=re.compile(r'\d') RegexLower=re.compile(r'[az]') RegexUpper=re.compile(r'[AZ]') 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)) 

Für PHP funktioniert das gut!

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

In diesem Fall ist das Ergebnis richtig

Thsks für @ridgerunner

Eine andere Lösung:

 import re passwordRegex = re.compile(r'''( ^(?=.*[AZ].*[AZ]) # at least two capital letters (?=.*[!@#$&*]) # at least one of these special c-er (?=.*[0-9].*[0-9]) # at least two numeric digits (?=.*[az].*[az].*[az]) # 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() 

Das Passwort muss mindestens 3 der folgenden 4 Komplexitätsregeln erfüllen.

[mindestens 1 Großbuchstabe (AZ) mindestens 1 Kleinbuchstabe (az) mindestens 1 Ziffer (0-9) mindestens 1 Sonderzeichen – vergiss nicht, Leerzeichen auch als Sonderzeichen zu behandeln]

mindestens 10 Zeichen

höchstens 128 Zeichen

nicht mehr als 2 identische Zeichen hintereinander (zB 111 nicht erlaubt)

‘^ (?!. (.) \ 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}