登录后台

页面导航

本文编写于 2026 天前,最后修改于 1430 天前,其中某些信息可能已经过时。

不存在 SSLServerSocketChannel

对于 BIO 通道的程序来讲,建立起 SSLServerSocket 之后,后续的工作就和普通的 ServerSocket 没有什么区别了,这是因为 JDK 中通过 JSSE 的 API,封装了 SSL 通道的实现逻辑,否则,类似于 C 程序员如果想要编写一个 https 的加密程序,那他基本得累个半死,所以,我们应该感谢 JAVA。

对于 NIO 通道来讲,我们一贯的思维也是存在一个 SSLServerSocketChannel,然后注册到 selector 中,后续的操作也和普通的 ServerSocketChannel 没什么区别了,但是,并不存在一个 SSLServerSocketChannel,关于这一点,JSSE 的官方的 Reference Guide 中:

title=

翻译出来的原因主要有一下两点:

  1. 因为 JDK 类继承限制,无法搞出一个 SSLServerSocketChannel,如果需要搞出这样的一个类,需要在源码和 API 中大动干戈。
  2. 其次,JSSE 的框架设计不想因为封装出一个 SSLServerSocketChannel,就将 NIO 的灵活多变,并且高性能的优势给抹掉。

因此,基于上述的原因,最终 JSSE 在 NIO 通道中并没有 SSLServerSocketChannel,而是采用 NIO + SSLEngine 的方式进行实现。

NIO + SSLEngine

NIO 的 selector 体系这里就不再说了,也即是 ServerSocketChannel 注册到 Selector 中,然后进行轮询,如果事件发生了,SelectionKey 就被遍历出来,然后判断监听的是 register 事件,还是 read/write 事件,事件触发后,将 socket 的数据读取到缓冲区中。这是 NIO 的思路,而如果在 NIO 中使用 SSL,也是延续这样的一个套路,不用做任何的改变.
当 read/write 事件发生之后,普通的 socket 直接就开始读取数据了,这个时候 SSLEngine 就开始工作了,首先 SSLEngine 会调用 beginHandShake 开始准备握手,然后执行握手,握手的工作是需要通过编程,调用 SSLEngine 的出栈和入栈来完成的,看下面的一个图:

title=

你可以认为 SSLEngine 相当于一个黑盒子,它的内部封装了 SSL 握手,会话等各种协议实现。而我们看到上面的四个蓝色的 buffer,左面的两个是应用程序中定义的 buffer,供应用程序使用的,右面的两个是需要从 socket 缓冲区或者 socketchannel 接收数据并存放的 buffer,用于缓存使用的;SSLEngine 的一共两个操作,一个是 wrap,叫做出栈,发出的出,从应用的 buffer 中,到网络缓冲区的 buffer 中,SSLEngine 起到的是转接的作用,相反的是 unwrap,数据从网络缓冲区流入到应用程序中。

我们为什么要了解 SSLEngine 这样的一个架构呢?

因为 NIO 方式的 SSL 交互,必须要通过 SSLEngine 来实现,甚至是握手也需要通过这种方法来实现,我们需要编程调用 wrap 和 unwrap,并根据出栈和入栈是否成功,和下一步的需要做的动作,再执行什么动作。

判断的依据是两个状态:

第一个是 SSLEngineResult.HandShakeStatus:

title=

这个状态指示,当每一次 SSLEngine 的 wrap 或者 unwrap 之后下一步应该干什么。

例如 NEED_WRAP 状态,相当于下一步我们需要执行 wrap;如果状态是 NEED_UNWRAP 状态,那么下一步应该执行 unwrap; NOT_HANDSHAKING 说明握手没有成功,应该抛出异常;如果是是 NEED_TASK 状态,SSL 协议中定义了一些耗时比较长的操作,需要执行 delegate 操作,这里应该开启一个线程,将这个耗时比较长的操作给执行了,例如 CRL 的远程校验。

这里可以看到,我们编程的时候,应该会有一个 while 循环,因为 SSL 的握手协议不是一下子就完成的,需要客户端和服务器端反复的进行交互,这里面会不断的通过 SSLEngine 进行 wrap 和 unwrap 等其它的操作;

其次,需要对上面的这几种状态进行条件判断,可以使用 case 语句。

还有一个状态标识是 SSLEngineResult.Status

title=

