Localiser une adresse IP avec Python

Introduction

Comment Localiser une Adresse IP avec Python : Les Bases

Qu’est-ce qu’une adresse IP ?

Une adresse IP (Internet Protocol) est un identifiant unique attribué à chaque appareil connecté à Internet. Elle permet aux appareils de communiquer entre eux via des réseaux. Les adresses IP peuvent être :

• Publiques : visibles sur Internet, elles permettent d’identifier un appareil sur le réseau global.
• Privées : utilisées au sein de réseaux locaux (LAN), elles ne sont pas accessibles directement depuis Internet.

Types d’adresses IP : IPv4 vs IPv6

• IPv4 : format classique (32 bits) composé de quatre groupes de chiffres séparés par des points (exemple : 192.168.1.1).
• IPv6 : format plus récent (128 bits) conçu pour pallier la pénurie d’adresses IPv4 (exemple : 2001:0db8:85a3:0000:0000:8a2e:0370:7334).

Localisation géographique et adresses IP

Les adresses IP publiques sont associées à des plages attribuées aux fournisseurs d’accès à Internet (FAI). En analysant ces plages, il est possible de déterminer approximativement la localisation géographique d’un appareil. Cette méthode repose sur des bases de données fournies par des entreprises spécialisées comme MaxMind ou des API publiques.

Présentation des bibliothèques Python pour la géolocalisation

Python propose de nombreuses bibliothèques et outils pour localiser une adresse IP. Chaque méthode a ses avantages et inconvénients. Voici les principales bibliothèques utilisées pour cette tâche :

ipaddress

La bibliothèque ipaddress est intégrée à Python. Bien qu’elle ne fournisse pas directement de données de localisation, elle permet de manipuler et de valider des adresses IP. Par exemple, on peut vérifier si une adresse IP est valide ou déterminer son type (IPv4 ou IPv6).

Exemple d’utilisation :

import ipaddress

ip = "192.168.1.1"
try:
    ip_obj = ipaddress.ip_address(ip)
    print(f"L'adresse {ip} est valide.")
    print(f"Type : {'IPv4' if ip_obj.version == 4 else 'IPv6'}")
except ValueError:
    print("Adresse IP invalide.")

GeoIP (MaxMind)

GeoIP2, une bibliothèque de MaxMind, est l’une des options les plus fiables pour localiser des adresses IP. Elle nécessite l’installation de fichiers de base de données locaux ou une API en ligne.

Avantages :

• Données précises grâce à des bases actualisées régulièrement.
• Facilité d’intégration avec Python.

ipwhois

La bibliothèque ipwhois permet de récupérer des informations sur une adresse IP en interrogeant les bases de données WHOIS. Elle est utile pour obtenir des détails sur l’organisation propriétaire d’une adresse IP.

Requests et APIs publiques

Requests est une bibliothèque populaire pour interagir avec des APIs publiques comme ipinfo.io ou ipstack. Ces services en ligne offrent des informations sur la géolocalisation des adresses IP sans nécessiter de base de données locale.

Étape 1 : Installation des bibliothèques nécessaires

Avant de commencer à coder, il est important d’installer les bibliothèques et outils requis. Voici les étapes pour configurer l’environnement Python.

Installation de GeoIP2

Pour utiliser GeoIP2, commencez par installer la bibliothèque via pip :

pip install geoip2

Ensuite, téléchargez les fichiers de base de données gratuits ou payants depuis le site de MaxMind :

• Base de données gratuite : GeoLite2 (moins précise que la version payante).
• Base de données payante : GeoIP2 (plus complète).

Créez un compte sur MaxMind pour accéder aux fichiers.

Installation de ipwhois

Pour récupérer des informations via WHOIS, installez la bibliothèque ipwhois :

pip install ipwhois

Utilisation des APIs publiques

La bibliothèque requests est essentielle pour interagir avec des APIs publiques :

pip install requests

Installer les outils de visualisation

Pour afficher les données de localisation sur une carte, vous pouvez utiliser Folium, une bibliothèque Python dédiée à la cartographie :

pip install folium

Partie 3 : Utilisation des APIs publiques pour localiser une adresse IP

Étape 2 : Utiliser une API publique pour localiser une adresse IP

Les APIs publiques offrent une solution rapide et facile pour localiser une adresse IP. Voici deux exemples populaires : ipinfo et ipstack.

Exemple avec ipinfo.io

