Validateur Regex d'adresses IP en Java

Qu'est-ce qu'une adresse IP ?

Une adresse IP (Internet Protocol) est un identifiant unique pour les appareils sur un réseau. Elle existe en deux formats :

• IPv4 : 4 octets décimaux (ex. : 192.168.0.1)

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

Une validation correcte garantit que le routage des données et l'identification des appareils fonctionnent de manière fluide.

Patterns regex pour adresses IP

Pattern regex IPv4 :

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

Explication :

• Garantit quatre blocs de nombres

• Chaque bloc est compris entre 0 et 255

• Les points séparent les blocs
  
  

Décomposition du fonctionnement pour les adresses IPv4 :

• 25[0-5] : correspond aux nombres 250-255

• 2[0-4]\d : correspond aux nombres 200-249

• 1\d\d : correspond aux nombres 100-199

• [1-9]?\d : correspond aux nombres 0-99 (gère les chiffres simples ou doubles, sans zéros initiaux sauf pour 0 lui-même)

Chacun de ces patterns garantit que chaque octet est un nombre valide entre 0 et 255. Les groupes sont séparés par des points, et le pattern global impose exactement quatre octets, comme l'exige la norme IPv4.

Pattern regex IPv6 :

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

Explication :

• Garantit 8 groupes de 1 à 4 chiffres hexadécimaux

• Les groupes sont séparés par des deux-points

Exemple JavaScript : validation d'adresses IP

Pour valider des adresses IP en JavaScript avec des expressions régulières :

// Regular expressions for IPv4 and 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}$/;

/**
 * Validates whether a given string is a valid IPv4 or IPv6 address.
 * @param {string} ip - IP address to validate.
 * @returns {string} - The type of IP address or 'Invalid IP'.
 */
function validateIPAddress(ip) {
  if (ipv4Pattern.test(ip)) {
    return "Valid IPv4 Address";
  }
  if (ipv6Pattern.test(ip)) {
    return "Valid IPv6 Address";
  }
  return "Invalid IP";
}

// Try it out with a few examples:
console.log(validateIPAddress("127.0.0.1"));                       // Valid IPv4 Address
console.log(validateIPAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334")); // Valid IPv6 Address
console.log(validateIPAddress("300.168.0.1"));                     // Invalid IP

Exemple de code 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("Valid IPv4 Address");
        } else {
            System.out.println("Invalid IPv4 Address");
        }
    }
}

Scénarios de validation courants

Cas de test 1

• Entrée : 000.12.12.034

• Résultat : true

Cas de test 2

• Entrée : 121.234.12.12

• Résultat : true

Cas de test 3

• Entrée : 000.12.234.23.23

• Résultat : false

Cas de test 4

• Entrée : I.Am.not.an.ip

• Résultat : false
  
  

Exemple de code 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("Valid IPv6 Address");
        } else {
            System.out.println("Invalid IPv6 Address");
        }
    }
}

Exemples de saisies

IPv4 valides :

• 127.0.0.1

• 192.168.100.100

IPv4 invalides :

• 256.300.888.1

• 192.168.1

IPv6 valides :

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

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

IPv6 invalides :

• 2001:db8:85a3::8a2e:370g:7334 (caractères invalides)

• 1234:5678:90ab (trop courte)

Exemples supplémentaires :

Considérations de performance

Complexité temporelle : La validation d'une adresse IP avec ces expressions régulières s'effectue en temps linéaire O(N), où N est la longueur de la chaîne d'entrée.

Complexité spatiale : L'utilisation de mémoire reste constante à O(1), le moteur regex ne nécessitant pas de mémoire additionnelle proportionnelle à la taille de l'entrée.

Cas d'utilisation

• Suivi des tentatives de connexion : journalisez les IP pour les connexions réussies ou échouées.

• Traitement de géolocalisation IP : localisez les utilisateurs selon leur IP.

• Liste blanche pour API : validez les IP entrantes par rapport aux listes d'autorisation.

• Validation de formulaires : n'acceptez que des IP correctement formatées dans les panneaux d'administration ou les tableaux de bord.

Conseils pratiques

• Utilisez des regex séparés pour IPv4 et IPv6 plutôt qu'un pattern fusionné pour éviter la confusion.

• Nettoyez l'entrée avant la validation (ex. : supprimez les espaces).

• Ne comptez pas uniquement sur le regex : après la validation du format, utilisez InetAddress.getByName() pour confirmer l'état de routage.

• Évitez de faire confiance aux IP soumises par les clients pour les opérations sensibles à la sécurité.

• Stockez les IP dans un format cohérent (complet ou abrégé pour IPv6) dans les bases de données.

• Utilisez le Testeur Regex Java pour tester et affiner des variations personnalisées (ex. : plages CIDR).

Outils recommandés à combiner

• Validateur Regex adresse MAC Java - pour valider les adresses matérielles

• Testeur Regex Java - pour des tests regex personnalisés

• Validateur Regex Email Java - vérifiez les formats d'email des utilisateurs

• Encodeur base64 - encodez les adresses IP si nécessaire pour les headers API

• Générateur de tokens - générez des tokens sécurisés à associer aux IP