SSL socket 通信

本文通过构造一个简单的SSL Server和SSL Client来讲解Java环境下SSL的通信原理。

编写服务器端的代码，与普通的Socket代码不同，我们需要在程序中导入证书，并使用该证书构造SSLSocket。需要的说明的是：

   

    ●KeyStore ks=KeyStore.getInstance("JKS");

   

    访问Java密钥库，JKS是keytool创建的Java密钥库，保存密钥。

   

    ● KeyManagerFactory kmf=KeyManagerFactory.getInstance("SunX509");

   

    创建用于管理JKS密钥库的X.509密钥管理器。

   

    ● SSLContext sslContext=SSLContext.getInstance("SSLv3");

   

    构造SSL环境，指定SSL版本为3.0，也可以使用TLSv1，但是SSLv3更加常用。

   

    ●sslContext.init(kmf.getKeyManagers(),null,null);

   

    初始化SSL环境。第二个参数是告诉JSSE使用的可信任证书的来源，设置为null是从javax.net.ssl.trustStore中获得证书。 第三个参数是JSSE生成的随机数，这个参数将影响系统的安全性，设置为null是个好选择，可以保证JSSE的安全性。

import java.io.BufferedReader;   
import java.io.FileInputStream;   
import java.io.IOException;   
import java.io.InputStreamReader;   
import java.io.PrintWriter;   
import java.net.ServerSocket;   
import java.net.Socket;   
import java.security.KeyStore;   
  
import javax.net.ServerSocketFactory;   
import javax.net.ssl.KeyManagerFactory;   
import javax.net.ssl.SSLContext;   
import javax.net.ssl.SSLServerSocket;   
  
public class SSLServer extends Thread {   
    private Socket socket;   
  
    public SSLServer(Socket socket) {   
        this.socket = socket;   
    }   
  
    public void run() {   
        try {   
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));   
            PrintWriter writer = new PrintWriter(socket.getOutputStream());   
  
            String data = reader.readLine();   
            writer.println(data);   
            writer.close();   
            socket.close();   
        } catch (IOException e) {   
  
        }   
    }   
  
    private static String SERVER_KEY_STORE = "D:/certificate/ceshi/server/zserver.keystore";   
    private static String SERVER_KEY_STORE_PASSWORD = "123456";   
  
    public static void main(String[] args) throws Exception {   
        System.setProperty("javax.net.ssl.trustStore", SERVER_KEY_STORE);   
        SSLContext context = SSLContext.getInstance("SSLv3");   
           
        KeyStore ks = KeyStore.getInstance("jks");   
        ks.load(new FileInputStream(SERVER_KEY_STORE), null);   
        KeyManagerFactory kf = KeyManagerFactory.getInstance("SunX509");   
        kf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());   
           
        context.init(kf.getKeyManagers(), null, null);   
  
        ServerSocketFactory factory = context.getServerSocketFactory();   
        ServerSocket _socket = factory.createServerSocket(8443);   
        ((SSLServerSocket) _socket).setNeedClientAuth(false);   
  
        while (true) {   
            new SSLServer(_socket.accept()).start();   
        }   
    }   
}  

 服务端很简单：侦听8080端口，并把客户端发来的字符串返回去。我们需要为客户端创建一个保存所有信任证书的仓库，然后把服务端证书导进这个仓库。这样，当客户端连接服务端时，会发现服务端的证书在自己的信任列表中，就可以正常通信了。 下面是客户端的代码：

import java.io.BufferedReader;   
import java.io.InputStreamReader;   
import java.io.PrintWriter;   
import java.net.Socket;   
  
import javax.net.SocketFactory;   
import javax.net.ssl.SSLSocketFactory;   
  
public class SSLClient {   
  
    private static String CLIENT_KEY_STORE = "D:/certificate/ceshi/client/zclient.keystore";   
  
    public static void main(String[] args) throws Exception {   
        // Set the key store to use for validating the server cert.   
        System.setProperty("javax.net.ssl.trustStore", CLIENT_KEY_STORE);   
        System.setProperty("javax.net.ssl.trustStorePassword","123456"); 
  
        System.setProperty("javax.net.debug", "ssl,handshake");   
  
        SSLClient client = new SSLClient();   
        Socket s = client.clientWithoutCert();   
  
        PrintWriter writer = new PrintWriter(s.getOutputStream());   
        BufferedReader reader = new BufferedReader(new InputStreamReader(s   
                .getInputStream()));   
        writer.println("hello");   
        writer.flush();   
        System.out.println(reader.readLine());   
        s.close();   
    }   
  
    private Socket clientWithoutCert() throws Exception {   
        SocketFactory sf = SSLSocketFactory.getDefault();   
        Socket s = sf.createSocket("localhost", 8443);   
        return s;   
    }   
}  

 以上便是Java环境下SSL单向握手的全过程。因为我们在客户端设置了日志输出级别为DEBUG：

