Vérifier si une adresse IP est privée en Python

Les adresses IP privées sont utilisées dans les réseaux locaux et ne sont pas routables sur Internet. Être capable de distinguer une adresse IP privée d’une adresse publique est une compétence essentielle pour de nombreuses tâches d’administration système, de configuration réseau ou de développement d’applications réseau.

Plages d’adresses IP privées

Selon la norme RFC 1918, les plages d’adresses IP privées sont:

• Classe A: 10.0.0.0 - 10.255.255.255 (10.0.0.0/8)
• Classe B: 172.16.0.0 - 172.31.255.255 (172.16.0.0/12)
• Classe C: 192.168.0.0 - 192.168.255.255 (192.168.0.0/16)

Heureusement, Python nous offre un moyen simple de vérifier si une adresse IP appartient à ces plages grâce au module ipaddress.

Méthode 1: Utilisation du module ipaddress (Recommandée)

Le module ipaddress est inclus dans la bibliothèque standard de Python depuis la version 3.3, ce qui en fait la méthode recommandée.

import ipaddress

def is_private_ip(ip_string):
    """
    Vérifie si une adresse IP est privée.
    
    Args:
        ip_string (str): L'adresse IP à vérifier sous forme de chaîne (ex: '192.168.1.1')
        
    Returns:
        bool: True si l'adresse IP est privée, False sinon
    """
    try:
        ip = ipaddress.ip_address(ip_string)
        return ip.is_private
    except ValueError:
        # Gestion des erreurs si l'entrée n'est pas une adresse IP valide
        print(f"Erreur: {ip_string} n'est pas une adresse IP valide")
        return False

# Exemples d'utilisation
test_ips = [
    '192.168.1.1',    # Privée (Classe C)
    '10.0.0.1',       # Privée (Classe A)
    '172.16.0.1',     # Privée (Classe B)
    '8.8.8.8',        # Publique (Google DNS)
    '127.0.0.1',      # Loopback (spéciale)
    '172.32.0.1',     # Publique (juste en dehors de la plage privée)
    '169.254.1.1',    # Link-local (spéciale)
]

for ip in test_ips:
    result = "privée" if is_private_ip(ip) else "publique"
    print(f"{ip} est une adresse IP {result}")

Résultat:

192.168.1.1 est une adresse IP privée
10.0.0.1 est une adresse IP privée
172.16.0.1 est une adresse IP privée
8.8.8.8 est une adresse IP publique
127.0.0.1 est une adresse IP publique  # Note: bien que spéciale (loopback), elle n'est pas classée comme privée
172.32.0.1 est une adresse IP publique
169.254.1.1 est une adresse IP publique  # Note: bien que spéciale (link-local), elle n'est pas classée comme privée

Méthode 2: Implémentation manuelle

Si vous ne pouvez pas utiliser le module ipaddress pour une raison quelconque, vous pouvez implémenter la vérification manuellement:

def is_private_ip_manual(ip_string):
    """
    Vérifie manuellement si une adresse IP est privée.
    
    Args:
        ip_string (str): L'adresse IP à vérifier
        
    Returns:
        bool: True si l'adresse IP est privée, False sinon
    """
    try:
        # Conversion de l'adresse IP en liste d'entiers
        octets = list(map(int, ip_string.split('.')))
        if len(octets) != 4 or any(octet < 0 or octet > 255 for octet in octets):
            raise ValueError("Format d'adresse IP invalide")
            
        # Vérification des plages d'adresses IP privées
        # Classe A: 10.0.0.0 - 10.255.255.255
        if octets[0] == 10:
            return True
            
        # Classe B: 172.16.0.0 - 172.31.255.255
        if octets[0] == 172 and 16 <= octets[1] <= 31:
            return True
            
        # Classe C: 192.168.0.0 - 192.168.255.255
        if octets[0] == 192 and octets[1] == 168:
            return True
            
        return False
        
    except (ValueError, IndexError):
        print(f"Erreur: {ip_string} n'est pas une adresse IP valide")
        return False

Gestion des adresses IP spéciales

Le module ipaddress permet également d’identifier d’autres types d’adresses spéciales:

import ipaddress

