SSL 簡介
SSL（Secure Socket Layer，安全套接字層）是一種保證網絡上的兩個節(jié)點進行安全通信的協議。IETF（Interet Engineering Task Force）國際組織對 SSL 作了標準化，制定了 RFC2246 規(guī)范，并將其稱為傳輸層安全（Transport Layer Security，TLS）
SSL 和 TLS 都建立在 TCP/IP 的基礎上，一些應用層協議，如 HTTP 和 IMAP，都可以采用 SSL 來保證安全通信。建立在 SSL 協議上的 HTTP 被稱為 HTTPS 協議。HTTP 使用的默認端口為 80，而 HTTPS 使用的默認端口為 443
SSL 采用加密技術來實現安全通信，保證通信數據的保密性和完整性，并且保證通信雙方可以驗證對方的身份
1. 加密通信
當客戶與服務器進行通信時，通信數據有可能被網絡上的其他計算機非法監(jiān)聽，SSL 使用加密技術實現會話雙方信息的安全傳遞。加密技術的基本原理是，數據從一端發(fā)送到另一端時，發(fā)送者先對數據加密，然后把它發(fā)送給接收者。這樣，在網絡上傳輸的是經過加密的數據。如果有人在網絡上非法截獲了這批數據，由于沒有解密的密鑰，數無法獲取真正的原始數據。接收者接收到加密的數據后，先對數據解密，然后處理
對稱加密和非對稱加密是密碼學中兩種常見的加密方法
1.1 對稱加密
對稱加密是一種加密和解密使用相同密鑰的加密方法，在對稱加密中，發(fā)送方和接收方使用同一個密鑰來加密和解密數據。常見的對稱加密算法包括 AES、DES、3DES 等
對稱加密的優(yōu)點是加密和解密速度較快，適用于大量數據的加密和解密。缺點是密鑰的管理和分發(fā)比較困難，因為需要在通信雙方之間安全地共享密鑰
1.2 非對稱加密
非對稱加密使用兩個不同的密鑰：公鑰和私鑰。公鑰可以公開共享，而私鑰是保密的。發(fā)送方使用接收方的公鑰來加密數據，只有接收方使用自己的私鑰才能解密數據。常見的非對稱加密算法包括 RSA、ECC 等
非對稱加密的優(yōu)點是解決了對稱加密中密鑰管理和分發(fā)的問題，因為公鑰可以公開共享。非對稱加密的缺點是加密和解密速度相對較慢，不適用于大量數據的加密和解密
2. 安全證書
除了對數據加密通信，SSL 還采用了身份認證機制，確保通信雙方都可以驗證對方的真實身份。這和生活中我們使用身份證來證明自己的身份很相似，比如你到銀行去取錢，你自稱自己是張三，如何讓對方相信你的身份呢？最有效的辦法就是出示身份證。每人都擁有唯一的身份證，這個身份證上記錄了你的真實信息。身份證由國家權威機構頒發(fā)，不允許偽造。在身份證不能被別人假冒復制的前提下，只要你出示身份證，就可以證明你自己的身份
個人可以通過身份證來證明自己的身份，對于一個單位，比如商場，可以通過營業(yè)執(zhí)照來證明身份。營業(yè)執(zhí)照也由國家權威機構頒發(fā)，不允許偽造，它保證了營業(yè)執(zhí)照的可信性
SSL 通過安全證書來證明客戶或服務器的身份，當客戶通過安全的連接和服務器通信時，服務器會先向客戶出示它的安全證書，這個證書聲明該服務器是安全的，而且的確是這個服務器，每一個證書在全世界范圍內都是唯一的，其他非法服務器無法假冒，可以把安全證書比作電子身份證
對于單個客戶來說，到公認的權威機構去獲取安全證書是云件麻煩的事。為了擴大客戶群并且便于客戶的訪問，許多服務器不要求客戶出示安全證書。在某些情況下，服務器也會要求客戶出示安全證書，以便核實該客戶的身份，這主要是在 B2B 事務中
獲取安全證書有兩種方式，一種方式是從權威機構獲得證書，還有一種方式是創(chuàng)建自我簽名證書
2.1 從權威機構獲取證書
安全證書由國際權威的證書機構頒發(fā)，它們保證了證書的可信性。申請安全證書時，必須支付一定的費用。一個安全證書只對一個 IP 地址有效，如果用戶的系統(tǒng)環(huán)境中有多個 IP 地址須為每個 IP 地址都購買安全證書
2.2 創(chuàng)建自我簽名證書
在某些場合，通信雙方只關心數據在網絡上可以被安全傳輸，并不需要對方進行身份驗證，在這種情況下，可以創(chuàng)建自我簽名的證書。就像用戶自己制作的名片，缺乏權威性，達不到身份認證的目的。當你向對方遞交名片時，名片上聲稱你是某個大公司的老總，信不信只能由對方自己去判斷
既然自我簽名證書不能有效地證明自己的身份，那么有何意義呢？在技術上，無論是從權威機構獲得的證書，還是自己制作的證書，采用的加密技術都是一樣的，使用這些證書，都可以實現安全地加密通信
3. SSL 握手
安全證書既包含了用于加密數據的密鑰，又包含了用于證實身份的數字簽名。安全證書采用公鑰加密技術，公鑰加密指使用一對非對稱的密鑰進行加密或解密。每一對密鑰由公鑰和私鑰組成，公鑰被廣泛發(fā)布，私鑰是隱藏的，不公開。用公鑰加密的數據只能夠私鑰解密，反過來，使用私鑰加密的數據只能被公鑰解密
客戶與服務器通信時，首先要進行 SSL 握手，SSL 握手主要完成以下任務：
- 協商使用的加密套件，加密套件中包括一組加密參數，這些參數指定了加密算法和密鑰的長度等信息
- 驗證對方的身份，此操作是可選的
- 確定使用的加密算法
SSL 握手過程采用非對稱加密方法傳遞數據，由此來建立一個安全的會話。SSL 握手完成后，通信雙方將采用對稱加密方法傳遞實際的應用數據。所謂對稱加密，指通信雙方使用同樣的密鑰來加密數據
SSL 握手的具體流程如下：
- 客戶將自己的 SSL 版本號、加密參數、與會話有關的數據以及其他一些必要信息發(fā)送到服務器
- 服務器將自己的 SSL 版本號、加密參數、與會話有關的數據以及其他一些必要信息發(fā)送給客戶，同時發(fā)送給客戶的還有服務器的證書。如果服務器需要驗證客戶身份，那么服務器還會發(fā)出要求客戶提供安全證書的請求
- 客戶端驗證服務器證書，如果驗證失敗，就提示不能建立 SSL 連接。如果成功，就繼續(xù)下一步驟
- 客戶端為本次會話生成預備主密碼（pre-master secret），并將其用服務器安全證書附帶的公鑰加密后發(fā)送給服務器
- 如果服務器要求驗證客戶身份，那么客戶端還要再對另外一些數據簽名后，將其與客戶端證書一起發(fā)送給服務器
- 如果服務器要求驗證客戶身份，則檢查簽署客戶證書的 CA 是否可信。如果不在信任列表中，則結束本次會話。如果檢查通過，那么服務器用自己的私鑰解密收到的預備主密碼，并用它通過某些算法生成本次會話的主密碼（master secret）
- 客戶端與服務器均使用此主密碼生成本次會話的會話密鑰（對稱密鑰）。在雙方 SSL 握手結束后傳遞任何消息均使用此會話密鑰。這樣做的主要原因是對稱加密比非對稱加密的運算量低一個數量級以上，能夠顯著提高雙方會話時的運算速度
- 客戶端通知服務器此后發(fā)送的消息都使用這個會話密鑰進行加密，并通知服務器客戶端已經完成本次 SSL 握手
- 服務器通知客戶端此后發(fā)的消息都使用這個會話密鑰進行加密，并通如服務器已經完成本次 SSL 握手
- 本次握手過程結束，會話已經建立。在接下來的會話過程中，雙方使用同一個會話密鑰分別對發(fā)送以及接收的信息進行加密和解密
4. 創(chuàng)建自我簽名的安全證書
JDK 提供了制作證書的工具 keytool，它的位置為：<JDK根目錄>\bin\keytool.exe
keytool 工具提出了密鑰庫的概念，密鑰庫中可以包含多個條目，每個條目包括一個自我簽名的安全證書以及一對非對稱密鑰
通過 keytool 工具創(chuàng)建密鑰庫的命令為：
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 封裝了底層復雜的安全通信細節(jié)，使得開發(fā)人員能方便地用它來開發(fā)安全的網絡應用程序
1. KeyStore、KeyManager 與 TrustManager 類
在進行安全通信時，要求客戶端與服務器端都支持 SSL 或 TCL 協議?？蛻舳伺c服務器端可能都需要設置用于證實自身身份的安全證書，還要設置信任對方的哪些安全證書。更常見的情況是，服務器端只需要設置用于證實自身身份的安全證書，而客戶端只需要設置信任服務器的哪些安全證書
KeyStore 類用于存放包含安全證書的密鑰庫，以下程序代碼創(chuàng)建了一個 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 接口的任務是選擇用于證實自身身份的安全證書，把它發(fā)送給對方。KeyManagerFactory 負責創(chuàng)建 KeyManager 對象，例如
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
keyManagerFactory.init(keyStore, password);
KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
TrustManager 接口的任務是，決定是否信任對方的安全證書。TruesManagerFactory 負責創(chuàng)建 TrustManager 對象，例如
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("SunX509");
trustManagerFactory.init (keyStore);
TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
2. SSLContext 類
SSLContext 類負責設置與安全通信有關的各種信息，比如使用的協議（SSL 或者 TLS），自身的安全證書以及對方的安全證書。SSLContext 還負責構造 SSLServerSocketFactory、SSLSocketFactory 和 SSLEngine 對象
以下程序代碼創(chuàng)建并初始化了一個 SSLContext 對象，然后由它創(chuàng)建了一個 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 方法會創(chuàng)建默認的 KeyManager 對象以及與之關聯的 KeyStore 對象，KeyStore 對象從系統(tǒng)屬性 javax.net.ssl.keyStore 取安全證書。如果不存在這樣的系統(tǒng)屬性，那么KeyStore 對象內容為空
- 如果參數 tm 為 null，那么 init 方法會創(chuàng)建一個默認的 TrustManager 對象以及與之關聯的 KeyStore 對象，KeyStore 對象按照如下步驟獲取安全證書：
- 先嘗試從系統(tǒng)屬性 javax.net.ssl.trustStore 獲取安全證書
- 如果上一步失敗，就把 <JDK 根目錄>/lib/security/jssecacerts 文件作為安全證書
- 如果上一步失敗，就把 <JDK 根目錄>/lib/security/cacerts 文件作為安全證書
- 如果上一步失敗，那么 KeyStore 對象的內容為空
3. SSLServerSocketFactory類
SSLServerSocketFactory 類負責創(chuàng)建 SSLServerSocket 對象
SSLServerSocket serverSocket = (SSLServerSocket) sslServerSocketFactory.createServerSocket(8000); // 監(jiān)聽端口8000
SSLServerSocketFactory 對象有兩種創(chuàng)建方法：
- 調用 SSLContext 類的 getServerSocketFactory 方法
- 調用 SSLServerSocketFactory 類的靜態(tài) getDefault 方法
SSLServerSocketFactory 類的靜態(tài) getDefault 方法返回一個默認的 SSLServerSocketFactory 對象，它與一個默認的 SSLContext 對象關聯，getDefault 方法的實現按照如下方式初始化這個默認的 SSLContext 對象
sslContext.init(null,null,null);
4. SSLSocketFactory 類
SSLSocketFactory 類負責創(chuàng)建 SSLSocket 對象
SSLSocket socket = (SSLSocket) sslSocketFactory.createSocket("localhost",8000);
SSLSocketFactory 對象有兩種創(chuàng)建方法
- 調用 SSLContext 類的 getSocketFactory 方法
- 調用 SSLSocketFactory 類的靜態(tài) getDefault 方法
SSLSocketFactory 類的靜態(tài) getDefault 方法返回一個默認的 SSLSocketFactory 對象，它與一個默認的 SSLContext 對象關聯，getDefault 方法的實現按照如下方式初始化這個默認的 SSLContext 對象
sslContext.init(null,null,null);
5. SSLSocket類
SSLSocket 類是 Socket 類的子類，因此兩者的用法有許多相似之處。此外，SSLSocket 類還具有與安全通信有關的方法
5.1 設置加密套件
客戶與服務器在握手階段需要協商實際使用的加密套件，以下兩種情況都會導致握手失?。?/p>
- 不存在雙方都可以使用的相同加密套件
- 盡管存在這樣的加套件，但是有一方或雙方沒有使用該加密套件的安全證書
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 握手完成，會發(fā)出一個 HandshakeCompletedEvent 事件，該事件由 HandshakeCompletedListener 負責監(jiān)聽。SSLSocket 類的 addHandshakeCompletedListener 方法負責注冊 HandshakeCompletedListener 監(jiān)聽器
下例為 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 是否允許創(chuàng)建新的會話。flag 的默認值為 true。如果 flag 參數為 true，那么對于新創(chuàng)建的 SSLSocket，如果當前已經有可用的會話，就直接加入該會話，如果沒有可用的會話，就創(chuàng)建一個新的會話。如果 flag 為 false 參數，那么對于新創(chuàng)建的 SSLSocket，如果當前已經有可用的會話，就直接加入該會話，如果沒有可用的會話，那么該 SSLSocket 無法與對方進行安全通信
SSLSocket的 startHandshake 方法顯式地執(zhí)行一次 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 時，表示希望對方提供身份認證。如果對方未出示安全證書，則連接不會中斷，通信可繼續(xù)進行
setNeedClientAuth(boolean need)：當 need 參數為 true 時，表示要求對方必須提供身份認證。如果對方未出示安全證書，則連接中斷，通信無法繼續(xù)
6. SSLServerSocket類
SSLServerSocket 類是 ServerSocket 類的子類，因此兩者的用法有許多相似之處。此外，SSLServerSocket 類還具有與安全通信有關的方法，這些方法與 SSLSocket 類中的同名方法具有相同的作用文章來源：http://www.zghlxwxcb.cn/news/detail-501345.html
7. SSLEngine 類
SSLEngine 類與 SocketChannel 類聯合使用，就能實現非阻塞的安全通信。SSLEngine 類封裝了與安全通信有關的細節(jié)，把應用程序發(fā)送的應用數據打包為網絡數據，打包指對應用數據進行加密，加入 SSL 握手數據，把它變?yōu)榫W絡數據。SSLEngine 類還能把接收的網絡數據展開為應用數據，展開指對網絡數據解密，并且去除其中的 SSL 握手數據，從而還原為應用程序可以處理的應用數據。SSLEngine 類的 wrap 方法負責打包應用數據，unwrap 方法負責展開網絡數據文章來源地址http://www.zghlxwxcb.cn/news/detail-501345.html
public class SSLEngineDemo {
private static boolean logging = true;
private SSLContext sslc;
private SSLEngine clientEngine; //客戶端Engine
private ByteBuffer clientOut; //存放客戶端發(fā)送的應用數據
private ByteBuffer clientIn; //存放客戶端接收到的應用數據
private SSLEngine serverEngine; //服務器端Engine
private ByteBuffer serverOut; //存放服務器端發(fā)送的應用數據
private ByteBuffer serverIn; //存放服務器端接收到的應用數據
private ByteBuffer cTOs;//存放客戶端向服務器端發(fā)送的網絡數據
private ByteBuffer sTOc;//存放服務器向客戶海發(fā)送的網絡數據
//設置密鑰庫文件和信任庫文件以及口令
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;
/*創(chuàng)建客戶端以及服務器端的SSLEngine*/
serverEngine = sslc.createSSLEnqine();
serverEngine.setUseClientMode(false);
serverEngine.setNeedClientAuth(true);
clientEngine = sslc.createSSLEngine("client", 80);
clientEngine.setUseClientMode(true);
/*創(chuàng)建客戶端以及服務器的應用沖區(qū)和網絡緩沖區(qū)*/
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());
}
/**執(zhí)行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);
}
}
/**判斷兩個緩沖區(qū)內容是否相同*/
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);
}
}
創(chuàng)建基于 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);
//當要求客戶端提供安全證書時，服務器端可創(chuàng)建TrustManagerFactory,
//并由它創(chuàng)建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));
}
}
到了這里，關于Java 網絡編程 —— 安全網絡通信的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！
