O regex da senha deve conter pelo menos oito caracteres, pelo menos um número e letras maiúsculas e minúsculas e caracteres especiais

445

Quero uma expressão regular para verificar se:

Uma palavra-passe contenha, pelo menos, oito caracteres, incluindo, pelo menos, um número e inclui ambas as letras maiúsculas e inferiores 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])(?=.*[A-Z])(?=.*[a-z]).*$"

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

Swapnil Tatkondawar
fonte

Respostas:

1179

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:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\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:

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

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

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,10}$"
Srinivas
fonte
46
"^ (? =. * [A-Za-z]) (? =. * \ D) [A-Za-z \ d] {8,} $" não permite símbolos como um dos 8 caracteres
Wee
Eu achei o seguinte permitido para todos os caracteres (especial e pontuação), sem torná-los obrigatórios: "^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) [a- zA-Z \ d \ w \ W] {8,} $ "
Gavin
413

Você pode usar esse regex com várias asserções de lookahead (condições) :

^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$

Este regex aplicará estas regras:

  • Pelo menos uma letra maiúscula em inglês ,(?=.*?[A-Z])
  • Pelo menos uma letra minúscula em inglês, (?=.*?[a-z])
  • Pelo menos um dígito, (?=.*?[0-9])
  • Pelo menos um caractere especial, (?=.*?[#?!@$%^&*-])
  • Comprimento mínimo de oito .{8,}(com as âncoras)
anubhava
fonte
71

As expressões regulares não têm um operador AND, por isso é muito difícil escrever um regex que corresponda a senhas válidas, quando a validade é definida por algo E outra coisa E outra coisa ...

Mas, expressões regulares têm um operador OR, então aplique o teorema de DeMorgan e escreva 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 maiúsculas OU ou qualquer coisa sem minúsculas OU qualquer coisa sem caracteres especiais.

Assim:

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

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

Matt Timmermans
fonte
3
Ok, eu tinha medo que você fosse um daqueles cientistas da computação que às vezes conhecemos que não percebem que há uma diferença entre expressões regulares e expressões regulares . ;) É verdade que muitas tarefas regex são muito mais simples se você puder negar o resultado da correspondência posteriormente, mas isso nem sempre é possível. Essa é uma bela expressão regular, no entanto. Não é simples, é elegante!
Alan Moore
1
Por que eu não pensei antes? Grande resposta (quando é possível negar o resultado)
TeChn4K
2
este está permitindo espaços como verificar se uma senha não deve conter espaço com seu regexp? Eu tentei isso /^(\s|.{0,7}|[^0-9 ♡**^^AZ ♡*|[^azAZ*|[^azAZ***[^az)*|[^$#@%)*|\s)$/ .test ('aAa # a1a aa'); mas ele não está funcionando
Gaurav
1
@Gaurav, add | [^ \ s] * \ s. *
Matt Timmermans
1
Adoro. Para que funcionasse, tive que remover a última cláusula |[a-zA-Z0-9]*.
i--
35

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

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

Este regex aplicará estas regras:

  • Pelo menos uma letra maiúscula em inglês
  • Pelo menos uma letra minúscula em inglês
  • Pelo menos um dígito
  • Pelo menos um caractere especial
  • Comprimento mínimo de oito
Edwin Beltran
fonte
1
No formato JavaScript, \Wcorresponde apenas a caracteres ASCII. Então você não mudou isso e agora precisa filtrar os caracteres de espaço em branco. Além disso, todos os parênteses e {1,}quantificadores que você adicionou são ruído puro, e remover os ?operadores não gananciosos ( ) era inútil. Não há melhorias aqui.
Alan Moore
E como evitar a cadeia vazia. Regex de cadeia de caracteres vazio deve retornar true. Usei o seguinte regex (? =. * [0-9]) (? =. * [Az]) (? =. * [AZ]) (? =. * [@ # $% ^ & + =]) (? = \\ S + $). {8,15}
Coder
2
falha para _ caractere especial
Akhilesh
22

Tive alguma dificuldade em seguir a resposta mais popular para minhas circunstâncias. Por exemplo, minha validação falhou com caracteres como ;ou [. Eu não estava interessado em listar meus caracteres especiais em branco, então, em vez disso, aproveitei [^\w\s]como teste - basta colocar - combinar caracteres que não sejam palavras (incluindo numéricos) e caracteres que não sejam espaços em branco. Para resumir, aqui está o que funcionou para mim ...

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

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

JSFiddle Link - demo simples que abrange vários casos

scniro
fonte
2
Agradável. mas têm encontrado uma questão que a sua expressão regular não aceitará _ (sublinhado) como um caractere especial :(.
user3217843
Bom, mas um pouco de erros.Ele também aceita Space, que não é uma senha válida se usarmos o espaço.
Dinesh.net
Eu realmente gosto desta resposta, exceto que ela não pode aceitar sublinhados. Tudo que fiz foi substituir (?=.*?[^\w\s])com (?=.*?([^\w\s]|[_]))adicionar suporte para sublinhados e ele funciona muito bem agora. Além disso, o @ Dinish.net, o sistema que eu uso retira o espaço em branco da string de senha quando a obtemos, portanto, usar o método vanilla JS String.prototype.trim () funcionaria bem se você quiser usar esta resposta.
Devin Carpenter
15

Uma versão mais "genérica" ​​(?), Não permitindo letras em inglês como caracteres especiais .

^(?=\S*[a-z])(?=\S*[A-Z])(?=\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*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$/;
  
  pwdList.forEach(function (pw) {
    document.write('<span style="color:'+ (re.test(pw) ? 'green':'red') + '">' + pw + '</span><br/>');
  });

SamWhan
fonte
13

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

Você pode usar este método:

$.validator.addMethod("pwcheck", function (value) {
    return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});
  1. Pelo menos uma letra maiúscula em inglês
  2. Pelo menos uma letra minúscula em inglês
  3. Pelo menos um dígito
  4. Pelo menos um caractere especial
Vikram
fonte
10

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:

"/^(?=.*[a-z])(?=.*[A-Z])(?=.*\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 a condição mínima e máxima não for necessária, remova .{6, 16}

  • 6 é o limite mínimo de caracteres
  • 20 é o limite máximo de caracteres
  • ? = significa expressão de correspondência
ojus kulkarni
fonte
2
@Madhu Eu atualizei a minha resposta para a sua condição para caracteres especiais opcionais
Ojus kulkarni
7

Não está respondendo diretamente à pergunta, mas realmente precisa ser uma regex?

Eu costumava fazer muito Perl e me acostumava a resolver problemas com expressões regulares. No entanto, quando eles ficam mais complicados com todas as expectativas e outras peculiaridades, você precisa escrever dezenas de testes de unidade para eliminar todos esses bugs.

Além disso, uma regex é tipicamente algumas vezes mais lenta que uma solução imperativa ou funcional.

Por exemplo, a seguinte função Scala (não muito FP) resolve a pergunta original cerca de três vezes mais rápido que o regex da resposta mais popular. O que ele faz também é tão claro que você não precisa de um teste de unidade:

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
}
Heikki Salokanto
fonte
7

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 exigem caracteres especiais é que eles também não permitem caracteres especiais; portanto, eles também impõem requisitos máximos, que não acredito que o OP solicitou. Normalmente, você deseja permitir que seus usuários tornem a senha deles tão forte quanto eles querem; por que restringir senhas fortes?

Portanto, sua expressão "mínimo de 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 qualquer caractere

ou

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

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

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

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

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

ou

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

deathwombat
fonte
Obrigada pelo esclarecimento.
Hải Nguyễn
Isso deve ser marcado como a resposta correta. A resposta principal está errada.
Jake
6
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: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,30}$/    
SHASHANK HONRAO
fonte
2
De que maneira sua resposta é melhor do que as outras respostas escritas anos atrás?
JSantos
@ JoshYates1980, você pode mencionar o "Caractere Especial" para o qual a regex falhou para você. Deixe-me verificar com isso e atualizá-lo de acordo. Mas, até onde eu sei, funciona com todos, de acordo com a condição de mandato de 1 caractere especial. Esperando por você resposta ....
Shashank HONRAO
1
@SHASHANKHONRAO Atualizei a expressão para: ^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) (? =. * [$ @ $!% *? & + ~ |{}:;<>/])[A-Za-z\d$@$!%*?&+~| {}:; <> /] {8,15}, que incluirá os seguintes caracteres não alfanuméricos: (@ $!% *? & + ~ `| {}:; <> /)
:; JoshYates1980
6

Que tal considerar a seguinte solução regex:

^(?=.*[\w])(?=.*[\W])[\w\W]{8,}$

O que valida o seguinte:

  1. Pelo menos uma letra minúscula
  2. Pelo menos uma letra maiúscula
  3. Pelo menos um dígito
  4. Pelo menos um caractere especial
  5. Pelo menos, deve ter 8 caracteres.

Confira trabalhando no seguinte link https://regex101.com/r/qPmC06/4/

Emerson Joel Rojas Soliz
fonte
Sua regex sugerida e a do link regex101 variam. Não deveria ser ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W\_])[A-Za-z\d\W\_]{8,}$?
CraZ
1
@ CraZ Eu editei o regex, obrigado pela sua sugestão.
Emerson Joel Rojas Soliz
3

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

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

Apenas crie uma variável de string, atribua o padrão e crie um método booleano que retorne true se o padrão estiver correto, ou 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);
}
Arun Sivanandan
fonte
3

Eu encontrei muitos problemas aqui, então criei os meus.

Aqui está em toda a sua glória, com testes:

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

https://regex101.com/r/DCRR65/4/tests

Coisas a serem observadas:

  1. não usa \wporque isso inclui _, pelo qual estou testando.
  2. Eu tive muitos problemas combinando símbolos, sem combinar o final da linha.
  3. Não especifica símbolos especificamente, isso também ocorre porque locais diferentes podem ter símbolos diferentes em seus teclados que eles podem querer usar.
Stefano
fonte
Este passe regex mesmo quando os espaços em branco é senha dentro, não funcionou para mim
Arthur Melo
2

O @ClasG já sugeriu :

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

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

Um melhor é:

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*([^\w\s]|[_]))\S{8,}$
SONewbiee
fonte
2

Demo:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}
<input type="text" id="password" value="Sample@1">
<input type="button" id="submit" onclick="password_check()" value="submit">

Mohideen bin Mohammed
fonte
2

Testando este em 2020:

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

Verifique-se

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
const str = `some12*Nuts`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Mihir Kumar
fonte
Como isso é melhor do que a resposta aceita?
Toto
@ Para não haver uma resposta aceita neste tópico, pelo menos não vejo nenhuma, há respostas com muitos votos, mas não vejo uma resposta aceita. Além disso, eu encontrei este e li sobre ele no regex101 para obter validade, então compartilhei-o com um trecho de código para verificar a validade também.
Mihir Kumar
1

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 online: https://regex101.com

Samrat Saha
fonte
1

Só podemos fazer isso usando HTML5.

Use o código abaixo no atributo pattern,

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

Funcionará perfeitamente.

Vidya
fonte
1

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)(?=.*[a-z])(?=.*[A-Z])(?=.*[~!@#$%^&*()]).{8,20})
Harshal_Kalavadiya
fonte
1

Usa isto,

((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%?=*&]).{8,20})

Ele validará pelo menos uma letra minúscula, uma maiúscula, um número e os caracteres especiais de (!, @, #, $,%,?, =, *, &).

O comprimento mínimo é 8 e o comprimento máximo é 20

Anand Raja
fonte
Como isso difere da resposta aceita?
Totó
0

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,}$"
Dadaji
fonte
0

Tente o seguinte:

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

Essa expressão regular funciona para mim perfeitamente.

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

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

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

Esse padrão foi usado para a programação JAVA.

Anup Seth
fonte
0

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

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

Venkatesh
fonte
0

Na verdade, eu apenas copiei a primeira resposta aqui e a transformei em um regex mais conveniente para a interface do usuário que precisa de um superior, um inferior e pelo menos 8 caracteres, mas aceita tudo "no meio".

Este é um exemplo-regex que requer

  1. comprimento mínimo de 8 caracteres
  2. pelo menos uma letra minúscula
  3. pelo menos uma letra maiuscula

IMPORTANTE : Este regex também exceto todos os outros caracteres, como números, caracteres especiais como $, # ,! etc. - desde que as regras 1. a 3. correspondam à sequência de entrada

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

Cuidado com o "." no final da regex. Isso corresponderá a quase qualquer caractere (e pode ser legível)

Frithjof Schaefer
fonte
0

Se você deseja usar expressões regulares para verificar no mínimo oito caracteres, pelo menos uma letra maiúscula, pelo menos uma letra minúscula, pelo menos um número de 0 a 9 e pelo menos um caractere especial de:! @ # $% ^ & * _? E também forneça ao usuário mais informações sobre o que está faltando na senha, você pode usar o seguinte código:

let password = "@Aa3a4d$";

//  Check every single condition separately
let lowercase = password.match((/[a-z]+/g));
let uppercase = password.match((/[A-Z]+/g));
let digits = password.match((/[\d]+/g));
let special = password.match((/[!@#$%^&*_]+/g));
let lenght = password.match((/[A-Za-z\d!@#$%^&*_]{8,}/g));

//  Array to store information about any mismatches in the string
let errors = [];

if (password === '' ) {
    errors.push('Password is required');
}
if (lowercase === null) {
    errors.push('Password must include at least one lowercase letter');
}
if (uppercase === null) {
    errors.push('Password must include at least one uppercase letter');
}
if (digits === null) {
    errors.push('Password must include at least one digit from 0 to 9');
}
if (special  === null) {
    errors.push('Password must include at least one special character');
}
if (lenght === null) {
    errors.push('Password must include at least 8 characters');
}
if (errors.length > 0) {
    console.log(errors);
    return;
} else {
    // Process your password
}
Towerss
fonte
-1

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

* Mínimo de 8 caracteres, pelo menos 1 alfabeto maiúsculo, 1 alfabeto minúsculo, 1 número e 1 caractere especial:

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

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

"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"
Carette
fonte
1
Isso está quantificando uma aparência positiva.
Ctwheels