`
fxly0401
  • 浏览: 148136 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

SSL介绍与Java实例

javassl加密 
阅读更多
   原文链接：http://www.iteye.com/topic/1125183
   有关SSL的原理和介绍在网上已经有不少，对于Java下使用keytool生成证书，配置SSL通信的教程也非常多。但如果我们不能够亲自动手做一个SSL Sever和SSL Client，可能就永远也不能深入地理解Java环境下，SSL的通信是如何实现的。对SSL中的各种概念的认识也可能会仅限于可以使用的程度。本文通过构造一个简单的SSL Server和SSL Client来讲解Java环境下SSL的通信原理。

首先我们先回顾一下常规的Java Socket编程。在Java下写一个Socket服务器和客户端的例子还是比较简单的。以下是服务端的代码：

Java代码  
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();   
        }   
    }   
}
  

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


服务端很简单：侦听8080端口，并把客户端发来的字符串返回去。下面是客户端的代码：

Java代码  
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();   
    }   
  
} 


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"字串，然后获得服务端的返回。把服务端运行起来后，执行客户端，我们将得到"hello"的返回。

就是这样一套简单的网络通信的代码，我们来把它改造成使用SSL通信。在SSL通信协议中，我们都知道首先服务端必须有一个数字证书，当客户端连接到服务端时，会得到这个证书，然后客户端会判断这个证书是否是可信的，如果是，则交换信道加密密钥，进行通信。如果不信任这个证书，则连接失败。

因此，我们首先要为服务端生成一个数字证书。Java环境下，数字证书是用keytool生成的，这些证书被存储在store的概念中，就是证书仓库。我们来调用keytool命令为服务端生成数字证书和保存它使用的证书仓库：

Bash代码  
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  

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的用法在本文中就不再多赘述。执行上面的命令得到如下结果：

Bash代码  
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]  

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通信：

Java代码  
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();   
        }   
    }   
} 


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不能仅生成一个空白仓库，所以和服务端一样，我们还是生成一个证书加一个仓库（客户端证书加仓库）：

Bash代码  
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  

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


结果如下：

Bash代码  
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]  

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]

接下来，我们要把服务端的证书导出来，并导入到客户端的仓库。第一步是导出服务端的证书：

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

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

执行结果如下：

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

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

然后是把导出的证书导入到客户端证书仓库：

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

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

结果如下：

Bash代码  
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  

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


好，准备工作做完了，我们来撰写客户端的代码：

Java代码  
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;   
    }   
}  


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：

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

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

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

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



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

Bash代码  
*** ClientHello, TLSv1  

*** ClientHello, TLSv1

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

Bash代码  
*** ServerHello, TLSv1  

*** ServerHello, TLSv1


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

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

Bash代码  
*** ServerHelloDone  

*** ServerHelloDone


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

Bash代码  
*** ClientKeyExchange, RSA PreMasterSecret, TLSv1  

*** ClientKeyExchange, RSA PreMasterSecret, TLSv1


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

Bash代码  
main, WRITE: TLSv1 Change Cipher Spec, length = 1  

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


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

Bash代码  
*** Finished  

*** Finished


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

Bash代码  
main, READ: TLSv1 Change Cipher Spec, length = 1  

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


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

Bash代码  
*** Finished  

*** Finished


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

Java代码  
((SSLServerSocket) _socket).setNeedClientAuth(false);  

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

改成：

Java代码  
((SSLServerSocket) _socket).setNeedClientAuth(true);  

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

就可以了。但是，同样的道理，现在服务端并没有信任客户端的证书，因为客户端的证书也是自己生成的。所以，对于服务端，需要做同样的工作：把客户端的证书导出来，并导入到服务端的证书仓库：

Bash代码  
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 -export -alias bluedash-ssl-demo-client -keystore ./client_ks -file client_key.cer
Enter keystore password:  client
Certificate stored in file <client_key.cer>

Bash代码  
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  

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

完成了证书的导入，还要在客户端需要加入一段代码，用于在连接时，客户端向服务端出示自己的证书：

Java代码  
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;   
    }   
} 


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

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

Bash代码  
*** 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  

*** 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


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

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


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

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

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


参考资料：

fn1. Tomcat双向SSL认证的配置 - http://www.javaeedev.com/blog/article.jspx?articleId=ff808081198fb524011993a9bb7a029a

fn2. Understanding SSL - http://developerspoint.wordpress.com/2008/06/21/understanding-ssl/

fn3. Change Cipher Spec Protocol - http://www.pierobon.org/ssl/ch2/ccs.htm

fn4. SSL & TLS Essentials: Securing the Web - http://www.amazon.com/SSL-TLS-Essentials-Securing-Web/dp/0471383546/ref=sr_1_1?ie=UTF8&s=books&qid=1280891641&sr=8-1

评论一：
另外，最重要的一点，服务端证书里面的CN一定和服务端的域名统一，我们的证书服务的域名是localhost，那么我们的客户端在连接服务端时一定也要用localhost来连接，否则根据SSL协议标准，域名与证书的CN不匹配，说明这个证书是不安全的，通信将无法正常运行
此次加入以下代码也可以解决： 
System.setProperty("java.protocol.handler.pkgs", "javax.net.ssl"); 
     HostnameVerifier hv = new HostnameVerifier() { 
          public boolean verify(String urlHostName, SSLSession session) { 
           return urlHostName.equals(session.getPeerHost()); 
          } 
     }; 
    
     HttpsURLConnection.setDefaultHostnameVerifier(hv);


评论二：
还有我觉得这样就可以了，不知道对不对？至少我能正常通信。 
System.setProperty("javax.net.ssl.keyStore", "D:/server31.keystore"); 
System.setProperty("javax.net.ssl.keyStorePassword", "password"); 
System.setProperty("javax.net.ssl.trustStore", "D:/server31.keystore"); 
System.setProperty("javax.net.ssl.trustStorePassword", "password");


可以的，keyStore和trustStore可以共用一个文件，没有问题。store就相当于一个钱包，这里面可以放证书也可以放自己的密钥。

评论三：
smallbee 写道
最近项目也在用Https，其中一个系统1是银行系统，部署在银行内部，另外一个系统2可以部署在行内也可以部署在行外。之前系统2都是行内的，所以走socket通信，现在想增加一个https通信方便行外系统2对接系统1。

后台都是java写的。要求ssl双向认证。

用jdk生成证书然后Https通信都成功了。

想请教下:
1、这个证书的一个过程是怎么样的？证书是自己做的么？然后去CA认证，还是都是从CA买的，他们帮我们认证好？
2、从上面的说法，如果想发给服务器，需要把服务器证书倒出来到客户端，让客户端信任服务器证书，然后实现通信。但是如果证书是从CA那里验证过的，是不是不需要导出到客户端这个步骤，直接配置服务器证书就可以了，验证的工作室客户端拿服务器证书去CA认证，这个认证走通信么？会连接CA服务器还是本地证书文件验证？

阿男bluedash回复：

证书，就是用来自己证明身份的证书，你可以自己生成一个，但是没有用。为什么呢？因为数字证书必须由第三方的权威机构签名后才有效。
权威机构就那几家，你可以打开你的任何浏览器，在选项里面，找高ssl相关的配置，可以看到每个浏览器里面，都有默认的几十家权威机构的数字签名文件。
对于java环境，这些默认的机构也存在，它们的签名保存在keystore里面，我们自己生成的数字证书，都是自签名的，自己签自己。
这种默认是不被浏览器或是jvm环境接受的，原因上面说了，因为我们自己签名不算数的，“自己”这个机构不在默认的keystore里面。

所以，现在问题来了，怎么样，让客户端信任服务端这个自签名的证书呢？
答案你已经知道了，将自己的证书，导进需要信任你的证书的keystore里面。

jvm有自已默认的keystore，在java的安装目录里面，是jre/lib/security/xxx那个。
/usr/lib/jvm/jre/lib/security/cacerts
里面包含了很多第三方的权威机构的数字证书。
但是我们在做项目的时候，不想污染这个默认的库，会产生安全问题。
所以我们用keytool自己生成一个全新的keystore，其实就是一个文件，你知道的。

对于自签名的证书，肯定是不可能通过验证的
如果我们把自签名的证书导进这个cacerts里面
那么我们自己签的所有证书，就都在自己的java环境下面可以认证通过了。
但是如果你想让别人的环境下面也认你这个证书，就要在别人的环境下面把你的证书给加进信任列表
如果对方是个浏览器，就把证书导出来，让对方加进浏览器的信任列表
如果对方是java，就让对方将你的证书导入到他们的keystore

当然，如果你的证书是找Verisign签过名的，那就完全没问题了。
但是Verisign非常贵，一年好多钱，所以只有生产系统上才用。因为，我们不可能让所有的用户都把服务端自签名证书导到他们的环境里，那是不现实的。而且，浏览器会弹窗报警，说服务端提供的证书不是受信的第三方签名的，用户一看有危险就闪人了。

所以，说了这么半天，你应该明白了一个道理：SSL并不存在服务端和客户端，只存在谁需要信任谁

那么我问个问题，双向握手时，需要几个证书？单向握手时，需要几个证书？

如果服务端强制要求客户端提供证书
那么他那边必定要给你生成一个能用的证书，在他的信任列表里面
否则你自己生成的客户端证书是没有用的，必须找对方签名才可以
因为对方的环境里面不可能信任你自生成的证书

如果是双向握手，为什么需要给你两个证书？
因为除了客户端要验证服务端身份, 服务器段也要验证客户端身份, 只有允许的客户端, 才能发起请求

所以，如果服务端需要验证客户端身份，那对方必须给你一个他信任的客户端证书，
要么就是：你自己生成一个客户端证书，让对方去签名。

总之必须由对方提供，你自己生成的自签名证书，是不可能在对方的信任列表里的。
如果手里现在只有一个证书，应该有两种情况：1. 这个是服务端证书，只需要单向握 2. 需要双向握手，对方少给你一个证书

我文章中单向握手的客户端的例子
客户端不向服务端提供客户端证书
客户端只验证服务端证书
即clientWithoutCert()这个列子


理解了原理最重要
后续的问题就都不难了。

原理特别简单：你自己做张信用卡，自己签个名，去商店买东西，没人要
于是你找银行给你背书：此信用卡有效，和银行账户绑定，你四处用，就okay了
但是银行给你签名要花钱，你只是试着玩，于是你找朋友商店，让他给你签个名，你这张卡在他的店里面有效，于是，你的卡在他的店里就能用了

所以不存在谁是客户端，谁是服务端，只是看谁签名，谁信任谁，就这样。把这个印在脑子里，就特别简单。

keystore没什么神奇的，就是一个钱包，里面有你自己的卡（自己的证书），可以拿去用，还有几张证书（第三方机构的证书），别人在你这用卡的时候，你对证书查，发现别人的卡是你这证书上面机构发的，你就信任。
  • 大小: 25.6 KB
  • 大小: 41.9 KB
分享到：
| 业务系统与监控系统并存
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java中的SSL及HTTPS协议实例源码

    让我们看看如何在Java中使用SSL和HTTPS协议的源码实例： ```java import javax.net.ssl.HttpsURLConnection; import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; public ...

    基于java的开发源码-SSL及HTTPS协议实例源码.zip

    基于java的开发源码-SSL及HTTPS协议实例源码.zip 基于java的开发源码-SSL及HTTPS协议实例源码.zip 基于java的开发源码-SSL及HTTPS协议实例源码.zip 基于java的开发源码-SSL及HTTPS协议实例源码.zip 基于java的开发...

    java https ssl 实例 例子

    Java sslSocket 聊天实例是使用 Java 的 SSL SOCKET 编程来实现安全聊天室功能的示例程序。 十二、用 COMMVIEW 工具截获浏览器访问支付宝的 TCP/IP 包 COMMVIEW 是一个网络嗅探工具，能够截获网络数据包。在本实例...

    SSL.rar_JAVA SSL _ssl_ssl java

    2. 初始化SSLContext：使用KeyManagerFactory创建KeyManager实例，然后与TrustManagerFactory创建的TrustManager一起，用于初始化SSLContext对象。 3. 创建SSLEngine：SSLContext的createSSLEngine方法用于创建...

    java源码包实例源码JAVA开发源码55个合集.zip

    Java中的SSL及HTTPS协议实例源码.rar Java写的ATM机取款模拟程序.zip Java写的一个mp3播放器.rar Java写的图片幻灯片切换特效.rar Java写的天气预报软件.rar Java写的巨型LCD液晶时钟显示屏.rar JAVA图书馆管理系统...

    JAVA源码Java中的SSL及HTTPS协议实例源码

    JAVA源码Java中的SSL及HTTPS协议实例源码

    基于Java的实例开发源码-SSL及HTTPS协议实例源码.zip

    学习这个实例，你可以深入理解SSL/TLS的实现细节，包括如何在Java中设置和管理证书，以及如何处理SSL/TLS连接的各种状态和事件。这对于提升网络安全意识，以及编写自己的安全通信软件非常有帮助。 对于初学者，通过...

    Java中的SSL及HTTPS协议实例源码.rar

    SSL是一种用于在网络中建立安全连接的协议，而HTTPS则是HTTP协议与SSL/TLS（Transport Layer Security，SSL的后续版本）的结合，为HTTP提供了加密传输、服务器身份验证和消息完整性检查的能力。 SSL协议主要包含...

    基于Java的实例源码-SSL及HTTPS协议实例源码.zip

    综上所述，Java中的SSL和HTTPS协议实例源码可以帮助开发者深入理解如何在实际项目中实现安全的网络通信。通过学习和实践这些源码，不仅可以提高对SSL/TLS协议的理解，还能提升在网络安全领域的开发能力。

    Java中的SSL及HTTPS协议实例源码.zip

    通过实际的源码实例，我们可以深入理解这些概念，学习如何在Java代码中实现和配置SSL连接，从而增强系统的安全性。在实际项目中，我们还需要关注性能优化，如复用SSL连接、减少握手次数等，以提升系统效率。

    java源码资源Java中的SSL及HTTPS协议实例源码

    java源码资源Java中的SSL及HTTPS协议实例源码提取方式是百度网盘分享地址

    ssl_java.zip

    Java平台提供了一套完整的API，即JSSE（Java Secure Socket Extension），来支持SSL协议。在Java中实现SSL双向认证，也被称为mutual authentication，是指客户端和服务器都需要向对方证明自己的身份。以下将详细讲解...

    java源码：Java中的SSL及HTTPS协议实例源码.rar

    总的来说，这个压缩包中的源码实例将带你深入了解Java中的SSL和HTTPS协议，以及如何在实际项目中应用这些知识，确保网络通信的安全性。通过学习和实践这些代码，你可以更好地掌握Java安全编程，并能解决诸如数据加密...

    SSL及HTTPS协议实例源码

    4. **SSLContext**：在Java中，SSLContext负责配置和创建SSL/TLS连接，包括加载密钥库和信任库。 5. **TrustManager和KeyManager**：这两者是SSLContext的组成部分，TrustManager负责验证服务器的证书，KeyManager则...

    基于java的中的SSL及HTTPS协议实例源码.zip

    本资源“基于Java的中的SSL及HTTPS协议实例源码.zip”包含了实现这些协议的代码示例，有助于开发者深入理解并应用到实际项目中。 SSL是一种网络安全协议，其主要功能是为网络通信提供加密处理，保证数据在网络传输...

    JAVA实现SSL协议

    Java 实现 SSL（Secure Socket Layer）协议主要用于在网络通信中提供安全性和私密性，它通过加密数据和验证身份来确保信息在互联网上的安全传输。在Java中，SSL协议的实现主要依赖于`java.security`和`javax.net.ssl...

    Java Socket 实现SMTP邮件发送，支持SSL/TSL

    Java Socket编程是Java网络编程的基础，它提供了网络通信的能力，使得程序可以与其他计算机上的服务进行交互。在本案例中，我们将关注如何使用Java Socket来实现SMTP（Simple Mail Transfer Protocol）邮件发送，并...

Magicbox
Global site tag (gtag.js) - Google Analytics