segura - validar la complejidad de las contraseñas c#

Expresión regular para validación de contraseña

Question

Actualmente utilizo esta expresión regular para verificar si una cadena cumple con algunas condiciones.

Las condiciones de la cadena deben tener entre 8 y 15 caracteres. La cadena debe contener al menos un número. La cadena debe contener al menos una letra mayúscula. La cadena debe contener al menos una letra minúscula.

(?!^[0-9]*$)(?!^[a-zA-Z]*$)^([a-zA-Z0-9]{8,15})$

Funciona en su mayor parte, pero no permite caracteres especiales. Cualquier ayuda para modificar esta expresión regular para permitir un carácter especial es muy apreciada.

Answer 1

¿Es una expresión regular una forma más fácil / mejor de imponer una restricción simple que la forma más obvia?

static bool ValidatePassword( string password )
{
  const int MIN_LENGTH =  8 ;
  const int MAX_LENGTH = 15 ;

  if ( password == null ) throw new ArgumentNullException() ;

  bool meetsLengthRequirements = password.Length >= MIN_LENGTH && password.Length <= MAX_LENGTH ;
  bool hasUpperCaseLetter      = false ;
  bool hasLowerCaseLetter      = false ;
  bool hasDecimalDigit         = false ;

  if ( meetsLengthRequirements )
  {
    foreach (char c in password )
    {
      if      ( char.IsUpper(c) ) hasUpperCaseLetter = true ;
      else if ( char.IsLower(c) ) hasLowerCaseLetter = true ;
      else if ( char.IsDigit(c) ) hasDecimalDigit    = true ;
    }
  }

  bool isValid = meetsLengthRequirements
              && hasUpperCaseLetter
              && hasLowerCaseLetter
              && hasDecimalDigit
              ;
  return isValid ;

}

¿Cuál cree que será el programador de mantenimiento dentro de 3 años que necesita modificar la restricción y le será más fácil comprenderlo?

Answer 2

Creo que debería ser así:

(?!^[0-9]*$)(?!^[a-zA-Z]*$)^(.{8,15})$

Esto verifica las restricciones con sus clases de caracteres y luego verifica si tiene entre 8 y 15 caracteres. Los caracteres ya no importan, porque ya verificó que sus restricciones coinciden.

Answer 3

Gracias Nicholas Carey. Primero iba a utilizar expresiones regulares, pero lo que escribiste cambió mi opinión. Es mucho más fácil de mantener de esta manera.

//You can set these from your custom service methods
int minLen = 8;
int minDigit 2;
int minSpChar 2;

Boolean ErrorFlag = false;
//Check for password length
if (model.NewPassword.Length < minLen)
{
    ErrorFlag = true;
    ModelState.AddModelError("NewPassword", "Password must be at least " + minLen + " characters long.");
}

//Check for Digits and Special Characters
int digitCount = 0;
int splCharCount = 0;
foreach (char c in model.NewPassword)
{
    if (char.IsDigit(c)) digitCount++;
    if (Regex.IsMatch(c.ToString(), @"[!#$%&''()*+,-.:;<=>?@[///]{}^_`|~]")) splCharCount++;
}

if (digitCount < minDigit)
{
    ErrorFlag = true;
    ModelState.AddModelError("NewPassword", "Password must have at least " + minDigit + " digit(s).");
}
if (splCharCount < minSpChar)
{
    ErrorFlag = true;
    ModelState.AddModelError("NewPassword", "Password must have at least " + minSpChar + " special character(s).");
}

if (ErrorFlag)
    return View(model);

Answer 4

Intente esto (también corrigió la comprobación de mayúsculas y minúsculas, tuvo un error ya que los agrupó como [a-zA-Z], solo busca al menos uno inferior o superior. Así que los separó):

(?!^[0-9]*$)(?!^[a-z]*$)(?!^[A-Z]*$)^(.{8,15})$

Actualización: ¡Encontré que la expresión regular no funciona realmente como se esperaba y esta no es la forma en que se debe escribir también!

Intenta algo como esto:

(?=^.{8,15}$)(?=.*/d)(?=.*[A-Z])(?=.*[a-z])(?!.*/s).*$

(Entre 8 y 15 inclusive, contiene al menos un dígito, al menos una mayúscula y al menos una minúscula y sin espacios en blanco).

Y creo que esto también es más fácil de entender.

Answer 5

Largo, y tal vez podría acortarse. Es compatible con caracteres especiales ?"-_ .

/A(?=[-/?/"_a-zA-Z0-9]*?[A-Z])(?=[-/?/"_a-zA-Z0-9]*?[a-z])(?=[-/?/"_a-zA-Z0-9]*?[0-9])[-/?/"_a-zA-Z0-9]{8,15}/z

Answer 6

Los revisaría uno por uno; es decir, busque un número /d+ , luego, si eso falla, puede decirle al usuario que necesita agregar un dígito. Esto evita devolver un error "no válido" sin sugerirle al usuario qué tiene de malo.

Answer 7

Parece que hay mucha confusión aquí. Las respuestas que veo hasta ahora no aplican correctamente la regla de mayúsculas del número 1+ / 1 + minúsculas / mayúsculas, lo que significa que las contraseñas como abc123 , 123XYZ o AB * & ^ # aún serán aceptadas. Prevenir todo en minúsculas, mayúsculas o todos los dígitos no es suficiente; Tienes que hacer cumplir la presencia de al menos uno de cada uno.

Intenta lo siguiente:

^(?=.*[a-z])(?=.*[A-Z])(?=.*/d).{8,15}$

Si también quieres requerir al menos un carácter especial (lo que probablemente sea una buena idea), prueba esto:

^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)(?=.*[^/da-zA-Z]).{8,15}$

El .{8,15} puede ser más restrictivo si lo desea (por ejemplo, puede cambiarlo a /S{8,15} para no permitir espacios en blanco), pero recuerde que hacerlo reducirá la fortaleza de su esquema de contraseña.

He probado este patrón y funciona como se esperaba. Probado en ReFiddle aquí: http://refiddle.com/110

Edición: una pequeña nota, la forma más fácil de hacerlo es con 3 expresiones regulares separadas y la propiedad Length la cadena. También es más fácil de leer y mantener, así que hazlo de esa manera si tienes la opción. Sin embargo, si esto es para las reglas de validación en el marcado, probablemente esté atascado con una sola expresión regular.

Answer 8

Puedes probar este método:

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,15}");
        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 12 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;
        }
    }

Answer 9

Se puede intentar esto:

(^[/S]*(?=.*[a-z])(?=.*[A-Z])(?=.*[/d])(?=.*[/W_])[/S]{8,15}$)

Además, puedes usar esta página para verificar expresiones regulares:

http://rubular.com/r/ckRwasekcd