Python 抓包程序（pypcap）

#/usr/bin/env python
#-*-coding:utf8-*-

#抓包脚本
"""
This script is used to Capture and Analysis packets

Required dependencies:
 libpcap-devel
Installation:
rpm -ivh ../libpcap-devel-0.9.-.el5.i386.rpm
 pypcap
Installation:
tar zxvf pypcap-1.1.tar.gz
cd pypcap-1.1
CFLAGS=-m32 python setup.py config
CFLAGS=-m32 python setup.py build
CFLAGS=-m32 python setup.py install 

 iplist Format
iplist＝ 'ip/mask','ip/mask'  OR iplist＝ 'ip/mask',    #本脚本主要根据ip段分析内外网流量数据，我自定义一个函数用来解析子网掩码方式的ip段，这里支持多个ip段，也支持一个段，但是要加‘,’

Writer:Dongweiming

"""

import pcap
import socket
import struct
import ctypes
import datetime
import threading
import inspect
import traceback
from optparse import OptionParser
from subprocess import *
import sys,os
import time

iplist = '115.12.1.0/24','219.213.232.192/26'  #设置解析这2个段的ip列表

def _async_raise(tid, exctype):
    if not inspect.isclass(exctype):
        raise TypeError("Only types can be raised (not instances)")
    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
    if res == :
        raise ValueError("invalid thread id")
    elif res != :
        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, )
        raise SystemError("PyThreadState_SetAsyncExc failed")
def ipto(ip,ti):
    d = ti/
    c = /(**(ti%))
    ip_items = ip.split('.')
    if len(ip_items[d:]) == :
        if ti% == :
            cmin = '%s.%s' % ('.'.join(ip_items[:d]),'')
            cmax = '%s.%s' % ('.'.join(ip_items[:d]),'')
        else:
            for i in range(**(ti%)):
            mymax = (i+)*c-
            mymin=  i*c
            data =  int(''.join(ip_items[d:]))
            if data < mymax and data >= mymin:
                cmin = '%s.%s' % ('.'.join(ip_items[:d]),mymin)
                  cmax = '%s.%s' % ('.'.join(ip_items[:d]),mymax)
    else:
        if ti% == :
             cmin = '%s.%s.%s' % ('.'.join(ip_items[:d]),'',('0.'*(len(ip_items)-d-))[:-])
             cmax = '%s.%s.%s' % ('.'.join(ip_items[:d]),'',('255.'*(len(ip_items)-d-))[:-])
        else:
        for i in range(**(ti%)):
                mymax = (i+)*c-
                mymin=  i*c
            data =  int(''.join(ip_items[d]))
            if data < mymax and data >= mymin:
            cmin = '%s.%s.%s' % ('.'.join(ip_items[:d]),mymin,('0.'*(len(ip_items)-d-))[:-])
            cmax = '%s.%s.%s' % ('.'.join(ip_items[:d]),mymax,('255.'*(len(ip_items)-d-))[:-])
    return cmin,cmax  #返回ip段中可用的最小ip和最大ip

class MYthread(threading.Thread):  #自定义theading.Thread类，能够产生线程并且杀掉线程
    def _get_my_tid(self):
        if not self.isAlive():
            raise threading.ThreadError("the thread is not active")
        if hasattr(self, "_thread_id"):
            return self._thread_id

        for tid, tobj in threading._active.items():
            if tobj is self:
                self._thread_id = tid
                return tid
        raise AssertionError("could not determine the thread's id")
    def raise_exc(self, exctype):
        _async_raise(self._get_my_tid(), exctype)

    def terminate(self):
        self.raise_exc(SystemExit)
class Crawl():  #解析主函数
    def __init__(self,eth,mytime,flag):
        self.bytes =
        self.bytes_out =
        self.packets =
        self.packets_out =
        self.eth = eth
        self.mytime = mytime
        self.flag = flag
    def myntohl(self,ip):
        return socket.ntohl(struct.unpack("I",socket.inet_aton(ip))[])  #inet_aton 将ip地址的4段地址分别进行2进制转化，输出用16进制表示，
                                                     #unpack的处理是按16进制（4bit）将2进制字符，从后向前读入的，低位入
                                                     #ntohl, htonl 表示的是网络地址和主机地址之间的转换（network byte <==> host byte）
                                                     #由于unpack/pack的解/打包的颠倒顺序，必须通过htonl 或者 ntohl 进行处理
                                                     #比如从’192.168.1.235’ 可以转换为数字’’，此数字为网络字节序
    def check(self,dict,uip):
        flag =
        for i in dict.keys():
            if uip > self.myntohl(i) and uip < self.myntohl(dict[i]):  #如果抓取的uip属于ip段，flag＝，否则为0
