Netty使用SslHandler实现加密通信

已于 2023-11-02 11:53:09 修改
阅读量1.3k 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 技术文档 文章标签： Netty加密通信 Netty
于 2023-10-17 18:30:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Josh_scott/article/details/133890164
本文详细介绍了如何使用Netty库在Java中实现一个支持双向认证的SSL服务器，包括引入依赖、生成keystore文件、配置SslContext以及在Server和Client端的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

“不积跬步，无以至千里。”

说明

Netty使用SslHandler实现加密通信，认证方式为双向认证，单向认证忽略，话不多说，直接上代码

引入依赖

<dependency>
  <groupId>io.netty</groupId>
  <artifactId>netty-all</artifactId>
  <version>4.1.100.Final</version>
</dependency>

生成keystore.jks文件

keytool -genkeypair -alias your_alias -keyalg RSA -keystore keystore.jks -keysize 2048

Server端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslProvider;
import io.netty.util.CharsetUtil;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyStore;

public class NettySslServer {

    private static final int PORT = 8888;

    public static void main(String[] args) throws Exception {
        // 加载SSL证书
        String serverKeyStorePath = "/home/admin/server/keystore.jks";
        String clientKeyStorePath = "/home/admin/client/keystore.jks";
        String serverKeyStorePassword = "happya";
        String clientKeyStorePassword = "happya";

        // 创建SslContext
        KeyStore keyStore = KeyStore.getInstance("JKS");
        try (InputStream keyStoreInputStream = new FileInputStream(serverKeyStorePath)) {
            keyStore.load(keyStoreInputStream, serverKeyStorePassword.toCharArray());
        }

        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, serverKeyStorePassword.toCharArray());

        KeyStore trustStore = KeyStore.getInstance("JKS");
        try (InputStream trustStoreInputStream = new FileInputStream(clientKeyStorePath)) {
            trustStore.load(trustStoreInputStream, clientKeyStorePassword.toCharArray());
        }

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);

        SslContext sslContext = SslContextBuilder.forServer(keyManagerFactory)
                    .trustManager(trustManagerFactory)
                    .sslProvider(SslProvider.OPENSSL)
                    .build();
        // 创建EventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建服务器Bootstrap
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 在ChannelPipeline中添加SslHandler
                            pipeline.addLast(sslContext.newHandler(ch.alloc()));
                            // 添加加密通信处理器
                            pipeline.addLast(new SecureChatServerHandler());
                        }
                    })
                    .childOption(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 启动服务器
            System.out.println("======Begin to start ssl server======");
            ChannelFuture future = serverBootstrap.bind(PORT).sync();
            System.out.println("======Ssl server started======");
            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static class SecureChatServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            // 当连接建立时，发送欢迎消息
            System.out.println("Server channel active : " + ctx.channel().toString());
            ctx.channel().writeAndFlush(Unpooled.wrappedBuffer("Welcome to the secure chat server!\n".getBytes(StandardCharsets.UTF_8)));
            ctx.channel().writeAndFlush(Unpooled.wrappedBuffer("Your connection is protected by SSL.\n".getBytes(StandardCharsets.UTF_8)));
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ByteBuf byteBuf= (ByteBuf) msg;
            System.out.println("Server received message: " + byteBuf.toString(CharsetUtil.UTF_8));
            super.channelRead(ctx, msg);
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            // 处理异常
            cause.printStackTrace();
            ctx.close();
        }
    }
}

Client端

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslProvider;
import io.netty.util.CharsetUtil;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyStore;

public class NettySslClient {

    private static final String HOST = "localhost";
    private static final int PORT = 8888;

    public static void main(String[] args) throws Exception {
        // 加载SSL证书
        String serverKeyStorePath = "/home/admin/server/keystore.jks";
        String clientKeyStorePath = "/home/admin/client/keystore.jks";
        String serverKeyStorePassword = "happya";
        String clientKeyStorePassword = "happya";

        // 创建SslContext
        KeyStore keyStore = KeyStore.getInstance("JKS");
        try (InputStream keyStoreInputStream = new FileInputStream(clientKeyStorePath)) {
            keyStore.load(keyStoreInputStream, clientKeyStorePassword.toCharArray());
        }

        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, clientKeyStorePassword.toCharArray());

