Comment pouvez-vous tester si un mot de passe d'adhésion ASP.NET répond aux exigences de complexité configurées?

Question

J'ai une page ASP.NET qui permet à un administrateur de changer le mot de passe pour un utilisateur. Étant donné que l'administrateur ne connaît pas le mot de passe de l'utilisateur, je me sers de ce qui suit:

MembershipUser member = Membership.GetUser(_usernameTextBox.Text); 
member.ChangePassword(member.ResetPassword(), _passNewTextBox.Text); 

- comme décrit par ce SO question.

Si le nouveau mot de passe ne répond pas aux exigences de complexité configurées dans le fichier web.config, le mot de passe aura été réinitialisé, mais pas le mot de passe souhaité. Si le nouveau mot de passe ne répond pas aux exigences de complexité, le mot de passe ne devrait pas changer du tout.

Existe-t-il un moyen facile de tester le nouveau mot de passe par rapport aux exigences de complexité?

Answer 1

Vous pouvez utiliser les propriétés suivantes pour tester le mot de passe contre:

• Membership.PasswordStrengthRegularExpression
• Membership.MinRequiredPasswordLength
• Membership.MinRequiredNonAlphanumericCharacters

Notez que la propriété PasswordStrengthRegularExpression sera une chaîne vide si vous avez pas configuré dans le fichier web.config.

Pour info sur la correspondance d'expression régulière, voir la référence MSDN sur Regex.IsMatch(String)

* Merci à Matt pour les commentaires utiles.

Answer 2

Vous pouvez utiliser un validateur d'expressions régulières pour vérifier si le mot de passe répond aux exigences de complexité.

Vous pouvez également utiliser un contrôle Pasword Strength Meter.

Answer 3

Ce n'est peut-être pas la solution la plus simple, mais utilisez un validateur d'expressions régulières sur la page et faites en sorte qu'il corresponde aux exigences du mot de passe. De cette façon, vous n'avez même pas à poster si le mot de passe n'est pas bon.

Answer 4

/// <summary> 
/// Checks password complexity requirements for the actual membership provider 
/// </summary> 
/// <param name="password">password to check</param> 
/// <returns>true if the password meets the req. complexity</returns> 
static public bool CheckPasswordComplexity(string password) 
{ 
    return CheckPasswordComplexity(Membership.Provider, password); 
} 


/// <summary> 
/// Checks password complexity requirements for the given membership provider 
/// </summary> 
/// <param name="membershipProvider">membership provider</param> 
/// <param name="password">password to check</param> 
/// <returns>true if the password meets the req. complexity</returns> 
static public bool CheckPasswordComplexity(MembershipProvider membershipProvider, string password) 
{ 
    if (string.IsNullOrEmpty(password)) return false; 
    if (password.Length < membershipProvider.MinRequiredPasswordLength) return false; 
    int nonAlnumCount = 0; 
    for (int i = 0; i < password.Length; i++) 
    { 
     if (!char.IsLetterOrDigit(password, i)) nonAlnumCount++; 
    } 
    if (nonAlnumCount < membershipProvider.MinRequiredNonAlphanumericCharacters) return false; 
    if (!string.IsNullOrEmpty(membershipProvider.PasswordStrengthRegularExpression) && 
     !Regex.IsMatch(password, membershipProvider.PasswordStrengthRegularExpression)) 
    { 
     return false; 
    } 
    return true; 
} 

Answer 5

Je n'ai pas accès au wiki.

Une ligne doit être ajustée pour corriger un petit bug.

modifier si (nonAlnumCount < Membership.MinRequiredNonAlphanumericCharacters) comme suit si (nonAlnumCount < membershipProvider.MinRequiredNonAlphanumericCharacters)

Answer 6

Sur la base de la solution de Bamba, je décide de faire une méthode d'extension sur le fournisseur d'appartenances (et réduit la Code:

public static bool IsPasswordValid(this MembershipProvider membershipProvider, string password) 
    { 
     return (!string.IsNullOrEmpty(password) && // Password is not empty or null AND 
      password.Length >= membershipProvider.MinRequiredPasswordLength && // Meets required length AND 
      password.Count(c => !char.IsLetterOrDigit(c)) >= membershipProvider.MinRequiredNonAlphanumericCharacters && // Contains enough non-alphanumeric characters AND 
      (string.IsNullOrEmpty(membershipProvider.PasswordStrengthRegularExpression) || // Either there is no RegEx requirement OR 
       Regex.IsMatch(password, membershipProvider.PasswordStrengthRegularExpression))); // It matches the RegEx 
    } 

pour l'utiliser, il suffit d'appeler Membership.Provider.IsPasswordValid(...) chaque fois que nécessaire

.