Java 下 SSL 通訊原理及例項

有關SSL的原理和介紹在網上已經有不少，對於Java下使用keytool生成證照，配置SSL通訊的教程也非常多。但如果我們不能夠親自動手做一個SSL Sever和SSL Client，可能就永遠也不能深入地理解Java環境下，SSL的通訊是如何實現的。對SSL中的各種概念的認識也可能會僅限於可以使用的程度。本文通過構造一個簡單的SSL Server和SSL Client來講解Java環境下SSL的通訊原理。

首先我們先回顧一下常規的Java Socket程式設計。在Java下寫一個Socket伺服器和客戶端的例子還是比較簡單的。

服務端很簡單：偵聽8080埠，並把客戶端發來的字串返回去。以下是服務端的程式碼：

package org.bluedash.tryssl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Server extends Thread {
    private Socket socket;
    public Server(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) {

        }
    }
    public static void main(String[] args) throws Exception {
        while (true) {
            new Server((new ServerSocket(8080)).accept()).start();
        }
    }
}

客戶端也非常簡單：向服務端發起請求，傳送一個”hello”字串，然後獲得服務端的返回。下面是客戶端的程式碼：

package org.bluedash.tryssl;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class Client {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("localhost", 8080);
        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();
    }
}

把服務端執行起來後，執行客戶端，我們將得到”hello”的返回。

就是這樣一套簡單的網路通訊的程式碼，我們來把它改造成使用SSL通訊。在SSL通訊協議中，我們都知道首先服務端必須有一個數字證照，當客戶端連線到服務端時，會得到這個證照，然後客戶端會判斷這個證照是否是可信的，如果是，則交換通道加密金鑰，進行通訊。如果不信任這個證照，則連線失敗。

因此，我們首先要為服務端生成一個數字證照。Java環境下，數字證照是用keytool生成的，這些證照被儲存在store的概念中，就是證照倉庫。我們來呼叫keytool命令為服務端生成數字證照和儲存它使用的證照倉庫：

keytool -genkey -v -alias bluedash-ssl-demo-server -keyalg RSA -keystore ./server_ks -dname "CN=localhost,OU=cn,O=cn,L=cn,ST=cn,C=cn" -storepass server -keypass 123123

這樣，我們就將服務端證照bluedash-ssl-demo-server儲存在了server_ksy這個store檔案當中。有關keytool的用法在本文中就不再多贅述。執行上面的命令得到如下結果：

Generating 1,024 bit RSA key pair and self-signed certificate (SHA1withRSA) with a validity of 90 days
        for: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
[Storing ./server_ks]

然後，改造我們的服務端程式碼，讓服務端使用這個證照，並提供SSL通訊：

package org.bluedash.tryssl;

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 = "/Users/liweinan/projs/ssl/src/main/resources/META-INF/server_ks";
    private static String SERVER_KEY_STORE_PASSWORD = "123123";

    public static void main(String[] args) throws Exception {
        System.setProperty("javax.net.ssl.trustStore", SERVER_KEY_STORE);
        SSLContext context = SSLContext.getInstance("TLS");

        KeyStore ks = KeyStore.getInstance("jceks");
        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();
        }
    }
}

可以看到，服務端的Socket準備設定工作大大增加了，增加的程式碼的作用主要是將證照匯入並進行使用。此外，所使用的Socket變成了SSLServerSocket，另外埠改到了8443（這個不是強制的，僅僅是為了遵守習慣）。另外，最重要的一點，服務端證照裡面的CN一定和服務端的域名統一，我們的證照服務的域名是localhost，那麼我們的客戶端在連線服務端時一定也要用localhost來連線，否則根據SSL協議標準，域名與證照的CN不匹配，說明這個證照是不安全的，通訊將無法正常執行。

有了服務端，我們原來的客戶端就不能使用了，必須要走SSL協議。由於服務端的證照是我們自己生成的，沒有任何受信任機構的簽名，所以客戶端是無法驗證服務端證照的有效性的，通訊必然會失敗。所以我們需要為客戶端建立一個儲存所有信任證照的倉庫，然後把服務端證照導進這個倉庫。這樣，當客戶端連線服務端時，會發現服務端的證照在自己的信任列表中，就可以正常通訊了。

因此現在我們要做的是生成一個客戶端的證照倉庫，因為keytool不能僅生成一個空白倉庫，所以和服務端一樣，我們還是生成一個證照加一個倉庫（客戶端證照加倉庫）：

keytool -genkey -v -alias bluedash-ssl-demo-client -keyalg RSA -keystore ./client_ks -dname "CN=localhost,OU=cn,O=cn,L=cn,ST=cn,C=cn" -storepass client -keypass 456456

結果如下：

Generating 1,024 bit RSA key pair and self-signed certificate (SHA1withRSA) with a validity of 90 days
        for: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
[Storing ./client_ks]

接下來，我們要把服務端的證照匯出來，並匯入到客戶端的倉庫。第一步是匯出服務端的證照：

keytool -export -alias bluedash-ssl-demo-server -keystore ./server_ks -file server_key.cer

執行結果如下：

Enter keystore password:  server
Certificate stored in file <server_key.cer>

然後是把匯出的證照匯入到客戶端證照倉庫：

