首页 > 其他 > 详细

j.一个NIO与SSLEngine结合的例子

时间:2016-04-12 00:26:29      阅读:2485      评论:0      收藏:0      [点我收藏+]

标签:class   style   log   com   http   si   it   使用   la   

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

对于NIO通道来讲,我们一贯的思维也是存在一个SSLServerSocketChannel,然后注册到selector中,后续的操作也和普通的ServerSocketChannel没什么区别了,但是,并不存在一个SSLServerSocketChannel,关于这一点,JSSE的官方的Reference Guide中:
技术分享
翻译出来的原因主要有一下两点:
1.因为JDK类继承限制,无法搞出一个SSLServerSocketChannel,如果需要搞出这样的一个类,需要在源码和API中大动干戈。
2.其次,JSSE的框架设计不想因为封装出一个SSLServerSocketChannel,就将NIO的灵活多变,并且高性能的优势给抹掉。
因此,基于上述的原因,最终JSSE在NIO通道中并没有SSLServerSocketChannel,而是采用NIO + SSLEngine的方式进行实现。

NIO的selector体系这里就不再说了,也即是ServerSocketChannel注册到Selector中,然后进行轮询,如果事件发生了,SelectionKey就被遍历出来,然后判断监听的是register事件,还是read/write事件,事件触发后,将socket的数据读取到缓冲区中。这是NIO的思路,而如果在NIO中使用SSL,也是延续这样的一个套路,不用做任何的改变.
read/write事件发生之后,普通的socket直接就开始读取数据了,这个时候SSLEngine就开始工作了,首先SSLEngine会调用beginHandShake开始准备握手,然后执行握手,握手的工作是需要通过编程,调用SSLEngine的出栈和入栈来完成的,看下面的一个图:
技术分享
你可以认为SSLEngine相当于一个黑盒子,它的内部封装了SSL握手,会话等各种协议实现。而我们看到上面的四个蓝色的buffer,左面的两个是应用程序中定义的buffer,供应用程序使用的,右面的两个是需要从socket缓冲区或者socketchannel接收数据并存放的buffer,用于缓存使用的;SSLEngine的一共两个操作,一个是wrap,叫做出栈,发出的出,从应用的buffer中,到网络缓冲区的buffer中,SSLEngine起到的是转接的作用,相反的是unwrap,数据从网络缓冲区流入到应用程序中。
我们为什么要了解SSLEngine这样的一个架构呢?
因为NIO方式的SSL交互,必须要通过SSLEngine来实现,甚至是握手也需要通过这种方法来实现,我们需要编程调用wrap和unwrap,并根据出栈和入栈是否成功,和下一步的需要做的动作,再执行什么动作。
判断的依据是两个状态:
第一个是SSLEngineResult.HandShakeStatus:
技术分享
这个状态指示,当每一次SSLEngine的wrap或者unwrap之后下一步应该干什么。
例如NEED_WRAP状态,相当于下一步我们需要执行wrap;如果状态是NEED_UNWRAP状态,那么下一步应该执行unwrap;NOT_HANDSHAKING说明握手没有成功,应该抛出异常;如果是NEED_TASK状态,SSL协议中定义了一些耗时比较长的操作,需要执行delegate操作,这里应该开启一个线程,将这个耗时比较长的操作给执行了,例如CRL的远程校验。
这里可以看到,我们编程的时候,应该会有一个while循环,因为SSL的握手协议不是一下子就完成的,需要客户端和服务器端反复的进行交互,这里面会不断的通过SSLEngine进行wrap和unwrap等其它的操作;
其次,需要对上面的这几种状态进行条件判断,可以使用case语句。

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

我们来看一个例子:
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(inpassword);
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(keyStorepassword);

        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(kmf.getKeyManagers(), nullnull);
        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 keythrows 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(peerNetDatapeerAppData);//调用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(peerNetDatapeerAppData);
                    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(dummymyNetData);//意味着从应用程序中发送数据到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[] argsthrows Exception {
        new SSLHandshakeServer().run();
    }
}  

总结一下,NIO+SSLEngine的这种方式,可以说是高度的开放,利用SSLEngine这个工具,来完成握手这个过程,而握手的过程需要通过编程和控制状态来实现,实际上,这也是JDK的API设计的缺陷之一,没有封装的好,让我们程序员写这些莫名其妙的代码,而JDK说加不了SSLServerSocketChannel其实应该就是一个说辞而已,不过,既然如此,那我们只需按照他的要求进行编程,也能达到NIO中SSL通道的效果。
SSLEngine也可以用在BIO中,也就是在BIO你也可以这么搞,但是因为BIO中有SSLServerSocket,这个类,一个类就可以搞定了,握手的内部实现和流程控制都在这个JDK的内部来实现,作为程序员完全不用掌握那么多。
Tomcat中的代码基本上和上述的代码类似,在下一节中,我们会重点就这块分析一下Tomcat的NIO通道中的SecurityNioChannel的实现的,非常的相似。

上面的程序握手完毕就拉倒了,双方没有继续发送数据,当然你可以在双方成功握手之后,继续使用SSLEngine来发送数据,而再次发送的数据就是进行加密传输的了,这些都是SSLEngine的实现了,需要分析JDK的代码了。

最后给出上面的服务器端对应的客户端程序,可以比对一下,其实差不太多:
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(inpassword);
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(trustStore);
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(nulltmf.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 keythrows 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(peerNetDatapeerAppData);
                    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(peerNetDatapeerAppData);
                    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(dummymyNetData);
                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[] argsthrows Exception {
        new SSLHandshakeClient().run();
    }
}  














j.一个NIO与SSLEngine结合的例子

标签:class   style   log   com   http   si   it   使用   la   

原文:http://www.cnblogs.com/yuantongaaaaaa/p/5380503.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号