因此我们可以看到SSL通信的全过程，这些日志可以帮助我们更具体地了解通过SSL协议建立网络连接时的全过程。

结合日志，我们来看一下SSL双向认证的全过程：



第一步: 客户端发送ClientHello消息，发起SSL连接请求，告诉服务器自己支持的SSL选项（加密方式等）。

1. *** ClientHello, TLSv1  

第二步: 服务器响应请求，回复ServerHello消息，和客户端确认SSL加密方式：

1. *** ServerHello, TLSv1  

第三步: 服务端向客户端发布自己的公钥。

第四步: 客户端与服务端的协通沟通完毕，服务端发送ServerHelloDone消息：

1. *** ServerHelloDone  

第五步: 客户端使用服务端给予的公钥，创建会话用密钥（SSL证书认证完成后，为了提高性能，所有的信息交互就可能会使用对称加密算法），并通过ClientKeyExchange消息发给服务器：

1. *** ClientKeyExchange, RSA PreMasterSecret, TLSv1  

第六步： 客户端通知服务器改变加密算法，通过ChangeCipherSpec消息发给服务端：

1. main, WRITE: TLSv1 Change Cipher Spec, length = 1  

第七步： 客户端发送Finished消息，告知服务器请检查加密算法的变更请求：

1. *** Finished  

第八步：服务端确认算法变更，返回ChangeCipherSpec消息

1. main, READ: TLSv1 Change Cipher Spec, length = 1  

第九步：服务端发送Finished消息，加密算法生效：

1. *** Finished  

那么如何让服务端也认证客户端的身份，即双向握手呢？其实很简单，在服务端代码中，把这一行：

1. ((SSLServerSocket) _socket).setNeedClientAuth(false);  

改成：

((SSLServerSocket) _socket).setNeedClientAuth(true); 

就可以了。但是，同样的道理，现在服务端并没有信任客户端的证书，因为客户端的证书也是自己生成的。所以，对于服务端，需要做同样的工作：把客户端的证书导出来，并导入到服务端的证书仓库：完成了证书的导入，还要在客户端需要加入一段代码，用于在连接时，客户端向服务端出示自己的证书：

import java.io.BufferedReader;   
import java.io.FileInputStream;   
import java.io.InputStreamReader;   
import java.io.PrintWriter;   
import java.net.Socket;   
import java.security.KeyStore;   
import javax.net.SocketFactory;   
import javax.net.ssl.KeyManagerFactory;   
import javax.net.ssl.SSLContext;   
import javax.net.ssl.SSLSocketFactory;   
  
public class SSLClient {   
    private static String CLIENT_KEY_STORE = "/Users/liweinan/projs/ssl/src/main/resources/META-INF/client_ks";   
    private static String CLIENT_KEY_STORE_PASSWORD = "456456";   
       
    public static void main(String[] args) throws Exception {   
        // Set the key store to use for validating the server cert.   
        System.setProperty("javax.net.ssl.trustStore", CLIENT_KEY_STORE);   
        System.setProperty("javax.net.debug", "ssl,handshake");   
        SSLClient client = new SSLClient();   
        Socket s = client.clientWithCert();   
           
        PrintWriter writer = new PrintWriter(s.getOutputStream());   
        BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream()));   
        writer.println("hello");   
        writer.flush();   
        System.out.println(reader.readLine());   
        s.close();   
    }   
  
    private Socket clientWithoutCert() throws Exception {   
        SocketFactory sf = SSLSocketFactory.getDefault();   
        Socket s = sf.createSocket("localhost", 8443);   
        return s;   
    }   
  
    private Socket clientWithCert() throws Exception {   
        SSLContext context = SSLContext.getInstance("TLS");   
        KeyStore ks = KeyStore.getInstance("jceks");   
           
        ks.load(new FileInputStream(CLIENT_KEY_STORE), null);   
        KeyManagerFactory kf = KeyManagerFactory.getInstance("SunX509");   
        kf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());   
        context.init(kf.getKeyManagers(), null, null);   
           
        SocketFactory factory = context.getSocketFactory();   
        Socket s = factory.createSocket("localhost", 8443);   
        return s;   
    }   
}  

通过比对单向认证的日志输出，我们可以发现双向认证时，多出了服务端认证客户端证书的步骤：

1. 1. *** CertificateRequest   
   2. Cert Types: RSA, DSS   
   3. Cert Authorities:   
   4. <CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn>   
   5. <CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn>   
   6. *** ServerHelloDone 

1. *** CertificateVerify   
2. main, WRITE: TLSv1 Handshake, length = 134  
3. main, WRITE: TLSv1 Change Cipher Spec, length = 1

@*** ServerHelloDone@ 之前，服务端向客户端发起了需要证书的请求 @*** CertificateRequest@ 。

在客户端向服务端发出 @Change Cipher Spec@ 请求之前，多了一步客户端证书认证的过程 @*** CertificateVerify@ 。

客户端与服务端互相认证证书的情景，可参考下图：