Regex para contraseña debe contener al menos ocho caracteres, al menos un número y letras mayúsculas y minúsculas y caracteres especiales

Quiero una expresión regular para verificar eso:

Una contraseña contiene al menos ocho caracteres, incluyendo al menos un número e incluye tanto las letras minúsculas y mayúsculas y caracteres especiales, por ejemplo #, ?, !.

No puede ser su contraseña anterior o contener su nombre de usuario "password", o"websitename"

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 una contraseña que debe tener ocho caracteres, incluyendo una letra mayúscula, un carácter especial y caracteres alfanuméricos ?

Mínimo ocho caracteres, al menos una letra y un número:

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

Mínimo ocho caracteres, al menos una letra, un número y un carácter especial:

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

Mínimo ocho caracteres, al menos una letra mayúscula, una letra minúscula y un número:

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

Mínimo ocho caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

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

Mínimo ocho y máximo 10 caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

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

Puede usar esta expresión regular con múltiples aserciones anticipadas (condiciones) :

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

Esta expresión regular hará cumplir estas reglas:

• Al menos una letra mayúscula en inglés ,(?=.*?[A-Z])
• Al menos una letra minúscula en inglés, (?=.*?[a-z])
• Al menos un dígito, (?=.*?[0-9])
• Al menos un personaje especial, (?=.*?[#?!@$%^&*-])
• Mínimo ocho de longitud .{8,}(con los anclajes)

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

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

Cualquier cosa con menos de ocho caracteres O cualquier cosa sin números O cualquier cosa sin mayúsculas O cualquier cosa sin minúsculas O cualquier cosa sin caracteres especiales.

Entonces:

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

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

Solo una pequeña mejora para la respuesta de @anubhava: dado que los caracteres especiales están limitados a los del teclado, use esto para cualquier carácter especial:

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

Esta expresión regular hará cumplir estas reglas:

• Al menos una letra mayúscula en inglés
• Al menos una letra minúscula en inglés
• Al menos un dígito
• Al menos un personaje especial
• Mínimo ocho de longitud

Tuve algunas dificultades para seguir la respuesta más popular para mis circunstancias. Por ejemplo, mi validación estaba fallando con caracteres como ;o [. No estaba interesado en incluir en una lista blanca mis caracteres especiales, por lo que en su lugar aproveché [^\w\s]como prueba, simplemente poner, coincide con los caracteres que no son palabras (incluidos los numéricos) y los que no son espacios en blanco. Para resumir, esto es lo que funcionó para mí ...

• al menos 8personajes
• al menos 1carácter numérico
• al menos 1 letra minúscula
• al menos 1 letra mayúscula
• al menos 1un personaje especial

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

JSFiddle Link : demostración simple que cubre varios casos

Una versión más "genérica" ​​(?), Que no permite letras inglesas como caracteres especiales .

^(?=\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/>');
  });

Importa el archivo JavaScript jquery.validate.min.js.

Puedes 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. Al menos una letra mayúscula en inglés
2. Al menos una letra minúscula en inglés
3. Al menos un dígito
4. Al menos un personaje especial

Prueba este:

1. Mínimo seis caracteres
2. Al menos un carácter en mayúscula
3. Al menos un carácter en minúscula
4. Al menos un personaje especial

Expresión:

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

Caracteres especiales opcionales:

1. Al menos un personaje especial
2. Al menos un número
3. Los caracteres especiales son opcionales
4. Mínimo seis caracteres y máximo 16 caracteres.

Expresión:

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

Si no se requieren las condiciones mínimas y máximas, elimine .{6, 16}

• 6 es el límite mínimo de caracteres
• 20 es el límite máximo de caracteres
• ? = significa expresión de coincidencia

No responde directamente a la pregunta, pero ¿realmente tiene que ser una expresión regular?

Solía ​​hacer mucho Perl, y me acostumbré a resolver problemas con expresiones regulares. Sin embargo, cuando se vuelven más complicados con todos los look-aheads y otras peculiaridades, debes escribir docenas de pruebas unitarias para matar a todos esos pequeños errores.

Además, una expresión regular suele ser varias veces más lenta que una solución imperativa o funcional.

Por ejemplo, la siguiente función Scala (no muy FP) resuelve la pregunta original aproximadamente tres veces más rápido que la expresión regular de la respuesta más popular. Lo que hace también es tan claro que no necesita una prueba unitaria:

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
}

Le respondería a Peter Mortensen, pero no tengo suficiente reputación.

Sus expresiones son perfectas para cada uno de los requisitos mínimos especificados. El problema con sus expresiones que no requieren caracteres especiales es que tampoco PERMITEN caracteres especiales, por lo que también imponen requisitos máximos, lo que no creo que el OP solicitó. Normalmente desea permitir que sus usuarios hagan que su contraseña sea tan segura como quieran; ¿Por qué restringir contraseñas seguras?

Entonces, su expresión "mínimo ocho caracteres, al menos una letra y un número":

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

logra el requisito mínimo, pero los caracteres restantes solo pueden ser letras y números. Para permitir (pero no requerir) caracteres especiales, debe usar algo como:

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

o

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

Del mismo modo, "mínimo ocho caracteres, al menos una letra mayúscula, una letra minúscula y un número:"

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

cumple con ese requisito mínimo, pero solo permite letras y números. Utilizar:

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

o

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} para permitir caracteres especiales 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}$/    

