1.从SSL/TLS说起

1.1 握手阶段的详细过程

（1） 支持的协议版本，比如TLS 1.0版。
（2） 一个客户端生成的随机数，稍后用于生成"对话密钥"。
（3） 支持的加密方法，比如RSA公钥加密。
（4） 支持的压缩方法。
服务器回应（SeverHello）
 
服务器收到客户端请求后，向客户端发出回应，这叫做SeverHello。服务器的回应包含以下内容。
 
（1） 确认使用的加密通信协议版本，比如TLS 1.0版本。如果浏览器与服务器支持的版本不一致，服务器关闭加密通信。
（2） 一个服务器生成的随机数，稍后用于生成"对话密钥"。
（3） 确认使用的加密方法，比如RSA公钥加密。
（4） 服务器证书。
除了上面这些信息，如果服务器需要确认客户端的身份，就会再包含一项请求，要求客户端提供"客户端证书"。比如，金融机构往往只允许认证客户连入自己的网络，就会向正式客户提供USB密钥，里面就包含了一张客户端证书。
 
客户端回应
 
客户端收到服务器回应以后，首先验证服务器证书。如果证书不是可信机构颁布、或者证书中的域名与实际域名不一致、或者证书已经过期，就会向访问者显示一个警告，由其选择是否还要继续通信。
 
如果证书没有问题，客户端就会从证书中取出服务器的公钥。然后，向服务器发送下面三项信息
 
（1） 一个随机数。该随机数用服务器公钥加密，防止被窃听。
（2） 编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
（3） 客户端握手结束通知，表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供服务器校验。
上面第一项的随机数，是整个握手阶段出现的第三个随机数，又称"pre-master key"。有了它以后，客户端和服务器就同时有了三个随机数，接着双方就用事先商定的加密方法，各自生成本次会话所用的同一把"会话密钥"。
 
服务器的最后回应
 服务器收到客户端的第三个随机数pre-master key之后，计算生成本次会话所用的"会话密钥"。然后，向客户端最后发送下面信息。
 
（1）编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
（2）服务器握手结束通知，表示服务器的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供客户端校验。
至此，整个握手阶段全部结束。接下来，客户端与服务器进入加密通信，就完全是使用普通的HTTP协议，只不过用"会话密钥"加密内容。
 
2.使用JDK工具keytool
 
使用ssl双向验证，就必须先要生成服务端和客户端的证书，并相互添加信任，具体流程如下：
 
 
生成Netty服务端私钥和证书仓库
 
keytool -genkey -alias server_cert -keypass 123456 -keyalg RSA -keysize 1024 -validity 365 -keystore i:\server.jks -storepass 123456 -dname “CN=localhost”
 
  
keysize 2048 密钥长度2048位（这个长度的密钥目前可认为无法被暴力破解）
validity 365 证书有效期365天
keyalg RSA 使用RSA非对称加密算法
dname “CN=localhost” 设置Common Name为localhost
keypass 密钥的访问密码为123456
storepass 密钥库的访问密码为123456（其实这两个密码也可以设置一样，通常都设置一样，方便记）
keystore 指定生成的密钥库文件为i:\server.jks如果只制定文件名，那么会生成至当前用户目录下
 
 
生成Netty服务端自签名证书
 
keytool -export -alias server_cert -keystore i:/server.jks -storepass 123456 -file i:/server.cer
 
 
生成客户端的密钥对和证书仓库，用于将服务端的证书保存到客户端的授信证书仓库中
 
keytool -genkey -alias client_cert -keysize 2048 -validity 365 -keyalg RSA -dname “CN=localhost” -keypass 123456 -storepass 123456 -keystore i:/client.jks
 
 
将服务端证书导入到客户端的证书仓库中
 
keytool -import -trustcacerts -alias securechat -file i:/server.cer -storepass 123456 -keystore clinet.jks
 
如果你只做单向认证，则到此就可以结束了，如果是双响认证，则还需继续往下走
 
 
生成客户端自签名证书
 
keytool -export -alias client_cert -keystore i:/client.jks -storepass 123456 -file client.cer
 
 
将客户端的自签名证书导入到服务端的信任证书仓库中
 
keytool -import -trustcacerts -alias securechat -file i:/client.cer -storepass 123456 -keystore i:/server.jks
 
 
3.通过 SSL/TLS 保护 Netty 通信
 
