Regex para senha deve conter pelo menos oito caracteres, pelo menos um número e letras maiúsculas e minúsculas e caracteres especiais

Eu quero uma expressão regular para verificar que:

Uma senha contém pelo menos oito caracteres, incluindo pelo menos um número e inclui letras maiúsculas e minúsculas e caracteres especiais, por exemplo # ? ! .

Não pode ser sua senha antiga ou conter seu nome de usuário, "password" ou "websitename"

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])(?=.*[AZ])(?=.*[az]).*$" 

Como posso escrevê-lo para uma senha deve ter oito caracteres, incluindo uma letra maiúscula, um caractere especial e caracteres alfanuméricos ?

Mínimo de oito caracteres, pelo menos uma letra e um número:

 "^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$" 

Mínimo de oito caracteres, pelo menos uma letra, um número e um caractere especial:

 "^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$" 

Mínimo de oito caracteres, pelo menos uma letra maiúscula, uma letra minúscula e um número:

 "^(?=.*[az])(?=.*[AZ])(?=.*\d)[a-zA-Z\d]{8,}$" 

Mínimo de oito caracteres, pelo menos uma letra maiúscula, uma letra minúscula, um número e um caractere especial:

 "^(?=.*[az])(?=.*[AZ])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}" 

Mínimo oito e no máximo 10 caracteres, pelo menos uma letra maiúscula, uma letra minúscula, um número e um caractere especial:

 "^(?=.*[az])(?=.*[AZ])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,10}" 

Você pode usar este regex:

 ^(?=.*?[AZ])(?=.*?[az])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$ 

