Java SSL 服务器 客户端通信 试用

简述：

SSL（百度百科）

Secure Socket Layer 安全套接层， 是为网络通信提供安全以及数据完整性的一种安全协议，在传输层对网络连接进行加密

SSL协议分为两层：

1）SSL记录协议，它建立在可靠的传输协议（如TCP）之上，为高层协议提供数据封装、压缩、加密等基本功能的支持。

2）SSL握手协议，它建立在SSL记录协议之上，用于在实际的数据传输开始前，通讯双方进行身份验证、协商加密算法、交换加密密钥

SSL的核心是 公开密钥加密，这是种非对称密钥加密，其实直接地说就client和server各自生成一对加密密钥和解密密钥，各自吧加密密钥发给对方，这个是公开的私钥，解密方法保留在本地，加密方法传到对方那里

步骤：

1.生成server端密钥

[html]  view plain copy

1. keytool -genkey -alias serverkey -keystore key OfServer.keystore  

之后会出现如下信息，

根据私钥导出服务端证书

[plain]  view plain copy

1. keytool -export -alias serverkey -keystore keyOfServer.keystore -file server.crt  

将服务端证书，加入客户端的认证证书列表中

[plain]  view plain copy

1. keytool -import -alias serverkey -file server.crt -keystore trustOfClient.keystore  

2：生成client端密钥

[plain]  view plain copy

1. keytool -genkey -alias clientkey -keystore keyOfClient.keystore  

根据私钥导出客户端证书

[plain]  view plain copy

1. keytool -export -alias clientkey -keystore keyOfClient.keystore -file client.crt  

将证书加到服务端信任列表

[plain]  view plain copy

1. keytool -import -alias serverkey -file client.crt -keystore trustOfServer.keystore  

至此，客户端和服务器端的证书都已经生成了

3. 之后进入代码部分

把上面四个keystore文件移入项目路径

代码：

SSLServer.java

[java]  view plain copy