L’API ipinfo.io fournit des informations telles que la ville, le pays et le fournisseur d’accès.

Exemple de script Python :

import requests

def get_location_ipinfo(ip):
    url = f"https://ipinfo.io/{ip}/json"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return {
            "IP": data.get("ip"),
            "Ville": data.get("city"),
            "Région": data.get("region"),
            "Pays": data.get("country"),
            "Fournisseur": data.get("org")
        }
    else:
        return {"Erreur": "Impossible de récupérer les données"}

# Exemple d'utilisation
ip = "8.8.8.8"
location = get_location_ipinfo(ip)
print(location)

Exemple avec ipstack

L’API ipstack propose un service similaire avec un plan gratuit limité.

Exemple de script Python :

import requests

def get_location_ipstack(ip, api_key):
    url = f"http://api.ipstack.com/{ip}?access_key={api_key}"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return {
            "IP": data.get("ip"),
            "Ville": data.get("city"),
            "Région": data.get("region_name"),
            "Pays": data.get("country_name"),
            "Latitude": data.get("latitude"),
            "Longitude": data.get("longitude")
        }
    else:
        return {"Erreur": "Impossible de récupérer les données"}

# Exemple d'utilisation
api_key = "VOTRE_API_KEY"
ip = "8.8.8.8"
location = get_location_ipstack(ip, api_key)
print(location)

Comparaison des services

Service	Avantages	Inconvénients
ipinfo.io	Facile à utiliser, rapide	Données limitées en mode gratuit
ipstack	Données complètes, API simple	Nécessite une clé API

Étape 3 : Localisation d’une adresse IP avec GeoIP (MaxMind)

MaxMind est l’un des outils les plus fiables pour la géolocalisation IP. Leur bibliothèque Python GeoIP2 utilise des bases de données locales pour fournir des informations détaillées sur une adresse IP. Suivons les étapes pour configurer et utiliser cet outil.

Configuration de GeoIP2

1. Installation de la bibliothèque Python : Utilisez pip pour installer GeoIP2 :

   pip install geoip2
   

2. Téléchargement de la base de données GeoLite2 :
   • Connectez-vous ou créez un compte sur MaxMind.
   • Téléchargez la base de données gratuite GeoLite2 en format .mmdb.
   • Placez ce fichier dans un dossier accessible par votre script Python.

Récupération de la localisation avec GeoIP2

Voici un exemple complet d’utilisation de GeoIP2 pour localiser une adresse IP :

import geoip2.database

def get_location_geoip(ip):
    # Chemin vers la base de données téléchargée
    database_path = "GeoLite2-City.mmdb"

    try:
        # Ouverture de la base de données
        with geoip2.database.Reader(database_path) as reader:
            # Recherche des données pour l'adresse IP
            response = reader.city(ip)

            # Extraction des informations utiles
            location_data = {
                "IP": ip,
                "Ville": response.city.name,
                "Région": response.subdivisions.most_specific.name,
                "Pays": response.country.name,
                "Latitude": response.location.latitude,
                "Longitude": response.location.longitude
            }
            return location_data
    except Exception as e:
        return {"Erreur": str(e)}

# Exemple d'utilisation
ip = "8.8.8.8"
location = get_location_geoip(ip)
print(location)

Analyse des résultats

La fonction get_location_geoip retourne un dictionnaire contenant les informations suivantes :

• Ville : Le nom de la ville associée à l’adresse IP.
• Région : La subdivision administrative la plus précise.
• Pays : Le pays où se trouve l’adresse IP.
• Latitude et Longitude : Les coordonnées géographiques.

Exemple de sortie :

{
  "IP": "8.8.8.8",
  "Ville": "Mountain View",
  "Région": "California",
  "Pays": "United States",
  "Latitude": 37.386,
  "Longitude": -122.0838
}

Automatiser l’analyse d’un fichier d’adresses IP

Vous pouvez automatiser la géolocalisation d’un grand nombre d’adresses IP en les récupérant depuis un fichier. Voici un exemple de script :

import geoip2.database

def process_ips(file_path, database_path):
    results = []

    # Ouverture de la base de données
    with geoip2.database.Reader(database_path) as reader:
        with open(file_path, "r") as file:
            for line in file:
                ip = line.strip()
                try:
                    response = reader.city(ip)
                    results.append({
                        "IP": ip,
                        "Ville": response.city.name,
                        "Région": response.subdivisions.most_specific.name,
                        "Pays": response.country.name,
                        "Latitude": response.location.latitude,
                        "Longitude": response.location.longitude
                    })
                except Exception as e:
                    results.append({"IP": ip, "Erreur": str(e)})

    return results

