Come trovare un indirizzo IP inutilizzato su una rete?

Voglio solo scoprire l'indirizzo IP inutilizzato su una rete. Penso che sia possibile con nmap. Qualcuno può dirmi il modo in cui pls?

Nota:

Ho solo bisogno dell'elenco IP gratuito da solo.

Uno scanner veloce è arp-scan che utilizza ARP per "vedere" altre macchine su una rete. Restituisce anche l'indirizzo MAC e cerca di determinare il produttore della scheda di rete.

Esempio di utilizzo (sostituirlo wlan0con eth0se necessario):

$ 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

Nota che questa utility riporta solo macchine accese. pingpuò essere bloccato, ma arp-scannon può essere bloccato poiché è necessario che una macchina interagisca con altre macchine su una rete. Per essere sicuri che un IP non sia utilizzato, è meglio guardare il router (per indirizzi statici / dinamici) e il server DHCP (per indirizzi dinamici).

sudo nmap -sP -PR 192.168.0.* (o qualunque sia la tua rete) farà il trucco.

Per installarlo usa sudo apt-get install nmap.

Fonte: serverfault.com .

Ho appena provato questo, funziona come un incanto tra cui host oscurati, è necessario aggiungere sudo per poter utilizzare l' -PRopzione.

Trovo utile il fping; tra le altre cose, eseguirà il ping di una serie di indirizzi ed elenchi che sono "vivi" e che sono "irraggiungibili". fping non è installato di default.

sudo apt-get install fping

L'approccio semplice è semplicemente eseguirlo su una gamma di indirizzi.

fping -g 192.168.0.2 192.168.0.254 2>/dev/null

Un po 'più elaborato, per produrre un elenco di IP non utilizzati.

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

Credo che non sia la soluzione migliore ma fa quello che vuoi. Questo script viene eseguito pingsulla 192.168.0.0/24rete e restituisce un elenco di IP inattivi se non sono presenti nella cache ARP.

Vantaggi rispetto alle soluzioni precedenti:

• utilizza entrambi i metodi: ping e controllo ARP
• non è necessario eseguire come rootutente
• funziona circa 1,5 minuti sul mio Core i3-2100

Per scansionare la tua rete eseguilo con i <first IP> <last IP>parametri.

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

Aggiornamento dopo il downvote

L'ho scritto perché nmap -PR 192.168.0.*non ha funzionato per me:

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

Aggiornamento 2

Risolti tutti i problemi con ARP-cache.

Questo dovrebbe farlo bene in 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

penso che sia più semplice

# 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