keytool -import -trustcacerts -alias bluedash-ssl-demo-server -file ./server_key.cer -keystore ./client_ks

結果如下：

Enter keystore password:  client
Owner: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
Issuer: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
Serial number: 4c57c7de
Valid from: Tue Aug 03 15:40:14 CST 2010 until: Mon Nov 01 15:40:14 CST 2010
Certificate fingerprints:
         MD5:  FC:D4:8B:36:3F:1B:30:EA:6D:63:55:4F:C7:68:3B:0C
         SHA1: E1:54:2F:7C:1A:50:F5:74:AA:63:1E:F9:CC:B1:1C:73:AA:34:8A:C4
         Signature algorithm name: SHA1withRSA
         Version: 3
Trust this certificate? [no]:  yes
Certificate was added to keystore

好，準備工作做完了，我們來撰寫客戶端的程式碼：

package org.bluedash.tryssl;

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 = "/Users/liweinan/projs/ssl/src/main/resources/META-INF/client_ks";

    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.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;
    }
}

可以看到，除了把一些類變成SSL通訊類以外，客戶端也多出了使用信任證照倉庫的程式碼。以上，我們便完成了SSL單向握手通訊。即：客戶端驗證服務端的證照，服務端不認證客戶端的證照。
以上便是Java環境下SSL單向握手的全過程。因為我們在客戶端設定了日誌輸出級別為DEBUG：

System.setProperty("javax.net.debug", "ssl,handshake");

因此我們可以看到SSL通訊的全過程，這些日誌可以幫助我們更具體地瞭解通過SSL協議建立網路連線時的全過程。
結合日誌，我們來看一下SSL雙向認證的全過程：

第一步: 客戶端傳送ClientHello訊息，發起SSL連線請求，告訴伺服器自己支援的SSL選項（加密方式等）。

*** ClientHello, TLSv1

第二步: 伺服器響應請求，回覆ServerHello訊息，和客戶端確認SSL加密方式：

*** ServerHello, TLSv1

第三步: 服務端向客戶端釋出自己的公鑰。

第四步: 客戶端與服務端的協通溝通完畢，服務端傳送ServerHelloDone訊息：

*** ServerHelloDone

第五步: 客戶端使用服務端給予的公鑰，建立會話用金鑰（SSL證照認證完成後，為了提高效能，所有的資訊互動就可能會使用對稱加密演算法），並通過ClientKeyExchange訊息發給伺服器：

*** ClientKeyExchange, RSA PreMasterSecret, TLSv1

第六步： 客戶端通知伺服器改變加密演算法，通過ChangeCipherSpec訊息發給服務端：

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

第七步： 客戶端傳送Finished訊息，告知伺服器請檢查加密演算法的變更請求：

*** Finished

第八步：服務端確認演算法變更，返回ChangeCipherSpec訊息

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

第九步：服務端傳送Finished訊息，加密演算法生效：

*** Finished

那麼如何讓服務端也認證客戶端的身份，即雙向握手呢？其實很簡單，在服務端程式碼中，把這一行：

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

改成：

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

就可以了。但是，同樣的道理，現在服務端並沒有信任客戶端的證照，因為客戶端的證照也是自己生成的。所以，對於服務端，需要做同樣的工作：把客戶端的證照匯出來，並匯入到服務端的證照倉庫：

keytool -export -alias bluedash-ssl-demo-client -keystore ./client_ks -file client_key.cer
Enter keystore password:  client
Certificate stored in file <client_key.cer>

keytool -import -trustcacerts -alias bluedash-ssl-demo-client -file ./client_key.cer -keystore ./server_ks
Enter keystore password:  server
Owner: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
Issuer: CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn
Serial number: 4c57c80b
Valid from: Tue Aug 03 15:40:59 CST 2010 until: Mon Nov 01 15:40:59 CST 2010
Certificate fingerprints:
         MD5:  DB:91:F4:1E:65:D1:81:F2:1E:A6:A3:55:3F:E8:12:79
         SHA1: BF:77:56:61:04:DD:95:FC:E5:84:48:5C:BE:60:AF:02:96:A2:E1:E2
         Signature algorithm name: SHA1withRSA
         Version: 3
Trust this certificate? [no]:  yes
Certificate was added to keystore

完成了證照的匯入，還要在客戶端需要加入一段程式碼，用於在連線時，客戶端向服務端出示自己的證照：

package org.bluedash.tryssl;

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;
    }
}

通過比對單向認證的日誌輸出，我們可以發現雙向認證時，多出了服務端認證客戶端證照的步驟：

*** CertificateRequest
Cert Types: RSA, DSS
Cert Authorities:
<CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn>
<CN=localhost, OU=cn, O=cn, L=cn, ST=cn, C=cn>
*** ServerHelloDone

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

在 @*** ServerHelloDone@ 之前，服務端向客戶端發起了需要證照的請求 @*** CertificateRequest@ 。
在客戶端向服務端發出 @Change Cipher Spec@ 請求之前，多了一步客戶端證照認證的過程 @*** CertificateVerify@ 。
客戶端與服務端互相認證證照的情景，可參考下圖：

參考資料

1. Change Cipher Spec Protocol
2. SSL & TLS Essentials: Securing the Web