Netty学习10--粘包分包分析,如何避免socket攻击

最新推荐文章于 2024-05-24 17:50:34 发布
最新推荐文章于 2024-05-24 17:50:34 发布
阅读量641 收藏 1
点赞数 1
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33371766/article/details/106819003
版权 
1、消息如何在管道中流转

当前的一个handler如何往下面的一个handler传递一个对象

一个管道中会有多个handler


handler往下传递对象的方法是sendUpstream(event)

2、看下粘包和分包是怎么样一个情况
hello hello

定义一个稳定的结构 length + hello


心中会有连个疑惑

1、为什么FrameDecoder return的对象就是往下传递的对象  （还是调用了sendUpstream）

2、buffer里面数据未被读取完怎么办？    （cumulation缓存）

3、为什么return null就可以缓存buffer     （cumulation缓存）

=============================分割线===========================

3、FrameDecoder里面的cumulation其实就是一个缓存的buffer对象
包头+长度+数据

Intger.max

把长度定义的很大，这种数据包，通常被称为socket攻击，字节流式攻击

2048

分包截断

1.pipeline模块实现

MyHandler1
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.UpstreamMessageEvent;

public class MyHandler1 extends SimpleChannelHandler {

	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

		ChannelBuffer buffer = (ChannelBuffer)e.getMessage();
		
		byte[] array = buffer.array();
		String message = new String(array);
		System.out.println("handler1:" + message);
		
		//传递
		ctx.sendUpstream(new UpstreamMessageEvent(ctx.getChannel(), "abc", e.getRemoteAddress()));
		ctx.sendUpstream(new UpstreamMessageEvent(ctx.getChannel(), "efg", e.getRemoteAddress()));
	}
}

MyHandler2
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;

public class MyHandler2 extends SimpleChannelHandler {

	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

		String message = (String)e.getMessage();
		
		System.out.println("handler2:" + message);
	}
}

Server
import java.net.InetSocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

public class Server {

	public static void main(String[] args) {
		//服务类
		ServerBootstrap bootstrap = new ServerBootstrap();
		
		//boss线程监听端口，worker线程负责数据读写
		ExecutorService boss = Executors.newCachedThreadPool();
		ExecutorService worker = Executors.newCachedThreadPool();
		
		//设置niosocket工厂
		bootstrap.setFactory(new NioServerSocketChannelFactory(boss, worker));
		
		//设置管道的工厂
		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
			
			@Override
			public ChannelPipeline getPipeline() throws Exception {

				ChannelPipeline pipeline = Channels.pipeline();
				pipeline.addLast("handler1", new MyHandler1());
				pipeline.addLast("handler2", new MyHandler2());
				return pipeline;
			}
		});
		
		bootstrap.bind(new InetSocketAddress(8011));
		
		System.out.println("start.");
	}

}

Client
import java.net.Socket;

public class Client {

	public static void main(String[] args) throws Exception {

		Socket socket = new Socket("127.0.0.1", 8011);
		
		socket.getOutputStream().write("hello".getBytes());
		
		socket.close();
	}

}

测试，启动server和client，handler1和2成功收到消息。

****************packet模块实现**************

MyDecoder
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.frame.FrameDecoder;

public class MyDecoder extends FrameDecoder {

	@Override
	protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {

		if(buffer.readableBytes() > 4){
			
			if(buffer.readableBytes() > 2048){
				buffer.skipBytes(buffer.readableBytes());
			}
			
			
			//标记
			buffer.markReaderIndex();
			//长度
			int length = buffer.readInt();
			
			if(buffer.readableBytes() < length){
				buffer.resetReaderIndex();
				//缓存当前剩余的buffer数据，等待剩下数据包到来
				return null;
			}
			
			//读数据
			byte[] bytes = new byte[length];
			buffer.readBytes(bytes);
			//往下传递对象
			return new String(bytes);
		}
		//缓存当前剩余的buffer数据，等待剩下数据包到来
		return null;
	}

}

HelloHandler

import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;

