Java实现 SSL双向认证

我们常见的SSL验证较多的只是验证我们的服务器是否是真实正确的，当然如果你访问的URL压根就错了，那谁也没有办法。这个就是所谓的SSL单向认证。

 

但是实际中，我们有可能还会验证客户端是否符合要求，也就是给我们每个用户颁发一个证书，比且每个数字证书都是唯一的，不公开的。这样就能通过这个数字证书保证当前访问我服务器的这个用户是经过服务器认可的，其他人不可访问。

 

双向认证 从第一个层面上 确保了服务器 与客户端 都是互相认可的。那么他们之间要进行通信，就会在通信协议上附加SSL协议，确保通信的内容是加密的，即使是sniffer这样的网络嗅探工具看到的都是 乱码。以后给大家演示下不加密的情况下，用sniffer看到的是什么。恐怕这样你就能提高警惕了。

 

以下内容从网络上摘抄 加以实际验证后修改的。

 

模拟场景：
Server端和Client端通信，需要进行授权和身份的验证，即Client只能接受Server的消息，Server只能接受Client的消息。

实现技术：
JSSE（Java Security Socket Extension）
是Sun为了解决在Internet上的安全通讯而推出的解决方案。它实现了SSL和TSL（传输层安全）协议。在JSSE中包含了数据加密，服务器验 证，消息完整性和客户端验证等技术。通过使用JSSE，开发人员可以在客户机和服务器之间通过TCP/IP协议安全地传输数据。

 

为了实现消息认证。
Server需要：
1）KeyStore: 其中保存服务端的私钥
2）Trust KeyStore:其中保存客户端的授权证书
同样，Client需要：
1）KeyStore：其中保存客户端的私钥
2）Trust KeyStore：其中保存服务端的授权证书

 

在这里我还是推荐使用Java自带的keytool命令，去生成这样信息文件。当然目前非常流行的开源的生成SSL证书的还有OpenSSL。 OpenSSL用C语言编写，跨系统。但是我们可能在以后的过程中用java程序生成证书的方便性考虑，还是用JDK自带的keytool。

1）生成服务端私钥，并且导入到服务端KeyStore文件中
keytool -genkey -alias serverkey -keystore kserver.keystore
过程中，分别需要填写，根据需求自己设置就行
keystore密码：123456
名字和姓氏：jin
组织单位名称：none
组织名称：none
城市或区域名称：BJ
州或省份名称：BJ
国家代码：CN
serverkey私钥的密码，不填写和keystore的密码一致。这里千万注意，直接回车就行了，不用修改密码。否则在后面的程序中以及无法直接应用这个私钥，会报错。

 

 

就可以生成kserver.keystore文件
server.keystore是给服务端用的，其中保存着自己的私钥

2）根据私钥，导出服务端证书
keytool -export -alias serverkey -keystore kserver.keystore -file server.crt
server.crt就是服务端的证书

3）将服务端证书，导入到客户端的Trust KeyStore中
keytool -import -alias serverkey -file server.crt -keystore tclient.keystore
tclient.keystore是给客户端用的，其中保存着受信任的证书

采用同样的方法，生成客户端的私钥，客户端的证书，并且导入到服务端的Trust KeyStore中
1）keytool -genkey -alias clientkey -keystore kclient.keystore
2）keytool -export -alias clientkey -keystore kclient.keystore -file client.crt
3）keytool -import -alias clientkey -file client.crt -keystore tserver.keystore

如此一来，生成的文件分成两组
服务端保存：kserver.keystore tserver.keystore
客户端保存：kclient.keystore  tclient.kyestore

 

  

以下是通过Java Socket通信程序来验证我们生成的证书是否可用。

客户端：

 

客户端代码  

1. package examples.ssl;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8. import java.io.OutputStream;  
9. import java.security.KeyStore;  
10.   
11. import javax.net.ssl.KeyManagerFactory;  
12. import javax.net.ssl.SSLContext;  
13. import javax.net.ssl.SSLSocket;  
14. import javax.net.ssl.TrustManagerFactory;  
15.   
16. /**  
17.  * SSL Client  
18.  *   
19.  */  
20. public class SSLClient {  
21.   
22.     private static final String DEFAULT_HOST                    = "127.0.0.1";  
23.     private static final int    DEFAULT_PORT                    = 7777;  
24.   
25.     private static final String CLIENT_KEY_STORE_PASSWORD       = "123456";  
26.     private static final String CLIENT_TRUST_KEY_STORE_PASSWORD = "123456";  
27.   
28.     private SSLSocket           sslSocket;  
29.   
30.     /**  
31.      * 启动客户端程序  
32.      *   
33.      * @param args  
34.      */  
35.     public static void main(String[] args) {  
36.         SSLClient client = new SSLClient();  
37.         client.init();  
38.         client.process();  
39.     }  
40.   
41.     /**  
42.      * 通过ssl socket与服务端进行连接,并且发送一个消息  
43.      */  
44.     public void process() {  
45.         if (sslSocket == null) {  
46.             System.out.println("ERROR");  
47.             return;  
48.         }  
49.         try {  
50.             InputStream input = sslSocket.getInputStream();  
51.             OutputStream output = sslSocket.getOutputStream();  
52.   
53.             BufferedInputStream bis = new BufferedInputStream(input);  
54.             BufferedOutputStream bos = new BufferedOutputStream(output);  
55.   
56.             bos.write("Client Message".getBytes());  
57.             bos.flush();  
58.   
59.             byte[] buffer = new byte[20];  
60.             bis.read(buffer);  
61.             System.out.println(new String(buffer));  
62.   
63.             sslSocket.close();  
64.         } catch (IOException e) {  
65.             System.out.println(e);  
66.         }  
67.     }  
68.   
69.     /**  
70.      * <ul>  
71.      * <li>ssl连接的重点:</li>  
72.      * <li>初始化SSLSocket</li>  
73.      * <li>导入客户端私钥KeyStore，导入客户端受信任的KeyStore(服务端的证书)</li>  
74.      * </ul>  
75.      */  
76.     public void init() {  
77.         try {  
78.             SSLContext ctx = SSLContext.getInstance("SSL");  
79.   
80.             KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");  
81.             TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");  
82.   
83.             KeyStore ks = KeyStore.getInstance("JKS");  
84.             KeyStore tks = KeyStore.getInstance("JKS");  
85.   
86.             ks.load(new FileInputStream("E://kclient.keystore"), CLIENT_KEY_STORE_PASSWORD.toCharArray());  
87.             tks.load(new FileInputStream("E://tclient.keystore"), CLIENT_TRUST_KEY_STORE_PASSWORD.toCharArray());  
88.   
89.             kmf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());  
90.             tmf.init(tks);  
91.   
92.             ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);  
93.   
94.             sslSocket = (SSLSocket) ctx.getSocketFactory().createSocket(DEFAULT_HOST, DEFAULT_PORT);  
95.         } catch (Exception e) {  
96.             System.out.println(e);  
97.         }  
98.     }  
99.   
100. }  

 