def check_ip_type(ip_string):
    """
    Vérifie le type d'une adresse IP (privée, loopback, link-local, etc.)
    
    Args:
        ip_string (str): L'adresse IP à vérifier
        
    Returns:
        str: Description du type d'adresse IP
    """
    try:
        ip = ipaddress.ip_address(ip_string)
        
        if ip.is_private:
            return "Adresse IP privée"
        elif ip.is_loopback:
            return "Adresse de loopback"
        elif ip.is_link_local:
            return "Adresse link-local"
        elif ip.is_multicast:
            return "Adresse multicast"
        elif ip.is_reserved:
            return "Adresse réservée"
        elif ip.is_global:
            return "Adresse IP publique (globale)"
        else:
            return "Autre type d'adresse"
            
    except ValueError:
        return "Adresse IP invalide"

# Exemples d'utilisation avec différentes adresses
special_ips = [
    '192.168.1.1',    # Privée
    '10.0.0.1',       # Privée
    '127.0.0.1',      # Loopback
    '169.254.1.1',    # Link-local
    '224.0.0.1',      # Multicast
    '8.8.8.8',        # Publique (Google DNS)
    '2001:db8::1',    # IPv6 documentation
    'fe80::1',        # IPv6 link-local
]

for ip in special_ips:
    print(f"{ip}: {check_ip_type(ip)}")

Compatibilité avec IPv6

Le module ipaddress gère également les adresses IPv6:

import ipaddress

def is_private_ipv6(ip_string):
    """
    Vérifie si une adresse IPv6 est privée.
    
    Args:
        ip_string (str): L'adresse IPv6 à vérifier
        
    Returns:
        bool: True si l'adresse IPv6 est privée, False sinon
    """
    try:
        ip = ipaddress.ip_address(ip_string)
        return ip.is_private
    except ValueError:
        print(f"Erreur: {ip_string} n'est pas une adresse IP valide")
        return False

# Exemples d'adresses IPv6
ipv6_addresses = [
    '2001:db8::1',          # Adresse de documentation (non-routée)
    'fe80::1',              # Link-local
    'fd00::1',              # Unique Local Address (ULA) - l'équivalent "privé" en IPv6
    '2001:4860:4860::8888', # Publique (Google DNS)
]

for ip in ipv6_addresses:
    result = "privée" if is_private_ipv6(ip) else "publique"
    print(f"{ip} est une adresse IPv6 {result}")

Cas d’utilisation pratiques

Voici quelques cas d’utilisation pratiques pour cette fonctionnalité:

1. Filtrage de trafic dans une application:

def process_connection(ip_address, data):
    if is_private_ip(ip_address):
        # Traitement pour les connexions internes
        process_internal_connection(ip_address, data)
    else:
        # Traitement pour les connexions externes
        # Application de mesures de sécurité supplémentaires
        apply_security_measures(ip_address)
        process_external_connection(ip_address, data)

2. Journalisation contextuelle:

def log_access(ip_address, resource, action):
    ip_type = "interne" if is_private_ip(ip_address) else "externe"
    log_entry = f"{datetime.now()} - Accès {ip_type} depuis {ip_address} - {action} sur {resource}"
    logging.info(log_entry)

3. Intégration avec des outils de surveillance réseau:

def analyze_traffic_patterns(traffic_data):
    internal_traffic = {}
    external_traffic = {}
    
    for entry in traffic_data:
        ip = entry['source_ip']
        if is_private_ip(ip):
            if ip not in internal_traffic:
                internal_traffic[ip] = 0
            internal_traffic[ip] += entry['bytes']
        else:
            if ip not in external_traffic:
                external_traffic[ip] = 0
            external_traffic[ip] += entry['bytes']
    
    return {
        'internal_summary': internal_traffic,
        'external_summary': external_traffic
    }

Conclusion

La vérification des adresses IP privées est une tâche courante dans la programmation réseau. Le module ipaddress de Python simplifie considérablement cette opération avec sa méthode is_private. Pour des cas plus complexes, ce module offre également d’autres méthodes utiles comme is_loopback, is_link_local, etc.

Cette fonctionnalité est particulièrement utile pour:

• Développer des applications réseau sécurisées
• Configurer des règles de pare-feu
• Analyser des journaux de trafic
• Gérer différemment les connexions internes et externes

Pour plus d’informations, consultez la documentation officielle du module ipaddress.

import EmailSubscribe from ’../../../components/EmailSubscribe.astro’;