Esta regex aplicará estas regras:

  • Pelo menos uma letra inglesa maiúscula , (?=.*?[AZ])
  • Pelo menos uma letra inglesa minúscula, (?=.*?[az])
  • Pelo menos um dígito, (?=.*?[0-9])
  • Pelo menos um caractere especial, (?=.*?[#?!@$%^&*-])
  • Mínimo oito de comprimento .{8,} (com as âncoras)

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

Mas, expressões regulares têm um operador OR, portanto, basta aplicar o teorema de DeMorgan e escrever um regex que corresponda a senhas inválidas:

Qualquer coisa com menos de oito caracteres ou qualquer coisa sem números ou qualquer coisa sem letras maiúsculas ou qualquer coisa sem letras minúsculas ou qualquer coisa sem caracteres especiais.

Assim:

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

Se alguma coisa corresponde a isso, então é uma senha inválida.

Apenas uma pequena melhora para a resposta de @ anubhava: Como os caracteres especiais são limitados aos do teclado, use-os para qualquer caractere especial:

^(?=.*?[AZ])(?=(.*[az]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{8,}$

Esta regex aplicará estas regras:

  • Pelo menos uma letra inglesa maiúscula
  • Pelo menos uma letra inglesa minúscula
  • Pelo menos um dígito
  • Pelo menos um caractere especial
  • Mínimo oito em comprimento

Eu tive alguma dificuldade em seguir a resposta mais popular para as minhas circunstâncias. Por exemplo, minha validação estava falhando com caracteres como ; ou [ . Eu não estava interessado em listar em branco meus caracteres especiais, então eu optei por [^\w\s] como um teste – simplesmente colocar – combinar caracteres não-palavra (incluindo números) e caracteres não-brancos. Para resumir, aqui está o que funcionou para mim …

  • pelo menos 8 caracteres
  • pelo menos 1 caractere numérico
  • pelo menos 1 letra minúscula
  • pelo menos 1 letra maiúscula
  • pelo menos 1 caractere especial

 /^(?=.*?[AZ])(?=.*?[az])(?=.*?[0-9])(?=.*?[^\w\s]).{8,}$/ 

JSFiddle Link – demo simples cobrindo vários casos

Uma versão mais “genérica” ​​(?), Não permitindo letras inglesas como caracteres especiais .

 ^(?=\S*[az])(?=\S*[AZ])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$ 
 var pwdList = [ '@@V4-\3Z`zTzM{>k', '12qw!"QW12', '123qweASD!"#', '1qA!"#$%&', 'Günther32', '123456789', 'qweASD123', 'qweqQWEQWEqw', '12qwAS!' ], re = /^(?=\S*[az])(?=\S*[AZ])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$/; pwdList.forEach(function (pw) { document.write('' + pw + '
'); });

Importe o arquivo JavaScript jquery.validate.min.js .

Você pode usar este método:

 $.validator.addMethod("pwcheck", function (value) { return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[az]/.test(value) && /[0-9]/.test(value) && /[AZ]/.test(value) }); 
  1. Pelo menos uma letra inglesa maiúscula
  2. Pelo menos uma letra inglesa minúscula
  3. Pelo menos um dígito
  4. Pelo menos um caractere especial

Tente este:

  1. Mínimo de seis caracteres
  2. Pelo menos um caractere maiúsculo
  3. Pelo menos um caractere minúsculo
  4. Pelo menos um caractere especial

Expressão:

 "/^(?=.*[az])(?=.*[AZ])(?=.*\d)(?=.*[$@$!%*?&.])[A-Za-z\d$@$!%*?&.]{6, 20}/" 

Caracteres especiais opcionais:

  1. Pelo menos um caractere especial
  2. Pelo menos um numero
  3. Caracteres especiais são opcionais
  4. Mínimo de seis caracteres e máximo de 16 caracteres

Expressão:

 "/^(?=.*\d)(?=.*[a-zA-Z]).{6,20}$/" 

Se as condições mín e má não forem necessárias, remova .{6, 16}

  • 6 é o limite mínimo de caracteres
  • 20 é o limite máximo de caracteres
  • ? = significa expressão de correspondência
 Use the following Regex to satisfy the below conditions: Conditions: 1] Min 1 uppercase letter. 2] Min 1 lowercase letter. 3] Min 1 special character. 4] Min 1 number. 5] Min 8 characters. 6] Max 30 characters. Regex: /^(?=.*[az])(?=.*[AZ])(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,30}$/ 

Não respondendo diretamente a pergunta, mas ela realmente precisa ser um regex?

Eu costumava fazer muito Perl, e me acostumei a resolver problemas com expressões regulares. No entanto, quando eles ficam mais complicados com todos os olhares e outras peculiaridades, você precisa escrever dezenas de testes de unidade para matar todos esses pequenos bugs.

Além disso, um regex é normalmente algumas vezes mais lento que um imperativo ou uma solução funcional.

Por exemplo, a seguinte function Scala (não muito FP) resolve a questão original cerca de três vezes mais rápido que a expressão regular da resposta mais popular. O que isso faz também é tão claro que você não precisa de um teste unitário:

 def validatePassword(password: String): Boolean = { if (password.length < 8) return false var lower = false var upper = false var numbers = false var special = false password.foreach { c => if (c.isDigit) numbers = true else if (c.isLower) lower = true else if (c.isUpper) upper = true else special = true } lower && upper && numbers && special } 

Eu responderia a Peter Mortensen, mas não tenho reputação suficiente.

Suas expressões são perfeitas para cada um dos requisitos mínimos especificados. O problema com suas expressões que não requerem caracteres especiais é que elas também NÃO PERMITEM caracteres especiais, então elas também impõem os requisitos máximos, o que não acredito que o OP tenha solicitado. Normalmente, você deseja permitir que seus usuários façam a senha tão forte quanto desejarem. Por que restringir senhas fortes?

Então, sua expressão “no mínimo oito caracteres, pelo menos uma letra e um número”:

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

atinge o requisito mínimo, mas os caracteres restantes podem ser apenas letras e números. Para permitir (mas não exigir) caracteres especiais, você deve usar algo como:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ para permitir que qualquer caractere

ou

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ para permitir caracteres especiais específicos

Da mesma forma, “mínimo de oito caracteres, pelo menos uma letra maiúscula, uma letra minúscula e um número:”

^(?=.*[az])(?=.*[AZ])(?=.*\d)[a-zA-Z\d]{8,}$

atende a esse requisito mínimo, mas permite apenas letras e números. Usar:

^(?=.*[az])(?=.*[AZ])(?=.*\d).{8,}$ para permitir que qualquer caractere

ou

^(?=.*[az])(?=.*[AZ])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} para permitir caracteres especiais específicos.

De acordo com sua necessidade, esse padrão deve funcionar bem. Tente isso

 ^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,} 

