c# - online - regex quick reference

Expresión regular para verificar si la contraseña es "8 caracteres, incluyendo 1 letra mayúscula, 1 carácter especial, caracteres alfanuméricos"

Question

Quiero una expresión regular para verificar que

una contraseña debe tener ocho caracteres, incluyendo una letra mayúscula, un carácter especial y caracteres alfanuméricos.

Y aquí está mi expresión de validación, que es para ocho caracteres, incluyendo una letra mayúscula, una letra minúscula y un número o carácter especial.

(?=^.{8,}$)((?=.*/d)|(?=.*/W+))(?![./n])(?=.*[A-Z])(?=.*[a-z]).*$"

¿Cómo puedo escribirlo para obtener una contraseña que debe tener ocho caracteres, incluyendo una letra mayúscula, un carácter especial y caracteres alfanuméricos?

Answer 1

Como ejemplo, cómo esto podría hacerse con una expresión regular legible / mantenible.

Para una expresión regular más larga siempre debe usar RegexOptions.IgnorePatternWhitespace para permitir espacios en blanco y comentarios en la expresión para una mejor legibilidad.

String[] passwords = { "foobar", "Foobar", "Foobar1", "Fooobar12" };

foreach (String s in passwords) {

    Match password = Regex.Match(s, @"
                                      ^              # Match the start of the string
                                       (?=.*/p{Lu})  # Positive lookahead assertion, is true when there is an uppercase letter
                                       (?=.*/P{L})   # Positive lookahead assertion, is true when there is a non-letter
                                       /S{8,}        # At least 8 non whitespace characters
                                      $              # Match the end of the string
                                     ", RegexOptions.IgnorePatternWhitespace);

    if (password.Success) {
        Console.WriteLine(s + ": valid");
    }
    else {
        Console.WriteLine(s + ": invalid");
    }
}

Console.ReadLine();

Answer 2

Esta pregunta comienza a ser viral y aparecen muchas sugerencias interesantes.

Sí, escribir a mano es difícil. Entonces, una solución más fácil es usar una plantilla. Aunque la expresión regular resultante puede no ser la más óptima, será más fácil de mantener y / o cambiar, y el usuario tendrá un mejor control sobre el resultado. Es posible que me haya perdido algo, por lo que cualquier crítica constructiva será útil.

Estos enlaces pueden ser interesantes: haga coincidir al menos 2 dígitos 2 letras en cualquier orden en una cadena , Lenguaje de expresión regular , Grupos de captura

Estoy usando esta plantilla (?=(?:.*?({type})){({count})}) base a todas las expresiones regulares que vi en SO. El siguiente paso es reemplazar el patrón necesario ( number , special character ...) y agregar la configuración de longitud.

He hecho una pequeña clase para componer el regex PasswordRegexGenerator.cs Un ejemplo:

string result = new PasswordRegexGenerator ( )
        .UpperCase ( 3, -1 )    // ... {3,}
        .Number ( 2, 4 )        // ... {2,4}
        .SpecialCharacter ( 2 ) // ... {2}
        .Total ( 8,-1 )
        .Compose ( );

/// <summary>
/// Generator for regular expression, validating password requirements.
/// </summary>
public class PasswordRegexGenerator
{
    private string _elementTemplate = "(?=(?:.*?({type})){({count})})";

    private Dictionary<string, string> _elements = new Dictionary<string, string> {
        { "uppercase", "[A-Z]" },
        { "lowercase", "[a-z]" },
        { "number", @"/d" },
        { "special", @"/W" },
        { "alphanumeric", @"/w" }
    };

    private StringBuilder _sb = new StringBuilder ( );

    private string Construct ( string what, int min, int max )
    {
        StringBuilder sb = new StringBuilder ( _elementTemplate );
        string count = min.ToString ( );

        if ( max == -1 )
        {
            count += ",";
        }
        else if ( max > 0 )
        {
            count += "," + max.ToString();
        }

        return sb
            .Replace ( "({type})", what )
            .Replace ( "({count})", count )
            .ToString ( );
    }

    /// <summary>
    /// Change the template for the generation of the regex parts
    /// </summary>
    /// <param name="newTemplate">the new template</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexTemplate ( string newTemplate )
    {
        _elementTemplate = newTemplate;
        return this;
       }

    /// <summary>
    /// Change or update the regex for a certain type ( number, uppercase ... )
    /// </summary>
    /// <param name="name">type of the regex</param>
    /// <param name="regex">new value for the regex</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexElements ( string name, string regex )
    {
        if ( _elements.ContainsKey ( name ) )
        {
            _elements[ name ] = regex;
        }
        else
        {
            _elements.Add ( name, regex );
        }
        return this;
    }

    #region construction methods 

    /// <summary>
    /// Adding number requirement
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <returns></returns>
    public PasswordRegexGenerator Number ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "number" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator UpperCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "uppercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator LowerCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "lowercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator SpecialCharacter ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "special" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator Total ( int min, int max = 0 )
    {
        string count = min.ToString ( ) + ( ( max == 0 ) ? "" : "," + max.ToString ( ) );
        _sb.Append ( ".{" + count + "}" );
        return this;
    }

    #endregion

    public string Compose ()
    {
        return "(" + _sb.ToString ( ) + ")";
    }
}

Answer 3

La expresión regular que está buscando probablemente sea enorme y una pesadilla para mantener especialmente para las personas que no están tan familiarizadas con las expresiones regulares.

Creo que sería más fácil romper tu expresión regular y hacerlo de a poco. Podría tomar un poco más para hacer, pero estoy bastante seguro de que mantenerlo y depurarlo sería más fácil. Esto también le permitirá proporcionar mensajes de error más dirigidos a sus usuarios (que Invalid Password sean solo la Invalid Password ), lo que debería mejorar la experiencia del usuario.

Por lo que estoy viendo, eres bastante fluido en expresiones regulares, así que supongo que darte las expresiones regulares para hacer lo que necesitas sería inútil.

Al ver tu comentario, así es como lo haría:

• Debe tener ocho caracteres. Longitud: no necesita una expresión regular para esto. Usar la propiedad .Length debería ser suficiente.

• Incluyendo una letra mayúscula: puede usar la expresión regular [AZ]+ . Si la cadena contiene al menos una letra mayúscula, esta expresión regular arrojará true .

• Un carácter especial: puede usar /W que coincidirá con cualquier carácter que no sea una letra o un número. De lo contrario, puede usar algo como [!@#] Para especificar una lista personalizada de caracteres especiales. Sin embargo, tenga en cuenta que los caracteres como $ , ^ , ( y ) son caracteres especiales en el lenguaje de expresiones regulares, por lo que deben escaparse de la siguiente manera: /$ . En resumen, puede usar el /W

• Caracteres alfanuméricos: el uso de /w+ debe coincidir con cualquier letra, número y guión bajo.

Echa un vistazo a this tutorial para obtener más información.

Answer 4

La expresión regular que estaba buscando es: /^(?=.*[az])(?=.*[AZ])(?=.*[0-9])(?=.*[!@#/$%/^&/*/[/]"/';:_/-<>/., =/+////]).{8,}$/u .

Ejemplo y prueba: http://regexr.com/3fhr4

Answer 5

La respuesta es no usar una expresión regular. Esto es conjuntos y contando.

Las expresiones regulares son sobre orden.

En tu vida como programador, se te pedirá que hagas muchas cosas que no tienen sentido. Aprende a cavar un nivel más profundo. Aprende cuando la pregunta es incorrecta.

La pregunta (si menciona expresiones regulares) es incorrecta.

Pseudocódigo (ha cambiado entre muchos idiomas, últimamente):

if s.length < 8:
    return False
nUpper = nLower = nAlphanum = nSpecial = 0
for c in s:
    if isUpper(c):
        nUpper++
    if isLower(c):
        nLower++
    if isAlphanumeric(c):
        nAlphanum++
    if isSpecial(c):
        nSpecial++
return (0 < nUpper) and (0 < nAlphanum) and (0 < nSpecial)

Apuesto a que leíste y entendiste el código anterior casi al instante. Apuesto a que tomó mucho más tiempo con la expresión regular, y está menos seguro de que sea correcta. Extender la expresión regular es arriesgado. Extendió el inmediato anterior, mucho menos.

Tenga en cuenta también que la pregunta está redactada de manera imprecisa. ¿El conjunto de caracteres es ASCII o Unicode, o? Supongo que al leer la pregunta es que se supone al menos un carácter en minúscula. Entonces creo que la última regla supuesta debería ser:

return (0 < nUpper) and (0 < nLower) and (0 < nAlphanum) and (0 < nSpecial)

(Cambiando los sombreros a enfocados en la seguridad, esta es una regla realmente molesta / no útil.)

Aprender a saber cuándo la pregunta es incorrecta es enormemente más importante que las respuestas inteligentes. Una respuesta inteligente a la pregunta incorrecta casi siempre es incorrecta.

Answer 6

Puede usar la clase inferior para la validación:

public class PasswordValidator{

  private Pattern pattern;
  private Matcher matcher;

  private static final String PASSWORD_PATTERN =
          "((?=.*//d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";

  public PasswordValidator(){
      pattern = Pattern.compile(PASSWORD_PATTERN);
  }

  /**
   * Validate password with regular expression
   * @param password password for validation
   * @return true valid password, false invalid password
   */
  public boolean validate(final String password){

      matcher = pattern.matcher(password);
      return matcher.matches();

  }
}

donde 6 y 20 son longitud mínima y máxima para la contraseña.

Answer 7

Si solo necesita una mayúscula y un carácter especial, esto debería funcionar:

@"^(?=.{8,}$)(?=[^A-Z]*[A-Z][^A-Z]*$)/w*/W/w*$"

Answer 8

Tantas respuestas ... ¡todo mal!

Las expresiones regulares no tienen un operador AND, por lo que es bastante difícil escribir una expresión regular que coincida con las contraseñas válidas, cuando la validez está definida por algo Y algo más Y algo más ...

Pero, las expresiones regulares tienen un operador OR, así que solo aplica el teorema de DeMorgan y escribe una expresión regular que coincida con las contraseñas no válidas .

cualquier cosa con menos de 8 caracteres O cualquier cosa sin números O cualquier cosa sin mayúsculas O cualquier cosa sin caracteres especiales

Asi que:

^(.{0,7}|[^0-9]*|[^A-Z]*|[a-zA-Z0-9]*)$

Si algo coincide con eso, entonces es una contraseña inválida .

Answer 9

(                   # Start of group
    (?=.*/d)        #   must contain at least one digit
    (?=.*[A-Z])     #   must contain at least one uppercase character
    (?=.*/W)        #   must contain at least one special symbol
       .            #     match anything with previous condition checking
         {8,8}      #        length is exactly 8 characters
)                   # End of group

En una línea:

((?=.*/d)(?=.*[A-Z])(?=.*/W).{8,8})

Fuentes:

• Expresión de coincidencia de contraseña

• Validación de la solidez de la contraseña con expresiones regulares

Answer 10

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