Vuoi vedere quali IP sono attivi su una rete? Vuoi sapere come si svolge un programma di questo stile? Bene oggi te lo mostro come creare un programma in python 3 che analizzerà la rete in una gamma di IP forniti dall'utente.
Per questo compito automatizzeremo il ping del sistema operativo.
opzione 1 - Scanner semplice
Metto questa prima opzione, perché è più facile da capire e da realizzare, prima di addentrarci in qualcosa di più complicato.
Il programma completo è il seguente:
import os import sys import platform from datetime import datetime ip = input ("Inserisci l'IP:") diviso ip = ip.split ('.') try: rosso = diviso ip [0] + '.' + diviso ip [1 ] + ' . '+ ipDivid [2] +'. ' start = int (input ("Inserisci il numero iniziale della sottorete:")) end = int (input ("Inserisci il numero in cui vuoi terminare lo sweep:")) tranne: print ("[!] Error" ) sys.exit (1) if (platform.system () == "Windows"): ping = "ping -n 1" else: ping = "ping -c 1" starttime = datetime.now () print ("[ * ] La scansione viene eseguita da ", rosso + str (inizio)," a ", rosso + str (fine)) per la sottorete nell'intervallo (inizio, fine + 1): indirizzo = rosso + str (sottorete) risposta = os .popen (ping + "" + address) for line in response.readlines(): if ("ttl" in line.lower()): print (address, "is active") break endtime = datetime.now () time = endTime - startTime print ("[*] La scansione è durata% s"% tempo) [color = # a9a9a9] Codice completo [/ color]
Passo 1
Abbiamo bisogno di importare alcune librerie, per il nostro programma:
import os import sys import platform from datetime import datetime[color = # a9a9a9] Librerie [/ color]
Spiegazione delle biblioteche
- tu: Ne abbiamo bisogno per eseguire il ping attraverso il sistema operativo.
- sistema: Lo uso per terminare il programma a causa di un errore nell'input dell'utente.
- piattaforma: Ci permette di conoscere il sistema operativo in cui eseguiamo il programma, il suo utilizzo ci rende indipendenti dalla piattaforma.
- appuntamento: Lo uso per sapere il tempo necessario per eseguire la scansione, se non vuoi saperlo puoi salvarlo.
Passo 2
Nel seguente pezzo di codice chiediamo all'utente i dati necessari, come l'host e l'intervallo di sottorete. Abbiamo anche un blocco try and catch che sostanzialmente utilizzo per terminare il programma in modo controllato, se l'IP inserito dall'utente non è corretto, la prima istruzione del blocco darà un errore, e se alla richiesta dell'inizio e alla fine non inserisce numeri, salterà un errore.
ip = input ("Inserisci l'IP:") ip diviso = ip.split ('.') try: network = ip diviso [0] + '.' + ip diviso [1] + '.' + ip diviso [2 ] + '. ' start = int (input ("Inserisci il numero iniziale della sottorete:")) end = int (input ("Inserisci il numero in cui vuoi terminare lo sweep:")) tranne: print ("[!] Error" ) sys.exit (1)Uso la prima istruzione nel blocco try per creare un prefisso di rete, che sarà utile in seguito.
Ad esempio nell'immagine seguente con i dati che inserisco faremmo una scansione per vedere se gli indirizzi da 192.168.0.190 a 192.168.0.199 sono attivi.
Passaggio 3
Nella parte successiva del codice l'unica cosa che controllo è quale sistema operativo viene utilizzato attraverso la funzione piattaforma.sistema ().
if (platform.system() == "Windows"): ping = "ping -n 1" else: ping = "ping -c 1"Ciò è necessario perché vogliamo inviare un singolo pacchetto e in Windows l'istruzione viene eseguita con -n e in unix con -c.
Passaggio 4
Successivamente analizzerò il seguente frammento di codice:
starttime = datetime.now () print ("[*] La scansione viene eseguita da", rosso + str (inizio), "a", rosso + str (fine)) per la sottorete nell'intervallo (inizio, fine + 1) : address = network + str (subnet) response = os.popen (ping + "" + address) for line in response.readlines (): if ("ttl" in line.lower ()): print (address, "is active ") break endtime = datetime.now () time = endtime - starttime print (" [*] La scansione è durata% s "% tempo)Questo passaggio è dove eseguiamo la vera funzionalità, quindi prima di iniziare ottengo il tempo corrispondente:
ora di inizio = datetime.now ()E dipingiamo una linea per schermata in modo che l'utente sappia che la scansione è stata eseguita (e l'intervallo):
print ("[*] La scansione è in corso da", red + str (inizio), "a", red + str (fine))Quindi vediamo un for, che passerà attraverso l'intervallo di indirizzi IP desiderati, la sua prima istruzione concatena i numeri mancanti al prefisso di rete, cioè se abbiamo 192.168.0. quindi se il ciclo for va da 190 a 199, la prima volta che si inserisce l'indirizzo sarà 192.168.0.190 e man mano che avanza il 190 verrà modificato, il resto lo teniamo. Quindi otteniamo la risposta ping, che viene eseguita dall'istruzione:
os.popen (ping + "" + indirizzo)Per sapere se l'IP è attivo controlleremo se la risposta che abbiamo contiene la parola ttl, Io uso riga.inferiore () perché sembra che in Linux esca in minuscolo e in Windows in maiuscolo, quindi non abbiamo problemi.
Nella parte finale, tutto ciò che faccio è ottenere di nuovo il tempo, e riposo questo nuovo tempo con quello precedente per dipingere il tempo impiegato per il mio programma.
Successivamente mostro un'immagine dell'esecuzione del programma, come possiamo vedere è un po' lento (52 secondi per 19 indirizzi) dipende anche dalla potenza del PC, ma questa volta può essere migliorato se utilizziamo i thread, quindi ora Farò il programma usando i " thread Python ".
Opzione 2 - Scanner Python filettato
Ora avvieremo un programma simile, ma qualcosa di più complesso, poiché ora il lavoro sarà diviso tra più thread e non rimarrà solo un carico, alla fine vedremo che il tempo è notevolmente ridotto, quindi possiamo dire che è una versione più ottimale.
Il programma è il seguente:
import os import sys import platform import threading, subprocess from datetime import datetime IPXHILOS = 4 ip = input ("Inserisci l'IP:") diviso ip = ip.split ('.') try: red = diviso ip [0] + ' .' + IP diviso [1] + '.' + IP diviso [2] + '.' start = int (input ("Inserisci il numero iniziale della sottorete:")) end = int (input ("Inserisci il numero in cui vuoi terminare lo sweep:")) tranne: print ("[!] Error" ) sys.exit (1) if (platform.system () == "Windows"): ping = "ping -n 1" else: ping = "ping -c 1" class Thread (threading.Thread): def __init __ ( self, start, end): threading.Thread .__ init __ (self) self.start = start self.fin = end def run (self): per sottorete nell'intervallo (self.start, self.fin): indirizzo = rete + str (subnet) response = os.popen (ping + "" + address) for line in response.readlines(): if ("ttl" in line.lower()): print (address, "is active") break startTime = datetime .now () print ("[*] La scansione viene eseguita da", network + str (inizio), "to", network + str (fine)) NumberIPs = end-begining numberThreads = int ((NumberIPs / IPXHILOS) ) threads = [] try: for i nell'intervallo (numberThreads): endAux = inizio + IPXTHREADS if (endAux> end): endAux = end thread = Thread (beginning, endAux) thread.start () threads.append ( thread) inizio = finAux tranne Exceptio n so e: print ("[!] Errore durante la creazione dei thread:", e) sys.exit (2) per il thread nei thread: thread.join () endtime = datetime.now () time = endtime - starttime print ("[ *] La scansione ha richiesto% s "% tempo) [color = # a9a9a9] Programma completo [/ color]
Qui ti parlerò delle istruzioni che cambiano e vengono aggiunte (ignorerò le parti uguali al programma precedente):
Le importazioni che utilizziamo nel programma precedente sono valide per noi, dobbiamo solo aggiungere quanto segue, che verrà utilizzato per i thread Python.
importare thread, sottoprocessoUso una variabile per il numero di IP che voglio che ogni thread controlli, quindi viene aggiunta all'inizio del programma:
IPXTHREADS = 4La richiesta di dati da parte dell'utente e il controllo del sistema operativo rimangono intatti. In questo spettacolo Creo una classe chiamata Thread che si estende da threading.Thread, questa classe riceve come parametri l'inizio e la fine degli indirizzi con cui ogni thread dovrà lavorare, quindi ho una funzione run, che è necessaria e deve essere chiamata così, si occuperà di fare il lavoro quando avvia il thread più tardi, il for non cambia:
class Thread (threading.Thread): def __init __ (self, start, end): threading.Thread .__ init __ (self) self.start = start self.fin = end def run (self): per sottorete nell'intervallo ( self.start , self.fin): address = network + str (subnet) response = os.popen (ping + "" + address) for line in response.readlines(): if ("ttl" in line.lower() ): print ( indirizzo, "è attivo") breakOra spiegheremo la parte che ho al di fuori della classe Filo.
Uso le seguenti istruzioni per conoscere il numero di IP che ho in totale, in base all'inizio e alla fine che l'utente mi dà:
NumberIPs = fine-inizioOra, una volta che lo sappiamo, possiamo calcolare il numero di thread di cui avrò bisogno per lavorare:
numberThreads = int ((NumberIPs / IPXTHREADS))Avrò bisogno di un elenco in cui archiviare ogni thread, in modo che in seguito possa fare in modo che il thread principale attenda il completamento del lavoro:
discussioni = []Il seguente frammento di codice creerà i thread e passerà loro la loro sezione di lavoro, per questo dobbiamo "giocare" con l'inizio e la fine di ogni thread, ecco perché ho creato la variabile finAux. Una volta creato, il thread inizia con cominciare () e viene aggiunto all'elenco dei thread.
prova: for i nell'intervallo (numberThreads): endAux = inizio + IPXTHREADS if (endAux> end): endAux = fine thread = Thread (inizio, endAux) thread.start () threads.append (thread) inizio = endAux tranne Eccezione come e: print ("[!] Errore durante la creazione dei thread:", e) sys.exit (2)Quindi creo un ciclo il cui scopo è aspettare che i thread finiscano
per thread in thread: thread.join ()E infine, il tempo è preso, verrebbe sottratto da quello che ho preso prima di iniziare e viene mostrato sullo schermo, proprio come il programma precedente.
Se facciamo lo stesso test di prima con questo programma vediamo che ci vogliono 6 secondi per fare lo stesso lavoro, che differenza.
NotaIl tempo può variare a seconda della potenza del tuo PC e della variabile IPXHILOS, io gli assegno un 4, se assegni più lavoro ad ogni thread ci vorrà più tempo, se ha meno lavoro sarà più veloce, ma attenzione che ci è un limite al numero di thread che possiamo creare.
Possiamo fidarci che questo programma ci dia il 100% degli host attivi?La risposta è no, dal momento che puoi bloccare il ping su un host bloccando le richieste e/o le risposte ICMP, quello di cui puoi essere certo è che se ti dice che è attivo, lo è. Ci sono altri tipi di scanner, come TCP che puoi fare con le porte che un sistema operativo normalmente lascia aperte, e la combinazione degli scanner TCP e ping sarà più affidabile.
Vi lascio uno zip con i 2 codici:
codigos_ping_python.zip 1.38K 270 download
