一、介绍
平时发网络数据都是基于应用层的收发，如果要进行底层发送和接收必须使用另外的工具，这里以winpcap介绍tcpip底层的收发

二、安装包
pip install winpcapy

三、代码编写
1、导入库

from winpcapy import WinPcapUtils

2、发数据

arp_request_hex_template = "%(dst_mac)s%(src_mac)s08060001080006040001" \
                           "%(sender_mac)s%(sender_ip)s%(target_mac)s%(target_ip)s" + "00" * 18
packet = arp_request_hex_template % {
    "dst_mac": "aa"*6,
    "src_mac": "bb"*6,
    "sender_mac": "bb"*6,
    "target_mac": "cc"*6,
    # 192.168.0.1
    "sender_ip": "c0a80001",
    # 192.168.0.2
    "target_ip": "c0a80002"
}
# Send the packet (ethernet frame with an arp request) on the interface
WinPcapUtils.send_packet("*Ethernet*", bytes.fromhex(packet))

3、收数据

from winpcapy import WinPcapUtils

# Example Callback function to parse IP packets
def packet_callback(win_pcap, param, header, pkt_data):
    # Assuming IP (for real parsing use modules like dpkt)
    ip_frame = pkt_data[14:]
    # Parse ips
    src_ip = ".".join([str(ord(b)) for b in ip_frame[0xc:0x10]])
    dst_ip = ".".join([str(ord(b)) for b in ip_frame[0x10:0x14]])
    print("%s -> %s" % (src_ip, dst_ip))

WinPcapUtils.capture_on("*Ethernet*", packet_callback)

指定网卡名称

from winpcapy import WinPcap

device_name = '\\Device\\NPF_{AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE}'
with WinPcap(device_name) as capture:
    capture.send(bytes.fromhex('ff'*6))

git链接
https://github.com/orweis/winpcapy

使用Python进行数据爬取时，很多情况下需要登录或需要某些Cookie，如果直接从浏览器中复制Cookie的话每次都要重新复制，使用selenium比较慢，这样很麻烦。因此考虑使用Python抓包，这样的话每次只需要在程序运行后手动登录或点击一次，下面就可以自动进行了。

依赖的包

1. scapy (用于抓包)
2. dpkt (用于分析)
3. socket (用于获取数据包的IP)

抓包代码

from scapy.sendrecv import sniff
from scapy.utils import wrpcap
import dpkt
import socket

ifs = 'Intel(R) Ethernet Connection (5) I219-LM'  # 网卡
ip_dst = 'xx.xx.xx.xx'  # 目标ip地址

d = sniff(iface=ifs, count=10)
wrpcap("demo.pcap", d) #保存为pcap文件

分析代码

可以使用dpkt或scapy中的rdpcap进行分析

scapy中rdpcap分析

d = rdpcap('demo.pcap')
res = []
for pkt in d.res:
    try:  # 只要应用层数据包，因此如果不包含应用层数据包则进入except
        IP_pkt = pkt.payload  # 获取IP层数据包
        TCP_pkt = IP_pkt.payload  # 获取TCP层数据包
        Raw_pkt = TCP_pkt.payload  # 获取应用层数据包
        data = Raw_pkt.load  # 获取包内具体数据
        res.append(data.decode(errors='ignore'))  # Bytes解码为str
    except AttributeError:
        pass
for r_i in range(len(res)):
	# 上面得到的数据每一条都是不完整的，下面就是进行具体筛选和拼接
    getIndex = res[r_i].find('*****这里放入筛选语句')
    if getIndex != -1:
        p_get = res[r_i][getIndex:-1]
        count = 1
        while res[r_i + count].find(r'HTTP/1.1 200 OK') == -1:  # 直到遇到下一个数据包开头
            p_get += res[r_i + count]
            count += 1
        break

dpkt分析

cookie = ''
with open("demo.pcap", "rb") as f:
    pcap = dpkt.pcap.Reader(f)
    for timestamp, buf in pcap:
        eth = dpkt.ethernet.Ethernet(buf)  # 获得以太包，即数据链路层包
        if not isinstance(eth.data, dpkt.ip.IP):  # 判断是否是网络层数据
            continue
        ip = eth.data
        dst_ip = socket.inet_ntoa(ip.dst)
        if dst_ip == ip_dst and isinstance(ip.data, dpkt.tcp.TCP):  # 判断是否是传输层且是否符合目标IP(使用sniff过滤器也是一样的)
            tcp = ip.data
            try:
                request = dpkt.http.Request(tcp.data)  # 请求包
                for key, value in request.headers.items():  # 请求头
                    if key == 'cookie':
                        cookie = value
                        print(f'找到Cookie = {cookie}')
            except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
                continue
        if cookie != '':
            break
