Verificar se um endereço IP é privado em Python

Os endereços IP privados são usados em redes locais e não são roteáveis na Internet. Saber distinguir um endereço IP privado de um endereço público é uma habilidade essencial para muitas tarefas de administração de sistemas, configuração de rede ou desenvolvimento de aplicações de rede.

Faixas de endereços IP privados

De acordo com a norma RFC 1918, as faixas de endereços IP privados são:

• 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)

Felizmente, o Python nos oferece uma maneira simples de verificar se um endereço IP pertence a essas faixas graças ao módulo ipaddress.

Método 1: Usando o módulo ipaddress (Recomendado)

O módulo ipaddress está incluído na biblioteca padrão do Python desde a versão 3.3, o que o torna o 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: Implementação manual

Se você não puder usar o módulo ipaddress por qualquer motivo, pode implementar a verificação 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

Tratamento de endereços IP especiais

O módulo ipaddress também permite identificar outros tipos de endereços especiais:

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

Compatibilidade com IPv6

O módulo ipaddress também lida com endereços 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áticos

Aqui estão alguns casos de uso práticos para essa funcionalidade:

1. Filtragem de tráfego em uma aplicação:

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 de logs 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. Integração com ferramentas de monitoramento de rede:

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
    }

Conclusão

A verificação de endereços IP privados é uma tarefa comum na programação de redes. O módulo ipaddress do Python simplifica consideravelmente essa operação com seu método is_private. Para casos mais complexos, esse módulo também oferece outros métodos úteis, como is_loopback, is_link_local, etc.

Essa funcionalidade é particularmente útil para:

• Desenvolver aplicações de rede seguras
• Configurar regras de firewall
• Analisar logs de tráfego
• Tratar de forma diferente as conexões internas e externas

Para mais informações, consulte a documentação oficial do módulo ipaddress.