这个属性是指示 wrap 或者 unwrap 方法是否执行成功和失败的,可以看到上面,如果 buffer 字节数没有足够的空间,就会报 overflow,因此,对于这个状态的判断,通常出现在异常处理和边界检验中。

SSLEngine 处理流程

SSL 通讯过程,主要包括握手,对话,关闭对话,三个步骤。其中握手部分的主要内容有协商协议,相互验证,生成并交换对称密钥,其中相互验证和对称密钥的交换是由非对称加密来完成的。在对话过程中,实际的明文是由之前生成的对称密钥来加密的。当对话结束后,互相发送结束信号结束通讯。

在上述过程中不仅仅是通讯双方简单的交换数据,更重要的是要根据 SSL 协议的要求,在特定的状态下发送或接受特定的数据,并且这些数据是经过处理的数据,也就是在 tcp 头和通讯正文之间还要包括一些 ssl 的信 息,并且正文是由特定形式加密的。SSLEngine 正是完成了管理状态,封装应用程序数据发往网络,解析网络数据并传递给应用程序的角色。

先看看 SSLEngine 有哪些状态,有哪些工作要做,假设从一个 ssl server 看。

首先在握手阶段,需要和 client 程序多次握手,进行身份验证,对称密钥生成等工作,在这段时间里,并没有实际的应用层数据交换,而只有 SSL 协议数据的交换。且不看实际传输的内容和意义,在握手过程中,Server 的 SSLEngine 初始化后总是等待 client 的请求(等待接收数据),此时它的状态是 NEED_UNWRAP,unwrap 是解包的意思,这意味着,SSLEngine 等待解析一个 SSL 的数据包。

当 server 收到数据包后,在 nio 中数据包总是放在一个 buffer 里而不再是读 stream,我们把这个 buffer 交给 SSLEngine,调用它的 unwrap 方法,SSLEngine 会解析这个数据包,把其中关于 SSL 握手的信息提取出来,并改变自己的状态,此处它将变成 NEED_WRAP 状态,意味着打包,它需要把对应的 SSL 回复内容写到数据包中返回到客户端。

以此类推,SSLEngine多数时间总是在解包和打包两个状态间切换,尤其是在实际通讯时,注意到在 unwrap 和 wrap 函数中都有一个源 buffer 和一个目的 buffer,因为 SSLEngine 不仅提取 SSL 协议相关的内容还要解密网络数据并把明文传递给应用程序,这其实才是这两个函数名字的来源,只不过在握手过程中,并没有实际的数据,而只有 SSL 协议信息,所以那个目的 buffer 总是没有东西。可以把SSL通讯看做交换礼物,SSLEngine把包裹拆了把礼物给你,或者他把礼物包起来送走,只是在SSL握手时,那个包裹里没有礼物,SSLEngine 只是拆了个空包裹或是寄了个空包裹。

那么还有没有其它状态,有一个 FINISHED 状态,表示这次handshake完成了;而当进入实际交换数据的时候,这个状态是 NOT_HANDSHAKE,表示当前不在握手,一般这个时候只需要在 socket 可读时,调用 unwrap 函数解密来自网络的 SSL 数据包,在 socket 可写的时候调用 wrap 函数把明文数据加密发送出去。

还有一个状态 NEED_TASK,首先要知道一点 SSLEngine 是异步的,wrap 和 unwrap 函数调用都会立刻返回,比如在 server 收到 client 第一次请求后,会调用 unwrap,但实际上 SSLEngine 还会做很多工作,比如访问 Keystore 文件,这些操作是费时的,但是实际上函数却立刻返回了,这时候 SSLEngine 会进入 NEED_TASK 状态,而不是立刻进入 NEED_WRAP 状态,所以必须让 SSLEngine 完成手头的工作,才能进入下一步工作,这时可以调用 SSLEngine的 getDelegatedTask() 方法获得那个尚未完成的工作,它是一个 Runnable 的对象,可以调用它的 run 方法等待他完成,如果你是个高并发的 server,也可以在这个时候做其他事情,等待这个工作完成,再接下去做wrap工作。

