用python实现wireshark的follow tcp stream功能

长话短说，wireshark有一个follow tcp stream功能，这个功能很方便。美中不足的是提取出的stream 数据没有时间戳等其他信息，在分析数据的延时和丢包问题时就有些力不从心了。这里简单用python实现了一个简单follow tcp stream功能，同时保留了tcp信息。

原理很简单，仍然是基于wireshark，里面有一个Export packet dissection as XML ‘pdml’ file。 导出来之后的文件内容是这个样子的：

<proto name="tcp" showname="Transmission Control Protocol, Src Port: 59203 (59203), Dst Port: 80 (80), Seq: 1, Ack: 1, Len: 381" size="20" pos="34">
    <field name="tcp.srcport" showname="Source Port: 59203 (59203)" size="2" pos="34" show="59203" value="e743"/>
    <field name="tcp.dstport" showname="Destination Port: 80 (80)" size="2" pos="36" show="80" value="0050"/>
    <field name="tcp.port" showname="Source or Destination Port: 59203" hide="yes" size="2" pos="34" show="59203" value="e743"/>
    <field name="tcp.port" showname="Source or Destination Port: 80" hide="yes" size="2" pos="36" show="80" value="0050"/>
    <field name="tcp.stream" showname="Stream index: 4" size="0" pos="34" show="4"/>
    <field name="tcp.len" showname="TCP Segment Len: 381" size="1" pos="46" show="381" value="50"/>
    <field name="tcp.seq" showname="Sequence number: 1    (relative sequence number)" size="4" pos="38" show="1" value="3b0ac4bd"/>
    <field name="tcp.nxtseq" showname="Next sequence number: 382    (relative sequence number)" size="0" pos="34" show="382"/>
    <field name="tcp.ack" showname="Acknowledgment number: 1    (relative ack number)" size="4" pos="42" show="1" value="397d7582"/>
    <field name="tcp.hdr_len" showname="Header Length: 20 bytes" size="1" pos="46" show="20" value="50"/>

看到上面的内容，我想什么都不用说了。用python简单的做个xml文件解析，将数据提取出来就可以了。

那么剩下的一个问题就是follow tcp stream 这个算法如何实现？本质就是一个tcp数据如何重组的过程，具体可以参考这篇博文TCP数据包重组实现分析

这里，简单起见，我做了一些约束：

1.  只能提取A-->B这样的单个方向的数据。如果需要提取B-->A的数据，可以重新过滤一下数据，然后执行一次脚本。
2. 忽略最开头的syn包和断开连接时的Fin包。

基于上面两个简化，实际算法可以简化为根据tcp帧中的seq，从小到大排序。简单举个例子：有三个tcp包，按seq排序后如下样子

(seq=1, nxtseq=5, data='1234') , (seq=4, nxt=6, data='45') , (seq=7,nxt=8, data='7')

第一个数据包的nxtseq > 第二个数据的seq，说明两个数据包之间有数据重复，事实也是如此，重复了数字‘4’

第二个数据包的nxtseq < 第三个数据包的seq，说明这两个数据包之间有丢帧。事实也是如此，丢失了数字‘6’

好了，原理就介绍到这儿。

剩下稍微介绍一下wireshark过滤规则和这个算法的局限性

1. 按照ip过滤某个方向的数据，一般可以使先执行wireshark的follow tcp stream功能，一般在filter一栏会有这样一个表达式 tcp.stream eq xxx。在这个表达式的后面可以继续跟上ip过滤的表达式：  tcp.steam eq xxx and ip.src==xxx  and ip.dst==xxx
2. 按照tcp端口号过滤某个方向的数据。首先同ip过滤，先固定到一条tcp连接上,得到tcp.stream eq xxx。 然后加上端口过滤：tcp.stream eq xxx and tcp.srcport==xxx and tcp.dstport==xxx
3. 这个工具的局限性，因为是基于python element tree 对xml文件进行解析和数据提取，所以即使是解析100M的pcap文件，首先生成的pdml文件就会暴增到几百兆，然后这几百兆的文件又要被读入内存，（python element tree的特点），总计下来就是生成pdml文件有点慢（几分钟），内存消耗特大，几百兆。

最后简单贴一些关键代码。完整的脚本可以从这里免费下载 TCPParser -- follow tcp stream by python

这是从pdml文件的某个proto中提取需要的元素信息。

def extract_element(self, proto, elem):
        result = dict()
        for key in elem.keys():
            result[key]=""
        
        fieldname   = ""
        attribname  = ""    
        for field in proto.findall("field"):
            fieldname = field.get('name')
            if fieldname in elem:
                attribname = elem[fieldname]
                result[fieldname] = field.get(attribname, '')
                
        return result

def regularize_stream(self, frame_list):
        '''
                    正则化tcp stream的数据，主要是根据seq，nxtseq补上缺少的segment，以及删除重复的数据
                    不少缺少的segment时，data为空，frame.number='lost'
                    删除重复的数据时，尽可能保留较早之前收到的数据，也就是前一个包的数据
        '''
        self.reporter.title("TCPParser regularize timestamp")
        timer = Timer("regularize_stream_data").start()
        reg_frame_list = []
        expectseq = -1
        first = True
        for frame in frame_list:
            if first:
                # 第一个数据包
                first = False
                expectseq = frame["tcp.nxtseq"]
                reg_frame_list.append(frame)
                continue
            
            # 从第二个数据包开始
            seq = frame["tcp.seq"]
            nxtseq = frame["tcp.nxtseq"]
            if seq == expectseq :
                # 数据刚好，完全连续，不多不少
                if nxtseq == 0: continue # 表示ack包，无意义
                expectseq = nxtseq
                reg_frame_list.append(frame)
            elif seq > expectseq:
                # 数据有缺失，说明丢包了
                self.reporter.error("previous tcp segment is lost: " + str(frame[TCPFrame.KEY_FRAMENo]))
#                newpacket = self.new_lost_packet(frame, str(expectseq), str(seq))
#                reg_frame_list.append(newpacket)
                reg_frame_list.append(frame)
                expectseq = nxtseq
                
            elif seq < expectseq:
                # 数据有重叠，数据重传时补传过多数据了
                self.reporter.warning("tcp segment retransmission: " + str(frame[TCPFrame.KEY_FRAMENo]))
                if expectseq < nxtseq:
                    # 当前数据包需要舍弃一部分内容
                    # pre_packet[-(expectseq-seq):-1] == frame[0:expectseq-seq]
                    frame["tcp.seq"] = expectseq 
                    frame["data"] = frame["data"][expectseq-nxtseq:]
                    frame["datalen"] = len(frame["data"])
                    expectseq = nxtseq
                    reg_frame_list.append(frame)
                else:
                    # 当前数据包的内容可以完全舍弃
                    # expectseq 保持不变
                    # pre_packet[-(nxtseq-seq):] = frame[:nextseq-seq]
                    pass
        timer.stop()        
        return reg_frame_list