Regex Java pour la validation du mot de passe
Je crée une expression rationnelle pour la validation du mot de passe à utiliser dans une application Java en tant que paramètre de configuration.
La regexp est:
^.*(?=.{8,})(?=..*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=]).*$
La politique de mot de passe est:
Au moins 8 caractères
Contient au moins un chiffre
Contient au moins un caractère alpha inférieur et un caractère alpha supérieur
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 peux pas demander à l'expression rationnelle de vérifier l'espace, l'onglet, le retour chariot, etc.
Quelqu'un pourrait-il m'aider?
Essaye ça:
^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$
Explication:
^ # start-of-string
(?=.*[0-9]) # a digit must occur at least once
(?=.*[a-z]) # a lower case letter must occur at least once
(?=.*[A-Z]) # an upper case letter must occur at least once
(?=.*[@#$%^&+=]) # a special character must occur at least once
(?=\S+$) # no whitespace allowed in the entire string
.{8,} # anything, at least eight places though
$ # end-of-string
Il est facile d'ajouter, de modifier ou de supprimer des règles individuelles, car chaque règle est un "module" indépendant.
La construction (?=.*[xyz]) mange la chaîne entière (.*) et renvoie la première occurrence où [xyz] peut correspondre. Il réussit si [xyz] est trouvé, sinon il échoue.
L'alternative serait d'utiliser un qualificatif réticent: (?=.*?[xyz]). Cela ne fera guère de différence pour la vérification du mot de passe; pour des chaînes beaucoup plus longues, ce pourrait être la variante la plus efficace.
La variante la plus efficace (mais la plus difficile à lire et à gérer, donc la plus sujette aux erreurs) serait bien sûr (?=[^xyz]*[xyz]). Pour une expression rationnelle de cette longueur et dans ce but, je déconseillerais de le faire de cette façon, car cela ne présente aucun avantage réel.
exemple simple en utilisant regex
public class passwordvalidation {
public static void main(String[] args) {
String passwd = "aaZZa44@";
String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
System.out.println(passwd.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 n'est autorisé dans la chaîne entière.{8,}au moins 8 caractères
Vous ne devez pas utiliser de Regex trop complexe (si vous pouvez les éviter) car ils sont
- difficile à lire (au moins pour tout le monde sauf vous-même)
- difficile à étendre
- difficile à déboguer
Bien que l’utilisation de nombreuses expressions régulières de petite taille puisse entraîner un léger surcoût, elle est facilement surpondérée par les points supérieurs.
Je mettrais en œuvre comme ceci:
bool matchesPolicy(pwd) {
if (pwd.length < 8) return false;
if (not pwd =~ /[0-9]/) return false;
if (not pwd =~ /[a-z]/) return false;
if (not pwd =~ /[A-Z]/) return false;
if (not pwd =~ /[%@$^]/) return false;
if (pwd =~ /\s/) return false;
return true;
}
Exigence de mot de passe:
- Le mot de passe doit comporter au moins huit (8) caractères pour que le système puisse le prendre en charge.
Les mots de passe doivent inclure des caractères d'au moins deux (2) de ces groupes: caractères alphabétiques, numériques et spéciaux.
^.*(?=.{8,})(?=.*\d)(?=.*[a-zA-Z])|(?=.{8,})(?=.*\d)(?=.*[!@#$%^&])|(?=.{8,})(?=.*[a-zA-Z])(?=.*[!@#$%^&]).*$
Je l'ai testé et ça marche
Pour toute personne intéressée par les exigences minimales pour chaque type de personnage, je suggérerais de prolonger l'extension suivante par rapport à la réponse acceptée de Tomalak:
^(?=(.*[0-9]){%d,})(?=(.*[a-z]){%d,})(?=(.*[A-Z]){%d,})(?=(.*[^0-9a-zA-Z]){%d,})(?=\S+$).{%d,}$
Notez qu'il s'agit d'une chaîne de formatage et non du motif de regex final. Il suffit de remplacer% d par les occurrences minimales requises pour: chiffres, minuscules, majuscules, autres que chiffres/caractères et mot de passe complet (respectivement). Les occurrences maximales sont peu probables (à moins que vous ne vouliez un maximum de 0, rejetant effectivement de tels caractères), mais ceux-ci pourraient également être facilement ajoutés. Notez le groupement supplémentaire autour de chaque type afin que les contraintes min/max permettent des correspondances non consécutives. Cela a fonctionné à merveille pour un système permettant de configurer de manière centralisée le nombre de caractères de chaque type requis, puis de demander au site Web et à deux plates-formes mobiles différentes de récupérer ces informations afin de construire le motif regex basé sur la chaîne de formatage ci-dessus.
String s=pwd;
int n=0;
for(int i=0;i<s.length();i++)
{
if((Character.isDigit(s.charAt(i))))
{
n=5;
break;
}
else
{
}
}
for(int i=0;i<s.length();i++)
{
if((Character.isLetter(s.charAt(i))))
{
n+=5;
break;
}
else
{
}
}
if(n==10)
{
out.print("Password format correct <b>Accepted</b><br>");
}
else
{
out.print("Password must be alphanumeric <b>Declined</b><br>");
}
Explication:
- Commencez par définir le mot de passe en tant que chaîne et créez le jeu entier o.
- Ensuite, vérifiez chaque caractère par pour la boucle.
- S'il trouve un nombre dans la chaîne, le n ajoute 5. Ensuite, passez à la bouclenext pour. Character.isDigit (s.charAt (i))
- Cette boucle vérifie tous les alphabets placés dans la chaîne. Si sa trouve alors Ajouter un plus 5 dans n. Character.isLetter (s.charAt (i))
- Maintenant, vérifions le nombre entier n au moyen de la condition if. Si n = 10 est vrai Chaîne donnée est alphanumérique, sinon ce n'est pas le cas.
Je pense que cela peut aussi le faire (en mode plus simple):
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[^\s]{8,}$
Méthode Java prête à l'emploi, avec paramètres
Il suffit de copier et coller et définir vos paramètres souhaités.
Si vous ne voulez pas de module, commentez-le ou ajoutez un "if" comme je l'ai fait pour les caractères spéciaux
//______________________________________________________________________________
/**
* Validation Password */
//______________________________________________________________________________
private static boolean validation_Password(final String PASSWORD_Arg) {
boolean result = false;
try {
if (PASSWORD_Arg!=null) {
//_________________________
//Parameteres
final String MIN_LENGHT="8";
final String MAX_LENGHT="20";
final boolean SPECIAL_CHAR_NEEDED=true;
//_________________________
//Modules
final String ONE_DIGIT = "(?=.*[0-9])"; //(?=.*[0-9]) a digit must occur at least once
final String LOWER_CASE = "(?=.*[a-z])"; //(?=.*[a-z]) a lower case letter must occur at least once
final String UPPER_CASE = "(?=.*[A-Z])"; //(?=.*[A-Z]) an upper case letter must occur at least once
final String NO_SPACE = "(?=\\S+$)"; //(?=\\S+$) no whitespace allowed in the entire string
//final String MIN_CHAR = ".{" + MIN_LENGHT + ",}"; //.{8,} at least 8 characters
final String MIN_MAX_CHAR = ".{" + MIN_LENGHT + "," + MAX_LENGHT + "}"; //.{5,10} represents minimum of 5 characters and maximum of 10 characters
final String SPECIAL_CHAR;
if (SPECIAL_CHAR_NEEDED==true) SPECIAL_CHAR= "(?=.*[@#$%^&+=])"; //(?=.*[@#$%^&+=]) a special character must occur at least once
else SPECIAL_CHAR="";
//_________________________
//Pattern
//String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
final String PATTERN = ONE_DIGIT + LOWER_CASE + UPPER_CASE + SPECIAL_CHAR + NO_SPACE + MIN_MAX_CHAR;
//_________________________
result = PASSWORD_Arg.matches(PATTERN);
//_________________________
}
} catch (Exception ex) {
result=false;
}
return result;
}
Aussi, vous pouvez faire comme ça.
public boolean isPasswordValid(String password) {
String regExpn =
"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}$";
CharSequence inputStr = password;
Pattern pattern = Pattern.compile(regExpn,Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
if(matcher.matches())
return true;
else
return false;
}
facile
("^ (? =. * [0-9]) (? =. * [Az]) (? =. * [AZ]) (? =. * [\\ W _]) [\\ S] {8 , 10} $ ")
- (? = n'importe quoi) -> signifie que la recherche est positive dans toutes les chaînes en entrée et que cette condition est écrite si pas écrit retour faux .
(?! n'importe quoi) -> (et vice versa) signifie négatif si la condition est écrit retour faux .
sens proche ^ (condition) (condition) (condition) (condition) [\ S] {8,10} $
Celui-ci vérifie chaque caractère spécial:
^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=\S+$).*[A-Za-z0-9].{8,}$