Expression régulière pour vérifier si le mot de passe est "8 caractères dont 1 lettre majuscule, 1 caractère spécial, des caractères alphanumériques".

Question

Je souhaite qu'une expression régulière vérifie que

un mot de passe doit comporter huit caractères, dont une lettre majuscule, un caractère spécial et des caractères alphanumériques.

Voici mon expression de validation, qui contient huit caractères, dont une lettre majuscule, une lettre minuscule et un chiffre ou un caractère spécial.

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

Comment puis-je l'écrire pour un mot de passe qui doit comporter huit caractères dont une lettre majuscule, un caractère spécial et des caractères alphanumériques ?

Answer 1

Si vous n'avez besoin que d'une seule majuscule et d'un seul caractère spécial, cela devrait fonctionner :

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

Answer 2

L'expression régulière que vous recherchez est : /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/u .

Exemple et test : http://regexr.com/3fhr4

Answer 3

Cette question commence à devenir virale et de nombreuses suggestions intéressantes apparaissent.

Oui, écrire à la main est difficile. Une solution plus simple consiste donc à utiliser un modèle. Bien que la regex obtenue puisse ne pas être optimale, elle sera plus facile à maintenir et/ou à modifier, et l'utilisateur aura un meilleur contrôle sur le résultat. Il est possible que j'aie oublié quelque chose, toute critique constructive sera donc la bienvenue.

Ce lien pourrait être intéressant : correspond à au moins 2 chiffres et 2 lettres dans n'importe quel ordre dans une chaîne de caractères , Langage d'expression régulière , Capturer les groupes

J'utilise ce modèle (?=(?:.*?({type})){({count})}) basé sur toutes les regex que j'ai vues dans SO. L'étape suivante consiste à remplacer le motif nécessaire ( number , special character ... ) et en ajoutant la configuration pour la longueur.

J'ai créé une petite classe pour composer la regex PasswordRegexGenerator.cs Un exemple :

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

Answer 4

Vous pouvez utiliser la classe ci-dessous pour la validation :

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

  }
}

où 6 et 20 sont les longueurs minimale et maximale du mot de passe.

Answer 5

• Utiliser une expression non rétroactive pour faire correspondre le mot de passe entier en premier, s'il comporte au moins 8 caractères (de cette façon, il n'y a pas d'explosion combinatoire pour les mots de passe longs mais non valides) : (?>{8,})
• Utilisez des assertions de type "lookbehind" pour vérifier la présence de tous les caractères requis (conditions AND). (?<=...)
• Au moins un caractère majuscule : (?<=\p{Lu}.*)
• Au moins un caractère spécial (c'est un peu ambigu, mais utilisons le mot "pas") : (?<=\W.*)
• Au moins un caractère alphanumérique ( : (?<=\w.*)

En résumé :

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