㈠ python2.7 能安装libpcap（抓包）库吗
你好：
因该是可以的；
请问抱什么错误吗！
㈡ Python渗透测试工具都有哪些
网络
Scapy, Scapy3k: 发送，嗅探，分析和伪造网络数据包。可用作交互式包处理程序或单独作为一个库
pypcap, Pcapy, pylibpcap: 几个不同 libpcap 捆绑的python库
libdnet: 低级网络路由，包括端口查看和以太网帧的转发
dpkt: 快速，轻量数据包创建和分析，面向基本的 TCP/IP 协议
Impacket: 伪造和解码网络数据包，支持高级协议如 NMB 和 SMB
pynids: libnids 封装提供网络嗅探，IP 包碎片重组，TCP 流重组和端口扫描侦查
Dirtbags py-pcap: 无需 libpcap 库支持读取 pcap 文件
flowgrep: 通过正则表达式查找数据包中的 Payloads
Knock Subdomain Scan: 通过字典枚举目标子域名
SubBrute: 快速的子域名枚举工具
Mallory: 可扩展的 TCP/UDP 中间人代理工具，可以实时修改非标准协议
Pytbull: 灵活的 IDS/IPS 测试框架（附带超过300个测试样例）
调试和逆向工程
Paimei: 逆向工程框架，包含PyDBG, PIDA , pGRAPH
Immunity Debugger: 脚本 GUI 和命令行调试器
mona.py: Immunity Debugger 中的扩展，用于代替 pvefindaddr
IDAPython: IDA pro 中的插件，集成 Python 编程语言，允许脚本在 IDA Pro 中执行
PyEMU: 全脚本实现的英特尔32位仿真器，用于恶意软件分析
pefile: 读取并处理 PE 文件
pydasm: Python 封装的libdasm
PyDbgEng: Python 封装的微软 Windows 调试引擎
uhooker: 截获 DLL 或内存中任意地址可执行文件的 API 调用
diStorm: AMD64 下的反汇编库
python-ptrace: Python 写的使用 ptrace 的调试器
vdb/vtrace: vtrace 是用 Python 实现的跨平台调试 API, vdb 是使用它的调试器
Androguard: 安卓应用程序的逆向分析工具
Capstone: 一个轻量级的多平台多架构支持的反汇编框架。支持包括ARM,ARM64,MIPS和x86/x64平台
PyBFD: GNU 二进制文件描述(BFD)库的 Python 接口
Fuzzing
Sulley: 一个模糊器开发和模糊测试的框架，由多个可扩展的构件组成的
Peach Fuzzing Platform: 可扩展的模糊测试框架(v2版本 是用 Python 语言编写的)
antiparser: 模糊测试和故障注入的 API
TAOF: (The Art of Fuzzing, 模糊的艺术)包含 ProxyFuzz, 一个中间人网络模糊测试工具
untidy: 针对 XML 模糊测试工具
Powerfuzzer: 高度自动化和可完全定制的 Web 模糊测试工具
SMUDGE: 纯 Python 实现的网络协议模糊测试
Mistress: 基于预设模式，侦测实时文件格式和侦测畸形数据中的协议
Fuzzbox: 媒体多编码器的模糊测试
Forensic Fuzzing Tools: 通过生成模糊测试用的文件，文件系统和包含模糊测试文件的文件系统，来测试取证工具的鲁棒性
Windows IPC Fuzzing Tools: 使用 Windows 进程间通信机制进行模糊测试的工具
WSBang: 基于 Web 服务自动化测试 SOAP 安全性
Construct: 用于解析和构建数据格式(二进制或文本)的库
fuzzer.py(feliam): 由 Felipe Andres Manzano 编写的简单模糊测试工具
Fusil: 用于编写模糊测试程序的 Python 库
Web
Requests: 优雅，简单，人性化的 HTTP 库
HTTPie: 人性化的类似 cURL 命令行的 HTTP 客户端
ProxMon: 处理代理日志和报告发现的问题
WSMap: 寻找 Web 服务器和发现文件
Twill: 从命令行界面浏览网页。支持自动化网络测试
Ghost.py: Python 写的 WebKit Web 客户端
Windmill: Web 测试工具帮助你轻松实现自动化调试 Web 应用
FunkLoad: Web 功能和负载测试
spynner: Python 写的 Web浏览模块支持 Javascript/AJAX
python-spidermonkey: 是 Mozilla JS 引擎在 Python 上的移植，允许调用 Javascript 脚本和函数
mitmproxy: 支持 SSL 的 HTTP 代理。可以在控制台接口实时检查和编辑网络流量
pathod/pathoc: 变态的 HTTP/S 守护进程，用于测试和折磨 HTTP 客户端
㈢ python 怎么调用linux下的tcpmp
之前在linux用python脚本写一个抓包分析小工具，实在不想用什么libpcap、pypcap所以，简单来了个tcpmp加grep搞定。基本思路是分别起tcpmp和grep两个进程，进程直接通过pipe交换数据，简单代码如下：
[python] view plain
#! /usr/bin/python
def tcpmp():
import subprocess, fcntl, os
# sudo tcpmp -i eth0 -n -s 0 -w - | grep -a -o -E "Host: .*|GET /.*"
cmd1 = ['tcpmp', '-i', 'eth0', '-n','-B', '4096','-s', '0', '-w', '-']
cmd2 = ['grep', '--line-buffered', '-a', '-o', '-E', 'Host: .*|GET /.*']
p1 = subprocess.Popen(cmd1, stdout=subprocess.PIPE)
p2 = subprocess.Popen(cmd2, stdout=subprocess.PIPE, stdin=p1.stdout)
flags = fcntl.fcntl(p2.stdout.fileno(), fcntl.F_GETFL)
fcntl.fcntl(p2.stdout.fileno(), fcntl.F_SETFL, (flags | os.O_NDELAY | os.O_NONBLOCK))
return p2
def poll_tcpmp(proc):
#print 'poll_tcpmp....'
import select
txt = None
while True:
# wait 1/10 second
readReady, _, _ = select.select([proc.stdout.fileno()], [], [], 0.1)
if not len(readReady):
break
try:
for line in iter(proc.stdout.readline, ""):
if txt is None:
txt = ''
txt += line
except IOError:
print 'data empty...'
pass
break
return txt
proc = tcpmp()
while True:
text = poll_tcpmp(proc)
if text:
print '>>>> ' + text
㈣ 在linux下，python怎么才能抓到网卡上的所有TCP数据包
Ethereal 自带许多协议的 decoder,简单,易用,基于winpcap的一个开源的软件.但是它的架构并不灵活,如何你要加入一个自己定义的的解码器,得去修改 Ethereal的代码,再重新编译,很烦琐.对于一般的明文 协议,没有什么问题,但是对于加密协议,比如网络游戏,客户端程序一般会在刚连接上的时候,发送一个随机密钥,而后的报文都会用这个密钥进行加密,如此. 要想破解,得要有一个可编程的抓包器.
libpcap是一个不错的选择,但是对于抓包这样需要反复进行”试 验->修改”这个过程的操作,c 语言显然不是明智的选择.
Python提供了几个libpcapbind。在windows平台上,你需要先安装winpcap,如果你已经安装了Ethereal非常好用
一个规范的抓包过程
import pcap
import dpkt
pc=pcap.pcap() #注，参数可为网卡名，如eth0
pc.setfilter('tcp port 80') #设置监听过滤器
for ptime,pdata in pc: #ptime为收到时间，pdata为收到数据
print ptime,pdata #...
对抓到的以太网V2数据包(raw packet)进行解包
p=dpkt.ethernet.Ethernet(pdata)
if p.data.__class__.__name__=='IP':
ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))
if p.data.data.__class__.__name__=='TCP':
if data.dport==80:
print p.data.data.data # by gashero
一些显示参数
nrecv,ndrop,nifdrop=pc.stats()
返回的元组中，第一个参数为接收到的数据包，(by gashero)第二个参数为被核心丢弃的数据包。
㈤ python3.2 下的抓包库。。无论是pypcap还是scapy。貌似都没有py3的版本。。跪求一个可以python3用
有一个py3kcap是pycap的封装版本，可以用于python3版本。
给你一个使用的示例代码：
#!/usr/bin/env python3.2
import ctypes,sys
from ctypes.util import find_library
#pcap = ctypes.cdll.LoadLibrary("libpcap.so")
pcap = None
if(find_library("libpcap") == None):
print("We are here!")
pcap = ctypes.cdll.LoadLibrary("libpcap.so")
else:
pcap = ctypes.cdll.LoadLibrary(find_library("libpcap"))
# required so we can access bpf_program->bf_insns
"""
struct bpf_program {
u_int bf_len;
struct bpf_insn *bf_insns;}
"""
class bpf_program(ctypes.Structure):
_fields_ = [("bf_len", ctypes.c_int),("bf_insns", ctypes.c_void_p)]
class sockaddr(ctypes.Structure):
_fields_=[("sa_family",ctypes.c_uint16),("sa_data",ctypes.c_char*14)]
class pcap_pkthdr(ctypes.Structure):
_fields_ = [("tv_sec", ctypes.c_long), ("tv_usec", ctypes.c_long), ("caplen", ctypes.c_uint), ("len", ctypes.c_uint)]
pkthdr = pcap_pkthdr()
program = bpf_program()
# prepare args
snaplen = ctypes.c_int(1500)
#buf = ctypes.c_char_p(filter)
optimize = ctypes.c_int(1)
mask = ctypes.c_uint()
net = ctypes.c_uint()
to_ms = ctypes.c_int(100000)
promisc = ctypes.c_int(1)
filter = bytes(str("port 80"), 'ascii')
buf = ctypes.c_char_p(filter)
errbuf = ctypes.create_string_buffer(256)
pcap_close = pcap.pcap_close
pcap_lookupdev = pcap.pcap_lookupdev
pcap_lookupdev.restype = ctypes.c_char_p
#pcap_lookupnet(dev, &net, &mask, errbuf)
pcap_lookupnet = pcap.pcap_lookupnet
#pcap_t *pcap_open_live(const char *device, int snaplen,int promisc, int to_ms,
#char *errbuf
pcap_open_live = pcap.pcap_open_live
#int pcap_compile(pcap_t *p, struct bpf_program *fp,const char *str, int optimize,
#bpf_u_int32 netmask)
pcap_compile = pcap.pcap_compile
#int pcap_setfilter(pcap_t *p, struct bpf_program *fp);
pcap_setfilter = pcap.pcap_setfilter
#const u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h);
pcap_next = pcap.pcap_next
# int pcap_compile_nopcap(int snaplen, int linktype, struct bpf_program *program,
# const char *buf, int optimize, bpf_u_int32 mask);
pcap_geterr = pcap.pcap_geterr
pcap_geterr.restype = ctypes.c_char_p
#check for default lookup device
dev = pcap_lookupdev(errbuf)
#override it for now ..
dev = bytes(str("wlan0"), 'ascii')
if(dev):
print("{0} is the default interface".format(dev))
else:
print("Was not able to find default interface")
if(pcap_lookupnet(dev,ctypes.byref(net),ctypes.byref(mask),errbuf) == -1):
print("Error could not get netmask for device {0}".format(errbuf))
sys.exit(0)
else:
print("Got Required netmask")
handle = pcap_open_live(dev,snaplen,promisc,to_ms,errbuf)
if(handle is False):
print("Error unable to open session : {0}".format(errbuf.value))
sys.exit(0)
else:
print("Pcap open live worked!")
if(pcap_compile(handle,ctypes.byref(program),buf,optimize,mask) == -1):
# this requires we call pcap_geterr() to get the error
err = pcap_geterr(handle)
print("Error could not compile bpf filter because {0}".format(err))
else:
print("Filter Compiled!")
if(pcap_setfilter(handle,ctypes.byref(program)) == -1):
print("Error couldn't install filter {0}".format(errbuf.value))
sys.exit(0)
else:
print("Filter installed!")
if(pcap_next(handle,ctypes.byref(pkthdr)) == -1):
err = pcap_geterr(handle)
print("ERROR pcap_next: {0}".format(err))
print("Got {0} bytes of data".format(pkthdr.len))
pcap_close(handle)
㈥ 为什么很多人喜欢 Python
很多人关注起Python就是因为简单易懂，做Web很方便。但在深入CS学科的很多高级主题时，Python能发挥出更加强大无比的力量。而这来自于Python是个好胶水。
坦白讲，Python不算最好的胶水，至少Lua做胶水就比Python好，API好用。但Python再算上强大的标准库、数据结构、友好的转义后，就脱颖而出了。
在科学计算领域，NumPy和SciPy的存在解放了很多人的思想束缚。其底层C模块，性能一流。
而当你需要一流的性能与一流的可调试性时，Python C模块是最好的选择。封装虽然有些麻烦，但封装后可以在Python里调用实在太方便。一些已有的C/C++应用也可以通过将函数封装给Python调用，而极大的降低调试难度，提升单元测试覆盖率。
2007年时我开始学Python的C模块编程，并在博客中放出了我的笔记。那时写了不少东西。封装libpcap后，做网络抓包，通信劫持，使得别人眼里，我俨然是个正经黑客。后来迷恋erlang期间，做了C node的Python封装，使得Python与Erlang可以互发消息，组建集群。搞硬件开发期间，封装了Cubieboard和RaspberryPi的GPIO、SPI等众多外设的Python接口，调试速度快到了云边。做USB通信期间，因为PyUSB不支持isochronous通信而自己重写了个libusb的Python封装，使得USB编程不再困难。做音视频识别的日子里，做了v4l2的Python封装，使得操作摄像头的控制精度达到了最高。
相比于其他人，用上这些Python封装后，迭代速度数十倍的提高带来了系统进化速度的极大提高。比如我在音视频识别的研究期间，因为NumPy和我自己的封装，每天动则十几次甚至几十次的迭代，优化算法的各种参数。使得我在不到两年时间里，识别效果就超过可某大学教授12年的研究成果。识别速度更是超出对方两个数量级。
对于各个领域的研究者，我是真心推荐Python的。用上NumPy和SciPy，你就拥有了极致的性能，顶级的可调式性，和产品级的稳定性。而这也使得Python的这套组合成为科学计算领域唯一能与matlab竞争的选择。
㈦ python安装libpcap包问题 试了mingw是特定头文件和使用GNU工具集导入库的集合使用后出现要选择打开方式
你的python没有安装好。.py文件没有被注册成正确的python关联。你选择“始终使用”这个选项吧。
感觉怪怪的。通常我们安装都会顺利。
另外python所在的目录一定要放到系统环境变量的path里
㈧ 如何利用libpcap和Python嗅探数据包
一提到Python获取数据包的方式，相信很多Python爱好者会利用Linux的libpcap软件包或利用Windows下的WinPcap可移植版的方式进行抓取数据包，然后再利用dpkt软件包进行协议分析，我们这里想换一个角度去思考：
1. Python版本的pcap存储内存数据过小，也就是说缓存不够，在高并发下容易发生丢包现象，其实C版本的也同样存在这样的问题，只不过Python版本的缓存实在是过低，让人很郁闷。
2. dpkt协议分析并非必须，如果你对RFC 791和RFC 793等协议熟悉的话，完全可以使用struct.unpack的方式进行分析。
如果你平常习惯使用tcpmp抓取数据包的话，完全可以使用它来代替pcap软件包，只不过我们需要利用tcpmp将抓取的数据以pcap格式进行保存，说道这里大家一定会想到Wireshark工具，具体命令如下：
tcpmp dst 10.13.202.116 and tcp dst port 80 -s 0 -i eth1 -w ../pcap/tcpmp.pcap -C 1k -W 5
我们首先需要对pcap文件格式有所了解，具体信息大家可以参考其他资料文档，我这里只说其重要的结构体组成，如下：
sturct pcap_file_header
{
DWORD magic;
WORD version_major;
WORD version_minor;
DWORD thiszone;
DWORD sigfigs;
DWORD snaplen;
DWORD linktype;
}
struct pcap_pkthdr
{
struct timeval ts;
DWORD caplen;
DWORD len;
}
struct timeval
{
DWORD GMTtime;
DWORD microTime;
}
这里需要说明的一点是，因为在Python的世界里一切都是对象，所以往往Python在处理数据包的时候感觉让人比较麻烦。Python提供了几个libpcapbind,http://monkey.org/~gsong/pypcap/这里有 一个最简单的。在windows平台上,你需要先安装winpcap,如果你已经安装了Ethereal非常好用。一个规范的抓包过程:
import pcap
import dpkt
pc=pcap.pcap() #注，参数可为网卡名，如eth0
pc.setfilter('tcp port 80') #设置监听过滤器
for ptime,pdata in pc: #ptime为收到时间，pdata为收到数据
print ptime,pdata #...
对抓到的以太网V2数据包(raw packet)进行解包:
p=dpkt.ethernet.Ethernet(pdata)
if p.data.__class__.__name__=='IP':
ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))
if p.data.data.__class__.__name__=='TCP':
if data.dport==80:
print p.data.data.data
一些显示参数nrecv,ndrop,nifdrop=pc.stats()返回的元组中，第一个参数为接收到的数据包，第二个参数为被核心丢弃的数据包。
至于对于如何监控tcpmp生成的pcap文件数据，大家可以通过pyinotify软件包来实现，如下：
class Packer(pyinotify.ProcessEvent):
def __init__(self, proct):
self.proct = proct
self.process = None
def process_IN_CREATE(self, event):
logger.debug("create file: %s in queue" % self.process_IF_START_THREAD(event))
def process_IN_MODIFY(self, event):
self.process_IF_START_THREAD(event)
logger.debug("modify file: %s in queue" % self.process_IF_START_THREAD(event))
def process_IN_DELETE(self, event):
filename = os.path.join(event.path, event.name)
logger.debug("delete file: %s" % filename)
def process_IF_START_THREAD(self, event):
filename = os.path.join(event.path, event.name)
if filename != self.process:
self.process = filename
self.proct.put(filename)
if self.proct.qsize() > 1:
try:
logger.debug("create consumer proct.qsize: %s" % self.proct.qsize())
consumer = Consumer(self.proct)
consumer.start()
except Exception, errmsg:
logger.error("create consumer failed: %s" % errmsg)
return filename
class Factory(object):
def __init__(self, proct):
self.proct = proct
self.manager = pyinotify.WatchManager()
self.mask = pyinotify.IN_CREATE | pyinotify.IN_DELETE | pyinotify.IN_MODIFY
def work(self):
try:
try:
notifier = pyinotify.ThreadedNotifier(self.manager, Packer(self.proct))
notifier.start()
self.manager.add_watch("../pcap", self.mask, rec = True)
notifier.join()
except Exception, errmsg:
logger.error("create notifier failed: %s" % errmsg)
except KeyboardInterrupt, errmsg:
logger.error("factory has been terminated: %s" % errmsg)
在获得要分析的pcap文件数据之后，就要对其分析了，只要你足够了解pcap文件格式就可以了，对于我们来讲只需要获得TCP数据段的数据即可，如下：
class Writer(threading.Thread):
def __init__(self, proct, stack):
threading.Thread.__init__(self)
self.proct = proct
self.stack = stack
self.pcap_pkthdr = {}
def run(self):
while True:
filename = self.proct.get()
try:
f = open(filename, "rb")
readlines = f.read()
f.close()
offset = 24
while len(readlines) > offset:
self.pcap_pkthdr["len"] = readlines[offset+12:offset+16]
try:
length = struct.unpack("I", self.pcap_pkthdr["len"])[0]
self.stack.put(readlines[offset+16:offset+16+length])
offset += length + 16
except Exception, errmsg:
logger.error("unpack pcap_pkthdr failed: %s" % errmsg)
except IOError, errmsg:
logger.error("open file failed: %s" % errmsg)
在获得TCP数据段的数据包之后，问题就简单多了，根据大家的具体需求就可以进行相应的分析了，我这里是想分析其HTTP协议数据，同样也借助了dpkt软件包进行分析，如下：
def worker(memcache, packet, local_address, remote_address):
try:
p = dpkt.ethernet.Ethernet(packet)
if p.data.__class__.__name__ == "IP":
srcip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.src)))
dstip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.dst)))
if p.data.data.__class__.__name__ == "TCP":
tcpacket = p.data.data
if tcpacket.dport == 80 and dstip == local_address:
srcport = tcpacket.sport
key = srcip + ":" + str(srcport)
if tcpacket.data:
if not memcache.has_key(key):
memcache[key] = {}
if not memcache[key].has_key("response"):
memcache[key]["response"] = None
if memcache[key].has_key("data"):
memcache[key]["data"] += tcpacket.data
else:
memcache[key]["data"] = tcpacket.data
else:
if memcache.has_key(key):
memcache[key]["response"] = dpkt.http.Request(memcache[key]["data"])
try:
stackless.tasklet(connection)(memcache[key]["response"], local_address, remote_address)
stackless.run()
except Exception, errmsg:
logger.error("connect remote remote_address failed: %s", errmsg)
logger.debug("old headers(none content-length): %s", memcache[key]["response"])
memcache.pop(key)
except Exception, errmsg:
logger.error("dpkt.ethernet.Ethernet failed in worker: %s", errmsg)
如果大家只是想单纯的获取IP地址、端口、流量信息，那么问题就更简单了，这里只是抛砖引玉。另外再提供一段代码供参考:
import pcap, dpkt, struct
import binascii
def main():
a = pcap.pcap()
a.setfilter('udp portrange 4000-4050')
try:
for i,pdata in a:
p=dpkt.ethernet.Ethernet(pdata)
src='%d.%d.%d.%d' % tuple(map(ord,list(p.data.src)))
dst='%d.%d.%d.%d' % tuple(map(ord,list(p.data.dst)))
sport = p.data.data.sport
dport = p.data.data.dport
qq = int( binascii.hexlify(p.data.data.data[7:11]) , 16 )
print 'QQ: %d, From: %s:%d , To: %s:%d' % (qq,src,sport,dst,dport)
except Exception,e:
print '%s' % e
n = raw_input()
if __name__ == '__main__':
main()
㈨ python中txt文件路径怎么打开
可以使用绝对路径，类似于d:\work\deter.xls
python中打开文件的路径是当前工作路径，可以通过下面的方式查看
import os
os.getcwd() 可以通过
os.chdir('c:\\')
进行修改
㈩ winpcap在python3中的使用，求助
from ctypes import *
from winpcapy import *
import time
import sys
import string
import platform
if platform.python_version()[0] == "3":
raw_input=input
#/* prototype of the packet handler */
#void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);
PHAND=CFUNCTYPE(None,POINTER(c_ubyte),POINTER(pcap_pkthdr),POINTER(c_ubyte))
## Callback function invoked by libpcap for every incoming packet
def _packet_handler(param,header,pkt_data):
## convert the timestamp to readable format
local_tv_sec = header.contents.ts.tv_sec
ltime=time.localtime(local_tv_sec);
timestr=time.strftime("%H:%M:%S", ltime)
print
print("%s,%.6d len:%d" % (timestr, header.contents.ts.tv_usec, header.contents.len))
packet_handler=PHAND(_packet_handler)
alldevs=POINTER(pcap_if_t)()
errbuf= create_string_buffer(PCAP_ERRBUF_SIZE)
## Retrieve the device list
if (pcap_findalldevs(byref(alldevs), errbuf) == -1):
print ("Error in pcap_findalldevs: %s\n" % errbuf.value)
sys.exit(1)
## Print the list
i=0
try:
d=alldevs.contents
except:
print ("Error in pcap_findalldevs: %s" % errbuf.value)
print ("Maybe you need admin privilege?\n")
sys.exit(1)
while d:
i=i+1
print("%d. %s" % (i, d.name))
if (d.description):
print (" (%s)\n" % (d.description))
else:
print (" (No description available)\n")
if d.next:
d=d.next.contents
else:
d=False
if (i==0):
print ("\nNo interfaces found! Make sure WinPcap is installed.\n")
sys.exit(-1)
print ("Enter the interface number (1-%d):" % (i))
inum= raw_input('--> ')
if inum in string.digits:
inum=int(inum)
else:
inum=0
if ((inum < 1) | (inum > i)):
print ("\nInterface number out of range.\n")
## Free the device list
pcap_freealldevs(alldevs)
sys.exit(-1)
## Jump to the selected adapter
d=alldevs
for i in range(0,inum-1):
d=d.contents.next
## Open the device
## Open the adapter
d=d.contents
adhandle = pcap_open_live(d.name,65536,1,1000,errbuf)
if (adhandle == None):
print("\nUnable to open the adapter. %s is not supported by Pcap-WinPcap\n" % d.contents.name)
## Free the device list
pcap_freealldevs(alldevs)
sys.exit(-1)
print("\nlistening on %s...\n" % (d.description))
## At this point, we don't need any more the device list. Free it
pcap_freealldevs(alldevs)
## start the capture (we take only 15 packets)
pcap_loop(adhandle, 15, packet_handler, None)
pcap_close(adhandle)
这是WINPCAPY自带的例子。