#       if (uip > self.myntohl('') and uip < self.myntohl('')) or (self.myntohl('') and uip < self.myntohl('')):
                 flag =
        return flag
    def run(self):  #设置的抓取时间里pcap一直抓包，各个队列累加数值，最后除以时间，即平均
        dict = {}
        for i in iplist:
             d = i.split('/')
             cmin,cmax = ipto(d[],int(d[]))
             dict[cmin]=cmax  #这里记录一个字典，key是ip段最小的的ip，value是最大的ip

        if self.eth == 'all':
            pc = pcap.pcap()
        else:
            pc = pcap.pcap(self.eth)
        for ptime,pdata in pc:
            #try:
            #    ip_type = socket.ntohs(struct.unpack("H",pdata[:])[])  #
            #except:
            #     pass
              #if ip_type != 2048:
        #    continue
         s_uip = socket.ntohl(struct.unpack("I",pdata[+:+])[]) #源ip的网络字节序
        #d_uip = socket.ntohl(struct.unpack("I",pdata[+:+])[])  #目的ip的网络字节序
            bytes = socket.ntohs(struct.unpack("H",pdata[+:+])[])+ #数据的字节数
            if self.check(dict,s_uip):
            self.bytes_out += bytes
                self.packets_out +=
         else:
            self.bytes += bytes
                self.packets +=
    def withtime(self):
        pid =  os.getpid()
        name = sys.argv[]
        Popen("kill -9 `ps -ef |grep %s|grep -v grep |awk '{print $2}'|grep -v %d`" % (name,pid),stdout=PIPE, stderr=PIPE,shell=True) #这里是
                                     #在启动时候主动杀掉系统中存在的残留程序,使用中发现有时候（极少）执行时间到没有杀掉程序，为了定时任务安全
        self.t = MYthread(target = self.run)
        self.t.setDaemon()
        self.t.start()
        curtime = time.ctime(time.time())
        t =
        while t<int(self.mytime):
           t +=
           time.sleep()
        nowtime = time.ctime(time.time())
        data = "From[%s]To[%s]%s\n%s%s%s%s\n%s%s%s%s\n" \
        % (curtime,nowtime,u'数据统计'.encode('utf8'),u'出网总流量/s'.encode('utf8').ljust(,' '),\
           u'出网总数据包/s'.encode('utf8').ljust(,' '),u'进网总流量/s'.encode('utf8').ljust(,' '),\
           u'进网总数据包/s'.encode('utf8').ljust(,' '),str(int(self.bytes_out)/int(self.mytime)).ljust(,' '),\
           str(int(self.packets_out)/int(self.mytime)).ljust(,' '),str(int(self.bytes)/int(self.mytime)).ljust(,' '),\
           str(int(self.packets)/int(self.mytime)).ljust(,' '))
        if self.flag:
            print data
        self.log(data)
        self.t.terminate()
        self.t.join()

    def log(self,log):  #记录日志，使用－p选项只在记录，不在终端打印，用于定时任务等需求时（定时任务执行没必要输出）
        path = os.path.split(os.path.realpath(__file__))[]
        log_file = "%s/common.log" % path
        if not os.path.exists(log_file):
            f=open(log_file,'w')
            f.close()
        try:
            fr = open(log_file, "a+")
            fr.write(log+"\r\n")
        fr.close()
    except Exception, e:
            pass

if __name__ == '__main__':
    argc = len(sys.argv)
    parser = OptionParser(description="Use For Capture and Analysis packets",add_help_option=False,prog="sniffer.py",usage="%prog [ -e <ethname>][ -t <time>]")
    parser.add_option("-e", "--eth",action = "store",default = "all",help = "Select the card, the default is 'all'") #选择网卡，默认是all
    parser.add_option("-t", "--time",action = "store",default = ,help = "Select the capture time,the default is 5s")  #设置要抓包的时间，单位秒，时间越长越精确
    parser.add_option("-p", "--myprint",action = "store_false",default = True,help = "Print data, the default is true")
    parser.add_option("-h", "--help",action = "help",help="print help")
    options, arguments=parser.parse_args()
    a = Crawl(options.eth,options.time,options.myprint)
    a.withtime()

参考链接：https://old.dongwm.com/old/archives/pythonzhuabaochengxupypcap/