1. package testSSL;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.ByteArrayOutputStream;  
6. import java.io.FileInputStream;  
7. import java.io.FileNotFoundException;  
8. import java.io.IOException;  
9. import java.io.InputStream;  
10. import java.io.OutputStream;  
11. import java.net.Socket;  
12. import java.security.KeyManagementException;  
13. import java.security.KeyStore;  
14. import java.security.KeyStoreException;  
15. import java.security.NoSuchAlgorithmException;  
16. import java.security.UnrecoverableKeyException;  
17. import java.security.cert.CertificateException;  
18.   
19. import javax.net.ssl.KeyManagerFactory;  
20. import javax.net.ssl.SSLContext;  
21. import javax.net.ssl.SSLServerSocket;  
22. import javax.net.ssl.TrustManagerFactory;  
23.   
24. public class SSLServer extends Thread{  
25.     private static final int SERVER_PORT = 12120;   
26.     private static final String SERVER_KEYSTORE_PWD = "123456";   
27.     private static final String SERVER_TRUST_KEYSTORE_PWD = "654321";   
28.   
29.     private SSLServerSocket serverSocket;  
30.       
31.     public SSLServer() {  
32.         // Initialize SSLServer  
33.         try {  
34.             //Load KeyStore And TrustKeyStore  
35.             KeyStore keyStore = KeyStore.getInstance("JKS");  
36.             KeyStore trustKeyStore = KeyStore.getInstance("JKS");  
37.             try {  
38.                 keyStore.load(new FileInputStream(  
39.                         "./src/testSSL/keyOfServer.keystore"),   
40.                         SERVER_KEYSTORE_PWD.toCharArray());  
41.                 trustKeyStore.load(new FileInputStream(  
42.                         "./src/testSSL/trustOfServer.keystore"),   
43.                         SERVER_TRUST_KEYSTORE_PWD.toCharArray());  
44.             } catch (CertificateException e) {  
45.                 e.printStackTrace();  
46.             } catch (FileNotFoundException e) {  
47.                 e.printStackTrace();  
48.             } catch (IOException e) {  
49.                 e.printStackTrace();  
50.             }  
51.               
52.             //Initialize KeyStore Factory  
53.             KeyManagerFactory keyManagerFactory =   
54.                 KeyManagerFactory.getInstance("SunX509");  
55.             TrustManagerFactory trustManagerFactory =   
56.                 TrustManagerFactory.getInstance("SunX509");  
57.             try {  
58.                 keyManagerFactory.init(keyStore, SERVER_KEYSTORE_PWD.toCharArray());  
59.             } catch (UnrecoverableKeyException e) {  
60.                 e.printStackTrace();  
61.             }  
62.             trustManagerFactory.init(trustKeyStore);  
63.               
64.             //Initialize SSLContext  
65.             SSLContext context = SSLContext.getInstance("SSL");  
66.             try {  
67.                 context.init(keyManagerFactory.getKeyManagers(),   
68.                         trustManagerFactory.getTrustManagers(), null);  
69.             } catch (KeyManagementException e) {  
70.                 e.printStackTrace();  
71.             }  
72.               
73.             //Set up Server Socket  
74.             try {  
75.                 serverSocket = (SSLServerSocket) context.  
76.                     getServerSocketFactory().createServerSocket(SERVER_PORT);  
77.             } catch (IOException e) {  
78.                 e.printStackTrace();  
79.             }  
80.             serverSocket.setNeedClientAuth(true);  
81.         } catch (NoSuchAlgorithmException e) {  
82.             e.printStackTrace();  
83.         } catch (KeyStoreException e) {  
84.             e.printStackTrace();  
85.         }  
86.     }  
87.       
88.       
89.     @Override  
90.     public void run() {  
91.         if(serverSocket == null){  
92.             System.out.println("Null server socket");  
93.             return;  
94.         }  
95.         while(true){  
96.             try {  
97.                 Socket socket = serverSocket.accept();  
98.                 //Response To Client  
99.                 OutputStream output = socket.getOutputStream();  
100.                 BufferedOutputStream bufferedOutput = new BufferedOutputStream(output);  
101.                 bufferedOutput.write("Server Response: Hello".getBytes());  
102.                 bufferedOutput.flush();  
103.                   
104.                 //Receive From Client  
105.                 InputStream input = socket.getInputStream();  
106.                 System.out.println("------Receive------");  
107.                 //use byte array to initialize the output string  
108.                 System.out.println(new String(StreamToByteArray(input)));   
109.   
110.             } catch (IOException e) {  
111.                 e.printStackTrace();  
112.             }  
113.         }  
114.     }  
115.       
116.       
117.     /** 
118.      * convert stream to Byte Array 
119.      * @param inputStream 
120.      * @return 
121.      * @throws IOException 
122.      */  
123.     public byte[] StreamToByteArray(InputStream inputStream) throws IOException {  
124.         ByteArrayOutputStream bout = new ByteArrayOutputStream();  
125.         byte[] buffer = new byte[1024];  
126.         int readIndex = inputStream.read(buffer);  
127.         bout.write(buffer, 0, readIndex);  
128.         bout.flush();  
129.         bout.close();  
130.         inputStream.close();  
131.         return bout.toByteArray();  
132.     }  
133.       
134.       
135.     public static void main(String[] args){  
136.         System.out.println("=======Start Server !======");  
137.         new SSLServer().start();  
138.     }  
139. }  

SSLClient.java

[java]  view plain copy