# Exemple d'utilisation
database_path = "GeoLite2-City.mmdb"
file_path = "ips.txt"  # Fichier contenant une adresse IP par ligne
locations = process_ips(file_path, database_path)
print(locations)

Comparaison entre GeoIP et les APIs publiques

Critères	GeoIP (MaxMind)	APIs publiques (ipinfo, ipstack)
Précision	Très précise avec la version payante	Précision moyenne
Coût	Gratuit (version GeoLite2)	Plans gratuits et payants
Performances	Rapide (base locale)	Plus lent (requêtes API)
Dépendance réseau	Aucune (base locale)	Dépend de la connectivité

Étape 4 : Visualisation des données sur une carte

Afficher les données de localisation sur une carte interactive peut rendre vos analyses plus intuitives. La bibliothèque Python Folium permet de créer facilement des cartes interactives.

Installer Folium

Si ce n’est pas encore fait, installez Folium :

pip install folium

Exemple de visualisation

Voici comment afficher une adresse IP sur une carte interactive :

import folium

def create_map(latitude, longitude, description):
    # Créer une carte centrée sur les coordonnées
    map_obj = folium.Map(location=[latitude, longitude], zoom_start=10)

    # Ajouter un marqueur pour l'adresse IP
    folium.Marker(
        [latitude, longitude],
        popup=description,
        tooltip="Cliquez pour plus d'infos"
    ).add_to(map_obj)

    # Sauvegarder la carte dans un fichier HTML
    map_obj.save("map.html")
    print("Carte générée : map.html")

# Exemple d'utilisation
latitude = 37.386
longitude = -122.0838
description = "Adresse IP : 8.8.8.8"
create_map(latitude, longitude, description)

Ouvrez le fichier map.html dans votre navigateur pour voir la carte interactive.

Ajouter plusieurs adresses IP sur une seule carte

Pour plusieurs adresses IP, utilisez une boucle pour ajouter plusieurs marqueurs sur la carte :

import folium

def create_map_multiple(locations):
    # Créer une carte générale
    map_obj = folium.Map(location=[0, 0], zoom_start=2)

    # Ajouter les marqueurs
    for location in locations:
        folium.Marker(
            [location["Latitude"], location["Longitude"]],
            popup=f"{location['IP']} - {location['Ville']}, {location['Pays']}",
            tooltip=location["IP"]
        ).add_to(map_obj)

    # Sauvegarder la carte
    map_obj.save("map_multiple.html")
    print("Carte multiple générée : map_multiple.html")

# Exemple d'utilisation
locations = [
    {"IP": "8.8.8.8", "Ville": "Mountain View", "Pays": "United States", "Latitude": 37.386, "Longitude": -122.0838},
    {"IP": "1.1.1.1", "Ville": "Sydney", "Pays": "Australia", "Latitude": -33.8688, "Longitude": 151.2093}
]
create_map_multiple(locations)

Bonnes pratiques et limites

Respect de la vie privée

Localiser une adresse IP soulève des questions éthiques et légales. Voici quelques points essentiels :

• Conformité au RGPD : Si vous travaillez en Europe ou avec des données d’utilisateurs européens, assurez-vous de respecter la réglementation sur la vie privée.
• Consentement : Si vous collectez des adresses IP des utilisateurs, informez-les et obtenez leur consentement.
• Usage responsable : Limitez l’utilisation des données à des fins légitimes comme l’analyse de trafic ou la détection de fraudes.

Fiabilité des données

Les informations de géolocalisation basées sur des adresses IP ne sont pas toujours précises. En effet :

• Les bases de données IP sont mises à jour périodiquement et peuvent contenir des erreurs.
• Une adresse IP peut être associée à un proxy ou à un VPN, ce qui fausse les résultats.

Optimisation des performances

Si vous traitez un grand volume de données, considérez ces stratégies :

• Mise en cache : Évitez de demander des informations sur la même IP plusieurs fois.
• Base locale : Si la rapidité est essentielle, préférez l’utilisation de GeoIP2 avec une base locale.
• Gestion des erreurs : Vérifiez toujours les réponses des APIs et gérez les exceptions pour éviter que votre script plante.

