Regex для проверки надежности пароля.

Вы можете выполнить эти проверки, используя положительные ожидания вперед:

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

Рублевая ссылка

Объяснение:

 ^ Start anchor (?=.*[AZ].*[AZ]) Ensure string has two uppercase letters. (?=.*[[email protected]#$&*]) 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. 

Вы можете использовать позитивный внешний вид с нулевой длиной, чтобы указать каждое из ваших ограничений отдельно:

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

Если ваш механизм регулярных выражений не поддерживает нотацию \p и чистый ASCII достаточно, вы можете заменить \p{Lu} на [AZ] и \p{Ll} на [az] .

Ответы, приведенные выше, являются совершенными, но я предлагаю использовать несколько меньших регулярных выражений, а не большой.
Разделение длинного регулярного выражения имеет ряд преимуществ:

• легкость писать и читать
• легкость отладки
• легкость добавления / удаления части регулярного выражения

Как правило, этот подход позволяет легко поддерживать код.

Сказав это, я разделяю fragment кода, который я пишу в Swift как пример:

 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 [] } } } 

Я бы предложил добавить

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

Решение codaddict работает отлично, но этот бит немного эффективнее: (синтаксис 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. (?=(?:[^AZ]*[AZ]){2}) # At least two uppercase. (?=[^[email protected]#$&*]*[[email protected]#$&*]) # 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) 

Отрицательные classы символов потребляют все до желаемого символа за один шаг, требуя нулевого обратного отсчета. (Решение с точечной звездой работает очень хорошо, но требует некоторого возврата). Конечно, с короткими целевыми строками, такими как пароли, это повышение эффективности будет незначительным.

 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)) 

Для PHP это работает отлично!

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

в этом случае результат верен

Thsks для @ridgerunner

Другое решение:

 import re passwordRegex = re.compile(r'''( ^(?=.*[AZ].*[AZ]) # at least two capital letters (?=.*[[email protected]#$&*]) # 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() 

Пароль должен соответствовать как минимум 3 из следующих 4 правил сложности,

[как минимум 1 символ верхнего регистра (AZ) не менее 1 строчного символа (az) не менее 1 цифры (0-9) не менее 1 специального символа – не забудьте также обрабатывать пробелы как специальные символы]

не менее 10 символов

не более 128 символов

не более 2 одинаковых символов в строке (например, 111 не разрешено)

(? =. [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}