it-swarm.com.de

Regulärer Ausdruck zum Überprüfen, ob das Kennwort "8 Zeichen einschließlich 1 Großbuchstaben, 1 Sonderzeichen, alphanumerische Zeichen" ist

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

ein Passwort muss aus acht Zeichen bestehen, darunter ein Großbuchstabe, ein Sonderzeichen und alphanumerische Zeichen.

Und hier ist mein Bestätigungsausdruck für acht Zeichen, darunter ein Großbuchstabe, ein Kleinbuchstabe und eine Zahl oder ein Sonderzeichen.

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

Wie schreibe ich ein Kennwort, das aus acht Zeichen bestehen muss, darunter ein Großbuchstabe, ein Sonderzeichen und alphanumerische Zeichen?

96
Rania Umair

Der reguläre Ausdruck, nach dem Sie suchen, ist höchstwahrscheinlich sehr groß und ein Albtraum, insbesondere für Personen, die mit regulären Ausdrücken nicht so vertraut sind.

Ich denke, es wäre einfacher, deinen Regex zu zerlegen und ein bisschen nach dem anderen zu machen. Es könnte etwas mehr Zeit in Anspruch nehmen, aber ich bin mir ziemlich sicher, dass die Wartung und das Debuggen einfacher sind. Auf diese Weise können Sie Ihren Benutzern auch mehr gerichtete Fehlermeldungen zur Verfügung stellen (nicht nur Invalid Password), was die Benutzererfahrung verbessern sollte.

Von dem, was ich sehe, sind Sie in Regex ziemlich fließend, also 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 keine Regex. Die Verwendung der .Length-Eigenschaft sollte ausreichen.

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

  • Ein Sonderzeichen: Sie können entweder den \W verwenden, der mit jedem Zeichen übereinstimmt, bei dem es sich nicht um einen Buchstaben oder eine Zahl handelt. Andernfalls können Sie mit [[email protected]#] eine benutzerdefinierte Liste von Sonderzeichen angeben. Beachten Sie jedoch, dass Zeichen wie $, ^, ( und ) Sonderzeichen in der Sprache für reguläre Ausdrücke sind. Sie müssen daher wie folgt umgangen werden: \$. Kurz gesagt, Sie könnten den \W verwenden.

  • Alphanumerische Zeichen: Die Verwendung von \w+ sollte mit Buchstaben, Ziffern und Unterstrichen übereinstimmen.

Weitere Informationen finden Sie in this tutorial.

126
npinti
(                   # 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})

Quellen:

95
mmdemirbas

So viele Antworten .... alles schlecht!

Reguläre Ausdrücke haben keinen AND-Operator. Daher ist es ziemlich schwierig, einen Regex zu schreiben, der mit gültigen Passwörtern übereinstimmt, wenn Gültigkeit durch etwas AND AND AND AND AND Anderes definiert wird.

Reguläre Ausdrücke do verfügen jedoch über einen OR - Operator. Wenden Sie einfach den Satz von DeMorgan an und schreiben Sie eine Regex, die den Passwörtern invalid entspricht.

alles mit weniger als 8 ZeichenODERalles ohne NummernODERalles ohne GroßbuchstabenODERalles ohne Sonderzeichen

So:

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

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

24
Matt Timmermans

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

Für einen längeren Regex sollten Sie immer RegexOptions.IgnorePatternWhitespace verwenden, um Leerzeichen und Kommentare im Ausdruck zuzulassen, 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();
10
stema

Die Antwort lautet, keinen regulären Ausdruck zu verwenden. Dies setzt und zählt.

Reguläre Ausdrücke beziehen sich auf 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 reguläre Ausdrücke erwähnt wurden) ist falsch.

Pseudocode (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 Regex viel länger gebraucht und sind sich nicht sicher, ob er richtig ist. Die Erweiterung des Regex ist riskant. Erweitert das unmittelbare oben, viel weniger.

Beachten Sie auch, dass die Frage ungenau formuliert ist. Ist der Zeichensatz ASCII oder Unicode oder? Ich schätze beim Lesen der Frage, dass mindestens ein Kleinbuchstabe angenommen wird. Ich denke, die letzte Regel sollte lauten:

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

(Hüte auf sicherheitsgerichtet zu ändern, das ist eine wirklich nervige/nicht nützliche Regel.)

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

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

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

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

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

1
Lucas

Sie können unter 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.

0
amit pandya

Diese Frage fängt an, viral zu sein, und es sind viele interessante Vorschläge aufgetaucht.

Ja, das Schreiben von Hand ist schwierig. Eine einfachere Lösung ist daher 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, sodass konstruktive Kritik hilfreich ist.

Diese Links könnten interessant sein: mindestens 2 Ziffern mit 2 Buchstaben in beliebiger Reihenfolge in einer Zeichenfolge zusammenbringen , Regular Expression Language , Gruppen erfassen

Ich verwende diese Vorlage (?=(?:.*?({type})){({count})}) basierend auf allen regulären Ausdrücken, die ich in SO gesehen habe. Der nächste Schritt ist das Ersetzen des benötigten Musters (number, special character ...) und das Hinzufügen der Konfiguration für die Länge.

Ich habe eine kleine Klasse für das Erstellen des Regex 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 ( ) + ")";
    }
}
0
Bakudan