1. package testSSL;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.ByteArrayOutputStream;  
6. import java.io.FileInputStream;  
7. import java.io.FileNotFoundException;  
8. import java.io.IOException;  
9. import java.io.InputStream;  
10. import java.io.OutputStream;  
11. import java.security.KeyManagementException;  
12. import java.security.KeyStore;  
13. import java.security.KeyStoreException;  
14. import java.security.NoSuchAlgorithmException;  
15. import java.security.UnrecoverableKeyException;  
16. import java.security.cert.CertificateException;  
17.   
18. import javax.net.ssl.KeyManagerFactory;  
19. import javax.net.ssl.SSLContext;  
20. import javax.net.ssl.SSLSocket;  
21. import javax.net.ssl.TrustManagerFactory;  
22.   
23. public class SSLClient {  
24.     private static final String SERVER_HOST = "127.0.0.1";  
25.     private static final int SERVER_PORT = 12120;   
26.     private static final String CLIENT_KEYSTORE_PWD = "654321";   
27.     private static final String CLIENT_TRUST_KEYSTORE_PWD = "654321";   
28.     SSLSocket clientSocket;  
29.       
30.     public SSLClient(){  
31.         // Initialize SSLClient  
32.         try {  
33.             //Load KeyStore And TrustKeyStore  
34.             KeyStore keyStore = KeyStore.getInstance("JKS");  
35.             KeyStore trustKeyStore = KeyStore.getInstance("JKS");  
36.             try {  
37.                 keyStore.load(new FileInputStream(  
38.                         "./src/testSSL/keyOfClient.keystore"),   
39.                         CLIENT_KEYSTORE_PWD.toCharArray());  
40.                 trustKeyStore.load(new FileInputStream(  
41.                         "./src/testSSL/trustOfClient.keystore"),   
42.                         CLIENT_TRUST_KEYSTORE_PWD.toCharArray());  
43.             } catch (CertificateException e) {  
44.                 e.printStackTrace();  
45.             } catch (FileNotFoundException e) {  
46.                 e.printStackTrace();  
47.             } catch (IOException e) {  
48.                 e.printStackTrace();  
49.             }  
50.               
51.             //Initialize KeyStore Factory  
52.             KeyManagerFactory keyManagerFactory =   
53.                 KeyManagerFactory.getInstance("SunX509");  
54.             TrustManagerFactory trustManagerFactory =   
55.                 TrustManagerFactory.getInstance("SunX509");  
56.             try {  
57.                 keyManagerFactory.init(keyStore, CLIENT_KEYSTORE_PWD.toCharArray());  
58.             } catch (UnrecoverableKeyException e) {  
59.                 e.printStackTrace();  
60.             }  
61.             trustManagerFactory.init(trustKeyStore);  
62.               
63.             //Initialize SSLContext  
64.             SSLContext context = SSLContext.getInstance("SSL");  
65.             try {  
66.                 context.init(keyManagerFactory.getKeyManagers(),   
67.                         trustManagerFactory.getTrustManagers(), null);  
68.             } catch (KeyManagementException e) {  
69.                 e.printStackTrace();  
70.             }  
71.               
72.             //Set up Client Socket  
73.             try {  
74.                 clientSocket = (SSLSocket) context.  
75.                     getSocketFactory().createSocket(SERVER_HOST, SERVER_PORT);  
76.             } catch (IOException e) {  
77.                 e.printStackTrace();  
78.             }  
79.         } catch (NoSuchAlgorithmException e) {  
80.             e.printStackTrace();  
81.         } catch (KeyStoreException e) {  
82.             e.printStackTrace();  
83.         }  
84.     }  
85.       
86.   
87.     private void Test() {  
88.         if(clientSocket == null){  
89.             System.out.println("NULL clientSocket");  
90.             return;  
91.         }  
92.           
93.         // Run Client Test  
94.         InputStream input = null;  
95.         OutputStream output = null;  
96.         try {  
97.             input = clientSocket.getInputStream();  
98.             output = clientSocket.getOutputStream();  
99.         } catch (IOException e) {  
100.             e.printStackTrace();  
101.         }   
102.           
103.         //Output Message To Server  
104.         BufferedOutputStream bufferedOutput = new BufferedOutputStream(output);  
105.         try {  
106.             //output to Server  
107.             bufferedOutput.write("Client Test Running".getBytes());  
108.             bufferedOutput.flush();  
109.         } catch (IOException e) {  
110.             e.printStackTrace();  
111.         }  
112.           
113.         //Output To Client Console  
114.         try {  
115.             System.out.println(new String(StreamToByteArray(input)));  
116.         } catch (IOException e) {  
117.             e.printStackTrace();  
118.         }  
119.           
120.         try {  
121.             Thread.sleep(3000);  
122.         } catch (InterruptedException e1) {  
123.             e1.printStackTrace();  
124.         }  
125.           
126. //      //close client socket  
127. //      try {  
128. //          clientSocket.close();  
129. //      } catch (IOException e) {  
130. //          e.printStackTrace();  
131. //      }  
132.     }  
133.       
134.       
135.     /** 
136.      * convert stream to Byte Array 
137.      * @param inputStream 
138.      * @return 
139.      * @throws IOException 
140.      */  
141.     public byte[] StreamToByteArray(InputStream inputStream) throws IOException {  
142.         ByteArrayOutputStream bout = new ByteArrayOutputStream();  
143.         byte[] buffer = new byte[1024];  
144.         int readIndex = inputStream.read(buffer);  
145.         bout.write(buffer, 0, readIndex);  
146.         bout.flush();  
147.         bout.close();  
148.         inputStream.close();  
149.         return bout.toByteArray();  
150.     }  
151.       
152.       
153.     public static void main(String[] args) {  
154.         new SSLClient().Test();  
155.     }  
156. }  

输出：

server端

client端

项目下载地址：

http://download.csdn.net/detail/anialy/5051274