if cookie != '':
    try:
        # 这里放置测试采集代码
        print('Cookie正确，开始采集数据')
        break
    except:
        cookie = ''
        print('Cookie不正确，继续获取')

全部代码

ifs = 'Intel(R) Ethernet Connection (5) I219-LM'  # 网卡
ip_dst = 'xx.xx.xx.xx'  # 目标ip地址
while 1:
    d = sniff(iface=ifs, count=100)
    wrpcap("demo.pcap", d) #保存为pcap文件
    cookie = ''
    with open("demo.pcap", "rb") as f:
        pcap = dpkt.pcap.Reader(f)
        for timestamp, buf in pcap:
            eth = dpkt.ethernet.Ethernet(buf)  # 获得以太包，即数据链路层包
            if not isinstance(eth.data, dpkt.ip.IP):  # 判断是否是网络层数据
                continue
            ip = eth.data
            dst_ip = socket.inet_ntoa(ip.dst)
            if dst_ip == ip_dst and isinstance(ip.data, dpkt.tcp.TCP):  # 判断是否是传输层且是否符合目标IP
                tcp = ip.data
                try:
                    request = dpkt.http.Request(tcp.data)  # 请求包
                    for key, value in request.headers.items():  # 请求头
                        if key == 'cookie':
                            cookie = value
                            print(f'找到Cookie = {cookie}')
                except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
                    continue
            if cookie != '':
                break
    if cookie != '':
        try:
            # 这里放置测试采集代码
            print('Cookie正确，开始采集数据')
            break
        except:
            cookie = ''
            print('Cookie不正确，继续获取')

需求描述

最近项目支撑，需要针对各类ms漏洞、webshell、k8等工具编写防御规则，我们统一把恶意工具下载到本地，在本地开一个web服务。每针对一个工具开发一条规则，就需要捕获一个数据包，而且必须是经过过滤处理的单独的数据包。希望能有一个工具简化抓包过程。

思路1：本地开启web服务，如果是开启wireshark，然后批量爬虫的话，会得到包含多个追踪流的数据包，如果借助scapy进行拆包，要处理的异常情况太多。放弃。

思路2：使用sniffer抓包。缺陷是存在漏包，访问了某个地址之后，产生的流量没有被sniffer抓到。

思路3：使用tcpdump。缺陷是每次工作都得开个虚拟机，并且不便于移植到同事的电脑上。

思路4：使用windump，一个windows版本的tcpdump。缺陷是：我物理机下不能运行，虚拟机运行时，过滤器与保存文件的操作不能同时使用，工具的奇怪bug太多。

思路5：使用tshark实现windows下抓包，代替tcpdump 😃

实现逻辑

tshark相当于是命令行版的wireshark，不需要额外安装，在安装wireshark的时候就会安装上这个工具。那么，先开启tshark抓包，然后python爬取一个目标路径，最后tshark停止抓包，并将抓取的内容写入到电脑上。这里最大的问题是如何停止抓包，我是用的方法是设置抓包时间，让它到时间就停止。

关于tshark：

1. tshark的位置
   请使用Everything等工具直接搜索出来。
2. 使用tshark.exe -D命令查看电脑上有哪些网卡。
   我这里是以太网抓包，因此脚本中指定\Device\NPF_{FA29BC17-7BFC-4CE8-BB48-71174A6BDA54}即可指定抓取的网卡是以太网
   
3. \Device\NPF_{FA29BC17-7BFC-4CE8-BB48-71174A6BDA54}
   这串东西是接口名称，通过wireshark可以看到，如下图，点击一下“管理接口”即可看到。
   

代码设计

我一开始设计的是windump，tshark的代码是同事做的，这里介绍的是tshark，使用中有些注意事项：
工具总共涉及到3个文件：脚本、脚本配置文件、目标url地址。
只需修改配置文件和目标url地址即可，脚本无需修改（注意安装相关库文件），可以直接运行。

1. 填写配置文件：cfg.yaml
   指明tshark的绝对路径
   指明要抓包的网卡接口名称
   指明本机地址，充当捕获过滤器
   指明服务器，即目的地址，既用来拼接爬虫url，又用来充当捕获过滤器

# tshark 路径
tshark_path: "D:\\Program Files\\Wireshark\\tshark.exe"

# 网卡名称(tshark -D 查看网卡)
iface: r"\Device\NPF_{FA29BC17-7BFC-4CE8-BB48-71174A6BDA54}"

# 本机ip地址
localhost: "10.71.35.238"

# 服务器IP
serverIP: "10.8.144.32"

# 服务器端口
port: "8085"

2. 填写url地址：item.txt
   下面的地址用来跟cfg.yaml中的服务器IP进行拼接

