Regex để xác nhận độ mạnh của mật khẩu

Tiêu chí độ mạnh mật khẩu của tôi là như sau:

• Độ dài 8 ký tự
• 2 chữ cái in hoa
• 1 nhân vật đặc biệt (!@#$&*)
• 2 chữ số (0-9)
• 3 chữ cái in thường

Ai đó có thể xin vui lòng cho tôi regex cho cùng. Tất cả các điều kiện phải được đáp ứng bằng mật khẩu.

Bạn có thể thực hiện các kiểm tra này bằng cách sử dụng các xác nhận tích cực về phía trước:

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

Liên kết rubular

Giải trình:

^                         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.

Bạn có thể sử dụng các hướng nhìn tích cực có độ dài bằng không để chỉ định riêng từng ràng buộc của mình:

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

Nếu công cụ regex của bạn không hỗ trợ \pký hiệu và ASCII thuần túy là đủ, thì bạn có thể thay thế \p{Lu}bằng [A-Z]và \p{Ll}bằng [a-z].

Câu trả lời được đưa ra ở trên là hoàn hảo nhưng tôi đề nghị sử dụng nhiều regex nhỏ hơn là một lớn.
Tách regex dài có một số lợi thế:

• dễ dàng để viết và đọc
• dễ dàng để gỡ lỗi
• dễ dàng thêm / xóa một phần của regex

Nói chung cách tiếp cận này giữ mã dễ dàng duy trì .

Phải nói rằng, tôi chia sẻ một đoạn mã mà tôi viết trong Swift làm ví dụ:

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

Tôi sẽ đề nghị thêm

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

Giải pháp của codaddict hoạt động tốt, nhưng giải pháp này hiệu quả hơn một chút: (cú pháp 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)

Các lớp nhân vật bị phủ định tiêu thụ mọi thứ cho đến ký tự mong muốn trong một bước duy nhất, yêu cầu quay lại bằng không. (Giải pháp sao chấm chỉ hoạt động tốt, nhưng không yêu cầu quay lại.) Tất nhiên với các chuỗi mục tiêu ngắn như mật khẩu, cải thiện hiệu quả này sẽ không đáng kể.

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

Giải pháp của @ codaddict sẽ hoạt động.

Bạn cũng nên xem xét thay đổi một số quy tắc của mình thành:

1. Thêm các ký tự đặc biệt hơn, ví dụ%, ^, (,), -, _, + và dấu chấm. Tôi đang thêm tất cả các ký tự đặc biệt mà bạn đã bỏ lỡ phía trên các ký hiệu số trong bàn phím Hoa Kỳ. Thoát khỏi những người sử dụng regex.
2. Tạo mật khẩu 8 ký tự trở lên. Không chỉ là một số 8 tĩnh.

Với những cải tiến ở trên, và để linh hoạt hơn và dễ đọc hơn, tôi sẽ sửa đổi regex thành.

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

Giải thích cơ bản

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

Giải thích chi tiết

^                             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

Và cuối cùng, cho mục đích thử nghiệm ở đây là một robulink với regex ở trên

Đối với PHP, điều này hoạt động tốt!

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

trong trường hợp này kết quả là đúng

Thsks cho @ridgerunner

Giải pháp khác:

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

Mật khẩu phải đáp ứng ít nhất 3 trong số 4 quy tắc phức tạp sau đây,

[ít nhất 1 ký tự viết hoa (AZ) ít nhất 1 ký tự chữ thường (az) ít nhất 1 chữ số (0-9) ít nhất 1 ký tự đặc biệt - đừng quên coi không gian là ký tự đặc biệt]

ít nhất 10 ký tự

nhiều nhất là 128 ký tự

không quá 2 ký tự giống nhau trong một hàng (ví dụ: 111 không được phép)

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

Tất cả các regex trên không may không làm việc cho tôi. Các quy tắc cơ bản của mật khẩu mạnh là

• Nên chứa ít nhất một chữ in hoa
• Nên chứa ít nhất một chữ cái nhỏ
• Nên chứa ít nhất một số
• Nên chứa ít nhất một ký tự đặc biệt
• Và chiều dài tối thiểu

Vì vậy, Regex tốt nhất sẽ là

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

Regex ở trên có độ dài tối thiểu là 8. Bạn có thể thay đổi nó từ {8,} thành { any_number ,}

Sửa đổi trong quy tắc?

giả sử bạn muốn tối thiểu x ký tự chữ nhỏ, ký tự y chữ cái, số ký tự z , Tổng chiều dài tối thiểu w . Sau đó thử dưới regex

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

Lưu ý: Thay đổi x , y , z , w trong regex

Chỉnh sửa: Cập nhật câu trả lời regex

Edit2: Đã thêm sửa đổi