CA认证原理以及实现（上）

左手的ㄟ右手 2022-05-20 23:19 155阅读 0赞

转载自：https://blog.csdn.net/lujiancs/article/details/38487235

原理基础

数字证书为发布公钥提供了一种简便的途径，其数字证书则成为加密算法以及公钥的载体，依靠数字证书，我们可以构建一个简单的加密网络应用平台，数字证书就好比我们生活中的身份证，现实中，身份证由公安机关签发，而网络用户的身份凭证由数字证书颁发认证机构—CA签发，只有经过CA签发的证书在网络中才具备可认证性，CA并不是一个单纯的防御手段，它集合了多种密码学算法：  
消息摘要算法：MD5、和SHA（对数字证书本省做摘要处理，用于验证数据完整性服务器）  
对称加密算法：RC2、RC4、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(证书请求语法标准----文件后缀名:.p10、.csr)、PKCS\#12(个人信息交换语法标准----文件后缀名:.p12、.pfx)等

在获得数字证书后，可以将其保存在电脑中，也可以保存在USB Key等相应的设备中。

我们先来看一个简单的证书机构签发的流程:

![da552e4e-1976-38e8-ae0f-5d6b24ce20d0.jpg][]

这里的认证机构如何是证书申请者本身，将获得自签名证书。

当客户端获得服务器下发的数字证书后，即可使用数字证书进行加密交互：  
![2e93fbc5-28fb-39b3-bc8c-f4a0358bb1f8.jpg][]

数字证书的应用环境是在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握手协议交互后，数据交互双方确定了本次会话使用的对称加密算法以及密钥，就可以开始进行加密数据交互了，以下是握手协议服务器端和客户端构建加密交互的相关流程图：

协商算法

![7f082129-0309-3c29-ac5a-e4d29b9ce078.jpg][]

1、 随机数为后续构建密钥准备  
2、 其他信息包括服务器证书、甚至包含获取客户端证书的请求

验证算法  
如果服务器端回复客户端时带有其他信息，则进入数字证书验证阶段  
客户端验证服务器端证书：  
![08c9c163-fa60-3277-9928-1bf3d5ddb24e.jpg][]

服务器端验证客户端证书:

![1303c3c9-ff88-39ae-b5ac-c5d4ca2f1d24.jpg][]

产生密钥  
当服务器端和客户端经过上述流程后，就开始密钥构建交互了，服务器端和客户端最初需要主密钥为构建会话密钥做准备：

![62a0235c-ad93-3129-bfe9-1ebf301e3c35.jpg][]

上述5、6不存在次序关系，因为是异步完成

会话密钥  
完成上述主密钥构建操作后，服务器端和客户端将建立会话密钥，完成握手协议：

![116b5eb3-d853-38aa-b87c-2dc8875d2706.jpg][]

加密交互  
上述服务器端和客户端完成了握手协议以后就进入正式会话阶段，如果上述流程中有任何一端受到外界因素干扰发生异常，则重新进入协商算法阶段，下面流程表现进入会话阶段后，服务器端和客户端将使用会话密钥进行加密交互：

![ae33e3a6-c027-3924-8522-41549e1c32da.jpg][]

代码解释  
在JAVA 6 以上版本中提供了完善的数字证书管理的实现，我们不需要关注相关具体算法，仅通过操作密钥库和数字证书就可以完成相应的加密/解密和签名/验证操作，密钥库管理私钥，数字证书管理公钥，私钥和密钥分属消息传递两方，进行加密消息的传递。  
因此，我们可以将密钥库看做私钥相关操作的入口，数字证书则是公钥相关操作的入口：

Java代码 [![复制代码][icon_copy.gif]][icon_copy.gif 1] [![收藏代码][icon_star.png]![spinner.gif][]][icon_star.png_spinner.gif]

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.     \}

[da552e4e-1976-38e8-ae0f-5d6b24ce20d0.jpg]: /images/20220521/6cd3c7d3401d472bb52af17aaef99ce8.png
[2e93fbc5-28fb-39b3-bc8c-f4a0358bb1f8.jpg]: /images/20220521/e6a9313de4214836ab2d7f995b0c6a7f.png
[7f082129-0309-3c29-ac5a-e4d29b9ce078.jpg]: /images/20220521/ecc140e4fb15439fb2e91abfe03c24ff.png
[08c9c163-fa60-3277-9928-1bf3d5ddb24e.jpg]: /images/20220521/92efc66683c74ec5b3d0a860c3a8dbef.png
[1303c3c9-ff88-39ae-b5ac-c5d4ca2f1d24.jpg]: /images/20220521/a7855bcd0a1d41a0a0bcf3f929dcda4f.png
[62a0235c-ad93-3129-bfe9-1ebf301e3c35.jpg]: /images/20220521/44b5c48cd2a6417da94b293d7f1a67d8.png
[116b5eb3-d853-38aa-b87c-2dc8875d2706.jpg]: /images/20220521/00a84d59bbdb485db1f562090b4d4106.png
[ae33e3a6-c027-3924-8522-41549e1c32da.jpg]: /images/20220521/f051e68d961c4b7b8799de0bdc63df3f.png
[icon_copy.gif]: http://yale.iteye.com/images/icon_copy.gif
[icon_copy.gif 1]: http://yale.iteye.com/blog/1675344#
[icon_star.png]: http://yale.iteye.com/images/icon_star.png
[spinner.gif]: /images/20220521/fe1b4dc3cfd849a5894ff76386dda466.png
[icon_star.png_spinner.gif]: http://yale.iteye.com/blog/1675344