/webtrojan/web-malware-collection-13-06-2012/PHP/SyRiAn.Sh3ll.v7.txt
/webtrojan/web-malware-collection-13-06-2012/PHP/ugdevil.v2.0.txt
/webtrojan/web-malware-collection-13-06-2012/PHP/up.php
/webtrojan/web-malware-collection-13-06-2012/PHP/uploader.txt

3. 脚本内容如下：
   要注意修改第80行的休眠时间，休眠时间过短的话，有可能抓不到包

import threading
import time
import requests
import os
import yaml
from subprocess import PIPE, Popen


# 导入配置文件
def load_cfg():
    with open('cfg.yaml', 'r', encoding='utf-8') as f:
        con = f.read()
    cfg = yaml.safe_load(con)
    # print(cfg['tshark_path'])
    return cfg


# 爬虫批量访问指定url
def request_url(url):
    url = 'http://' + url
    try:
        res = requests.get(url=url, timeout=5)
    except:
        print('failed to get' + url)
        return False
    if res.status_code == 200:
        return True
    else:
        print('访问失败，请重试：' + url)


# 使用tshark抓包
def tshark_cap(filename):
    # 提取url中最后一个斜线后面的内容作为文件名。如果文件名存在空格，就进行替换
    filename = filename.replace(' ', '_')  # 默认是一个空格，如果文件名中存在多个空格，请手动更改url或者修改代码
    filename = filename + '.pcap'  # 拼接出文件名
    file_path = 'pcaps/'  # 抓包的包放在pcaps文件夹下。pcaps是与脚本在同一路径下
    file = file_path + filename  # 拼接出文件的绝对路径
    cfg = load_cfg()
    tshark_path = cfg['tshark_path']
    tshark_path = tshark_path.strip()
    iface = cfg['iface']
    iface = iface.strip()
    localhost = cfg['localhost']
    localhost = localhost.strip()
    serverIP = cfg['serverIP']
    serverIP = serverIP.strip()
    filt = '"host ' + localhost + ' and host ' + serverIP + '"'  # 拼接出过滤器，用来过滤数据包
    command = tshark_path + ' -i ' + iface + ' -f ' + filt + ' -a duration:2 -w '  # 设定tshark抓包2秒，2秒之后自动关闭
    # command = r'"C:\\Program Files\\Wireshark\\tshark.exe" -i \Device\NPF_{144EC01C-9E64-43EC-AFA0-531860514A37} -f "host 10.71.35.157 and host 10.253.251.97" -a duration:3 -w '
    command = command + file
    # print(command)
    p = Popen(command, stdout=PIPE, stderr=PIPE)
    stdout, stderr = p.communicate()


def main():
    if not os.path.exists('pcaps'):
        os.mkdir('pcaps')
    print("请创建 item.txt 文件，并将表格中的内容粘贴进文件中....")
    os.system("pause")
    print('running....')
    with open('item.txt', 'rb') as f:
        contents = f.read()
    filenames = contents.decode('utf-8')
    filenames = filenames.split('\r\n')
    host = load_cfg()['serverIP'] + ":" + load_cfg()['port']
    for filename in filenames:
        if len(filename) < 1:
            continue
        filename = filename.strip()
        url = host + filename
        pname = filename.split('/')[-1]
        req = threading.Thread(target=request_url, name='request', args=(url,))
        cat = threading.Thread(target=tshark_cap, name='catpcap', args=(pname,))
        cat.start()
        # 请注意，休眠时间不足的话，会导致抓到的数据包是空包
        # 不同的电脑上，此时的休眠时间不同。我同事是2秒就行，我的是5秒才行.
        # 你需要通过输入不同的休眠时间来测试，究竟休眠多少时间才能抓到数据包
        time.sleep(5)
        req.start()
        req.join()
        cat.join()
        # time.sleep(1)


if __name__ == '__main__':
    print('''
本工具为批量抓包工具，访问一次指定地址，抓一次数据包。
==============================================================
使用说明：
安装wireshark时会默认安装“tshark.exe”（一个命令行版的wireshark），
你可以使用everything搜索出其位置，在终端中运行它，如“.\tshark.exe -D”获取本地网卡，选择你像抓取的网卡编号
脚本使用GET方法每访问一次目标地址，就会调用tshark抓一次包
数据包会导出在与脚本同目录下的“pcaps”文件夹下

1. 使用方法：python 批量抓包-1112项目专用.py
2. 注意：使用前请先配置 cfg.yaml（此文件需要与脚本位于同一目录下）
3. 在“item.txt”中输入你要访问的url地址（此文件需要与脚本位于同一目录下）
 
    ''')
    main()
    print('enjoy it :)')
    # os.system("pause")

效果演示