        KeyStore trustStore = KeyStore.getInstance("JKS");
        try (InputStream trustStoreInputStream = new FileInputStream(serverKeyStorePath)) {
            trustStore.load(trustStoreInputStream, serverKeyStorePassword.toCharArray());
        }

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);

        // 创建EventLoopGroup
        EventLoopGroup group = new NioEventLoopGroup();
		SslContext sslContext = SslContextBuilder.forClient()
                    .keyManager(keyManagerFactory)
                    .trustManager(trustManagerFactory)
                    .sslProvider(SslProvider.OPENSSL)
                    .build();
        try {
            // 创建客户端Bootstrap
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 在ChannelPipeline中添加SslHandler
                            pipeline.addLast(sslContext.newHandler(ch.alloc());
                            // 添加加密通信处理器
                            pipeline.addLast(new SecureChatClientHandler());
                        }
                    });

            // 连接服务器
            System.out.println("======Begin to start ssl client======");
            ChannelFuture future = bootstrap.connect(HOST, PORT).sync();
            System.out.println("======Ssl client started======");
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static class SecureChatClientHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            // 连接建立时，发送一条消息给服务器
            System.out.println("Client channel active : " + ctx.channel().toString());
            ctx.channel().writeAndFlush(Unpooled.wrappedBuffer("Hello from client!\n".getBytes(StandardCharsets.UTF_8)));
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ByteBuf byteBuf = (ByteBuf) msg;
            System.out.println("Client received message: \n" + byteBuf.toString(CharsetUtil.UTF_8));
            super.channelRead(ctx, msg);
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            // 处理异常
            cause.printStackTrace();
            ctx.close();
        }
    }
}

测试结果

server

======Begin to start ssl server======
======Ssl server started======
Server channel active : [id: 0x6cbfa6c6, L:/127.0.0.1:8888 - R:/127.0.0.1:58440]
Server received message: Hello from client!

client

