asp.net - tutorial - membership visual studio 2017

¿Cómo se puede probar si una contraseña de membresía de ASP.NET cumplirá con los requisitos de complejidad configurados?

Question

Tengo una página ASP.NET que permite a un administrador cambiar la contraseña de un usuario. Como el administrador no conoce la contraseña del usuario, estoy usando lo siguiente:

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

- como se describe en esta pregunta SO .

Si la nueva contraseña no cumple con los requisitos de complejidad que están configurados en el archivo web.config, la contraseña se habrá restablecido, pero no se habrá cambiado a la deseada. Si la nueva contraseña no cumple con los requisitos de complejidad, la contraseña no debe cambiar en absoluto.

¿Existe alguna manera fácil de probar la nueva contraseña contra los requisitos de complejidad?

Answer 1

Puede que no sea la manera más fácil, pero use un validador de expresiones regular en la página y haga que coincida con los requisitos de contraseña. De esta forma, ni siquiera tendrá que volver a publicar si la contraseña no es buena.

Answer 2

Puede usar las siguientes propiedades para probar la contraseña contra:

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

Tenga en cuenta que la propiedad PasswordStrengthRegularExpression será una cadena vacía si no la ha configurado en el archivo web.config.

Para obtener información sobre la coincidencia de expresiones regulares, consulte la referencia de MSDN en Regex.IsMatch (String)

* Gracias a Matt por los útiles comentarios.

Answer 3

Puede usar un Validador de expresiones regulares para verificar si la contraseña cumple con los requisitos de complejidad.

También puede usar un control de medidor de fuerza Pasword .

Answer 4

No tengo acceso a la wiki.

Una línea debe ajustarse para arreglar un pequeño error.

modifique if (nonAlnumCount <Membership.MinRequiredNonAlphanumericCharacters) de la siguiente manera if (nonAlnumCount <membershipProvider.MinRequiredNonAlphanumericCharacters)

Answer 5

/// <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 6

Basado en la solución de Bamba, decidí hacer un método de extensión para el proveedor de membresía (y reduje el código:

    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
    }

Para usarlo, solo debe llamar a Membership.Provider.IsPasswordValid(...) donde sea necesario.