นิพจน์ทั่วไปเพื่อตรวจสอบว่ารหัสผ่านเป็น“ 8 อักขระรวมทั้งตัวอักษรตัวพิมพ์ใหญ่ 1 ตัวอักขระพิเศษ 1 ตัวอักขระตัวเลขและตัวอักษร”

ฉันต้องการนิพจน์ทั่วไปเพื่อตรวจสอบสิ่งนั้น

รหัสผ่านต้องมีอักขระแปดตัวรวมทั้งตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักขระพิเศษหนึ่งตัวและอักขระที่เป็นตัวเลขและตัวอักษร

และนี่คือนิพจน์การตรวจสอบความถูกต้องของฉันซึ่งมีไว้สำหรับอักขระแปดตัวซึ่งรวมถึงอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักษรตัวพิมพ์เล็กหนึ่งตัวและตัวเลขหนึ่งตัวหรืออักขระพิเศษ

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

ฉันจะเขียนรหัสผ่านที่ต้องมีอักขระแปดตัวรวมทั้งตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักขระพิเศษและอักขระที่เป็นตัวเลขและตัวอักษรได้อย่างไร

การแสดงออกปกติที่คุณเป็นมักจะเป็นเรื่องใหญ่และเป็นฝันร้ายที่ต้องรักษาโดยเฉพาะอย่างยิ่งสำหรับคนที่ไม่คุ้นเคยกับนิพจน์ทั่วไป

ฉันคิดว่ามันจะง่ายกว่าที่จะทำลาย regex ของคุณและทำทีละนิด อาจต้องใช้เวลาทำมากกว่านี้เล็กน้อย แต่ฉันค่อนข้างมั่นใจว่าการดูแลรักษาและการดีบักมันจะง่ายกว่า นอกจากนี้ยังช่วยให้คุณสามารถให้ข้อความแสดงข้อผิดพลาดโดยตรงแก่ผู้ใช้ของคุณได้มากขึ้น (นอกเหนือจากเพียงInvalid Password) ซึ่งจะช่วยปรับปรุงประสบการณ์ของผู้ใช้

จากสิ่งที่ฉันเห็นว่าคุณค่อนข้างคล่องแคล่วใน regex ดังนั้นฉันคิดว่าการให้นิพจน์ทั่วไปทำในสิ่งที่คุณต้องการจะไร้ผล

เมื่อเห็นความคิดเห็นของคุณนี่คือวิธีที่ฉันจะอธิบาย:

• ต้องมีความยาวแปดอักขระ: คุณไม่จำเป็นต้องมีนิพจน์ทั่วไปสำหรับสิ่งนี้ ใช้.Lengthทรัพย์สินก็น่าจะเพียงพอ

• รวมตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัว: คุณสามารถใช้ไฟล์ [A-Z]+นิพจน์ทั่วไป ถ้า string trueมีจดหมายกรณีอย่างน้อยหนึ่งบนนี้แสดงออกปกติจะให้ผลผลิต

