Comprobar si una dirección IP es privada en Python

Las direcciones IP privadas se utilizan en las redes locales y no son enrutables en Internet. Saber distinguir una dirección IP privada de una pública es una competencia esencial para numerosas tareas de administración de sistemas, configuración de redes o desarrollo de aplicaciones de red.

Rangos de direcciones IP privadas

Según el estándar RFC 1918, los rangos de direcciones IP privadas son:

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

Afortunadamente, Python nos ofrece una forma sencilla de comprobar si una dirección IP pertenece a estos rangos gracias al módulo ipaddress.

Método 1: uso del módulo ipaddress (recomendado)

El módulo ipaddress está incluido en la biblioteca estándar de Python desde la versión 3.3, lo que lo convierte en el método recomendado.

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}")

Resultado:

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étodo 2: implementación manual

Si no puedes utilizar el módulo ipaddress por cualquier motivo, puedes implementar la comprobación manualmente:

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

Gestión de direcciones IP especiales

El módulo ipaddress también permite identificar otros tipos de direcciones especiales:

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)}")

Compatibilidad con IPv6

El módulo ipaddress también gestiona las direcciones 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}")

Casos de uso prácticos

A continuación se presentan algunos casos de uso prácticos de esta funcionalidad:

1. Filtrado de tráfico en una aplicación:

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. Registro contextual:

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. Integración con herramientas de monitorización de red:

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
    }

Conclusión

La comprobación de direcciones IP privadas es una tarea habitual en la programación de redes. El módulo ipaddress de Python simplifica considerablemente esta operación gracias a su método is_private. Para casos más complejos, este módulo también ofrece otros métodos útiles como is_loopback, is_link_local, etc.

Esta funcionalidad resulta especialmente útil para:

• Desarrollar aplicaciones de red seguras
• Configurar reglas de cortafuegos
• Analizar registros de tráfico
• Gestionar de forma diferenciada las conexiones internas y externas

Para más información, consulta la documentación oficial del módulo ipaddress.