服务器端：

Java代码  

1. package examples.ssl;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.Socket;  
9. import java.security.KeyStore;  
10.   
11. import javax.net.ssl.KeyManagerFactory;  
12. import javax.net.ssl.SSLContext;  
13. import javax.net.ssl.SSLServerSocket;  
14. import javax.net.ssl.TrustManagerFactory;  
15.   
16. /*********************************************************************************************************************** 
17.  * <ul> 
18.  * <li>1)生成服务端私钥</li> 
19.  * <li>keytool -genkey -alias serverkey -keystore kserver.keystore</li> 
20.  * <li>2)根据私钥,到处服务端证书</li> 
21.  * <li>keytool -exoport -alias serverkey -keystore kserver.keystore -file server.crt</li> 
22.  * <li>3)把证书加入到客户端受信任的keystore中</li> 
23.  * <li>keytool -import -alias serverkey -file server.crt -keystore tclient.keystore</li> 
24.  * </ul> 
25.  **********************************************************************************************************************/  
26.   
27. /** 
28.  * SSL Server 
29.  *  
30.  */  
31. public class SSLServer {  
32.   
33.     private static final int    DEFAULT_PORT                    = 7777;  
34.   
35.     private static final String SERVER_KEY_STORE_PASSWORD       = "123456";  
36.     private static final String SERVER_TRUST_KEY_STORE_PASSWORD = "123456";  
37.   
38.     private SSLServerSocket     serverSocket;  
39.   
40.     /** 
41.      * 启动程序 
42.      *  
43.      * @param args 
44.      */  
45.     public static void main(String[] args) {  
46.         SSLServer server = new SSLServer();  
47.         server.init();  
48.         server.start();  
49.     }  
50.   
51.     /** 
52.      * <ul> 
53.      * <li>听SSL Server Socket</li> 
54.      * <li> 由于该程序不是演示Socket监听，所以简单采用单线程形式，并且仅仅接受客户端的消息，并且返回客户端指定消息</li> 
55.      * </ul> 
56.      */  
57.     public void start() {  
58.         if (serverSocket == null) {  
59.             System.out.println("ERROR");  
60.             return;  
61.         }  
62.         while (true) {  
63.             try {  
64.                 Socket s = serverSocket.accept();  
65.                 InputStream input = s.getInputStream();  
66.                 OutputStream output = s.getOutputStream();  
67.   
68.                 BufferedInputStream bis = new BufferedInputStream(input);  
69.                 BufferedOutputStream bos = new BufferedOutputStream(output);  
70.   
71.                 byte[] buffer = new byte[20];  
72.                 bis.read(buffer);  
73.                 System.out.println(new String(buffer));  
74.   
75.                 bos.write("Server Echo".getBytes());  
76.                 bos.flush();  
77.   
78.                 s.close();  
79.             } catch (Exception e) {  
80.                 System.out.println(e);  
81.             }  
82.         }  
83.     }  
84.   
85.     /** 
86.      * <ul> 
87.      * <li>ssl连接的重点:</li> 
88.      * <li>初始化SSLServerSocket</li> 
89.      * <li>导入服务端私钥KeyStore，导入服务端受信任的KeyStore(客户端的证书)</li> 
90.      * </ul> 
91.      */  
92.     public void init() {  
93.         try {  
94.             SSLContext ctx = SSLContext.getInstance("SSL");  
95.   
96.             KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");  
97.             TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");  
98.   
99.             KeyStore ks = KeyStore.getInstance("JKS");  
100.             KeyStore tks = KeyStore.getInstance("JKS");  
101.   
102.             ks.load(new FileInputStream("E://kserver.keystore"), SERVER_KEY_STORE_PASSWORD.toCharArray());  
103.             tks.load(new FileInputStream("E://tserver.keystore"), SERVER_TRUST_KEY_STORE_PASSWORD.toCharArray());  
104.   
105.             kmf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());  
106.             tmf.init(tks);  
107.   
108.             ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);  
109.   
110.             serverSocket = (SSLServerSocket) ctx.getServerSocketFactory().createServerSocket(DEFAULT_PORT);  
111.             serverSocket.setNeedClientAuth(true);   
112.         } catch (Exception e) {  
113.             e.printStackTrace();  
114.         }  
115.     }  
116. }  

 

 

http://blog.csdn.net/binyao02123202/article/details/7702989