• อักขระพิเศษหนึ่งตัว: คุณสามารถใช้อักขระ\Wที่จะจับคู่อักขระใด ๆ ที่ไม่ใช่ตัวอักษรหรือตัวเลขหรืออื่น ๆ คุณสามารถใช้บางอย่างเช่นนี้[!@#]เพื่อระบุรายการอักขระพิเศษที่กำหนดเอง หมายเหตุแม้ว่าตัวอักษรที่เช่น$, ^, (และ)มีตัวอักษรพิเศษในภาษาแสดงออกปกติดังนั้นพวกเขาจะต้องหนีออกมาเพื่อต้องการ:\$มีตัวอักษรพิเศษในภาษาแสดงออกปกติดังนั้นพวกเขาจะต้องหนีออกมาเพื่อต้องการ:ดังนั้นในระยะสั้นคุณอาจใช้ไฟล์\W.

• อักขระที่เป็นตัวอักษรและตัวเลข: การใช้ \w+ควรจับคู่ตัวอักษรและตัวเลขและขีดล่าง

ดูบทช่วยสอนนี้สำหรับข้อมูลเพิ่มเติม

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

ในหนึ่งบรรทัด:

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

แก้ไข 2019-05-28:

คุณต้องจับคู่สตริงอินพุตทั้งหมด ดังนั้นคุณสามารถใส่นิพจน์ทั่วไประหว่าง^และ$เพื่อป้องกันไม่ให้สมมติว่าการจับคู่บางส่วนโดยบังเอิญเป็นการจับคู่อินพุตทั้งหมด:

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

แหล่งที่มา:

• นิพจน์การจับคู่รหัสผ่าน

• การตรวจสอบความแข็งแรงของรหัสผ่านด้วยนิพจน์ทั่วไป

คำตอบมากมาย .... แย่หมด!

นิพจน์ทั่วไปไม่มีตัวดำเนินการ AND ดังนั้นจึงค่อนข้างยากที่จะเขียน regex ที่ตรงกับรหัสผ่านที่ถูกต้องเมื่อความถูกต้องถูกกำหนดโดยบางสิ่งและอย่างอื่นและอย่างอื่น ...

แต่การแสดงออกปกติจะมีการดำเนินการหรือดังนั้นเพียงแค่ใช้ทฤษฎีบท DeMorgan และเขียน regex ที่ตรงกับที่ไม่ถูกต้องรหัสผ่าน

สิ่งใดก็ตามที่มีอักขระน้อยกว่า 8 ตัวหรือสิ่งที่ไม่มีตัวเลขหรือสิ่งที่ไม่มีตัวพิมพ์ใหญ่หรืออะไรก็ตามที่ไม่มีอักขระพิเศษ

ดังนั้น:

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

หากมีสิ่งใดตรงกับสิ่งนั้นแสดงว่าเป็นรหัสผ่านที่ไม่ถูกต้อง

คำตอบคืออย่าใช้นิพจน์ทั่วไป นี่คือการตั้งค่าและการนับ

นิพจน์ทั่วไปเกี่ยวกับลำดับ

ในชีวิตของคุณในฐานะโปรแกรมเมอร์คุณจะขอให้ทำหลายสิ่งที่ไม่สมเหตุสมผล เรียนรู้ที่จะขุดระดับให้ลึกขึ้น เรียนรู้เมื่อคำถามผิด

คำถาม (หากกล่าวถึงนิพจน์ทั่วไป) ผิด

Pseudocode (สลับไปมาระหว่างภาษามากเกินไปในช่วงปลาย):

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)

พนันได้เลยว่าคุณอ่านและเข้าใจโค้ดด้านบนแทบจะในทันที เดิมพันว่าคุณใช้เวลานานกว่ามากกับ regex และมีความมั่นใจน้อยกว่าว่าถูกต้อง การขยายนิพจน์ทั่วไปมีความเสี่ยง ขยายทันทีข้างต้นน้อยกว่ามาก

โปรดทราบว่าคำถามเป็นวลีที่ไม่ชัดเจน ชุดอักขระเป็น ASCII หรือ Unicode หรือ ?? การเดาของฉันจากการอ่านคำถามคือสมมติว่ามีอักขระตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว ดังนั้นฉันคิดว่ากฎสุดท้ายที่สันนิษฐานควรเป็น:

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

(การเปลี่ยนหมวกเป็นแบบเน้นความปลอดภัยนี่เป็นเรื่องจริงที่น่ารำคาญ / ไม่ใช่กฎที่มีประโยชน์.)

การเรียนรู้ที่จะรู้ว่าเมื่อคำถามผิดมีความสำคัญมากกว่าคำตอบที่ชาญฉลาด คำตอบที่ชาญฉลาดสำหรับคำถามผิดมักจะผิดอยู่เสมอ

