CA認證原理以及實現（上）

原理基礎
數字證書爲發佈公鑰提供了一種簡便的途徑，其數字證書則成爲加密算法以及公鑰的載體，依靠數字證書，咱們能夠構建一個簡單的加密網絡應用平臺，數字證書就比如咱們生活中的身份證，現實中，身份證由公安機關簽發，而網絡用戶的身份憑證由數字證書頒發認證機構—CA簽發，只有通過CA簽發的證書在網絡中才具有可認證性，CA並非一個單純的防護手段，它集合了多種密碼學算法：
消息摘要算法：MD五、和SHA（對數字證書本省作摘要處理，用於驗證數據完整性服務器）
對稱加密算法：RC二、RC四、IDEA、DES、AES（對數據進行加密/解密操做，用於保證數據保密性服務）
非對稱加密算法：RSA、DH（對數據進行加密/解密操做，用於保證數據保密性服務）
數字簽名算法：RSA、DSA(對數據進行簽名/驗證操做，保證數據的完整性和抗否定性)。

證書的簽發過程其實是對申請數字證書的公鑰作數字簽名，證書的驗證過程其實是對數字證書的公鑰作驗證簽名，其中還包含證書有效期驗證，經過CA數字證書，咱們對網絡上傳輸的數據進行加密/解密和簽名/驗證操做，確保數據機密性、完整性、抗否定性、認證性，保證交易實體身份的真實性，保證網絡安全性。

 

全部證書有多種文件編碼格式，主要包括:
CER編碼(規範編碼格式)：是數字證書的一種編碼格式，它是BER(基本編碼格式)的一個變種，比BER規定得更嚴格
DER(卓越編碼格式)：一樣是BER的一個變種，與CER的不一樣在於，DER使用定長模式，而CER使用變長模式。

全部證書都符合公鑰基礎設施(PKI)制定的ITU-T X509國際標準，PKCS(公鑰加密標準)由RSA實驗室和其餘安全系統開發商爲促進公鑰密碼的發展而制定的一系列標準，好比:PKCS#7(密碼消息語法標準----文件後綴名:.p7b、.p7c、.spc)、PKCS#10(證書請求語法標準----文件後綴名:.p十、.csr)、PKCS#12(我的信息交換語法標準----文件後綴名:.p十二、.pfx)等

在得到數字證書後，能夠將其保存在電腦中，也能夠保存在USB Key等相應的設備中。

 

咱們先來看一個簡單的證書機構簽發的流程:

這裏的認證機構如何是證書申請者自己，將得到自簽名證書。

當客戶端得到服務器下發的數字證書後，便可使用數字證書進行加密交互：

 

數字證書的應用環境是在https安全協議中，使用流程遠比上述加密交互流程複雜，可是相關操做封裝在傳輸層，對於應用層透明，在https安全協議中使用非對稱加密算法交換密鑰，使用對稱加密算法對數據進行加密/解密操做，提升加密/解密效率

 

要得到數字證書，咱們須要使用數字證書管理工具：KeyTool和OpenSSL構建CSR(數字證書籤發申請)，交由CA機構簽發，造成最終的數字證書，這裏咱們不對KeyTool作講解（KeyTool不含有根證書，所以KeyTool沒有辦法做爲CA），網上資料對keytool講解的也挺多的，咱們下面針對OpenSSL進行講解。

 

在咱們搭建OPEN SSL環境前，咱們要知道HTTPS協議和SSL/TLS協議，簡單的說，HTTPS就是HTTP+SSL（secure socket layer）/TLS(Transport Layer Security)協議，HTTPS協議爲數字證書提供了最佳的應用環境，HTTPS協議通常在服務器中配置，如HTTP服務器APACHE、TOMCAT等。
SSL:位於TCP/IP中的網絡傳輸層，做爲網絡通信提供安全以及數據完整性的一種安全協議
TLS:做爲SSL協議的繼承者，成爲下一代網絡安全性和數據完整性安全協議
SSL共有3個版本:1.0、2.0、3.0，TLS也有1.0、2.0、3.0，一般咱們說的SSL/TLS協議指的是SSL3.0/TLS1.0的網絡傳輸層安全協議

