Regexp Java pour valider mot de passe

Je suis en train de créer une expression régulière pour la validation des mots de passe qui sera utilisée dans une application Java en tant que paramètre de configuration.

La regexp est la suivante :

^.*(?=.{8,})(?=..*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=]).*$

La politique concernant les mots de passe est la suivante :

  • Au moins 8 caractères
  • Contient au moins un chiffre
  • Contient au moins un caractère alphabétique minuscule et un caractère alphabétique majuscule.
  • Contient au moins un caractère dans un ensemble de caractères spéciaux (@#%$^ etc.)
  • Ne contient pas d’espace, de tabulation, etc.

Il ne me manque que le point 5. Je ne parviens pas à faire en sorte que l’expression régulière vérifie la présence d’espace, de tabulation, de retour à la ligne, etc.

Quelqu’un peut-il m’aider ?

Essayez ça :

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Explication :

^                 # début de la chaîne de caractères
(?=.*[0-9])       # un chiffre doit apparaître au moins une fois
(?=.*[a-z])       # une lettre minuscule doit apparaître au moins une fois
(?=.*[A-Z])       # une lettre majuscule doit apparaître au moins une fois
(?=.*[@#$%^&+=])  # un caractère spécial doit apparaître au moins une fois
(?=\S+$)          # aucun espace blanc n'est autorisé dans la chaîne entière
.{8,}             # n'importe quoi, au moins 8 caractères
$                 # fin de la chaîne de caractères

Il est facile d’ajouter, de modifier ou de supprimer des règles particulières, puisque chaque règle est un « module » indépendant.

La construction (?=.*[xyz]) prend la chaîne entière (.*) et retourne à la première occurrence où [xyz] peut correspondre. Il réussit si [xyz] est trouvé, il échoue sinon.

L’alternative serait d’utiliser un qualificateur réticent : (?=.* ?[xyz]). Pour une vérification de mot de passe, cela ne fera pas de différence, mais pour des chaînes beaucoup plus longues, cela pourrait être la variante la plus efficace.

La variante la plus efficace (mais la plus difficile à lire et à maintenir, donc la plus susceptible de provoquer des erreurs) serait (?=[^xyz]*[xyz]), bien sûr. Pour une regex de cette longueur et dans ce but, je déconseille de procéder de cette façon, car cela ne présente aucun avantage réel.

Exemple simple utilisant des expressions régulières

public class mdpvalidation {
    public static void main(String[] args) {
      String mdp = "xwQRb23!"; 
      String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
      System.out.println(mdp.matches(pattern));
   }
}

Explications :

  • (?=.*[0-9]) un chiffre doit apparaître au moins une fois
  • (?=.*[a-z]) une lettre minuscule doit apparaître au moins une fois
  • (?=.*[A-Z]) une lettre majuscule doit apparaître au moins une fois
  • (?=.*[@#$%^&+=]) un caractère spécial doit apparaître au moins une fois
  • (?=\\S+$) aucun espace blanc n’est autorisé dans la chaîne entière
  • .{8,} au moins 8 caractères

Vous ne devriez pas utiliser des Regex trop complexes (si vous pouvez les éviter) parce qu’elles sont difficiles à lire, à déboguer, etc…

Bien qu’il puisse y avoir un léger surcoût de performance dans l’utilisation de nombreuses petites expressions régulières, Je procéderais de la manière suivante :

bool valider(mdp) {
    if (pwd.length < 8) return false;
    if (not mdp =~ /[0-9]/) return false;
    if (not mdp =~ /[a-z]/) return false;
    if (not mdp =~ /[A-Z]/) return false;
    if (not mdp =~ /[%@$^]/) return false;
    if (mdp =~ /\s/) return false;
    return true;
}