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

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 ?

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}$"

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)

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.

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

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

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/>');
  });

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

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

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
}

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.

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}$/    

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/

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

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.

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

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,}$

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">

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}`);
    });
}

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

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.

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})

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

Verificação de link online https://regex101.com/r/mqGurh/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

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

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.

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

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

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)

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
}

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,}"