Regulärer Ausdruck, um zu überprüfen, ob das Passwort "8 Zeichen einschließlich 1 Großbuchstaben, 1 Sonderzeichen, alphanumerische Zeichen" lautet.

Ich möchte, dass ein regulärer Ausdruck dies überprüft

Ein Passwort muss aus acht Zeichen bestehen, einschließlich eines Großbuchstabens, eines Sonderzeichens und alphanumerischer Zeichen.

Und hier ist mein Validierungsausdruck für acht Zeichen, einschließlich eines Großbuchstaben, eines Kleinbuchstaben und einer Zahl oder eines Sonderzeichens.

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

Wie kann ich es für ein Passwort schreiben, das aus acht Zeichen bestehen muss, einschließlich eines Großbuchstabens, eines Sonderzeichens und alphanumerischer Zeichen?

Der reguläre Ausdruck, nach dem Sie suchen, wird höchstwahrscheinlich riesig und ein Albtraum sein, den Sie besonders für Menschen pflegen müssen, die mit regulären Ausdrücken nicht so vertraut sind.

Ich denke, es wäre einfacher, Ihre Regex zu zerlegen und es Stück für Stück zu tun. Es könnte etwas länger dauern, aber ich bin mir ziemlich sicher, dass es einfacher wäre, es zu warten und zu debuggen. Auf diese Weise können Sie Ihren Benutzern (außer nur Invalid Password) gezieltere Fehlermeldungen zur Verfügung stellen, die die Benutzererfahrung verbessern sollen.

Nach dem, was ich sehe, sprechen Sie Regex ziemlich fließend, daher würde ich davon ausgehen, dass es sinnlos wäre, Ihnen die regulären Ausdrücke zu geben, um das zu tun, was Sie brauchen.

Wenn ich Ihren Kommentar sehe, würde ich so vorgehen:

• Muss acht Zeichen lang sein: Sie benötigen dafür keinen regulären Ausdruck. Die Nutzung der .LengthEigenschaft sollte ausreichen.

• Einschließlich eines Großbuchstabens: Sie können den [A-Z]+regulären Ausdruck verwenden. Wenn die Zeichenfolge mindestens einen Großbuchstaben enthält, ergibt dieser reguläre Ausdruck true.

• Ein Sonderzeichen: Sie können entweder das \WZeichen verwenden, das mit jedem Zeichen übereinstimmt, das kein Buchstabe oder eine Zahl ist, oder Sie können so etwas verwenden [!@#], um eine benutzerdefinierte Liste von Sonderzeichen anzugeben. Beachten Sie aber , dass Charaktere wie $, ^, (und )sind Sonderzeichen in der regulären Ausdruckssprache, so dass sie wie so entkommen sein müssen: \$. Kurz gesagt, Sie könnten das verwenden \W.

• Alphanumerische Zeichen: Die Verwendung von \w+sollte mit jedem Buchstaben, jeder Zahl und jedem Unterstrich übereinstimmen.

Weitere Informationen finden Sie in diesem Tutorial.

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

In einer Zeile:

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

Bearbeiten 2019-05-28:

Sie müssen die gesamte Eingabezeichenfolge abgleichen. Sie können also den regulären Ausdruck zwischen ^und einschließen $, um zu verhindern, dass versehentlich Teilübereinstimmungen als Übereinstimmung mit der gesamten Eingabe angenommen werden:

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

Quellen:

• Passwort passender Ausdruck

• Überprüfung der Kennwortstärke mit regulären Ausdrücken

So viele Antworten ... alles schlecht!

Reguläre Ausdrücke haben keinen UND-Operator, daher ist es ziemlich schwierig, einen regulären Ausdruck zu schreiben, der gültigen Passwörtern entspricht, wenn die Gültigkeit durch etwas UND etwas anderes UND etwas anderes definiert wird ...

Reguläre Ausdrücke haben jedoch einen ODER-Operator. Wenden Sie daher einfach den Satz von DeMorgan an und schreiben Sie einen regulären Ausdruck , der mit ungültigen Kennwörtern übereinstimmt .

alles mit weniger als 8 Zeichen ODER alles ohne Zahlen ODER alles ohne Großbuchstaben ODER alles ohne Sonderzeichen

So:

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

Wenn etwas dazu passt, ist es ein ungültiges Passwort.

Die Antwort ist, keinen regulären Ausdruck zu verwenden. Dies ist Sätze und Zählen.

Bei regulären Ausdrücken geht es um Ordnung.

In Ihrem Leben als Programmierer werden Sie gebeten, viele Dinge zu tun, die keinen Sinn ergeben. Lerne ein Level tiefer zu graben. Erfahren Sie, wenn die Frage falsch ist.

Die Frage (wenn es um reguläre Ausdrücke geht) ist falsch.

Pseudocode (hat in letzter Zeit zwischen zu vielen Sprachen gewechselt):

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)

