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

L'expression régulière que vous recherchez sera très probablement énorme et un cauchemar à maintenir, en particulier pour les personnes qui ne sont pas familières avec les expressions régulières.

Je pense qu'il serait plus facile de décomposer votre regex et de le faire petit à petit. Cela pourrait prendre un peu plus de temps, mais je suis presque sûr que la maintenance et le débogage seraient plus faciles. Cela vous permettrait également de fournir des messages d'erreur plus ciblés à vos utilisateurs (autres que simplement Invalid Password ), ce qui devrait améliorer l'expérience des utilisateurs.

D'après ce que je vois, vous maîtrisez assez bien les expressions régulières, donc je suppose qu'il serait futile de vous donner les expressions régulières pour faire ce dont vous avez besoin.

Au vu de votre commentaire, voici comment je procéderais :

• Doit être long de huit caractères : vous n'avez pas besoin d'une expression rationnelle pour cela. L'utilisation de l'option .Length devrait suffire.

• Dont une lettre majuscule : Vous pouvez utiliser la touche [A-Z]+ expression régulière. Si la chaîne contient au moins une lettre majuscule, cette expression régulière donnera true .

• Un caractère spécial : Vous pouvez utiliser soit le \W qui correspondra à tout caractère qui n'est pas une lettre ou un chiffre ou encore, vous pouvez utiliser quelque chose comme ceci [!@#] pour spécifier une liste personnalisée de caractères spéciaux. Notez toutefois que les caractères tels que $ , ^ , ( y ) sont des caractères spéciaux dans le langage des expressions régulières, et doivent donc être échappés de cette manière : \$ . En résumé, vous pouvez donc utiliser la fonction \W .

• Caractères alphanumériques : En utilisant la touche \w+ doit correspondre à n'importe quelle lettre, n'importe quel chiffre et n'importe quel trait de soulignement.

Jetez un coup d'œil à cette pour plus d'informations.

Answer 2

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

En une ligne :

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

Editer 2019-05-28 :

Vous devez faire correspondre la totalité de la chaîne d'entrée. Vous pouvez donc enfermer la regex entre ^ y $ afin d'éviter de considérer accidentellement que des correspondances partielles correspondent à l'ensemble de l'entrée :

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

Sources :

• Expression de correspondance du mot de passe

• Validation de la force du mot de passe à l'aide d'expressions régulières

Answer 3

Autant de réponses.... toutes mauvaises !

Les expressions régulières n'ont pas d'opérateur ET, il est donc assez difficile d'écrire une expression rationnelle qui corresponde à des mots de passe valides, alors que la validité est définie par quelque chose ET quelque chose d'autre ET quelque chose d'autre...

Mais les expressions régulières faire ont un opérateur OR, il suffit donc d'appliquer le théorème de DeMorgan, et d'écrire une regex qui correspond à invalide mots de passe.

tout ce qui contient moins de 8 caractères OU tout ce qui n'est pas numéroté OU tout ce qui n'a pas de majuscule OU tout ce qui n'a pas de caractères spéciaux

Ainsi :

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

Si quelque chose correspond, il s'agit d'un invalide mot de passe.

Answer 4

La réponse est de ne pas utiliser d'expression régulière. Il s'agit d'ensembles et de comptages.

Les expressions régulières sont une question d'ordre.

Dans votre vie de programmeur, on vous demandera de faire beaucoup de choses qui n'ont pas de sens. Apprenez à creuser un peu plus. Apprenez quand la question n'est pas la bonne.

La question (si elle mentionne les expressions régulières) est erronée.

Pseudocode (je suis passé d'un langage à l'autre ces derniers temps) :

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)

Je parie que vous avez lu et compris le code ci-dessus presque instantanément. Je parie que vous avez pris beaucoup plus de temps avec l'expression rationnelle et que vous n'êtes pas certain qu'elle soit correcte. L'extension de la regex est risquée. L'extension de la regex immédiate ci-dessus l'est beaucoup moins.

Il convient également de noter que la question est formulée de manière imprécise. Le jeu de caractères est-il ASCII ou Unicode, ou ? D'après la lecture de la question, je suppose qu'au moins un caractère minuscule est supposé. Je pense donc que la dernière règle supposée devrait être :

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

(En changeant de casquette pour se concentrer sur la sécurité, il s'agit d'une vraiment règle ennuyeuse/non utile).

Apprendre à savoir quand la question est fausse est bien plus important que des réponses intelligentes. Une réponse intelligente à une mauvaise question est presque toujours erronée.

Answer 5

Voici un exemple de ce que l'on pourrait faire avec une expression rationnelle lisible et facile à maintenir.

Pour une expression rationnelle plus longue, vous devez toujours utiliser RegexOptions.IgnorePatternWhitespace pour autoriser les espaces et les commentaires dans l'expression afin d'en améliorer la lisibilité.

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