Netty配置SSL证书加密

在 Netty 中，配置 SSL 加密通信可以确保客户端和服务端之间的数据传输是加密的。要实现 SSL 加密通信，需要生成 SSL 证书，然后将其配置在 Netty 的客户端和服务端。

以下是一个完整的过程，包括如何使用 OpenSSL 生成证书并将其配置到 Netty 中。

1. 使用 OpenSSL 生成 SSL 证书

首先，使用 OpenSSL 生成自签名的 SSL 证书。

生成 CA (Certificate Authority) 证书

CA 证书可以用作签发服务器和客户端证书的根证书。

shell 复制代码

# 生成CA私钥
openssl genrsa -out ca.key 2048

# 使用私钥生成自签名CA证书
openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 -out ca.crt -subj "/CN=NettyTestCA"

生成服务端证书

服务端证书用于加密传输数据的公钥和私钥。

shell 复制代码

bash复制代码# 生成服务端私钥
openssl genrsa -out server.key 2048

# 生成服务端证书签名请求(CSR)
openssl req -new -key server.key -out server.csr -subj "/CN=localhost"

# 使用CA签发服务端证书
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 365 -sha256

生成客户端证书

客户端证书用于客户端身份验证。

shell 复制代码

# 生成客户端私钥
openssl genrsa -out client.key 2048

# 生成客户端证书签名请求(CSR)
openssl req -new -key client.key -out client.csr -subj "/CN=client"

# 使用CA签发客户端证书
openssl x509 -req -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out client.crt -days 365 -sha256

此时你将拥有以下文件：

ca.crt：CA 根证书
server.key 和 server.crt：服务端私钥和公钥证书
client.key 和 client.crt：客户端私钥和公钥证书
"/CN=localhost"：是 X.509 证书的一部分，它通常代表该证书关联的主机名或标识名

2. 配置 Netty 服务端的 SSL

在服务端，需要使用 SslContext 来加载 SSL 证书，并将其添加到 Netty 的 Channel Pipeline 中。

java 复制代码

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
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.util.SelfSignedCertificate;

import javax.net.ssl.SSLException;
import java.io.File;
import java.security.cert.CertificateException;

public class NettySslServer {

    public static void main(String[] args) throws InterruptedException, SSLException, CertificateException {
        // 加载服务端的私钥和公钥
        File certChainFile = new File("server.crt");
        File keyFile = new File("server.key");
        File rootCertFile = new File("ca.crt");

        // 构建 SSL 上下文
        SslContext sslContext = SslContextBuilder
                .forServer(certChainFile, keyFile)
                .trustManager(rootCertFile) // 加载CA证书，用于验证客户端证书
                .clientAuth(io.netty.handler.ssl.ClientAuth.REQUIRE) // 设置客户端认证
                .build();

        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加 SSL handler
                            pipeline.addLast(sslContext.newHandler(ch.alloc()));
                            // 添加其他的业务处理 handler
                            pipeline.addLast(new MyServerHandler());
                        }
                    });

            // 绑定端口并启动
            b.bind(8443).sync().channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

3. 配置 Netty 客户端的 SSL

客户端同样需要加载 SSL 证书，并通过 SslContext 实现加密通信。

java 复制代码

package com.demo.ssl;

import io.netty.bootstrap.Bootstrap;
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.codec.string.StringEncoder;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;

import javax.net.ssl.SSLException;
import java.io.File;
import java.util.concurrent.TimeUnit;

public class NettySslClient {

    public static void main(String[] args) throws SSLException, InterruptedException {

        String path = "D:\\java\\IdeaProjectsTest\\spring-cloud-demo02\\netty-demo\\src\\main\\resources\\ca\\";
        // 加载客户端的私钥和公钥
        File certChainFile = new File(path + "client.crt");
        File keyFile = new File(path + "client.key");
        //File rootCertFile = new File(path + "ca.crt");

        // 构建 SSL 上下文
        SslContext sslContext = SslContextBuilder
                .forClient()
                .keyManager(certChainFile, keyFile)  // 加载客户端证书
                //.trustManager(rootCertFile) // 加载 CA 证书
                .trustManager(InsecureTrustManagerFactory.INSTANCE) // 一般来讲，CA证书由服务器持有，不会将其暴露给客户端，客户端使用由CA证书签发的客户端证书和服务器建立加密传输通道
                .build();

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加 SSL handler
                            pipeline.addLast(sslContext.newHandler(ch.alloc()));
                            // 添加 StringEncoder，用于将 String 编码为 ByteBuf
                            pipeline.addLast(new StringEncoder());
                            // 添加自定义的业务逻辑处理器
                            pipeline.addLast(new ChannelInboundHandlerAdapter() {
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    ctx.executor().scheduleAtFixedRate(() -> {
                                        // 发送消息
                                        ctx.writeAndFlush("Hello from client at " + System.currentTimeMillis())
                                                .addListener((ChannelFutureListener) future -> {
                                                    if (!future.isSuccess()) {
                                                        System.err.println("Failed to send message: " + future.cause());
                                                    }
                                                });
                                    }, 0, 1000, TimeUnit.MILLISECONDS);
                                }

                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) {
                                    // 处理从服务端接收的数据
                                    System.out.println("Server responded: " + msg);
                                }
                            });
                        }
                    });

            // 连接到服务端
            ChannelFuture f = b.connect("localhost", 8443).sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

4. 验证加密通信