public class HelloHandler extends SimpleChannelHandler {
	
	private int count = 1;

	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
		System.out.println(e.getMessage() + "  " +count);
		count++;
	}
}

Server
import java.net.InetSocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

public class Server {

	public static void main(String[] args) {
		//服务类
		ServerBootstrap bootstrap = new ServerBootstrap();
		
		//boss线程监听端口，worker线程负责数据读写
		ExecutorService boss = Executors.newCachedThreadPool();
		ExecutorService worker = Executors.newCachedThreadPool();
		
		//设置niosocket工厂
		bootstrap.setFactory(new NioServerSocketChannelFactory(boss, worker));
		
		//设置管道的工厂
		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
			
			@Override
			public ChannelPipeline getPipeline() throws Exception {

				ChannelPipeline pipeline = Channels.pipeline();
				pipeline.addLast("decoder", new MyDecoder());
				pipeline.addLast("handler", new HelloHandler());
				return pipeline;
			}
		});
		
		bootstrap.bind(new InetSocketAddress(8010));
		
		System.out.println("start.");
	}

}

Client
import java.net.Socket;
import java.nio.ByteBuffer;

public class Client {

	public static void main(String[] args) throws Exception {
		Socket socket = new Socket("127.0.0.1", 8010);
		
		String message = "hello";
		
		byte[] bytes = message.getBytes();
		
		ByteBuffer buffer = ByteBuffer.allocate(4 + bytes.length);
		buffer.putInt(bytes.length);
		buffer.put(bytes);
		
		byte[] array = buffer.array();
			
		for(int i=0; i < 500; i++){
			socket.getOutputStream().write(array);
		}
			
		socket.close();
	}

}

启动server和client，第一次运行会出现以下警告，再次运行client发送消息，成功！

最后的如何避免socket攻击

RequestDecoder（Netty学习09--自定义数据包协议有实现）
package com.cxb.common.codc;

import com.cxb.common.constant.ConstantValue;
import com.cxb.common.model.Request;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.frame.FrameDecoder;


/**
 * 请求解码器
 * <pre>
 * 数据包格式
 * +——----——+——-----——+——----——+——----——+——-----——+
 * | 包头          | 模块号        | 命令号      |  长度        |   数据       |
 * +——----——+——-----——+——----——+——----——+——-----——+
 * </pre>
 * 包头4字节
 * 模块号2字节short
 * 命令号2字节short
 * 长度4字节(描述数据部分字节长度)
 *
 */
public class RequestDecoder extends FrameDecoder{
	
	/**
	 * 数据包基本长度
	 */
	public static int BASE_LENTH = 4 + 2 + 2 + 4;

	@Override
	protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer) throws Exception {
		
		//可读长度必须大于基本长度
		if(buffer.readableBytes() >= BASE_LENTH){
			//防止socket字节流攻击
			if(buffer.readableBytes() > 2048){
				buffer.skipBytes(buffer.readableBytes());
			}
			
			//记录包头开始的index
			int beginReader;
			
			while(true){
				beginReader = buffer.readerIndex();
				buffer.markReaderIndex();
				if(buffer.readInt() == ConstantValue.FLAG){
					break;
				}
				
				//未读到包头，略过一个字节
				buffer.resetReaderIndex();
				buffer.readByte();
				
				//长度又变得不满足
				if(buffer.readableBytes() < BASE_LENTH){
					return null;
				}
			}
			
			//模块号
			short module = buffer.readShort();
			//命令号
			short cmd = buffer.readShort();
			//长度
			int length = buffer.readInt();
			
			//判断请求数据包数据是否到齐
			if(buffer.readableBytes() < length){
				//还原读指针
				buffer.readerIndex(beginReader);
				return null;
			}
			
			//读取data数据
			byte[] data = new byte[length];
			buffer.readBytes(data);
			
			Request request = new Request();
			request.setModule(module);
			request.setCmd(cmd);
			request.setData(data);
			
			//继续往下传递 
			return request;
			
		}
		//数据包不完整，需要等待后面的包来
		return null;
	}

}

