Expression régulière .NET pour créer mot de passe fort

Question

Voici l'expression régulière .NET que j'utilise pour créer un mot de passe (qui ne correspond pas à mes exigences de mot de passe du projet):

(?=^.{15,25}$)(\d{2,}[a-z]{2,}[A-Z]{2,}[!@#$%&+~?]{2,}) 

exigences de mot de passe:

1. minimum 15 caractères (jusqu'à 25)
2. Deux numéros
3. Deux lettres majuscules
4. Deux lettres Minuscules
5. Deux caractères spéciaux ! @ # $ % & + ~ ?

Ils ne sont pas tenus d'être à côté de l'autre & dans l'ordre spécifique l'expression régulière que je collais exige.

ci-dessus Expression régulière nécessite un mot de passe comme ceci: 12abCD @QWertyP

Il leur demande dans l'ordre spécifique dans le RE ... qui est pas ce que je veux!

Cela devrait passer un RE correctement formaté avec les spécifications ci-dessus: Qq1W w2Ee # 3Rr4 @ TT5

Comment puis-je supprimer la nécessité pour eux d'être à côté les uns des autres et pour ?? Évidemment le mot de passe devrait être aléatoire si la personne le choisit.

Answer 1

Je pense que vous cherchez plus que ce que l'expression rationnelle a été conçu pour faire.

Considérons une méthode C#/VB comme ceci:

bool IsStrongPassword(String password) 
{ 
    int upperCount = 0; 
    int lowerCount = 0; 
    int digitCount = 0; 
    int symbolCount = 0; 

    for (int i = 0; i < password.Length; i++) 
    { 
     if (Char.IsUpper(password[ i ])) 
      upperCount++; 
     else if (Char.IsLetter(password[ i ])) 
      lowerCount++; 
     else if (Char.IsDigit(password[ i ])) 
      digitCount++; 
     else if (Char.IsSymbol(password[ i ])) 
      symbolCount++; 
    } 

    return password.Length >= 15 && upperCount >= 2 && lowerCount >= 2 && digitCount >= 2 && symbolCount >= 2; 
} 

Answer 2

Pour autant que je sache, vous ne pouvez pas le faire raisonnablement, ce qui signifie que vous auriez à la liste toutes les combinaisons de commandes possibles dans l'expression rationnelle, qui ajouterait jusqu'à 24 combinaisons.

je ferais 4 chèques distincts:

• \d{2,}
• [a-z]{2,}
• [A-Z]{2,}
• [!@#$%&+~?]{2,}

question connexe: Variable order regex syntax

En passant, vos règles me semblent trop lourdes. Je les reconsidérerais, par exemple, pour avoir 3 caractères de deux d'etters, de chiffres ou de symboles.

Answer 3

Exiger un de chaque type de personnage, vous pouvez utiliser ceci:

(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%&+~?])^.{15,25}$

Je ne suis pas tout à fait sûr de savoir comment traduire qu'exiger deux de chaque type de caractère, bien que.Fondamentalement, le ?= correspond à un suffixe .* (c'est-à-dire n'importe quoi), mais ne capture rien, vous pouvez donc vérifier que toutes les conditions sont remplies en spécifiant l'ordre.

Answer 4

^(?=.*\d.*\d)(?=.*[a-z].*[a-z])(?=.*[A-Z].*[A-Z])(?=.*[!@#$%&+~?].*[!@#$%&+~?]).{15,25}$ 

Cette regex fera ce que vous voulez. Il fera jusqu'à 5 passages à travers votre chaîne de mot de passe, mais compte tenu de ce que vous faites avec, je ne m'attends pas à ce que ce soit un problème. Edité pour corriger une faute de frappe qui a ruiné l'expression rationnelle.

Answer 5

Ce sera beaucoup plus lisible et maintenable dans le code classique:

Le pseudo-code serait:

int count_alpha = 0, count_digit = 0, count_symbol = 0, ... 

for each ch in password: 
    if is_alpha(ch): 
    count_alpha += 1 
    elif is_digit(ch): 
    count_digit += 1 
    ... 

if (count_alpha < 2) or (count_digit < 2) or ... 
    rejection_message() 
    ... 

Il se pourrait que vous mettre en œuvre les exigences plutôt que dans une position de les influencer, mais je recommande généralement d'estimer l'entrophie et d'utiliser le code existant pour le faire.

Answer 6

Je pense qu'il pourrait être aussi suivre aussi: (. = ( [az]) {2,})?

^(?. = (\ d) {2,}) (= (. [AZ]) {2,}) (? = (. [! @ # $% & + ~?]) {2,})). {15,25}

$

Answer 7

^((?=(.*\d){2,})(?=(.*[a-z]){2,})(?=(.*[A-Z]){2,})(?=(.*[!@#$%&+~?]){2,})).{15,25}$ 

Je sais que c'est un an, mais d'après les quelques réponses, j'ai compris que cela fonctionnerait.

La première réponse est correcte, sauf qu'elle a juste besoin d'un * précédant le motif.