SSL/TLS協議分爲兩層：
記錄協議:建議在可靠的傳輸協議之上，爲高層協議提供數據封裝、壓縮、加密等基本功能的支持
握手協議:創建在SSL記錄協議之上，用於在實際的數據傳輸開始前，通信雙方進行身份認證、協商加密算法、交換加密密鑰等

通過了SSL/TLS握手協議交互後，數據交互雙方肯定了本次會話使用的對稱加密算法以及密鑰，就能夠開始進行加密數據交互了，如下是握手協議服務器端和客戶端構建加密交互的相關流程圖：

協商算法

一、 隨機數爲後續構建密鑰準備
二、 其餘信息包括服務器證書、甚至包含獲取客戶端證書的請求

 

驗證算法
若是服務器端回覆客戶端時帶有其餘信息，則進入數字證書驗證階段
客戶端驗證服務器端證書：

 

服務器端驗證客戶端證書:

 

產生密鑰
當服務器端和客戶端通過上述流程後，就開始密鑰構建交互了，服務器端和客戶端最初須要主密鑰爲構建會話密鑰作準備：

上述五、6不存在次序關係，由於是異步完成

 

會話密鑰
完成上述主密鑰構建操做後，服務器端和客戶端將創建會話密鑰，完成握手協議：

 

加密交互
上述服務器端和客戶端完成了握手協議之後就進入正式會話階段，若是上述流程中有任何一端受到外界因素干擾發生異常，則從新進入協商算法階段，下面流程表現進入會話階段後，服務器端和客戶端將使用會話密鑰進行加密交互：

 

代碼解釋
在JAVA 6 以上版本中提供了完善的數字證書管理的實現，咱們不須要關注相關具體算法，僅經過操做密鑰庫和數字證書就能夠完成相應的加密/解密和簽名/驗證操做，密鑰庫管理私鑰，數字證書管理公鑰，私鑰和密鑰分屬消息傳遞兩方，進行加密消息的傳遞。
所以，咱們能夠將密鑰庫看作私鑰相關操做的入口，數字證書則是公鑰相關操做的入口：

Java代碼    

