版本：
1.4 修正解析IP包总长度结果为0(IP_Total_Length == 0)的情况 wireshark 提示 (reported as 0, presumed to be because of "TCP segmentation offload" (TSO))
主要功能：
用于分析TCP交互过程中的用时信息，找出网络卡慢原因
前置操作：
安装 python3.x 环境
通过tcpdump或wireshark等抓包软件抓包并另存为PCAP文件格式
在程序末尾设置：
日志文件存放目录位置
PCAP文件或存放多个PCAP文件的目录位置
TCP用时分析包含：
客户端发送请求的传输用时(有多个数据包时计算传输完成用时)
服务端对客户端请求进行处理的计算用时(服务端处理速度)
服务端处理完后返回响应数据的传输用时(有多个数据包时计算传输完成用时)
客户端发起多个请求之间的间隔用时(如：等待用户输入、等待其他进程先完成)
客户端原因长时间等待保持连接用时(Keep-Alive)
服务端原因长时间等待保持连接用时(Keep-Alive)
客户端接收服务器响应数据包时缓冲区满造成等待用时(Windows=0)
服务端接收客户端请求数据包时缓冲区满造成等待用时(Windows=0)
会话超时被强制终止前的用时(未完成)
UDP用时分析包含：
(未完成)
数据解析功能：
解析TCP数据
解析HTTP数据
解析HTTPS数据(未完成)
解析MySQL数据(未完成)
解析UDP数据(未完成)
其他功能：
画流量图(精确到秒)需要先安装 matplotlib 模块
从PCAP文件(或存放多个PCAP文件的目录中)中提取指定会话的数据另存为PCAP文件
import socket, struct, os, time
from binascii import b2a_hex, a2b_hex
import logging
import re
from io import BytesIO ## 在内存中组装TCP数据用
import gzip
from urllib.parse import unquote
ReadMe = '''
版本：
1.4 修正解析IP包总长度结果为0(IP_Total_Length == 0)的情况 wireshark 提示 (reported as 0, presumed to be because of "TCP segmentation offload" (TSO))
主要功能：
用于分析TCP交互过程中的用时信息，找出网络卡慢原因
前置操作：
安装 python3.x 环境
通过tcpdump或wireshark等抓包软件抓包并另存为PCAP文件格式
在程序末尾设置：
日志文件存放目录位置
PCAP文件或存放多个PCAP文件的目录位置
TCP用时分析包含：
客户端发送请求的传输用时(有多个数据包时计算传输完成用时)
服务端对客户端请求进行处理的计算用时(服务端处理速度)
服务端处理完后返回响应数据的传输用时(有多个数据包时计算传输完成用时)
客户端发起多个请求之间的间隔用时(如：等待用户输入、等待其他进程先完成)
客户端原因长时间等待保持连接用时(Keep-Alive)
服务端原因长时间等待保持连接用时(Keep-Alive)
客户端接收服务器响应数据包时缓冲区满造成等待用时(Windows=0)
服务端接收客户端请求数据包时缓冲区满造成等待用时(Windows=0)
会话超时被强制终止前的用时(未完成)
UDP用时分析包含：
(未完成)
数据解析功能：
解析TCP数据
解析HTTP数据
解析HTTPS数据(未完成)
解析MySQL数据(未完成)
解析UDP数据(未完成)
其他功能：
画流量图(精确到秒)需要先安装 matplotlib 模块
从PCAP文件(或存放多个PCAP文件的目录中)中提取指定会话的数据另存为PCAP文件
'''
## 显示颜色
import ctypes
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12
绿色 = 0x0a # green.
红色 = 0x0c # red.
金色 = 0x0e # yellow.
白色 = 0x0f # white.
蓝色 = 0x09 # blue.
天蓝色 = 0x0b # skyblue.
深灰色 = 0x08 # dark gray.
暗天蓝色 = 0x03 # dark skyblue.
# get handle
std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
def 设置CMD颜色(color, handle=std_out_handle):
Bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)
return Bool
####################
## 解析数据包函数 ##
####################
## TCP校验
def 计算校验和(DATA):
LEN = len(DATA)
if LEN % 2 == 0:
FMT = '!' + str(LEN//2) + 'H'
else:
DATA += b'\x00'
LEN = len(DATA)
FMT = '!' + str(LEN//2) + 'H'
X = struct.unpack(FMT, DATA)
SUM = 0
for i in X:
SUM += i
while(SUM > 65535): ## 值大于 65535 说明二进制位数超过16bit
H16 = SUM >> 16 ## 取高16位
L16 = SUM & 0xffff ## 取低16位
SUM = H16 + L16
校验和 = SUM ^ 0xffff
#Log.debug(f"计算 TCP_Checksum {hex(校验和)}")
return(校验和)
## 解析包头(16字节)
def Packet_Header(BytesData):
PacketHeader = struct.unpack('IIII', BytesData)
时间戳 = PacketHeader[0]
微秒 = PacketHeader[1]
抓取数据包长度 = PacketHeader[2] # 所抓获的数据包保存在pcap文件中的实际长度，以字节为单位。
实际数据包长度 = PacketHeader[3] # 所抓获的数据包的真实长度，如果文件中保存不是完整的数据包，那么这个值可能要比前面的数据包长度的值大。
#return(时间戳, 微秒, 抓取数据包长度, 实际数据包长度)
时间戳_float = 时间戳 + 微秒/1000000
return(时间戳_float, 抓取数据包长度, 实际数据包长度)
## 解析帧头(14字节)
def EthernetII_Header(BytesData):
DstMAC = BytesData[0:6] # 目的MAC地址
SrcMAC = BytesData[6:12] # 源MAC地址
FrameType = BytesData[12:14] # 帧类型
return(DstMAC, SrcMAC, FrameType)
## 解析IP头(20字节)
def IPv4_Header(BytesData):
IP_B, IP_TOS, IP_Total_Length, IP_Identification, IP_H, IP_TTL, IP_Protocol, IP_Header_checksum, IP_Source, IP_Destination = struct.unpack('!BBHHHBBHII', BytesData) # B
IP_Version = IP_B >> 4 # 取1字节的前4位
IP_Header_Length = IP_B & 0xF # 取1字节的后4位
IP_Flags = IP_H >> 13
IP_Fragment_offset = IP_H & 0b0001111111111111
return(IP_Version, IP_Header_Length, IP_TOS, IP_Total_Length, IP_Identification, IP_Flags, IP_Fragment_offset, IP_TTL, IP_Protocol, IP_Header_checksum, IP_Source, IP_Destination)
## 解析TCP头(20字节)
def TCP_Header(BytesData):
TCP_Source_Port, TCP_Destination_Port, TCP_Sequence_Number, TCP_Acknowledgment_Number, TCP_H, TCP_Window, TCP_Checksum, TCP_Urgent_Pointers = struct.unpack('!HHLLHHHH', BytesData) # H(2B)
TCP_Data_Offset = TCP_H >> 12
先去掉后6位 = TCP_H >> 6
TCP_Reserved = 先去掉后6位 & 0b0000111111
TCP_Flags = TCP_H & 0b0000000000111111
return(TCP_Source_Port, TCP_Destination_Port, TCP_Sequence_Number, TCP_Acknowledgment_Number, TCP_Data_Offset, TCP_Reserved, TCP_Flags, TCP_Window, TCP_Checksum, TCP_Urgent_Pointers)
## 解析TCP头中Options(0字节或4字节的倍数)
def TCP_Options(BytesData):
#print("TCP_Options", BytesData)
## 格式 Kind/Type(1 Byte) + Length(1 Byte) + Value(X Bytes)
## EOL 和 NOP Option 只有 Kind/Type(1 Byte)
## 准备需要return的变量
MSS = 0 # 本端可以接受的最大实际数据长度(单位字节，不含TCP Header)，默认值536，最大65535
WSOPT = 0 # 窗口扩大系数（转成倍数是 2**WSOPT）
#SACK_Premitted = 0 # 告知对方自己支持SACK(允许只重传丢失部分数据)，自定义值，1表示启用，0表示不启用
L_SACK_INFO = [] # 重传的数据信息
N = 0 # 记录已经读到的位置
while N < len(BytesData):
# 读取首字节判断 Kind/Type(1 Byte)
Kind = BytesData[N:N+1]
#print(" Kind/Type", Kind)
if Kind == b'\x02':
## 最大Segment长度(MSS)
#print(" Kind: Maximum Segment Size (最大Segment长度)")
Length = 4 ## 固定为4
#print(" Length:", Length)
Value = struct.unpack('!H', BytesData[N+2:N+Length])[0]
#print(" Value: ", Value)
N += Length ## 更新N为实际已经读取了的字数
MSS = Value ## 赋值准备return的变量
elif Kind == b'\x01':
## 补位填充
#print(" Kind: NOP Option (补位填充)")
N +=1
elif Kind == b'\x00':
## 选项列表结束
#print(" Kind: EOL (选项列表结束)")
N +=1
elif Kind == b'\x03':
## 窗口扩大系数
#print(" Kind: Window Scaling Factor (窗口扩大系数)")
Length = 3 ## 固定为3
#print(" Length:", Length)
Value = struct.unpack('B', BytesData[N+2:N+Length])[0]
#print(" Value: ", Value)
N += Length
WSOPT = Value
elif Kind == b'\x04':
## 支持SACK
#print(" Kind: SACK-Premitted(支持SACK)")
Length = 2 ## 固定为2
#print(" Length:", Length)
N += Length
#SACK_Premitted = 1 ## 自定义，1表示启用，0表示不启用
elif Kind == b'\x05':
## 乱序/丢包数据
#print(" Kind: SACK Block(乱序/丢包信息)")
## 长度不固定，存在后续1个字节中
Length = struct.unpack('B', BytesData[N+1:N+2])[0]
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
#print("len(Value)", len(Value))
for i in range(0, len(Value)-2, 8):
T = struct.unpack('!II', Value[i:i+8])
#print("T", T)
L_SACK_INFO.append(T)
N += Length
elif Kind == b'\x08':
## Timestamps(随时间单调递增的值)
#print(" Kind: Timestamps(随时间单调递增的值)")
Length = 10 ## 固定为10
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
elif Kind == b'\x13': # 19
## MD5认证
#print(" Kind: TCP-MD5(MD5认证)")
Length = 18 ## 固定为18
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
elif Kind == b'\x1c': # 28
## 超过一定闲置时间后拆除连接
#print(" Kind: User Timeout(超过一定闲置时间后拆除连接)")
Length = 4 ## 固定为4
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
elif Kind == b'\x1d': # 29
## 认证（可选用各种算法）
#print(" Kind: TCP-AO(认证（可选用各种算法）)")
## 长度不固定，存在后续1个字节中
Length = struct.unpack('B', BytesData[N+1:N+2])[0]
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
elif Kind == b'\xfd': # 253
## 科研实验保留
#print(" Kind: Experimental(科研实验保留/253)")
## 长度不固定，存在后续1个字节中
Length = struct.unpack('B', BytesData[N+1:N+2])[0]
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
elif Kind == b'\xfe': # 254
## 科研实验保留
#print(" Kind: Experimental(科研实验保留/254)")
## 长度不固定，存在后续1个字节中
Length = struct.unpack('B', BytesData[N+1:N+2])[0]
#print(" Length:", Length)
Value = BytesData[N+2:N+Length]
#print(" Value: ", b2a_hex(Value))
N += Length
else:
print(f"【W】未知 TCP Option，终止继续解析TCP选项部分，Kind={Kind}")
Value = BytesData[N:]
print(" Value: ", b2a_hex(Value))
break
return(MSS, WSOPT, L_SACK_INFO)
## 粗略解析TCP实际数据（以UTF8编码解析，忽略解析不出的部分）
def TCP_DATA(BytesData):
print(BytesData.decode('UTF8', errors='ignore'))
##################################################
## 解析PCAP文件中每个数据包，结果存入全局总字典 ##
##################################################
## 总字典 # {(源地址,源端口,目的地址,目的端口):D_TCP, (目的地址,目的端口,源地址,源端口):D_TCP}
## 参数 D_TCP # 子字典，存单个TCP会话交互中的包信息
## 参数 PacketHeader_Bytes # PCAP文件存储每个数据包的包头（16字节）内容为：时间戳, 抓取数据包长度, 实际数据包长度
## 参数 PacketData # 数据包实际内容
## 记录 D_TCP['L_DATA'] # TCP会话交互中的包简要信息列表 (编号,时间戳,SrcIP,DstIP,SrcPort,DstPort,Seq,Ack,FLAGE,TCP_DATA_LEN,TCP_req_or_ack,TCP_Window,hex(TCP_Checksum),PS)
## 前置条件：不能含VLAN信息，这些由前置拆分PCAP文件的函数解决
##################################################
def D_SAVE(D_TCP, PacketHeader_Bytes, PacketData, 编号):
TCP校验 = 0 # 是否检查TCP校验和，0关闭 1开启
PS = '' # 初始化每个包的备注信息
时间戳, 抓取数据包长度, 实际数据包长度 = Packet_Header(PacketHeader_Bytes)
DstMAC, SrcMAC, FrameType = EthernetII_Header(PacketData[0:14]) # 以太帧头
###########【IPv4】###########
if FrameType == b'\x08\x00':
## 解析IP头(20字节[14:34])
(IP_Version, IP_Header_Length, IP_TOS, IP_Total_Length, IP_Identification, IP_Flags, IP_Fragment_offset, IP_TTL, IP_Protocol, IP_Header_checksum, IP_Source, IP_Destination) = IPv4_Header(PacketData[14:34])
IP部首字节长度 = IP_Header_Length*4
###########【TCP】###########
if IP_Protocol == 6: # TCP b'\x06'
TCP_Source_Port, TCP_Destination_Port, TCP_Sequence_Number, TCP_Acknowledgment_Number, TCP_Data_Offset, TCP_Reserved, TCP_Flags, TCP_Window, TCP_Checksum, TCP_Urgent_Pointers = TCP_Header(PacketData[34:54])
if TCP_Reserved != 0:
Log.debug("【注意，保留6bit被使用，支持(CWR/ECN)功能】TCP_Reserved(6bit)", TCP_Reserved)
## 根据TCP部首长度计算是否有TCP可选字段
TCP部首实际长度 = TCP_Data_Offset*4
TCP部首固定长度 = 20
TCP选项长度 = TCP部首实际长度 - TCP部首固定长度
## 初始化TCP选项信息
MSS = 0 # 本端可以接受的最大实际数据长度(单位字节，不含TCP Header)，默认值536，最大65535
WSOPT = 0 # 窗口扩大系数
L_SACK_INFO = [] # 放丢包信息
if TCP选项长度 > 0:
MSS, WSOPT, L_SACK_INFO = TCP_Options(PacketData[54:54+TCP选项长度])
if MSS == 0:
MSS = 536 # 使用默认值
TCP_DATA_LEN = IP_Total_Length - IP部首字节长度 - TCP部首固定长度 - TCP选项长度
## 计算数据长度
## 最小60字节，不足会填充
#剩余全部数据 = PacketData[54+TCP选项长度:]
剩余有效数据 = PacketData[54+TCP选项长度:54+TCP选项长度+TCP_DATA_LEN]
#print("剩余全部数据字节数(TCP选项后全部)", len(剩余全部数据)) ## 当不足最小长度会填充，这个会比下面的大
#print("剩余有效数据字节数(计算得到)", len(剩余有效数据))
## 修正解析IP包总长度结果为0的情况 wireshark 提示 (reported as 0, presumed to be because of "TCP segmentation offload" (TSO))
if IP_Total_Length == 0:
剩余有效数据 = PacketData[54+TCP选项长度:] # 修正内容数据值为剩余全部数据值
TCP_DATA_LEN = len(剩余有效数据) # 修正内容数据的长度值
## 是否进行TCP校验，校验错误的包可能可以正常使用
if TCP校验 == 1:
## 校验TCP是否正确
#print("提取 TCP_Checksum", hex(TCP_Checksum))
TCP_Pseudo_Total_Length = TCP部首实际长度 + TCP_DATA_LEN
#print("TCP_Pseudo_Total_Length", TCP_Pseudo_Total_Length)
TCP_Pseudo_Header = PacketData[26:34] + b'\x00\x06' + struct.pack('!H', TCP_Pseudo_Total_Length) # 构造TCP伪部首
if TCP选项长度 == 0:
DATA = TCP_Pseudo_Header + PacketData[34:54] + 剩余有效数据
else:
TCP选项_Bytes = PacketData[54:54+TCP选项长度]
DATA = TCP_Pseudo_Header + PacketData[34:54] + TCP选项_Bytes + 剩余有效数据
校验结果 = 计算校验和(DATA) #校验通过返回为0
if 校验结果 != 0:
PS = PS + f"TCP校验错误({hex(校验结果)})"
## 分析数据包中的TCP内容
TCP_req_or_ack = '' # 标识一下是请求还是响应（一般都是客户端发起请求，服务端响应）
FLAGE = ''
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort = TCP_Source_Port
DstPort = TCP_Destination_Port
Seq = TCP_Sequence_Number
Ack = TCP_Acknowledgment_Number
if TCP_Flags == 24: # 24 011000 URG ACK PSH RST SYN FIN
FLAGE = 'ACK PSH'
elif TCP_Flags == 16: # 16 010000 URG ACK PSH RST SYN FIN
FLAGE = 'ACK'
elif TCP_Flags == 17: # 17 010001 URG ACK PSH RST SYN FIN
FLAGE = 'ACK FIN'
elif TCP_Flags == 18: # 18 010010 URG ACK PSH RST SYN FIN
FLAGE = 'ACK SYN'
elif TCP_Flags == 2: # 2 000010 URG ACK PSH RST SYN FIN
FLAGE = 'SYN'
elif TCP_Flags == 20: # 20 010100 URG ACK PSH RST SYN FIN
FLAGE = 'ACK RST'
elif TCP_Flags == 4: # 4 000100 URG ACK PSH RST SYN FIN
FLAGE = 'RST'
elif TCP_Flags == 25: # 25 011001 URG ACK PSH RST SYN FIN
FLAGE = 'A.P.F'
elif TCP_Flags == 28: # 28 011100 URG ACK PSH RST SYN FIN
FLAGE = 'A.P.R'
else:
FLAGE = 'NA'
Log.error("【ERROR】TCP_Flags unknown %d URG ACK PSH RST SYN FIN 编号 %d" % (TCP_Flags, 编号))
## 先判断出客户端和服务端的IP及端口
## 如果前面还没有判断出客户端和服务端，且这个包不是'SYN'和'ACK SYN'，就根据端口大小估计客户端和服务端，大的为客户端
if D_TCP['CLIENT'] == ():
if FLAGE not in ('SYN', 'ACK SYN'):
if SrcPort > DstPort:
D_TCP['CLIENT'] = (SrcIP, SrcPort)
D_TCP['SERVER'] = (DstIP, DstPort)
D_TCP['C_Tx_DATA_ALL'] = Seq
D_TCP['S_Tx_DATA_ALL'] = Ack
else:
D_TCP['CLIENT'] = (DstIP, DstPort)
D_TCP['SERVER'] = (SrcIP, SrcPort)
D_TCP['S_Tx_DATA_ALL'] = Seq
D_TCP['C_Tx_DATA_ALL'] = Ack
## 根据FLAGE分类存数据包
if FLAGE in ('ACK', 'ACK PSH'):
## 先区分是哪端发的ACK
if SrcPort == D_TCP['CLIENT'][1]:
## 客户端发ACK
## Seq = C发的这个包的数据编号（累计值，不含当次数据，不含重发）
## Ack = C确认已经接到S数据的编号（丢包/乱序信息放在TCP选项SACK中发送）
## 判断是否有数据
if TCP_DATA_LEN == 0:
TCP_ACK_KeepAlive_Mark = 0 # 标记是否是Keep-Alive包，0表示不是。1表示是，初始化为0
if TCP_Window == 0: # 记录C发的ACK且窗口为0的包信息，说明C接收缓存满，同一段接收满的包的(Seq,Ack)相同，就只记录一次Ack
PS = PS + '接收缓冲区已满(C)'
if Ack not in D_TCP['D_C_WIN_0']:
D_TCP['D_C_WIN_0'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)] # 记录C接收缓存满的包信息
D_TCP['C_ACK_WIN_0'].append((Seq,Ack)) # 记录C接收缓存满的包信息（判断对方探测包使用）
else:
D_TCP['D_C_WIN_0'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)) # 记录C接收缓存满的包信息
if L_SACK_INFO != []:
if L_SACK_INFO[0][0] +1 == L_SACK_INFO[0][1]:
PS = PS + f'【TCP Keep-Alive ACK】(C) 响应保持连接包，L_SACK_INFO={L_SACK_INFO}'
TCP_ACK_KeepAlive_Mark = 1 # 标记是Keep-Alive包
## 保存C响应保持连接的包信息
if Ack in D_TCP['C_TCP_Keep_Alive_ACK']:
D_TCP['C_TCP_Keep_Alive_ACK'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['C_TCP_Keep_Alive_ACK'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
else:
PS = PS + f'C丢包乱序通知={L_SACK_INFO}'
## 保存纯确认消息包到 D_C_ACK （C确认收完S数据的纯回应包会在这里）
if TCP_ACK_KeepAlive_Mark == 0: # 忽略响应保持连接包
if Ack in D_TCP['D_C_ACK']:
D_TCP['D_C_ACK'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window))
else:
D_TCP['D_C_ACK'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window)]
## 数据长度为1，Seq(自发送累计) 主动变小1的，应该就是C发的keep-alive包，不累计大小
elif TCP_DATA_LEN == 1 and 剩余有效数据 == b'\x00':
PS = PS + '【TCP Keep-Alive】 (C) 请求保持连接包(长度1，内容空)'
## 保存C发起保持连接的包信息
if Ack in D_TCP['C_TCP_Keep_Alive']:
D_TCP['C_TCP_Keep_Alive'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['C_TCP_Keep_Alive'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
elif TCP_DATA_LEN == 1 and (Ack,Seq) in D_TCP['S_ACK_WIN_0']: # TCP数据长度是1且能和S缓存满的消息能对应上，说明是C发的探测S窗口的包
PS = PS + '(C=>S Window=?)'
#elif TCP_DATA_LEN == 1: # 查看长度为1情况
# print(编号, 剩余有效数据, len(剩余有效数据))
else:
## 已经避开了纯消息包和保持连接的包
## 记录TCP有效数据的包信息(C)发起的（一般都是客户端发起请求，包信息保存到 C_TCP_REQ 字典 Key=Ack Value=[(包信息1),(包信息2)] 一个请求可能会分成多个包发送）
TCP_req_or_ack = 'C_req' # 备注标识为：客户端发起请求
if Ack in D_TCP['D_C_ACK_DATA']:
D_TCP['D_C_ACK_DATA'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['D_C_ACK_DATA'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
## 重复的情况
if (Seq,Ack) not in D_TCP['P_C_Tx_Seq_Ack']:
D_TCP['P_C_Tx_Seq_Ack'].add((Seq,Ack)) # 加入C发送过的数据集合，查重复用
D_TCP['C_Tx_DATA_ALL'] += TCP_DATA_LEN # 累计C发送数据(也可以用于识别C发的keep-alive)
else:
PS = PS + 'C重发数据(Seq,Ack)完全重复'
else:
## 服务端发ACK
## Seq = S自己已经发数据的累计（不含本次的数据量，不累计重发数据）
## Ack = S已经接到了C发的多少数据（S告诉C端，S是接到C多少数据后的回应，在HTTP里这个可以用于区别这个回应是针对哪个请求的）
if TCP_DATA_LEN == 0:
## 保存到 D_S_ACK
if Ack in D_TCP['D_S_ACK']:
D_TCP['D_S_ACK'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window))
else:
D_TCP['D_S_ACK'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window)]
if TCP_Window == 0: # 记录S发的ACK且窗口为0的包信息(Seq,Ack)说明S接收缓存满
PS = '接收缓冲区已满(S)'
if Ack not in D_TCP['D_S_WIN_0']:
D_TCP['D_S_WIN_0'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
D_TCP['S_ACK_WIN_0'].append((Seq,Ack)) # 记录S接收缓存满的包信息
else:
D_TCP['D_S_WIN_0'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
if L_SACK_INFO != []:
if L_SACK_INFO[0][0] +1 == L_SACK_INFO[0][1]:
PS = PS + f'【TCP Keep-Alive ACK】(S) 响应保持连接包，L_SACK_INFO={L_SACK_INFO}'
## 保存S响应保持连接的包信息
if Ack in D_TCP['S_TCP_Keep_Alive_ACK']:
D_TCP['S_TCP_Keep_Alive_ACK'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['S_TCP_Keep_Alive_ACK'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
else:
PS = PS + f'S丢包乱序通知={L_SACK_INFO}'
## 数据长度是1且能和C缓存满的消息能对应上（Seq Ack 交换位置），说明是S发的探测C窗口的包
elif TCP_DATA_LEN == 1 and (Ack,Seq) in D_TCP['C_ACK_WIN_0']:
PS = PS + '探测窗口(S=>C Window=?)'
## (S) 请求保持连接包(长度1，内容空)
elif TCP_DATA_LEN == 1 and 剩余有效数据 == b'\x00':
PS = PS + '【TCP Keep-Alive】 (S) 请求保持连接包(长度1，内容空)'
## 保存S发起保持连接的包信息
if Ack in D_TCP['S_TCP_Keep_Alive']:
D_TCP['S_TCP_Keep_Alive'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['S_TCP_Keep_Alive'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
else:
## 已经避开了纯消息包和保持连接的包
TCP_req_or_ack = ' S_ack' # 备注标识为：服务端响应请求
## 记录TCP有效数据的包信息(S)发起的
if Ack in D_TCP['D_S_ACK_DATA']:
D_TCP['D_S_ACK_DATA'][Ack].append((时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号))
else:
D_TCP['D_S_ACK_DATA'][Ack] = [(时间戳, Seq, Ack, TCP_DATA_LEN, TCP_Window, 编号)]
## 重复的情况
if (Seq,Ack) not in D_TCP['P_S_Tx_Seq_Ack']:
D_TCP['P_S_Tx_Seq_Ack'].add((Seq,Ack))
D_TCP['S_Tx_DATA_ALL'] += TCP_DATA_LEN # 累计S发送数据(也可以用于识别S发的keep-alive)
else:
PS = PS + 'S重发数据(Seq,Ack)完全重复'
elif FLAGE in ('ACK FIN', 'A.P.F'): ## 终止连接
if DstPort == D_TCP['CLIENT'][1]: ## 是 S 发起的 ACK FIN
PS = PS + '(S)发起终止连接'
if Seq in D_TCP['S_ACK_FIN_SeqKey']:
D_TCP['S_ACK_FIN_SeqKey'][Seq].append((时间戳, Seq, Ack, TCP_DATA_LEN))
else:
D_TCP['S_ACK_FIN_SeqKey'][Seq] = [(时间戳, Seq, Ack, TCP_DATA_LEN)]
else: ## 是 C 发起的 ACK FIN
PS = PS + '(C)发起终止连接'
D_TCP['C_ACK_FIN'] = (时间戳, Seq, Ack, TCP_DATA_LEN)
elif FLAGE in ('ACK RST', 'RST', 'A.P.R'): ## 强制断开连接
if DstPort == D_TCP['CLIENT'][1]:
if Ack in D_TCP['S_ACK_RST']:
PS = PS + 'S强制终止连接(重复)'
else:
D_TCP['S_ACK_RST'][Ack] = (时间戳, Seq, Ack, TCP_DATA_LEN)
PS = PS + 'S强制终止连接'
else:
## C终止自己的请求 C_ACK_RST_AckKey 以Ack为KEY，给没有数据回应情况用请求Ack匹配RST的ACK
if Ack in D_TCP['C_ACK_RST_AckKey']:
PS = PS + 'C强制终止连接(重复)'
else:
PS = PS + 'C强制终止连接'
D_TCP['C_ACK_RST_AckKey'][Ack] = (时间戳, Seq, Ack, TCP_DATA_LEN) # 记录
## C终止自己的请求 C_ACK_RST_SeqKey 以Seq为KEY，期望S响应的Ack=这个Seq，给有回应的匹配用
if Seq in D_TCP['C_ACK_RST_SeqKey']:
PS = PS + '(匹配有回应)'
else:
D_TCP['C_ACK_RST_SeqKey'][Seq] = (时间戳, Seq, Ack, TCP_DATA_LEN) # 记录
PS = PS + '(记录)'
elif FLAGE == 'SYN': ## 发起连接方是客户端
if D_TCP['CLIENT'] != ():
if D_TCP['CLIENT'] == (SrcIP, SrcPort):
PS = PS + f"重复SYN【C 新建TCP连接】初始Seq={D_TCP['C_Tx_DATA_ALL']} MSS={MSS} 窗口扩大系数={WSOPT}"
else:
D_TCP['CLIENT'] = (SrcIP, SrcPort)
D_TCP['SERVER'] = (DstIP, DstPort)
D_TCP['C_SYN'] = (时间戳, Seq, Ack, 0)
D_TCP['C_Tx_DATA_ALL'] = Seq+1 ## 客户端初始数据编号
PS = PS + f"前面判断谁是客户端错误或端口被复用，重置【C 新建TCP连接】初始Seq={D_TCP['C_Tx_DATA_ALL']} MSS={MSS} 窗口扩大系数={WSOPT}"
else:
D_TCP['CLIENT'] = (SrcIP, SrcPort)
D_TCP['SERVER'] = (DstIP, DstPort)
D_TCP['C_SYN'] = (时间戳, Seq, Ack, 0)
D_TCP['C_Tx_DATA_ALL'] = Seq+1 ## 客户端初始数据编号
PS = PS + f"【C 新建TCP连接】初始Seq={D_TCP['C_Tx_DATA_ALL']} MSS={MSS} 窗口扩大系数={WSOPT}"
elif FLAGE == 'ACK SYN': ## 回应SYN请求，是本次连接的服务端，Seq随机，Ack为发起方Seq+1
if D_TCP['CLIENT'] == ():
D_TCP['CLIENT'] = (DstIP, DstPort)
D_TCP['SERVER'] = (SrcIP, SrcPort)
if D_TCP['C_SYN'] != ():
if Ack == D_TCP['C_SYN'][1] + 1:
D_TCP['S_ACK_SYN'] = (时间戳, Seq, Ack, 0)
D_TCP['S_Tx_DATA_ALL'] = Seq+1 ## 服务端初始数据编号
PS = PS + f"【S 响应TCP连接】初始Seq={D_TCP['S_Tx_DATA_ALL']} MSS={MSS} 窗口扩大系数={WSOPT}"
else:
PS = PS + 'SYN_ACK错误 或 SYN重连 或 端口被复用'
else:
DEBUG = f"【DEBUG】编号={编号} ACK SYN 前面没有SYN"
Log.debug(DEBUG)
else:
Log.error(f"【ERROR】未定义怎么处理的 FLAGE {FLAGE} 忽略")
PS = PS + f"【ERROR】未定义怎么处理的 FLAGE {FLAGE} 忽略"
## 保存信息用于显示（TCP校验通过的包/忽略TCP校验的包）
D_TCP['L_DATA'].append((编号,时间戳,SrcIP,DstIP,SrcPort,DstPort,Seq,Ack,FLAGE,TCP_DATA_LEN,TCP_req_or_ack,TCP_Window,hex(TCP_Checksum),PS))
elif IP_Protocol == 17:
Log.error("【ERROR】UDP PASS")
else:
Log.error("【ERROR】NOT TCP/UDP PASS")
else:
Log.error("【ERROR】NOT IPv4 Ethernet")
## 记录数据包信息
def SHOW_PACK_INFO(L_DATA):
Log.info('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-5s %5s %s %s' % ('ID','TIME','SrcIP','DstIP','SPort','DPort','Seq','Ack','FLAGE','LEN','请求/响应','WIN','校验码','备注说明'))
for i in L_DATA:
Log.info('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s' % i)
Log.info('')
#############################
## 分析请求/响应的交互时间 ##
#############################
## 以客户端视角(在客户端处抓包)或服务端视角(在服务端处抓包)分析每个请求/响应的交互时间，记录各过程耗时，返回列表
## 请求完成耗时 COMP
## 发完请求耗时 C_req
## 处理请求耗时 SYS
## 传回结果耗时 S_send
## 请求包数量 C_PKS
## 响应包数量 S_PKS
## 设置了一下可以反应问题的自定义响应码：
# 响应状态码 = 0 # 自定义初始值，如果后面解析不出，就响应码设置为0
# 响应状态码 = 1 # 自定义，两种方法都找不到响应信息，且发现了C发的RST信息
# 响应状态码 = 2 # 自定义，两种方法都找不到响应信息，且没有发现C发的RST信息，应该是真没有响应
# 响应状态码 = 3 # 自定义，两种方法都找不到响应信息，且找到服务端发起了FIN终止
# 响应状态码 = 4 # 自定义，有响应的情况下表示C发起了RST，强制断开连接
# 响应状态码 = 5 # 自定义，两种方法都找不到响应信息，且发现了S发的RST信息
## 分析请求的结果及用时信息（一次TCP会话中全部交互过程），返回分析结果 L_TCP_TIME
def TCP_SESSION_TIME(D_TCP):
## 客户端发起的请求都在 D_TCP['D_C_ACK_DATA'] 中，有数据，大请求分成多个包的话seq最小那个是第一个包（可在乱序中找到实际第一个包）
## 在 D_TCP['D_C_ACK_DATA'] 中找出起始请求包，生成包信息列表
L_C_ACK = []
for K in D_TCP['D_C_ACK_DATA']: # {1653587983: [(1625798739.757637, 1741930757, 1653587983, 87, 8212, 5)], ...}
L = D_TCP['D_C_ACK_DATA'][K]
MIN_INFO = L[0]
MIN_SEQ = L[0][1]
for Ln in range(1, len(L)):
if L[Ln][1] < MIN_SEQ:
MIN_SEQ = L[Ln][1]
MIN_INFO = L[Ln]
L_C_ACK.append(MIN_INFO)
## 服务端响应生成一个以Seq为Key，Ack为值的字典，方便客户端以自己Ack去匹配服务端Seq然后找出相应服务端Ack
D_S_ACK_DATA_SeqKey = {}
for K in D_TCP['D_S_ACK_DATA']:
L = D_TCP['D_S_ACK_DATA'][K]
MIN_SEQ = L[0][1]
ACK = L[0][2]
for Ln in range(1, len(L)):
if L[Ln][1] < MIN_SEQ:
MIN_SEQ = L[Ln][1]
ACK = L[Ln][2]
D_S_ACK_DATA_SeqKey[MIN_SEQ] = ACK
L_TCP_TIME = [] # 记录用时分析结果
for C_REQ in L_C_ACK:
C发送请求时间戳 = C_REQ[0]
REQ_seq = C_REQ[1]
REQ_ack = C_REQ[2]
REQ_len = C_REQ[3]
## 设置初始值
响应状态码 = 0 # 正常响应设置为0
请求类型 = "TCP"
## 处理 C 发送的请求包
Log.debug(f"C 发送 {请求类型} 请求 ACK={REQ_ack}")
C发送请求包列表 = D_TCP['D_C_ACK_DATA'][REQ_ack]
## 检查一下有没有异常的数据包（乱序/编号有问题）
if 检查数据包编号(C发送请求包列表) == 1:
Log.debug(" 【WARNING】数据包编号有乱序")
else:
Log.debug(" 数据包编号正常（单包请求忽略检查）")
## 开始分析请求时间信息（没有处理重发/乱序问题）
REQ_DATA_LEN = 0 # 累计请求数据总长度(字节)
C发送请求尾包 = C发送请求包列表[-1] # 请求包按时间最后一个
C发完请求耗时 = C发送请求尾包[0] - C发送请求时间戳 # 最后一个减去第一个包的时间，单包请求结果为0
for i in C发送请求包列表:
Log.debug(f' {请求类型} 请求信息 {i}')
REQ_DATA_LEN += i[3]
累计计算预估S响应ACK = REQ_seq+REQ_DATA_LEN
## C 发送的请求包数量(含重复包)
C发送请求包数量 = len(C发送请求包列表)
Log.debug(f" C 发送 {请求类型} 数据统计：数量 {C发送请求包数量} 个，共 {REQ_DATA_LEN} 字节")
Log.debug(f" C 发送 {请求类型} 时间 {C发送请求时间戳}")
Log.debug(f" C 发完 {请求类型} 时间 {C发送请求尾包[0]}")
Log.debug(" C 发完 %s 耗时 %.6f 秒 (含重发数据的时间)" % (请求类型, C发完请求耗时))
if REQ_ack in D_S_ACK_DATA_SeqKey: ## D_S_ACK_DATA_SeqKey 的KEY是HTTP首回应包的seq，值等于请求的ack
C_REQ提取S_ACK = D_S_ACK_DATA_SeqKey[REQ_ack]
else:
C_REQ提取S_ACK = -1
if C_REQ提取S_ACK == 累计计算预估S响应ACK:
Log.debug(f" 【I】期望 S 回应 ACK {C_REQ提取S_ACK}(请求ACK查响应SEQ) == {累计计算预估S响应ACK}(发数据累计预估)")
else:
Log.debug(f" 【W】期望 S 回应 ACK {C_REQ提取S_ACK}(请求ACK查响应SEQ) != {累计计算预估S响应ACK}(发数据累计预估)")
## 检查有没有响应数据
if C_REQ提取S_ACK in D_TCP['D_S_ACK_DATA']: ## 初始值是负数，没有找到可用值时使用初始可以保证这个判断失败
Log.debug(f" 【I】使用(请求ACK查响应SEQ)找到的响应信息")
S响应ACK = C_REQ提取S_ACK
elif 累计计算预估S响应ACK in D_TCP['D_S_ACK_DATA']:
Log.debug(f" 【I】使用(累计计算预估S响应ACK)找到的响应信息")
S响应ACK = 累计计算预估S响应ACK
elif 累计计算预估S响应ACK in D_TCP['S_ACK_RST']:
Log.debug(f" 【E】使用(累计计算预估S响应ACK)找到S强制终止连接的响应信息")
响应状态码 = 5 ## 自定义，两种方法都找不到响应信息，且发现了S发的RST信息
L_TCP_TIME.append((REQ_ack, C发送请求时间戳, 请求类型, 响应状态码, 0, C发完请求耗时, 0, 0, C发送请求包数量, 0))
continue
elif REQ_ack in D_TCP['C_ACK_RST_AckKey']:
Log.debug(f" 【E】找不到响应数据，找到C主动终止了连接：发现ACK={REQ_ack} 在 D_TCP['C_ACK_RST_AckKey']出现")
响应状态码 = 1 ## 自定义，两种方法都找不到响应信息，且发现了C发的RST信息
L_TCP_TIME.append((REQ_ack, C发送请求时间戳, 请求类型, 响应状态码, 0, C发完请求耗时, 0, 0, C发送请求包数量, 0))
continue
elif REQ_ack in D_TCP['S_ACK_FIN_SeqKey']:
Log.debug(f" 【E】找不到响应数据，找到服务端发送FIN终止连接：{D_TCP['S_ACK_FIN_SeqKey'][REQ_ack]}")
响应状态码 = 3 ## 自定义，两种方法都找不到响应信息，且找到服务端发起了FIN终止
L_TCP_TIME.append((REQ_ack, C发送请求时间戳, 请求类型, 响应状态码, 0, C发完请求耗时, 0, 0, C发送请求包数量, 0))
continue
else:
Log.debug(" 【E】两种方法都找不到响应信息，且没有发现C发的RST信息，应该是真没有响应")
响应状态码 = 2 ## 自定义，两种方法都找不到响应信息，且没有发现C发的RST信息，应该是真没有响应
L_TCP_TIME.append((REQ_ack, C发送请求时间戳, 请求类型, 响应状态码, 0, C发完请求耗时, 0, 0, C发送请求包数量, 0))
continue
## 2个方法中任意成功一个就继续分析
S发送响应数据包列表 = D_TCP['D_S_ACK_DATA'][S响应ACK]
## 有响应响应信息会继续下面的分析
## 当客户端发起RST，服务器依据可能返回响应数据，为了区分出这种情况，最后再查一下这个，修改响应码标识
if S响应ACK in D_TCP['C_ACK_RST_SeqKey']:
Log.debug(f" 【W】有响应的情况下C主动终止了连接：RST_Seq=S响应ACK={S响应ACK} 在 D_TCP['C_ACK_RST_SeqKey']出现（设置自定义SC=4）")
响应状态码 = 4 # 自定义，有响应的情况下表示C发起了RST，强制断开连接
## 检查一下有没有异常的数据包（乱序/编号有问题）
if 检查数据包编号(S发送响应数据包列表) == 1:
Log.debug(" 【WARNING】数据包编号有乱序")
else:
Log.debug(" 数据包编号正常（单包请求忽略检查）")
## 接到的正常响应包
R_REQ_DATA_LEN = 0
for i in S发送响应数据包列表:
Log.debug(f" {请求类型} 响应信息 {i}")
R_REQ_DATA_LEN += i[3]
## S重发响应数据包，(Seq,Ack)重复的包
S发送请求包数量 = len(S发送响应数据包列表)
# S发送请求包数量 += 1
Log.debug(" S 响应数据统计：数量 %d 个，共 %d 字节，响应状态码 %d" % (S发送请求包数量, R_REQ_DATA_LEN, 响应状态码))
S发送响应数据包首数据 = S发送响应数据包列表[0]
S发送响应数据包尾数据 = S发送响应数据包列表[-1]
S处理请求耗时 = S发送响应数据包首数据[0] - C发送请求尾包[0]
Log.debug(f' S 发送响应数据时间 {S发送响应数据包首数据[0]}')
Log.debug(f' S 发完响应数据时间 {S发送响应数据包尾数据[0]}')
S发完响应数据耗时 = S发送响应数据包尾数据[0] - S发送响应数据包首数据[0]
Log.debug(" S 发完响应数据耗时 %.6f (含重发数据的时间)" % (S发完响应数据耗时))
Log.debug(" S 处理 %s 耗时 %.6f 秒 (S发送响应数据首包时间 - C发送请求数据尾包时间)" % (请求类型, S处理请求耗时))
C完成请求耗时 = S发送响应数据包尾数据[0] - C发送请求时间戳
Log.debug(" 完成 %s 总耗时 %.6f 秒 (S发送响应数据尾包时间 - C发送请求数据首包时间)" % (请求类型, C完成请求耗时))
## 记录耗时（正常情况）
L_TCP_TIME.append((REQ_ack, C发送请求时间戳, 请求类型, 响应状态码, C完成请求耗时, C发完请求耗时, S处理请求耗时, S发完响应数据耗时, C发送请求包数量, S发送请求包数量))
## 查看重复的首个请求信息
#if K in D_TCP['C_HTTP_REQ_RPT']:
# Log.warning(f"【WARNING】请求首包有重发 {D_TCP['C_HTTP_REQ_RPT'][K]}")
Log.debug('')
return(L_TCP_TIME)
## 请求耗时信息汇总 L_TCP_TIME
def SHOW_TCP_ALTERNATELY_TIME(L_TCP_TIME, 视角='S'):
Log.info('')
if L_TCP_TIME != []:
if 视角 == 'S':
Log.info("【每个请求发出到收完响应数据的耗时信息（服务端抓包）单位秒】")
Log.info(" %-9s %-9s %4s %3s %5s %7s %7s %7s %4s %4s" % ('请求(ack)','时间戳','类型','SC','COMP','C_req','SYS','S_send','C_PKS','S_PKS'))
else:
Log.info("【每个请求发出到收完响应数据的耗时信息（客户端抓包）单位秒】")
Log.info(" %-9s %-9s %4s %3s %5s %7s %7s %7s %4s %4s" % ('请求(ack)','时间戳','类型','SC','COMP','C_req','SYS_NET','S_send','C_PKS','S_PKS'))
for i in L_TCP_TIME:
Log.info(" %10d %.2f %4s %-4d %7.3f %7.3f %7.3f %7.3f %4d %4d" % i)
Log.info('')
## 正常返回0 错误返回1
def 检查数据包编号(L):
#Log.debug(f" L{L}")
#Log.debug(f" S 0 {L[0]}")
数量 = len(L)
if 数量 > 1:
SEQ = L[0][1]
LEN = L[0][3]
for i in range(1, 数量):
if L[i][1] == SEQ + LEN:
SEQ = SEQ + LEN
LEN = L[i][3]
#Log.debug(f" V {i} {L[i]}")
else:
#Log.debug(f" X {i} {L[i]}")
Log.debug(f" 【DEBUG】错误包{L[i]}")
return(1)
return(0)
## 整个TCP交互的开始和结束时间（估计值，不精确）
def 整个TCP交互的开始和结束时间(D_TCP, L_DATA):
if D_TCP['C_SYN'] == ():
C_发起开始时间 = L_DATA[0][1] # 第一个包的时间戳
else:
C_发起开始时间 = D_TCP['C_SYN'][0]
if D_TCP['C_ACK_FIN'] == ():
C_发起结束时间 = L_DATA[-1][1] # 最后一个包的时间戳
else:
C_发起结束Ack = D_TCP['C_ACK_FIN'][2] ## D_TCP['C_ACK_FIN'] = (时间戳, Seq, Ack, TCP数据长度)
if C_发起结束Ack in D_TCP['D_C_ACK']:
C_发起结束时间 = D_TCP['D_C_ACK'][C_发起结束Ack][0][0] ## C FIN 前的ack纯确认包作为实际交互结束时间点
else:
C_发起结束Seq = D_TCP['C_ACK_FIN'][1]
C_发起结束时间 = D_TCP['D_S_ACK_DATA'][C_发起结束Seq][0][0] ## C FIN 前的服务端最后数据包作为交互结束时间点（客户端直接结束交互的情况）
return(C_发起开始时间, C_发起结束时间)
## 从TCP会话字典信息D_TCP中统计分析 Keep-Alive 时间（分服务端原因造成的和客户端原因造成的情况）
## L_C_KeepAlive_RANGE (客户端原因等待的时间戳区间列表：可能是客户端在等待什么，如等待用户输入，等待其他任务完成)
## L_S_KeepAlive_RANGE (服务端原因等待的时间戳区间列表：可能是服务端在处理耗时的请求)
def 分析KeepAlive耗时(D_TCP):
L_C_KeepAlive_RANGE = []
L_S_KeepAlive_RANGE = []
## 先分析C首先发起KeepAlive的情况
Log.debug(f" 遍历 D_TCP['C_TCP_Keep_Alive']")
for Ack in D_TCP['C_TCP_Keep_Alive']: # 每个客户端发起每段保持连接信息（相同Ack是同一KeepAlive区间）
Log.debug(f" {Ack}:{D_TCP['C_TCP_Keep_Alive'][Ack]}")
归属标识 = '' # 需要判断是客户端还是服务器原因造成的KeepAlive
C_time = D_TCP['C_TCP_Keep_Alive'][Ack][0][0] # 本段C发起KeepAlive的第一个包的时间戳
C_seq = D_TCP['C_TCP_Keep_Alive'][Ack][0][1] # 本段C发起KeepAlive的第一个包的seq
if C_seq+1 in D_TCP['S_TCP_Keep_Alive'] and D_TCP['S_TCP_Keep_Alive'][C_seq+1][0][0] < C_time: # S比C早发起保持连接，忽略C，按S的算（防止后面处理S发起KeepAlive时重复计算）
Log.debug(f" 忽略{D_TCP['C_TCP_Keep_Alive'][Ack][0]}")
else:
Log.debug(f" 确认{D_TCP['C_TCP_Keep_Alive'][Ack][0]}")
## 根据 KeepAlive 前后的数据包判断 KeepAlive 是谁的原因造成的
## 往前找开始KeepAlive的包（比KeepAlive包提前一个才是真实开始等待的时间）
if C_seq+1 in D_TCP['D_S_ACK_DATA'] and C_time>=D_TCP['D_S_ACK_DATA'][C_seq+1][-1][0]: # 客户端发KeepAlive，客户端seq+1会是服务端发数据Ack，所以在D_TCP['D_S_ACK_DATA']中找
Log.debug(f" （始）前包服务器响应数据，归客户端原因 ACK(C_seq+1)={C_seq+1} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][C_seq+1]}")
选择开始保持连接的数据包 = D_TCP['D_S_ACK_DATA'][C_seq+1][-1] # 开始部分要找最后一个数据包
归属标识 = 'C'
elif Ack in D_TCP['D_C_ACK_DATA'] and C_time>=D_TCP['D_C_ACK_DATA'][Ack][-1][0]: # 客户端发KeepAlive，但是客户端发数据在等待服务端，所以在D_TCP['D_C_ACK_DATA']中找，ACK相同
Log.debug(f" （始）前包客户端响应数据，归服务端原因ACK={Ack} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][Ack]}")
选择开始保持连接的数据包 = D_TCP['D_C_ACK_DATA'][Ack][-1] # 开始部分要找最后一个数据包
归属标识 = 'S'
else:
if D_TCP['C_TCP_Keep_Alive'][Ack][0][5] == D_TCP['L_DATA'][0][0]: # 在会话抓到的开头的包就是KeepAlive(第一个包的第一个编号判断)
## 往后找
Log.debug(f" 开头的包就是KeepAlive（C发起），根据KeepAlive结束后是C发请求还是S响应数据来判断是谁的原因造成本次KeepAlive")
if Ack in D_TCP['D_C_ACK_DATA'] and C_time <= D_TCP['D_C_ACK_DATA'][Ack][0][0]:
Log.debug(f" （始）后包客户端请求数据，归客户端原因 ACK={Ack} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][Ack]} 本身为开始计时包{D_TCP['C_TCP_Keep_Alive'][Ack]}")
归属标识 = 'C'
elif C_seq+1 in D_TCP['D_S_ACK_DATA'] and C_time <= D_TCP['D_S_ACK_DATA'][C_seq+1][0][0]:
Log.debug(f" （始）后包服务器响应数据，归服务端原因 ACK(C_seq+1)={C_seq+1} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][C_seq+1]} 本身为开始计时包{D_TCP['C_TCP_Keep_Alive'][Ack]}")
归属标识 = 'S'
else:
Log.debug(f" 判断不出KeepAlive是哪方原因造成的")
continue
选择开始保持连接的数据包 = D_TCP['C_TCP_Keep_Alive'][Ack][0]
else:
Log.debug(f" 不在D_S_ACK_DATA及D_C_ACK_DATA中，有问题")
continue
等待开始时间 = 选择开始保持连接的数据包[0]
## 找结束KeepAlive，开始发有效数据的第一个包（比KeepAlive包晚一个才是真实结束等待的时间）
if Ack in D_TCP['D_C_ACK_DATA'] and C_time<=D_TCP['D_C_ACK_DATA'][Ack][0][0]:
Log.debug(f" （终）ACK={Ack} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][Ack]}")
选择标识结束保持连接的数据包 = D_TCP['D_C_ACK_DATA'][Ack][0]
elif C_seq+1 in D_TCP['D_S_ACK_DATA'] and C_time<=D_TCP['D_S_ACK_DATA'][C_seq+1][0][0]:
Log.debug(f" （终）ACK(C_seq+1)={C_seq+1} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][C_seq+1]}")
选择标识结束保持连接的数据包 = D_TCP['D_S_ACK_DATA'][C_seq+1][0]
else:
## 有可能等待最后都没有后续数据，找最后一个保持连接的包
Log.debug(" （W）找不到后续数据包")
X1 = D_TCP['C_TCP_Keep_Alive'][Ack][-1]
if C_seq+1 in D_TCP['S_TCP_Keep_Alive']:
X2 = D_TCP['S_TCP_Keep_Alive'][C_seq+1][-1]
if X1[0] > X2[0]:
选择标识结束保持连接的数据包 = X1
else:
选择标识结束保持连接的数据包 = X2
else:
选择标识结束保持连接的数据包 = X1
Log.debug(f" （终）选择标识结束保持连接的数据包={选择标识结束保持连接的数据包}")
等待结束时间 = 选择标识结束保持连接的数据包[0]
Log.debug(f" {选择开始保持连接的数据包} <-{归属标识} KeepAlive 时间区间-> {选择标识结束保持连接的数据包}")
if 归属标识 == 'C':
L_C_KeepAlive_RANGE.append((等待开始时间, 等待结束时间))
elif 归属标识 == 'S':
L_S_KeepAlive_RANGE.append((等待开始时间, 等待结束时间))
else:
pass
#Log.debug("")
## 再分析S首先发起KeepAlive的情况
Log.debug(f" 遍历 D_TCP['S_TCP_Keep_Alive']")
for Ack in D_TCP['S_TCP_Keep_Alive']: # 每个服务端发起每段保持连接信息（相同Ack是同一KeepAlive区间）
Log.debug(f" {Ack}:{D_TCP['S_TCP_Keep_Alive'][Ack]}")
归属标识 = '' # 需要判断是客户端还是服务器原因造成的KeepAlive
C_time = D_TCP['S_TCP_Keep_Alive'][Ack][0][0] # 本段S发起KeepAlive的第一个包的时间戳
C_seq = D_TCP['S_TCP_Keep_Alive'][Ack][0][1] # 本段S发起KeepAlive的第一个包的seq
if C_seq+1 in D_TCP['C_TCP_Keep_Alive'] and D_TCP['C_TCP_Keep_Alive'][C_seq+1][0][0] < C_time: # C比S早发起保持连接，忽略S，按C的算（前面已经处理防止重复计算）
Log.debug(f" 忽略{D_TCP['S_TCP_Keep_Alive'][Ack][0]}")
else:
Log.debug(f" 确认{D_TCP['S_TCP_Keep_Alive'][Ack][0]}")
## 根据 KeepAlive 前后的数据包判断 KeepAlive 是谁的原因造成的
## 往前找开始KeepAlive的包（比KeepAlive包提前一个才是真实开始等待的时间）
if C_seq+1 in D_TCP['D_C_ACK_DATA'] and C_time>=D_TCP['D_C_ACK_DATA'][C_seq+1][-1][0]: # 客户端发KeepAlive，客户端seq+1会是服务端发数据Ack，所以在D_TCP['D_C_ACK_DATA']中找
Log.debug(f" （始）前包客户端请求数据，归服务端原因 ACK(C_seq+1)={C_seq+1} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][C_seq+1]}")
选择开始保持连接的数据包 = D_TCP['D_C_ACK_DATA'][C_seq+1][-1]
归属标识 = 'S'
elif Ack in D_TCP['D_S_ACK_DATA'] and C_time>=D_TCP['D_S_ACK_DATA'][Ack][-1][0]: # 客户端发KeepAlive，但是客户端发数据在等待服务端，所以在D_TCP['D_S_ACK_DATA']中找，ACK相同
Log.debug(f" （始）前包服务端响应数据，归客户端原因ACK={Ack} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][Ack]}")
选择开始保持连接的数据包 = D_TCP['D_S_ACK_DATA'][Ack][-1]
归属标识 = 'C'
else:
if D_TCP['S_TCP_Keep_Alive'][Ack][0][5] == D_TCP['L_DATA'][0][0]: # 在会话抓到的开头的包就是KeepAlive(第一个包的第一个编号判断)
Log.debug(f" 开头的包就是KeepAlive（S发起），根据KeepAlive结束后是C发请求还是S响应数据来判断是谁的原因造成本次KeepAlive")
## 往后找
if C_seq+1 in D_TCP['D_C_ACK_DATA'] and C_time <= D_TCP['D_C_ACK_DATA'][C_seq+1][0][0]: # C请求
Log.debug(f" （始）后包客户端请求数据，归客户端原因 ACK={Ack} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][Ack]} 本身为开始计时包{D_TCP['S_TCP_Keep_Alive'][Ack]}")
归属标识 = 'C'
elif Ack in D_TCP['D_S_ACK_DATA'] and C_time <= D_TCP['D_S_ACK_DATA'][Ack][0][0]: # S响应
Log.debug(f" （始）后包服务器响应数据，归服务端原因 ACK(C_seq+1)={C_seq+1} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][C_seq+1]} 本身为开始计时包{D_TCP['C_TCP_Keep_Alive'][Ack]}")
归属标识 = 'S'
else:
Log.debug(f" 判断不出KeepAlive是哪方原因造成的")
continue
选择开始保持连接的数据包 = D_TCP['S_TCP_Keep_Alive'][Ack][0]
else:
Log.error(f" 不在D_C_ACK_DATA及D_S_ACK_DATA中，有问题")
continue
等待开始时间 = 选择开始保持连接的数据包[0]
## 找结束KeepAlive，开始发有效数据的第一个包（比KeepAlive包晚一个才是真实结束等待的时间）
if Ack in D_TCP['D_S_ACK_DATA'] and C_time<=D_TCP['D_S_ACK_DATA'][Ack][0][0]:
Log.debug(f" （终）ACK={Ack} in D_TCP['D_S_ACK_DATA']={D_TCP['D_S_ACK_DATA'][Ack]}")
选择标识结束保持连接的数据包 = D_TCP['D_S_ACK_DATA'][Ack][0]
elif C_seq+1 in D_TCP['D_C_ACK_DATA'] and C_time<=D_TCP['D_C_ACK_DATA'][C_seq+1][0][0]:
Log.debug(f" （终）ACK(C_seq+1)={C_seq+1} in D_TCP['D_C_ACK_DATA']={D_TCP['D_C_ACK_DATA'][C_seq+1]}")
选择标识结束保持连接的数据包 = D_TCP['D_C_ACK_DATA'][C_seq+1][0]
else:
## 有可能等待最后都没有后续数据，找最后一个保持连接的包
Log.debug(" （W）找不到后续数据包")
X1 = D_TCP['S_TCP_Keep_Alive'][Ack][-1]
if C_seq+1 in D_TCP['C_TCP_Keep_Alive']:
X2 = D_TCP['C_TCP_Keep_Alive'][C_seq+1][-1]
if X1[0] > X2[0]:
选择标识结束保持连接的数据包 = X1
else:
选择标识结束保持连接的数据包 = X2
else:
选择标识结束保持连接的数据包 = X1
Log.debug(f" （终）选择标识结束保持连接的数据包={选择标识结束保持连接的数据包}")
等待结束时间 = 选择标识结束保持连接的数据包[0]
Log.debug(f" {选择开始保持连接的数据包} <-{归属标识} KeepAlive 时间区间-> {选择标识结束保持连接的数据包}")
if 归属标识 == 'C':
L_C_KeepAlive_RANGE.append((等待开始时间, 等待结束时间))
elif 归属标识 == 'S':
L_S_KeepAlive_RANGE.append((等待开始时间, 等待结束时间))
else:
pass
#Log.debug("")
return(L_C_KeepAlive_RANGE, L_S_KeepAlive_RANGE)
## 客户端响应ACK消息和下次客户端发送请求的时间间隔（这两个seq和ack相同的情况是没有Keep-Alive的，可区分）
def 客户端发起请求间隔耗时(D_TCP):
'''
28 1625539397.99094 192.168.100.252 192.168.100.13 9577 1433 3622347657 1299493386 ACK PSH 45 C_req 256 0x5e0
29 1625539397.991202 192.168.100.13 192.168.100.252 1433 9577 1299493386 3622347702 ACK PSH 26 S_ack 260 0xe40
30 1625539398.031743 192.168.100.252 192.168.100.13 9577 1433 3622347702 1299493412 ACK 0 256 0x6ddb 上次交互完成（响应以接完S数据包）
31 1625539414.326215 192.168.100.252 192.168.100.13 9577 1433 3622347702 1299493412 ACK PSH 275 C_req 256 0x3438 下次交互开始
32 1625539414.326322 192.168.100.13 192.168.100.252 1433 9577 1299493412 3622347977 ACK PSH 68 S_ack 258 0x4780
'''
L_TIME_Client_WAIT = [] # 客户端发起请求间隔耗时的每段时间戳
for ACK in D_TCP['D_C_ACK']: # 遍历C响应收到S数据的包（先响应后发数据，说明本地数据处理要时间或等待用户输入指令等）
if ACK not in D_TCP['C_TCP_Keep_Alive']: # 不是 Keep-Alive 的情况才计算相邻两次请求的间隔时间
TIME1, Seq1, Ack1, A1, B1 = D_TCP['D_C_ACK'][ACK][0] # 客户端响应服务器对上次请求收到服务器的响应【多个包只取第一个】
if Ack1 in D_TCP['D_C_ACK_DATA']: # 找到紧接着的下一次请求
for j in D_TCP['D_C_ACK_DATA'][Ack1]:
TIME2, Seq2, Ack2, A2, B2, C2 = j
if Seq1 == Seq2 and Ack1 == Ack2:
#Log.debug(f"[TIME]= {TIME2-TIME1} 下次交互开始={j} - 上次交互完成={D_TCP['D_C_ACK'][ACK][0]}")
L_TIME_Client_WAIT.append((TIME1, TIME2))
break
# else:
# Log.debug("找不到下次请求信息，Ack1 不在 D_TCP['D_C_ACK_DATA'] 中")
#else:
# Log.debug(f"D_TCP['D_C_ACK'][ACK] 有保持连接记录，忽略计算 {D_TCP['D_C_ACK'][ACK]}")
#Log.debug('')
return(L_TIME_Client_WAIT)
## 从TCP会话字典信息D_TCP中统计分析 接收窗口大小=0 造成的时间消耗（分服务端原因造成的和客户端原因造成的情况）
## 返回 L_C_WIN_0_RANGE 客户端接收窗口满时间段列表 [(TimeStart, TimeEnd),]
## 返回 L_S_WIN_0_RANGE 服务端接收窗口满时间段列表 [(TimeStart, TimeEnd),]
def 分析接收窗口满耗时(D_TCP):
#print("D_TCP['D_C_WIN_0']", D_TCP['D_C_WIN_0'])
#print("D_TCP['D_S_WIN_0']", D_TCP['D_S_WIN_0'])
L_C_WIN_0_RANGE = []
L_S_WIN_0_RANGE = []
for K in D_TCP['D_C_WIN_0']:
TimeStart = D_TCP['D_C_WIN_0'][K][0][0]
if K in D_TCP['D_C_ACK']:
TimeEnd = D_TCP['D_C_ACK'][K][-1][0]
else:
TimeEnd = D_TCP['D_C_WIN_0'][K][-1][0]
L_C_WIN_0_RANGE.append((TimeStart, TimeEnd))
for K in D_TCP['D_S_WIN_0']:
TimeStart = D_TCP['D_S_WIN_0'][K][0][0]
if K in D_TCP['D_S_ACK']:
TimeEnd = D_TCP['D_S_ACK'][K][-1][0]
else:
TimeEnd = D_TCP['D_S_WIN_0'][K][-1][0]
L_S_WIN_0_RANGE.append((TimeStart, TimeEnd))
return(L_C_WIN_0_RANGE, L_S_WIN_0_RANGE)
## 画图，TCP会话交互中各种用时信息画成图（开始时间结束时间、保持连接时间和客户端请求间隔等待时间等）
def TCP会话用时信息画图(TCP_START_TIME_MIN, TCP_END_TIME_MAX, D_C_KeepAlive, D_C_WAIT, D_S_KeepAlive, D_C_WIN_0_TIME, D_S_WIN_0_TIME):
开始时间点 = int(TCP_START_TIME_MIN)
结束时间点 = int(TCP_END_TIME_MAX)
X = [i for i in range(开始时间点, 结束时间点+1)]
X_TEXT = [time.strftime('%H:%M:%S', time.localtime(i)) for i in range(开始时间点, 结束时间点+1)]
#print(f"X轴时间戳 X[0]={X[0]} X[-1]={X[-1]}")
#print(X_TEXT)
D_Y = {}
#print("D_C_KeepAlive", D_C_KeepAlive)
for K in D_C_KeepAlive:
L_S_KeepAlive_RANGE = D_S_KeepAlive[K] # 提取这个key下的KeepAlive时间区间列表
P_S_KeepAlive_TIME = set() # 把所有时间按秒生成集合，方便匹配查找
for TIMEs in L_S_KeepAlive_RANGE: # 遍历每一个KeepAlive时间区间
t1 = TIMEs[0] # 开始时间
t2 = TIMEs[1] # 结束时间
L = [i for i in range(int(t1), int(t2))] # 以秒为单位生成时间区间列表
LP = set(L) # 时间区间列表 转 时间区间集合
P_S_KeepAlive_TIME = P_S_KeepAlive_TIME | LP # 并集
L_C_KeepAlive_RANGE = D_C_KeepAlive[K]
P_C_KeepAlive_TIME = set()
for TIMEs in L_C_KeepAlive_RANGE:
L = [i for i in range(int(TIMEs[0]), int(TIMEs[1]))]
P_C_KeepAlive_TIME = P_C_KeepAlive_TIME | set(L)
L_TIME_Client_WAIT = D_C_WAIT[K]
P_C_WAIT_TIME = set()
for TIMEs in L_TIME_Client_WAIT:
L = [i for i in range(int(TIMEs[0]), int(TIMEs[1]))]
P_C_WAIT_TIME = P_C_WAIT_TIME | set(L)
L_C_WIN_0_RANGE = D_C_WIN_0_TIME[K]
P_C_WIN_0_TIME = set()
for TIMEs in L_C_WIN_0_RANGE:
L = [i for i in range(int(TIMEs[0]), int(TIMEs[1]))]
P_C_WIN_0_TIME = P_C_WIN_0_TIME | set(L)
L_S_WIN_0_RANGE = D_S_WIN_0_TIME[K]
P_S_WIN_0_TIME = set()
for TIMEs in L_S_WIN_0_RANGE:
L = [i for i in range(int(TIMEs[0]), int(TIMEs[1]))]
P_S_WIN_0_TIME = P_S_WIN_0_TIME | set(L)
Y = [] # 为每个Key对应的交互生成各自Y值
## ax.set_yticklabels(['-2','Start/End(-1)','RUN(0)','Client-Wait(1)','(C)Keep-Alive(2)','(S)Keep-Alive(3)','(C)windows=0(4)','(S)windows=0(5)']) # 自定义Y轴刻度
for i in X: # 遍历整个时间区间（所有交互统一的时间区间）
if i < 开始时间点 or i > 结束时间点:
Y.append(-2) # 超出开始和结束时间
elif i in (开始时间点, 结束时间点):
Y.append(-1) # 标记开始和结束时间
elif i in P_C_KeepAlive_TIME:
Y.append(2) # C发起保持连接造成的等待
elif i in P_S_KeepAlive_TIME:
Y.append(3) # S发起保持连接造成的等待
elif i in P_C_WAIT_TIME:
Y.append(1) # 等待客户端发包造成的等待
elif i in P_C_WIN_0_TIME:
Y.append(4) # 客户端接收窗口满造成的等待
elif i in P_S_WIN_0_TIME:
Y.append(5) # 服务端接收窗口满造成的等待
else:
Y.append(0) # 正在运行的时间
#Log.debug(f"RUN {i}")
D_Y[K] = Y
## 分成多个图显示（通用、可控）
X轴刻度数量 = 10 # X轴只显示10个刻度
X轴间隔 = len(X)//X轴刻度数量
if X轴间隔 == 0: # 按秒合并的时间刻度，可能会少于10个
X轴间隔 = 1 # 显示每一个刻度
图数量 = len(D_Y)
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker # 解决时间为X轴可能会造成刻度太密集，看不清问题
if 图数量 == 1:
L_KEY = [KEY for KEY in D_Y]
fig, ax = plt.subplots(1,1)
ax.xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔)) # X轴间隔刻度
ax.yaxis.set_major_locator(ticker.MultipleLocator(1)) # 强制Y轴每个刻度都显示
ax.plot(X_TEXT, D_Y[L_KEY[0]], '.', label=L_KEY[0], markersize=2)
ax.set_yticklabels(['-2','Start/End(-1)','RUN(0)','Client-Wait(1)','(C)Keep-Alive(2)','(S)Keep-Alive(3)','(C)windows=0(4)','(S)windows=0(5)']) # 自定义Y轴刻度
ax.legend() # 显示图例label
plt.ylim(-1.5,5.5) # 控制y轴显示范围，隐藏-1值
#plt.grid() # 使用网格，方便查看XY对应
plt.xlabel('Time') # X轴标注
#plt.title('TITLE') # 标题
plt.show()
else:
fig, ax = plt.subplots(图数量, 1, sharex=True, sharey=True, figsize=(20,10)) # n行1列，统一X和Y轴刻度
plt.ylim(-1.5,3.5) # 控制y轴显示范围，隐藏-1值
AX_List = ax.ravel() # 子图列表：AX_List[0]第一个子图，AX_List[1]第二个子图...
L_KEY = [KEY for KEY in D_Y]
for n in range(0, 图数量):
AX_List[n].plot(X_TEXT,D_Y[L_KEY[n]], '.', label=L_KEY[n], markersize=2) # 第1个图的第1根线
AX_List[n].legend() # 显示图例label
AX_List[n].set_yticklabels(['-2','Start/End(-1)','RUN(0)','Client-Wait(1)','(C)Keep-Alive(2)','(S)Keep-Alive(3)','(C)windows=0(4)','(S)windows=0(5)']) # 自定义Y轴刻度
AX_List[n].xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔)) # X轴间隔N标一个刻度
AX_List[n].yaxis.set_major_locator(ticker.MultipleLocator(1)) # 强制Y轴每个刻度都显示
plt.show()
## 记录日志
def SHOW_TIME_WAIT(C_发起开始时间, C_发起结束时间, L_TIME_Client_WAIT, L_C_KeepAlive_RANGE, L_S_KeepAlive_RANGE, L_C_WIN_0_RANGE, L_S_WIN_0_RANGE, D_TCP):
会话总用时 = C_发起结束时间 - C_发起开始时间
开始时间 = time.strftime('%H:%M:%S', time.localtime(C_发起开始时间))
结束时间 = time.strftime('%H:%M:%S', time.localtime(C_发起结束时间))
源地址, 源端口 = D_TCP['CLIENT']
目的地址, 目的端口 = D_TCP['SERVER']
## 时间合计
C_KeepAlive时间合计 = sum([i[1]-i[0] for i in L_C_KeepAlive_RANGE])
C_KeepAlive间隔明细 = [(time.strftime('%H:%M:%S', time.localtime(i[0])), time.strftime('%H:%M:%S', time.localtime(i[1]))) for i in L_C_KeepAlive_RANGE]
S_KeepAlive时间合计 = sum([i[1]-i[0] for i in L_S_KeepAlive_RANGE])
S_KeepAlive间隔明细 = [(time.strftime('%H:%M:%S', time.localtime(i[0])), time.strftime('%H:%M:%S', time.localtime(i[1]))) for i in L_S_KeepAlive_RANGE]
C间隔发包时间合计 = sum([i[1]-i[0] for i in L_TIME_Client_WAIT])
C接收窗口满耗时合计 = sum([i[1]-i[0] for i in L_C_WIN_0_RANGE])
C接收窗口满耗时明细 = [(time.strftime('%H:%M:%S', time.localtime(i[0])), time.strftime('%H:%M:%S', time.localtime(i[1]))) for i in L_C_WIN_0_RANGE]
S接收窗口满耗时合计 = sum([i[1]-i[0] for i in L_S_WIN_0_RANGE])
S接收窗口满耗时明细 = [(time.strftime('%H:%M:%S', time.localtime(i[0])), time.strftime('%H:%M:%S', time.localtime(i[1]))) for i in L_S_WIN_0_RANGE]
程序正常交互用时合计 = 会话总用时 - C_KeepAlive时间合计 - S_KeepAlive时间合计 - C间隔发包时间合计 - C接收窗口满耗时合计 - S接收窗口满耗时合计
T_DATA = (源地址, 源端口, 目的地址, 目的端口, 开始时间, 结束时间, round(会话总用时,2), round(C_KeepAlive时间合计,2), round(S_KeepAlive时间合计,2), round(C间隔发包时间合计,2), round(C接收窗口满耗时合计,2), round(S接收窗口满耗时合计,2), round(程序正常交互用时合计,2))
Log.info("%-15s %-5s <--> %-15s %-5s %8s %8s %10s %10s %9s %13s %13s %13s %9s" % T_DATA)
Log.debug(f" C_KeepAlive间隔明细={C_KeepAlive间隔明细}")
Log.debug(f" S_KeepAlive间隔明细={S_KeepAlive间隔明细}")
Log.debug(f" C接收窗口满耗时明细={C接收窗口满耗时明细}")
Log.debug(f" S接收窗口满耗时明细={S接收窗口满耗时明细}")
Log.debug(f" C_发包间隔明细")
for i in L_TIME_Client_WAIT:
TIME1,TIME2 = i
#if TIME2-TIME1 > 0.5: # 间隔大于0.5秒的才记录明细，太短没有显示必要
Log.debug(f" {i}={time.strftime('%H:%M:%S', time.localtime(TIME1))} -> {time.strftime('%H:%M:%S', time.localtime(TIME2))} 时间间隔={round(TIME2-TIME1, 6)}秒")
return(T_DATA)
## 统计整个会话中收发数据情况
def 统计整个会话中收发数据情况(D_TCP):
C_Tx_DATA_ALL = D_TCP['C_Tx_DATA_ALL']
S_Tx_DATA_ALL = D_TCP['S_Tx_DATA_ALL']
try:
C_FIN_SEQ = D_TCP['C_ACK_FIN'][1]
except:
Log.debug('无C_FIN_SEQ')
Log.debug(f"C_Tx_DATA_ALL={C_Tx_DATA_ALL}")
Log.debug(f"S_Tx_DATA_ALL={S_Tx_DATA_ALL}")
else:
if C_Tx_DATA_ALL == C_FIN_SEQ:
Log.debug(f"C_Tx_DATA_ALL={C_Tx_DATA_ALL} 正常")
else:
Log.debug(f"C_Tx_DATA_ALL={C_Tx_DATA_ALL} 异常")
for K in D_TCP['S_ACK_FIN_SeqKey']:
S_FIN_SEQ = D_TCP['S_ACK_FIN_SeqKey'][K][0][1]
if S_Tx_DATA_ALL == S_FIN_SEQ:
Log.debug(f"S_Tx_DATA_ALL={S_Tx_DATA_ALL} 正常")
else:
Log.debug(f"S_Tx_DATA_ALL={S_Tx_DATA_ALL} 异常")
Log.debug('')
## 返回 D_TIME_TCP_SESSION_PACKET 字典：Key=时间戳(精确到秒)，Value=这一秒内包数据和大小统计信息
def 提取PCAP中指定TCP会话双向流量信息(PCAP_File_OR_Dir, SIP, SPORT, DIP, DPORT):
#print((PCAP_File_OR_Dir, SaveDir, 匹配内容, UserIP, UserPort))
## 统计数据包信息的字典
D_TIME_TCP_SESSION_PACKET = {} # {时间戳:{(SIP,SPORT,DIP,DPORT):{'TCP_Packets':0, 'TCP_Bytes':0}, (DIP,DPORT,SIP,SPORT):{'TCP_Packets':0, 'TCP_Bytes':0}}}
## 开始处理单个或多个PCAP文件
E = 0
if os.path.isfile(PCAP_File_OR_Dir):
PATH,FileName = os.path.split(PCAP_File_OR_Dir) # 拆分路径和文件名
#print(PATH,FileName)
PCAP_File_OR_Dir = PATH # 这个后面但目录用
L_FileName = ['\\'+FileName] # 文件名
elif os.path.isdir(PCAP_File_OR_Dir):
L_FileName = [i for i in os.listdir(PCAP_File_OR_Dir) if os.path.isfile(PCAP_File_OR_Dir+i)] # 目录内内容列表(只取文件)
else:
print(f"{PCAP_File_OR_Dir} 不存在")
E = 1
if E == 0:
文件数量 = len(L_FileName)
TCP会话数量 = 0
计数 = 1
for F in L_FileName:
FullFileName = PCAP_File_OR_Dir+str(F)
print(f"拆分PCAP文件：{FullFileName} 进度：{计数}/{文件数量}") ## 根据源目的IP和端口分成多个小pcap文件
f = open(FullFileName, 'rb') # 以二进制方式读取pcap格式文件
PCAP_DATA = f.read(24) # 读取前24字节头信息，忽略
计数 += 1
N = 0
while 1:
包头 = f.read(16)
if not 包头: # 判断 包头 是否为空（读完或者本身为空时 S 为空）
break
N += 1
#if N == 14:
# break
#print("N", N)
PacketHeader = struct.unpack('IIII', 包头)
时间戳 = PacketHeader[0]
#微秒 = PacketHeader[1]
#抓取数据包长度 = PacketHeader[2] # 所抓获的数据包保存在pcap文件中的实际长度，以字节为单位。
实际数据包长度 = PacketHeader[3] # 所抓获的数据包的真实长度，如果文件中保存不是完整的数据包，那么这个值可能要比前面的数据包长度的值大。
PacketData = f.read(实际数据包长度)
# 以太部首
FrameType = PacketData[12:14] # 帧类型
# IP数据报头
if FrameType == b'\x08\x00': # 普通包
pass
elif FrameType == b'\x81\x00': # VLAN包
PacketData = PacketData[0:12] + b'\x08\x00' + PacketData[18:] ## 剔除VLAN数据
包头 = struct.pack('IIII', PacketHeader[0], PacketHeader[1], PacketHeader[2]-4, PacketHeader[3]-4) ## 修改包头
else:
#print("其他包忽略")
pass
## SrcIP SrcPort 和 DstIP DstPort 互换位置是同个TCP交互，要存入同个对象
IP_Protocol = PacketData[23:24]
## 只要TCP协议
if IP_Protocol == b'\x06': # 协议（TCP 6）（UDP 17）
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort_Bytes = PacketData[34:36]
DstPort_Bytes = PacketData[36:38]
SrcPort = struct.unpack('>H', SrcPort_Bytes)[0]
DstPort = struct.unpack('>H', DstPort_Bytes)[0]
## 每一次TCP发数据生成2个Key
TCP_KEY_SD = (SrcIP,SrcPort,DstIP,DstPort) # 以当前包的源到目的生成一个Key
#TCP_KEY_DS = (DstIP,DstPort,SrcIP,SrcPort) # 以当前包的目的到源生成一个Key
## 只有分离出指定的IP的交互内容
if SrcIP == SIP and SrcPort == SPORT:
SAVE = 1
elif DstIP == SIP and DstPort == SPORT:
SAVE = 1
else:
SAVE = 0
## 匹配到是需要分析的数据包
if SAVE == 1:
if 时间戳 in D_TIME_TCP_SESSION_PACKET: ## 全部流量统计
D_TIME_TCP_SESSION_PACKET[时间戳][TCP_KEY_SD]['Packets_Count'] += 1 ## 全部流量统计：全部数据包数量累计加1
D_TIME_TCP_SESSION_PACKET[时间戳][TCP_KEY_SD]['Packets_Bytes'] += 实际数据包长度 ## 全部流量统计：全部数据包大小累计
else:
D_TIME_TCP_SESSION_PACKET[时间戳] = {TCP_KEY_SD:{'Packets_Count': 1, 'Packets_Bytes':实际数据包长度}}
f.close()
print(f"【Done {time.strftime('%Y-%m-%d %H:%M:%S')}】")
else:
print("有错误终止操作")
return(D_TIME_TCP_SESSION_PACKET)
## 返回 D_TCP_ALL 字典：Key=(源IP,源端口,目的IP,目的端口)，Value=TCP信息字典
## 返回 D_UDP_ALL 字典：Key=(源IP,源端口,目的IP,目的端口)，Value=()
## 返回 D_TIME_PACKET 字典：Key=时间戳(精确到秒)，Value=这一秒内包数据和大小统计信息
## 返回 D_TCP_PACKET 字典：Key=TCP数据流方向，Value=这个方向上的数据包统计信息
def 提取PCAP中指定TCP会话数据(PCAP_File_OR_Dir, SaveDir, 匹配内容, UserIP, UserPort):
#print((PCAP_File_OR_Dir, SaveDir, 匹配内容, UserIP, UserPort))
## 每个会话解析为TCP会话信息字典
D_TCP_ALL = {}
## 存储每个UDP会话信息
D_UDP_ALL = {}
## 统计数据包信息的字典
D_TIME_PACKET = {} # {时间戳:{'Packets_Count':0, 'Packets_Bytes':0, 'TCP_Count':0, 'TCP_Bytes':0, 'UDP_Count':0, 'UDP_Bytes':0, 'OTHER_Count':0, 'OTHER_Bytes':0}}
D_TCP_PACKET = {} # {(源IP,源端口,目的IP,目的端口):{'Packets':包数量, 'Bytes_Len':网络传输字节数量, 'Time_End':最后一个包的时间戳}}
D_UDP_PACKET = {}
## 开始处理单个或多个PCAP文件
E = 0
if os.path.isfile(PCAP_File_OR_Dir):
PATH,FileName = os.path.split(PCAP_File_OR_Dir) # 拆分路径和文件名
#print(PATH,FileName)
PCAP_File_OR_Dir = PATH # 这个后面但目录用
L_FileName = ['\\'+FileName] # 文件名
elif os.path.isdir(PCAP_File_OR_Dir):
L_FileName = [i for i in os.listdir(PCAP_File_OR_Dir) if os.path.isfile(PCAP_File_OR_Dir+i)] # 目录内内容列表(只取文件)
if L_FileName == []:
E = 1
print(f"{PCAP_File_OR_Dir} 中没有发现文件")
else:
print(f"{PCAP_File_OR_Dir} 不存在")
E = 1
try:
if not os.path.isdir(SaveDir):
os.makedirs(SaveDir)
os.chdir(SaveDir) ## 切换到存放拆分后文件的目录
except Exception as e:
print(e)
E = 1
else:
pass
if E == 0:
文件数量 = len(L_FileName)
TCP会话数量 = 0
UDP会话数量 = 0
计数 = 1
for F in L_FileName:
FullFileName = PCAP_File_OR_Dir+str(F)
print(f" 拆分PCAP文件：{FullFileName} 进度：{计数}/{文件数量}") ## 根据源目的IP和端口分成多个小pcap文件
f = open(FullFileName, 'rb') # 以二进制方式读取pcap格式文件
PCAP_DATA = f.read(24) # 读取前24字节头信息，忽略
计数 += 1
N = 0
while 1:
包头 = f.read(16)
if not 包头: # 判断 包头 是否为空（读完或者本身为空时 S 为空）
break
N += 1
#if N == 14:
# break
#print("N", N)
PacketHeader = struct.unpack('IIII', 包头)
时间戳 = PacketHeader[0]
#微秒 = PacketHeader[1]
#抓取数据包长度 = PacketHeader[2] # 所抓获的数据包保存在pcap文件中的实际长度，以字节为单位。
实际数据包长度 = PacketHeader[3] # 所抓获的数据包的真实长度，如果文件中保存不是完整的数据包，那么这个值可能要比前面的数据包长度的值大。
PacketData = f.read(实际数据包长度)
## ==全部流量统计==
if 时间戳 in D_TIME_PACKET: ## 全部流量统计
D_TIME_PACKET[时间戳]['Packets_Count'] += 1 ## 全部流量统计：全部数据包数量累计加1
D_TIME_PACKET[时间戳]['Packets_Bytes'] += 实际数据包长度 ## 全部流量统计：全部数据包大小累计
else:
D_TIME_PACKET[时间戳] = {'Packets_Count': 1, 'Packets_Bytes':实际数据包长度, 'TCP_Count':0, 'TCP_Bytes':0, 'UDP_Count':0, 'UDP_Bytes':0, 'OTHER_Count':0, 'OTHER_Bytes':0, '筛选出的TCP包数量合计':0, '筛选出的TCP包大小合计':0}
## ==全部流量统计==
# 以太部首
FrameType = PacketData[12:14] # 帧类型
# IP数据报头
if FrameType == b'\x08\x00': # 普通包
pass
elif FrameType == b'\x81\x00': # VLAN包
PacketData = PacketData[0:12] + b'\x08\x00' + PacketData[18:] ## 剔除VLAN数据
包头 = struct.pack('IIII', PacketHeader[0], PacketHeader[1], PacketHeader[2]-4, PacketHeader[3]-4) ## 修改包头
else:
#print("其他包忽略")
pass
## SrcIP_SrcPort 和 DstIP_DstPort 互换位置是同个TCP交互，要存入同个文件对象
IP_Protocol = PacketData[23:24]
## 只要TCP协议
if IP_Protocol == b'\x06': # 协议（TCP 6）（UDP 17）
D_TIME_PACKET[时间戳]['TCP_Count'] += 1 ## 全部流量统计：TCP数据包数量累计加1
D_TIME_PACKET[时间戳]['TCP_Bytes'] += 实际数据包长度 ## 全部流量统计：TCP数据包大小累计
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort_Bytes = PacketData[34:36]
DstPort_Bytes = PacketData[36:38]
SrcPort = struct.unpack('>H', SrcPort_Bytes)[0]
DstPort = struct.unpack('>H', DstPort_Bytes)[0]
## 每一次TCP发数据生成2个Key
TCP_KEY_SD = (SrcIP,SrcPort,DstIP,DstPort) # 以当前包的源到目的生成一个Key
TCP_KEY_DS = (DstIP,DstPort,SrcIP,SrcPort) # 以当前包的目的到源生成一个Key
## 通过IP端口等匹配出需要的交互内容
if 匹配内容 == 'IP':
if UserIP in (SrcIP, DstIP):
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'PORT':
if UserPort in (SrcPort, DstPort):
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'IP+PORT':
if SrcIP == UserIP and SrcPort == UserPort:
SAVE = 1
elif DstIP == UserIP and DstPort == UserPort:
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'ALL':
SAVE = 1 # 全都要
else:
SAVE = 0 # 这个包不需要
## 匹配到是需要分析的数据包
if SAVE == 1:
## 筛选出的TCP流量统计
D_TIME_PACKET[时间戳]['筛选出的TCP包数量合计'] += 1 ## 筛选出的TCP流量统计：TCP数据包数量累计加1
D_TIME_PACKET[时间戳]['筛选出的TCP包大小合计'] += 实际数据包长度 ## 筛选出的TCP流量统计：TCP数据包大小累计
## TCP会话统计流量
if TCP_KEY_SD in D_TCP_PACKET: ## TCP会话统计流量
D_TCP_PACKET[TCP_KEY_SD]['Packets'] +=1 ## TCP会话统计流量：TCP会话数据包数量累计加1
D_TCP_PACKET[TCP_KEY_SD]['Bytes_Len'] += 实际数据包长度 ## TCP会话统计流量：TCP会话数据包大小累计
else:
D_TCP_PACKET[TCP_KEY_SD] = {'Packets':1, 'Bytes_Len':实际数据包长度}
## 对TCP交互数据包进行分析并保存到字典对象中
## 交互的两个方向会同时记录到字典key中，且两个方向Key对应的Value是同一个对象，只要匹配任意方向一次即可
if TCP_KEY_SD in D_TCP_ALL:
D_SAVE(D_TCP_ALL[TCP_KEY_SD], 包头, PacketData, N)
else:
Log.debug(f" 新建 D_TCP_ALL Key(SD)={TCP_KEY_SD} Key(DS)={TCP_KEY_DS} Value=D_TCP(同一个对象)")
TCP会话数量 += 1
## 两个方向对应同一个文件
D_TCP = {}
D_TCP['CLIENT'] = () ## (HOST, PORT) # 客户端IP和端口
D_TCP['SERVER'] = () ## (HOST, PORT) # 服务端IP和端口
D_TCP['C_SYN'] = () ## (时间戳, seq, ack), # 客户端发起连接
D_TCP['S_ACK_SYN'] = () ## (时间戳, seq, ack), # 服务端确认连接
D_TCP['C_ACK'] = () ## (时间戳, seq, ack), # 客户端确认连接
D_TCP['S_ACK_FIN_SeqKey'] = {} ## 服务端发起的终止信息，以Seq为KEY，因为Seq=对应请求的Ack
D_TCP['C_ACK_FIN'] = () ## C已经确认S接收完全部数据的信息
D_TCP['S_ACK_RST'] = {} ## 服务端强制断开TCP连接
D_TCP['C_ACK_RST_AckKey'] = {} ## 客户端强制断开TCP连接
D_TCP['C_ACK_RST_SeqKey'] = {} ## 客户端强制断开TCP连接
D_TCP['C_CLIENT_SEND_DATA'] = {} ## 客户端发起数据（用于判断重发的情况）以ACK为Key，是在响应S某部分交互的时候重复发，要以Ack为依据
D_TCP['TCP_CS_ERR'] = [] ## TCP校验失败的包编号
D_TCP['D_C_ACK'] = {} # C 发送的ACK信息（纯ACK确认消息，不含数据）
D_TCP['D_S_ACK'] = {} # S 发送的ACK信息（纯ACK确认消息，不含数据）
D_TCP['D_C_ACK_DATA'] = {} # C 发送的ACK及数据（一般都是客户端发起请求，包信息保存到 C_TCP_REQ 字典 Key=Ack Value=[(包信息1),(包信息2)] 一个请求可能会分成多个包发送）
D_TCP['D_S_ACK_DATA'] = {} # S 发送的ACK及数据（一般为服务端响应数据）
D_TCP['C_TCP_Keep_Alive'] = {} # C 发起的请求保持连接包
D_TCP['S_TCP_Keep_Alive'] = {} # S 发起的请求保持连接包
D_TCP['C_TCP_Keep_Alive_ACK'] = {} # C 响应请求保持连接包
D_TCP['S_TCP_Keep_Alive_ACK'] = {} # S 响应请求保持连接包
D_TCP['C_ACK_WIN_0'] = [] ## 记录C发的ACK且窗口为0的包信息(Seq,Ack)说明C缓存满，S会发ACK数据为1的包探测查看状态，S的(Seq,Ack)和C的刚好相反
D_TCP['S_ACK_WIN_0'] = [] ## 记录S发的ACK且窗口为0的包信息(Seq,Ack)说明S缓存满
D_TCP['D_C_WIN_0'] = {} # 记录C接收窗口满的信息，用于计算因C窗口满消耗的时间
D_TCP['D_S_WIN_0'] = {} # 记录S接收窗口满的信息，用于计算因S窗口满消耗的时间
D_TCP['C_Tx_DATA_ALL'] = 0 ## 在最后的时候更新到主字典里
D_TCP['S_Tx_DATA_ALL'] = 0 ## 在最后的时候更新到主字典里
D_TCP['P_C_Tx_Seq_Ack'] = set() # C发的含数据的ACK包的(Seq,Ack)信息集合，遇到重复说明是重发的包，在S处抓包这个就是 L_C_Rx_Info 接收到C发数据，重复说明重收，接不到对方丢的包的
D_TCP['P_S_Tx_Seq_Ack'] = set() # S发的含数据的ACK包的(Seq,Ack)信息集合，遇到重复说明是重发的包，在C处抓包这个就是 L_S_Rx_Info 接收到S发数据，重复说明重收，接不到对方丢的包的
D_TCP['L_DATA'] = []
D_TCP_ALL[TCP_KEY_SD] = D_TCP ### Key(方向1)对应新建的字典对象D_TCP
D_TCP_ALL[TCP_KEY_DS] = D_TCP ### Key(方向2)对应新建的字典对象D_TCP
D_SAVE(D_TCP_ALL[TCP_KEY_SD], 包头, PacketData, N)
elif IP_Protocol == b'\x11': ## 协议（TCP 6）（UDP 17）
D_TIME_PACKET[时间戳]['UDP_Count'] += 1 ## 全部流量统计：UDP数据包数量累计加1
D_TIME_PACKET[时间戳]['UDP_Bytes'] += 实际数据包长度 ## 全部流量统计：UDP数据包大小累计
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort_Bytes = PacketData[34:36]
DstPort_Bytes = PacketData[36:38]
SrcPort = struct.unpack('>H', SrcPort_Bytes)[0]
DstPort = struct.unpack('>H', DstPort_Bytes)[0]
## 每一次UDP发数据生成2个Key
UDP_KEY_SD = (SrcIP,SrcPort,DstIP,DstPort) # 以当前包的源到目的生成一个Key
UDP_KEY_DS = (DstIP,DstPort,SrcIP,SrcPort) # 以当前包的目的到源生成一个Key
## 只有分离出指定的IP的交互内容
if 匹配内容 == 'IP':
if UserIP in (SrcIP, DstIP):
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'PORT':
if UserPort in (SrcPort, DstPort):
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'IP+PORT':
if SrcIP == UserIP and SrcPort == UserPort:
SAVE = 1
elif DstIP == UserIP and DstPort == UserPort:
SAVE = 1
else:
SAVE = 0
elif 匹配内容 == 'ALL':
SAVE = 1 # 全都要
else:
SAVE = 0 # 这个包不需要
## 匹配到是需要分析的数据包
if SAVE == 1:
## UDP会话统计流量
if UDP_KEY_SD in D_UDP_PACKET: ## TCP会话统计流量
D_UDP_PACKET[UDP_KEY_SD]['Packets'] +=1 ## TCP会话统计流量：TCP会话数据包数量累计加1
D_UDP_PACKET[UDP_KEY_SD]['Bytes_Len'] += 实际数据包长度 ## TCP会话统计流量：TCP会话数据包大小累计
else:
D_UDP_PACKET[UDP_KEY_SD] = {'Packets':1, 'Bytes_Len':实际数据包长度}
## 对UDP交互数据包进行分析保存
if UDP_KEY_SD in D_UDP_ALL:
pass
else:
Log.debug(f" UDP {UDP_KEY_SD}")
UDP会话数量 += 1
## 两个方向对应同一个文件
D_UDP_ALL[UDP_KEY_SD] = () # 方向1
D_UDP_ALL[UDP_KEY_DS] = () # 方向2
else:
D_TIME_PACKET[时间戳]['OTHER_Count'] += 1 ## 全部流量统计：其它数据包数量累计加1
D_TIME_PACKET[时间戳]['OTHER_Bytes'] += 实际数据包长度 ## 全部流量统计：其它数据包大小累计
f.close()
print(f" 完成 {time.strftime('%Y-%m-%d %H:%M:%S')}")
#print(f" TCP会话数量: {TCP会话数量}")
#print(f" UDP会话数量: {UDP会话数量}")
else:
print("【ERROR】有错误终止操作")
return(D_TCP_ALL, D_TIME_PACKET, D_TCP_PACKET, D_UDP_ALL, D_UDP_PACKET)
## 去除重复内容的Key 返回 L_TCP_SESSION_KEY
def TCP会话Key去重(D_TCP_ALL):
L_TCP_SESSION_KEY = []
P = set()
for k in D_TCP_ALL:
if k in P:
pass
else:
L_TCP_SESSION_KEY.append(k)
P.add(k)
P.add((k[2],k[3],k[0],k[1]))
#L_DATA = D_TCP_ALL[k]['L_DATA']
return(L_TCP_SESSION_KEY)
## 去除重复内容的Key 返回 L_UDP_SESSION_KEY
def UDP会话Key去重(D_UDP_ALL):
L_UDP_SESSION_KEY = []
P = set()
for k in D_UDP_ALL:
if k in P:
pass
else:
L_UDP_SESSION_KEY.append(k)
P.add(k)
P.add((k[2],k[3],k[0],k[1]))
return(L_UDP_SESSION_KEY)
## 按时间戳存储数据包大小的字典转成画图可用的XY轴列表
def D_TIME_PACKET_2_XY(D_TIME_PACKET):
L_TIME_KEY = [i for i in D_TIME_PACKET] # 时间戳Key列表
Y_Packets_Count = []
Y_Packets_Bytes = []
Y_TCP_Count = []
Y_TCP_Bytes = []
Y_UDP_Count = []
Y_UDP_Bytes = []
Y_TCP刷选出部分_Count = []
Y_TCP刷选出部分_Bytes = []
for i in L_TIME_KEY:
if i in D_TIME_PACKET:
Y_Packets_Count.append(D_TIME_PACKET[i]['Packets_Count'])
Y_Packets_Bytes.append(D_TIME_PACKET[i]['Packets_Bytes'])
Y_TCP_Count.append(D_TIME_PACKET[i]['TCP_Count'])
Y_TCP_Bytes.append(D_TIME_PACKET[i]['TCP_Bytes'])
Y_UDP_Count.append(D_TIME_PACKET[i]['UDP_Count'])
Y_UDP_Bytes.append(D_TIME_PACKET[i]['UDP_Bytes'])
Y_TCP刷选出部分_Count.append(D_TIME_PACKET[i]['筛选出的TCP包数量合计'])
Y_TCP刷选出部分_Bytes.append(D_TIME_PACKET[i]['筛选出的TCP包大小合计'])
else:
Y_Packets_Count.append(0)
Y_Packets_Bytes.append(0)
Y_TCP_Count.append(0)
Y_TCP_Bytes.append(0)
Y_UDP_Count.append(0)
Y_UDP_Bytes.append(0)
Y_TCP刷选出部分_Count.append(0)
Y_TCP刷选出部分_Bytes.append(0)
return(L_TIME_KEY, Y_Packets_Count, Y_Packets_Bytes, Y_TCP_Count, Y_TCP_Bytes, Y_UDP_Count, Y_UDP_Bytes, Y_TCP刷选出部分_Count, Y_TCP刷选出部分_Bytes)
## 流量画图
def 画流量图(D_TIME_PACKET):
X, Y_Packets_Count, Y_Packets_Bytes, Y_TCP_Count, Y_TCP_Bytes, Y_UDP_Count, Y_UDP_Bytes, Y_TCP刷选出部分_Count, Y_TCP刷选出部分_Bytes = D_TIME_PACKET_2_XY(D_TIME_PACKET)
X_TEXT = [time.strftime('%H:%M:%S', time.localtime(i)) for i in X] # 文本时间
#print("X", X)
#print("X_TEXT", X_TEXT)
## 分成多个图显示（通用、可控）
X轴刻度数量 = 10 # X轴只显示10个刻度
X轴间隔 = len(X)//X轴刻度数量
if X轴间隔 == 0: # 按秒合并的时间刻度，可能会少于10个
X轴间隔 = 1 # 显示每一个刻度
Log.debug(f"原X轴刻度数={len(X)} 设置X轴间隔={X轴间隔}")
图数量 = 3
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker # 解决时间为X轴可能会造成刻度太密集，看不清问题
fig, ax = plt.subplots(图数量, 1, sharex=True, sharey=False, figsize=(20,10)) # n行1列，统一X轴刻度
AX_List = ax.ravel() # 子图列表：AX_List[0]第一个子图，AX_List[1]第二个子图...
## 子图1每秒总流量，用左边y轴
AX_List[0].plot(X_TEXT, Y_Packets_Count, '-', label='ALL Packets Count', markersize=2) # 第1个图的第1根线
AX_List[0].legend(loc=2) # 显示图例label(位置左上)
#AX_List[0].xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔)) # X轴间隔N标一个刻度
AX_List[0].set_ylabel('Packets')
## 子图1每秒包数量，用右边y轴
AX_0_Y2 = AX_List[0].twinx()
AX_0_Y2.plot(X_TEXT, Y_Packets_Bytes, ':r', label='ALL Packets Bytes', markersize=1) # 第1个图的第2根线
AX_0_Y2.legend(loc=1) # 显示图例label(位置右上)
#AX_0_Y2.xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔))
AX_0_Y2.set_ylabel('Bytes')
AX_0_Y2.get_yaxis().get_major_formatter().set_scientific(False) # y轴值不使用科学记数法
## 子图2 总TCP和UDP的包数量和流量情况
AX_List[1].plot(X_TEXT, Y_TCP_Count, ':', label='All TCP Count', markersize=2)
AX_List[1].plot(X_TEXT, Y_UDP_Count, '-', label='All UDP Count', markersize=1)
AX_List[1].legend(loc=2)
#AX_List[1].xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔))
AX_List[1].set_ylabel('Packets')
AX_1_Y2 = AX_List[1].twinx()
AX_1_Y2.plot(X_TEXT, Y_TCP_Bytes, ':', label='ALL TCP Bytes', markersize=2)
AX_1_Y2.plot(X_TEXT, Y_UDP_Bytes, '-', label='ALL UDP Bytes', markersize=1)
AX_1_Y2.legend(loc=1)
AX_1_Y2.set_ylabel('Bytes')
AX_1_Y2.xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔))
AX_1_Y2.get_yaxis().get_major_formatter().set_scientific(False)
## 子图3 筛选出的TCP会话的流量图
## 子图3每秒总流量，用左边y轴
AX_List[2].plot(X_TEXT, Y_TCP刷选出部分_Count, '-', label='SELECT TCP Packets Count', markersize=2)
AX_List[2].legend(loc=2)
AX_List[2].xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔))
AX_List[2].set_ylabel('Packets')
## 子图3每秒包数量，用右边y轴
AX_2_Y2 = AX_List[2].twinx()
AX_2_Y2.plot(X_TEXT, Y_TCP刷选出部分_Bytes, ':r', label='SELECT TCP Packets Bytes', markersize=1)
AX_2_Y2.legend(loc=1)
AX_2_Y2.xaxis.set_major_locator(ticker.MultipleLocator(X轴间隔))
AX_2_Y2.set_ylabel('Bytes')
AX_2_Y2.get_yaxis().get_major_formatter().set_scientific(False)
plt.xlabel('Time')
plt.show()
def 合并会话(D_TCP_PACKET):
D_TCP_SESSION = {}
for Key in D_TCP_PACKET:
if Key in D_TCP_SESSION:
print("重复")
else:
SrcIP, SrcPort, DstIP, DstPort = Key
Key_New = (DstIP, DstPort, SrcIP, SrcPort)
if Key_New in D_TCP_SESSION:
#print("合并")
D_TCP_SESSION[Key_New]['Packets'] += D_TCP_PACKET[Key]['Packets'] # 发包数量累加
D_TCP_SESSION[Key_New]['Bytes_Len'] += D_TCP_PACKET[Key]['Bytes_Len'] # 内容长度累加
else:
D_TCP_SESSION[Key] = D_TCP_PACKET[Key] # 复制
return(D_TCP_SESSION)
## 从PCAP文件中提取出指定会话的内容另存为PCAP文件
## 参数 PCAP_File_OR_Dir PCAP文件名或PCAP文件目录(多个PCAP文件需要按时间顺序存放)
## 参数 SaveDir 提取出的PCAP文件存放的目录
## 参数 D_SESSION_INFO 需要提取的会话信息(IP和端口正反方向都要写入) {'TCP':[(源IP,源端口,目的IP,目的端口),(目的IP,目的端口,源IP,源端口),], 'UDP':[(源IP,源端口,目的IP,目的端口),(目的IP,目的端口,源IP,源端口),]}
def 提取PCAP中指定会话数据另存为独立PCAP(PCAP_File_OR_Dir, SaveDir, D_SESSION_INFO):
print(f"【I】源PCAP文件或目录 {PCAP_File_OR_Dir}")
print(f"【I】保存目录 {SaveDir}")
E = 0
if os.path.isfile(PCAP_File_OR_Dir):
PATH,FileName = os.path.split(PCAP_File_OR_Dir) # 拆分路径和文件名
#print(PATH,FileName)
PCAP_File_OR_Dir = PATH # 这个后面但目录用
L_FileName = ['\\'+FileName] # 文件名
elif os.path.isdir(PCAP_File_OR_Dir):
L_FileName = [i for i in os.listdir(PCAP_File_OR_Dir) if os.path.isfile(PCAP_File_OR_Dir+i)] # 目录内内容列表(只取文件)
else:
print(f"【E】{PCAP_File_OR_Dir} 不存在")
E = 1
try:
if not os.path.isdir(SaveDir):
os.makedirs(SaveDir)
os.chdir(SaveDir) ## 切换到存放拆分后文件的目录
except Exception as e:
print(e)
E = 1
else:
pass
if E == 0:
## 本地文件名保存到字典中
D_Local_File_Name = {}
文件数量 = len(L_FileName)
新建PCAP文件数量 = 0
计数 = 1
for F in L_FileName:
FullFileName = PCAP_File_OR_Dir+str(F)
print(f"【I】拆分PCAP文件：{FullFileName} 进度：{计数}/{文件数量}") ## 根据源目的IP和端口分成多个小pcap文件
f = open(FullFileName, 'rb') # 以二进制方式读取pcap格式文件
PCAP_DATA = f.read(24) # 读取前24字节头信息，忽略
计数 += 1
while 1:
包头 = f.read(16)
if not 包头: # 判断 包头 是否为空（读完或者本身为空时 S 为空）
break
PacketHeader = struct.unpack('IIII', 包头)
PacketData = f.read(PacketHeader[3])
# 以太部首
FrameType = PacketData[12:14] # 帧类型
# IP数据报头
if FrameType == b'\x08\x00': # 普通包
pass
elif FrameType == b'\x81\x00': # VLAN包
PacketData = PacketData[0:12] + b'\x08\x00' + PacketData[18:] ## 剔除VLAN数据
包头 = struct.pack('IIII', PacketHeader[0], PacketHeader[1], PacketHeader[2]-4, PacketHeader[3]-4) ## 修改包头
else:
#print("其他包忽略")
pass
## SrcIP_SrcPort 和 DstIP_DstPort 互换位置是同个TCP交互，要存入同个文件对象
IP_Protocol = PacketData[23:24]
## 只要TCP协议
if IP_Protocol == b'\x06': # 协议（TCP 6）（UDP 17）
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort_Bytes = PacketData[34:36]
DstPort_Bytes = PacketData[36:38]
SrcPort = struct.unpack('>H', SrcPort_Bytes)[0]
DstPort = struct.unpack('>H', DstPort_Bytes)[0]
## 每一次连接生成2个文件名
SRC = SrcIP+'_'+ str(SrcPort)
DST = DstIP+'_'+ str(DstPort)
TCP_F_NAME_SD = 'TCP_'+SRC+'-'+DST+'.pcap' # 以当前包的源到目的生成一个文件
TCP_F_NAME_DS = 'TCP_'+DST+'-'+SRC+'.pcap' # 以当前包的目的到源生成一个文件
#print("TCP_F_NAME_SD", TCP_F_NAME_SD)
#print("TCP_F_NAME_DS", TCP_F_NAME_DS)
## 另存为小文件
if (SrcIP, SrcPort, DstIP, DstPort) in D_SESSION_INFO['TCP']:
if TCP_F_NAME_SD in D_Local_File_Name:
#print(" 归属", TCP_F_NAME_SD)
fp = open(D_Local_File_Name[TCP_F_NAME_SD], 'ba')
fp.write(包头)
fp.write(PacketData)
fp.close()
else:
print("【I】 新建", TCP_F_NAME_SD)
fp = open(TCP_F_NAME_SD, 'ba') # 新建一个文件对象，名字用客户端到服务端方向
fp.write(PCAP_DATA)
fp.write(包头)
fp.write(PacketData)
fp.close()
新建PCAP文件数量 += 1
## 两个方向对应同一个文件
D_Local_File_Name[TCP_F_NAME_SD] = TCP_F_NAME_SD # 方向1
D_Local_File_Name[TCP_F_NAME_DS] = TCP_F_NAME_SD # 方向2
elif IP_Protocol == b'\x11': # 协议（TCP 6）（UDP 17）
SrcIP_Bytes = PacketData[26:30] # 源IP地址
DstIP_Bytes = PacketData[30:34] # 目的IP地址
SrcIP = socket.inet_ntoa(SrcIP_Bytes)
DstIP = socket.inet_ntoa(DstIP_Bytes)
SrcPort_Bytes = PacketData[34:36]
DstPort_Bytes = PacketData[36:38]
SrcPort = struct.unpack('>H', SrcPort_Bytes)[0]
DstPort = struct.unpack('>H', DstPort_Bytes)[0]
## 每一次连接生成2个文件名
SRC = SrcIP+'_'+ str(SrcPort)
DST = DstIP+'_'+ str(DstPort)
UDP_F_NAME_SD = 'UDP_'+SRC+'-'+DST+'.pcap' # 以当前包的源到目的生成一个文件
UDP_F_NAME_DS = 'UDP_'+DST+'-'+SRC+'.pcap' # 以当前包的目的到源生成一个文件
## 另存为小文件
if (SrcIP, SrcPort, DstIP, DstPort) in D_SESSION_INFO['UDP']:
if UDP_F_NAME_SD in D_Local_File_Name:
#print(" 归属", UDP_F_NAME_SD)
fp = open(D_Local_File_Name[UDP_F_NAME_SD], 'ba')
fp.write(包头)
fp.write(PacketData)
fp.close()
else:
print("【I】 新建", UDP_F_NAME_SD)
fp = open(UDP_F_NAME_SD, 'ba') # 新建一个文件对象，名字用客户端到服务端方向
fp.write(PCAP_DATA)
fp.write(包头)
fp.write(PacketData)
fp.close()
新建PCAP文件数量 += 1
## 两个方向对应同一个文件
D_Local_File_Name[UDP_F_NAME_SD] = UDP_F_NAME_SD # 方向1
D_Local_File_Name[UDP_F_NAME_DS] = UDP_F_NAME_SD # 方向2
else:
#print("IP_Protocol", IP_Protocol)
pass
f.close()
print(f"【I】完成 {time.strftime('%Y-%m-%d %H:%M:%S')}")
print(f"【I】新建PCAP文件数量: {新建PCAP文件数量}")
else:
print("【E】有错误，终止 提取PCAP中指定会话数据() 操作")
## 返回传入元组对象的第二个值，排序要用
def T2(X):
return(X[1])
def 过滤出的包数据画流量图(D_TCP_PACKET, D_TIME_PACKET):
## 单向TCP会话统计 D_TCP_PACKET
Log.info("单向分别统计")
L_TCP_PACKET = [(Key,D_TCP_PACKET[Key]['Bytes_Len']) for Key in D_TCP_PACKET]
L_TCP_PACKET.sort(key=T2)
#for Key in D_TCP_PACKET:
# Log.info(f" {Key} {D_TCP_PACKET[Key]}")
for i in L_TCP_PACKET:
Log.info(f" {i[0]} {D_TCP_PACKET[i[0]]}")
## 双向TCP会话统计 D_TCP_SESSION
D_TCP_SESSION = 合并会话(D_TCP_PACKET)
Log.info("双向合并统计")
#for Key in D_TCP_SESSION:
# Log.info(f" {Key} {D_TCP_SESSION[Key]}")
L_TCP_SESSION = [(Key,D_TCP_SESSION[Key]['Bytes_Len']) for Key in D_TCP_SESSION]
L_TCP_SESSION.sort(key=T2)
for i in L_TCP_SESSION:
Log.info(f" {i[0]} {D_TCP_SESSION[i[0]]}")
画流量图(D_TIME_PACKET)
def TCP会话交互过程用时分析(L_会话编号, L_TCP_SESSION_KEY, D_TCP_ALL, 图, 选择日志等级):
设置CMD颜色(天蓝色)
Log.info("-----------------------------------------------------------------------------------------------------------------------------------------------------------------")
TCP_START_TIME = []
TCP_END_TIME = []
D_S_KeepAlive = {} # S发起KeepAlive信息字典，Key=交互信息，Value=[(KeepAlive每次开始, 结束时间), ]
D_C_KeepAlive = {} # {'Key标识数据归属':[('10:18:29', '10:20:24'), [('10:19:50', '10:24:40')]],}
D_C_WAIT = {}
D_C_WIN_0_TIME = {}
D_S_WIN_0_TIME = {}
头行 = ('客户端', '端口', '服务端', '端口', '开始时间', '结束时间', '会话总用时', 'C_Keep时间', 'S_Keep时间', 'C间隔发包合时', 'C缓冲窗满合时', 'S缓冲窗满合时', '程序其它用时合计')
Log.info("%s %s %s %s %s %s %s %s %s %s %s %s %s" % 头行)
for 会话编号 in L_会话编号:
选择会话KEY = L_TCP_SESSION_KEY[会话编号]
L_DATA = D_TCP_ALL[选择会话KEY]['L_DATA']
C_发起开始时间 = L_DATA[0][1] # TCP会话第一个包的时间戳
C_发起结束时间 = L_DATA[-1][1] # TCP会话最后一个包的时间戳
TCP_START_TIME.append(C_发起开始时间)
TCP_END_TIME.append(C_发起结束时间)
L_TIME_Client_WAIT = 客户端发起请求间隔耗时(D_TCP_ALL[选择会话KEY]) # 客户端发起新请求和上次完成交互之间的间隔时间(下次交互开始-上次交互完成)
L_C_KeepAlive_RANGE, L_S_KeepAlive_RANGE = 分析KeepAlive耗时(D_TCP_ALL[选择会话KEY]) # 因保持连接造成的等待耗时
L_C_WIN_0_RANGE, L_S_WIN_0_RANGE = 分析接收窗口满耗时(D_TCP_ALL[选择会话KEY]) # 因接收窗口满造成的时间消耗
#print("L_C_WIN_0_RANGE", L_C_WIN_0_RANGE)
#print("L_S_WIN_0_RANGE", L_S_WIN_0_RANGE)
源地址, 源端口 = D_TCP_ALL[选择会话KEY]['CLIENT']
目的地址, 目的端口 = D_TCP_ALL[选择会话KEY]['SERVER']
D_C_KeepAlive[f"{源地址}:{源端口}<=>{目的地址}:{目的端口}"] = L_C_KeepAlive_RANGE
D_S_KeepAlive[f"{源地址}:{源端口}<=>{目的地址}:{目的端口}"] = L_S_KeepAlive_RANGE
D_C_WAIT[f"{源地址}:{源端口}<=>{目的地址}:{目的端口}"] = L_TIME_Client_WAIT
D_C_WIN_0_TIME[f"{源地址}:{源端口}<=>{目的地址}:{目的端口}"] = L_C_WIN_0_RANGE
D_S_WIN_0_TIME[f"{源地址}:{源端口}<=>{目的地址}:{目的端口}"] = L_S_WIN_0_RANGE
T_DATA = SHOW_TIME_WAIT(C_发起开始时间, C_发起结束时间, L_TIME_Client_WAIT, L_C_KeepAlive_RANGE, L_S_KeepAlive_RANGE, L_C_WIN_0_RANGE, L_S_WIN_0_RANGE, D_TCP_ALL[选择会话KEY])
## 每次交互的详细信息
L_TCP_TIME = TCP_SESSION_TIME(D_TCP_ALL[选择会话KEY]) # 分析TCP每次交互用时信息
SHOW_TCP_ALTERNATELY_TIME(L_TCP_TIME, 视角) # 记录每次客户端发请求到收完响应数据的统计信息
TCP交互用时合计 = sum([i[4] for i in L_TCP_TIME])
客户端发请求用时合计 = sum([i[5] for i in L_TCP_TIME])
服务端处理用时合计 = sum([i[6] for i in L_TCP_TIME])
服务端发包用时合计 = sum([i[7] for i in L_TCP_TIME])
Log.info(f" 程序其它用时合计包含: TCP交互用时合计={round(TCP交互用时合计,3)}(秒) (客户端发请求用时合计={round(客户端发请求用时合计,3)}, 服务端处理用时合计={round(服务端处理用时合计,3)}, 服务端发包用时合计={round(服务端发包用时合计,3)})")
## == debug == 标记用时分析的起止点
if 选择日志等级 == '0':
L_C_KeepAlive_RANGE_start = [i[0] for i in L_C_KeepAlive_RANGE]
L_C_KeepAlive_RANGE_end = [i[1] for i in L_C_KeepAlive_RANGE]
L_S_KeepAlive_RANGE_start = [i[0] for i in L_S_KeepAlive_RANGE]
L_S_KeepAlive_RANGE_end = [i[1] for i in L_S_KeepAlive_RANGE]
L_TIME_Client_WAIT_start = [i[0] for i in L_TIME_Client_WAIT]
L_TIME_Client_WAIT_end = [i[1] for i in L_TIME_Client_WAIT]
L_C_WIN_0_RANGE_start = [i[0] for i in L_C_WIN_0_RANGE]
L_C_WIN_0_RANGE_end = [i[1] for i in L_C_WIN_0_RANGE]
L_S_WIN_0_RANGE_start = [i[0] for i in L_S_WIN_0_RANGE]
L_S_WIN_0_RANGE_end = [i[1] for i in L_S_WIN_0_RANGE]
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-5s %5s %s %s' % ('ID','TIME','SrcIP','DstIP','SPort','DPort','Seq','Ack','FLAGE','LEN','请求/响应','WIN','校验码','备注说明'))
for i in L_DATA:
if i[1] in L_C_KeepAlive_RANGE_start:
X = i + ('[T]L_C_KeepAlive_RANGE_start',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_C_KeepAlive_RANGE_end:
X = i + ('[T]L_C_KeepAlive_RANGE_end',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_S_KeepAlive_RANGE_start:
X = i + ('[T]L_S_KeepAlive_RANGE_start',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_S_KeepAlive_RANGE_end:
X = i + ('[T]L_S_KeepAlive_RANGE_end',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_TIME_Client_WAIT_start:
X = i + ('[T]L_TIME_Client_WAIT_start',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_TIME_Client_WAIT_end:
X = i + ('[T]L_TIME_Client_WAIT_end',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_C_WIN_0_RANGE_start:
X = i + ('[T]L_C_WIN_0_RANGE_start',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_C_WIN_0_RANGE_end:
X = i + ('[T]L_C_WIN_0_RANGE_end',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_S_WIN_0_RANGE_start:
X = i + ('[T]L_S_WIN_0_RANGE_start',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
elif i[1] in L_S_WIN_0_RANGE_end:
X = i + ('[T]L_S_WIN_0_RANGE_end',)
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s %s' % X)
else:
Log.debug('%3s %-17s %-15s %-15s %5s %5s %10s %10s %-7s %4s %-9s %5s %6s %s' % i)
Log.debug('')
## == debug ==
设置CMD颜色(白色)
print(f"\n结果已写入日志文件：{LOG_FILE}\n\n")
## 画图：TCP会话交互中各种用时信息画成图
## 计算最小开始时间和最大结束时间，统一X时间轴用
if 图 == 1:
TCP_START_TIME_MIN = min(TCP_START_TIME)
TCP_END_TIME_MAX = max(TCP_END_TIME)
TCP会话用时信息画图(TCP_START_TIME_MIN, TCP_END_TIME_MAX, D_C_KeepAlive, D_C_WAIT, D_S_KeepAlive, D_C_WIN_0_TIME, D_S_WIN_0_TIME)
## 组装TCP数据
## 读取数据包的 Seq, TCP数据长度, TCP实际有效数据
## Seq
## TCP_DATA_LEN
## 剩余有效数据
def 读取包信息(PacketData):
Seq = 0
TCP_DATA_LEN = 0
剩余有效数据 = b''
DstMAC, SrcMAC, FrameType = EthernetII_Header(PacketData[0:14]) # 以太帧头
###########【IPv4】###########
if FrameType == b'\x08\x00':
## 解析IP头(20字节[14:34])
(IP_Version, IP_Header_Length, IP_TOS, IP_Total_Length, IP_Identification, IP_Flags, IP_Fragment_offset, IP_TTL, IP_Protocol, IP_Header_checksum, IP_Source, IP_Destination) = IPv4_Header(PacketData[14:34])
IP部首字节长度 = IP_Header_Length*4
###########【TCP】###########
if IP_Protocol == 6: # TCP b'\x06'
TCP_Source_Port, TCP_Destination_Port, TCP_Sequence_Number, TCP_Acknowledgment_Number, TCP_Data_Offset, TCP_Reserved, TCP_Flags, TCP_Window, TCP_Checksum, TCP_Urgent_Pointers = TCP_Header(PacketData[34:54])
## 根据TCP部首长度计算是否有TCP可选字段
TCP部首实际长度 = TCP_Data_Offset*4
TCP部首固定长度 = 20
TCP选项长度 = TCP部首实际长度 - TCP部首固定长度
TCP_DATA_LEN = IP_Total_Length - IP部首字节长度 - TCP部首固定长度 - TCP选项长度
## 计算数据长度
## 最小60字节，不足会填充
#剩余全部数据 = PacketData[54+TCP选项长度:]
剩余有效数据 = PacketData[54+TCP选项长度:54+TCP选项长度+TCP_DATA_LEN]
#print("剩余全部数据字节数(TCP选项后全部)", len(剩余全部数据)) ## 当不足最小长度会填充，这个会比下面的大
#print("剩余有效数据字节数(计算得到)", len(剩余有效数据))
## 修正解析IP包总长度结果为0的情况 wireshark 提示 (reported as 0, presumed to be because of "TCP segmentation offload" (TSO))
if IP_Total_Length == 0:
剩余有效数据 = PacketData[54+TCP选项长度:] # 修正内容数据值为剩余全部数据值
TCP_DATA_LEN = len(剩余有效数据) # 修正内容数据的长度值
## 分析数据包中的TCP内容
#SrcIP_Bytes = PacketData[26:30] # 源IP地址
#DstIP_Bytes = PacketData[30:34] # 目的IP地址
#SrcIP = socket.inet_ntoa(SrcIP_Bytes)
#DstIP = socket.inet_ntoa(DstIP_Bytes)
#SrcPort = TCP_Source_Port
#DstPort = TCP_Destination_Port
Seq = TCP_Sequence_Number
Ack = TCP_Acknowledgment_Number
elif IP_Protocol == 17:
Log.error("【ERROR】UDP PASS")
else:
Log.error("【ERROR】NOT TCP/UDP PASS")
else:
Log.error("【ERROR】NOT IPv4 Ethernet")
#print(f" 【DEBUG】Seq={Seq:10} TCP_DATA_LEN={TCP_DATA_LEN:<10} TCP_DATA={剩余有效数据}")
return(Seq, TCP_DATA_LEN, 剩余有效数据)
##【4】
## 传入 L_需要用到的Seq # 列表，所需的数据包Seq列表
## 返回 D_Seq_Len_DATA = {} # 字典，Key=(Seq,Len) Value=b''
def 从PCAP文件中提取TCP有效数据_生成以SeqLen为KEY的字典(PCAP_File_OR_Dir, P_Seq):
D_Seq_Len_DATA = {}
L_DATA_Other = []
## 开始处理单个或多个PCAP文件
E = 0
if os.path.isfile(PCAP_File_OR_Dir):
PATH,FileName = os.path.split(PCAP_File_OR_Dir) # 拆分路径和文件名
#print(PATH,FileName)
PCAP_File_OR_Dir = PATH # 这个后面但目录用
L_FileName = ['\\'+FileName] # 文件名
elif os.path.isdir(PCAP_File_OR_Dir):
L_FileName = [i for i in os.listdir(PCAP_File_OR_Dir) if os.path.isfile(PCAP_File_OR_Dir+i)] # 目录内内容列表(只取文件)
if L_FileName == []:
E = 1
print(f"{PCAP_File_OR_Dir} 中没有发现文件")
else:
print(f"{PCAP_File_OR_Dir} 不存在")
E = 1
if E == 0:
文件数量 = len(L_FileName)
计数 = 1
for F in L_FileName:
FullFileName = PCAP_File_OR_Dir+str(F)
print(f" 解析PCAP文件：{FullFileName} 进度：{计数}/{文件数量}") ## 根据源目的IP和端口分成多个小pcap文件
f = open(FullFileName, 'rb') # 以二进制方式读取pcap格式文件
PCAP_DATA = f.read(24) # 读取前24字节头信息，忽略
计数 += 1
N = 0
while 1:
包头 = f.read(16)
if not 包头: # 判断 包头 是否为空（读完或者本身为空时 S 为空）
break
N += 1
#if N == 14:
# break
#print("N", N)
PacketHeader = struct.unpack('IIII', 包头)
时间戳 = PacketHeader[0]
#微秒 = PacketHeader[1]
#抓取数据包长度 = PacketHeader[2] # 所抓获的数据包保存在pcap文件中的实际长度，以字节为单位。
实际数据包长度 = PacketHeader[3] # 所抓获的数据包的真实长度，如果文件中保存不是完整的数据包，那么这个值可能要比前面的数据包长度的值大。
PacketData = f.read(实际数据包长度)
# 以太部首
FrameType = PacketData[12:14] # 帧类型
# IP数据报头
if FrameType == b'\x08\x00': # 普通包
pass
elif FrameType == b'\x81\x00': # VLAN包
PacketData = PacketData[0:12] + b'\x08\x00' + PacketData[18:] ## 剔除VLAN数据
包头 = struct.pack('IIII', PacketHeader[0], PacketHeader[1], PacketHeader[2]-4, PacketHeader[3]-4) ## 修改包头
else:
#print("其他包忽略")
pass
IP_Protocol = PacketData[23:24]
## 只要TCP协议
if IP_Protocol == b'\x06': # 协议（TCP 6）（UDP 17）
Seq,Len,DATA_Bytes = 读取包信息(PacketData)
if Len > 0: # 取有实际数据的包
if Seq in P_Seq: # 只记录需要的部分
if (Seq,Len) in D_Seq_Len_DATA: # (Seq,Len) 重复的数据包
if D_Seq_Len_DATA[(Seq,Len)] == DATA_Bytes:
Log.debug(f"重复(Seq,Len)=({Seq},{Len}) 数据也一致")
else:
Log.debug(f"重复(Seq,Len)=({Seq},{Len}) 数据不一致")
L_DATA_Other.append((Seq,Len,DATA_Bytes))
else:
D_Seq_Len_DATA[(Seq,Len)] = DATA_Bytes # 保存找到的TCP数据(Bytes)
elif Len < 0:
Log.error(f"【ERROR】解析异常，长度={Len}<0，PacketData={PacketData}")
f.close()
print(f" 完成 {time.strftime('%Y-%m-%d %H:%M:%S')}")
else:
print("【ERROR】有错误终止操作")
return(D_Seq_Len_DATA, L_DATA_Other)
##【4】
def 根据SEQ整理组装数据为MBF(包信息列表, D_Seq_Len__Bytes):
MIN_DEQ = min([i[1] for i in 包信息列表])
Log.debug(f" MIN_DEQ={MIN_DEQ}")
Log.debug(" 组装数据")
MBF = BytesIO() # 内存文件，类似 f = open('new.data', 'ab')
## DEBUG
for i in 包信息列表:
Seq = i[1]
Len = i[3]
if Len <= 0:
Log.error(f" 【ERROR】有异常长度包 ({Seq},{Len}) {Seq-MIN_DEQ}:{Len} DATA={D_Seq_Len__Bytes[(Seq,Len)]}")
MBF.seek(Seq-MIN_DEQ) # 定位到指定位置
DATA_OLD = MBF.read(Len) # 原有数据
DATA_NEW = D_Seq_Len__Bytes[(Seq,Len)] # 新增数据
MBF.seek(Seq-MIN_DEQ) # 定位到指定位置
MBF.write(DATA_NEW) # 写入新数据
## 分析对比刚写入的新旧数据
if DATA_OLD == b'\x00'*Len or DATA_OLD == b'':
#MBF.seek(Seq-MIN_DEQ)
#MBF.write(DATA_NEW)
Log.debug(f" 全空，写入数据({Seq},{Len}) {Seq-MIN_DEQ}:{Len}")
elif DATA_OLD == DATA_NEW:
Log.debug(f" 重复，忽略数据({Seq},{Len}) {Seq-MIN_DEQ}:{Len}")
else:
#print(f" DATA_OLD={DATA_OLD}")
#print(f" DATA_NEW={DATA_NEW}")
#MBF.seek(Seq-MIN_DEQ)
#MBF.write(DATA_NEW)
Log.debug(f" 部分，重写数据({Seq},{Len}) {Seq-MIN_DEQ}:{Len}")
LIN_MIN = min(len(DATA_OLD), len(DATA_NEW)) # 取两者最短长度进行对比
for n in range(0, LIN_MIN):
if DATA_OLD[n] != 0:
if DATA_OLD[n] != DATA_NEW[n]:
Log.warning(f" START={Seq-MIN_DEQ} n={n} DATA_OLD[n]={DATA_OLD[n]} DATA_NEW[n]={DATA_NEW[n]}") # 记录非空不相等字节信息
print(f"【W】START={Seq-MIN_DEQ} n={n} DATA_OLD[n]={DATA_OLD[n]} DATA_NEW[n]={DATA_NEW[n]}")
n+=1
MBF.seek(0)
return(MBF)
## 解析HTTP请求数据（拼接数据包后的完整数据），直接写入日志
def MBF_HTTP_TEXT_C_ALL(MBF, FileSaveDir):
## 请求信息做成字典
D_HTTP_Header = {}
BytesData = MBF.getvalue()
CRLRx2_Index, L_CRLR_index = HTTP_CRLRx2_Index(BytesData)
Log.debug(f" 【DEBUG】CRLR结果：信息和数据分隔点={CRLRx2_Index} 信息内分隔点{L_CRLR_index}")
if CRLRx2_Index > 0:
## 信息部分
HTTP_INFO = BytesData[0:CRLRx2_Index-1] # -1可以把结尾的\r\n只留前一个\r\n
Log.debug(f" 【DEBUG】信息部分 {HTTP_INFO}")
HTTP_INFO_SP = HTTP_INFO.decode('ASCII', errors='ignore').split('\r\n')
## 解析请求行
请求行SP = HTTP_INFO_SP[0].split(' ')
请求方法, URL, 协议版本 = 请求行SP
D_HTTP_Header['Request'] = 请求方法
if 请求方法 == 'GET':
URL = unquote(URL)
D_HTTP_Header['URL'] = URL
D_HTTP_Header['Version'] = 协议版本
## 解析请求头
Log.info(f" ===[ 请求信息 ]===")
for n in range(1, len(HTTP_INFO_SP)):
#Log.info(f" {HTTP_INFO_SP[n]}")
SP = HTTP_INFO_SP[n].split(': ')
if len(SP) == 2:
if SP[0] == 'Referer':
D_HTTP_Header['Referer'] = unquote(SP[1]) ## 解码
else:
D_HTTP_Header[SP[0]] = SP[1]
for K in D_HTTP_Header:
Log.info(f" %-17s : %s" % (K, D_HTTP_Header[K]))
## 数据部分
HTTP_DATA = BytesData[CRLRx2_Index+1:] # +1可以省去开头的\r\n
Log.info(" ===[ 请求数据 ]===")
if len(HTTP_DATA) != 0:
if 'Content-Type' in D_HTTP_Header:
MIME = D_HTTP_Header['Content-Type']
if MIME in ('application/x-www-form-urlencoded; charset=UTF-8'):
REQ_DATA = unquote(HTTP_DATA.decode('ASCII', errors='ignore')) # 解码请求数据
Log.info(REQ_DATA)
elif MIME[0:30] == 'multipart/form-data; boundary=':
if len(MIME) > 30:
Boundary = bytes(MIME[30:], 'UTF8') # 提取分隔标识转成bytes
POST_form_data(HTTP_DATA, Boundary, FileSaveDir)
else:
Log.info('multipart/form-data; boundary=空')
else:
Log.info(f" 放弃解析 {MIME}")
else:
Log.info(' 没有 Content-Type 显示原始数据')
Log.info(f"{HTTP_DATA}")
else:
Log.info(" 无数据")
else:
Log.error(f"【ERROR】没有找到连续2个CRLR {CRLRx2_Index} {L_CRLR_index}")
Log.info(" ===[ LEN ]===")
Log.info(f" TCP DATA LEN: {len(BytesData)} (信息+数据)")
Log.info(f" HTTP DATA LEN: {len(HTTP_DATA)} (数据)")
if 'Content-Length' in D_HTTP_Header:
Log.debug(f" Content-Length:{D_HTTP_Header['Content-Length']}")
Log.info('')
## 解析HTTP响应数据（拼接数据包后的完整数据），直接写入日志
def MBF_HTTP_TEXT_S_ALL(MBF, FileSaveDir):
D_HTTP_Header = {'Content-Encoding':'', 'Transfer-Encoding':'', 'ETag':''} ## 请求信息做成字典，初始化几个重要变量
BytesData = MBF.getvalue()
CRLRx2_Index, L_CRLR_index = HTTP_CRLRx2_Index(BytesData)
Log.debug(f" 【DEBUG】CRLR结果：信息和数据分隔点={CRLRx2_Index} 信息内分隔点{L_CRLR_index}")
if CRLRx2_Index > 0:
## 信息部分
HTTP_INFO = BytesData[0:CRLRx2_Index-1] ## -1可以把结尾的\r\n只留前一个\r\n
Log.debug(f" 【DEBUG】信息部分 {HTTP_INFO}")
HTTP_INFO_SP = HTTP_INFO.decode('ASCII', errors='ignore').split('\r\n')
## 解析响应行
响应行SP = HTTP_INFO_SP[0].split(' ')
D_HTTP_Header['HTTP_INFO'] = 响应行SP
## 解析响应头
for n in range(1, len(HTTP_INFO_SP)):
#Log.info(f" {HTTP_INFO_SP[n]}")
SP = HTTP_INFO_SP[n].split(': ')
if len(SP) == 2:
D_HTTP_Header[SP[0]] = SP[1]
Log.info(f" ===[ 响应信息 ]===")
for K in D_HTTP_Header:
Log.info(f" %-17s : %s" % (K, D_HTTP_Header[K]))
## 数据部分
HTTP_DATA = BytesData[CRLRx2_Index+1:] ## +1可以省去开头的\r\n
Log.info(" ===[ 响应数据 ]===")
if len(HTTP_DATA) != 0:
字符集 = 'UTF8'
if 'Content-Type' in D_HTTP_Header:
MIME = D_HTTP_Header['Content-Type']
if MIME in ('text/plain;charset=UTF-8', 'text/html;charset=UTF-8'):
if D_HTTP_Header['Transfer-Encoding'] == 'chunked':
Log.info(f" 尝试 chunked 解码")
R, MBF = Chunked_BytesData_HTTP_DATA(HTTP_DATA) # chunked 数据拼接
if R == 0:
if D_HTTP_Header['Content-Encoding'] == 'gzip':
Log.info(f" 尝试 gzip 解码")
HTTP_TEXT = MBF_UNGZIP_Return_TEXT(MBF, 字符集) # gzip 解压
HTTP_TEXT_LEN = len(HTTP_TEXT)
if HTTP_TEXT_LEN == 0:
Log.info(f" 解码后为空")
elif HTTP_TEXT_LEN > 10000:
Log.info(f" HTTP_TEXT_LEN = {HTTP_TEXT_LEN} > 10000 保存到本地")
HTML_TEXT_SAVE(HTTP_TEXT, FileSaveDir, 字符集)
else:
Log.info(f"{HTTP_TEXT}")
else:
Log.info(f"{MBF}")
else:
Log.error(f" 解码 chunked 失败")
elif MIME in ('application/javascript', 'text/javascript;charset=utf-8'):
if 'Content-Disposition' in D_HTTP_Header:
FileName = unquote(D_HTTP_Header['Content-Disposition'].split('filename=')[1][1:-1])
扩展名 = ''
elif 'Content-disposition' in D_HTTP_Header:
FileName = unquote(D_HTTP_Header['Content-disposition'].split('filename=')[1][1:-1])
扩展名 = ''
else:
FileName = re.sub('[^a-f0-9\-]', '', D_HTTP_Header['ETag'])
扩展名 = '.js'
if D_HTTP_Header['Transfer-Encoding'] == 'chunked':
Log.info(f" 尝试 chunked 解码")
R, MBF = Chunked_BytesData_HTTP_DATA(HTTP_DATA) # chunked 数据拼接
if R == 0:
if D_HTTP_Header['Content-Encoding'] == 'gzip':
Log.info(f" 尝试 gzip 解码")
DATA_UNGZIP = MBF_UNGZIP(MBF) # gzip 解压
if type(DATA_UNGZIP) == bytes:
if DATA_UNGZIP != b'':
B_SAVE(DATA_UNGZIP, FileSaveDir, FileName, 扩展名)
else:
Log.info(f" 内容为空")
else:
Log.error(f" 解码 gzip 失败")
else:
DATA = MBF.getvalue()
B_SAVE(DATA, FileSaveDir, FileName, 扩展名)
else:
Log.error(f" 解码 chunked 失败")
else:
B_SAVE(HTTP_DATA, FileSaveDir, FileName, 扩展名)
elif MIME in ('text/css', 'text/css;charset=utf-8'):
if 'Content-Disposition' in D_HTTP_Header:
FileName = unquote(D_HTTP_Header['Content-Disposition'].split('filename=')[1][1:-1])
扩展名 = ''
elif 'Content-disposition' in D_HTTP_Header:
FileName = unquote(D_HTTP_Header['Content-disposition'].split('filename=')[1][1:-1])
扩展名 = ''
else:
FileName = re.sub('[^a-f0-9\-]', '', D_HTTP_Header['ETag'])
扩展名 = '.css'
#print(f"FileName={FileName} 扩展名={扩展名}")
if D_HTTP_Header['Transfer-Encoding'] == 'chunked':
Log.info(f" 尝试 chunked 解码")
R, MBF = Chunked_BytesData_HTTP_DATA(HTTP_DATA) # chunked 数据拼接
if R == 0:
if D_HTTP_Header['Content-Encoding'] == 'gzip':
Log.info(f" 尝试 gzip 解码")
DATA_UNGZIP = MBF_UNGZIP(MBF) # gzip 解压
if type(DATA_UNGZIP) == bytes:
if DATA_UNGZIP != b'':
B_SAVE(DATA_UNGZIP, FileSaveDir, FileName, 扩展名)
else:
Log.info(f" 内容为空")
else:
Log.error(f" 解码 gzip 失败")
else:
DATA = MBF.getvalue()
B_SAVE(DATA, FileSaveDir, FileName, 扩展名)
else:
Log.error(f" 解码 chunked 失败")
else:
B_SAVE(HTTP_DATA, FileSaveDir, FileName, 扩展名)
elif MIME == 'image/jpeg':
FileName = re.sub('[^a-f0-9\-]', '', D_HTTP_Header['ETag'])
B_SAVE(HTTP_DATA, FileSaveDir, FileName, '.jpeg')
elif MIME == 'image/gif':
FileName = re.sub('[^a-f0-9\-]', '', D_HTTP_Header['ETag'])
B_SAVE(HTTP_DATA, FileSaveDir, FileName, '.gif')
elif MIME == 'image/png':
FileName = re.sub('[^a-f0-9\-]', '', D_HTTP_Header['ETag'])
B_SAVE(HTTP_DATA, FileSaveDir, FileName, '.png')
elif MIME == 'application/x-msdownload;charset=UTF-8':
if 'Content-Disposition' in D_HTTP_Header:
FileName = unquote(D_HTTP_Header['Content-Disposition'].split('filename=')[1][1:-1])
Log.info(f" 文件 x-msdownload FileName={FileName}")
R, MBF = Chunked_BytesData_HTTP_DATA(HTTP_DATA)
if R == 0:
MBF_SAVE(MBF, FileSaveDir, FileName) # 保存到本地
else:
Log.info(f"{MBF}")
elif MIME == 'application/octet-stream;charset=UTF-8':
if D_HTTP_Header['Transfer-Encoding'] == 'chunked':
R, MBF = Chunked_BytesData_HTTP_DATA(HTTP_DATA)
if R == 0:
FileName = 'un.data'
MBF_SAVE(MBF, FileSaveDir, FileName) # 保存到本地
else:
Log.info(f"{MBF}")
elif MIME == 'video/mp4':
if 'Content-Range' in D_HTTP_Header and D_HTTP_Header['Content-Range'] != '': ## 抖音mp4，Content-Range : bytes 12017629-13681403/13681404
TEXT = D_HTTP_Header['Content-Range']
字节编号, 视频编号 = TEXT.split('/')
#SP_字节编号_开始, SP_字节编号_结束 = 字节编号[5:].split('-')
FileName = f"{视频编号}_{字节编号[6:]}"
else:
FileName = 'video_mp4'
B_SAVE(HTTP_DATA, FileSaveDir, FileName, '.mp4') # 保存到本地
else:
Log.info(f"放弃解析 {MIME}")
if len(HTTP_DATA) < 100000:
Log.info(f"{HTTP_DATA}")
else:
Log.info(f"原始数据>100000不打印了")
else:
Log.info('没有Content-Type')
else:
Log.info(' 无数据')
else:
Log.error(f"【ERROR】没有找到连续2个CRLR {CRLRx2_Index} {L_CRLR_index}")
Log.info(" ===[ LEN ]===")
Log.info(f" TCP DATA LEN: {len(BytesData)} (信息+数据)")
Log.info(f" HTTP DATA LEN: {len(HTTP_DATA)} (数据)")
if 'Content-Length' in D_HTTP_Header:
Log.debug(f" Content-Length:{D_HTTP_Header['Content-Length']}")
Log.info('')
## 二进制文件保存(文件名为'Content-Disposition'值或ETag或随机数字)
def B_SAVE(HTTP_DATA, FileSaveDir, FileName, 扩展名):
try:
os.chdir(FileSaveDir)
except Exception as e:
Log.error(f" 文件保存失败，目录 {FileSaveDir} 不存在或没有写入权限 {e}")
else:
if FileName == '':
FileName = '无名文件'
while 1:
if os.path.exists(FileName + 扩展名):
FileName += '_重复'
else:
break
try:
f = open(FileName + 扩展名, 'bw')
f.write(HTTP_DATA)
f.close()
except Exception as e:
Log.error(f" 文件 {FileName}{扩展名} 保存失败 {e}")
else:
Log.info(f" 文件 {FileName}{扩展名} 已保存到 {FileSaveDir} 目录")
## HTML TEXT 保存到本地(文件名为随机数字)
def HTML_TEXT_SAVE(TEXT, FileSaveDir, 字符集):
try:
os.chdir(FileSaveDir)
except Exception as e:
Log.error(f" 文件保存失败，目录 {FileSaveDir} 不存在或没有写入权限 {e}")
else:
FileName = '无名文件'
while 1:
if os.path.exists(FileName + '.html'):
FileName += '_重复' # 修改文件名防止重复造成覆盖
else:
break
try:
f = open(FileName + '.html', 'tw', encoding=字符集)
f.write(TEXT)
f.close()
except Exception as e:
Log.error(f" 生成随机文件名 {FileName}.html 保存失败 {e}")
else:
Log.info(f" 生成随机文件名 {FileName}.html 已保存到 {FileSaveDir} 目录")
## MBF 保存到本地
def MBF_SAVE(MBF, FileSaveDir, FileName):
try:
os.chdir(FileSaveDir)
f = open(FileName, 'bw')
f.write(MBF.getvalue())
f.close()
except Exception as e:
Log.error(f" 文件 {FileName} 保存失败，目录 {FileSaveDir} 不存在或没有写入权限 {e}")
else:
Log.debug(f" 文件 {FileName} 已保存到 {FileSaveDir} 目录")
## MBF gzip解压成字节码
def MBF_UNGZIP(MBF):
#print("GZIP", MBF.getvalue())
MBF.seek(0) ## 必须移动到MBF文件开头
f = gzip.open(MBF,'rb')
try:
DATA_UNGZIP = f.read()
except Exception as e:
print("GZIP解码前原值", f.read())
print(f"GZIP解码失败信息 {e}")
return('')
else:
return(DATA_UNGZIP)
## MBF gzip解压成文本
def MBF_UNGZIP_Return_TEXT(MBF, 字符集):
#print("GZIP", MBF.getvalue())
MBF.seek(0) ## 必须移动到MBF文件开头
f = gzip.open(MBF,'rb')
DATA_UNGZIP = f.read()
#print(f"DATA_UNGZIP {DATA_UNGZIP}")
try:
TEXT = DATA_UNGZIP.decode(字符集)
except Exception as e:
TEXT = f"用字符集{字符集}解码失败"
#print("TEXT", TEXT)
return(TEXT)
## 解析 HTTP Chunked 内容，传入BytesData，返回内存文件对象MBF
def Chunked_BytesData_HTTP_DATA(BytesData):
ChunkSizeBytes = b'' # 二进制类型ChunkSize
MBF_R = BytesIO()
MBF_R.write(BytesData)
MBF_R.seek(0)
MBF_W = BytesIO() # ChunkData 保存在内存文件中
while 1:
Bx = MBF_R.read(1)
if not Bx:
break
#Log.debug(f"Bx {Bx}")
if Bx == b'\r':
By = MBF_R.read(1)
if By == b'\n':
try:
ChunkSize = int(ChunkSizeBytes, 16) # 转成十进制数字类型ChunkSize
except Exception as e:
Log.debug(f" 【ERROR】CRLR ChunkSizeBytes {ChunkSizeBytes} LEN {len(ChunkSizeBytes)} E {e}")
return(1, '拼接数据异常，ChunkSize 异常')
else:
Log.debug(f" 【DEBUG】CRLR ChunkSizeBytes {ChunkSizeBytes} LEN {len(ChunkSizeBytes)} ChunkSize(int) {ChunkSize}")
if ChunkSize == 0:
return(0, MBF_W)
ChunkSizeBytes = b''
ChunkData = MBF_R.read(ChunkSize) # 读取实际数据
MBF_R.read(2) # 再向后读掉\r\n这两个字节
#print("ChunkData", ChunkData)
MBF_W.write(ChunkData) # 写入实际数据
else:
ChunkSizeBytes += By
else:
ChunkSizeBytes += Bx
return(1, '拼接数据异常，没有结尾0')
## 解析POST提交文件信息
def POST_form_data(HTTP_DATA, Boundary_in, FileSaveDir):
Boundary = b'--' + Boundary_in # 实际分隔标识要加 b'--'
Boundary_SP = b'\r\n'+Boundary+b'\r\n'
Boundary_S = Boundary+b'\r\n'
Boundary_E = b'\r\n' + Boundary + b'--\r\n'
LEN_S = len(Boundary_S)
LEN_E = -len(Boundary_E)
if HTTP_DATA[0:LEN_S] == Boundary_S and HTTP_DATA[LEN_E:] == Boundary_E:
Log.info(" 检查数据首尾部分：正常")
L = HTTP_DATA[LEN_S:LEN_E].split(Boundary_SP)
for i in L:
## 通过 b'\r\n\r\n' 分离信息和数据
INFO, DATA = i.split(b'\r\n\r\n')
#print(f"INFO {INFO}")
INFO_SP = INFO.split(b'\r\n')
## 先处理信息部分
FileName = '' # 准备文件名，有文件的话，保存到本地
for j in INFO_SP:
#print(j.split(b'; '))
for k in j.split(b'; '):
Log.info(f" {k}")
k_sp = k.split(b'=')
if len(k_sp) == 2:
if k_sp[0] == b'filename' and k_sp[1] != b'""':
FullFileName = unquote(k_sp[1][1:-1].decode('UTF8', errors='ignore')) # 去掉头尾引号再转ASCII再解码
Log.info(f" FullFileName {FullFileName}")
FileName = os.path.basename(FullFileName)
Log.debug(f" 提取文件名 FileName {FileName}")
if FileName != '':
try:
os.chdir(FileSaveDir)
f = open(FileName, 'bw')
f.write(DATA)
f.close()
except Exception as e:
Log.error(f" 文件 {FileName} 保存失败，目录 {FileSaveDir} 不存在或没有写入权限 {e}")
else:
Log.info(f" 文件 {FileName} 已保存到 {FileSaveDir} 目录")
else:
Log.info(f" 非文件数据(直接写入日志) {DATA}")
else:
Log.error(" 检查数据首尾部分：错误")
Log.error(f" Boundary_S {Boundary_S}")
Log.error(f" DATA_S {HTTP_DATA[0:LEN_S]}")
Log.error(f" Boundary_E {Boundary_E}")
Log.error(f" DATA_E {HTTP_DATA[LEN_E:]}")
## 查找CRLRCRLR位置（请求头部信息和实际数据的分界点）
## 16 16 10
## 回车 CR \r 0d 13 19 0x13 = 19
## 换行 LR \n 0a 10 16 0x13 = 16
## 空格 20 32
## 返回 CRLRx2_Index（连续2次CRLR位置，定位实际数据开始位置用）, L_CRLR_index（CRLR位置列表，给解析行和头定位用）
def HTTP_CRLRx2_Index(BytesData):
CR = 0
LR = 0
字节当前位置 = 0
CRLR位置记录 = -2 # 记录找到的连续2次CRLR位置，定位实际数据开始位置用，初始为-2是网络避开第一次匹配
L_CRLR_index = [] # 保存找到的CRLR位置，给解析行和头定位用
for B in BytesData:
if B == 13:
CR = 字节当前位置
if B == 10:
LR = 字节当前位置
if CR+1 == LR: # 前一个CR的位置在当前LR位置的前一字节，说明CRLR连续
if 字节当前位置 == CRLR位置记录 + 2:
#print("连续2次CRLR", 字节当前位置)
return(字节当前位置, L_CRLR_index) # 找到连续2次CRLR位置，直接终止返回结果
else:
CRLR位置记录 = 字节当前位置
L_CRLR_index.append(字节当前位置)
字节当前位置 += 1 # 每运行一次，位置加1
return(字节当前位置, L_CRLR_index) # 没有找到连续2次CRLR位置
##【4】【4 显示会话中每次交互信息】
def 显示会话中每次交互信息(L_会话编号, L_TCP_SESSION_KEY, D_TCP_ALL, 选择日志等级):
#print("L_会话编号", L_会话编号) # [0]
#print("L_TCP_SESSION_KEY", L_TCP_SESSION_KEY) # [('192.168.63.2', 40230, '120.39.196.244', 80)]
L_交互信息 = []
for 会话编号 in L_会话编号:
选择会话KEY = L_TCP_SESSION_KEY[会话编号]
#print(f" 会话编号={会话编号} 选择会话KEY={选择会话KEY}")
#L_DATA = D_TCP_ALL[选择会话KEY]['L_DATA']
#for i in L_DATA:
# print(i)
D_TCP_SESSION = D_TCP_ALL[选择会话KEY]
D_单个TCP会话中全部客户端请求 = D_TCP_SESSION['D_C_ACK_DATA'] # {2614655155: [(1633684486.114341, 1407086186, 2614655155, 753, 128, 4)], 2616554750: [(1633684521.717116, 1407086939, 2616554750, 755, 2269, 976)]}
D_单个TCP会话中全部服务端响应 = D_TCP_SESSION['D_S_ACK_DATA']
#print(f"D_单个TCP会话中全部客户端请求={D_单个TCP会话中全部客户端请求}")
## 遍历全部请求
P_有请求的响应ACK = set() # 记录有请求的响应ACK，后来找未抓到请求的响应包需要用到
for C_请求_ACK in D_单个TCP会话中全部客户端请求:
L_C_请求包信息 = D_单个TCP会话中全部客户端请求[C_请求_ACK] # [(1633684486.114341, 1407086186, 2614655155, 753, 128, 4)]
C_请求包数量 = len(L_C_请求包信息)
C_请求包大小 = sum([i[3] for i in L_C_请求包信息])
## 找请求对应的响应信息，请求的Ack = 响应的起始包的Seq
找到_S_响应_ACK = '-'
S_响应包数量 = 0
S_响应包大小 = 0
for S_响应_ACK in D_单个TCP会话中全部服务端响应:
L_S_响应包信息 = D_单个TCP会话中全部服务端响应[S_响应_ACK]
for S_响应包信息 in L_S_响应包信息:
S_响应包_Seq = S_响应包信息[1]
S_响应包_Ack = S_响应包信息[2]
if S_响应包_Seq == C_请求_ACK:
找到_S_响应_ACK = S_响应包_Ack
P_有请求的响应ACK.add(S_响应包_Ack) # 记录有请求的响应ACK，后来找未抓到请求的响应包需要用到
break
if 找到_S_响应_ACK != '-':
S_响应包数量 = len(L_S_响应包信息)
S_响应包大小 = sum([i[3] for i in L_S_响应包信息])
break
#print(f" C_请求_ACK={C_请求_ACK} C_请求包数量={C_请求包数量} C_请求包大小={C_请求包大小} | S_响应_ACK={找到_S_响应_ACK} S_响应包数量={S_响应包数量} S_响应包大小={S_响应包大小}")
L_交互信息.append((C_请求_ACK, C_请求包数量, C_请求包大小, 找到_S_响应_ACK, S_响应包数量, S_响应包大小, 选择会话KEY))
## 可能出现没有抓到请求，但抓到了响应的情况
for S_响应_ACK in D_单个TCP会话中全部服务端响应:
if S_响应_ACK not in P_有请求的响应ACK:
L_S_响应包信息 = D_单个TCP会话中全部服务端响应[S_响应_ACK]
S_响应包数量 = len(L_S_响应包信息)
S_响应包大小 = sum([i[3] for i in L_S_响应包信息])
C_请求_ACK = '-'
C_请求包数量 = 0
C_请求包大小 = 0
找到_S_响应_ACK = S_响应_ACK
L_交互信息.append((C_请求_ACK, C_请求包数量, C_请求包大小, 找到_S_响应_ACK, S_响应包数量, S_响应包大小, 选择会话KEY))
## 显示
#for i in L_交互信息:
# print(i)
return(L_交互信息)
##【4】【选择TCP交互解析方式】【TCP会话交互数据解析】
def TCP会话交互数据解析(L_可用交互编号, L_交互信息, PCAP_File_OR_Dir, D_TCP_ALL, ROOT_DIR):
#print("L_可用交互编号", L_可用交互编号)
#print("L_交互信息", L_交互信息)
for 编号 in L_可用交互编号:
Log.debug(f"TCP内容解析 {L_交互信息[编号]}") # (2614655155, 1, 753, 1407086939, 612, 2125895, ('192.168.63.2', 40230, '2.3.19.2', 80))
C_请求_ACK, C_请求包数量, C_请求包大小, S_响应_ACK, S_响应包数量, S_响应包大小, TCP会话KEY = L_交互信息[编号]
## 生成存放目录，以客户端服务端信息为名
FileSaveDir = ROOT_DIR+'_'.join([str(i) for i in TCP会话KEY])+'\\'
if not os.path.exists(FileSaveDir):
os.makedirs(FileSaveDir)
if C_请求_ACK != '-':
## 收集本次需要用到的请求和响应数据包的Seq
P_Seq = set()
D_TCP_会话交互 = D_TCP_ALL[TCP会话KEY]
for i in D_TCP_会话交互['D_C_ACK_DATA'][C_请求_ACK]: # [(1633684486.114341, 1407086186, 2614655155, 753, 128, 4)]
Seq = i[1]
P_Seq.add(Seq)
if S_响应_ACK != '-': # 有响应才继续
for i in D_TCP_会话交互['D_S_ACK_DATA'][S_响应_ACK]:
Seq = i[1]
P_Seq.add(Seq)
## 收集本次需要用到的请求和响应数据包的有效数据，做成字典
D_Seq_Len_DATA,L_DATA_Other = 从PCAP文件中提取TCP有效数据_生成以SeqLen为KEY的字典(PCAP_File_OR_Dir, P_Seq)
## 保存请求数据
MBF = 根据SEQ整理组装数据为MBF(D_TCP_会话交互['D_C_ACK_DATA'][C_请求_ACK], D_Seq_Len_DATA)
#Log.info(f" DATA_Bytes={MBF.getvalue()}")
保存文件名 = f"请求数据_{C_请求_ACK}_{C_请求包数量}_{C_请求包大小}"
#print(f" 保存文件名={保存文件名}")
Log.info(f" ===[ TCP请求 ACK={C_请求_ACK} ] [ {len(MBF.getvalue())}(Bytes) ] \t数据文件:{保存文件名} 保存目录:{FileSaveDir}")
MBF_SAVE(MBF, FileSaveDir, 保存文件名)
## 保存响应数据
if S_响应_ACK != '-':
MBF = 根据SEQ整理组装数据为MBF(D_TCP_会话交互['D_S_ACK_DATA'][S_响应_ACK], D_Seq_Len_DATA)
#Log.info(f" DATA_Bytes={MBF.getvalue()}")
保存文件名 = f"响应数据_{S_响应_ACK}_{S_响应包数量}_{S_响应包大小}"
#print(f" 保存文件名={保存文件名}")
Log.info(f" ===[ TCP响应 ACK={S_响应_ACK} ] [ {len(MBF.getvalue())}(Bytes) ] \t数据文件:{保存文件名} 保存目录:{FileSaveDir}")
MBF_SAVE(MBF, FileSaveDir, 保存文件名)
else:
Log.info(f" ===[ TCP响应 未找到 ]=====")
else: ## 没有抓到请求，只抓到响应
## 收集本次需要用到的响应数据包的Seq
P_Seq = set()
D_TCP_会话交互 = D_TCP_ALL[TCP会话KEY]
for i in D_TCP_会话交互['D_S_ACK_DATA'][S_响应_ACK]:
Seq = i[1]
P_Seq.add(Seq)
## 收集本次需要用到的请求和响应数据包的有效数据，做成字典
D_Seq_Len_DATA,L_DATA_Other = 从PCAP文件中提取TCP有效数据_生成以SeqLen为KEY的字典(PCAP_File_OR_Dir, P_Seq)
Log.info(f" ===[ TCP请求 未找到 ]=====")
## 保存响应数据
MBF = 根据SEQ整理组装数据为MBF(D_TCP_会话交互['D_S_ACK_DATA'][S_响应_ACK], D_Seq_Len_DATA)
#Log.info(f" DATA_Bytes={MBF.getvalue()}")
保存文件名 = f"响应数据_{S_响应_ACK}_{S_响应包数量}_{S_响应包大小}"
#print(f" 保存文件名={保存文件名}")
Log.info(f" ===[ TCP响应 ACK={S_响应_ACK} ] [ {len(MBF.getvalue())}(Bytes) ] \t数据文件:{保存文件名} 保存目录:{FileSaveDir}")
MBF_SAVE(MBF, FileSaveDir, 保存文件名)
##【4】【选择TCP交互解析方式】【尝试以HTTP协议解析】
def 尝试以HTTP协议解析(L_可用交互编号, L_交互信息, PCAP_File_OR_Dir, D_TCP_ALL, ROOT_DIR):
#print("L_可用交互编号", L_可用交互编号)
#print("L_交互信息", L_交互信息)
for 编号 in L_可用交互编号:
Log.debug(f"HTTP解析 {L_交互信息[编号]}") # (2614655155, 1, 753, 1407086939, 612, 2125895, ('192.168.63.2', 40230, '2.3.19.2', 80))
C_请求_ACK, C_请求包数量, C_请求包大小, S_响应_ACK, S_响应包数量, S_响应包大小, TCP会话KEY = L_交互信息[编号]
## 生成存放目录，以客户端服务端信息为名
FileSaveDir = ROOT_DIR+'_'.join([str(i) for i in TCP会话KEY])+'\\'
if not os.path.exists(FileSaveDir):
os.makedirs(FileSaveDir)
if C_请求_ACK != '-':
## 收集本次需要用到的请求和响应数据包的Seq
P_Seq = set()
D_HTTP = D_TCP_ALL[TCP会话KEY]
for i in D_HTTP['D_C_ACK_DATA'][C_请求_ACK]: # [(1633684486.114341, 1407086186, 2614655155, 753, 128, 4)]
Seq = i[1]
P_Seq.add(Seq)
if S_响应_ACK != '-': # 有响应才继续
for i in D_HTTP['D_S_ACK_DATA'][S_响应_ACK]:
Seq = i[1]
P_Seq.add(Seq)
## 收集本次需要用到的请求和响应数据包的有效数据，做成字典
D_Seq_Len_DATA,L_DATA_Other = 从PCAP文件中提取TCP有效数据_生成以SeqLen为KEY的字典(PCAP_File_OR_Dir, P_Seq)
Log.info(f"=====[ HTTP请求 ACK={C_请求_ACK} ]=====")
MBF = 根据SEQ整理组装数据为MBF(D_HTTP['D_C_ACK_DATA'][C_请求_ACK], D_Seq_Len_DATA)
try:
MBF_HTTP_TEXT_C_ALL(MBF, FileSaveDir)
except:
Log.error(f"=====[ 不是HTTP请求格式 ]=====")
if S_响应_ACK != '-':
Log.info(f"=====[ HTTP响应 ACK={S_响应_ACK} ]=====")
MBF = 根据SEQ整理组装数据为MBF(D_HTTP['D_S_ACK_DATA'][S_响应_ACK], D_Seq_Len_DATA)
try:
MBF_HTTP_TEXT_S_ALL(MBF, FileSaveDir)
except:
Log.error(f"=====[ 不是HTTP响应格式 ]=====")
else:
Log.info(f"=====[ HTTP响应 未找到 ]=====")
else: ## 没有抓到请求，只抓到响应
## 收集本次需要用到的响应数据包的Seq
P_Seq = set()
D_HTTP = D_TCP_ALL[TCP会话KEY]
for i in D_HTTP['D_S_ACK_DATA'][S_响应_ACK]:
Seq = i[1]
P_Seq.add(Seq)
## 收集本次需要用到的请求和响应数据包的有效数据，做成字典
D_Seq_Len_DATA,L_DATA_Other = 从PCAP文件中提取TCP有效数据_生成以SeqLen为KEY的字典(PCAP_File_OR_Dir, P_Seq)
Log.info(f"=====[ HTTP请求 未找到 ]=====")
Log.info(f"=====[ HTTP响应 ACK={S_响应_ACK} ]=====")
MBF = 根据SEQ整理组装数据为MBF(D_HTTP['D_S_ACK_DATA'][S_响应_ACK], D_Seq_Len_DATA)
try:
MBF_HTTP_TEXT_S_ALL(MBF, FileSaveDir)
except:
Log.error(f"=====[ 不是HTTP响应格式 ]=====")
def 解析用户输入的编号(TEXT):
TEXT = TEXT.replace(' ', '')
L = []
LSPa = TEXT.split(',')
#print("LSPa", LSPa)
for i in LSPa:
if i != '':
LSPb = i.split('-')
if len(LSPb) == 2:
A = int(LSPb[0])
B = int(LSPb[1])
if A <= B:
for j in range(A, B+1):
L.append(j)
elif len(LSPb) == 1:
#print("LSPb", LSPb)
A = int(LSPb[0])
L.append(A)
else:
pass
return(L)
## 交互操作提示内容
## 【0】选择日志等级(写入日志文件)
选择日志等级_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: 0 DEBUG 日志记录详细信息 ::
:: 1 INFO 日志记录主要信息并在终端显示 ::
:: 2 WARNING ::
:: 3 ERROR ::
:: 4 CRITICAL ::
:: q 退出 ::
::::::::::::::::::::::::::::::::::::::::::::::
【0】选择日志等级(写入日志文件): '''
## 【1】选择过滤规则
选择过滤规则_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: 0 IP ::
:: 1 PORT ::
:: 2 IP+PORT ::
:: 3 ALL (全部提取分析) ::
:: q 返回上级 ::
::::::::::::::::::::::::::::::::::::::::::::::
【1】选择过滤规则: '''
## 【2】选择TCP或UDP
选择TCP或UDP_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: t 查看TCP ::
:: u 查看UDP ::
:: t2p 每个TCP会话导出为单独PCAP文件 ::
:: u2p 每个UDP会话导出为单独PCAP文件 ::
:: q 返回上级 ::
::::::::::::::::::::::::::::::::::::::::::::::
【2】选择TCP或UDP: '''
## 【4】选择TCP解析功能
TCP选择功能_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: 0 TCP会话交互过程用时分析(无图) ::
:: 1 TCP会话交互过程用时分析(画图) ::
:: 2 选中TCP会话导出为PCAP文件 ::
:: 3 全部TCP会话导出为PCAP文件 ::
:: 4 显示会话中每次交互信息 ::
:: q 返回上级 ::
::::::::::::::::::::::::::::::::::::::::::::::
【4】选择TCP解析功能: '''
## 【4】选择UDP解析功能
UDP选择功能_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: 0 选中UDP会话导出为PCAP文件 ::
:: q 返回上级 ::
::::::::::::::::::::::::::::::::::::::::::::::
【4】选择UDP解析功能: '''
## 【5】选择TCP交互选择功能
TCP交互选择功能_TEXT = '''
::::::::::::::::::::::::::::::::::::::::::::::
:: tcp TCP会话交互数据解析 ::
:: udp UDP会话交互数据解析 ::
:: http 尝试以HTTP协议解析 ::
:: https 尝试以HTTPS协议解析 ::
:: mysql 尝试以MySQL协议解析 ::
:: q 返回上级 ::
::::::::::::::::::::::::::::::::::::::::::::::
【4】选择TCP交互解析方式: '''
## D_TCP_PACKET 用于显示交互的实际Bytes
def 显示_选择TCP会话编号(L_TCP_SESSION_KEY, D_TCP_PACKET, 筛选=''):
设置CMD颜色(暗天蓝色)
N = 0
print("----------------------------------------------------------------------------")
print("|【TCP】会话信息")
print("----------------------------------------------------------------------------")
print("| 编号 源地址:端口 目的地址:端口 Bytes=> | <=Bytes")
print("----------------------------------------------------------------------------")
if 筛选 == '':
for i in L_TCP_SESSION_KEY:
SIP,SPORT,DIP,DPORT = i
方向1Bytes = D_TCP_PACKET[i]['Bytes_Len']
if (DIP,DPORT,SIP,SPORT) in D_TCP_PACKET: # 判断是否有反方向流量
方向2Bytes = D_TCP_PACKET[(DIP,DPORT,SIP,SPORT)]['Bytes_Len']
else:
方向2Bytes = 0
print(f"| {N:<4} {SIP:>15}:{SPORT:<5} <=> {DIP:>15}:{DPORT:<5} {方向1Bytes:<9} {方向2Bytes:9}")
N += 1
print("----------------------------------------------------------------------------")
print(f"| TCP会话总数 {N}")
print("----------------------------------------------------------------------------")
else:
匹配规则 = f"(.*){筛选}(.*)"
n = 0
for i in L_TCP_SESSION_KEY:
X = re.search(匹配规则, str(i))
if X:
SIP,SPORT,DIP,DPORT = i
方向1Bytes = D_TCP_PACKET[i]['Bytes_Len']
if (DIP,DPORT,SIP,SPORT) in D_TCP_PACKET: # 判断是否有反方向流量
方向2Bytes = D_TCP_PACKET[(DIP,DPORT,SIP,SPORT)]['Bytes_Len']
else:
方向2Bytes = 0
print(f"| {N:<4} {SIP:>15}:{SPORT:<5} <=> {DIP:>15}:{DPORT:<5} {方向1Bytes:<9} {方向2Bytes:9}")
n += 1
N += 1
print("----------------------------------------------------------------------------")
print(f"| 匹配字符串='{筛选}'")
print("----------------------------------------------------------------------------")
print(f"| 筛选出TCP会话数 {n}")
print("----------------------------------------------------------------------------")
设置CMD颜色(金色)
print("::::::::::::::::::::::::::::::::::::::::::::::")
print(": x 画流量图 - s 筛选结果 - q 返回上级 :")
print(": 输入会话编号分析会话用时信息(例 0,1,3-5) :")
print("::::::::::::::::::::::::::::::::::::::::::::::")
设置CMD颜色(白色)
def 显示_选择UDP会话编号(L_UDP_SESSION_KEY, D_UDP_PACKET, 筛选=''):
设置CMD颜色(暗天蓝色)
N = 0
print("----------------------------------------------------------------------------")
print("| UDP交互信息")
print("| 编号 源地址:端口 目的地址:端口 Bytes=> | <=Bytes")
if 筛选 == '':
for i in L_UDP_SESSION_KEY:
SIP,SPORT,DIP,DPORT = i
方向1Bytes = D_UDP_PACKET[i]['Bytes_Len']
if (DIP,DPORT,SIP,SPORT) in D_UDP_PACKET: # 判断是否有反方向流量
方向2Bytes = D_UDP_PACKET[(DIP,DPORT,SIP,SPORT)]['Bytes_Len']
else:
方向2Bytes = 0
print(f"| {N:<4} {SIP:>15}:{SPORT:<5} <=> {DIP:>15}:{DPORT:<5} {方向1Bytes:<9} {方向2Bytes:9}")
N += 1
print(f"| UDP会话总数 {N}")
print("----------------------------------------------------------------------------")
else:
匹配规则 = f"(.*){筛选}(.*)"
n = 0
for i in L_UDP_SESSION_KEY:
X = re.search(匹配规则, str(i))
if X:
SIP,SPORT,DIP,DPORT = i
方向1Bytes = D_UDP_PACKET[i]['Bytes_Len']
if (DIP,DPORT,SIP,SPORT) in D_UDP_PACKET: # 判断是否有反方向流量
方向2Bytes = D_UDP_PACKET[(DIP,DPORT,SIP,SPORT)]['Bytes_Len']
else:
方向2Bytes = 0
print(f"| {N:<4} {SIP:>15}:{SPORT:<5} <=> {DIP:>15}:{DPORT:<5} {方向1Bytes:<9} {方向2Bytes:9}")
n += 1
N += 1
print(f"| 匹配字符串={筛选}")
print(f"| 筛选出UDP会话数 {n}")
print("----------------------------------------------------------------------------")
设置CMD颜色(金色)
print("::::::::::::::::::::::::::::::::::::::::::::::")
print(": x 画流量图 - s 筛选结果 - q 返回上级 :")
print(": 输入会话编号分析会话用时信息(例 0,1,3-5) :")
print("::::::::::::::::::::::::::::::::::::::::::::::")
设置CMD颜色(白色)
def 显示_选择TCP会话中交互编号(L_交互信息):
设置CMD颜色(暗天蓝色)
N = 0
print("------------------------------------------------------------------------------------------------------------")
print("|【TCP】会话中交互信息")
print("| 编号 请求Ack 包数 字节 响应Ack 包数 字节 TCP会话")
print("------------------------------------------------------------------------------------------------------------")
for i in L_交互信息:
请求ACK, 请求Packets, 请求Bytes, 响应ACK, 响应Packets, 响应Bytes, TCP会话 = i
print(f"| {N:<4} {请求ACK:10} {请求Packets:5} {请求Bytes:8} {响应ACK:10} {响应Packets:5} {响应Bytes:8} {TCP会话}")
N += 1
print("------------------------------------------------------------------------------------------------------------")
print(f"| TCP会话总数 {N}")
print("------------------------------------------------------------------------------------------------------------")
设置CMD颜色(金色)
print(":::::::::::::::::::::::::::::::::::::::")
print(": q 返回上级 :")
print(": 选择TCP会话中交互编号(例 0,1,3-5) :")
print(":::::::::::::::::::::::::::::::::::::::")
设置CMD颜色(白色)
def 显示_选中TCP会话信息(L_会话编号, L_TCP_SESSION_KEY, D_TCP_PACKET):
设置CMD颜色(红色)
可用编号范围 = [i for i in range(0, len(L_TCP_SESSION_KEY))]
L_可用会话编号 = []
print("----------------------------------------------------------------------------")
print("| 已选【TCP】会话")
print("----------------------------------------------------------------------------")
print("| 编号 源地址:端口 目的地址:端口 Bytes=> | <=Bytes")
print("----------------------------------------------------------------------------")
for n in L_会话编号:
if n in 可用编号范围:
SIP,SPORT,DIP,DPORT = L_TCP_SESSION_KEY[n]
方向1Bytes = D_TCP_PACKET[(SIP,SPORT,DIP,DPORT)]['Bytes_Len']
if (DIP,DPORT,SIP,SPORT) in D_TCP_PACKET: # 判断是否有反方向流量
方向2Bytes = D_TCP_PACKET[(DIP,DPORT,SIP,SPORT)]['Bytes_Len']
else:
方向2Bytes = 0
print(f"| {n:<4} {SIP:>15}:{SPORT:<5} <=> {DIP:>15}:{DPORT:<5} {方向1Bytes:<9} {方向2Bytes:9}")
L_可用会话编号.append(n)
else:
print(f"| {n:<4} 编号不存在，忽略")
print("----------------------------------------------------------------------------")
设置CMD颜色(白色)
return(L_可用会话编号)
def 显示_选中UDP会话信息(L_会话编号, L_UDP_SESSION_KEY):
设置CMD颜色(暗天蓝色)
可用编号范围 = [i for i in range(0, len(L_UDP_SESSION_KEY))]
L_可用会话编号 = []
print("-------------------------------------------------------------")
print("| 已选【UDP】会话编号")
for n in L_会话编号:
if n in 可用编号范围:
print(f"| {n}\t{L_UDP_SESSION_KEY[n]}")
L_可用会话编号.append(n)
else:
print(f"| {n}\t编号不存在，忽略")
print("-------------------------------------------------------------")
设置CMD颜色(白色)
return(L_可用会话编号)
def 显示_选中交互信息(L_交互信息, L_交互编号):
设置CMD颜色(红色)
可用交互编号范围 = [i for i in range(0, len(L_交互信息))]
L_可用交互编号 = []
print("------------------------------------------------------------------------------------------------------------")
print("| 已选交互编号")
print("| 编号 请求Ack 包数 字节 响应Ack 包数 字节 TCP会话")
print("------------------------------------------------------------------------------------------------------------")
for n in L_交互编号:
if n in 可用交互编号范围:
请求ACK, 请求Packets, 请求Bytes, 响应ACK, 响应Packets, 响应Bytes, TCP会话 = L_交互信息[n]
#print(f"| {n}\t{L_交互信息[n]}")
print(f"| {n:<4} {请求ACK:10} {请求Packets:5} {请求Bytes:8} {响应ACK:10} {响应Packets:5} {响应Bytes:8} {TCP会话}")
L_可用交互编号.append(n)
else:
print(f"| {n:<4} 编号不存在，忽略")
print("------------------------------------------------------------------------------------------------------------")
设置CMD颜色(白色)
return(L_可用交互编号)
## 交互运行
def RUN(LOG_DIR):
while 1:
设置CMD颜色(金色)
选择日志等级 = input(选择日志等级_TEXT)
设置CMD颜色(白色)
if 选择日志等级 == '0':
Log.setLevel(logging.DEBUG)
elif 选择日志等级 == '1':
Log.setLevel(logging.INFO)
elif 选择日志等级 == '2':
Log.setLevel(logging.WARNING)
elif 选择日志等级 == '3':
Log.setLevel(logging.ERROR)
elif 选择日志等级 == '4':
Log.setLevel(logging.CRITICAL)
elif 选择日志等级 == 'q':
break
else:
print("【W】请重新选择")
continue
while 1:
UserIP = ''
UserPort = 0
设置CMD颜色(金色)
选择过滤规则 = input(选择过滤规则_TEXT)
设置CMD颜色(白色)
if 选择过滤规则 == '0':
匹配内容 = 'IP'
UserIP = input(" 匹配IP: ")
elif 选择过滤规则 == '1':
匹配内容 = 'PORT'
UserPort = input(" 匹配PORT: ")
UserPort = int(UserPort)
elif 选择过滤规则 == '2':
匹配内容 = 'IP+PORT'
UserIP = input(" 匹配IP: ")
UserPort = input(" 匹配PORT: ")
UserPort = int(UserPort)
elif 选择过滤规则 == '3':
匹配内容 = 'ALL'
elif 选择过滤规则 == 'q':
break
else:
print("【W】请重新选择")
continue
设置CMD颜色(红色)
print(f" 选择过滤规则: {选择过滤规则} 匹配: {匹配内容}")
设置CMD颜色(白色)
## 每个会话解析为TCP会话信息字典
D_TCP_ALL, D_TIME_PACKET, D_TCP_PACKET, D_UDP_ALL, D_UDP_PACKET = 提取PCAP中指定TCP会话数据(PCAP_File_OR_Dir, SaveDir, 匹配内容, UserIP, UserPort)
L_TCP_SESSION_KEY = TCP会话Key去重(D_TCP_ALL)
L_UDP_SESSION_KEY = UDP会话Key去重(D_UDP_ALL)
设置CMD颜色(绿色)
print(f" TCP会话数量: {len(L_TCP_SESSION_KEY)}")
print(f" UDP会话数量: {len(L_UDP_SESSION_KEY)}")
设置CMD颜色(白色)
## 循环多次查看分析结果
while 1:
匹配字符串 = '' # 初始化筛选匹配字符串
设置CMD颜色(金色)
选择TCP或UDP = input(选择TCP或UDP_TEXT).lower() # 输入结果转成小写字母
设置CMD颜色(白色)
if 选择TCP或UDP == 'q':
print("返回上级")
break
elif 选择TCP或UDP == 't':
while 1:
## 选择会话编号或操作指令
if '匹配字符串' not in locals(): # 判断变量是否存在
匹配字符串 = ''
显示_选择TCP会话编号(L_TCP_SESSION_KEY, D_TCP_PACKET, 匹配字符串)
选择会话编号或操作指令 = input("【3】选择要分析的会话编号: ")
if 选择会话编号或操作指令 == 'q':
print("返回上级")
break
elif 选择会话编号或操作指令 == 's':
匹配字符串 = input("匹配字符串: ")
elif 选择会话编号或操作指令 == 'x':
过滤出的包数据画流量图(D_TCP_PACKET, D_TIME_PACKET)
else:
## 检查用户输入
L_会话编号 = 解析用户输入的编号(选择会话编号或操作指令)
L_可用会话编号 = 显示_选中TCP会话信息(L_会话编号, L_TCP_SESSION_KEY, D_TCP_PACKET)
while 1:
设置CMD颜色(金色)
TCP选择功能 = input(TCP选择功能_TEXT)
设置CMD颜色(白色)
if TCP选择功能 == 'q':
print("返回上级")
break
elif TCP选择功能 == '0': ## 0 TCP会话交互过程用时分析(无图)
图 = 0
TCP会话交互过程用时分析(L_可用会话编号, L_TCP_SESSION_KEY, D_TCP_ALL, 图, 选择日志等级)
elif TCP选择功能 == '1': ## 1 TCP会话交互过程用时分析(画图)
图 = 1
TCP会话交互过程用时分析(L_可用会话编号, L_TCP_SESSION_KEY, D_TCP_ALL, 图, 选择日志等级)
elif TCP选择功能 == '2': ## 2 选中TCP会话导出为PCAP文件
D_SESSION_INFO = {'TCP':[], 'UDP':[]}
for i in L_可用会话编号:
SIP,SPORT,DIP,DPORT = L_TCP_SESSION_KEY[i]
D_SESSION_INFO['TCP'].append(L_TCP_SESSION_KEY[i])
D_SESSION_INFO['TCP'].append((DIP,DPORT,SIP,SPORT))
设置CMD颜色(绿色)
提取PCAP中指定会话数据另存为独立PCAP(PCAP_File_OR_Dir, SaveDir, D_SESSION_INFO)
设置CMD颜色(白色)
elif TCP选择功能 == '3': ## 3 全部TCP会话导出为PCAP文件
print("【I】请返回上级的上级使用 [t2p 每个TCP会话导出为单独PCAP文件] 功能")
elif TCP选择功能 == '4': ## 4 显示会话中每次交互信息
while 1:
print("显示会话中每次交互信息")
L_交互信息 = 显示会话中每次交互信息(L_可用会话编号, L_TCP_SESSION_KEY, D_TCP_ALL, 选择日志等级)
设置CMD颜色(暗天蓝色)
显示_选择TCP会话中交互编号(L_交互信息)
设置CMD颜色(白色)
选择交互编号或操作指令 = input("【5】选择要分析的交互编号: ")
if 选择交互编号或操作指令 == 'q':
print("返回上级")
break
else:
## 解析用户输入
L_交互编号 = 解析用户输入的编号(选择交互编号或操作指令)
L_可用交互编号 = 显示_选中交互信息(L_交互信息, L_交互编号)
while 1:
设置CMD颜色(金色)
TCP交互选择功能 = input(TCP交互选择功能_TEXT).lower()
设置CMD颜色(白色)
if TCP交互选择功能 == 'q':
print("返回上级")
break
elif TCP交互选择功能 == 'tcp': ## TCP会话交互数据解析
设置CMD颜色(绿色)
TCP会话交互数据解析(L_可用交互编号, L_交互信息, PCAP_File_OR_Dir, D_TCP_ALL, ROOT_DIR)
设置CMD颜色(白色)
elif TCP交互选择功能 == 'udp': ## UDP会话交互数据解析
print("【W】未实现")
elif TCP交互选择功能 == 'http': ## 尝试以HTTP协议解析
设置CMD颜色(绿色)
尝试以HTTP协议解析(L_可用交互编号, L_交互信息, PCAP_File_OR_Dir, D_TCP_ALL, ROOT_DIR)
设置CMD颜色(白色)
elif TCP交互选择功能 == 'https': ## 尝试以HTTPS协议解析
print("【W】未实现")
elif TCP交互选择功能 == 'mysql': ## 尝试以MySQL协议解析
print("【W】未实现")
else:
print("【W】请重新选择")
continue
else:
print("【W】请重新选择")
continue
elif 选择TCP或UDP == 'u':
while 1:
## 选择会话编号或操作指令
if '匹配字符串' not in locals(): # 判断变量是否存在
匹配字符串 = ''
显示_选择UDP会话编号(L_UDP_SESSION_KEY, D_UDP_PACKET, 匹配字符串)
选择会话编号或操作指令 = input("【3】选择要分析的会话编号: ")
if 选择会话编号或操作指令 == 'q':
print("返回上级")
break
elif 选择会话编号或操作指令 == 's':
匹配字符串 = input("匹配字符串: ")
else:
## 检查用户输入
L_会话编号 = 解析用户输入的编号(选择会话编号或操作指令)
L_可用会话编号 = 显示_选中UDP会话信息(L_会话编号, L_UDP_SESSION_KEY)
while 1:
UDP选择功能 = input(UDP选择功能_TEXT)
if UDP选择功能 == 'q':
print("返回上级")
break
elif UDP选择功能 == '0':
D_SESSION_INFO = {'TCP':[], 'UDP':[]}
for i in L_可用会话编号:
SIP,SPORT,DIP,DPORT = L_UDP_SESSION_KEY[i]
D_SESSION_INFO['UDP'].append(L_UDP_SESSION_KEY[i])
D_SESSION_INFO['UDP'].append((DIP,DPORT,SIP,SPORT))
设置CMD颜色(绿色)
提取PCAP中指定会话数据另存为独立PCAP(PCAP_File_OR_Dir, SaveDir, D_SESSION_INFO)
设置CMD颜色(白色)
else:
print("【W】请重新选择")
continue
elif 选择TCP或UDP == 't2p':
设置CMD颜色(绿色)
print("【W】数量多时比较耗时且执行不稳定")
D_SESSION_INFO = {'TCP':[], 'UDP':[]}
for i in D_TCP_ALL: # 取全部TCP
D_SESSION_INFO['TCP'].append(i) # 取全部TCP
提取PCAP中指定会话数据另存为独立PCAP(PCAP_File_OR_Dir, SaveDir, D_SESSION_INFO)
设置CMD颜色(白色)
elif 选择TCP或UDP == 'u2p':
设置CMD颜色(绿色)
print("【W】数量多时比较耗时且执行不稳定")
D_SESSION_INFO = {'TCP':[], 'UDP':[]}
for i in D_UDP_ALL: # 取全部UDP
D_SESSION_INFO['UDP'].append(i) # 取全部UDP
提取PCAP中指定会话数据另存为独立PCAP(PCAP_File_OR_Dir, SaveDir, D_SESSION_INFO)
设置CMD颜色(白色)
else:
print("【W】请重新选择")
continue
## 设置保存文件的根目录
ROOT_DIR = 'A:\\TEST\\'
if os.path.exists(ROOT_DIR):
if os.path.isdir(ROOT_DIR):
print(f"已经存在ROOT_DIR={ROOT_DIR}但是文件")
else:
print(f"已经存在ROOT_DIR={ROOT_DIR}但是文件")
exit()
else:
print(f"新建根目录 ROOT_DIR={ROOT_DIR}")
os.makedirs(ROOT_DIR)
## 设置日志
LOG_DIR = ROOT_DIR + 'LOG\\' # 设置日志文件存放目录
if not os.path.exists(LOG_DIR):
os.makedirs(LOG_DIR)
Log = logging.getLogger("Main")
LOG_FILE = LOG_DIR + time.strftime('%Y-%m-%d_%H%M%S')+'.log'
formatter = logging.Formatter('%(message)s') # 指定logger输出格式
file_handler = logging.FileHandler(LOG_FILE,encoding='UTF8') # 日志文件路径和编码
file_handler.setFormatter(formatter) # 可以通过setFormatter指定输出格式
Log.addHandler(file_handler)
#Log.setLevel(logging.DEBUG) # 日志等级 DEBUG INFO WARNING ERROR CRITICAL 在交互时设置
## 日志内容同时在终端显示
console = logging.StreamHandler()
console.setLevel(logging.INFO) # INFO级日志打印到终端
Log.addHandler(console)
## 设置PCAP文件或目录位置
#PCAP_File_OR_Dir = ROOT_DIR + 'test.pcap' # PCAP文件位置
PCAP_File_OR_Dir = ROOT_DIR # PCAP目录位置
SaveDir = ROOT_DIR + 'PCAP_Save\\' # 拆分PCAP文件时存放的目录位置
视角 = 'S'
设置CMD颜色(暗天蓝色)
print(ReadMe)
设置CMD颜色(白色)
RUN(LOG_DIR)
5112
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
