Validador de IP con Regex en Go

Introducción: ¿Qué es un Regex de Dirección IP?

En Go, las expresiones regulares (regex) ofrecen una forma poderosa de validar patrones como direcciones IP. Las IPs son fundamentales en cualquier sistema basado en red, ya sea que esté almacenando información de usuarios, configurando firewalls o construyendo aplicaciones web.

Las direcciones IP existen en dos tipos:

• IPv4 (ej., 192.168.1.1)

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

Patrones Regex para Dirección IP

Patrón Regex para IPv4

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

Flavors de Regex Compatibles

Estos patrones regex para IPv4 funcionan en una amplia gama de motores de regex modernos, incluidos los utilizados en Go, Python, JavaScript, .NET, Java, Perl, Ruby y PCRE. Ya sea que integre la validación en código backend, scripts o APIs, puede esperar que estas expresiones se comporten de manera consistente en la mayoría de los entornos de desarrollo principales.

Explicación:

• Valida 4 octetos separados por puntos.

• Cada octeto va de 0 a 255.

• Ejemplo de coincidencia: 192.168.0.1

Notas Adicionales sobre la Validación de IPv4

Si bien puede encontrar patrones más simples como:

^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$

estos coinciden con cuatro grupos de 1 a 3 dígitos separados por puntos pero no restringen el rango a 0-255 para cada octeto. Eso significa que valores como 999.0.0.1 pasarían, aunque no son direcciones IP válidas.

El regex anterior es más preciso porque garantiza que cada octeto esté dentro del rango IPv4 válido. Este patrón es compatible con los flavors de regex más populares, incluidos .NET, Java, JavaScript, PCRE, Perl, Python y Ruby.

Patrones IPv4 Simples vs. Precisos

Puede encontrar dos tipos de expresiones regulares al validar direcciones IPv4: patrones simples y patrones precisos. Es importante conocer la diferencia, especialmente si le importa la calidad de los datos.

Regex IPv4 Simple:
Un regex básico podría verse así: ^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$. Verifica cuatro grupos de 1 a 3 dígitos separados por puntos. Es fácil de escribir y entender, pero también coincidirá con direcciones inválidas como 999.999.999.999 o incluso 256.100.100.100. En otras palabras, solo verifica la estructura, no la validez de cada octeto.

Regex IPv4 Preciso:
Un patrón más preciso garantiza que cada octeto esté entre 0 y 255. Por ejemplo:
^(25[0-5]2[0-4]\d1\d\d[1-9]?\d)(\.(25[0-5]2[0-4]\d1\d\d[1-9]?\d)){3}$
Este patrón garantiza que entradas como 300.1.1.1 o 256.256.256.256 sean rechazadas. Es la opción correcta si el objetivo es una validación robusta (configuraciones de firewall, registro de usuarios, etc.).

En resumen:

• Regex simple: Rápido, pero permite pasar direcciones inválidas.

• Regex preciso: Ligeramente más complejo, pero garantiza que todas las direcciones sean IPv4 realmente válidas.

Extracción de Direcciones IPv4 de Texto con Regex

¿Necesita extraer direcciones IPv4 de registros sin procesar o bloques de texto? Las expresiones regulares hacen esta tarea sencilla y eficiente, sin escaneo manual.

Así puede aislar direcciones IPv4 incrustadas en cadenas más largas:

Patrón Rápido para Extracción Básica

Para coincidir con cualquier secuencia que parezca una dirección IPv4 (independientemente de su validez), use:

\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b

• \b garantiza coincidencias de palabras completas, para no capturar números parciales.

• El patrón verifica cuatro conjuntos de 1 a 3 dígitos separados por puntos.

Patrón Estricto para Direcciones Reales

Para extracción estricta que solo devuelva direcciones IPv4 sintácticamente válidas (cada octeto entre 0 y 255), use:

