Möchten Sie sehen, welche IPs in einem Netzwerk aktiv sind? Möchten Sie wissen, wie ein Programm dieses Stils erstellt wird? Nun, heute zeige ich Ihnen, wie Sie in Python 3 ein Programm erstellen, das das Netzwerk mit einer Reihe von vom Benutzer bereitgestellten IP-Adressen durchsucht.
Für diese Aufgabe werden wir das Ping des Betriebssystems automatisieren.
Option 1 – Einfacher Scanner
Dies ist meine erste Wahl, weil es einfacher zu verstehen und durchzuführen ist, bevor ich mich auf etwas Komplizierteres einlasse.
Das komplette Programm sieht wie folgt aus:
Importe Import sys Importplattform von datetime importieren datetime ip = input ("Geben Sie die IP ein:") ipDivided = ip.split ('.') versuche: Netzwerk = ipDivided [0] + '.' + ipDivided [1] + '.' + ipDivided [2] + '.' start = int (input ("Geben Sie die Startnummer des Subnetzes ein:")) end = int (Eingabe ("Geben Sie die Nummer ein, an der Sie den Scan beenden möchten:")) außer: print ("[!] Fehler") sys.exit (1) if (platform.system () == "Windows"): ping = "ping -n 1" sonst: ping = "ping -c 1" TimeHome = datetime.now () Drucken ("[*] Es wird gescannt von", Rot + Str (Anfang), "Auf", Rot + Str (Ende)) für Subnetz in Reichweite (Anfang, Ende + 1): Adresse = Netzwerk + Str (Subnetz) antwort = os.popen (ping + "" + adresse) für Zeile in response.readlines (): if ("ttl" in line.lower ()): print (Adresse, "ist aktiv") brechen endTime = datetime.now () Zeit = Endzeit - timeHome print ("[*] Scan hat% s gedauert"% time)
[/color] [color = # a9a9a9] Vollständiger Code [/ color]
Wir müssen einige Bibliotheken für unser Programm importieren:
Importe Import sys Importplattform von datetime importieren datetime
[/color] [color = # a9a9a9] Bibliotheken [/ color]
- os : Wir brauchen es, um durch das Betriebssystem zu pingen.
- sys : Ich benutze es, um das Programm vor einem Fehler bei der Eingabe von Benutzerdaten zu beenden.
- Plattform : Sie ermöglicht es uns, das Betriebssystem zu kennen, auf dem wir das Programm ausführen, und macht uns durch seine Verwendung unabhängig von Plattformen.
- datetime : Ich benutze es, um zu wissen, wie lange es dauert, um den Scan durchzuführen. Wenn Sie es nicht wissen möchten, können Sie es speichern.
Im nächsten Codeteil fragen wir den Benutzer nach den erforderlichen Daten, z. B. dem Host und der Reichweite des Subnetzes. Wir haben auch einen try, catch-Block, den ich im Grunde genommen verwende, um das Programm auf kontrollierte Weise zu beenden. Wenn die vom Benutzer eingegebene IP nicht korrekt ist, gibt der erste Befehl des Blocks einen Fehler aus und wenn er beim Fragen nach Anfang und Ende keine Zahlen eingibt, springt er ein Fehler
ip = input ("Geben Sie die IP ein:") ipDivided = ip.split ('.') versuche: Netzwerk = ipDivided [0] + '.' + ipDivided [1] + '.' + ipDivided [2] + '.' start = int (input ("Geben Sie die Startnummer des Subnetzes ein:")) end = int (Eingabe ("Geben Sie die Nummer ein, an der Sie den Scan beenden möchten:")) außer: print ("[!] Fehler") sys.exit (1)
Die erste Anweisung des try-Blocks wird verwendet, um ein Präfix des Netzwerks zu erstellen, das später nützlich sein wird.
In der folgenden Abbildung mit den von uns eingefügten Daten würden wir beispielsweise scannen, um festzustellen, ob die Adressen von 192.168.0.190 bis 192.168.0.199 aktiv sind.
Im nächsten Teil des Codes überprüfe ich nur, ob das Betriebssystem über die Funktion platform.system () verwendet wird.
if (platform.system () == "Windows"): ping = "ping -n 1" sonst: ping = "ping -c 1"
Dies ist notwendig, da nur ein Paket gesendet werden soll und in Windows die Anweisung mit -n und in Unix mit -c erfolgt.
Als nächstes werde ich das folgende Codefragment analysieren:
TimeHome = datetime.now () drucken ("[*] Der Scan wird durchgeführt von", rot + str (Start), "hoch", rot + str (Ende)) für Subnetz in Reichweite (Anfang, Ende + 1): Adresse = Netzwerk + Str (Subnetz) antwort = os.popen (ping + "" + adresse) für Zeile in response.readlines (): if ("ttl" in line.lower ()): print (Adresse, "ist aktiv") brechen endTime = datetime.now () Zeit = Endzeit - timeHome print ("[*] Scan hat% s gedauert"% time)
In diesem Schritt führen wir die eigentliche Funktionalität aus. Bevor ich anfange, erhalte ich die entsprechende Zeit:
TimeHome = datetime.now ()
Und wir malen eine Zeile pro Bildschirm, damit der Benutzer weiß, dass der Scan ausgeführt wird (und den Bereich):
drucken ("[*] Der Scan wird durchgeführt von", rot + str (Start), "hoch", rot + str (Ende))
Dann sehen wir ein for, das den Bereich der gewünschten IP-Adressen durchläuft. Der erste Befehl verkettet das Präfix des Netzwerks mit den fehlenden Nummern, dh, wenn 192.168.0 vorliegt. Wenn die for-Schleife von 190 auf 199 wechselt, lautet die Adresse bei der ersten Eingabe 192.168.0.190, und je nach Fortschritt wird die 190 geändert, der Rest bleibt erhalten. Dann erhalten wir die Antwort des Pings, die durch die Anweisung erfolgt:
os.popen (ping + "" + adresse)
Um zu wissen, ob die IP aktiv ist, prüfen wir, ob die Antwort das Wort ttl enthält. Ich verwende line.lower (), da es den Anschein hat, dass es sich bei Linux um Kleinbuchstaben und bei Windows um Großbuchstaben handelt, sodass wir keine Probleme haben.
Im letzten Teil bekomme ich nur noch einmal die Zeit und ruhe diese neue Zeit mit der vorherigen aus, um die Zeit zu zeichnen, die mein Programm gebraucht hat.
Als nächstes zeige ich ein Bild von der Ausführung des Programms, da wir sehen, dass es etwas langsam ist (52 Sekunden für 19 Richtungen), hängt auch von der Leistung des PCs ab, aber diese Zeit kann verbessert werden, wenn wir Threads verwenden. Threads “von Python.
Option 2 – Python-Scanner mit Threads
Wir werden jetzt ein ähnliches Programm starten, aber etwas komplexeres, da wir jetzt die Arbeit auf mehrere Threads aufteilen und nicht nur eine Last übrig lassen, wir werden am Ende sehen, dass die Zeit stark reduziert ist, so können wir sagen Das ist eine optimalere Version.
Das Programm ist das folgende:
Importe Import sys Importplattform Threading importieren, Unterprozess von datetime importieren datetime IPXHILOS = 4 ip = input ("Geben Sie die IP ein:") ipDivided = ip.split ('.') versuche: Netzwerk = ipDivided [0] + '.' + ipDivided [1] + '.' + ipDivided [2] + '.' start = int (input ("Geben Sie die Startnummer des Subnetzes ein:")) end = int (Eingabe ("Geben Sie die Nummer ein, an der Sie den Scan beenden möchten:")) außer: print ("[!] Fehler") sys.exit (1) if (platform.system () == "Windows"): ping = "ping -n 1" sonst: ping = "ping -c 1" Klasse Thread (threading.Thread): def __init __ (self, start, end): threading.Thread .__ init __ (self) self.home = start self.fin = end def run (self): für Subnetz in Reichweite (self.start, self.fin): Adresse = Netzwerk + Str (Subnetz) antwort = os.popen (ping + "" + adresse) für Zeile in response.readlines (): if ("ttl" in line.lower ()): print (Adresse, "ist aktiv") brechen TimeHome = datetime.now () Drucken ("[*] Es wird gescannt von", Rot + Str (Anfang), "Auf", Rot + Str (Ende)) Anzahl IPs = End-Start numberHilos = int ((NumberIPs / IPXHILOS)) threads = [] versuche: für i in range (Anzahl Threads): finAux = start + IPXHILOS if (finAux> end): finAux = end thread = Thread (start, finAux) thread.start () threads.append (thread) start = finAux außer Ausnahme als e: print ("[!] Fehler beim Erstellen von Threads:", e) sys.exit (2) für Garn in Fäden: thread.join () endTime = datetime.now () Zeit = Endzeit - timeHome print ("[*] Scan hat% s gedauert"% time)
[/color] [color = # a9a9a9] Vollständiges Programm [/ color]
Hier werde ich über Anweisungen sprechen, die sich ändern und hinzugefügt werden (ich werde dieselben Teile wie im vorherigen Programm ignorieren):
Der Import, den wir im vorherigen Programm verwendet haben, ist uns wert. Wir müssen nur Folgendes hinzufügen, das für die Threads in Python verwendet wird.
Threading importieren, Unterprozess
Ich verwende eine Variable für die Anzahl der IPs, die ich für jeden Thread überprüfen möchte. Sie wird also am Anfang des Programms hinzugefügt:
IPXHILOS = 4
Die Anforderung von Benutzerdaten und die Überprüfung des Betriebssystems bleiben erhalten. In diesem Programm erstelle ich eine Klasse namens Thread, die von threading.Thread ausgeht . Diese Klasse erhält als Parameter den Anfang und das Ende der Adressen, mit denen jeder Thread arbeiten muss. Dann habe ich eine Ausführungsfunktion, die notwendig ist und muss Aufruf wie folgt, es wird für die Ausführung der Arbeit verantwortlich sein, wenn später der Thread gestartet wird, der sich für nicht ändert:
Klasse Thread (threading.Thread): def __init __ (self, start, end): threading.Thread .__ init __ (self) self.home = start self.fin = end def run (self): für Subnetz in Reichweite (self.start, self.fin): Adresse = Netzwerk + Str (Subnetz) antwort = os.popen (ping + "" + adresse) für Zeile in response.readlines (): if ("ttl" in line.lower ()): print (Adresse, "ist aktiv") brechen
Lassen Sie uns nun den Teil erklären, den ich außerhalb der Thread- Klasse habe.
Die folgende Anweisung verwendet ich, um die Anzahl der IPs zu kennen, die ich insgesamt habe, je nach Anfang und Ende, die der Benutzer mir gibt:
Anzahl IPs = End-Start
Sobald wir das wissen, können wir die Anzahl der Threads berechnen, die ich für die Arbeit benötigen werde:
numberHilos = int ((NumberIPs / IPXHILOS))
Ich benötige eine Liste, um jeden Thread zu speichern, damit ich den Haupt-Thread warten lassen kann, bis die Arbeit beendet ist:
threads = []
Das folgende Codefragment erstellt die Threads und übergibt seine Arbeit. Dazu müssen wir mit dem Anfang und dem Ende jedes Threads “spielen”. Deshalb habe ich die Variable finAux erstellt. Sobald der Thread erstellt wurde, beginnt er mit start () und wird der Thread-Liste hinzugefügt.
versuche: für i in range (Anzahl der Threads): finAux = start + IPXHILOS if (finAux> end): finAux = end thread = Thread (start, finAux) thread.start () threads.append (thread) start = finAux außer Ausnahme als e: print ("[!] Fehler beim Erstellen von Threads:", e) sys.exit (2)
Als nächstes erstelle ich eine Schleife, die darauf wartet, dass die Threads enden
für Garn in Fäden: thread.join ()
Und schließlich wird die Zeit abgezogen, die ich vor dem Start genommen habe, und auf dem Bildschirm angezeigt, wie im vorherigen Programm.
Wenn wir den gleichen Test wie zuvor mit diesem Programm machen, sehen wir, dass es 6 Sekunden dauert, um die gleiche Arbeit zu machen, kleiner Unterschied.
Ich hinterlasse eine Zip mit den 2 Codes:
149 Descargas codigos_ping_python.zip 1,38K 149 Downloads