Ich wette, Sie haben den obigen Code fast sofort gelesen und verstanden. Ich wette, Sie haben mit dem regulären Ausdruck viel länger gebraucht und sind sich weniger sicher, ob er korrekt ist. Die Erweiterung des regulären Ausdrucks ist riskant. Erweitert das Unmittelbare oben, geschweige denn.

Beachten Sie auch, dass die Frage ungenau formuliert ist. Ist der Zeichensatz ASCII oder Unicode oder ?? Meine Vermutung beim Lesen der Frage ist, dass mindestens ein Kleinbuchstabe angenommen wird. Daher denke ich, dass die angenommene letzte Regel lauten sollte:

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

(Wenn Sie die Hüte auf sicherheitsorientiert ändern, ist dies eine wirklich ärgerliche / nicht nützliche Regel.)

Zu wissen, wann die Frage falsch ist, ist massiv wichtiger als kluge Antworten. Eine kluge Antwort auf die falsche Frage ist fast immer falsch.

Als Beispiel, wie dies mit einem lesbaren / wartbaren regulären Ausdruck geschehen könnte.

Für eine längere Regex sollten Sie immer RegexOptions.IgnorePatternWhitespaceLeerzeichen und Kommentare im Ausdruck zulassen, um die Lesbarkeit zu verbessern.

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

Wenn Sie nur einen Großbuchstaben und ein Sonderzeichen benötigen, sollte dies funktionieren:

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

Der reguläre Ausdruck, nach dem Sie gesucht haben, lautet: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/u .

Beispiel und Test: http://regexr.com/3fhr4

Diese Frage beginnt viral zu werden und es erschienen viele interessante Vorschläge.

Ja, das Schreiben von Hand ist schwierig. Eine einfachere Lösung ist die Verwendung einer Vorlage. Obwohl der resultierende reguläre Ausdruck möglicherweise nicht optimal ist, ist er einfacher zu warten und / oder zu ändern, und der Benutzer hat eine bessere Kontrolle über das Ergebnis. Es ist möglich, dass ich etwas verpasst habe, daher ist jede konstruktive Kritik hilfreich.

Diese Links könnten interessant sein: Ordnen Sie mindestens 2 Ziffern und 2 Buchstaben in beliebiger Reihenfolge in einer Zeichenfolge zu , Sprache für reguläre Ausdrücke , Erfassungsgruppen

Ich verwende diese Vorlage (?=(?:.*?({type})){({count})})basierend auf dem gesamten regulären Ausdruck, den ich in SO gesehen habe. Der nächste Schritt ist das Ersetzen des erforderlichen Musters ( number, special character...) und das Hinzufügen einer Konfiguration für die Länge.

Ich habe eine kleine Klasse zum Erstellen des regulären Ausdrucks PasswordRegexGenerator.cs erstellt. Ein Beispiel:

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

Sie können die folgende Klasse zur Validierung verwenden:

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

  }
}

Dabei sind 6 und 20 die minimale und maximale Länge für das Passwort.

• Verwenden Sie einen Nonbacktracking-Ausdruck, um zuerst das gesamte Kennwort abzugleichen, wenn es mindestens 8 Zeichen enthält (auf diese Weise gibt es keine kombinatorische Explosion für lange, aber ungültige Kennwörter): (?>{8,})
• Verwenden Sie Lookbehind-Zusicherungen, um zu überprüfen, ob alle erforderlichen Zeichen (UND-Bedingungen) vorhanden sind. (?<=...)
• Mindestens ein Großbuchstabe: (?<=\p{Lu}.*)
• Mindestens ein Sonderzeichen (etwas mehrdeutig, aber verwenden wir kein Wort): (?<=\W.*)
• Mindestens ein alphanumerisches Zeichen (: (?<=\w.*)

Zusammenfassend:

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

Am besten ist es, nicht für alles Regex zu verwenden. Diese Anforderungen sind sehr gering. Bei CPU-bezogenen Zeichenfolgen sind Operationen zur Überprüfung der Kriterien / Validierung viel billiger und schneller als Regex!

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