另外还有一个非常容易出错的地方,一个 NEED_UNWRAP 状态的下一个状态然有可能是 NEED_UNWRAP,并且一次调用 unwrap 方法并不一定把 buffer 中的所有内容都解包出来,可能还有内容需要在一次 unwrap 才能把所有东西都解析完,我遇到的这种情况发生在用 nio 的 server 和老的 SSLSocket 通讯时,client 只向 server 一次性发送了这些数据,而 server 端需要连续两次 unwrap 才能把 client 的数据完整处理掉。

除了上述 4 个状态描述了 SSLEngine 的状态,还有 4 个状态用于描述每次调用 wrap 和 unwrap 后的结果状态。它们分别是:

  • BUFFER_OVERFLOW 表示目标 buffer 没有足够的空间来存放解包的内容,这往往是因为你的目的buffer太小,或者在 buffer 在写入前没有 clear;
  • BUFFER_UNDERFLOW 表示源 buffer 没足够内容让 SSLEngine 来解包,这往往是因为,可能还有数据尚未到达,或者在 buffer 读取前没有 flip;
  • CLOSED 表示通讯的某一段正试图结束这个SSL通讯。
  • OK 表示 SSLEngin 完成了操作。

首先 NIO 的 socket 基本都通过 Selector 来实现,把 socket 的 accept,read,write 事件都注册到 selector 上,不断的循环 select()就可以,只是对于一个 SSL Server Socket 而言,它只是个普通的 ServerSocket,首先只关心 accept 事件,所以首先这在 selector 上注册一个事件。

当 serversocket 接收到一个 SSL client 的请求后,就要开始进行握手,这个过程是同步的,所以先不要把 read 和 write 事件也注册到 selector 上,当完成握手后,才注册这两个事件,并把 socket 设置成非阻塞。当 select 到 socket 可读时先调用 unwrap 方法,可写时先调用 wrap 方法。

每个 socket 都有两组 buffer,分别是 appIn,netIn 和 appOut,netOut,其中 netXX 都代表从 socket 中读取或写入的东西,他们都是加了密的,而 appXX 代表应用程序可理解的数据内容,它们都通过 SSLEngine 的 wrap 和 unwrap 方法才能与 netXX 相互转换。

示例

服务端示例

public class SSLHandshakeServer {
    private static Logger logger = Logger.getLogger(SSLHandshakeServer.class.getName());
    private SocketChannel sc;//channel
    private SSLEngine sslEngine;//SSLEngine引擎
    private Selector selector;//NIO通道

    private ByteBuffer myNetData;
    private ByteBuffer myAppData;
    private ByteBuffer peerNetData;
    private ByteBuffer peerAppData;//四个buffer缓冲区

    private ByteBuffer dummy = ByteBuffer.allocate(0);

    private HandshakeStatus hsStatus;//SSLEngineResult.HandShakeStatus
    private Status status;//SSLEngineResult.Status

