Expressão regular para verificar se a senha é “8 caracteres incluindo 1 letra maiúscula, 1 caractere especial, caracteres alfanuméricos”

Eu quero uma expressão regular para verificar isso

a senha deve ter oito caracteres, incluindo uma letra maiúscula, um caractere especial e caracteres alfanuméricos.

E aqui está minha expressão de validação que é para oito caracteres, incluindo uma letra maiúscula, uma letra minúscula e um número ou caractere especial.

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

Como posso escrever para uma senha de oito caracteres, incluindo uma letra maiúscula, um caractere especial e caracteres alfanuméricos?

A expressão regular que você procura provavelmente será enorme e um pesadelo de se manter, especialmente para pessoas que não estão familiarizadas com expressões regulares.

Acho que seria mais fácil quebrar sua regex e fazer isso um pouco de cada vez. Pode demorar um pouco mais, mas tenho certeza de que mantê-lo e depurá-lo seria mais fácil. Isso também permitiria que você fornecesse mensagens de erro mais direcionadas aos seus usuários (além de apenas Invalid Password), o que deve melhorar a experiência do usuário.

Pelo que estou vendo, você é bastante fluente em regex, então presumo que fornecer as expressões regulares para fazer o que você precisa seria inútil.

Vendo seu comentário, é assim que eu faria:

• Deve ter oito caracteres: você não precisa de uma regex para isso. Usar a .Lengthpropriedade deve ser suficiente.

• Incluindo uma letra maiúscula: você pode usar a [A-Z]+expressão regular. Se a string contiver pelo menos uma letra maiúscula, essa expressão regular resultará true.

• Um caractere especial: Você pode usar o \Wque corresponderá a qualquer caractere que não seja uma letra ou um número ou então, você pode usar algo assim [!@#]para especificar uma lista personalizada de caracteres especiais. Nota que embora personagens como $, ^, (e )são caracteres especiais na linguagem de expressão regular, então eles precisam ser escapado assim: \$. Resumindo, você pode usar o \W.

• Caracteres alfanuméricos: o uso de \w+deve corresponder a qualquer letra, número e sublinhado.

Dê uma olhada neste tutorial para obter mais informações.

(                   # 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

Em uma linha:

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

Editar 28/05/2019:

Você precisa corresponder a toda a string de entrada. Portanto, você pode delimitar a regex entre ^e $para evitar assumir acidentalmente correspondências parciais como correspondendo à entrada inteira:

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

Fontes:

• Expressão de correspondência de senha

• Validação de força de senha com expressões regulares

Tantas respostas .... todas ruins!

Expressões regulares não têm um operador AND, então é muito difícil escrever uma regex que corresponda a senhas válidas, quando a validade é definida por algo E algo mais E algo mais ...

Mas, expressões regulares fazem têm um operador OR, por isso, basta aplicar o teorema de DeMorgan, e escrever um regex que corresponde inválidos senhas.

qualquer coisa com menos de 8 caracteres OU qualquer coisa sem números OU qualquer coisa sem maiúsculas OU qualquer coisa sem caracteres especiais

Assim:

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

Se alguma coisa corresponder a isso, é uma senha inválida .

A resposta é não usar uma expressão regular. Isso é jogos e contagem.

As expressões regulares são uma questão de ordem.

Em sua vida como programador, você terá que fazer muitas coisas que não fazem sentido. Aprenda a cavar um nível mais profundo. Aprenda quando a pergunta está errada.

A pergunta (se mencionou expressões regulares) está errada.

Pseudocódigo (tem alternado entre muitas linguagens, ultimamente):

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)

Aposto que você leu e entendeu o código acima quase instantaneamente. Aposto que você demorou muito mais com a regex e tem menos certeza de que está correto. Estender a regex é arriscado. Estendeu o imediato acima, muito menos.

Observe também que a pergunta foi formulada de maneira imprecisa. O conjunto de caracteres é ASCII ou Unicode ou ?? Meu palpite, ao ler a pergunta, é que pelo menos um caractere minúsculo é assumido. Portanto, acho que a última regra assumida deve ser:

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

(Mudar de chapéu para focado na segurança, esta é uma regra realmente irritante / inútil.)

Aprender a saber quando a pergunta está errada é muito mais importante do que respostas inteligentes. Uma resposta inteligente para a pergunta errada quase sempre está errada.

Como um exemplo de como isso poderia ser feito com um regex legível / sustentável.

Para uma regex mais longa, você sempre deve usar RegexOptions.IgnorePatternWhitespacepara permitir espaços em branco e comentários na expressão para melhor legibilidade.

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();

Se você precisar de apenas uma caixa alta e um caractere especial, isso deve funcionar:

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

A expressão regular que você estava procurando: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/u.

Exemplo e teste: http://regexr.com/3fhr4

Esta pergunta começa a ser viral e aparecem muitas sugestões interessantes.

Sim, escrever à mão é difícil. Portanto, uma solução mais fácil é usar um modelo. Embora o regex resultante possa não ser o ideal, será mais fácil manter e / ou alterar, e o usuário terá um melhor controle sobre o resultado. É possível que eu tenha perdido alguma coisa, então qualquer crítica construtiva será útil.

Estes links podem ser interessantes: corresponder a pelo menos 2 dígitos 2 letras em qualquer ordem em uma string , Linguagem de Expressão Regular , Grupos de captura

Estou usando este modelo com (?=(?:.*?({type})){({count})})base em todas as regex que vi no SO. A próxima etapa é substituir o padrão necessário ( number, special character...) e adicionar configuração para comprimento.

Eu fiz uma pequena classe para compor o regex PasswordRegexGenerator.cs Um exemplo:

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 ( ) + ")";
    }
}

Você pode usar a classe abaixo para validação:

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();

  }
}

onde 6 e 20 são os tamanhos mínimo e máximo para a senha.

• Use uma expressão sem retrocesso para corresponder à senha inteira primeiro, se ela tiver pelo menos 8 caracteres (dessa forma, não há explosão combinatória por muito tempo, mas senhas inválidas): (?>{8,})
• Use as declarações lookbehind para verificar a presença de todos os caracteres necessários (condições AND). (?<=...)
• Pelo menos um caractere maiúsculo: (?<=\p{Lu}.*)
• Pelo menos um caractere especial (um pouco ambíguo, mas vamos usar não palavra): (?<=\W.*)
• Pelo menos um caractere alfanumérico (: (?<=\w.*)

Resumido:

(?>.{8,})(?<=\p{Lu}.*)(?<=\W.*)(?<=\w.*)

O melhor é não usar regex para tudo. Esses requisitos são muito leves. Em operações de string baseadas na CPU para verificar os critérios / validação é muito mais barato e rápido do que regex!

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