1. /**** 
2.      * 得到私鑰，得到私鑰後，經過RSA算方法實現進行"私鑰加密，公鑰解密"和"公鑰加密，私鑰解密"操做 
3.      * @param keyStorePath 密鑰庫路徑 
4.      * @param alias 別名 
5.      * @param password 密碼 
6.      * @return  私鑰  
7.      */  
8.     private static PrivateKey getPrivateKeyByKeyStore(String keyStorePath,String alias,String password)throws Exception{  
9.         //得到密鑰庫  
10.         KeyStore ks = getKeyStore(keyStorePath,password);  
11.         //得到私鑰  
12.         return  (PrivateKey)ks.getKey(alias, password.toCharArray());  
13.           
14.     }  
15.       
16.     /**** 
17.      * 由Certificate得到公鑰，得到公鑰後，經過RSA算方法實現進行"私鑰加密，公鑰解密"和"公鑰加密，私鑰解密"操做 
18.      * @param certificatePath  證書路徑 
19.      * @return 公鑰 
20.      */  
21.     private static PublicKey getPublicKeyByCertificate(String certificatePath)throws Exception {  
22.         //得到證書  
23.         Certificate certificate = getCertificate(certificatePath);  
24.         //得到公鑰  
25.         return certificate.getPublicKey();  
26.     }  
27.       
28.     /**** 
29.      * 加載數字證書，JAVA 6僅支持x.509的數字證書 
30.      * @param certificatePath  證書路徑 
31.      * @return   證書 
32.      * @throws Exception 
33.      */  
34.     private static Certificate getCertificate(String certificatePath) throws Exception{  
35.         //實例化證書工廠  
36.         CertificateFactory certificateFactory = CertificateFactory.getInstance("x.509");  
37.         //取得證書文件流  
38.         FileInputStream in = new FileInputStream(certificatePath);  
39.         //生成證書  
40.         Certificate certificate = certificateFactory.generateCertificate(in);  
41.         //關閉證書文件流  
42.         in.close();  
43.         return certificate;  
44.     }  
45.       
46.     /**** 
47.      * 得到Certificate 
48.      * @param keyStorePath 密鑰庫路徑 
49.      * @param alias 別名 
50.      * @param password  密碼 
51.      * @return  證書 
52.      * @throws Exception 
53.      */  
54.     private static Certificate getCertificate(String keyStorePath,String alias,String password) throws Exception{  
55.         //由密鑰庫得到數字證書構建數字簽名對象  
56.         //得到密鑰庫  
57.         KeyStore ks = getKeyStore(keyStorePath,password);  
58.         //得到證書  
59.         return ks.getCertificate(alias);  
60.     }  
61.       
62.     /**** 
63.      * 加載密鑰庫，加載了之後，咱們就能經過相應的方法得到私鑰，也能夠得到數字證書 
64.      * @param keyStorePath 密鑰庫路徑 
65.      * @param password 密碼 
66.      * @return  密鑰庫 
67.      * @throws Exception 
68.      */  
69.     private static KeyStore getKeyStore(String keyStorePath,String password) throws Exception{  
70.         //實例化密鑰庫  
71.         KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());  
72.         //得到密鑰庫文件流  
73.         FileInputStream is = new FileInputStream(keyStorePath);  
74.         //加載密鑰庫  
75.         ks.load(is,password.toCharArray());  
76.         //關閉密鑰庫文件流  
77.         is.close();  
78.         return ks;  
79.     }  
80.       
81.     /**** 
82.      * 私鑰加密 
83.      * @param data  待加密的數據 
84.      * @param keyStorePath  密鑰庫路徑 
85.      * @param alias  別名 
86.      * @param password   密碼 
87.      * @return  加密數據 
88.      * @throws Exception 
89.      */  
90.     public static byte[] encryptByPriateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception{  
91.         //得到私鑰  
92.         PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath,alias,password);  
93.         //對數據加密  
94.         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
95.         return cipher.doFinal(data);  
96.     }  
97.       
98.     /**** 
99.      * 私鑰解密 
100.      * @param data  待解密數據 
101.      * @param keyStorePath 密鑰庫路徑 
102.      * @param alias  別名 
103.      * @param password  密碼 
104.      * @return  解密數據 
105.      * @throws Exception 
106.      */  
107.     public static byte[] decryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception{  
108.         //取得私鑰  
109.         PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath,alias,password);  
110.         //對數據解密  
111.         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
112.         cipher.init(Cipher.DECRYPT_MODE,privateKey);  
113.         return cipher.doFinal(data);  
114.     }  
115.       
116.     /**** 
117.      * 公鑰加密 
118.      * @param data  等待加密數據 
119.      * @param certificatePath  證書路徑 
120.      * @return   加密數據 
121.      * @throws Exception 
122.      */  
123.     public static byte[] encryptByPublicKey(byte[] data,String certificatePath) throws Exception{  
124.         //取得公鑰  
125.         PublicKey publicKey = getPublicKeyByCertificate(certificatePath);  
126.         //對數據加密  
127.         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
128.         cipher.init(Cipher.ENCRYPT_MODE,publicKey);  
129.         return cipher.doFinal(data);  
130.     }  
131.       
132.     /**** 
133.      * 公鑰解密 
134.      * @param data  等待解密的數據 
135.      * @param certificatePath  證書路徑 
136.      * @return  解密數據 
137.      * @throws Exception 
138.      */  
139.     public static byte[] decryptByPublicKey(byte[] data,String certificatePath)throws Exception{  
140.         //取得公鑰  
141.         PublicKey publicKey = getPublicKeyByCertificate(certificatePath);  
142.         //對數據解密  
143.         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
144.         cipher.init(Cipher.DECRYPT_MODE, publicKey);  
145.         return cipher.doFinal(data);  
146.     }  
147.       
148.     /**** 
149.      * @param sign  簽名 
150.      * @param keyStorePath 密鑰庫路徑 
151.      * @param alias 別名 
152.      * @param password 密碼 
153.      * @return 簽名 
154.      * @throws Exception 
155.      */  
156.     public static byte[] sign(byte[] sign,String keyStorePath,String alias,String password)throws Exception{  
157.         //得到證書  
158.         X509Certificate x509Certificate = (X509Certificate) getCertificate(keyStorePath,alias,password);  
159.         //構建簽名,由證書指定簽名算法  
160.         Signature signature = Signature.getInstance(x509Certificate.getSigAlgName());  
161.         //獲取私鑰  
162.         PrivateKey privateKey = getPrivateKeyByKeyStore(keyStorePath,alias,password);  
163.         //初始化簽名，由私鑰構建  
164.         signature.initSign(privateKey);  
165.         signature.update(sign);  
166.         return signature.sign();  
167.     }  
168.       
169.       
170.     /**** 
171.      * 驗證簽名 
172.      * @param data  數據 
173.      * @param sign  簽名 
174.      * @param certificatePath  證書路徑 
175.      * @return  驗證經過爲真 
176.      * @throws Exception 
177.      */  
178.     public static boolean verify(byte[] data,byte[] sign,String certificatePath) throws Exception{  
179.         //得到證書  
180.         X509Certificate x509Certificate = (X509Certificate)getCertificate(certificatePath);  
181.         //由證書構建簽名  
182.         Signature signature = Signature.getInstance(x509Certificate.getSigAlgName());  
183.         //由證書初始化簽名，其實是使用了證書中的公鑰  
184.         signature.initVerify(x509Certificate);  
185.         signature.update(data);  
186.         return signature.verify(sign);  
187.     }  
188.       
189.     //咱們假定密鑰庫文件yale.keystore存儲在D盤根目錄，數字證書文件yale.cer也存儲在D盤根目錄  
190.     /**** 
191.      * 公鑰加密---私鑰解密 
192.      * @throws Exception 
193.      */  
194.     public static void test1() throws Exception{  
195.         System.err.println("公鑰加密---私鑰解密");  
196.         String inputStr = "數字證書";  
197.         byte[] data = inputStr.getBytes();  
198.         //公鑰加密  
199.         byte[] encrypt = CertificateCoder.encryptByPublicKey(data, certificatePath);  
200.         //私鑰解密  
201.         byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt, keyStorePath, alias, password);  
202.         String outputStr = new String(decrypt);  
203.         System.err.println("加密前：\n" + inputStr);  
204.         System.err.println("解密後：\n" + outputStr);  
205.     }  
206.       
207.     /**** 
208.      * 私鑰加密---公鑰解密 
209.      * @throws Exception 
210.      */  
211.     public static void test2()throws Exception{  
212.         System.err.println("私鑰加密---公鑰解密");  
213.         String inputStr = "數字簽名";  
214.         byte[] data = inputStr.getBytes();  
215.         //私鑰加密  
216.         byte[] encodedData = CertificateCoder.encryptByPriateKey(data, keyStorePath, alias, password);  
217.         //公鑰加密  
218.         byte[] decodeData = CertificateCoder.decryptByPublicKey(encodedData, certificatePath);  
219.         String outputStr = new String (decodeData);  
220.         System.err.println("加密前：\n" + inputStr);  
221.         System.err.println("解密後：\n" + outputStr);  
222.     }  
223.       
224.     public static void testSign()throws Exception{  
225.         String inputStr = "簽名";  
226.         byte[] data = inputStr.getBytes();  
227.         System.err.println("私鑰簽名---公鑰驗證");  
228.         //產生簽名  
229.         byte[] sign = CertificateCoder.sign(data, keyStorePath, alias, password);  
230.         System.err.println("簽名:\n" + Hex.encodeHexString(sign));  
231.         //驗證簽名  
232.         boolean status = CertificateCoder.verify(data, sign, certificatePath);  
233.         System.err.println("狀態：\n " + status);  
234.     }