Python 抓包程序（pypcap）

#/usr/bin/env python
#-*-coding:utf8-*-#抓包脚本
"""
This script is used to Capture and Analysis packetsRequired 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 timeiplist = '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和最大ipclass 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:
passif __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()