Limites techniques

• Dépendances réseau : Les APIs publiques nécessitent une connexion Internet stable.
• Restrictions des APIs : Les services comme ipstack ou ipinfo imposent des limites d’utilisation en mode gratuit.
• Performance des bases locales : Si la base GeoLite2 n’est pas mise à jour régulièrement, vos résultats peuvent devenir obsolètes.

FAQ

1. Peut-on localiser une adresse IP avec précision ?

La précision dépend de la source des données. Les bases de données comme GeoIP fournissent des localisations approximatives au niveau de la ville, mais rarement au niveau exact de l’adresse. Les proxys et VPN peuvent masquer la localisation réelle.

2. Est-il légal de localiser une adresse IP ?

En général, oui, mais cela dépend de l’objectif. La localisation des IP doit respecter les lois sur la vie privée, comme le RGPD en Europe. Il est important d’obtenir le consentement des utilisateurs si vous collectez leurs données.

3. Quelle est la meilleure API pour la géolocalisation ?

Cela dépend de vos besoins :

• ipinfo.io : Facile à utiliser et offre des plans gratuits.
• ipstack : Très complet avec des données détaillées.
• GeoIP2 : Idéal pour des projets nécessitant des bases locales et rapides.

4. Pourquoi certaines IP ne retournent-elles pas de données ?

Les raisons possibles incluent :

• L’adresse IP est privée (réseaux locaux).
• L’adresse IP est nouvelle ou temporaire et non encore répertoriée.
• Les proxys, VPNs ou NAT masquent la localisation réelle.

5. Peut-on localiser plusieurs adresses IP en une fois ?

Oui, vous pouvez automatiser la localisation d’un ensemble d’adresses IP en les lisant depuis un fichier ou une base de données, comme montré dans les exemples précédents.

6. Quelle est la différence entre GeoLite2 et GeoIP2 ?

• GeoLite2 : Base de données gratuite avec des données moins précises.
• GeoIP2 : Version payante avec des données actualisées et plus détaillées.

Exemple d’Application Complète : Géolocalisation IP avec Python

Pour intégrer tout ce que nous avons vu dans un projet fonctionnel, créons une application Python complète qui localise plusieurs adresses IP, les visualise sur une carte interactive, et gère les limitations des APIs.

Objectifs de l’application :

1. Lire une liste d’adresses IP depuis un fichier.
2. Récupérer leurs localisations via l’API ipstack ou la base GeoLite2.
3. Générer une carte interactive avec tous les points localisés.
4. Optimiser le processus pour gérer les erreurs et améliorer les performances.

Étape 1 : Structure du projet

Fichiers nécessaires :

1. ips.txt : Un fichier texte contenant une adresse IP par ligne.

   8.8.8.8
   1.1.1.1
   142.250.72.14
   216.58.217.206
   

2. GeoLite2-City.mmdb : La base de données GeoLite2 téléchargée depuis MaxMind.
3. Le script Python principal : ip_locator.py.

Étape 2 : Code Python Complet

ip_locator.py

Voici le code pour localiser les adresses IP et visualiser les résultats :

import geoip2.database
import folium
import requests
import time

# Configuration
GEOIP_DATABASE = "GeoLite2-City.mmdb"  # Chemin vers la base de données
IP_LIST_FILE = "ips.txt"               # Fichier contenant les IP
OUTPUT_MAP_FILE = "ip_map.html"        # Carte générée
USE_API = False                        # Activer/Désactiver l'utilisation des APIs
API_KEY = "VOTRE_API_KEY_IPSTACK"      # Clé API pour ipstack

# Récupération des données avec GeoLite2
def get_location_geoip(ip):
    try:
        with geoip2.database.Reader(GEOIP_DATABASE) as reader:
            response = reader.city(ip)
            return {
                "IP": ip,
                "Ville": response.city.name,
                "Région": response.subdivisions.most_specific.name,
                "Pays": response.country.name,
                "Latitude": response.location.latitude,
                "Longitude": response.location.longitude
            }
    except Exception as e:
        return {"IP": ip, "Erreur": str(e)}