为了支持 SSL/TLS，Java 提供了 javax.net.ssl包，它的 SSLContext和SSLEngine类使得实现解密和加密相当简单直接。Netty 通过一个名为SslHandler的ChannelHandler实现利用了这个 API，其中SslHandler在内部使用SSLEngine来完成实际的工作。
 
下图为SslHandler类的继承关系：
 
 通过 SslHandler 进行解密和加密的数据流：
 
 通过Factory创建SSLContext并对其进行正确的初始化
 
public class SSLContextFactory  {
    public static SSLContext getSslContext() throws Exception {
        char[] passArray = "123456".toCharArray();
        SSLContext sslContext = SSLContext.getInstance("TLSv1");
        KeyStore ks = KeyStore.getInstance("JKS");
        //加载keytool 生成的文件
        FileInputStream inputStream = new FileInputStream("i:/server.jks");
        ks.load(inputStream, passArray);
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(ks, passArray);
        sslContext.init(kmf.getKeyManagers(), null, null);
        inputStream.close();
        return sslContext;
添加handler,利用SSLContext创建SSL引擎SSLEngine，设置SSLEngine为服务端模式，由于不需要对客户端进行认证，因此NeedClientAuth不需要额外设置,将SslHandler添加到pipeline中，利用SslHandler实现Socket安全传输
 
.childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline() ;
                            SSLEngine sslEngine = SSLContextFactory.getSslContext().createSSLEngine();
                            sslEngine.setUseClientMode(false);
                            sslEngine.setNeedClientAuth(true);
                            pipeline.addFirst("ssl", new SslHandler(sslEngine));
                    });
4.基于Netty的Http通信
 
HTTP 是基于请求/响应模式的：客户端向服务器发送一个 HTTP 请求，然后服务器将会返回一个 HTTP 响应。经过HttpServerCodec解码之后，一个HTTP请求会导致：ParseRequestHandler的 channelRead()方法调用多次（测试时 "received message"输出了两次）
 
 为了消除这项繁琐的任务，Netty 提供了一个聚合器，它可以将多个消息部分合并为 FullHttpRequest 或者 FullHttpResponse 消息。FullHttpRequest 和 FullHttpResponse 消息是特殊的子类型，分别代表了完整的请求和响应。
 
用HttpObjectAggregator 将多个消息转换为单一的一个FullHttpRequest，如下：
 
  ph.addLast("decoder",new HttpRequestDecoder());
  ph.addLast("encoder",new HttpResponseEncoder());
  ph.addLast("aggregator", new HttpObjectAggregator(10*1024*1024));
接下来添加业务逻辑代码,在上面的基础上 添加ph.addLast(“http”,HttpServerHandler)
 