在运行客户端和服务端时，所有数据都会通过 SSL 加密。服务端和客户端会互相验证对方的证书。如果一切配置正确，客户端和服务端将成功建立 SSL 加密连接，所有传输的数据将被加密和解密。

5. 动态加载证书

Netty SSL服务器或者客户端中，如果服务器或客户端的证书过期的话，在SSL握手时无法就通过证书验证，连接会失败，这时我们就会手动更新证书或者实现自动续期并替换证书。但无论哪种方式，证书都讲被替换（修改），无论服务器还是客户端都没有办法实时监测到更改并重新加载SSL上下文对象，只能自己手动重启服务器或者客户端，这很不友好。所以我们需要手动实现检测到变化后自动重新加载证书并更新SSL上下文对象。需要说明的是，当客户端第一次与服务端建立 SSL 连接时，服务端会在握手过程中使用证书，如果此时证书已经过期，握手会失败，客户端会收到 SSL 错误，连接无法建立；一旦 SSL 握手完成，即使证书过期，只要连接不关闭，数据传输仍然会继续，不会因为证书过期而中断。这里我为Netty的 SslContext 实现动态更新逻辑，也就是当证书更新时，动态地替换当前的SSL上下文，代码如下。

java 复制代码

import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;

import javax.net.ssl.SSLException;
import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.security.cert.CertificateException;

public class DynamicSslContextLoader {
    private static volatile DynamicSslContextLoader instance;
    private final String certChainFilePath;
    private final String keyFilePath;
    private final String rootCertFilePath;

    private volatile SslContext sslContext;

    private DynamicSslContextLoader(String certChainFilePath, String keyFilePath, String rootCertFilePath) throws SSLException, CertificateException {
        this.certChainFilePath = certChainFilePath;
        this.keyFilePath = keyFilePath;
        this.rootCertFilePath = rootCertFilePath;
        this.sslContext = createSslContext();
        startWatchingCertificateFiles();
    }

    private SslContext createSslContext() throws SSLException, CertificateException {
        File certChainFile = new File(certChainFilePath);
        File keyFile = new File(keyFilePath);
        File rootCertFile = new File(rootCertFilePath);
        return SslContextBuilder
                .forServer(certChainFile, keyFile)
                .trustManager(rootCertFile)
                .clientAuth(io.netty.handler.ssl.ClientAuth.REQUIRE)
                .build();
    }

    public SslContext getSslContext() {
        return sslContext;
    }

    public static DynamicSslContextLoader getInstance(String certChainFilePath, String keyFilePath, String rootCertFilePath) throws SSLException, CertificateException {
        DynamicSslContextLoader localInstance = instance;
        if (localInstance == null) {
            synchronized (DynamicSslContextLoader.class) {
                localInstance = instance;
                if (localInstance == null) {
                    instance = localInstance = new DynamicSslContextLoader(certChainFilePath, keyFilePath, rootCertFilePath);
                }
            }
        }
        return localInstance;
    }

    private void startWatchingCertificateFiles() {
        Path certPath = Paths.get(certChainFilePath).getParent();
        Thread watcherThread = new Thread(() -> {
            try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
                certPath.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
                while (true) {
                    WatchKey key = watchService.take();
                    for (WatchEvent<?> event : key.pollEvents()) {
                        Path changed = (Path) event.context();
                        if (changed.endsWith(getFileName(certChainFilePath)) || changed.endsWith(getFileName(keyFilePath)) || changed.endsWith(getFileName(rootCertFilePath))) {
                            // 证书文件发生修改，重新加载
                            System.out.println("Certificate file changed, reloading SSL context...");
                            sslContext = createSslContext();
                        }
                    }
                    key.reset();
                }
            } catch (IOException | InterruptedException | CertificateException e) {
                e.printStackTrace();
            }
        });
        watcherThread.setDaemon(true);
        watcherThread.start();
    }

    private static String getFileName(String fileAbPath) {
        return fileAbPath.substring(fileAbPath.lastIndexOf(File.separator) + 1);
    }
   
}

在bootstrap中这样使用：pipeline.addLast(DynamicSslContextLoader.getInstance(certChainFilePath, keyFilePath, rootCertFilePath).getSslContext().newHandler(ch.alloc()));因为Netty需要全局共享 SSL 上下文，所以这里使用DCL来实现线程安全的单例模式。

一个更好的经验是使用Nginx代理Netty服务器，Nginx可以集中处理SSL加密和解密，简化后端服务的 SSL 管理。只需在Nginx中配置证书，后端服务不必直接处理 SSL/TLS。Nginx 也提供了负载均衡的功能，可以根据配置将请求分发到多个后端服务器，实现高可用和性能优化。它还提供了很多安全功能（如防火墙、访问控制、限流等），可以保护后端的 Netty 服务。对于中小型项目，如果只需要做简单的负载均衡、SSL 加密和反向代理，Nginx 非常适合，架构简单且维护成本较低（对于有运维能力的人来说）。坏处就是，Nginx 是基于静态配置的，需要手动配置后端服务的地址，不利于后端服务动态扩容缩容（但也不是特别麻烦）。

总结

使用 OpenSSL 生成 CA、服务端和客户端的证书。
在 Netty 中，配置 SslContext 来加载证书，并将其应用到 ChannelPipeline 中。
通过 Netty 的 SslHandler 实现安全的加密数据传输，确保数据在传输过程中是加密的。