Java での SSL 通信原則のサンプル コード共有

インターネット上にはすでに SSL に関する多くの原則と入門書があり、keytool を使用して Java で証明書を生成し、SSL 通信を構成するチュートリアルも数多くあります。しかし、SSL サーバーと SSL クライアントを自分で作成できない場合、Java 環境で SSL 通信がどのように実装されているかを深く理解することはできないかもしれません。 SSL のさまざまな概念に関する知識も、使用できる範囲に限定される場合があります。この記事では、簡単な SSL サーバーと SSL クライアントを構築することで、Java 環境における SSL の通信原理を説明します。

まず、通常の Java Socket プログラミングを復習しましょう。 Java でソケット サーバーとクライアントの例を記述するのは比較的簡単です。

サーバーは非常に単純です: ポート 8080 をリッスンし、クライアントから送信された string を返します。以下はサーバー コードです:

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 を使用して生成され、これらの証明書は証明書ウェアハウスであるストアの概念に保管されます。 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 ストア ファイルに保存します。 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();
        }
    }
}

ご覧のとおり、サーバー上でソケットの準備と設定が行われています。コードの機能は主に証明書をインポートして使用することです。さらに、使用されるソケットは 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

一部のクラスを SSL 通信クラスに変換することに加えて、クライアントには信頼証明書ウェアハウスを使用するための追加コードもあることがわかります。以上でSSL片方向ハンドシェイク通信が完了しました。つまり、クライアントはサーバーの証明書を検証しますが、サーバーはクライアントの証明書を検証しません。

上記はJava環境におけるSSL一方向ハンドシェイクの全プロセスです。クライアントのログ出力レベルを DEBUG:

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 プロトコルを介してネットワーク接続を確立するプロセス全体をより具体的に理解するのに役立ちます。

ログと組み合わせて、SSL 双方向認証のプロセス全体を見てみましょう:

ステップ 1: クライアントは ClientHello メッセージを送信し、SSL 接続リクエストを開始し、サポートする SSL オプションをサーバーに伝えます (暗号化方式など）。

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

ステップ 2: サーバーはリクエストに応答し、ServerHello メッセージに応答し、クライアントに SSL 暗号化方式を確認します。

*** ClientHello, TLSv1

ステップ 3: サーバーはその公開キーをクライアントに公開します。

第四步: 客户端与服务端的协通沟通完毕，服务端发送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@ 。
客户端与服务端互相认证证书的情景，可参考下图：

以上がJava での SSL 通信原則のサンプル コード共有の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。