Regex pour des complexes de validation de mot de passe

J'ai regardé autour de sur stackoverflow, etc, mais je n'ai pas trouvé une bonne réponse à cette question..est-ce que la regex de support de l'écriture d'une règle de ce type? Si oui, est-il une regex nos experts là-bas qui peut m'aider à l'écrire, je suis un gros newb de regex et un manque de temps...

Je sais que je peux le faire avec un manuel de fonction en c# à l'aide de c# char, le nombre de méthodes, mais je voudrais utiliser une regex si je peux..

Exigence :

  • Au moins 8 caractères de long
    • 2 lettres
    • 2 chiffres
    • 1 majuscule
    • 1 minuscule
    • 1 Symbole
Si ce sont les règles que vous allez utiliser, je vous déteste. 🙂
Je n'ai pas fait de ces règles 🙂
Exactement 8 caractères ou d'au moins 8 caractères?
N'oubliez pas un hiéroglyphe.
Regex serait beaucoup trop complexe.

OriginalL'auteur kyleb | 2013-06-05

  1. 14

    Vous pouvez utiliser cette expression

    ^(?=(.*\d){2})(?=.*[a-z])(?=.*[A-Z])(?=.*[^a-zA-Z\d]).{8,}$
    ---------  --------------------- --------------- -----
        |               |                    |          |->match 8 or more characters
        |               |                    |->match further only if theres anything except letter or digit
        |               |->match further only if there is an upper-lower case letter
        |
        |->match further only if there are two digits anywhere

    Démo

    il ya une raison pourquoi vous êtes toujours à la modification de votre réponse. 🙂
    Ce qui ne fonctionne pas du tout..
    Ah, après la modification, il fonctionne maintenant.. je ne voudrais pas l'utiliser mais +1 à des fins de piratage.
    ouais..moi 2..
    Un inconvénient de cette est que vous ne pouvez pas dire à l'utilisateur pourquoi leur mot de passe n'est pas valide, vous ne pouvez leur dire qu'il ne l'est pas.

    OriginalL'auteur Anirudha

  2. 18

    Vous êtes beaucoup mieux d'écrire une simple routine de validation pour un mot de passe qui a toutes ces vérifications.

    Une expression régulière ne semble pas que le meilleur (ou le plus extensible) solution pour ce problème particulier.

    if(password.Length < 8)
  return false;

var letters = 0;
var digits = 0;
var uppers = 0;
var lowers = 0;
var symbols = 0;
foreach(var ch in password)
{
   if (char.IsLetter(ch)) letters++;
   if (char.IsDigit(ch)) digits++;
   ....
} 

if(letters < 2) return false;
...
    Alors qu'une regex, c'est beaucoup plus facile à gérer solution.
    Je me penche vers cela, mais je veux voir si n'importe qui peut créer une expression régulière comme cette première..
    +1, nice, concevable et plus maintenable, que d'être comparé à long-long expressions régulières.
    Je tente aussi, mais de ce que j'ai sur l'image, c'est beaucoup trop long.

    OriginalL'auteur Oded

  3. 4

    Je vous recommande de faire le chemin Oded de répondre, en fait, mais je pense que LINQ est un plus lisible et explicite le mécanisme de validation dans ce cas.

    string p = "psW%Rd32";
return p.Length >= 8 &&
    p.Count(c => char.IsDigit(c)) >= 2 &&
    p.Count(c => char.IsUpper(c)) >= 1 &&
    p.Count(c => char.IsLower(c)) >= 1) ...
    Bien que je l'aime, vous itérer plusieurs fois sur la chaîne (une fois par Count).
    retour p.Longueur == 8 est faux. vous devez avoir AU MOINS 8 caractères
    +1 - Bien qu'il nécessite un nombre d'itérations par le biais de la chaîne, il est facile à lire et bien organisé.
    Je savais que tu le prendrais sur la performance. 🙂 Je suppose que c'est en temps réel, la validation d'une zone de texte, pas à parcourir des milliers de mots de passe après le fait. Dans ce cas, nous avons une itération de façon réaliste, pas plus de 1-2 dizaine de personnages, des avantages de performances ne seront pas ressentis sur n'importe quel PROCESSEUR de l'15 dernières années.
    Corrigé, merci

    OriginalL'auteur Rotem

  4. 2

    Vous pouvez essayer cette méthode.

     private bool ValidatePassword(string password, out string ErrorMessage)
{
    var input = password;
    ErrorMessage = string.Empty;

    if (string.IsNullOrWhiteSpace(input))
    {
        throw new Exception("Password should not be empty");
    }

    var hasNumber = new Regex(@"[0-9]+");
    var hasUpperChar = new Regex(@"[A-Z]+");
    var hasMiniMaxChars = new Regex(@".{8,8}");
    var hasLowerChar = new Regex(@"[a-z]+");
    var hasSymbols = new Regex(@"[!@#$%^&*()_+=\[{\]};:<>|./?,-]");

    if (!hasLowerChar.IsMatch(input))
    {
        ErrorMessage = "Password should contain At least one lower case letter";
        return false;
    }
    else if (!hasUpperChar.IsMatch(input))
    {
        ErrorMessage = "Password should contain At least one upper case letter";
        return false;
    }
    else if (!hasMiniMaxChars.IsMatch(input))
    {
        ErrorMessage = "Password should not be less than or greater than 8 characters";
        return false;
    }
    else if (!hasNumber.IsMatch(input))
    {
        ErrorMessage = "Password should contain At least one numeric value";
        return false;
    }

    else if (!hasSymbols.IsMatch(input))
    {
        ErrorMessage = "Password should contain At least one special case characters";
        return false;
    }
    else
    {
        return true;
    }
}
    J'aime cette approche mieux. Merci
    Thankss
    -1 : cela échoue sur les Normes d'Accessibilité - tous les messages d'erreur doivent être retournés dans une seule et même réponse. Cette méthode pourrait provoquer de multiples tentatives de la même entrée avec différentes réponses d'erreur. Il devrait être remaniée pour tester toutes les règles et de retourner une collection d'erreurs

    OriginalL'auteur Anurag