Validar una contraseña en Java

Esta publicación cubre varios métodos para validar una contraseña en Java.

Hemos visto que un Se prefiere una array de caracteres sobre un objeto String para almacenar información altamente confidencial, como contraseñas de usuario en Java. Pero si debe usar una string para almacenar una contraseña, puede usar cualquiera de los siguientes métodos para validarla:

1. Usando el Validador OWASP

Nosotros podemos usar Regex de validación de OWASP, que se considera muy seguro. La expresión regular requiere que la contraseña tenga de 4 a 8 caracteres y debe contener números, letras minúsculas y mayúsculas.

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

El siguiente es el desglose de cada componente:

^               # start of the string
(?=.*\d)        # a digit must occur at least once
(?=.*[a-z])     # a lower case letter must occur at least once
(?=.*[A-Z])     # an upper case letter must occur at least once
.{4,8}          # 4-8 character password, both inclusive
$               # end of the string

Aquí está la versión compleja, que requiere una contraseña de 4 a 32 caracteres. La contraseña debe cumplir al menos 3 de 4 condiciones (letras mayúsculas y minúsculas, números y caracteres especiales) y no debe tener más de 2 caracteres iguales seguidos.

^(?:(?=.*\d)(?=.*[A-Z])(?=.*[a-z])|(?=.*\d)(?=.*[^A-Za-z0-9])(?=.*[a-z])|(?=.*[^A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z])|(?=.*\d)(?=.*[A-Z])(?=.*[^A-Za-z0-9]))(?!.*(.)\1{2,})[A-Za-z0-9!~<>,;:_=?*+#.”&§%°()\|\[\]\-\$\^\@\/]{8,32}$

import java.util.regex.Pattern;

// Programa Java para validar una contraseña en Java

class Main

{

// Contraseña de 4-8 caracteres que requiere números y letras de ambos casos

private static final String PASSWORD_REGEX =

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

// Contraseña de 4 a 32 caracteres que requiere al menos 3 de 4 (mayúsculas

// y letras minúsculas, números y caracteres especiales) y como máximo

// 2 caracteres consecutivos iguales.

private static final String COMPLEX_PASSWORD_REGEX =

"^(?:(?=.*\\d)(?=.*[A-Z])(?=.*[a-z])|" +

"(?=.*\\d)(?=.*[^A-Za-z0-9])(?=.*[a-z])|" +

"(?=.*[^A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z])|" +

"(?=.*\\d)(?=.*[A-Z])(?=.*[^A-Za-z0-9]))(?!.*(.)\\1{2,})" +

"[A-Za-z0-9!~<>,;:_=?*+#.\"&§%°()\\|\\[\\]\\-\\$\\^\\@\\/]" +

"{8,32}$";

private static final Pattern PASSWORD_PATTERN =

Pattern.compile(COMPLEX_PASSWORD_REGEX);

public static void main(String[] args)

{

String password = "Stream@Java8";

// Validar una contraseña

if (PASSWORD_PATTERN.matcher(password).matches()) {

System.out.print("The Password " + password + " is valid");

}

else {

System.out.print("The Password " + password + " isn't valid");

}

Descargar Ejecutar código

Resultado:

The Password Stream@Java8 is valid

2. Usar otra expresión regular

Aquí hay otra expresión regular para validar una contraseña, tomada de la Subproceso de desbordamiento de stack. Esta es básicamente una extensión de OWASP Regex vista anteriormente. Dado que cada regla es un "módulo" independiente, podemos agregar, modificar o eliminar reglas individuales fácilmente.

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

A continuación la explicación detallada:

^                  # start of the string
(?=.*[0-9])        # a digit must occur at least once
(?=.*[a-z])        # a lower case letter must occur at least once
(?=.*[A-Z])        # an upper case letter must occur at least once
(?=.*[@#$%^&+=])   # a special character must occur at least once
(?=\\S+$)          # no whitespace allowed in the entire string
.{8,16}            # 8-16 character password, both inclusive
$                  # end of the string

import java.util.regex.Pattern;

// Programa Java para validar una contraseña en Java

class Main

{

// Contraseña de 8-16 caracteres con al menos un dígito, al menos uno

// letra minúscula, al menos una letra mayúscula, al menos una

// caracter especial sin espacios en blanco

private static final String PASSWORD_REGEX =

"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,16}$";

private static final Pattern PASSWORD_PATTERN =

Pattern.compile(PASSWORD_REGEX);