Biểu thức chính quy để kiểm tra xem mật khẩu có phải là "8 ký tự bao gồm 1 ký tự hoa, 1 ký tự đặc biệt, ký tự chữ và số"

Tôi muốn một biểu thức chính quy để kiểm tra điều đó

mật khẩu phải có tám ký tự bao gồm một ký tự viết hoa, một ký tự đặc biệt và các ký tự chữ và số.

Và đây là biểu thức xác thực của tôi dành cho tám ký tự bao gồm một ký tự hoa, một ký tự viết thường và một số hoặc ký tự đặc biệt.

(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

Làm cách nào tôi có thể viết nó cho mật khẩu phải có tám ký tự bao gồm một ký tự hoa, một ký tự đặc biệt và các ký tự chữ và số?

Biểu thức chính quy mà bạn đang theo dõi rất có thể sẽ rất lớn và là một cơn ác mộng để duy trì, đặc biệt là đối với những người không quen thuộc với biểu thức chính quy.

Tôi nghĩ sẽ dễ dàng hơn để chia nhỏ regex của bạn và làm từng chút một. Có thể mất nhiều thời gian hơn để làm, nhưng tôi khá chắc chắn rằng việc duy trì nó và gỡ lỗi nó sẽ dễ dàng hơn. Điều này cũng sẽ cho phép bạn cung cấp nhiều thông báo lỗi trực tiếp hơn cho người dùng của bạn (ngoài chỉ Invalid Password), điều này sẽ cải thiện trải nghiệm người dùng.

Từ những gì tôi thấy bạn khá thông thạo regex, vì vậy tôi cho rằng việc cung cấp cho bạn các biểu thức chính quy để thực hiện những gì bạn cần sẽ là vô ích.

Xem bình luận của bạn, đây là cách tôi sẽ làm về nó:

• Phải có tám ký tự Dài: Bạn không cần regex cho điều này. Sử dụng .Lengthtài sản phải là đủ.

• Bao gồm một chữ cái viết hoa: Bạn có thể sử dụng [A-Z]+biểu thức chính quy. Nếu chuỗi chứa ít nhất một chữ cái viết hoa, thì biểu thức chính quy này sẽ mang lại kết quả true.

• Một ký tự đặc biệt: Bạn có thể sử dụng \Wký tự sẽ khớp với bất kỳ ký tự nào không phải là chữ cái hoặc số hoặc nếu không, bạn có thể sử dụng một cái gì đó tương tự như vậy [!@#]để chỉ định danh sách tùy chỉnh các ký tự đặc biệt. Lưu ý rằng mặc dù các nhân vật chẳng hạn như $, ^, (và )là nhân vật đặc biệt trong ngôn ngữ biểu hiện thường xuyên, vì vậy họ cần phải được thoát như vậy: \$. Vì vậy, trong ngắn hạn, bạn có thể sử dụng \W.

• Ký tự chữ và số: Sử dụng ký tự \w+phải khớp với bất kỳ chữ cái và số nào và gạch dưới.

Hãy xem hướng dẫn này để biết thêm thông tin.

(                   # Start of group
    (?=.*\d)        #   must contain at least one digit
    (?=.*[A-Z])     #   must contain at least one uppercase character
    (?=.*\W)        #   must contain at least one special symbol
       .            #     match anything with previous condition checking
         {8,8}      #        length is exactly 8 characters
)                   # End of group

Trong một dòng:

((?=.*\d)(?=.*[A-Z])(?=.*\W).{8,8})

Chỉnh sửa 2019-05-28:

Bạn cần phải khớp toàn bộ chuỗi đầu vào. Vì vậy, bạn có thể bao gồm regex giữa ^và $để tránh việc vô tình giả định các kết quả phù hợp từng phần là khớp với toàn bộ đầu vào:

^((?=.*\d)(?=.*[A-Z])(?=.*\W).{8,8})$

Nguồn:

• Biểu thức đối sánh mật khẩu

• Xác thực độ mạnh của mật khẩu với các biểu thức chính quy

Rất nhiều câu trả lời .... tất cả đều tệ!

Biểu thức chính quy không có toán tử AND, vì vậy, khá khó để viết một regex khớp với mật khẩu hợp lệ, khi tính hợp lệ được xác định bởi thứ gì đó VÀ thứ khác VÀ thứ khác ...

Nhưng, biểu thức thông thường làm có một toán tử OR, vì vậy chỉ cần áp dụng định lý DeMorgan, và viết một regex phù hợp với không hợp lệ mật khẩu.

bất kỳ thứ gì có ít hơn 8 ký tự HOẶC bất kỳ thứ gì không có số HOẶC bất kỳ thứ gì không có chữ hoa HOẶC bất kỳ thứ gì không có ký tự đặc biệt

Vì thế:

^(.{0,7}|[^0-9]*|[^A-Z]*|[a-zA-Z0-9]*)$

Nếu bất kỳ điều gì khớp với điều đó, thì đó là mật khẩu không hợp lệ .

Câu trả lời là không sử dụng biểu thức chính quy. Đây là tập hợp và đếm.

Biểu thức chính quy là về thứ tự.

Trong cuộc sống của bạn với tư cách là một lập trình viên, bạn sẽ phải làm nhiều việc không có ý nghĩa. Tìm hiểu để đào sâu hơn một cấp độ. Tìm hiểu khi câu hỏi sai.

Câu hỏi (nếu nó đề cập đến biểu thức chính quy) là sai.

Mã giả (đã chuyển đổi giữa quá nhiều ngôn ngữ, muộn):

if s.length < 8:
    return False
nUpper = nLower = nAlphanum = nSpecial = 0
for c in s:
    if isUpper(c):
        nUpper++
    if isLower(c):
        nLower++
    if isAlphanumeric(c):
        nAlphanum++
    if isSpecial(c):
        nSpecial++
return (0 < nUpper) and (0 < nAlphanum) and (0 < nSpecial)

Cá là bạn đã đọc và hiểu đoạn mã trên gần như ngay lập tức. Đặt cược là bạn mất nhiều thời gian hơn với regex, và ít chắc chắn rằng nó là chính xác. Mở rộng regex là rủi ro. Mở rộng ngay bên trên, ít hơn nhiều.

Cũng lưu ý rằng câu hỏi được diễn đạt không chính xác. Bộ ký tự là ASCII hay Unicode, hoặc ?? Suy đoán của tôi khi đọc câu hỏi là ít nhất một ký tự viết thường được giả định. Vì vậy, tôi nghĩ quy tắc cuối cùng được giả định nên là:

return (0 < nUpper) and (0 < nLower) and (0 < nAlphanum) and (0 < nSpecial)

(Thay đổi mũ thành tập trung vào bảo mật, đây là một quy tắc thực sự khó chịu / không hữu ích.)

Học cách biết khi nào câu hỏi sai quan trọng hơn những câu trả lời thông minh. Một câu trả lời thông minh cho câu hỏi sai hầu như luôn luôn sai.

Ví dụ về cách điều này có thể được thực hiện với một regex có thể đọc được / có thể bảo trì.

Đối với regex dài hơn, bạn nên luôn sử dụng RegexOptions.IgnorePatternWhitespaceđể cho phép khoảng trắng và chú thích trong biểu thức để dễ đọc hơn.

String[] passwords = { "foobar", "Foobar", "Foobar1", "Fooobar12" };

foreach (String s in passwords) {

    Match password = Regex.Match(s, @"
                                      ^              # Match the start of the string
                                       (?=.*\p{Lu})  # Positive lookahead assertion, is true when there is an uppercase letter
                                       (?=.*\P{L})   # Positive lookahead assertion, is true when there is a non-letter
                                       \S{8,}        # At least 8 non whitespace characters
                                      $              # Match the end of the string
                                     ", RegexOptions.IgnorePatternWhitespace);

    if (password.Success) {
        Console.WriteLine(s + ": valid");
    }
    else {
        Console.WriteLine(s + ": invalid");
    }
}

Console.ReadLine();

Nếu bạn chỉ cần một chữ hoa và ký tự đặc biệt thì điều này sẽ hoạt động:

@"^(?=.{8,}$)(?=[^A-Z]*[A-Z][^A-Z]*$)\w*\W\w*$"

Biểu thức chính quy bạn đang tìm kiếm là: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/u .

Ví dụ và thử nghiệm: http://regexr.com/3fhr4

Câu hỏi này bắt đầu lan truyền và rất nhiều gợi ý thú vị xuất hiện.

Vâng, viết bằng tay rất khó. Vì vậy, một giải pháp dễ dàng hơn là sử dụng một mẫu. Mặc dù kết quả regex có thể không phải là tối ưu nhất, nó sẽ dễ bảo trì và / hoặc thay đổi hơn và người dùng sẽ kiểm soát tốt hơn kết quả. Có thể là tôi đã bỏ lỡ điều gì đó, vì vậy bất kỳ lời phê bình mang tính xây dựng nào cũng sẽ hữu ích.

Các liên kết này có thể thú vị: so khớp ít nhất 2 chữ số 2 chữ cái theo thứ tự bất kỳ trong một chuỗi , Ngôn ngữ biểu thức chính quy , Nhóm nắm bắt

Tôi đang sử dụng mẫu này (?=(?:.*?({type})){({count})})dựa trên tất cả regex mà tôi đã thấy trong SO. Bước tiếp theo là thay thế mẫu cần thiết ( number,special character ...) và thêm cấu hình cho độ dài.

Tôi đã tạo một lớp học nhỏ để soạn thảo regex PasswordRegexGenerator.cs Một ví dụ:

string result = new PasswordRegexGenerator ( )
        .UpperCase ( 3, -1 )    // ... {3,}
        .Number ( 2, 4 )        // ... {2,4}
        .SpecialCharacter ( 2 ) // ... {2}
        .Total ( 8,-1 )
        .Compose ( );

/// <summary>
/// Generator for regular expression, validating password requirements.
/// </summary>
public class PasswordRegexGenerator
{
    private string _elementTemplate = "(?=(?:.*?({type})){({count})})";

    private Dictionary<string, string> _elements = new Dictionary<string, string> {
        { "uppercase", "[A-Z]" },
        { "lowercase", "[a-z]" },
        { "number", @"\d" },
        { "special", @"\W" },
        { "alphanumeric", @"\w" }
    };

    private StringBuilder _sb = new StringBuilder ( );

    private string Construct ( string what, int min, int max )
    {
        StringBuilder sb = new StringBuilder ( _elementTemplate );
        string count = min.ToString ( );

        if ( max == -1 )
        {
            count += ",";
        }
        else if ( max > 0 )
        {
            count += "," + max.ToString();
        }

        return sb
            .Replace ( "({type})", what )
            .Replace ( "({count})", count )
            .ToString ( );
    }

    /// <summary>
    /// Change the template for the generation of the regex parts
    /// </summary>
    /// <param name="newTemplate">the new template</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexTemplate ( string newTemplate )
    {
        _elementTemplate = newTemplate;
        return this;
       }

    /// <summary>
    /// Change or update the regex for a certain type ( number, uppercase ... )
    /// </summary>
    /// <param name="name">type of the regex</param>
    /// <param name="regex">new value for the regex</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexElements ( string name, string regex )
    {
        if ( _elements.ContainsKey ( name ) )
        {
            _elements[ name ] = regex;
        }
        else
        {
            _elements.Add ( name, regex );
        }
        return this;
    }

    #region construction methods 

    /// <summary>
    /// Adding number requirement
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <returns></returns>
    public PasswordRegexGenerator Number ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "number" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator UpperCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "uppercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator LowerCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "lowercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator SpecialCharacter ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "special" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator Total ( int min, int max = 0 )
    {
        string count = min.ToString ( ) + ( ( max == 0 ) ? "" : "," + max.ToString ( ) );
        _sb.Append ( ".{" + count + "}" );
        return this;
    }

    #endregion

    public string Compose ()
    {
        return "(" + _sb.ToString ( ) + ")";
    }
}

Bạn có thể sử dụng lớp dưới đây để xác thực:

public class PasswordValidator{

  private Pattern pattern;
  private Matcher matcher;

  private static final String PASSWORD_PATTERN =
          "((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";

  public PasswordValidator(){
      pattern = Pattern.compile(PASSWORD_PATTERN);
  }

  /**
   * Validate password with regular expression
   * @param password password for validation
   * @return true valid password, false invalid password
   */
  public boolean validate(final String password){

      matcher = pattern.matcher(password);
      return matcher.matches();

  }
}

trong đó 6 và 20 là độ dài tối thiểu và tối đa cho mật khẩu.

• Sử dụng biểu thức không theo dõi để khớp với toàn bộ mật khẩu trước, nếu mật khẩu đó có ít nhất 8 ký tự (theo cách này, không có sự bùng nổ tổ hợp đối với mật khẩu dài nhưng không hợp lệ): (?>{8,})
• Sử dụng xác nhận phía sau để kiểm tra sự hiện diện của tất cả các ký tự bắt buộc (điều kiện AND). (?<=...)
• Ít nhất một ký tự viết hoa: (?<=\p{Lu}.*)
• Ít nhất một ký tự đặc biệt (hơi mơ hồ, nhưng hãy sử dụng không phải từ): (?<=\W.*)
• Ít nhất một ký tự chữ và số (: (?<=\w.*)

Tóm tắt:

(?>.{8,})(?<=\p{Lu}.*)(?<=\W.*)(?<=\w.*)

Tốt nhất là không sử dụng regex cho mọi thứ. Những yêu cầu đó rất nhẹ. Trên các hoạt động chuỗi khôn ngoan của CPU để kiểm tra các tiêu chí / xác nhận là rẻ hơn và nhanh hơn nhiều so với regex!

/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$/