Validateur Regex d'adresses IP en Go

Introduction : qu'est-ce qu'un regex d'adresse IP ?

En Go, les expressions régulières (regex) offrent un moyen puissant de valider des patterns tels que les adresses IP. Les IP sont fondamentales dans tout système réseau, que vous stockiez des informations utilisateur, configuriez des pare-feu ou construisiez des applications web.

Les adresses IP se déclinent en deux types :

• IPv4 (ex. : 192.168.1.1)

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

Patterns regex pour adresses IP

Pattern regex 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}$

Compatibilité avec les moteurs regex

Ces patterns IPv4 fonctionnent avec un large éventail de moteurs regex modernes, notamment ceux utilisés en Go, Python, JavaScript, .NET, Java, Perl, Ruby et PCRE. Que vous intégriez la validation dans du code backend, des scripts ou des API, ces expressions se comportent de manière cohérente dans la plupart des environnements de développement majeurs.

Explication :

• Valide 4 octets séparés par des points.

• Chaque octet est compris entre 0 et 255.

• Exemple de correspondance : 192.168.0.1

Remarques complémentaires sur la validation IPv4

Des patterns plus simples comme ^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$ correspondent à quatre groupes de 1 à 3 chiffres séparés par des points, mais ne restreignent pas la plage à 0-255 pour chaque octet. Des valeurs invalides pourraient donc passer. Le pattern ci-dessus est plus précis car il garantit que chaque octet est dans la plage IPv4 valide.

Patterns IPv4 simples vs. précis

Regex IPv4 simple : Un regex basique comme ^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$ vérifie la structure, mais acceptera des adresses invalides comme 999.999.999.999.

Regex IPv4 précis : Un pattern plus rigoureux garantit que chaque octet est compris entre 0 et 255, rejetant des entrées comme 300.1.1.1 ou 256.256.256.256. À privilégier pour les configurations de pare-feu, les inscriptions utilisateur, etc.

En résumé :

• Regex simple : rapide, mais laisse passer des adresses invalides.

• Regex précis : légèrement plus complexe, mais garantit des adresses IPv4 véritablement valides.

Extraire des adresses IPv4 depuis un texte avec regex

Pour extraire des adresses IPv4 de journaux bruts ou de blocs de texte, les expressions régulières rendent cette tâche simple et efficace.

Pattern rapide pour extraction basique

Pour correspondre à toute séquence ressemblant à une adresse IPv4 :

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

• \b assure des correspondances sur des mots entiers.

• Le pattern vérifie quatre groupes de 1 à 3 chiffres séparés par des points.

Pattern strict pour adresses réelles

Pour une extraction plus stricte (chaque octet entre 0 et 255) :

\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

Exemple : Avec Log : tentative échouée depuis 192.168.99.120 à midi, le pattern strict extrait 192.168.99.120.

Pattern regex IPv6

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

Explication :

• Correspond à 8 groupes de nombres hexadécimaux séparés par des deux-points.

• Chaque groupe contient 1 à 4 chiffres hexadécimaux.

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

Comment valider des IP en Go avec regex

Utilisez le package regexp intégré de Go pour compiler le pattern et tester des chaînes :

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",                    // valid IPv4
"256.300.88.1",                   // invalid IPv4
"2001:0db8:85a3:0000:0000:8a2e:0370:7334", // valid IPv6
"2001:db8::1",                    // invalid (compressed, unsupported here)
}
for _, ip := range testIPs {
    fmt.Printf("IP: %s | IPv4: %t | IPv6: %t\n", ip, isValidIPv4(ip), isValidIPv6(ip))
}

}

Optionnel : convertir une adresse IPv4 en entier 32 bits

Une fois l'adresse IPv4 validée, vous pourriez avoir besoin de la convertir en entier 32 bits, par exemple pour un stockage efficace, des comparaisons rapides ou pour travailler avec des API réseau bas niveau.

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
}

Exemple d'utilisation :

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

Cas d'utilisation de la validation regex d'adresses IP

• Suivi des IP utilisateur : validez les IP avant de les stocker dans des journaux ou des outils analytiques.

• Contrôle d'accès : n'autorisez que les requêtes provenant de plages IP autorisées.

• Configuration réseau : automatisez la validation des IP lors de la configuration ou du provisionnement.

• Nettoyage de données : standardisez des jeux de données contenant des enregistrements IP malformés ou corrompus.

Conseils pratiques

• N'utilisez la validation IPv6 que si nécessaire, car beaucoup de systèmes reposent encore principalement sur IPv4.

• Le regex ne valide pas les IP réservées ou locales (comme 127.0.0.1 ou ::1), seulement le format.

• Pour les formats IPv6 compressés (comme ::1), utilisez le package net pour une analyse complète.

• Utilisez le Testeur Regex Go pour affiner vos patterns IP et tester les cas limites.

Outils recommandés à combiner

• Validateur Regex Password Go - sécurisez les identifiants utilisateur

• Validateur Regex Email Go - validez les données de contact avec les IP

• Validateur Regex URL Go - vérifiez les URL liées aux IP

• Testeur Regex Go - testez directement vos patterns IP

• Validateur Regex GUID Go - validez les identifiants de ressources