# Récupération des données avec l'API ipstack
def get_location_ipstack(ip):
    url = f"http://api.ipstack.com/{ip}?access_key={API_KEY}"
    try:
        response = requests.get(url)
        if response.status_code == 200:
            data = response.json()
            return {
                "IP": ip,
                "Ville": data.get("city"),
                "Région": data.get("region_name"),
                "Pays": data.get("country_name"),
                "Latitude": data.get("latitude"),
                "Longitude": data.get("longitude")
            }
        else:
            return {"IP": ip, "Erreur": f"HTTP {response.status_code}"}
    except Exception as e:
        return {"IP": ip, "Erreur": str(e)}

# Lire les adresses IP depuis un fichier
def read_ips(file_path):
    try:
        with open(file_path, "r") as file:
            return [line.strip() for line in file.readlines() if line.strip()]
    except FileNotFoundError:
        print("Erreur : Fichier non trouvé.")
        return []

# Générer une carte interactive
def create_map(locations, output_file):
    # Initialiser la carte centrée sur le monde
    map_obj = folium.Map(location=[0, 0], zoom_start=2)

    # Ajouter des marqueurs pour chaque localisation
    for location in locations:
        if "Erreur" not in location:
            folium.Marker(
                [location["Latitude"], location["Longitude"]],
                popup=f"{location['IP']} - {location['Ville']}, {location['Pays']}",
                tooltip=location["IP"]
            ).add_to(map_obj)
        else:
            print(f"Erreur pour l'IP {location['IP']}: {location['Erreur']}")

    # Sauvegarder la carte
    map_obj.save(output_file)
    print(f"Carte générée : {output_file}")

# Main script
def main():
    print("Lecture des adresses IP...")
    ip_addresses = read_ips(IP_LIST_FILE)
    if not ip_addresses:
        print("Aucune adresse IP à traiter.")
        return

    print("Localisation des adresses IP...")
    locations = []
    for ip in ip_addresses:
        if USE_API:
            result = get_location_ipstack(ip)
        else:
            result = get_location_geoip(ip)
        print(f"Résultat pour {ip}: {result}")
        locations.append(result)
        # Limite pour éviter de surcharger les APIs
        if USE_API:
            time.sleep(1)

    print("Création de la carte interactive...")
    create_map(locations, OUTPUT_MAP_FILE)

# Exécuter le script
if __name__ == "__main__":
    main()

Étape 3 : Exécution du script

1. Installer les dépendances

Avant de lancer le script, installez les bibliothèques nécessaires :

pip install geoip2 folium requests

2. Ajouter les fichiers requis

• Placez le fichier ips.txt contenant les adresses IP dans le même dossier que le script.
• Téléchargez la base de données GeoLite2 (GeoLite2-City.mmdb) depuis MaxMind.

3. Lancer le script

Exécutez le script dans votre terminal ou IDE :

python ip_locator.py

4. Résultat

• Une carte interactive ip_map.html sera générée dans le même dossier. Ouvrez ce fichier dans un navigateur pour visualiser les points localisés.

Étape 4 : Fonctionnalités supplémentaires (optionnel)

1. Exporter les résultats dans un fichier CSV

Ajoutez cette fonction pour sauvegarder les résultats dans un fichier CSV :

import csv

def export_to_csv(locations, output_file):
    with open(output_file, mode="w", newline="") as file:
        writer = csv.DictWriter(file, fieldnames=["IP", "Ville", "Région", "Pays", "Latitude", "Longitude", "Erreur"])
        writer.writeheader()
        for location in locations:
            writer.writerow(location)
    print(f"Résultats exportés dans : {output_file}")

Appelez cette fonction dans le script principal après la localisation des IP :

export_to_csv(locations, "locations.csv")

2. Améliorer la carte avec des couleurs

Ajoutez des couleurs aux marqueurs en fonction des pays :

import random

def get_random_color():
    return f"#{random.randint(0, 255):02x}{random.randint(0, 255):02x}{random.randint(0, 255):02x}"

# Modifier les marqueurs dans la fonction `create_map`
for location in locations:
    if "Erreur" not in location:
        folium.CircleMarker(
            [location["Latitude"], location["Longitude"]],
            radius=10,
            color=get_random_color(),
            fill=True,
            fill_color=get_random_color(),
            popup=f"{location['IP']} - {location['Ville']}, {location['Pays']}",
            tooltip=location["IP"]
        ).add_to(map_obj)

Résumé

Ce projet met en œuvre les concepts de localisation IP, intégrant des bases de données locales et des APIs pour fournir des résultats fiables. Il combine Python avec des outils de visualisation comme Folium pour une expérience utilisateur enrichissante.

Conclusion