Validador de IP con Regex en Java

¿Qué es una Dirección IP?

Una Dirección IP (Protocolo de Internet) es un identificador único para dispositivos en una red. Existe en dos formatos:

• IPv4: 4 octetos decimales (ej., 192.168.0.1)

• IPv6: 8 bloques hexadecimales (ej., 2001:0db8:85a3:0000:0000:8a2e:0370:7334)

La validación correcta garantiza que el enrutamiento de datos y la identificación de dispositivos funcionen sin problemas.

Patrones Regex para Dirección IP

Patrón Regex para IPv4:

^((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.|$)){4}$

Explicación:

• Garantiza cuatro bloques de números

• Cada bloque va de 0 a 255

• Los puntos separan los bloques
  
  

Así funciona para las direcciones IPv4:

• 25[0-5]: Coincide con números del 250 al 255

• 2[0-4]\d: Coincide con números del 200 al 249

• 1\d\d: Coincide con números del 100 al 199

• [1-9]?\d: Coincide con números del 0 al 99 (maneja uno o dos dígitos, asegurando que no haya ceros iniciales excepto para el 0 mismo)

Cada uno de estos patrones garantiza que cada octeto (el valor entre los puntos) sea un número válido entre 0 y 255. Los grupos están separados por puntos literales, y el patrón en su conjunto impone exactamente cuatro octetos, tal como lo requiere el estándar IPv4.

Patrón Regex para IPv6:

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Explicación:

• Garantiza 8 grupos de 1 a 4 dígitos hexadecimales

• Los grupos están separados por dos puntos

Ejemplo en JavaScript: Validación de Direcciones IP

Si desea validar direcciones IP en JavaScript, las expresiones regulares son su mejor aliado. Aquí hay una guía rápida sobre cómo verificar tanto IPv4 como IPv6 usando regex.

// Expresiones regulares para IPv4 e IPv6
const ipv4Pattern = /^((25[0-5]2[0-4]\d1\d\d[1-9]?\d)(\.$)){4}$/;
const ipv6Pattern = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
/**

Valida si una cadena dada es una dirección IPv4 o IPv6 válida.
@param {string} ip - Dirección IP a validar.
@returns {string} - El tipo de dirección IP o 'IP Inválida'.
*/
function validateIPAddress(ip) {
if (ipv4Pattern.test(ip)) {
return "Dirección IPv4 Válida";
}
if (ipv6Pattern.test(ip)) {
return "Dirección IPv6 Válida";
}
return "IP Inválida";
}

// Pruebe con algunos ejemplos:
console.log(validateIPAddress("127.0.0.1"));                       // Dirección IPv4 Válida
console.log(validateIPAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334")); // Dirección IPv6 Válida
console.log(validateIPAddress("300.168.0.1"));                     // IP Inválida

Ejemplo de Código en Java (IPv4)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class IPv4Validator {
public static void main(String[] args) {
String ip = "192.168.1.1";
String ipv4Regex = "^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.|$)){4}$";
    Pattern pattern = Pattern.compile(ipv4Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Dirección IPv4 Válida");
    } else {
        System.out.println("Dirección IPv4 Inválida");
    }
}

}

Escenarios Comunes de Validación

Caso de Prueba 1

• Entrada: 000.12.12.034

• Salida: true

Caso de Prueba 2

• Entrada: 121.234.12.12

• Salida: true

Caso de Prueba 3

• Entrada: 000.12.234.23.23

• Salida: false

Caso de Prueba 4

• Entrada: I.Am.not.an.ip

• Salida: false
  
  

Ejemplo de Código en Java (IPv6)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class IPv6Validator {
public static void main(String[] args) {
String ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
String ipv6Regex = "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$";
    Pattern pattern = Pattern.compile(ipv6Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Dirección IPv6 Válida");
    } else {
        System.out.println("Dirección IPv6 Inválida");
    }
}

}

Entradas de Ejemplo

IPv4 Válida:

• 127.0.0.1

• 192.168.100.100

IPv4 Inválida:

• 256.300.888.1

• 192.168.1

IPv6 Válida:

• 2001:0db8:85a3:0000:0000:8a2e:0370:7334

• fe80::1ff:fe23:4567:890a

IPv6 Inválida:

• 2001:db8:85a3::8a2e:370g:7334 (caracteres inválidos)

• 1234:5678:90ab (demasiado corta)

Consideraciones de Rendimiento

Complejidad Temporal:
Validar una dirección IP con estas expresiones regulares opera en tiempo lineal, O(N), donde N es la longitud de la cadena de entrada. El patrón escanea cada carácter una vez, lo que lo hace eficiente incluso para direcciones más largas.

Complejidad Espacial:
El uso de memoria permanece constante en O(1), ya que el motor regex no requiere memoria adicional proporcional al tamaño de la entrada.

Casos de Uso

• Rastreo de Intentos de Inicio de Sesión: Registre IPs de inicios de sesión fallidos o exitosos.

• Procesamiento de Geo IP: Mapee ubicaciones de usuarios basándose en IPs.

• Lista Blanca de API: Valide las IPs entrantes contra listas de permitidos.

• Validación de Formularios: Acepte solo IPs con formato correcto en paneles de administración.

Consejos Profesionales

• Use regex separados para IPv4 e IPv6 en lugar de un patrón combinado para evitar confusiones.

• Limpie la entrada antes de validar (ej., elimine espacios en blanco).

• No confíe solo en regex; después de la validación de formato, use InetAddress.getByName() para confirmar el estado enrutable.

• Evite confiar en IPs enviadas por usuarios para operaciones sensibles de seguridad.

• Almacene las IPs en formato consistente (ya sea completo o acortado IPv6) en bases de datos.

• Use el Probador de Regex en Java para probar y afinar variaciones personalizadas.

Combínelo con Estas Herramientas

• Validador de Dirección MAC con Regex en Java - para validar direcciones de hardware

• Probador de Regex en Java - para pruebas de regex personalizadas

• Validador de Email con Regex en Java - verifique formatos de email de usuarios

• Codificador Base64 - codifique direcciones IP si es necesario para encabezados de API

• Generador de Token - genere tokens seguros para mapear con IPs