    public void run() throws Exception {
        char[] password = "123456".toCharArray();
        KeyStore keyStore = KeyStore.getInstance("JKS");
        InputStream in = this.getClass().getResourceAsStream("serverkeystore");
        keyStore.load(in, password);
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(keyStore, password);

        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(kmf.getKeyManagers(), null, null);
        sslEngine = sslContext.createSSLEngine();
        sslEngine.setUseClientMode(false);

        SSLSession session = sslEngine.getSession();//初始化SSLEngine

        myAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
        myNetData = ByteBuffer.allocate(session.getPacketBufferSize());
        peerAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
        peerNetData = ByteBuffer.allocate(session.getPacketBufferSize());
        peerNetData.clear();//定义四个缓冲区

       //NIO的流程
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        selector = Selector.open();
        ServerSocket serverSocket = serverChannel.socket();
        serverSocket.bind(new InetSocketAddress(443));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        logger.info("Server listens on port 443... ...");
        while (true) {
            selector.select();
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey selectionKey = it.next();
                it.remove();
                handleRequest(selectionKey);//当SelectionKey有事件进来后,进行NIO的处理
            }
        }
    }
    private void handleRequest(SelectionKey key) throws Exception {
        if (key.isAcceptable()) {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel channel = ssc.accept();
            channel.configureBlocking(false);
            channel.register(selector, SelectionKey.OP_READ);//当rigister事件发生后,下一步就是读了
        } else if (key.isReadable()) {
            sc = (SocketChannel) key.channel();
            logger.info("Server handshake begins... ...");
            //从这里,SSL的交互就开始了
            sslEngine.beginHandshake();//开始begin握手
            hsStatus = sslEngine.getHandshakeStatus();
            doHandshake();//开始进行正式的SSL握手
            if (hsStatus == HandshakeStatus.FINISHED) {//当握手阶段告一段落,握手完毕
                key.cancel();
                sc.close();
            }
            logger.info("Server handshake completes... ...");
        }
    }
    //这个方法就是服务器端的握手
    private void doHandshake() throws IOException {
        SSLEngineResult result;
        while (hsStatus != HandshakeStatus.FINISHED) {//一个大的while循环,
            logger.info("handshake status: " + hsStatus);
            switch (hsStatus) {//判断handshakestatus,下一步的动作是什么?
            case NEED_TASK://指定delegate任务
                Runnable runnable;
                while ((runnable = sslEngine.getDelegatedTask()) != null) {
                    runnable.run();//因为耗时比较长,所以需要另起一个线程
                }
                hsStatus = sslEngine.getHandshakeStatus();
                break;
            case NEED_UNWRAP://需要进行入站了,说明socket缓冲区中有数据包进来了
                int count = sc.read(peerNetData);//从socket中进行读取
                if (count < 0) {
                    logger.info("no data is read for unwrap.");
                    break;
                } else {
                    logger.info("data read: " + count);
                }
                peerNetData.flip();
                peerAppData.clear();
                do {
                    result = sslEngine.unwrap(peerNetData, peerAppData);//调用SSLEngine进行unwrap操作
                    logger.info("Unwrapping:\n" + result);
                    // During an handshake renegotiation we might need to
                    // perform
                    // several unwraps to consume the handshake data.
                } while (result.getStatus() == SSLEngineResult.Status.OK//判断状态
                        && result.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP
                        && result.bytesProduced() == 0);
                if (peerAppData.position() == 0 && result.getStatus() == SSLEngineResult.Status.OK
                        && peerNetData.hasRemaining()) {
                    result = sslEngine.unwrap(peerNetData, peerAppData);
                    logger.info("Unwrapping:\n" + result);
                }
                hsStatus = result.getHandshakeStatus();
                status = result.getStatus();
                assert status != status.BUFFER_OVERFLOW : "buffer not overflow." + status.toString();
                // Prepare the buffer to be written again.
                peerNetData.compact();
                // And the app buffer to be read.
                peerAppData.flip();
                break;
            case NEED_WRAP://需要出栈
                myNetData.clear();
                result = sslEngine.wrap(dummy, myNetData);//意味着从应用程序中发送数据到socket缓冲区中,先wrap
                hsStatus = result.getHandshakeStatus();
                status = result.getStatus();
                while (status != Status.OK) {
                    logger.info("status: " + status);
                    switch (status) {
                    case BUFFER_OVERFLOW:
                        break;
                    case BUFFER_UNDERFLOW:
                        break;
                    }
                }
                myNetData.flip();
                sc.write(myNetData);//最后再发送socketchannel
                break;
            }
        }
    }
    public static void main(String[] args) throws Exception {
        new SSLHandshakeServer().run();
    }
}

客户端示例