public class HttpServerHandler extends ChannelInboundHandlerAdapter {
    private String result = "";
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (!(msg instanceof FullHttpRequest)) {
            result = "未知请求!";
            send(ctx, result, HttpResponseStatus.BAD_REQUEST);
            return;
        FullHttpRequest httpRequest = (FullHttpRequest) msg;
        try {
            String path = httpRequest.uri();          //获取路径
            String body = getBody(httpRequest);     //获取参数
            HttpMethod method = httpRequest.method();//获取请求方法
            System.out.println("接收到:" +




    
 method + " 请求");
            //如果是GET请求
            if (HttpMethod.GET.equals(method)) {
                //接受到的消息，做业务逻辑处理...
                System.out.println("body:" + body);
                result = "GET请求";
                send(ctx, result, HttpResponseStatus.OK);
                return;
            //如果是POST请求
            if (HttpMethod.POST.equals(method)) {
                //接受到的消息，做业务逻辑处理...
                System.out.println("body:" + body);
                result = "POST请求";
                send(ctx, result, HttpResponseStatus.OK);
                return;
        } catch (Exception e) {
            System.out.println("处理请求失败!");
            e.printStackTrace();
        } finally {
            //释放请求
            httpRequest.release();
     //获取body参数
    private String getBody(FullHttpRequest request) {
        ByteBuf buf = request.content();
        return buf.toString(CharsetUtil.UTF_8);
     //发送的返回值
    private void send(ChannelHandlerContext ctx, String context, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer(context, CharsetUtil.UTF_8));
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
     //建立连接时，返回消息
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("连接的客户端地址:" + ctx.channel().remoteAddress());
        ctx.writeAndFlush("客户端" + InetAddress.getLocalHost().getHostName() + "成功与服务端建立连接！ ");
        super.channelActive(ctx);
5.基于Netty的HTTPS通信
 
哈哈，终于到了收获阶段_
 
有了上面SSL/TLS和HTTP的基础，启用 HTTPS 只需要将 SslHandler 添加到 ChannelPipeline 的ChannelHandler 组合中。
 
public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline ph = ch.pipeline();
        //添加sslhandler
        SSLEngine sslEngine = SSLContextFactory.getSslContext().createSSLEngine();
        sslEngine.setUseClientMode(false);
        ch.pipeline().addLast(new SslHandler(sslEngine));
        //处理http服务的关键handler
        //一个组合的HttpRequestDecoder和HttpResponseEncoder使得服务器端HTTP实现更容易。
        ph.addLast("codec", new HttpServerCodec());
        //ph.addLast("decoder",new HttpRequestDecoder());
        //ph.addLast("encoder",new HttpResponseEncoder());
        ph.addLast("aggregator", new HttpObjectAggregator(10*1024*1024));
        ph.addLast("handler", new HttpServerHandler());// 服务端业务逻辑
至此，通过通过浏览器使用https方式访问。本文谈到SSL/TLS协议的基本原理，以及基于Netty的实现，然后说了HTTP的通信，最后实现基于Netty的HTTPS通信，下一篇介绍PipleLine的源码分析_
 
本文的所有代码参考:git地址
				
业务场景： 由于工作需要，需要在两台服务器的java服务之间通过netty建立链接，将大文件（几百G到TB级别）从机器A上的serverA发送到机器B上的serverB。
实现方法设计：
系统现有的实现方法：将业务方存储在服务器上的文件，在传输之前，对文件进行分片，以定义的规则将文件分为大小20MB的分片存储在服务器中。同步时以异步的方式同步分片，当然A服务器上的文件同步到B服务器时也是以分片的...
				
1、使用JDK自带的keytool生成一个keystore，这个keystore是服务端使用的keytool -genkey -alias netty -keypass 123456 -keyalg RSA -keysize 1024 -validity 365 -keystore D:/test/netty.keystore -storepass 123456
2、新建一个安全工具类，用于返回一...
File certChainFile=new File("/home/certs/nginx.crt");
File keyFile=new File("/home/certs/pkcs8_rsa_private_key.pem");
SslConte...
				
这里写目录标题DotNetty TLS 开启双向认证加密传输数据一、生成PFX证书二、服务器端2.1 引用Nuget：2.2 创建处理请求类2.3 注册DotNetty监听服务三、客户端端3.1 引用Nuget3.2 响应处理3.3 连接到服务端
DotNetty TLS 开启双向认证加密传输数据
DotNetty为服务间通讯，包括提供服务的服务器端和请求数据的客户端。如果需要密文传输数据则需要开启TLS，用于通讯加密。TLS涉及到的是证书，首先来看看如果生成DotNetty的TLS证书。
一、生成PFX证
    每个Channel都将会被分配一个ChannelPipeline和ChannelConfig。ChannelConfig包含了该Channel的所有配置设置，并且支持热更新。由于特定的传输可能具有独特的设置，所以它可能会实现一个ChannelConfig的子类型。
    由于Channel...
自己基于Netty做了一个类IM项目，没有使用Spring框架，用到了应用层协议HTTP和websocket，在大致框架完成后，想对传输内容进行加密，便用到了TLS协议，用此博文记录自己的加密过程以及睬的坑。
TLS部分
KeyTool部分
Netty
                    xuepiaosonglin: 
                    public AbstractSelector openSelector() throws IOException {
    return new EPollSelectorProvider(this);
   public AbstractSelector openSelector() throws IOException {
        return new PollSelectorImpl(this);
                Netty进阶：自顶向下解析FastThreadLocal
                    TheLudlows: 
                    你说的对，https://github.com/netty/netty/pull/8956，19年3月这个PR已经删除了cleaner代码，稍后我会删掉这部分解释
                Netty进阶：自顶向下解析FastThreadLocal
                    math_xing: 
                    有个问题咨询博主，Threadlocal中只要线程对象被gc回收，就不会出现内存泄露，因为对其内部的ThreadLocalMap没有引用了。但FastThreadLocal使用普通线程的情况下，原理不是一样吗？为什么还要在线程对象被gc回收时多此一举清理呢？或许我没有理解FastThreadLocal内存泄漏的点在哪，麻烦指教
                Netty实战：HTTPS传输原理分析及Netty的实现
                    嵩山琅琅: 
                    博主您好，我现在用netty作为数据传输通道 接收到https请求以后 从外网搬运到内弯  在内网接收到响应信息以后返回给请求客户端。这样也需要配置https的证书吗