SSL 簡介
SSL（Secure Socket Layer，安全套接字層）是一種保證網絡上的兩個節點進行安全通信的協議。IETF（Interet Engineering Task Force）國際組織對 SSL 作了標準化，制定了 RFC2246 規範，並將其稱爲傳輸層安全（Transport Layer Security，TLS）
SSL 和 TLS 都建立在 TCP/IP 的基礎上，一些應用層協議，如 HTTP 和 IMAP，都可以採用 SSL 來保證安全通信。建立在 SSL 協議上的 HTTP 被稱爲 HTTPS 協議。HTTP 使用的默認端口爲 80，而 HTTPS 使用的默認端口爲 443
SSL 採用加密技術來實現安全通信，保證通信數據的保密性和完整性，並且保證通信雙方可以驗證對方的身份
1. 加密通信
當客戶與服務器進行通信時，通信數據有可能被網絡上的其他計算機非法監聽，SSL 使用加密技術實現會話雙方信息的安全傳遞。加密技術的基本原理是，數據從一端發送到另一端時，發送者先對數據加密，然後把它發送給接收者。這樣，在網絡上傳輸的是經過加密的數據。如果有人在網絡上非法截獲了這批數據，由於沒有解密的密鑰，數無法獲取真正的原始數據。接收者接收到加密的數據後，先對數據解密，然後處理
2. 安全證書
除了對數據加密通信，SSL 還採用了身份認證機制，確保通信雙方都可以驗證對方的真實身份。這和生活中我們使用身份證來證明自己的身份很相似，比如你到銀行去取錢，你自稱自己是張三，如何讓對方相信你的身份呢？最有效的辦法就是出示身份證。每人都擁有唯一的身份證，這個身份證上記錄了你的真實信息。身份證由國家權威機構頒發，不允許僞造。在身份證不能被別人假冒複製的前提下，只要你出示身份證，就可以證明你自己的身份
個人可以通過身份證來證明自己的身份，對於一個單位，比如商場，可以通過營業執照來證明身份。營業執照也由國家權威機構頒發，不允許僞造，它保證了營業執照的可信性
SSL 通過安全證書來證明客戶或服務器的身份，當客戶通過安全的連接和服務器通信時，服務器會先向客戶出示它的安全證書，這個證書聲明該服務器是安全的，而且的確是這個服務器，每一個證書在全世界範圍內都是唯一的，其他非法服務器無法假冒，可以把安全證書比作電子身份證
對於單個客戶來說，到公認的權威機構去獲取安全證書是雲件麻煩的事。爲了擴大客戶羣並且便於客戶的訪問，許多服務器不要求客戶出示安全證書。在某些情況下，服務器也會要求客戶出示安全證書，以便覈實該客戶的身份，這主要是在 B2B 事務中
獲取安全證書有兩種方式，一種方式是從權威機構獲得證書，還有一種方式是創建自我簽名證書
2.1 從權威機構獲取證書
安全證書由國際權威的證書機構頒發，它們保證了證書的可信性。申請安全證書時，必須支付一定的費用。一個安全證書只對一個 IP 地址有效，如果用戶的系統環境中有多個 IP 地址須爲每個 IP 地址都購買安全證書
2.2 創建自我簽名證書
在某些場合，通信雙方只關心數據在網絡上可以被安全傳輸，並不需要對方進行身份驗證，在這種情況下，可以創建自我簽名的證書。就像用戶自己製作的名片，缺乏權威性，達不到身份認證的目的。當你向對方遞交名片時，名片上聲稱你是某個大公司的老總，信不信只能由對方自己去判斷
既然自我簽名證書不能有效地證明自己的身份，那麼有何意義呢？在技術上，無論是從權威機構獲得的證書，還是自己製作的證書，採用的加密技術都是一樣的，使用這些證書，都可以實現安全地加密通信
3. SSL 握手
安全證書既包含了用於加密數據的密鑰，又包含了用於證實身份的數字簽名。安全證書採用公鑰加密技術，公鑰加密指使用一對非對稱的密鑰進行加密或解密。每一對密鑰由公鑰和私鑰組成，公鑰被廣泛發佈，私鑰是隱藏的，不公開。用公鑰加密的數據只能夠私鑰解密，反過來，使用私鑰加密的數據只能被公鑰解密
客戶與服務器通信時，首先要進行 SSL 握手，SSL 握手主要完成以下任務：
- 協商使用的加密套件，加密套件中包括一組加密參數，這些參數指定了加密算法和密鑰的長度等信息
- 驗證對方的身份，此操作是可選的
- 確定使用的加密算法
SSL 握手過程採用非對稱加密方法傳遞數據，由此來建立一個安全的會話。SSL 握手完成後，通信雙方將採用對稱加密方法傳遞實際的應用數據。所謂對稱加密，指通信雙方使用同樣的密鑰來加密數據
SSL 握手的具體流程如下：
- 客戶將自己的 SSL 版本號、加密參數、與會話有關的數據以及其他一些必要信息發送到服務器
- 服務器將自己的 SSL 版本號、加密參數、與會話有關的數據以及其他一些必要信息發送給客戶，同時發送給客戶的還有服務器的證書。如果服務器需要驗證客戶身份，那麼服務器還會發出要求客戶提供安全證書的請求
- 客戶端驗證服務器證書，如果驗證失敗，就提示不能建立 SSL 連接。如果成功，就繼續下一步驟
- 客戶端爲本次會話生成預備主密碼（pre-master secret），並將其用服務器安全證書附帶的公鑰加密後發送給服務器
- 如果服務器要求驗證客戶身份，那麼客戶端還要再對另外一些數據簽名後，將其與客戶端證書一起發送給服務器
- 如果服務器要求驗證客戶身份，則檢查簽署客戶證書的 CA 是否可信。如果不在信任列表中，則結束本次會話。如果檢查通過，那麼服務器用自己的私鑰解密收到的預備主密碼，並用它通過某些算法生成本次會話的主密碼（master secret）
- 客戶端與服務器均使用此主密碼生成本次會話的會話密鑰（對稱密鑰）。在雙方 SSL 握手結束後傳遞任何消息均使用此會話密鑰。這樣做的主要原因是對稱加密比非對稱加密的運算量低一個數量級以上，能夠顯著提高雙方會話時的運算速度
- 客戶端通知服務器此後發送的消息都使用這個會話密鑰進行加密，並通知服務器客戶端已經完成本次 SSL 握手
- 服務器通知客戶端此後發的消息都使用這個會話密鑰進行加密，並通如服務器已經完成本次 SSL 握手
- 本次握手過程結束，會話已經建立。在接下來的會話過程中，雙方使用同一個會話密鑰分別對發送以及接收的信息進行加密和解密
4. 創建自我簽名的安全證書
JDK 提供了製作證書的工具 keytool，它的位置爲：<JDK根目錄>\bin\keytool.exe
keytool 工具提出了密鑰庫的概念，密鑰庫中可以包含多個條目，每個條目包括一個自我簽名的安全證書以及一對非對稱密鑰
通過 keytool 工具創建密鑰庫的命令爲：
keytool -genkeypair -alias weiqin -keyalg RSA -keystore C:\chapter15\test.keystore
- genkeypair：生成一對非對稱密鑰
- alias：指定條目以及密鑰對的別名，該別名是公開的
- keyalg：指定加密算法，本例中採用通用的 RSA 算法
- keystore：設定密鑰庫文件的存放路徑以及文件名字
命令的運行過程首先會提示輸入密鑰庫的密碼，然後提示輸入個人信息，如姓名、組織單位和所在城市等，只要輸入真實信息即可
以下命令查看 test.keystore 密庫的信息，會列出所包含的條目的信息
keytool -list -v -keystore C:\chapter15\test.keystore -storepass "123456”
以下命令把 test.keystore 密鑰庫中別名爲 weiqin 的條目導出到一個安全證書，文件名爲 weiqin.crt。weiqin.crt 文中包含了自我簽名的安全證書，以及密鑰對中的公鑰，但不包含密鑰對中的私鑰
keytool -export -alias weigin -keystore C:\chapter15\test.keystore
-file C:\chapter15\weigin.crt -storepass “123456”
以下命令刪除 test.keystore 密鑰庫中的別名爲 weiqin 的條目
keytool -delete -alias weigin -keystore C:\chapter15\test.keystore -storepass “123456”
以下命令把 weiqin.crt 安全證書導入 testTrust.keystore 密庫中生成別名爲 weiqin 的條目，這個條目中包含密鑰對中的公鑰，但不包含密鑰對中的私鑰
keytool -import -alias weiqin
-keystore C:\chapter15\testTrust.keystore
-file C:\chapter15\weiqin.crt
-storepass "123456"
JSSE 簡介
JSSE 封裝了底層複雜的安全通信細節，使得開發人員能方便地用它來開發安全的網絡應用程序
1. KeyStore、KeyManager 與 TrustManager 類
在進行安全通信時，要求客戶端與服務器端都支持 SSL 或 TCL 協議。客戶端與服務器端可能都需要設置用於證實自身身份的安全證書，還要設置信任對方的哪些安全證書。更常見的情況是，服務器端只需要設置用於證實自身身份的安全證書，而客戶端只需要設置信任服務器的哪些安全證書
KeyStore 類用於存放包含安全證書的密鑰庫，以下程序代碼創建了一個 KeyStore 對象，它從 test.keystore 密鑰庫文件中加載安全證書
String passphrase = "123456";
//JKS是JDK 支持的KeyStore的類型
KeyStore keyStore = KeyStore.getInstance("JKS");
char[] password = passphrase.toCharArray();
//password參數用於打開密鑰庫
keyStore.load(new FileInputStream("test.keystore"), password);
KeyManager 接口的任務是選擇用於證實自身身份的安全證書，把它發送給對方。KeyManagerFactory 負責創建 KeyManager 對象，例如
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
keyManagerFactory.init(keyStore, password);
KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
TrustManager 接口的任務是，決定是否信任對方的安全證書。TruesManagerFactory 負責創建 TrustManager 對象，例如
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX509");
trustManagerFactory.init (keyStore);
TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
2. SSLContext 類
SSLContext 類負責設置與安全通信有關的各種信息，比如使用的協議（SSL 或者 TLS），自身的安全證書以及對方的安全證書。SSLContext 還負責構造 SSLServerSocketFactory、SSLSocketFactory 和 SSLEngine 對象
以下程序代碼創建並初始化了一個 SSLContext 對象，然後由它創建了一個 SSLServerSocketFactory 對象
SSLContext sslCtx = SSLContext.getInstance("TLS");//採用TLS協議
sslCtx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
SSLServerSocketFactory ssf = sslCtx.getServerSocketFactory();
SSLContext 的 init 方法的定義如下
public final void init(KeyManager[] km, TrustManager[] tm, SecureRandom random) throws KeyManagementException
- 參數 random 用於設置安全隨機數，如果該參數爲 null，init 方法就會採用默認的 SecureRandom 實現
- 如果參數 km 爲 null，那 init 方法會創建默認的 KeyManager 對象以及與之關聯的 KeyStore 對象，KeyStore 對象從系統屬性 javax.net.ssl.keyStore 取安全證書。如果不存在這樣的系統屬性，那麼KeyStore 對象內容爲空
- 如果參數 tm 爲 null，那麼 init 方法會創建一個默認的 TrustManager 對象以及與之關聯的 KeyStore 對象，KeyStore 對象按照如下步驟獲取安全證書：
- 先嚐試從系統屬性 javax.net.ssl.trustStore 獲取安全證書
- 如果上一步失敗，就把 <JDK 根目錄>/lib/security/jssecacerts 文件作爲安全證書
- 如果上一步失敗，就把 <JDK 根目錄>/lib/security/cacerts 文件作爲安全證書
- 如果上一步失敗，那麼 KeyStore 對象的內容爲空
3. SSLServerSocketFactory類
SSLServerSocketFactory 類負責創建 SSLServerSocket 對象
SSLServerSocket serverSocket = (SSLServerSocket) sslServerSocketFactory.createServerSocket(8000); // 監聽端口8000
SSLServerSocketFactory 對象有兩種創建方法：
- 調用 SSLContext 類的 getServerSocketFactory 方法
- 調用 SSLServerSocketFactory 類的靜態 getDefault 方法
SSLServerSocketFactory 類的靜態 getDefault 方法返回一個默認的 SSLServerSocketFactory 對象，它與一個默認的 SSLContext 對象關聯，getDefault 方法的實現按照如下方式初始化這個默認的 SSLContext 對象
sslContext.init(null,null,null);
4. SSLSocketFactory 類
SSLSocketFactory 類負責創建 SSLSocket 對象
SSLSocket socket = (SSLSocket) sslSocketFactory.createSocket("localhost",8000);
SSLSocketFactory 對象有兩種創建方法
- 調用 SSLContext 類的 getSocketFactory 方法
- 調用 SSLSocketFactory 類的靜態 getDefault 方法
SSLSocketFactory 類的靜態 getDefault 方法返回一個默認的 SSLSocketFactory 對象，它與一個默認的 SSLContext 對象關聯，getDefault 方法的實現按照如下方式初始化這個默認的 SSLContext 對象
sslContext.init(null,null,null);
5. SSLSocket類
SSLSocket 類是 Socket 類的子類，因此兩者的用法有許多相似之處。此外，SSLSocket 類還具有與安全通信有關的方法
5.1 設置加密套件
客戶與服務器在握手階段需要協商實際使用的加密套件，以下兩種情況都會導致握手失敗：
- 不存在雙方都可以使用的相同加密套件
- 儘管存在這樣的加套件，但是有一方或雙方沒有使用該加密套件的安全證書
SSLSocket 類的 getSupportedCipherSuites 方法返回一個字符串數組，它包含當 SSLSocket 對象所支持的加索套件組。SSLSocket 類的 setEnabledCipherSuites(String[] suites) 方法設置當前 SSLSocket 對象的可使用的加密套件組，可使用的加密件組應該是所支持的加密套件組的子集
以下代碼僅僅啓用了具有高加密強度的加密套件，這可以提高該通信端的安全性，禁止那些不支持強加密的通信端連接當前通信端
String[] strongSuites = {
"SSL_RSA_WITH_RC4_128_MD5",
"SSL_RSA_WITH_RC4_128_SHA",
"SSL_RSA_WITH_3DES_EDE_CBC_SHA"
};
sslSocket.setEnabledCipherSuites(strongSuites);
5.2 處理握手結束事件
SSL 握手需要花很長的時間，當 SSL 握手完成，會發出一個 HandshakeCompletedEvent 事件，該事件由 HandshakeCompletedListener 負責監聽。SSLSocket 類的 addHandshakeCompletedListener 方法負責註冊 HandshakeCompletedListener 監聽器
下例爲 SSLSocket 註冊了 HandshakeCompletedListener
socket.addHandshakeCompletedListener {
new HandshakeCompletedListener() {
public void handshakeCompleted(HandshakeCompletedEvent event) {
System.out.println("握手結束");
System.out.println("加密套件爲:" + event.getCipherSuite());
System.out.println("會話爲:" + event.getSession());
System.out.println("通信對方爲:" + event.getSession().getPeerHost());
}
});
}
5.3 管理 SSL 會話
一個客戶程序可能會向一個服務器的同一個端口打開多個安全套接字。如果對於每一安全連接都進行 SSL 握手，就會大大降低通信效率。爲了提高安全通信的效率，SSL 協議允許多個 SSLSocket 共享同一個 SSL 會話。在同一個會話中，只有第一個打開的 SSLSocket 要進行 SSL 握手，負責生成密鑰以及交換密鑰，其餘的 SSLSocket 都共享密鑰信息。在一段合理的時間範圍內，如果客戶程序向一個服務器的同一個端口打開多個安全套接字，JSSE 就會自動重用會話
SSLSocket 的 getSession 方法返回 SSLSocket 所屬的會話。SSLSocket 的 setEnableSessionCreation(boolean flag) 方法決定 SSLSocket 是否允許創建新的會話。flag 的默認值爲 true。如果 flag 參數爲 true，那麼對於新創建的 SSLSocket，如果當前已經有可用的會話，就直接加入該會話，如果沒有可用的會話，就創建一個新的會話。如果 flag 爲 false 參數，那麼對於新創建的 SSLSocket，如果當前已經有可用的會話，就直接加入該會話，如果沒有可用的會話，那麼該 SSLSocket 無法與對方進行安全通信
SSLSocket的 startHandshake 方法顯式地執行一次 SSL 握手，該方法具有以下用途：
- 使得會話使用新的密鑰
- 使得會話使用新的加密套件
- 重新開始一個會話。爲了保證不重用原先的會話，應該先將原先的會話失效、、
socket.getSession().invalidate();
socket.startHandshake();
5.4 客戶端模式
多數情況下客戶端無須向服務器證實自己的身份，因此當一個通信端無須向對方證實自己身份時，就稱它處於客戶模式，否則稱它處於服務器模式。通信雙方只能有一方處於服務器模式，另一方則處於客戶模式
SSLSocket 的 setUseClientMode(boolean mode) 方法被用來設置客戶模式或者服務器模式。如果 mode 參數爲 true，就表示處於客戶模式，即無須向對方證實自己的身份；如果 mode 爲 false，就表示處於服務器模式，即需要向對方證實自己的身價
當 SSL 初始握手已經開始，就不允許再調用 SSLSocket 的 seUseClientMode(boolean mode) 方法，否則會導致異常
當 SSLSocket 處於服務器模式，還可以通過以下方法來決定是否要求對方提供身份認證：
- setWantClientAuth(boolean want):：當 want 參數爲 true 時，表示希望對方提供身份認證。如果對方未出示安全證書，則連接不會中斷，通信可繼續進行
setNeedClientAuth(boolean need)：當 need 參數爲 true 時，表示要求對方必須提供身份認證。如果對方未出示安全證書，則連接中斷，通信無法繼續
6. SSLServerSocket類
SSLServerSocket 類是 ServerSocket 類的子類，因此兩者的用法有許多相似之處。此外，SSLServerSocket 類還具有與安全通信有關的方法，這些方法與 SSLSocket 類中的同名方法具有相同的作用
7. SSLEngine 類
SSLEngine 類與 SocketChannel 類聯合使用，就能實現非阻塞的安全通信。SSLEngine 類封裝了與安全通信有關的細節，把應用程序發送的應用數據打包爲網絡數據，打包指對應用數據進行加密，加入 SSL 握手數據，把它變爲網絡數據。SSLEngine 類還能把接收的網絡數據展開爲應用數據，展開指對網絡數據解密，並且去除其中的 SSL 握手數據，從而還原爲應用程序可以處理的應用數據。SSLEngine 類的 wrap 方法負責打包應用數據，unwrap 方法負責展開網絡數據
public class SSLEngineDemo {
private static boolean logging = true;
private SSLContext sslc;
private SSLEngine clientEngine; //客戶端Engine
private ByteBuffer clientOut; //存放客戶端發送的應用數據
private ByteBuffer clientIn; //存放客戶端接收到的應用數據
private SSLEngine serverEngine; //服務器端Engine
private ByteBuffer serverOut; //存放服務器端發送的應用數據
private ByteBuffer serverIn; //存放服務器端接收到的應用數據
private ByteBuffer cTOs;//存放客戶端向服務器端發送的網絡數據
private ByteBuffer sTOc;//存放服務器向客戶海發送的網絡數據
//設置密鑰庫文件和信任庫文件以及口令
private static String keyStoreFile = "test.keystore";
private static String trustStorefile = "test.keystore";
private static String passphrase = "123456";
public static void main(String args[]) throws Exception {
SSLEngineDemo demo = new SSLEngineDemo();
demo.runDemo();
}
/**初始化SSLContext*/
public SSLEngineDemo() throws Exception {
KeyStore ks = KeyStore.getInstance("JKS");
KeyStore ts = KeyStore.getInstance("JKS");
char[] password = passphrase.toCharArray();
ks.load(new FileInputStream(keyStoreFile), password);
ts.load(new FileInputStream(trustStoreFile), password);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, password);
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ts);
SSLContext sslCtx = SSLContext.getInstance("TLS");
sslCtx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
sslc = sslCtx;
}
private void runDemo() throws Exception {
boolean dataDone = false;
/*創建客戶端以及服務器端的SSLEngine*/
serverEngine = sslc.createSSLEnqine();
serverEngine.setUseClientMode(false);
serverEngine.setNeedClientAuth(true);
clientEngine = sslc.createSSLEngine("client", 80);
clientEngine.setUseClientMode(true);
/*創建客戶端以及服務器的應用衝區和網絡緩衝區*/
SSLSession session = clientEngine.getsSession();
int appBufferMax = session.getApplicationBufferSize();
int netBufferMax = session.getPacketBufferSize();
clientIn = ByteBuffer.allocate(appBufferMax + 50);
serverIn = ByteBuffer.allocate(appBufferMax + 50)
cTOs = ByteBuffer.allocateDirect(netBufferMax);
sTOc = ByteBuffer.allocateDirect(netBufferMax);
clientOut = ByteBuffer.wrap("Hi Server, I'm Client".getBytes());
serverOut = ByteBuffer.wrap("Hello Client, I'm Server".getBytes());
SSLEngineResult clientResult;
SSLEngineResult serverResult;
while (!isEnqineClosed(clientEngine) || !isEngineClosed(serverEngine)) {
log("==================");
//客戶端打包應用數據
clientResult = clientEngine.wrap(clientOut, cTOs);
log("client wrap:", clientResult);
//完成握手任務
runDelegatedTasks(clientResult, clientEngine);
//服務器端打包應用數據
serverResult = serverEngine.wrap(serverOut, sTOc);
log("server wrap:", serverResult);
//完成握手任務
runDelegatedTasks(serverResult, serverEngine);
cTOs.flip();
sTOc.flip();
log("---------------");
//客戶端展開網絡數據
clientResult = clientEngine.unwrap(sTOc, clientIn);
log("client unwrap:", clientResult);
//完成握手任務
runDelegatedTasks(clientResult, clientEngine);
//服務器端展開網絡數據
serverResult = serverEngine.unwrap(cTOs, serverIn);
log("server unwrap:", serverResult);
//完成握手任務
runDeleqatedTasks(serverResult, serverEngine);
cTOs.compact();
sTOc.compact();
if (!dataDone && (clientOut.limit() == serverIn.position()) && (serverOut,limit()=m clientIn.position())) {
checkTransfer(serverOut, clientIn);
checkTransfer(clientOut, serverIn);
log("\tClosing clientEngine's *OUTBOUND*...");
clientEngine.closeOutbound();
dataDone = true;
}
}
}
/**當SSLEngine的輸出與輸入都關閉時，意味着SSLEngine被關閉*/
private static boolean isEngineClosed(SSLEngine engine) {
return(engine.isOutboundDone() && engine.isInboundDone());
}
/**執行SSL握手任務*/
private static void runDelegatedTasks(SSLEngineResult result, SSLEngine engine) throws Exception {
if(result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
Runnable runnable;
while((runnable = engine.getDelegatedTask()) != null) {
log("\trunning delegated task...");
runnable.run();
}
HandshakeStatus hsStatus = engine.getHandshakeStatus();
if(hsStatus == HandshakeStatus.NEED_TASK) {
throw new Exception("handshake shouldn't need additional tasks");
}
log("\tnew HandshakeStatus:" + hsStatus);
}
}
/**判斷兩個緩衝區內容是否相同*/
private static void checkTransfer(ByteBuffer a, ByteBuffer b) throws Exception {
a.flip();
b.flip();
if(!a.equals(b)) {
throw new Exception("pata didn't transfer cleanly");
} else {
log("\tData transferred cleanly");
}
a.position(a.limit());
b.position(b.limit());
a.limit(a.capacity());
b.limit(b.capacity());
}
private static boolean resultOnce = true;
/**輸出日誌,打印SSLEngineResult的結果*/
private static void log(String str, SSLEngineResult result) {
if(resultOnce) {
resultOnce = false;
System.out.println("The format of the SSLEngineResult is: \n"
+"\t\"getStatus() / getHandshakeStatus()\”+\n"
+"\t\"bytesConsumed() / bytesProduced()\"\n");
}
HandshakeStatus hsStatus = result.getHandshakeStatus();
log(str + result,getStatus() + "/" + hsStatus + "," + result,bytesConsumed() + "/"
+ result.bytesProduced() + " bytes");
if (hsStatus == HandshakeStatus.FINISHED) {
log("\t...ready for application data");
}
}
/**輸出日誌*/
private static void log(String str) {
System.out.printin(str);
}
}
創建基於 SSL 的安全服務器和安全客戶
public class EchoServer {
private int port = 8000;
private SSLServerSocket serverSocket;
public EchoServer() throws Exception {
//輸出跟蹤日誌
SSLContext context = createSSLContext();
SSLServerSocketFactory factory = context.getServerSocketFactory();
serverSocket = (SSLServerSocket)factory.createServerSocket(poxt);
String[] supported = serverSocket.getSupportedCipherSuites();
serverSocket.setEnabledCipherSuites(supported);
}
public SSLContext createSSLContext() throws Exception {
//服務器用於證實自己身份的安全證書所在的密鑰庫
String keyStoreFile = "test.keystore";
String passphrase = "123456";
KeyStore ks = KeyStore.getInstance("JKS");
char[] password = passphrase.toCharArray();
ks.load(new FileInputStream(keyStoreFile), password);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, password);
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(kmf.getKeyManagers(), null, null);
//當要求客戶端提供安全證書時，服務器端可創建TrustManagerFactory,
//並由它創建TrustManager,TrustManger根據與之關聯的KeyStore中的信息
//決定是否相信客戶提供的安全證書
//客戶端用於證實自己身份的安全證書所在的密鑰庫
//String trustStorefile = "test.keystore";
//KeyStore ts = KeyStore.getInstance("JKS");
//ts.load(new FileInputStream(trustStoreFile), password);
//TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
//tmf.init(ts);
//sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
return sslContext;
}
private PrintWriter getWriter(Socket socket) throws IOException {
OutputStream socketOut = socket.getOutputStream();
return new PrintWriter(socketOut, true);
}
private BufferedReader getReader(Socket socket) throws IOException {
InputStream socketIn = socket.getInputstream();
return new BufferedReader(new InputStreamReader(socketIn));
}
public void service() {
while (true) {
Socket socket = null;
try {
//等特客戶連接
socket = serverSocket.accept();
BufferedReader br = getReader(socket);
PrintWriter pw = getWriter(socket);
String msg = null;
while ((msg = br.readLine()) != null) {
System.out.println(msg);
if (msg.equals("bye")) {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(socket != null) socket.close(); //斷開連接
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String args[]) throws Exception {
new EchoServer().service();
}
}
public class EchoClient {
private String host = "localhost";
private int port = 8000;
private SSLSocket socket;
public EchoClient() throws IOException {
SSLContext context = createSSLContext();
SSLSocketFactory factory = context.getSocketFactory();
socket = (SSLSocket)factory.createSocket(host,port);
Stringl] supported = socket.getSupportedCipherSuites();
socket.setEnabledCipherSuites(supported);
}
public SSLContext createSSLContext() throws Exception {
String passphrase = "123456";
char[] password = passphrase.toCharArray();
//設置客戶端所信任的安全證書所在的密鑰庫
String trustStoreFile = "test.keystore";
KeyStore ts = KeyStore.getInstance("JKS");
ts.load(new FileInputStream(trustStoreFile), password));
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ts);
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, tmf.getTrustManagers(), null);
return sslContext;
}
public static void main(String args[]) throws IOException {
new EchoClient().talk();
}
public void talk()throws IOException {
try {
BufferedReader br = getReader(socket);
PrintWriter pw = getWriter(socket);
BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
String msg = null;
while((msg = localReader.readLine()) != null) {
pw.println(msg);
System.out.println(br.readline());
if(msg.equals("bye")) {
break;
}
}
} catch(IOException e) {
e.printStackTrace();
} finally {
try {
if(socket != null) socket.close(); //斷開連接
} catch (IOException e) {
e.printStackTrace();
}
}
}
private PrintWriter getWriter(Socket socket) throws IOException {
OutputStream socketOut = socket.getoutputstream();
return new PrintWriter(socketOut, true);
}
private BufferedReader getReader(Socket socket) throws IOException {
InputStream socketIn = socket.getInputstream();
return new BufferedReader(new InputStreamReader(socketIn));
}
}