public class SSLHandshakeClient {
    private static Logger logger = Logger.getLogger(SSLHandshakeClient.class.getName());
    private SocketChannel sc;
    private SSLEngine sslEngine;
    private Selector selector;
    private HandshakeStatus hsStatus;
    private Status status;
    private ByteBuffer myNetData;
    private ByteBuffer myAppData;
    private ByteBuffer peerNetData;
    private ByteBuffer peerAppData;
    private ByteBuffer dummy = ByteBuffer.allocate(0);
    public void run() throws Exception {
        char[] password = "123456".toCharArray();
        KeyStore trustStore = KeyStore.getInstance("JKS");
        InputStream in = this.getClass().getResourceAsStream("clienttruststore.jks");
        trustStore.load(in, password);
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(trustStore);
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, tmf.getTrustManagers(), null);
        sslEngine = sslContext.createSSLEngine();
        sslEngine.setUseClientMode(true);
        SSLSession session = sslEngine.getSession();
        myAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
        myNetData = ByteBuffer.allocate(session.getPacketBufferSize());
        peerAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
        peerNetData = ByteBuffer.allocate(session.getPacketBufferSize());
        peerNetData.clear();
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        selector = Selector.open();
        channel.register(selector, SelectionKey.OP_CONNECT);
        channel.connect(new InetSocketAddress("localhost", 443));
        sslEngine.beginHandshake();
        hsStatus = sslEngine.getHandshakeStatus();
        while (true) {
            selector.select();
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey selectionKey = it.next();
                it.remove();
                handleSocketEvent(selectionKey);
            }
        }
    }
    private void handleSocketEvent(SelectionKey key) throws IOException {
        if (key.isConnectable()) {
            sc = (SocketChannel) key.channel();
            if (sc.isConnectionPending()) {
                sc.finishConnect();
            }
            doHandshake();
            sc.register(selector, SelectionKey.OP_READ);
        }
        if (key.isReadable()) {
            sc = (SocketChannel) key.channel();
            doHandshake();
            if (hsStatus == HandshakeStatus.FINISHED) {
                logger.info("Client handshake completes... ...");
                key.cancel();
                sc.close();
            }
        }
    }
    private void doHandshake() throws IOException {
        SSLEngineResult result;
        int count = 0;
        while (hsStatus != HandshakeStatus.FINISHED) {
            logger.info("handshake status: " + hsStatus);
            switch (hsStatus) {
            case NEED_TASK:
                Runnable runnable;
                while ((runnable = sslEngine.getDelegatedTask()) != null) {
                    runnable.run();
                }
                hsStatus = sslEngine.getHandshakeStatus();
                break;
            case NEED_UNWRAP:
                count = sc.read(peerNetData);
                if (count < 0) {
                    logger.info("no data is read for unwrap.");
                    break;
                } else {
                    logger.info("data read: " + count);
                }
                peerNetData.flip();
                peerAppData.clear();
                do {
                    result = sslEngine.unwrap(peerNetData, peerAppData);
                    logger.info("Unwrapping:\n" + result);
                    // During an handshake renegotiation we might need to
                    // perform
                    // several unwraps to consume the handshake data.
                } while (result.getStatus() == SSLEngineResult.Status.OK
                        && result.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP
                        && result.bytesProduced() == 0);
                if (peerAppData.position() == 0 && result.getStatus() == SSLEngineResult.Status.OK
                        && peerNetData.hasRemaining()) {
                    result = sslEngine.unwrap(peerNetData, peerAppData);
                    logger.info("Unwrapping:\n" + result);
                }
                hsStatus = result.getHandshakeStatus();
                status = result.getStatus();
                assert status != status.BUFFER_OVERFLOW : "buffer not overflow." + status.toString();
                // Prepare the buffer to be written again.
                peerNetData.compact();
                // And the app buffer to be read.
                peerAppData.flip();
                break;
            case NEED_WRAP:
                myNetData.clear();
                result = sslEngine.wrap(dummy, myNetData);
                hsStatus = result.getHandshakeStatus();
                status = result.getStatus();
                while (status != Status.OK) {
                    logger.info("status: " + status);
                    switch (status) {
                    case BUFFER_OVERFLOW:
                        break;
                    case BUFFER_UNDERFLOW:
                        break;
                    }
                }
                myNetData.flip();
                count = sc.write(myNetData);
                if (count <= 0) {
                    logger.info("No data is written.");
                } else {
                    logger.info("Written data: " + count);
                }
                break;
            }
        }
    }
    public static void main(String[] args) throws Exception {
        new SSLHandshakeClient().run();
    }
}

总结一下,NIO+SSLEngine 的这种方式,可以说是高度的开放,利用 SSLEngine 这个工具,来完成握手这个过程,而握手的过程需要通过编程和控制状态来实现,实际上,这也是 JDK 的 API 设计的缺陷之一,没有封装的好,让我们程序员写这些莫名其妙的代码,而 JDK 说加不了 SSLServerSocketChannel 其实应该就是一个说辞而已,不过,既然如此,那我们只需按照他的要求进行编程,也能达到 NIO 中 SSL 通道的效果。

SSLEngine 也可以用在 BIO 中,也就是在 BIO 你也可以这么搞,但是因为 BIO 中有 SSLServerSocket,这个类,一个类就可以搞定了,握手的内部实现和流程控制都在这个JDK的内部来实现,作为程序员完全不用掌握那么多。

本文内容来自:

  1. http://www.bubuko.com/infodetail-1500001.html
  2. https://blog.csdn.net/chyroger/article/details/7217383