======Begin to start ssl client======
======Ssl client started======
Client channel active : [id: 0x9a642804, L:/127.0.0.1:58440 - R:localhost/127.0.0.1:8888]
Client received message: 
Welcome to the secure chat server!
Your connection is protected by SSL.
Netty使用SSL实现双向通信加密
我是香菜
01-03 1702
最近项目有个需求，TCP服务器实现基于证书通信加密，之前没做过，花了一些时间调研，今天整理下。
netty中对TLS支持详解
最新发布
技术人集结地
04-20 146
Netty作为高性能的异步网络框架，其TLS（Transport Layer Security）支持是构建安全通信的核心功能。以下是Netty中TLS支持的实现细节、配置方法及最佳实践的详细解析
基于springboot的Netty的SSL加密PKI认证通信
04-01
采用springboot的基于Netty的SSL加密PKI认证通信，里面模拟了Netty的客户端和服务端的证书认证规则，同时分为单向认证和双向认证，信任证书链并对RA颁发的证书来进行验签，实现了双向和单向加密通信，保障了数据的安全，代码稳定运行，适合做教学案例，开发模块指引，项目代码整合。
在netty中使用protobuf并实现数据加密传输
xindoo
07-24 2534
在netty中使用protobuf，并且完成数据加密传输的一个简单示例。
Netty传输链路中，使用TLSv1.3传输层安全协议进行加密如何实现
panying941206的博客
07-18 980
netty中如何使用TLSv1.3协议进行加密
Netty+ssl
weixin_42394137的博客
10-28 931
Netty + ssl 双向验证
【Netty文件加密传输-java示例】
DRD
06-04 957
【代码】【Netty文件加密传输-java示例】
探秘 Netty 通信中的 SslHandler 类：保障网络通信安全的基石
u013127325的博客
03-09 1136
SslHandler是 Netty 中用于处理 SSL/TLS 协议的处理器，它是的一种实现。在 Netty 的中，SslHandler通常处于最前端，负责对进出Channel的数据进行加密和解密操作。通过使用SslHandler，可以确保在网络上传输的数据以加密形式存在，从而保护数据的机密性和完整性。SslHandler类是 Netty 中实现 SSL/TLS 加密通信的关键组件，它为开发者提供了便捷的方式来保障网络通信的安全。通过正确配置和使用SslHandler，可以轻松构建安全可靠的网络应用。
netty实现SSL/TSL双向加密认证示例
09-21
在本文中，我们将深入探讨如何使用 Netty 实现 SSL/TLS（Secure Sockets Layer/Transport Layer Security）双向加密认证。SSL/TLS 是互联网上广泛采用的安全通信协议，确保数据在网络传输过程中保持私密性和完整性。...
Android基于Netty框架实现通信
04-18
通过添加SslHandler到Handler链，可以启用加密通信。 **7. 性能优化** - 使用合适的ByteBuf类型：如PooledByteBuf或UnpooledByteBuf。 - 避免内存拷贝：合理设置缓冲区大小，减少不必要的数据复制。 - 调整线程池...
netty案例，netty4.1中级拓展篇十三《Netty基于SSL实现信息传输过程中双向加密验证》源码
10-11
netty案例，netty4.1中级拓展篇十三《Netty基于SSL实现信息传输过程中双向加密验证》源码 https://mp.weixin.qq.com/s?__biz=MzIxMDAwMDAxMw==&mid=2650724977&idx=1&sn=cab1a02be74a62d8184c18abc5eba6b5&scene=19#wechat_redirect
netty做服务端支持ssl协议实现websocket的wss协议（java）
05-16
在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳,,在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳
Netty实现SSL双向验证完整实例
热门推荐
moonpure的专栏
09-27 1万+
一、证书准备      要使用ssl双向验证，就必须先要生成服务端和客户端的证书，并相互添加信任，具体流程如下(本人调试这个用例的时候，花了很多时间来验证证书是否正确，以及握手失败的原因，这里证书生成过程只要按流程走，本人能保证绝对没有问题) 现在打开cmd，在哪个目录下打开，证书就会放在哪个目录下： 第一步:   生成Netty服务端私钥和证书仓库命令  keytool -genkey ...
netty整合ssl实现双向加密通信
AppTop_Jo的博客
06-12 1327
netty,ssl,springboot
基于netty框架不使用SSL证书，实现websocket数据加密传输
爱的不落叶
05-12 1383
服务器运行在专网环境，不能访问互联网。证书有有效期，CA机构规定，证书有效期最多2年。在客户的专网环境里更新和维护证书就会增加运营成本。客户要求数据要加密传输，所以参照SSL的加密过程实现自己的加密逻辑
Netty进行SSL认证
drsbbbl的博客
06-04 4848
第一步: 生成Netty服务端私钥和证书仓库命令，用于将客户端的证书保存到服务端的授信证书仓库中 keytool -genkey -alias securechat -keysize 2048 -validity 365 -keyalg RSA -dname "CN=localhost" -keypass sNetty -storepass sNetty -keystore sChat.jks 第二步：生成Netty服务端自签名证书 用于颁给使用者 从 证书仓库中导出证书 keytool -e...
使用Netty实现SSL和TLS加密通信
lonely_baby的博客
03-09 2986
代码中，我们在创建EchoServer时指定了SslContext对象，用于启用SSL和TLS协议支持。以上代码中，我们在EchoServerHandler的channelActive方法中添加了一个SslHandler处理器，并将其添加到ChannelPipeline中。Netty支持使用SSL和TLS协议进行加密通信，可以在保证通信安全的同时，保证数据传输的完整性和可靠性。例如，我们可以使用下面的代码创建一个EchoServer，并指定SSL和TLS协议支持。然后，我们调用sync方法等待服务器关闭。
netty系列之:对聊天进行加密
java_dazhuzhu的博客
08-13 315
简介 在之前的文章中，我们讲到了怎么使用netty建立聊天室，但是这样的简单的聊天室太容易被窃听了，如果想要在里面说点悄悄话是很不安全的，怎么办呢？学过密码学的朋友可能就想到了一个解决办法，聊天的时候对消息加密，处理的时候再对消息解密即可。 当然在netty中上述的工作都不需要我们手动来实现，netty已经提供了支持SSL的channel供我们选择，一起来看看吧。 PKI标准 在讲netty的具体支持之前，我们需要先了解一下公钥和私钥的加密标准体系PKI。PKI的全称是Public Key Infr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值