เพื่อเป็นตัวอย่างวิธีการนี้ด้วย regex ที่อ่านได้ / บำรุงรักษาได้

สำหรับ regex ที่ยาวขึ้นคุณควรใช้RegexOptions.IgnorePatternWhitespaceเพื่อให้มีช่องว่างและความคิดเห็นในนิพจน์เสมอเพื่อให้อ่านง่ายขึ้น

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

หากคุณต้องการตัวพิมพ์ใหญ่และอักขระพิเศษเพียงตัวเดียวสิ่งนี้ควรใช้งานได้:

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

/^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/uการแสดงออกปกติที่คุณกำลังมองหาคือ:

ตัวอย่างและการทดสอบ: http://regexr.com/3fhr4

คำถามนี้เริ่มเป็นไวรัลและมีข้อเสนอแนะที่น่าสนใจมากมายปรากฏขึ้น

ใช่การเขียนด้วยมือเป็นเรื่องยาก วิธีแก้ไขที่ง่ายกว่าคือการใช้เทมเพลต แม้ว่า regex ที่ได้อาจไม่เหมาะสมที่สุด แต่ก็จะง่ายต่อการบำรุงรักษาและ / หรือเปลี่ยนแปลงและผู้ใช้จะสามารถควบคุมผลลัพธ์ได้ดีขึ้น เป็นไปได้ว่าฉันพลาดอะไรไปดังนั้นการวิจารณ์ที่สร้างสรรค์จะเป็นประโยชน์

การเชื่อมโยงนี้อาจจะน่าสนใจ: การแข่งขันอย่างน้อย 2 ตัวเลข 2 ตัวอักษรในลำดับใด ๆ ในสตริง , นิพจน์ปกติภาษา , กลุ่มการจับ

ฉันใช้เทมเพลตนี้โดย(?=(?:.*?({type})){({count})})อ้างอิงจาก regex ทั้งหมดที่ฉันเห็นใน SO ขั้นตอนต่อไปคือการแทนที่รูปแบบที่ต้องการ ( number,special character ... ) และเพิ่มการกำหนดค่าสำหรับความยาว

ฉันได้สร้างคลาสเล็ก ๆ สำหรับการเขียน regex PasswordRegexGenerator.cs ตัวอย่าง:

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 ( ) + ")";
    }
}

คุณสามารถใช้คลาสด้านล่างเพื่อตรวจสอบความถูกต้อง:

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

  }
}

โดยที่ 6 และ 20 คือความยาวขั้นต่ำและสูงสุดสำหรับรหัสผ่าน

• ใช้นิพจน์ nonbacktracking เพื่อจับคู่รหัสผ่านทั้งหมดก่อนหากมีอักขระอย่างน้อย 8 ตัว (ด้วยวิธีนี้จะไม่มีการระเบิดร่วมกันเป็นเวลานาน แต่รหัสผ่านไม่ถูกต้อง): (?>{8,})
• ใช้การยืนยัน lookbehind เพื่อตรวจสอบว่ามีอักขระที่จำเป็นทั้งหมด (AND-condition) หรือไม่ (?<=...)
• อักขระตัวพิมพ์ใหญ่อย่างน้อยหนึ่งตัว: (?<=\p{Lu}.*)
• อักขระพิเศษอย่างน้อยหนึ่งตัว (มีความคลุมเครือเล็กน้อย แต่ขอใช้คำว่า not-word): (?<=\W.*)
• อักขระที่เป็นตัวอักษรและตัวเลขคละกันอย่างน้อยหนึ่งตัว (: (?<=\w.*)

สรุป:

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

ดีที่สุดคือไม่ใช้ regex สำหรับทุกสิ่ง ข้อกำหนดเหล่านั้นเบามาก ในการดำเนินการสตริง CPU ที่ชาญฉลาดสำหรับการตรวจสอบเกณฑ์ / การตรวจสอบนั้นถูกกว่าและเร็วกว่า regex มาก!

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