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

Je veux juste découvrir l'adresse IP inutilisée sur un réseau. Je pense que c'est possible avec nmap. Quelqu'un peut-il me dire la façon dont les pls?

Remarque:

J'ai juste besoin de la liste IP gratuite seule.

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

Exemple d'utilisation (remplacer wlan0par eth0si 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 signale uniquement les machines sous tension. pingpeut être bloqué, mais arp-scanne peut pas être bloqué car il est nécessaire qu'une machine interagisse avec d'autres machines sur un réseau. Pour être sûr qu'une adresse IP n'est pas utilisée, vous feriez mieux de regarder votre routeur (pour les adresses statiques / dynamiques) et le 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 .

Je viens de tester cela, fonctionne comme un charme, y compris les hôtes obscurs, vous devez ajouter sudo pour pouvoir utiliser l' -PRoption.

Je trouve fping utile; entre autres, il exécutera une commande ping sur une plage d'adresses et une liste qui sont «vivantes» et qui sont «inaccessibles». fping n'est pas installé par défaut.

sudo apt-get install fping

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

fping -g 192.168.0.2 192.168.0.254 2>/dev/null

Un peu plus en détail, pour produire une liste d'adresses IP inutilisé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 crois que ce n'est pas la meilleure solution mais elle fait ce que vous voulez. Ce script s'exécute pingsur le 192.168.0.0/24réseau 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 rootqu'utilisateur
• fonctionne environ 1,5 min sur mon Core i3-2100

Pour analyser votre réseau, exécutez-le avec des <first IP> <last IP>paramètres.

#!/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 downvote

Je l'ai écrit parce que ça nmap -PR 192.168.0.*ne fonctionnait pas 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

Update 2

Correction de tous les problèmes avec ARP-cache.

Cela devrait le faire 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