精华内容
下载资源
问答
  • JAVA写的网络抓包分析程序

    热门讨论 2008-09-03 15:44:34
    JAVA写的网络抓包分析程序 需要先下载jpcap winpcap
  • Java jpcap抓包

    2019-05-08 11:21:51
    Java和jpcap一个抓包的程序。可以抓WiFi的包。
  • Java抓包程序

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

    2018-01-03 15:52:41
    基于java的网络抓包程序,使用java编写,可以直接使用
  • jpcap java抓包必需jar包

    2018-06-15 19:22:04
    jPCAP在JAVA中,并非一个真正去实现对数据链路层的控制,而是一个中间件,JPCAP调用winpcap/libpcap,给 JAVA语言提供一个公共的接口,从而实现了平台无关性。
  • Java语言实现抓包

    2018-06-12 16:54:50
    本程序可以抓取ip,arp,tcp,udp,icmp协议的包,同时可以检测上网网速,上网流量,抓包数等等
  • java APP抓包工具

    2018-08-23 16:26:52
    java,开发IOS和安卓APP时,可以使用该抓包工具,获取后台接口的入参和出参
  • java jpcap 抓包

    2014-07-14 16:03:40
    jpcap是使用java实现的抓包工具。该资源有详细的说明使用文档,
  • 网络抓包java源码,可实现抓包、分析和还原。
  • java抓包工具

    热门讨论 2012-06-25 11:55:41
    毕业设计,抓包工具的设计与实现. 使用java调用jpcap编写。
  • JAVA网络抓包程序Java源码
  • java抓包.rar

    2009-10-20 01:35:31
    java抓包.rarjava抓包.rarjava抓包.rar
  • 首先我们先抛出一个问题,那就是Java怎么在网络层面进行编程?很多小伙伴肯定会说,Java不是有网络编程么?其实Java本身对网络编程是不够底层的,就如我们现在要进行抓包分析的话肯定是不够。因为Java本身所实现的...

    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在运行代码时,就能成功了。因此这里,防止权限不够的情况,建议以管理员方式启动。
    至此,本章节结束!

    展开全文
  • java抓包程序

    2011-11-23 12:09:12
    这是java写抓包程序,希望对你们有用 ,自己去下载拓展包
  • java实现http/https抓包拦截

    千次阅读 热门讨论 2019-10-20 15:29:13
    最近在调试一个项目时常常需要对接口进行抓包查看,接口位于微信的公众号内,目前每次调试时都是用的 fiddler进行抓包查看的。但每次打开fiddler去查看对应的接口并找到对应的参数感觉还是有点复杂,正好今天是周末...

    最近在调试一个项目时常常需要对接口进行抓包查看,接口位于微信的公众号内,目前每次调试时都是用的 fiddler进行抓包查看的。但每次打开fiddler去查看对应的接口并找到对应的参数感觉还是有点复杂,正好今天是周末,打算自己来研究下它的原理并自己通过java来写一个(之所以知道java可以实现这个功能是因为著名的web安全检测工具 burpsuite 就是用java写的)

     

    分析

    在使用fiddler或burpsuite时其抓包的原理都是通过代理服务器来实现的。fiddler或burpsuite通过自己创建一个代理服务器对需要拦截的socket请求进行一次中转,其过程有点像中间人的方式,从而可以实现对请求和响应的拦截和修改。

    知道了原理后,那么通过JAVA编写一个用于转发socket的程序就可以实现请求的拦截了.

    为了开发的方便与高效,这里采用netty框架来显示代理服务器的开发

    本文需要的依赖包为:

    <!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
    <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
       <version>4.1.42.Final</version>
    </dependency>

    http请求代理

    微信公众号内的接口目前全都是https的,直接开发https代理程序有一定难度,所以笔者决定在实现https的接口抓包之前还是先来搞定http的抓包拦截功能

    在开发之前先梳理下思图:这里以谷歌浏览器访问百度网站为例,先画下其访问流程图

    http请求无代理

    对于http请求无代理的情况其过程很简单,客户端向服务器发起请求,服务端响应此请求即可

    http请求有代理

    由于http请求太过简单,其所有的数据传输也都是明文传输了。其最大的安全性是很容易受到中间人攻击(MITM)。与MITM类比,那么此处的http代理服务器也就是中间人了。作为中间人服务器,它对于客户端的请求可以进行拦截、查看、过滤、转发、篡改等,由代理服务器处理完毕后再决定是否转发给目标服务器。同时对于目标服务器的响应也由中间的代理服务器先进行处理一遍,再决定怎样传回给客户端。

    如果用netty来实现http的代理服务器其主要代码如下:

    public class HttpProxyHandler extends ChannelInboundHandlerAdapter implements IProxyHandler {
        private Logger logger = LoggerFactory.getLogger(HttpProxyHandler.class);
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            logger.debug("[HttpProxyHandler]");
            if (msg instanceof HttpRequest) {
                HttpRequest httpRequest = (HttpRequest) msg;
                //获取客户端请求
                ClientRequest clientRequest = ProxyRequestUtil.getClientRequest(ctx.channel());
                if (clientRequest == null) {
                    //从本次请求中获取
                    Attribute<ClientRequest> clientRequestAttribute = ctx.channel().attr(CLIENTREQUEST_ATTRIBUTE_KEY);
                    clientRequest = ProxyRequestUtil.getClientReuqest(httpRequest);
                    //将clientRequest保存到channel中
                    clientRequestAttribute.setIfAbsent(clientRequest);
                }
                //如果是connect代理请求,返回成功以代表代理成功
                if (sendSuccessResponseIfConnectMethod(ctx, httpRequest.method().name())) {
                    logger.debug("[HttpProxyHandler][channelRead] sendSuccessResponseConnect");
                    ctx.channel().pipeline().remove("httpRequestDecoder");
                    ctx.channel().pipeline().remove("httpResponseEncoder");
                    ctx.channel().pipeline().remove("httpAggregator");
                    ReferenceCountUtil.release(msg);
                    return;
                }
                if (clientRequest.isHttps()) {
                    //https请求不在此处转发
                    super.channelRead(ctx, msg);
                    return;
                }
                sendToServer(clientRequest, ctx, msg);
                return;
            }
            super.channelRead(ctx, msg);
        }
    
        /**
         * 如果是connect请求的话,返回连接建立成功
         *
         * @param ctx        ChannelHandlerContext
         * @param methodName 请求类型名
         * @return 是否为connect请求
         */
        private boolean sendSuccessResponseIfConnectMethod(ChannelHandlerContext ctx, String methodName) {
            if (Constans.CONNECT_METHOD_NAME.equalsIgnoreCase(methodName)) {
                //代理建立成功
                //HTTP代理建立连接
                HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, Constans.CONNECT_SUCCESS);
                ctx.writeAndFlush(response);
                return true;
            }
            return false;
        }
    
    
        @Override
        public void sendToServer(ClientRequest clientRequest, ChannelHandlerContext ctx, Object msg) {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(ctx.channel().eventLoop())
                    // 注册线程池
                    .channel(ctx.channel().getClass())
                    // 使用NioSocketChannel来作为连接用的channel类
                    .handler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            //添加接收远程server的handler
                            ch.pipeline().addLast(new HttpRequestEncoder());
                            ch.pipeline().addLast(new HttpResponseDecoder());
                            ch.pipeline().addLast(new HttpObjectAggregator(6553600));
                            //代理handler,负责给客户端响应结果
                            ch.pipeline().addLast(new HttpProxyResponseHandler(ctx.channel()));
                        }
                    });
    
            //连接远程server
            ChannelFuture cf = bootstrap.connect(clientRequest.getHost(), clientRequest.getPort());
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (future.isSuccess()) {
                        //连接成功
                        future.channel().writeAndFlush(msg);
                        logger.debug("[operationComplete] connect remote server success!");
                    } else {
                        //连接失败
                        logger.error("[operationComplete] 连接远程server失败了");
                        ctx.channel().close();
                    }
                }
            });
        }
    
        @Override
        public void sendToClient(ClientRequest clientRequest, ChannelHandlerContext ctx, Object msg) {
    
        }
    }

    上面的代码为转发部分的处理代码,其具体完整实现可以查看文末的github地址

    对于http请求响应的处理代码为:

    public class HttpProxyResponseHandler extends ChannelInboundHandlerAdapter {
        private Logger logger = LoggerFactory.getLogger(HttpProxyResponseHandler.class);
        private Channel clientChannel;
    
        public HttpProxyResponseHandler(Channel clientChannel) {
            this.clientChannel = clientChannel;
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            if (msg instanceof FullHttpResponse) {
                FullHttpResponse response = (FullHttpResponse) msg;
                logger.debug("[channelRead][FullHttpResponse] 接收到远程的数据1 content:{}", response.content().toString(Charset.defaultCharset()));
            } else if (msg instanceof DefaultHttpResponse) {
                DefaultHttpResponse response = (DefaultHttpResponse) msg;
                logger.debug("[channelRead][FullHttpResponse] 接收到远程的数据 content:{}", response.toString());
            } else if (msg instanceof DefaultHttpContent) {
                DefaultHttpContent httpContent = (DefaultHttpContent) msg;
                logger.debug("[channelRead][DefaultHttpContent] 接收到远程的数据 content:{}", httpContent.content().toString(Charset.defaultCharset()));
            } else {
                logger.debug("[channelRead] 接收到远程的数据 " + msg.toString());
            }
            //发送给客户端
            clientChannel.writeAndFlush(msg);
        }
    }
    

    https请求拦截

    https的请求相对于http的请求流程稍微复杂一点,目前的浏览器主要采用tls1.2版本和tls1.3版本,在开发https的代理之前,先看一下https采用tls1.2的握手过程是怎么样的

    https tls1.2无代理

    其过程可以通过wireshark抓包进行分析

    通过tls and ip.addr=[目录ip]对https通信过程中的数据进行过滤

    以下为我分析的https中使用的tls1.2版本客户端与服务端的握手过程简要分析,其中参数了一些大牛的文章

    这其中的知识点比较多,如感兴趣可以仔细看下上面我在梳理过程中所画的时序图,如想深入研究可以进入上方的链接进行深入学习。

    我的理解后,其主要就是这样的:CA保证了通信双方的身份的真实性,基于公私钥交换确保了通信过程中的安全性

    对https请求进行代理分析

    回到本文主题,那么想要对https请求进行代理应该如何实现呢?

    在了解了https的通信过程后,那么我们有两种办法可以对https的请求进行代理:

    1. 获取到所要代理网站https证书颁发机构的私钥,也就是ca根证书的私钥,然后自己再重新颁发一个新的证书返回给被代理的客户端
    2. 自己生成一个ca证书,然后导入到将要被代理的客户端中,让其信任,随后再针对将要代理的请求动态生成https证书

    通过分析后我们可以知道,想要获取到ca根证书的私钥是不太可能的,据说ca根证书都是离线存储的,一般人拿不到的(一个https证书一年收费上千块不是开玩笑的),ca的代理机构的证书也是这个道理。

    那么通过上面的再次分析后通过方案1来进行请求代理的可行性还高一些,其代理过程可以简单如下图:

    在分析过后并自己画一个流程图后对于https的代理实现流程清晰多了,其实目前市面上的许多支持https的代理软件都是采用的这种方式来实现的,无论是常见的抓包利器fidder还是大名鼎鼎的安全测试工具BurpSuite都是基于此种方式来做的实现

    https代理基于netty的实现

    在有了上面的分析后,其实想要自己去实现一个https的代理服务器还是有一定难度的,https握手的细节实现就足以让人费事费力了。但在同样大名鼎鼎的netty框架面前这些都是小事儿!netty中的SslContext类帮我们完成了这些细节的实现,我们只管如何调用它遍可完成对https的握手了,框架就是框架,强大哇!

    由于时间关系,对于其实现的具体代码这里不做详细分析了,我已把代码提交到github上了.

    开源项目easyHttpProxy

    其具体的实现可以参考源码:https://github.com/puhaiyang/easyHttpProxy

    为了使用的方便,我也将此项目上传到了maven公网,其maven为:

    <dependency>
      <groupId>com.github.puhaiyang</groupId>
      <artifactId>easy-http-proxy</artifactId>
      <version>0.0.1</version>
    </dependency>

    使用时添加依赖包后,调用

    EasyHttpProxyServer.getInstace().start(6667);

    即可,其中6667为代理服务器监听的端口号,目前已支持了http/https并针对其他请求直接进行转发.

    如果不想自己生成证书,记得将jar包中的ca.crt、ca.key、ca_private.der拷贝的项目的运行根目录下,即classes path下,要不然https代理时会找不到ca根证书会出错。

    同时,记得将ca.crt导入到根证书

    具体步骤可见此截图:

    欢迎留言评论,共同学习共同进步!

     

     

    展开全文
  • 基于java的网络抓包

    2013-08-13 12:17:55
    基于java的网络抓包方法,通过java代码来抓取网络包
  • Java TCP 抓包简单示例

    万次阅读 热门讨论 2017-11-05 16:27:49
    Java TCP 抓包简单示例由于目前网上没有篇能真正方便读者操作的此类文章,本文对此通过示例做简单介绍。缘起有天本来在看头条,然后看到则游戏的广告,是《大唐帝国》的,看画面可能是我喜欢的建造类型...

    Java TCP 抓包简单示例

    由于目前网上没有一篇能真正方便读者操作的此类文章,本文对此通过示例做个简单介绍。

    缘起

    有一天本来在看头条,然后看到一则游戏的广告,看画面可能是我喜欢的建造类型(纪元1404,卡特尔一类)的游戏,就下载玩了。由于同时间我在看《网络是怎样连接的》,所以就在想如何通过抓包获取游戏中的地图数据。

    这里写图片描述

    这里写图片描述

    这里写图片描述

    前两张图是游戏截图,暴露了个人坐标,和三体中暴露地球坐标一样危险。

    第3张图是最近刚看过的一本书,是一本很详细介绍网络连接的书,但不是TCP抓包方面的书。

    抓包过程中发现地图数据很难分析,但是世界对话却很简单,因此就开始分析对话,分析出来后,就想着怎么写个程序来获取这些数据呢,网上搜了一些例子,都是比较早的,而且64位支持的不是很好,所以就有了本文。

    准备工作

    由于我很早之前安装 Wireshark 的时候安装过 winpcap,所以没有注意这个软件的兼容性,下载地址如下:

    https://www.winpcap.org/

    Windows 必须安装的一个软件,其他工具都是基于 winpcap 的。

    现在网上能查到和 Java 抓包相关的基本都是 jPcap,由于找不到版本配套的下载文件和64位的 dll,我找到了另一个工具 jnetpcap

    下载地址:https://github.com/ruedigergad/clj-net-pcap/blob/master/jnetpcap/jnetpcap-src-1.4.r1425-1.zip

    打开页面点击下载,这个链接不能直接通过迅雷等软件下载。

    对应网盘地址:http://pan.baidu.com/s/1o7GvB5o 密码:5g1y

    下载解压后,将 jnetpcap.dll 和 jnetpcap-pcap100.dll 放到 Java 的 bin 和 jre/bin 两个目录下。

    额外准备

    希望这个游戏能坚持到你看这篇文章的时候。

    如果你想按照我这里的过程,针对这个游戏进行抓包测试,可以额外装一些软件进行,如果仅仅是如何使用 Java 抓包,不需要这些。

    通过安卓抓包软件简单获取服务器IP等信息,如下图:

    这里写图片描述

    简单抓包数据分析:

    这里写图片描述

    分解代码

    以下内容和游戏无关,就是基本的用法。

    获取网卡

    通过下面代码获取当前机器的网卡信息。

    StringBuilder errbuf = new StringBuilder();
    
    int r = Pcap.findAllDevs(alldevs, errbuf);
    if (r == Pcap.NOT_OK || alldevs.isEmpty()) {
        System.err.printf("Can't read list of devices, error is %s", errbuf
                .toString());
        return;
    }

    输出网卡的信息。

    System.out.println("Network devices found:");
    
    int i = 0;
    for (PcapIf device : alldevs) {
        System.out.printf("#%d: %s [%s]\n", i++, device.getName(), device
                .getDescription());
    }

    在我电脑上输出的信息如下。

    Network devices found:
    #0: \Device\NPF_{22788384-70D1-47E6-A182-DEAE1D091D2C} [VMware Virtual Ethernet Adapter]
    #1: \Device\NPF_{144877C1-CBA4-4E7A-B408-E482BFA7F59D} [VMware Virtual Ethernet Adapter]
    #2: \Device\NPF_{93282E0F-D399-4904-95D5-062F4325FD48} [Microsoft]
    #3: \Device\NPF_{055061E0-011E-488C-BF6C-D48252BCDEAB} [Microsoft]
    #4: \Device\NPF_{6246A8BA-F000-4355-B3E0-5CAAF7229813} [VMware Virtual Ethernet Adapter]
    #5: \Device\NPF_{E4AB7839-5786-427B-BB2A-E8C40C529494} [Realtek PCIe GBE Family Controller]

    名字相同的网卡很难区分,还可以通过 device 获取网卡的 IP 信息来轻松识别网卡。

    选择一个要监控的网卡

    PcapIf device = alldevs.get(2);

    可以根据更多信息来匹配一个网卡,这里简单选择的第3个网卡。

    打开设备

    int snaplen = 64 * 1024;
    int flags = Pcap.MODE_PROMISCUOUS;
    int timeout = 10 * 1000;
    Pcap pcap = Pcap.openLive(device.getName(), snaplen, flags, timeout, errbuf);
    
    if (pcap == null) {
        System.err.printf("Error while opening device for capture: "
                + errbuf.toString());
        return;
    }

    创建一个数据包处理器

    PcapHandler<String> printSummaryHandler = new PcapHandler<String>() {
    
        public void nextPacket(String user, long seconds, int useconds,
                               int caplen, int len, ByteBuffer buffer) {
            Date timestamp = new Date(seconds * 1000 + useconds/1000); // In millis
    
            System.out.printf("Received packet at %s caplen=%-4d len=%-4d %s\n",
                    timestamp.toString(), // timestamp to 1 ms accuracy
                    caplen, // Length actually captured
                    len,    // Original length of the packet
                    user    // User supplied object
            );
        }
    };

    循环监听 10 个

    //可以修改 10 为 Integer.MAX_VALUE 来长期监听
    pcap.loop(10, printSummaryHandler, "jNetPcap rocks!");
    //监听结束后关闭
    pcap.close();

    上述过程的完整代码见文末。

    解析数据

    前面提到的游戏,我个人对其中的世界聊天部分进行了分析,还提供了基于 Spring Boot 和 websocket 的小程序,可以启动后通过网页查看。

    启动方法:

    1. 按照前面的要求配置好基础环境
    2. 安卓模拟器安装游戏,在12区创建一个账号(可以修改下面源码配置文件中的服务器IP)
    3. 登陆游戏后,下载下面的源码,修改代码中选择网卡的地方,改成自己连接网络的那个网卡
    4. 启动 TalkApplication 后访问 localhost:9090 即可

    源码下载:

    链接:http://pan.baidu.com/s/1min9JCk 密码:6sfd

    已知问题:websocket 中没有维持心跳包,因此过段时间后会自动断开。

    效果图:

    这里写图片描述

    这里写图片描述

    完整示例代码

    import org.jnetpcap.Pcap;
    import org.jnetpcap.PcapHandler;
    import org.jnetpcap.PcapIf;
    
    import java.nio.ByteBuffer;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    public class ClassicPcapExample {
    
        public static void main(String[] args) {
            List<PcapIf> alldevs = new ArrayList<PcapIf>(); // Will be filled with NICs
            StringBuilder errbuf = new StringBuilder();     // For any error msgs
    
            /********************************************
             * First get a list of devices on this system
             ********************************************/
            int r = Pcap.findAllDevs(alldevs, errbuf);
            if (r == Pcap.NOT_OK || alldevs.isEmpty()) {
                System.err.printf("Can't read list of devices, error is %s", errbuf
                        .toString());
                return;
            }
    
            System.out.println("Network devices found:");
    
            int i = 0;
            for (PcapIf device : alldevs) {
                System.out.printf("#%d: %s [%s]\n", i++, device.getName(), device
                        .getDescription());
            }
    
            PcapIf device = alldevs.get(2); // We know we have atleast 1 device
            System.out.printf("\nChoosing '%s' on your behalf:\n", device
                    .getDescription());
    
            /***************************************
             * Second we open up the selected device
             ***************************************/
            int snaplen = 64 * 1024;           // Capture all packets, no trucation
            int flags = Pcap.MODE_PROMISCUOUS; // capture all packets
            int timeout = 10 * 1000;           // 10 seconds in millis
            Pcap pcap = Pcap
                    .openLive(device.getName(), snaplen, flags, timeout, errbuf);
    
            if (pcap == null) {
                System.err.printf("Error while opening device for capture: "
                        + errbuf.toString());
                return;
            }
    
            /**********************************************************************
             * Third we create a packet hander which will be dispatched to from the
             * libpcap loop.
             **********************************************************************/
            PcapHandler<String> printSummaryHandler = new PcapHandler<String>() {
    
                public void nextPacket(String user, long seconds, int useconds,
                                       int caplen, int len, ByteBuffer buffer) {
                    Date timestamp = new Date(seconds * 1000 + useconds/1000); // In millis
    
                    System.out.printf("Received packet at %s caplen=%-4d len=%-4d %s\n",
                            timestamp.toString(), // timestamp to 1 ms accuracy
                            caplen, // Length actually captured
                            len,    // Original length of the packet
                            user    // User supplied object
                    );
                }
            };
    
            /************************************************************
             * Fourth we enter the loop and tell it to capture 10 packets
             ************************************************************/
            pcap.loop(10, printSummaryHandler, "jNetPcap rocks!");
    
            /*
             * Last thing to do is close the pcap handle
             */
            pcap.close();
        }
    
    }
    
    展开全文
  • 得到一个java开发的网络抓包程序源码,拿出来和大家分享一下
  • java网路抓包

    2014-06-03 20:21:37
    使用java语言编写的网路抓包程序,仅供参考学习,不可用来网络抓取别人数据,做不正当的用途
  • java抓包需要的包

    2014-12-30 19:46:11
    java抓包程序,使用jpcpa.jar包 java的JPCAP.jar,不过一直调用的都是winpcap(jpcap.dll)实现的许多接口。 压缩包包含 jpcap.jar和jpcap.dll
  • java抓包程序设计报告

    2016-05-05 13:30:29
    一个简易的java抓包程序的设计,捕获通过指定网络接口的信息并显示出来,以方便了解和管理自己的网络。
  • 这是基于java的局域网抓包分析软件,用于分析病毒扩散规律。是学校的大创项目,拿过省级挑战杯三等奖,文档内部有jpcap.jar & jdbc.jar 如果下载下来不好用的话请联系我邮箱cheng_monk@163.com 我看到后会及时回复的...
  • java android tcpdump抓包

    2017-11-13 18:34:04
    java android tcpdump抓包 最近研究了一下怎样使用java 在android 执行tcpdump进行抓包 找了好多资料都不怎么准确,这里就记录一下提供参考 方法主要放在execCmd 里面了 生成的 pacp 文件主要是可以配合 ...

    java android tcpdump抓包

    最近研究了一下怎样使用java 在android 执行tcpdump进行抓包
    找了好多资料都不怎么准确,这里就记录一下提供参考
    方法主要放在execCmd 里面了
    生成的 pacp 文件主要是可以配合 wireshark 查看抓包到的内容

    说一下遇到的几个问题:
    1. tcpdump 如果手机上没有,需要自己下载一个,adb push 到自己手机上。
    2. 执行tcpdump 需要root 权限,没有权限执行不了
    3. su 和 后面的命令不能放在一条执行,例如:su tcpdump -c xxx /xxx/xx
    4. 新的一行命令后面要加 \n 才能执行成功!!!

    package com.example.arvinliu.tcpdump;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.util.Log;
    import java.io.*;
    
    public class MainActivity extends AppCompatActivity {
    
        public DataOutputStream mOutputStream;
        private Process mProcess = null;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Log.i("start executing","+++++++++++++++++++++++++++++");
            execCmd();
            Log.i("done","$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
        }
    
        public boolean execCmd() {
            try {
                Process process = Runtime.getRuntime().exec("su");
                InputStreamReader in = new InputStreamReader(process.getInputStream());
                DataOutputStream out = new DataOutputStream(process.getOutputStream());
                BufferedReader br = new BufferedReader(in);
                out.writeBytes("/sdcard/tcpdump/tcpdump -i any -p -s 0 -c 10 -w /sdcard/tcpdump/c3.pcap \n");
                out.writeBytes("exit \n");
                out.flush();
                String line;
                while ((line = br.readLine()) != null){
                    Log.i("output==>",line);
                }
                br.close();
                in.close();
                out.close();
                return false;
            } catch (Exception e) {
                return false;
            }
        }
    }
    
    展开全文
  • java抓包转发详细资料

    2014-06-04 21:51:00
    java抓包转发详细资料。亲测可以使用。
  • java网络抓包程序

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

    热门讨论 2011-01-07 11:36:09
    java实现对网络的抓取,对数据包的分析,然后对http数据包进行重组还原成网页。
  • java网络抓包实验报告

    2013-04-01 10:55:56
    java网络抓包实验报告,内有详细的源代码可以参考
  • java利用Jpcap实现抓包

    万次阅读 2018-02-16 14:31:57
    Jpcap是一个可以监控当前网络情况的中间件,弥补了java对网络层以下的控制, 可以达到抓包的效果。 Jpcap运行需要依赖winCap和Jpcap的dll动态库和Jpcap.jar包。 这个我贴出来两个exe文件,一 一安装后 ...
  • 毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络抓包程序毕业论文:JAVA网络...
  • java使用jnetpcap实现的抓包简单实例,可以实现网卡下拉选择,然后点击获取报文,从后台查看报文日志

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,753
精华内容 19,501
关键字:

java写一个抓包

java 订阅