Basta criar uma variável de string, atribuir o padrão e criar um método booleano que retorne true se o padrão estiver correto, senão false.

Amostra:

 String pattern = "^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}"; String password_string = "Type the password here" private boolean isValidPassword(String password_string) { return password_string.matches(Constants.passwordPattern); } 
 (?=.*[0-9])(?=.*[az])(?=.*[AZ])(?=.*[@#$%^&+-]).{6} 

@ClasG já sugeriu :

 ^(?=\S*[az])(?=\S*[AZ])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$ 

mas não aceita _ (sublinhado) como um caractere especial (por exemplo, Aa12345_).

Um melhorado é:

 ^(?=\S*[az])(?=\S*[AZ])(?=\S*\d)(?=\S*([^\w\s]|[_]))\S{8,}$ 

Você pode usar o padrão de expressão regular abaixo para verificar a senha, se ela corresponde às suas expectativas ou não.

 ((?=.*\\d)(?=.*[az])(?=.*[AZ])(?=.*[~!@#$%^&*()]).{8,20}) 

Em Java / Android, para testar uma senha com pelo menos um número, uma letra, um caractere especial no seguinte padrão:

 "^(?=.*[A-Za-z])(?=.*\\d)(?=.*[$@$!%*#?&])[A-Za-z\\d$@$!%*#?&]{8,}$" 

Tente isto:

 ^.*(?=.{8,})(?=.*[az])(?=.*[AZ])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$ 

Essa expressão regular funciona perfeitamente para mim.

 function myFunction() { var str = "c1TTTTaTTT@"; var patt = new RegExp("^.*(?=.{8,})(?=.*[az])(?=.*[AZ])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$"); var res = patt.test(str); console.log("Is regular matches:", res); } 

Padrão para combinar pelo menos um caractere maiúsculo, um dígito e qualquer caractere especial e o comprimento entre 8 e 63.

“^ (? =. [az]) (? =. [AZ]) (? =. * \ d) [a-zA-Z \ d \ W] {8,63} $”

Este padrão foi usado para programação JAVA.

Use o seguinte Regex para satisfazer as condições abaixo:

 Conditions: 1] Min 1 special character. 2] Min 1 number. 3] Min 8 characters or More 

Regex: ^(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,}$

Pode testar on-line: https://regex101.com

Só podemos fazer isso usando HTML5.

Use abaixo o código no atributo pattern,

 pattern="(?=^.{8,}$)((?=.*\d)(?=.*\W+))(?![.\n])(?=.*[AZ])(?=.*[az]).*$" 

Isso funcionará perfeitamente.

Espero que o abaixo funcione. Eu tentei isso na política personalizada do Azure.

^ (? =. [az]) (? =. [AZ]) (? =. \ d) (? =. [@ # $% ^ & * -_ + = [] {} | \: ‘,? / ~"();!])([A-Za-z\d@#$%^&*\-_+=[\]{}|\\:',?/ ~ “(); !] |. (?! @)) {6,16} $

Uma solução que encontrei em uma das respostas anteriores como:

Mínimo de 8 caracteres, pelo menos, 1 Alfabeto Maiúsculas, 1 Alfabeto Minúsculas, 1 Número e 1 Caractere Especial: “^ (? =. [Az]) (? =. [AZ]) (? =. \ D) (? =. $ @ $!% ? &]) [A-Za-z \ d $ @ $!% ? &] {8,} “

… não funcionou para mim, mas o seguinte é uma versão simplificada e funciona muito bem (adicione qualquer caractere especial que você goste, eu adicionei # aqui), e adicione a regra de número como você faz com as letras como:

 "^(?=.*[az])(?=.*[AZ])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"