¿Qué hay de considerar la siguiente solución regex:

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

Lo que valida lo siguiente:

1. Al menos una minúscula
2. Al menos una mayúscula
3. Al menos un dígito
4. Al menos un personaje especial
5. Al menos debe tener 8 caracteres de longitud.

Compruébelo trabajando en el siguiente enlace https://regex101.com/r/qPmC06/4/

Según su necesidad, este patrón debería funcionar bien. Prueba esto,

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

Simplemente cree una variable de cadena, asigne el patrón y cree un método booleano que devuelva verdadero si el patrón es correcto, de lo contrario, falso.

Muestra:

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

He encontrado muchos problemas aquí, así que hice el mío.

Aquí está en todo su esplendor, con pruebas:

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

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

Cosas a tener en cuenta:

1. no usa \wporque eso incluye _, lo que estoy probando.
2. He tenido muchos problemas para hacer coincidir símbolos, sin hacer coincidir el final de la línea.
3. No especifica símbolos específicamente, esto también se debe a que las diferentes configuraciones regionales pueden tener diferentes símbolos en sus teclados que pueden querer usar.

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

@ClasG ya ha sugerido :

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

pero no acepta _ (guión bajo) como un carácter especial (por ejemplo, Aa12345_).

Una mejorada es:

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

Manifestación:

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

Prueba de este en 2020:

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

Verifícate

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 la siguiente expresión regular para satisfacer las siguientes condiciones:

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

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

Puede probar en línea: https://regex101.com

Solo podemos hacer esto usando HTML5.

Use el siguiente código en el atributo de patrón,

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

Funcionará perfectamente.

Puede usar el siguiente patrón de expresión regular para verificar la contraseña si coincide o no con sus expectativas.

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

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

Verificación de enlaces en línea https://regex101.com/r/mqGurh/1

Utilizar este,

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

Validará para al menos una minúscula, una mayúscula, un número y los caracteres especiales de (!, @, #, $,%,?, =, *, &).

La longitud mínima es 8 y la longitud máxima es 20

En Java / Android, para probar una contraseña con al menos un número, una letra, un carácter especial en el siguiente patrón:

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

Prueba esto:

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

Esta expresión regular me funciona perfectamente.

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

Patrón para que coincida con al menos 1 carácter en mayúscula, 1 dígito y cualquier carácter especial y la longitud entre 8 y 63.

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

Este patrón se usó para la programación JAVA.

Espero que lo siguiente funcione. Intenté esto en la política personalizada de Azure.

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

De hecho, acabo de copiar la primera respuesta aquí y la convertí en una expresión regular más conveniente para UX que necesita una superior, una inferior y al menos 8 caracteres, pero acepta todo "en el medio".

Este es un ejemplo de expresión regular que requiere

1. al menos 8 caracteres de longitud
2. al menos una letra minúscula
3. al menos una letra mayuscula

IMPORTANTE : Esta expresión regular también excepto todos los demás caracteres, por ejemplo, números, caracteres especiales como $, # ,! etc. , siempre que las reglas 1. a 3. coincidan con la cadena de entrada

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

Cuidado con el "." casi al final de la expresión regular. Esto coincidirá con casi cualquier personaje (y afaik cualquier personaje legible)

Si desea utilizar expresiones regulares para verificar un mínimo de ocho caracteres, al menos una letra mayúscula, al menos una letra minúscula, al menos un número del 0 al 9 y al menos un carácter especial de:! @ # $% ^ & * _? Y también le da al usuario un poco más de información sobre lo que falta en la contraseña, puede usar el siguiente 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
}

Una solución que encontré en una de las respuestas anteriores como:

* Mínimo 8 caracteres al menos 1 alfabeto en mayúsculas, 1 alfabeto en minúsculas, 1 número y 1 carácter especial:

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

... no funcionó para mí, pero la siguiente es una versión simplificada y funciona muy bien (agregue cualquier carácter especial que desee, agregué # aquí) y agregue la regla de número como lo hace con las letras como:

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