\b(?:(?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\.){3}
   (?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\b

• Este patrón verifica los límites numéricos de cada octeto, reduciendo los falsos positivos.

• Funciona en los principales motores de regex, incluidos Go, Python, JavaScript y PCRE.

Ejemplo:
Dado Log: Intento fallido desde 192.168.99.120 al mediodía, el patrón estricto extrae 192.168.99.120.

Patrón Regex para IPv6

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

Explicación:

• Coincide con 8 grupos de números hexadecimales separados por dos puntos.

• Cada grupo tiene entre 1 y 4 dígitos hexadecimales.

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

Cómo Validar IPs en Go Usando Regex

Use el paquete regexp incorporado de Go para compilar el patrón y probar cadenas:

package main
import (
"fmt"
"regexp"
)
func isValidIPv4(ip string) bool {
ipv4Pattern := ^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$
regex := regexp.MustCompile(ipv4Pattern)
return regex.MatchString(ip)
}
func isValidIPv6(ip string) bool {
ipv6Pattern := ^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
regex := regexp.MustCompile(ipv6Pattern)
return regex.MatchString(ip)
}
func main() {
testIPs := []string{
"192.168.1.1",                    // IPv4 válida
"256.300.88.1",                   // IPv4 inválida
"2001:0db8:85a3:0000:0000:8a2e:0370:7334", // IPv6 válida
"2001:db8::1",                    // inválida (comprimida, no compatible aquí)
}
for _, ip := range testIPs {
    fmt.Printf("IP: %s | IPv4: %t | IPv6: %t\n", ip, isValidIPv4(ip), isValidIPv6(ip))
}

}

Opcional: Convertir una Dirección IPv4 a un Entero de 32 bits

Una vez que haya validado su dirección IPv4, puede necesitar convertirla a un entero de 32 bits, por ejemplo, para almacenamiento eficiente, comparaciones rápidas o trabajar con APIs de red de bajo nivel.

Así puede hacerlo en Go:

import (
"fmt"
"strconv"
"strings"
)
func ipv4ToInt(ip string) (uint32, error) {
octets := strings.Split(ip, ".")
if len(octets) != 4 {
return 0, fmt.Errorf("invalid IPv4 address")
}
var result uint32
for i := 0; i < 4; i++ {
octet, err := strconv.Atoi(octets[i])
if err != nil octet < 0 octet > 255 {
return 0, fmt.Errorf("invalid octet in IPv4 address")
}
result = (result << 8) uint32(octet)
}
return result, nil
}

Ejemplo de uso:

ip := "192.168.1.1"
ipInt, err := ipv4ToInt(ip)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Printf("IPv4 %s como uint32: %d", ip, ipInt)
}

Esta función divide la IP por puntos, analiza cada octeto y desplaza bits a su lugar, produciendo un único entero sin signo de 32 bits. Perfecto para almacenar IPs de forma compacta o usarlas como claves numéricas en su servicio o caché.

Casos de Uso de la Validación de IP con Regex

• Rastreo de IP de Usuarios: Valide las IPs antes de almacenarlas en registros o herramientas de análisis.

• Control de Acceso: Permita solo solicitudes de rangos de IP en lista blanca.

• Configuración de Red: Automatice la validación de IPs durante la configuración o el aprovisionamiento.

• Limpieza de Datos: Estandarice conjuntos de datos con registros de IP mal formados o corruptos.

Consejos Profesionales

• Use la validación de IPv6 solo cuando sea necesario, ya que muchos sistemas todavía dependen principalmente de IPv4.

• El regex no valida IPs reservadas o locales (como 127.0.0.1 o ::1), solo el formato.

• Al trabajar con formatos IPv6 comprimidos (como ::1), considere usar el paquete net para un análisis completo.

• Use el Probador de Regex en Go para afinar sus patrones de IP y probar casos extremos.

Combínelo con Estas Herramientas

Use el Validador de IP con Regex en Go en flujos de trabajo que también requieran:

• Validador de Contraseña con Regex en Go - Proteja las credenciales de usuarios

• Validador de Email con Regex en Go - Valide datos de contacto junto con IPs

• Validador de URL con Regex en Go - Verifique URLs vinculadas a IPs

• Probador de Regex en Go - Pruebe sus patrones de IP directamente

• Validador de GUID con Regex en Go - Valide identificadores de recursos