精华内容
下载资源
问答
  • Java抓包程序

    2017-12-21 22:28:28
    java的抓包程序,带窗体的。网上查的时候发现带窗体的java抓包程序几乎都一样,用网上的代码改进了一个。一个渣,程序可能有些小毛病,无视吧。
  • java抓包程序

    2011-11-23 12:09:12
    这是java写的抓包程序,希望对你们有用 ,自己去下载拓展包
  • java抓包程序设计报告

    2016-05-05 13:30:29
    一个简易的java抓包程序的设计,捕获通过指定网络接口的信息并显示出来,以方便了解和管理自己的网络。
  • 使用java编写的抓包程序,对于一般的抓包比较简单,这里主要是对需要cookie验证的网页进行抓包,代码比较简单,自行下载理解。
  • Java抓包程序实现(附说明文档)

    千次下载 热门讨论 2015-04-27 11:13:51
    压缩包内包含了Java抓包用到到两个重要的软件,winpcap和jpcap,可以直接安装使用,本人亲测,windows 7环境下完美运行,JDK用的是1.7,需要配置下jpcap.dll到JDK的bin目录下。 另外还包含了一个Java程序(参考了...
  • java抓包程序jsoup实例

    2016-01-03 17:31:56
    前两天下个文档结果下不了就写了一个程序抓一下,希望能对大家有帮助
  • java抓包程序.rar

    2009-05-29 13:53:50
    java写的网络数据包捕获程序,并有分析数据功能,提供JAVA2D动态图像显示
  • JAVA网络抓包程序Java源码
  • 毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络...
  • java源码:JAVA网络抓包程序.rar
  • java网络抓包程序

    2008-11-28 13:35:49
    java网络抓包程序 学习工作的好参考 大家可以学习下
  • java抓包需要的包

    2014-12-30 19:46:11
    java抓包程序,使用jpcpa.jar包 java的JPCAP.jar,不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。 压缩包包含 jpcap.jar和jpcap.dll
  • 毕业论文:JAVA网络抓包程序javalearnsa资料分享
  • 模拟JAVA网络抓包功能,用到了ACCESS数据库。
  • java网络抓包程序源码

    2007-10-31 10:02:16
    一个抓包程序的源码,有兴趣的拿去看看
  • JAVA实现的抓包程序

    2009-04-27 11:13:24
    这是一款用java实现的抓包程序,你需要下载Jpcap7.0并安装后方可使用,另外本程序以sql2000做为数据的存储数据库。
  • 得到一个java开发的网络抓包程序源码,拿出来和大家分享一下
  • 网络课程作业,使用Jpcap实现的java网络抓包程序,支持ipv6,内附源码及文档 使用前先安装wincap和jpcap
  • java抓包工具及配置

    千次阅读 2014-12-30 19:38:56
     java抓包程序,使用jpcpa.jar包    下载地址:http://download.csdn.net/detail/moshenglv/8315223    java的JPCAP.jar,不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。  用winpcap 底层采用的...

    1、所需工具 jpcap.jar和jpcap.dll

      java抓包程序,使用jpcpa.jar包

      

      下载地址:http://download.csdn.net/detail/moshenglv/8315223

     

      java的JPCAP.jar,不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。

      用winpcap  底层采用的是c写的一些可以直接控制网卡的东东。

    2、配置

      首先下载需要的两个包 jpcap.jar和jpcap.dll

      将jpcap.dll复制到 %jdk安装路径%jre/bin 下面

      然后将jpcap.jar引入java工程,build path-->add jars

    3、代码

     

    package netPackage;
    
    /*******************
     * JpcapTip.java
     */
    
    //import java.net.NetworkInterface;
    //import java.net.InetAddress;
    //import java.net.UnknownHostException;
    
    import java.io.BufferedWriter;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.OutputStreamWriter;
    import java.io.UnsupportedEncodingException;
    import java.net.InetAddress;
    import java.nio.charset.Charset;
    
    import jpcap.JpcapCaptor;
    import jpcap.NetworkInterface;
    import jpcap.NetworkInterfaceAddress;
    import jpcap.PacketReceiver;
    import jpcap.packet.ARPPacket;
    import jpcap.packet.ICMPPacket;
    import jpcap.packet.IPPacket;
    import jpcap.packet.Packet;
    import jpcap.packet.TCPPacket;
    import jpcap.packet.UDPPacket;
    
    public class NetPackage implements PacketReceiver {
    
    	String result="";
    	int dst_port;
    	String dst_ip =null;
    	String src_ip =null;
    	int src_port;
    	
    	public void receivePacket(Packet packet) {
    		/* 分析源IP地址和目的IP地址 */
    		/* 分析协议类型 */
    		if (packet.getClass().equals(IPPacket.class)) {
    			System.out.println("协议类型 :IP协议");
    			IPPacket ipPacket = (IPPacket) packet;
    			byte[] iph = ipPacket.option;
    			String iphstr = new String(iph);
    			System.out.println(iphstr);
    		}
    
    		if (packet.getClass().equals(ARPPacket.class)) {
    			readHead(packet);
    			System.out.println("协议类型 :ARP协议");
    			try {
    				ARPPacket arpPacket = (ARPPacket) packet;
    				System.out.println("源网卡MAC地址为 :"
    						+ arpPacket.getSenderHardwareAddress());
    				System.out.println("源IP地址为 :"
    						+ arpPacket.getSenderProtocolAddress());
    				src_ip = ""+arpPacket.getSenderProtocolAddress();
    				System.out.println("目的网卡MAC地址为 :"
    						+ arpPacket.getTargetHardwareAddress());
    				System.out.println("目的IP地址为 :"
    						+ arpPacket.getTargetProtocolAddress());
                    dst_ip = ""+arpPacket.getTargetProtocolAddress();
                    result+="协议类型 :ARP协议 \n";
                    result+="源网卡MAC地址为 :"
    						+ arpPacket.getSenderHardwareAddress()+"\n";
                    result+="目的网卡MAC地址为 :"
    						+ arpPacket.getTargetHardwareAddress()+"\n";
                    result+="源ip:"+src_ip+"\n"+"目的ip:"+dst_ip+"\n";
                    
                    readData(packet);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		} else if (packet.getClass().equals(UDPPacket.class)) {
    			readHead(packet);
    			System.out.println("协议类型 :UDP协议");
    			try {
    				UDPPacket udpPacket = (UDPPacket) packet;
    				System.out.println("源IP地址为 :" + udpPacket.src_ip);
    				src_port = udpPacket.src_port;
    				System.out.println("源端口为:" + src_port);
    				System.out.println("目的IP地址为 :" + udpPacket.dst_ip);
    				dst_port = udpPacket.dst_port;
    				System.out.println("目的端口为:" + dst_port);
    				
    				dst_ip = ""+udpPacket.dst_ip;
    				src_ip = ""+udpPacket.src_ip;
    				
    				result+="协议类型 :UDP协议 \n";
    				result+="源IP地址为 :" + udpPacket.src_ip+"\n"
    				+"源端口为:" + src_port+"\n"
    				+"目的IP地址为 :" + udpPacket.dst_ip+"\n"
    				+"目的端口为:" + dst_port+"\n";
    				
    				readData(packet);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		} else if (packet.getClass().equals(TCPPacket.class)) {
    			readHead(packet);
    			System.out.println("协议类型 :TCP协议");
    			try {
    				TCPPacket tcpPacket = (TCPPacket) packet;
    				src_port = tcpPacket.src_port;
    				System.out.println("源IP地址为 :" + tcpPacket.src_ip);
    				System.out.println("源端口为:" + src_port);
    				System.out.println("目的IP地址为 :" + tcpPacket.dst_ip);
    				dst_port = tcpPacket.dst_port;
    				System.out.println("目的端口为:" + dst_port);
    				
    				result+="协议类型 :TCP协议 \n";
    				result+="源IP地址为 :" + tcpPacket.src_ip+"\n"
    				+"源端口为:" + src_port+"\n"
    				+"目的IP地址为 :" + tcpPacket.dst_ip+"\n"
    				+"目的端口为:" + dst_port+"\n";
    				
    				readData(packet);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		} else if (packet.getClass().equals(ICMPPacket.class))
    			{
    			readHead(packet);
    			  System.out.println("协议类型 :ICMP协议");
    			  result+="协议类型 :ICMP协议"+"\n";
    			  readData(packet);
    		}
    		
    		write(result);
    		result="";
    	}
    
    	public void readHead(Packet packet){
    		System.out.println("********************************************");
    		result+="********************************************"+"\n";
    		/* IP数据报报文头 */
    		byte[] l = packet.header;
    		String str = "";
    		System.out.print("报文头 : ");
    		for (int i = 0; i < l.length; i++) {
    			int m = 0;
    			m = l[i];
    			m = m << 24;
    			m = m >>> 24;
    			str = str + Integer.toHexString(m);
    		}
    		System.out.println(str);
    		int d = l.length;
    		System.out.println("首部长度 :" + (d * 8) + "bit");
    		
    		result+="报文头 : "+str+"\n";
            result+="首部长度 :" + (d * 8) + "bit"+"\n";
    	}
    	
    	public void readData(Packet packet){
    		/* IP数据报文数据 */
    		byte[] k = packet.data;
    		String str1 = "", str2 = "";
    		System.out.print("数据 : ");
    		for (int i = 0; i < k.length; i++) {
    			try {
    				str1 = new String(k, "utf-8");
    			} catch (UnsupportedEncodingException e) {
    			}
    		}
    		try {
    			str2 =new String(k, "gb2312");
    		} catch (UnsupportedEncodingException e) {
    			e.printStackTrace();
    		}
    		System.out.println(str1);
    		String s = " " + packet.getClass();
    		System.out.println("数据报类型 :" + s.substring(s.lastIndexOf(".") + 1));
    
    		result+="数据报类型 :" + s.substring(s.lastIndexOf(".") + 1)+"\n";
    		result+="数据 : "+str1+"\n";
    		result+="******************************************** \n";
    	}
    	
    	private void write(String result) {
    		try {
    			FileOutputStream fis = new FileOutputStream("F:\\result.txt",true);
    			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fis));
    			writer.write(result);
    			
    			writer.flush();
    			writer.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	public static void main(String[] args) throws Exception {
    
    		NetworkInterface[] devices = JpcapCaptor.getDeviceList(); 
    		// for (int i =0; i<devices.length;i++) {
    		int a = 0;
    		// try {
    		/* 本地网络信息 */
    		byte[] b = devices[1].mac_address; // 网卡物理地址
    		// }
    		// catch() {}
    		System.out.print("网卡MAC : 00");
    		for (int j = 0; j < b.length; j++) {
    			// a=a<<8;
    			a = b[j];
    			a = a << 24;
    			a = a >>> 24;
    			System.out.print(Integer.toHexString(a));
    		}
    		System.out.println();
    		NetworkInterfaceAddress[] k = devices[1].addresses;
    
    		for (int n = 0; n < k.length; n++) {
    			System.out.println("本机IP地址 : " + k[n].address); // 本机IP地址
    			System.out.println("子网掩码   : " + k[n].subnet); // 子网掩码
    		}
    		System.out.println("网络连接类型 : " + devices[1].datalink_description);
    		// }
    		
    		//0:无线网卡   1:有线网卡
    		NetworkInterface deviceName = devices[0];
    		
    		/* 将网卡设为混杂模式下用网络设备deviceName */
    		JpcapCaptor jpcap = null;
    		try {
    			jpcap = JpcapCaptor.openDevice(deviceName, 2000, false, 1); 
    
    		} catch (Exception e) {
    		}
    		System.out.println(jpcap);
    		jpcap.loopPacket(-1, new NetPackage());
    		
    	}
    
    }

     

     

     

     

     

      运行结果:

    ********************************************
    报文头 : 105e7ffffa64273719b650804500a13610001114b1fa3f3de4effffffaff876c08d1a58
    首部长度 :336bit
    协议类型 :UDP协议 
    源IP地址为 :/10.63.61.228
    源端口为:65288
    目的IP地址为 :/239.255.255.250
    目的端口为:1900
    数据报类型 :UDPPacket
    数据 : M-SEARCH * HTTP/1.1
    Host:239.255.255.250:1900
    ST:urn:schemas-upnp-org:device:InternetGatewayDevice:1
    Man:"ssdp:discover"
    MX:3




    ******************************************** 
    ********************************************
    报文头 : ffffffffffff74258a78270860180640174258a78270a3f02000000a3f030
    首部长度 :336bit
    协议类型 :ARP协议 
    源网卡MAC地址为 :74:25:8a:78:02:70
    目的网卡MAC地址为 :00:00:00:00:00:00
    源ip:/10.63.0.2
    目的ip:/10.63.0.48
    数据报类型 :ARPPacket
    数据 : 
    ******************************************** 
    ********************************************
    报文头 : cda41b4fe5764273719b6508045003436114004068f1da3f3de4adc27fb019fb1bb51438840000802200803200245b413321142
    首部长度 :528bit
    协议类型 :TCP协议 
    源IP地址为 :/10.63.61.228
    源端口为:6651
    目的IP地址为 :/173.194.127.176
    目的端口为:443
    数据报类型 :TCPPacket
    数据 : 
    ******************************************** 
    ********************************************
    报文头 : cda41b4fe5764273719b6508045003436124004068f1ca3f3de4adc27fb019fd1bbc38de736000080220013400245b413321142
    首部长度 :528bit
    协议类型 :TCP协议 
    源IP地址为 :/10.63.61.228
    源端口为:6653
    目的IP地址为 :/173.194.127.176
    目的端口为:443
    数据报类型 :TCPPacket
    数据 : 
    ******************************************** 

    欢迎关注公众号:

    展开全文
  • 前言 本学期计算机网络要求写一个抓包程序,我通过网上查阅资料,如何实现抓包,实现了一个较为简单的抓包程序。 文章目录 前言 项目准备 一、抓包功能的基本实现 二、完整项目实现 1.界面布局 2.抓包功能管理类 3....

    前言

    本学期计算机网络要求写一个抓包程序,我通过网上查阅资料,如何实现抓包,实现了一个较为简单的抓包程序。



    项目准备

    1.首先得有java编译环境,安装并配置好jdk;
    2.需要安装Winpcap,Winpcap是windows平台下的一个免费的,公共的网络访问系统(Linux系统是Libpcap);
    3.还需要下载Jpcap,Jpcap就是调用Winpcap给java提供一个公共的接口,从而实现平台无关性,并能够捕获发送数据包。Jpcap包括Jpcap.jar和Jpcap.dll,两者需要版本一致,并且区分32位和64位。将Jpcap.jar导入你的idea或者Eclipse项目,并且把Jpcap.dll复制到java的jdk的bin目录下,就ok了。


    注:我的项目是用idea开发的。

    一、抓包功能的基本实现

    前面的准备工作完成后,我们就可以使用Jpcap编程进行ip数据包的捕获了。

    • JpcapHandler :这个接口用来定义分析被捕获数据包的方法;

    • ARPPacket:这个类描述了ARP/RARP包,继承了Packet类;

    • DatalinkPacket :这个抽象类描述了数据链路层;

    • EthernetPacket :这个类描述了以太帧包,继承DatalinkPacket类;

    • ICMPPacket:这个类描述了ICMP包,继承了IPPacket类;

    • IPAddress:这个类描述了IPv4和IPv6地址,其中也包含了将IP地址转换为域名的方法;

    • IPPacket:这个类描述了IP包,继承了Packet类,支持IPv4和IPv6;

    • IPv6Option :这个类描述了IPv6选项报头;

    • Jpcap:用来捕获数据包;

    • Jpcap.JpcapInfo :Jpcap的内部类,它包含被捕获数据包的信息(在jpcap0.4修改部分BUG之后不再使用这个类);

    • JpcapSender :它用来发送一个数据包;

    • JpcapWriter :它用来将一个被捕获的数据包保存到文件;

    • Packet :这个类是所有被捕获的数据包的基类;

    • TCPPacket:这个类描述TCP包,继承了IPPacket类;

    • UDPPacket :这个类描述了UDP包,继承了IPPacket类;

      以抓取ip数据包为例,JPCAP抓包基本步骤为:绑定网络设备、抓包、分析。
      以下附上基本功能实现的代码(无界面,能够基本实现抓包功能):

    import java.io.IOException;
     
    import jpcap.*;
    import jpcap.packet.IPPacket;
    import jpcap.packet.Packet;
     
    public class JpcapPacket {
    	public static void main(String[] args)
    	{
            /*--------------	第一步绑定网络设备       --------------*/ 
    		NetworkInterface[] devices = JpcapCaptor.getDeviceList();
    		
    		for(NetworkInterface n : devices)
    		{
    			System.out.println(n.name + "     |     " + n.description);
    		}
    		System.out.println("-------------------------------------------");
    		
    		JpcapCaptor jpcap = null;
    		int caplen = 1512;
    		boolean promiscCheck = true;
    		
    		/*
    		devices[ ]中的数字需要注意,这里的数字根据你的网卡而定,
    		你选择抓包的网卡正确才能抓到数据包,
    		不同设备在使用有线网和无线网时的都不一样,
    		具体的需要自己去试验。
    		*/
    		try{
    			jpcap = JpcapCaptor.openDevice(devices[1], caplen, promiscCheck, 50);
    		}catch(IOException e)
    		{
    			e.printStackTrace();
    		}
    		
    		/*----------第二步抓包-----------------*/
    		int i = 0;
    		while(i < 10)
    		{
    			Packet packet  = jpcap.getPacket();
    			if(packet instanceof IPPacket && ((IPPacket)packet).version == 4)
    			{
    				i++;
    				IPPacket ip = (IPPacket)packet;//强转
    				
    				System.out.println("版本:IPv4");
    				System.out.println("优先权:" + ip.priority);
    				System.out.println("区分服务:最大的吞吐量: " + ip.t_flag);
    				System.out.println("区分服务:最高的可靠性:" + ip.r_flag);
    				System.out.println("长度:" + ip.length);
    				System.out.println("标识:" + ip.ident);
    				System.out.println("DF:Don't Fragment: " + ip.dont_frag);
    				System.out.println("NF:Nore Fragment: " + ip.more_frag);
    				System.out.println("片偏移:" + ip.offset);
    				System.out.println("生存时间:"+ ip.hop_limit);
    				
    				String protocol ="";
    				switch(new Integer(ip.protocol))
    				{
    				case 1:protocol = "ICMP";break;
    				case 2:protocol = "IGMP";break;
    				case 6:protocol = "TCP";break;
    				case 8:protocol = "EGP";break;
    				case 9:protocol = "IGP";break;
    				case 17:protocol = "UDP";break;
    				case 41:protocol = "IPv6";break;
    				case 89:protocol = "OSPF";break;
    				default : break;
    				}
    				System.out.println("协议:" + protocol);
    				System.out.println("源IP " + ip.src_ip.getHostAddress());
    				System.out.println("目的IP " + ip.dst_ip.getHostAddress());
    				System.out.println("源主机名: " + ip.src_ip);
    				System.out.println("目的主机名: " + ip.dst_ip);
    				System.out.println("----------------------------------------------");
    			}
    		}
    		
    	}
    }
    

    二、完整项目实现

    具有界面,能够实现基本功能(查看网卡信息,开始抓包,暂停抓包(开始抓包后“开始”按钮变为“暂停”,清空界面内容,退出,以及过滤器功能的简单实现)),界面如下图:
    界面如图
    注:界面使用swing实现(现在swing基本很少用了,不过做个简单界面还是不错)

    1.界面布局

    JpCapFrame代码如下:

    package packetCapture;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    import javax.swing.table.JTableHeader;
    import java.awt.*;
    
    /**
     * 流式布局
     */
    public class JpCapFrame extends JFrame {
        private static DefaultTableModel model;
        private static JTextField filterField;
        private JTextArea showArea;
        private JButton startBtn;
        private JButton checkBtn;
        private JButton exitBtn;
        private JButton clearBtn;
    
        public JpCapFrame() {
            super();
            initGUI();
        }
    
        public static DefaultTableModel getModel() {
            return model;
        }
    
        public JTextArea getShowArea() {
            return showArea;
        }
    
        public JButton getStartBtn() {
            return startBtn;
        }
    
        public JButton getCheckBtn() {
            return checkBtn;
        }
    
        public JButton getExitBtn() {
            return exitBtn;
        }
    
        public JButton getClearBtn() {
            return clearBtn;
        }
    
        public static JTextField getFilterField() {
            return filterField;
        }
    
        private void initGUI() {
            Font font1 = new Font("宋体", Font.BOLD, 15);
            Font font4 = new Font("宋体", Font.BOLD, 14);
            Font font2 = new Font("宋体", Font.PLAIN, 16);
            Font font3 = new Font("微软雅黑", Font.PLAIN, 16);
    
            //界面
            setSize(1550, 1000);
            setVisible(true);
            setTitle("Captor");
            Container container = this.getContentPane();
    
            //顶部
            JPanel pane = new JPanel();
            pane.setBounds(0, 0, 775, 150);
            pane.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 0));
            pane.setPreferredSize(new Dimension(775, 27));
    
            checkBtn = new JButton("查看网卡信息");
            checkBtn.setFont(font4);
            checkBtn.setBounds(0, 0, 50, 0);
            pane.add(checkBtn);
    
            startBtn = new JButton("开始");
            startBtn.setFont(font4);
            startBtn.setBounds(0, 0, 50, 0);
            pane.add(startBtn);
    
            clearBtn = new JButton("清空");
            clearBtn.setFont(font4);
            clearBtn.setBounds(0, 0, 50, 0);
            pane.add(clearBtn);
    
            exitBtn = new JButton("退出");
            exitBtn.setFont(font4);
            exitBtn.setBounds(0, 0, 50, 0);
            pane.add(exitBtn);
    
            JPanel panelTest = new JPanel();
            panelTest.setBounds(775, 0, 775, 150);
            panelTest.setPreferredSize(new Dimension(775, 27));
            panelTest.setLayout(new FlowLayout(FlowLayout.RIGHT, 20, 0));
    
            JLabel filter = new JLabel("Filter:");
            filter.setFont(font1);
            filter.setBounds(0, 0, 500, 0);
            filterField = new JTextField(50);
            filterField.setBounds(200, 0, 500, 0);
            panelTest.add(filter);
            panelTest.add(filterField);
    
            //中部主体内容显示区
            String[] name = {"No.", "Time", "Source", "Destination", "Protocol", "Length", "Info"};
            //model = new DefaultTableModel();
            //model.setColumnIdentifiers(name);
            JTable table = new JTable(model);
            JTableHeader tableHeader = table.getTableHeader();
            tableHeader.setFont(font1);
            table.setFont(font2);
            table.setRowHeight(20);
            model = (DefaultTableModel) table.getModel();
            model.setColumnIdentifiers(name);
            table.setEnabled(false);
            JScrollPane jScrollPane = new JScrollPane(table);
            jScrollPane.setBounds(0, 300, 1550, 600);
    
            //底部
            JPanel pane2 = new JPanel();
            pane2.setLayout(new BorderLayout());
            pane2.setPreferredSize(new Dimension(1550, 300));
    
            showArea = new JTextArea(5, 5);
            //showArea.setBounds(0,0,1200,300);
            //showArea.setText("Test");
            showArea.setEditable(false);
            showArea.setLineWrap(false);
            showArea.setFont(font3);
            //showArea.setBackground(Color.GRAY);
            //pane2.add(showArea);
            pane2.setSize(10, 10);
            pane2.setBounds(0, 0, 1, 1);
            //给textArea添加滚动条
            JScrollPane scrollPane = new JScrollPane(showArea);
            scrollPane.setBounds(0, 0, 1, 1);
            scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
            scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    
            pane2.add(scrollPane, BorderLayout.CENTER);
            scrollPane.setViewportView(showArea);
    
            container.add(jScrollPane, BorderLayout.CENTER);
            container.add(pane, BorderLayout.NORTH);
            container.add(panelTest, BorderLayout.NORTH);
            container.add(pane2, BorderLayout.SOUTH);
    
            setLocationRelativeTo(null);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    
    

    2.抓包功能管理类

    JpCapPacket代码如下:

    package packetCapture;
    
    import jpcap.JpcapCaptor;
    import jpcap.packet.IPPacket;
    import jpcap.packet.Packet;
    
    import java.sql.Timestamp;
    import java.util.Vector;
    
    public class JpCapPacket {
        private JpcapCaptor jpcap;
    
        public JpCapPacket(JpcapCaptor jpcap) {
            this.jpcap = jpcap;
        }
    
        void capture() throws InterruptedException {
            int i = 0;
            while (true) {
                synchronized (JpCapMain.getThread()) {
                    if (JpCapMain.isPause()) {
                        JpCapMain.getThread().wait();
                    }
                }
                Packet packet = jpcap.getPacket();
                if (packet instanceof IPPacket && ((IPPacket) packet).version == 4) {
                    i++;
                    IPPacket ip = (IPPacket) packet;//强转
    
    //                System.out.println("版本:IPv4");
    //                System.out.println("优先权:" + ip.priority);
    //                System.out.println("区分服务:最大的吞吐量: " + ip.t_flag);
    //                System.out.println("区分服务:最高的可靠性:" + ip.r_flag);
    //                System.out.println("长度:" + ip.length);
    //                System.out.println("标识:" + ip.ident);
    //                System.out.println("DF:Don't Fragment: " + ip.dont_frag);
    //                System.out.println("NF:Nore Fragment: " + ip.more_frag);
    //                System.out.println("片偏移:" + ip.offset);
    //                System.out.println("生存时间:" + ip.hop_limit);
    
                    String protocol = "";
                    switch (new Integer(ip.protocol)) {
                        case 1:
                            protocol = "ICMP";
                            break;
                        case 2:
                            protocol = "IGMP";
                            break;
                        case 6:
                            protocol = "TCP";
                            break;
                        case 8:
                            protocol = "EGP";
                            break;
                        case 9:
                            protocol = "IGP";
                            break;
                        case 17:
                            protocol = "UDP";
                            break;
                        case 41:
                            protocol = "IPv6";
                            break;
                        case 89:
                            protocol = "OSPF";
                            break;
                        default:
                            break;
                    }
    //                System.out.println("协议:" + protocol);
    //                System.out.println("源IP " + ip.src_ip.getHostAddress());
    //                System.out.println("目的IP " + ip.dst_ip.getHostAddress());
    //                System.out.println("源主机名: " + ip.src_ip);
    //                System.out.println("目的主机名: " + ip.dst_ip);
    //                System.out.println("----------------------------------------------");
                    String filterInput = JpCapFrame.getFilterField().getText();
                    if (filterInput.equals(ip.src_ip.getHostAddress()) ||
                            filterInput.equals(ip.dst_ip.getHostAddress()) ||
                            filterInput.equals(protocol) ||
                            filterInput.equals("")) {
                        Vector dataVector = new Vector();
                        Timestamp timestamp = new Timestamp((packet.sec * 1000) + (packet.usec / 1000));
    
                        dataVector.addElement(i + "");
                        //dataVector.addElement(new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss").format(new Date()));
                        dataVector.addElement(timestamp.toString());//数据包时间
                        dataVector.addElement(ip.src_ip.getHostAddress());
                        dataVector.addElement(ip.dst_ip.getHostAddress());
                        dataVector.addElement(protocol);
                        dataVector.addElement(packet.data.length);
    
                        String strtmp = "";
                        for (int j = 0; j < packet.data.length; j++) {
                            strtmp += Byte.toString(packet.data[j]);
                        }
                        dataVector.addElement(strtmp); //数据内容
    
                        JpCapFrame.getModel().addRow(dataVector);
                    }
                }
            }
        }
    }
    
    

    3.主界面及功能实现

    JpCapMain代码如下:

    package packetCapture;
    
    import jpcap.JpcapCaptor;
    import jpcap.NetworkInterface;
    
    import java.io.IOException;
    
    public class JpCapMain implements Runnable {
        JpCapFrame frame;
        JpcapCaptor jpcap = null;
        private static Thread thread = null;
        private static boolean pause = true;
    
        public JpCapMain() {
            //创建界面
            frame = new JpCapFrame();
            frame.setVisible(true);
    
            //绑定网络设备
            NetworkInterface[] devices = JpcapCaptor.getDeviceList();
    
            int caplen = 1512;
            boolean promiscCheck = true;
    
            /*
            WIFI:3
            有线:1
            (不同设备对应的不一样)
            */
            int device = 1;
            try {
                jpcap = JpcapCaptor.openDevice(devices[device], caplen, promiscCheck, 50);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            frame.getCheckBtn().addActionListener(e -> {
                frame.getShowArea().append("当前设备全部网络设备信息为: \n");
    
                for (NetworkInterface n : devices) {
                    System.out.println(n.name + "     |     " + n.description);
                    frame.getShowArea().append(n.name + "     |     " + n.description + "\n");
                }
                //System.out.println("-------------------------------------------");
                frame.getShowArea().append(printSeparator(110, 0));
                frame.getShowArea().append("\n当前使用网卡信息: " + devices[device].name + "     |     " + devices[device].description + "\n");
                frame.getShowArea().append(printSeparator(110, 1));
            });
    
            frame.getStartBtn().addActionListener(e -> {
                if (pause) {
                    if (thread == null) {
                        frame.getShowArea().append("   开始抓包,抓取范围为:" + JpCapFrame.getFilterField().getText() + " ……\n");
                        thread = new Thread(this);
                        thread.setPriority(Thread.MIN_PRIORITY);
                        //thread.sleep(100);
                        thread.start();
                        pause = false;
                        frame.getStartBtn().setText("暂停");
                    } else {
                        frame.getStartBtn().setText("暂停");
                        pause = false;
                        frame.getShowArea().append("   继续抓包,抓取范围为:" + JpCapFrame.getFilterField().getText() + " ……\n");
                        synchronized (thread) {
                            thread.notify();
                        }
                    }
                } else {
                    pause = true;
                    frame.getStartBtn().setText("开始");
                    frame.getShowArea().append("    暂停抓包\n");
                }
            });
    
            frame.getClearBtn().addActionListener(e -> {
                frame.getShowArea().setText("");
                frame.getModel().setRowCount(0);
            });
    
            frame.getExitBtn().addActionListener(e -> {
                System.exit(0);
            });
        }
    
        public static void main(String[] args) {
            new JpCapMain();
        }
    
        @Override
        public void run() {
            try {
                new JpCapPacket(jpcap).capture();
                thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * @param separator "-"的数量
         * @param line      "\n"的数量
         * @return
         */
        public String printSeparator(int separator, int line) {
            String s = "";
            String l = "";
    
            for (int i = 0; i < separator; i++) {
                s += "-";
            }
    
            for (int i = 0; i < line; i++) {
                l += "\n";
            }
            return s + l;
        }
    
        public static Thread getThread() {
            return thread;
        }
    
        public static boolean isPause() {
            return pause;
        }
    }
    

    项目完整代码如上。


    总结

    本项目基本实现了抓包的功能,但是因为做的比较赶,所以还有很多功能没有完善。比如演示的时候发现有的同学有选择网卡的功能,我这里只做了查看网卡的功能,但是实现这个功能还是不难的,就是在devices[device]中想办法能够通过选择网卡与device(int)值对应。另外存在的问题就是界面比较简单,不是很美观,然后没有实现点开每一个数据包能够查看具体信息的功能,均还有待完善。

    展开全文
  • java网络抓包

    2018-01-03 15:52:41
    基于java的网络抓包程序,使用java编写,可以直接使用
  • Java抓包工具 jpcap WinPcap,无脑安装就可,这2个程序直接安装就好,但开发环境一定要切换到你安装版的jre或者jdk,他默认安装到这里的。 里面还有2个例子,可以学习下
  • 主要介绍了java抓包后对pcap文件解析示例,需要的朋友可以参考下
  • 网络抓包程序

    2011-12-16 20:59:48
    网络抓包程序 java 基本网络 流程 实现 抓包
  • java的简单抓包程序

    2009-11-23 22:07:45
    菜鸟东拉西扯的作品。请高手不要见笑,还请多多指教,不胜感激。
  • 其实Java本身对网络编程是不够底层的,就如我们现在要进行抓包分析的话肯定是不够。因为Java本身所实现的网络编程是在应用层进行操作的,如果我们需要进行抓包的话,就需要深入到底层的协议去了。 文章目录1.libpcap...

    1.Java网络编程的局限性

    首先我们先抛出一个问题,那就是Java怎么在网络层面进行编程?很多小伙伴肯定会说,Java不是有网络编程么?其实Java本身对网络编程是不够底层的,就如我们现在要进行抓包分析的话肯定是不够。因为Java本身所实现的网络编程是在应用层进行操作的,如果我们需要进行抓包的话,就需要深入到底层的协议去了。如下图中的各种协议,应用层之下的协议,在Java中可能就束手无策了。
    在这里插入图片描述

    2.相关使用技术介绍

    2.1.Java使用libpcap流程介绍

    本章节我们将使用Jnetpcap来进行学习,在此之前我们需要了解如下一个流程,我们Java本身是不支持直接使用libpcap,因此需要一个JNI技术来作为桥梁,使得我们Java语言可以调用C语言的库,然后jnetpcap中,然后是的Java使用jnetpcap进行开发的时候,直接使用Java方式就可以了,不用关心Java怎么集成JNI调用C语言库。
    在这里插入图片描述

    2.2.libpcap/winpcap

    libpcap(Packet Capture Library)即数据包捕获函数库,是Unix/Linux平台下的网络数据包捕获函数库。它是一个独立于系统的用户层包捕获的API接口,为底层网络监测提供了一个可移植的框架。

    当前最流行的包嗅探和分析工具(tcpdump,Wireshark,Snort,nmap,ngrep等许多工具),都是基于libpcap函数库的。
    而winpcap就是windows下的libpcap。
    在这里插入图片描述

    2.3.JNI

    SUN公司发布的Java 本地接口(JNI)提供了将Java与C/C++、汇编等本地代码集成的方案,该规范使得在 Java 虚拟机内运行的 Java 代码能够与其它编程语言互相操作,包括创建本地方法、更新Java对象、调用Java方法,引用 Java类,捕捉和抛出异常等,也允许 Java代码调用 C/C++或汇编语言编写的程序和库。

    因此,我们可以通过Java——》JNI——》libpcap的方式来调用C语言库。

    2.4.jnetpcap

    jNetPcap是 libpcap的一个Java完整封装。jNetPcap使 用与libpcap相同风格的API。libpcap是unix/linux平台下的网络数据包捕获函数库,大多数网络监控软件都以它为基础。 Libpcap可以在绝大多数类unix平台下工作。Libpcap提供了系统独立的用户级别网络数据包捕获接口,并充分考虑到应用程序的可移植性。

    同时jnetpcap中,集成了JNI,因此在Java应用程序中,使用jnetpcap你就不需要在去额外使用jni了,就像你使用SpringBoot开发时,SpringBoot已经集成了tomcat。

    目前版本jnetpcap-1.4.r1425-1g所支持的操作系统如下
    在这里插入图片描述

    3.环境安装

    这里我们主要以windows环境进行搭建为主。我们需要如下几个步骤

    3.1.操作系统

    这一步至关重要,因为这将确定你的项目到底能不能做。
    不管目前我们用什么技术,我们必须认识到一点,那就是我们不管做了什么集成或者封装,底层还是用libpcap,因此如果libpcap不支持我们的服务器环境的话,说啥都没用。

    因为不同操作系统使用不同的C语言函数库,并不是所有的操作系统都支持的,如上文中提到的,支持X86芯片的windows系统,amd64芯片的linux等,但是限制不仅仅是操作系统,还有你的CPU处理芯片。这个需要你先确定好贵公司的服务器芯片。

    一般公司来说,X86芯片和amd芯片居多,但是对于国产化要求高的企业单位,可能要求服务器是国产化的,因此可能使用一些龙芯,飞腾系列的芯片,则是不支持的。毕竟现阶段libpcap是不太可能去适配这些国产芯片的。

    希望未来有一天我们的国产芯片能发展到让老外的软件及代码来适配我们的硬件基础设施。
    希望未来能更多的企业投入到芯片的研究中,让中国芯片走向世界!

    本人电脑X86芯片
    在这里插入图片描述
    系统为windows11专业版本
    在这里插入图片描述

    3.2.安装winpcap

    具体安装winpcap这里我就不细说了,如果不知道winpcap从哪儿获取,最简单的方式就是安装一个wireshark,因为wireshark是基于winpcap的。
    在这里插入图片描述
    如果你的系统是linux,则你需要安装的是libpcap。

    3.3.maven/SpringBoot集成jnetpcap

    3.3.1.创建Maven或者SpringBoot项目

    这里我们使用maven的方式进行环境集成,就不再使用导入jnetpcap.jar的方式进行集成了,毕竟网上到处的找包也不方便。当然你可以使用maven的方式集成了jnetpcap,然后在maven仓库中找到jnetpcap,导入到非maven项目中也可以。
    这里我采用Spring tool sute进行开发
    使用你的IDE创建一个maven项目或者SpringBoot项目
    在这里插入图片描述

    3.3.2.引入jnetpcap依赖

    获取你需要jnetpcap依赖,如下我们使用的是目前
    https://mvnrepository.com/artifact/jnetpcap/jnetpcap/1.4.r1425-1g
    在这里插入图片描述
    当然你也可以选择使用其他的版本,我们可以看到目前最新的版本是2018年1月进行更新的
    在这里插入图片描述
    我们单独引入jnetpcap是不够的,因为jnetpcap目前还没上传到maven仓库中,或许是因为我用的阿里云仓库,国际仓库是否有,这个不清楚。

    		<!-- jnetpcap抓包 -->
    		<dependency>
                <groupId>jnetpcap</groupId>
                <artifactId>jnetpcap</artifactId>
                <version>1.4.r1425-1g</version>
            </dependency>
    
    <!-- jnetpcap抓包的maven配置 -->
    	<repositories>
      		<repository>
        		<id>Clojars</id>
        		<name>Clojars</name>
       	 		<url>https://clojars.org/repo/</url>
      		</repository>
    	</repositories>
    

    完整maven配置如下

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.3.10.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>com.example</groupId>
    	<artifactId>jnetpcap_capture</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>jnetpcap_capture</name>
    	<description>Demo project for Spring Boot</description>
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<!-- jnetpcap抓包 -->
    		<dependency>
                <groupId>jnetpcap</groupId>
                <artifactId>jnetpcap</artifactId>
                <version>1.4.r1425-1g</version>
            </dependency>
            
    	</dependencies>
    	
    	<!-- jnetpcap抓包的maven配置 -->
    	<repositories>
      		<repository>
        		<id>Clojars</id>
        		<name>Clojars</name>
       	 		<url>https://clojars.org/repo/</url>
      		</repository>
    	</repositories>
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    
    

    3.4.非maven集成jnetpcap

    非maven环境集成jnetpcap时,比较简单,其实就是找到jnetpcap包,然后将jnetpcap导入项目即可,但是存在一个问题,就是如果我们仅仅导入jnetpcap包,是不够的,因为我们还需要与这个依赖包保持版本的jnetpcap函数库,这块反正网上到处找也费劲。所以如果你的项目是非maven项目,这里建议你创建一个maven或者springBoot项目,然后用maven的方式集成,然后在maven仓库中去找jnetpcap包。这样有个好处,就是maven中集成进来的jnetpcap包中就包含了jnetpcap的函数库。

    如果你不想折腾maven,那就来这儿下载吧
    在这里插入图片描述

    3.5.安装jnetpcap函数库

    从哪里获取jnetpcap函数库函数库嗯?网上到处下载,反正够折腾人的,jnetpcap依赖有几个版本,然后函数库也有几个版本,各版本之间是不能混合用的。主要现在jnetpcap官网也打不开,不知道是不是要科学访问还是什么的,反正到目前位置也快3年没更新了。jnetpcap最后一版是2018年1月更新的(楼主目前时间2021年9月)

    首先找到我们的通过maven集成的jnetpcap包依赖。
    1.将windows系统中的X86芯片 64位系统的jnetpcap.dll拷贝出来,这就是函数库。
    在这里插入图片描述
    在这里插入图片描述
    2.将函数库复制到jdk/bin目录下
    在这里插入图片描述
    至此,windows开发环境搭建完毕。

    4.获取网卡

    为了显示查看方便,我们先把其他不用的网卡给禁用掉
    在这里插入图片描述
    然后在cmd中,输入ipconfig /all查看我们的网卡信息
    在这里插入图片描述
    然后我们用代码的方式来获取我们的网卡信息,和上面我们的网卡信息做对比。

    import java.util.ArrayList;
    import java.util.List;
    
    import org.jnetpcap.Pcap;
    import org.jnetpcap.PcapIf;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class JnetApp {
    	public static void main(String[] args) {
    		SpringApplication.run(JnetApp.class, args);
    		 List<PcapIf> devs = new ArrayList<PcapIf>();
    	        StringBuilder errsb = new StringBuilder();
    	        int r = Pcap.findAllDevs(devs, errsb);
    	        if (r == Pcap.NOT_OK || devs.isEmpty()) {
    	            System.err.println("未获取到网卡");
    	        } else {
    	            System.out.println("获取到网卡:");
    	            System.out.println(devs);
    	        }
    	}
    }
    
    获取到网卡:
    [<flags=0, 
     addresses=[
      [addr=[INET4:192.168.1.233], 
        mask=[INET4:255.255.255.0], 
        broadcast=[INET4:255.255.255.255], 
        dstaddr=null], 
      [addr=[INET6:FE80:0000:0000:0000:A069:D7CC:E18D:CEE1], 
        mask=[0], 
        broadcast=[0], 
        dstaddr=null]], 
        name=\Device\NPF_{BE377809-60C5-49AD-A224-0F6C3B355EFB}, 
        desc=Intel(R) Ethernet Connection (2) I219-LM>]
    

    在这里插入图片描述
    刚开始的时候我电脑是正常运行的,然后系统自动更新以后,就发现获取不到网卡,然后以管理员启动IDE在运行代码时,就能成功了。因此这里,防止权限不够的情况,建议以管理员方式启动。
    至此,本章节结束!

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,351
精华内容 12,140
关键字:

java抓包程序

java 订阅