Analyseur d'IP LAN
Scanner d’adresses IP LAN
Ce script Python scanne un réseau local pour trouver les adresses IP actives. Il utilise la commande ping pour vérifier si un hôte est joignable et utilise le multithreading pour accélérer le processus de scan. Un sémaphore limite le nombre de threads concurrents pour éviter de surcharger le système. Le script prend une adresse réseau (par exemple, “192.168.1.0/24”) en entrée et affiche si chaque adresse IP du réseau est active ou inactive.
Ce script aide à identifier les appareils sur le réseau, comme un routeur maillé TP-LINK fonctionnant en mode bridge filaire, en recherchant les adresses IP actives.
import subprocess
import ipaddress
import threading
import os
import socket
import argparse
MAX_THREADS = 50 # Nombre maximum de threads à utiliser
def is_host_up(host, port=None):
"""
Vérifie si un hôte est actif en utilisant ping ou telnet.
Si un port est spécifié, utilise telnet pour vérifier si le port est ouvert.
Sinon, utilise ping.
Retourne True si l'hôte est actif, False sinon.
"""
if port:
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
result = sock.connect_ex((host, port))
if result == 0:
return True
else:
return False
except socket.error as e:
return False
finally:
sock.close()
else:
try:
# -c 1: Envoyer seulement 1 paquet
# -W 1: Attendre 1 seconde une réponse
subprocess.check_output(["ping", "-c", "1", "-W", "1", host], timeout=1)
return True
except subprocess.CalledProcessError:
return False
except subprocess.TimeoutExpired:
return False
def scan_ip(ip_str, up_ips, port=None):
"""
Scane une seule adresse IP et affiche son statut.
"""
if is_host_up(ip_str, port):
print(f"{ip_str} est active")
up_ips.append(ip_str)
else:
print(f"{ip_str} est inactive")
def scan_network(network, port=None):
"""
Scane un réseau pour les hôtes actifs en utilisant des threads, en limitant le nombre de threads concurrents.
"""
print(f"Scan du réseau : {network}")
threads = []
semaphore = threading.Semaphore(MAX_THREADS) # Limite le nombre de threads concurrents
up_ips = []
def scan_ip_with_semaphore(ip_str):
semaphore.acquire()
try:
scan_ip(ip_str, up_ips, port)
finally:
semaphore.release()
for ip in ipaddress.IPv4Network(network):
ip_str = str(ip)
thread = threading.Thread(target=scan_ip_with_semaphore, args=(ip_str,))
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
return up_ips
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Scanner un réseau pour les hôtes actifs.")
parser.add_argument("network", nargs='?', default="192.168.1.0/24", help="Le réseau à scanner (par exemple, 192.168.1.0/24)")
parser.add_argument("-p", "--port", type=int, help="Le port à vérifier (facultatif)")
args = parser.parse_args()
network_to_scan = args.network
port_to_scan = args.port
up_ips = scan_network(network_to_scan, port_to_scan)
print("\nAdresses IP actives :")
for ip in up_ips:
print(ip)
Contournement des adresses IP locales
Le script identifie les adresses IP actives. Pour assurer une communication réseau correcte, vérifiez que les paramètres proxy sont configurés pour contourner ces adresses IP locales.
192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,127.0.0.1,localhost,*.local,timestamp.apple.com,sequoia.apple.com,seed-sequoia.siri.apple.com, 192.168.1.0/16
Masques de sous-réseau
Ma deuxième machine est généralement à l’adresse 192.168.1.16.
Donc cela fonctionne en utilisant la commande ci-dessous.
python scripts/ip_scan.py 192.168.1.0/27 -p 22
car 32 - 27 = 5, 2^5 = 32, donc il essaiera 192.168.1.0 à 192.168.1.31.
Mais cela ne fonctionne pas avec 192.168.1.0/28, car 2^4 = 16, donc il essaiera 192.168.1.0 à 192.168.1.15, ce qui ne couvre pas 192.168.1.16.