Comment trouver une adresse IP inutilisée sur un réseau?

Un scanner rapide est arp-scan , qui utilise ARP pour" voir "les autres machines du réseau. Il renvoie également l'adresse MAC et tente de déterminer le fabricant de la carte réseau.

Exemple d'utilisation (remplacez wlan0 par eth0 si nécessaire):

$ sudo arp-scan -I wlan0 192.168.1.0/24
Interface: wlan0, datalink type: EN10MB (Ethernet)
Starting arp-scan 1.6 with 256 hosts (http://www.nta-monitor.com/tools/arp-scan/)
192.168.1.10    00:90:f5:33:e2:f2       CLEVO CO.
192.168.1.254   00:14:7f:72:cd:05       Thomson Telecom Belgium

2 packets received by filter, 0 packets dropped by kernel
Ending arp-scan 1.6: 256 hosts scanned in 1.406 seconds (182.08 hosts/sec).  2 responded

Notez que cet utilitaire ne signale que les machines sous tension. ping peut être bloqué, mais arp-scan ne peut pas être bloqué car il est nécessaire pour une machine d'interagir avec d'autres machines sur un réseau. Pour être sûr qu’une adresse IP est inutilisée, vous devriez consulter votre routeur (pour les adresses statiques / dynamiques) et votre serveur DHCP (pour les adresses dynamiques).

sudo nmap -sP -PR 192.168.0.* (ou quel que soit votre réseau) fera l'affaire.

Pour l'installer, utilisez sudo apt-get install nmap .

Source: serverfault.com .

Vient de tester cela, fonctionne comme un charme incluant des hôtes masqués, vous devez ajouter sudo pour pouvoir utiliser l'option -PR .

Je trouve fping utile; Entre autres choses, il enverra une liste d'adresses et de listes «vivantes» et «inaccessibles». fping n'est pas installé par défaut.

sudo apt-get install fping

L'approche simple consiste à l'exécuter sur une plage d'adresses.

fping -g 192.168.0.2 192.168.0.254 2>/dev/null

Un peu plus élaboré, pour produire une liste d'adresses IP non utilisées.

fping -g 192.168.0.2 192.168.0.254 2>/dev/null | grep 'is unreachable' | cut -d ' ' -f 1 | sort -t '.' -k 4 -n

Je pense que ce n'est pas la meilleure solution, mais que vous faites ce que vous voulez. Ce script exécute ping sur 192.168.0.0/24 network et renvoie la liste des adresses IP inactives s’il n’y en a pas dans le cache ARP.

Avantages par rapport aux solutions précédentes:

• utilise les deux méthodes: ping et vérification ARP
• pas besoin de s'exécuter en tant que root utilisateur
• fonctionne environ 1,5 min sur mon Core i3-2100

Pour analyser votre réseau, exécutez-le avec <first IP> <last IP> parameters.

#!/usr/bin/env python
from threading import Thread
import subprocess
from Queue import Queue

verbose = False

num_threads = 8
queue = Queue()
inactive_ips = [0 for i in range(256)]

lines = open("/proc/net/arp", "r").readlines()
arp_cache = [l.split()[0] for l in lines[1:] if l.split()[2] == "0x2"]

def ip_str_to_int(ip):
    ip = ip.rstrip().split('.')
    ipn = 0
    while ip:
        ipn = (ipn << 8) + int(ip.pop(0))
    return ipn

def ip_int_to_str(ip):
    ips = ''
    for i in range(4):
        ip, n = divmod(ip, 256)
        ips = str(n) + '.' + ips
    return ips[:-1] ## take out extra point


#wraps system ping command
def pinger(i, q):
    while True:
        ip_num = q.get()
        ip = ip_int_to_str(ip_num)
        if ip not in arp_cache:
            ret = subprocess.call("ping -c 1 %s" % ip,
                  shell=True,
                  stdout=open('/dev/null', 'w'),
                  stderr=subprocess.STDOUT)
            if ret != 0:
                  inactive_ips[ip_num % 256] = ip
        q.task_done()


if __name__ == '__main__':
    from optparse import OptionParser
    usage = "usage: %prog [options] [first IP] [last IP]"
    parser = OptionParser(usage=usage)
    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="make lots of noise")
    parser.add_option("-q", action="store_false", dest="verbose", help="print only IP adresses")
    (options, args) = parser.parse_args()
    verbose = options.verbose

    first = ip_str_to_int(args[0] if len(args) > 0 else "192.168.0.1")
    last = ip_str_to_int(args[1] if len(args) > 1 else "192.168.0.254")

    if verbose:
        print "Scanning inactive network addresses from %s to %s" % (
            ip_int_to_str(first),
            ip_int_to_str(last))

    for i in range(num_threads):
        worker = Thread(target=pinger, args=(i, queue))
        worker.setDaemon(True)
        worker.start()

    for ip in range(first, last + 1):
        queue.put(ip)

    queue.join()
    for ip in inactive_ips:
        if ip:
            print ip

Mettre à jour après le vote vers le bas

Je l'ai écrit parce que nmap -PR 192.168.0.* n'a pas fonctionné pour moi:

Starting Nmap 5.21 ( http://nmap.org ) at 2011-10-06 15:34 EEST
Nmap done: 256 IP addresses (0 hosts up) scanned in 0.03 seconds

Mise à jour 2

Résolution de tous les problèmes liés au cache ARP.

Cela devrait se faire correctement en bash:

#!/bin/bash

#setting language variables for subshell making sure we grep for the right word
LC_ALL=C
LANG=C

# retrieve IP from user input
read -p "Input your network (example: 192.168.0): " my_net

for i in $(seq 1 254);
do 
  ip="$my_net.$i"
  check="$(ping -c1 "$ip")"
  if [ "$(grep "Unreachable" <<<"$check")" != "" ]
  then
    echo "$ip is unreachable"
  fi
done

Je pense que c'est plus simple

# my_net define my Net_ID
my_net=192.168.1.
for i in 'seq 1 254';
do 
  ip="$my_net$i"
  ping -c2  $ip | grep "is unreachable" | cut -d" " -f1 &
done