代码下载​​​​​​​

小石潭记丶
关注
专栏目录
【Netty入门】解决TCP粘包/分包的实例
白夜行
06-13 4210
回顾TCP粘包/分包问题的解决方法1.消息定长2.在包尾都增加特殊字符进行分割3.将消息分为消息头和消息体针对这三种方法，下面我会分别举例验证FixedLengthFrameDecoder类对应第一种解决方法：消息定长（1）例1：服务端代码：public class Server4 { public static void main(String[] args) throws SigarEx
Netty4实战 - TCP粘包&拆包解决方案
热门推荐
Ricky
03-15 1万+
Netty4实战 - TCP粘包&拆包解决方案
Netty粘包分包现象及解决方案实战，防socket攻击
11-09
Netty粘包分包现象及解决方案实战，防socket攻击水。
Netty学习10-Netty的socket攻击及预防
jiang_zf的博客
11-26 1825
在前面的文章我们说到过，可以采用长度+数据的格式定义包结构；但是如果长度定义的特别大，那么缓冲区必然会存储不下，而引起宕机或其他问题。这便是一种socket攻击。 除此之外，如果定义的长度和实际长度不匹配，比如实际长度为5，定义的长度为6，那么读取的时候可能会把下一个数据包的一部分读取到，造成以后的数据不能正常解析；这也是一种socket攻击。 可以通过以下几个方面处理socket攻击： 1...
防止IP攻击
u010898743的博客
02-25 2498
1.一段时间内ip连接数大于一定值则断开该ip所有连接且拒绝ip一定时间内连接 2.一段时间内ip连接所发送的数据大于一定值则断开该ip所有连接且拒绝ip一定时间内连接 其实是实现判断频率的一种算法，有一个陷阱是如何判断连续时间内的频率，因为把时间分成一段段的话，按不同起始时间来分话频率会不一样。所以这个判断算法是有一定精度的，就是多久判断一次。相当于这个时间窗口移动的精度。 ...
SOCKET通信端口被攻击
u010174217的专栏
06-23 825
SOCKET通信端口被攻击 公司项目在使用SOCKET通信功能时，因为公司使用的是阿里云服务器，并且防火墙功能也使用了，在阿里云服务器中要放开对应SOCKET通信的端口，放开端口后就会出现被攻击的现象，在最开始阿里云服务器配置放开项目的对应端口时，一开始以为是SOCKET通信程序的逻辑出问题了，碰到以下两个问题： 问题1：阿里云服务器的监控功能默认每5秒访问这个端口一次，以此判断此端口是否畅通的。这个是阿里云服务器内部检测的功能， TCP协议端口检测功能不能关闭。 解决方案：把默认每...
netty的理解
try4family的博客
05-04 691
1、传统IO 传统IO的server端在执行接收连接的方法(server.accept();)、 连接上后从流中读取数据的方法(inputStream.read(bytes);)都会阻塞住 主线程中监听client端的连接，建立连接后得到socket得到inputstream就可以读取数据了，如果是不停的读取，那么就不能接收其他client的 连接请求了，因...
spring-boot 建socket服务器，处理物联网设备的粘包分包
04-09
spring-boot源码
Unity socket 案例包含粘包处理
08-07
4. **定长数据包**：每个数据包大小固定，这样接收方可以按固定大小读取数据，避免粘包问题。 5. **缓冲区管理**：在接收端维护一个缓冲区，当接收到数据时，先存入缓冲区，然后根据预先设定的规则从缓冲区中提取...
Socket粘包问题终极解决方案—Netty版（2W字）！
awangdea99的博客
05-15 237
上一篇我们讲了《Socket粘包问题的3种解决方案》，但没想到评论区竟然炸了。介于大家的热情讨论，以及不同的反馈意见，本文就来做一个扩展和延伸，试图找到问题的最优解，以及消息通讯的最优解决方案。 在正式开始之前，我们先对上篇评论中的几个典型问题做一个简单的回复，不感兴趣的朋友可直接划过。 问题一：TCP存在粘包问题吗？ 先说答案：TCP 本身并没有粘包和半包一说，因为 TCP 本质上只是一个传输控制协议（Transmission Control Protocol，TCP），它是一种面向连接的、可靠的、
netty如何解决粘包和半包
weixin_33851429的博客
08-18 311
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot + Netty 实现 TCP拆包粘包处理、TCP恶意连接拦截
qq_39648078的博客
08-01 1363
只根据IP来做校验不带端口号，因为客户端发起的每一次TCP连接端口号都不同！Jmeter模拟TCP连接，向我们TCP服务异步发起120个连接。
Netty底层剖析——TCP粘包和粘包
Durian_piza的博客
07-14 263
TCP无法理解上层的业务数据，即从哪里开始，从哪里结束 1.发送方发送的数据经过 MSS(最大报文长度)大小的 TCP 分段，当TCP 数据量 - TCP头部长度 > MSS的时候将发生拆包 2.应用程序写入的数据大于 套接口发送缓冲区大小，将会发生拆包 3.发送方写入数据小于 socket 缓冲区大小，网卡将其多次写入的数据一起发送，将会发生粘包 4.接收方不及时读取 socket 缓冲区数据，可能发生粘包 5.以太网帧的payload大于MTU进行IP分片 csdn：https://blog.csd
在Netty服务被N次攻击之后，终于抓到现行了！
程序新视界
02-04 1436
马上就要过春节了，本想着完成手头的任务就可以准备过年了。没想到Netty服务器又被攻击了，当收到服务器报警（CPU飙升报警）信息，就知道对方又下手了。 之前是交给下面的兄弟来解决，这次为了过个好年，决定亲自动手把这事给了结了。 故事前奏 Netty服务是公司比较边缘的服务，只有一台设备在使用，而且代码是之前技术Leader（已离职）写的，加上一直赶工期，所以就没抽出时间去彻底解决这事。 当初被攻击没排查代码，看到遭到疯狂请求、CPU跑满、日志打满，还以为是遭遇DDoS攻击了。 临时采取了几个措施： 分离服
使用netty实现并维护TCP长连接
shadowdowdow的博客
12-01 8074
使用netty实现并维护TCP长连接Netty是什么Netty的优点Netty为什么并发高创建TCP长连接实例 Netty是什么 Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是一个广泛使用的 Java 网络编程框架（Netty 在 2011 年获得了Duke’s Choice Award，见https://www.java.net/dukeschoice/2011）。它活跃和成长于用户社区，像大型公司 Faceboo
Netty解决TCP的粘包和分包（一）
weixin_34034261的博客
07-29 1022
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty中的粘包问题处理
最新发布
全栈工程师，热爱编程，喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得，以及在项目开发中的实践经验。
05-24 480
根据应用场景和需求设计自定义协议，可以更加灵活和高效地解决粘包问题。例如，在消息头部添加标识字段、校验字段等信息。粘包问题是网络编程中常见的问题，尤其是在使用TCP协议时。Netty提供了多种解决粘包和拆包问题的方案，包括定长消息、使用分隔符、使用长度字段和自定义协议。每种方案都有其适用的场景和优缺点，开发者需要根据实际需求选择合适的方案。通过示例代码，我们展示了如何在Netty中实现这些方案，并对每种方案的原理和实现进行了详细介绍。希望本文能帮助读者更好地理解和解决Netty中的粘包问题。
有了这个网络安全面试题，面试就像开了挂！（附PDF）
lvaolan的博客
02-26 1128
还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！【完整版领取方式在文末！！​​​​内容实在太多，不一一截图了。
netty-websocket-spring-boot-starter
06-28
Netty-WebSocket-Spring-Boot-Starter是一个用于将Websocket集成到Spring Boot应用程序中的库。它使用Netty作为底层框架，提供了一种快速和可靠的方式来处理异步通信。 这个库提供了一种简单的方法来创建Websocket...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值