cer, pfx 创建，并且读取公钥/密钥，加解密 （C#程序实现）

PKI技术（public key infrastructure）里面，cer文件和pfx文件是很常见的。通常cer文件里面保存着公钥以及用户的一些信息，pfx里面则含有私钥和公钥。

用makecert.exe可以创建公钥证书和私钥证书，具体看

http://msdn.microsoft.com/zh-cn/library/bfsktky3(v=vs.110).aspx

http://blog.csdn.net/hacode/article/details/4240238

这里使用程序的方法来创建。参考了http://www.cnblogs.com/luminji/archive/2010/10/28/1863179.html

下面的代码封装了一个类，可以在store里面创建一个认证，并且导出到cer，pfx，然后从store，cer，pfx读取信息

1. public sealed class DataCertificate
2. {
3. #region 生成证书
4. /// <summary>
5. /// 根据指定的证书名和makecert全路径生成证书（包含公钥和私钥，并保存在MY存储区）
6. /// </summary>
7. /// <param name="subjectName"></param>
8. /// <param name="makecertPath"></param>
9. /// <returns></returns>
10. public static bool CreateCertWithPrivateKey(string subjectName, string makecertPath)
11. {
12. subjectName = "CN=" + subjectName;
13. string param = " -pe -ss my -n \"" + subjectName + "\" ";
14. try
15. {
16. Process p = Process.Start(makecertPath, param);
17. p.WaitForExit();
18. p.Close();
19. }
20. catch (Exception e)
21. {
22. return false;
23. }
24. return true;
25. }
26. #endregion
27. #region 文件导入导出
28. /// <summary>
29. /// 从WINDOWS证书存储区的个人MY区找到主题为subjectName的证书，
30. /// 并导出为pfx文件，同时为其指定一个密码
31. /// 并将证书从个人区删除(如果isDelFromstor为true)
32. /// </summary>
33. /// <param name="subjectName">证书主题，不包含CN=</param>
34. /// <param name="pfxFileName">pfx文件名</param>
35. /// <param name="password">pfx文件密码</param>
36. /// <param name="isDelFromStore">是否从存储区删除</param>
37. /// <returns></returns>
38. public static bool ExportToPfxFile(string subjectName, string pfxFileName,
39. string password, bool isDelFromStore)
40. {
41. subjectName = "CN=" + subjectName;
42. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
43. store.Open(OpenFlags.ReadWrite);
44. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
45. foreach (X509Certificate2 x509 in storecollection)
46. {
47. if (x509.Subject == subjectName)
48. {
49. Debug.Print(string.Format("certificate name: {0}", x509.Subject));
50. byte[] pfxByte = x509.Export(X509ContentType.Pfx, password);
51. using (FileStream fileStream = new FileStream(pfxFileName, FileMode.Create))
52. {
53. // Write the data to the file, byte by byte.
54. for (int i = 0; i < pfxByte.Length; i++)
55. fileStream.WriteByte(pfxByte[i]);
56. // Set the stream position to the beginning of the file.
57. fileStream.Seek(0, SeekOrigin.Begin);
58. // Read and verify the data.
59. for (int i = 0; i < fileStream.Length; i++)
60. {
61. if (pfxByte[i] != fileStream.ReadByte())
62. {
63. fileStream.Close();
64. return false;
65. }
66. }
67. fileStream.Close();
68. }
69. if( isDelFromStore == true)
70. store.Remove(x509);
71. }
72. }
73. store.Close();
74. store = null;
75. storecollection = null;
76. return true;
77. }
78. /// <summary>
79. /// 从WINDOWS证书存储区的个人MY区找到主题为subjectName的证书，
80. /// 并导出为CER文件（即，只含公钥的）
81. /// </summary>
82. /// <param name="subjectName"></param>
83. /// <param name="cerFileName"></param>
84. /// <returns></returns>
85. public static bool ExportToCerFile(string subjectName, string cerFileName)
86. {
87. subjectName = "CN=" + subjectName;
88. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
89. store.Open(OpenFlags.ReadWrite);
90. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
91. foreach (X509Certificate2 x509 in storecollection)
92. {
93. if (x509.Subject == subjectName)
94. {
95. Debug.Print(string.Format("certificate name: {0}", x509.Subject));
96. //byte[] pfxByte = x509.Export(X509ContentType.Pfx, password);
97. byte[] cerByte = x509.Export(X509ContentType.Cert);
98. using (FileStream fileStream = new FileStream(cerFileName, FileMode.Create))
99. {
100. // Write the data to the file, byte by byte.
101. for (int i = 0; i < cerByte.Length; i++)
102. fileStream.WriteByte(cerByte[i]);
103. // Set the stream position to the beginning of the file.
104. fileStream.Seek(0, SeekOrigin.Begin);
105. // Read and verify the data.
106. for (int i = 0; i < fileStream.Length; i++)
107. {
108. if (cerByte[i] != fileStream.ReadByte())
109. {
110. fileStream.Close();
111. return false;
112. }
113. }
114. fileStream.Close();
115. }
116. }
117. }
118. store.Close();
119. store = null;
120. storecollection = null;
121. return true;
122. }
123. #endregion
124. #region 从证书中获取信息
125. /// <summary>
126. /// 根据私钥证书得到证书实体，得到实体后可以根据其公钥和私钥进行加解密
127. /// 加解密函数使用DEncrypt的RSACryption类
128. /// </summary>
129. /// <param name="pfxFileName"></param>
130. /// <param name="password"></param>
131. /// <returns></returns>
132. public static X509Certificate2 GetCertificateFromPfxFile(string pfxFileName,
133. string password)
134. {
135. try
136. {
137. return new X509Certificate2(pfxFileName, password, X509KeyStorageFlags.Exportable);
138. }
139. catch (Exception e)
140. {
141. return null;
142. }
143. }
144. /// <summary>
145. /// 到存储区获取证书
146. /// </summary>
147. /// <param name="subjectName"></param>
148. /// <returns></returns>
149. public static X509Certificate2 GetCertificateFromStore(string subjectName)
150. {
151. subjectName = "CN=" + subjectName;
152. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
153. store.Open(OpenFlags.ReadWrite);
154. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
155. foreach (X509Certificate2 x509 in storecollection)
156. {
157. if (x509.Subject == subjectName)
158. {
159. return x509;
160. }
161. }
162. store.Close();
163. store = null;
164. storecollection = null;
165. return null;
166. }
167. /// <summary>
168. /// 根据公钥证书，返回证书实体
169. /// </summary>
170. /// <param name="cerPath"></param>
171. public static X509Certificate2 GetCertFromCerFile(string cerPath)
172. {
173. try
174. {
175. return new X509Certificate2(cerPath);
176. }
177. catch (Exception e)
178. {
179. return null;
180. }
181. }
182. #endregion
183. }

两个RSA加解密辅助函数：

1. static string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
2. {
3. RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
4. provider.FromXmlString(xmlPrivateKey);
5. byte[] rgb = Convert.FromBase64String(m_strDecryptString);
6. byte[] bytes = provider.Decrypt(rgb, false);
7. return new UnicodeEncoding().GetString(bytes);
8. }
9. /// <summary>
10. /// RSA加密
11. /// </summary>
12. /// <param name="xmlPublicKey"></param>
13. /// <param name="m_strEncryptString"></param>
14. /// <returns></returns>
15. static string RSAEncrypt(string xmlPublicKey, string m_strEncryptString)
16. {
17. RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
18. provider.FromXmlString(xmlPublicKey);
19. byte[] bytes = new UnicodeEncoding().GetBytes(m_strEncryptString);
20. return Convert.ToBase64String(provider.Encrypt(bytes, false));
21. }

使用例子，下面的代码做了几个事情

1. 在个人store里面创建了一个认证， 从认证里面读取信息得到一个X509Certificate2的对象，这个对象内部包含公钥和私钥，然后做了次rsa加解密测试。

2. 从store里面导出一个cer文件，因为cer文件并没有私钥，只有公钥。测试代码就是用公钥加密然后用前面得到的私钥解密。

3. 导出一个pfx文件，pfx包括公钥和私钥，可以自己加解密。

这是个很简单的例子，但是对于理解cer文件和pfx文件已经公钥私钥应该有帮助。

1. // 在personal（个人）里面创建一个foo的证书
2. DataCertificate.CreateCertWithPrivateKey("foo", "C:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x64\\makecert.exe");
3. // 获取证书
4. X509Certificate2 c1 = DataCertificate.GetCertificateFromStore("foo");
5. string keyPublic = c1.PublicKey.Key.ToXmlString(false);  // 公钥
6. string keyPrivate = c1.PrivateKey.ToXmlString(true);  // 私钥
7. string cypher = RSAEncrypt(keyPublic, "程序员");  // 加密
8. string plain = RSADecrypt(keyPrivate, cypher);  // 解密
9. Debug.Assert(plain == "程序员");
10. // 生成一个cert文件
11. DataCertificate.ExportToCerFile("foo", "d:\\mycert\\foo.cer");
12. X509Certificate2 c2 = DataCertificate.GetCertFromCerFile("d:\\mycert\\foo.cer");
13. string keyPublic2 = c2.PublicKey.Key.ToXmlString(false);
14. bool b = keyPublic2 == keyPublic;
15. string cypher2 = RSAEncrypt(keyPublic2, "程序员2");  // 加密
16. string plain2 = RSADecrypt(keyPrivate, cypher2);  // 解密, cer里面并没有私钥，所以这里使用前面得到的私钥来解密
17. Debug.Assert(plain2 == "程序员2");
18. // 生成一个pfx， 并且从store里面删除
19. DataCertificate.ExportToPfxFile("foo", "d:\\mycert\\foo.pfx", "111", true);
20. X509Certificate2 c3 = DataCertificate.GetCertificateFromPfxFile("d:\\mycert\\foo.pfx", "111");
21. string keyPublic3 = c3.PublicKey.Key.ToXmlString(false);  // 公钥
22. string keyPrivate3 = c3.PrivateKey.ToXmlString(true);  // 私钥
23. string cypher3 = RSAEncrypt(keyPublic3, "程序员3");  // 加密
24. string plain3 = RSADecrypt(keyPrivate3, cypher3);  // 解密
25. Debug.Assert(plain3 == "程序员3");

附：完整代码

1. using System;
2. using System.Collections.Generic;
3. using System.Diagnostics;
4. using System.IO;
5. using System.Linq;
6. using System.Security.Cryptography;
7. using System.Security.Cryptography.X509Certificates;
8. using System.Text;
9. namespace ConsoleApplication1
10. {
11. public sealed class DataCertificate
12. {
13. #region 生成证书
14. /// <summary>
15. /// 根据指定的证书名和makecert全路径生成证书（包含公钥和私钥，并保存在MY存储区）
16. /// </summary>
17. /// <param name="subjectName"></param>
18. /// <param name="makecertPath"></param>
19. /// <returns></returns>
20. public static bool CreateCertWithPrivateKey(string subjectName, string makecertPath)
21. {
22. subjectName = "CN=" + subjectName;
23. string param = " -pe -ss my -n \"" + subjectName + "\" ";
24. try
25. {
26. Process p = Process.Start(makecertPath, param);
27. p.WaitForExit();
28. p.Close();
29. }
30. catch (Exception e)
31. {
32. return false;
33. }
34. return true;
35. }
36. #endregion
37. #region 文件导入导出
38. /// <summary>
39. /// 从WINDOWS证书存储区的个人MY区找到主题为subjectName的证书，
40. /// 并导出为pfx文件，同时为其指定一个密码
41. /// 并将证书从个人区删除(如果isDelFromstor为true)
42. /// </summary>
43. /// <param name="subjectName">证书主题，不包含CN=</param>
44. /// <param name="pfxFileName">pfx文件名</param>
45. /// <param name="password">pfx文件密码</param>
46. /// <param name="isDelFromStore">是否从存储区删除</param>
47. /// <returns></returns>
48. public static bool ExportToPfxFile(string subjectName, string pfxFileName,
49. string password, bool isDelFromStore)
50. {
51. subjectName = "CN=" + subjectName;
52. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
53. store.Open(OpenFlags.ReadWrite);
54. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
55. foreach (X509Certificate2 x509 in storecollection)
56. {
57. if (x509.Subject == subjectName)
58. {
59. Debug.Print(string.Format("certificate name: {0}", x509.Subject));
60. byte[] pfxByte = x509.Export(X509ContentType.Pfx, password);
61. using (FileStream fileStream = new FileStream(pfxFileName, FileMode.Create))
62. {
63. // Write the data to the file, byte by byte.
64. for (int i = 0; i < pfxByte.Length; i++)
65. fileStream.WriteByte(pfxByte[i]);
66. // Set the stream position to the beginning of the file.
67. fileStream.Seek(0, SeekOrigin.Begin);
68. // Read and verify the data.
69. for (int i = 0; i < fileStream.Length; i++)
70. {
71. if (pfxByte[i] != fileStream.ReadByte())
72. {
73. fileStream.Close();
74. return false;
75. }
76. }
77. fileStream.Close();
78. }
79. if( isDelFromStore == true)
80. store.Remove(x509);
81. }
82. }
83. store.Close();
84. store = null;
85. storecollection = null;
86. return true;
87. }
88. /// <summary>
89. /// 从WINDOWS证书存储区的个人MY区找到主题为subjectName的证书，
90. /// 并导出为CER文件（即，只含公钥的）
91. /// </summary>
92. /// <param name="subjectName"></param>
93. /// <param name="cerFileName"></param>
94. /// <returns></returns>
95. public static bool ExportToCerFile(string subjectName, string cerFileName)
96. {
97. subjectName = "CN=" + subjectName;
98. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
99. store.Open(OpenFlags.ReadWrite);
100. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
101. foreach (X509Certificate2 x509 in storecollection)
102. {
103. if (x509.Subject == subjectName)
104. {
105. Debug.Print(string.Format("certificate name: {0}", x509.Subject));
106. //byte[] pfxByte = x509.Export(X509ContentType.Pfx, password);
107. byte[] cerByte = x509.Export(X509ContentType.Cert);
108. using (FileStream fileStream = new FileStream(cerFileName, FileMode.Create))
109. {
110. // Write the data to the file, byte by byte.
111. for (int i = 0; i < cerByte.Length; i++)
112. fileStream.WriteByte(cerByte[i]);
113. // Set the stream position to the beginning of the file.
114. fileStream.Seek(0, SeekOrigin.Begin);
115. // Read and verify the data.
116. for (int i = 0; i < fileStream.Length; i++)
117. {
118. if (cerByte[i] != fileStream.ReadByte())
119. {
120. fileStream.Close();
121. return false;
122. }
123. }
124. fileStream.Close();
125. }
126. }
127. }
128. store.Close();
129. store = null;
130. storecollection = null;
131. return true;
132. }
133. #endregion
134. #region 从证书中获取信息
135. /// <summary>
136. /// 根据私钥证书得到证书实体，得到实体后可以根据其公钥和私钥进行加解密
137. /// 加解密函数使用DEncrypt的RSACryption类
138. /// </summary>
139. /// <param name="pfxFileName"></param>
140. /// <param name="password"></param>
141. /// <returns></returns>
142. public static X509Certificate2 GetCertificateFromPfxFile(string pfxFileName,
143. string password)
144. {
145. try
146. {
147. return new X509Certificate2(pfxFileName, password, X509KeyStorageFlags.Exportable);
148. }
149. catch (Exception e)
150. {
151. return null;
152. }
153. }
154. /// <summary>
155. /// 到存储区获取证书
156. /// </summary>
157. /// <param name="subjectName"></param>
158. /// <returns></returns>
159. public static X509Certificate2 GetCertificateFromStore(string subjectName)
160. {
161. subjectName = "CN=" + subjectName;
162. X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
163. store.Open(OpenFlags.ReadWrite);
164. X509Certificate2Collection storecollection = (X509Certificate2Collection)store.Certificates;
165. foreach (X509Certificate2 x509 in storecollection)
166. {
167. if (x509.Subject == subjectName)
168. {
169. return x509;
170. }
171. }
172. store.Close();
173. store = null;
174. storecollection = null;
175. return null;
176. }
177. /// <summary>
178. /// 根据公钥证书，返回证书实体
179. /// </summary>
180. /// <param name="cerPath"></param>
181. public static X509Certificate2 GetCertFromCerFile(string cerPath)
182. {
183. try
184. {
185. return new X509Certificate2(cerPath);
186. }
187. catch (Exception e)
188. {
189. return null;
190. }
191. }
192. #endregion
193. }
194. class Program
195. {
196. static string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
197. {
198. RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
199. provider.FromXmlString(xmlPrivateKey);
200. byte[] rgb = Convert.FromBase64String(m_strDecryptString);
201. byte[] bytes = provider.Decrypt(rgb, false);
202. return new UnicodeEncoding().GetString(bytes);
203. }
204. /// <summary>
205. /// RSA加密
206. /// </summary>
207. /// <param name="xmlPublicKey"></param>
208. /// <param name="m_strEncryptString"></param>
209. /// <returns></returns>
210. static string RSAEncrypt(string xmlPublicKey, string m_strEncryptString)
211. {
212. RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
213. provider.FromXmlString(xmlPublicKey);
214. byte[] bytes = new UnicodeEncoding().GetBytes(m_strEncryptString);
215. return Convert.ToBase64String(provider.Encrypt(bytes, false));
216. }
217. static void Main(string[] args)
218. {
219. // 在personal（个人）里面创建一个foo的证书
220. DataCertificate.CreateCertWithPrivateKey("foo", "C:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x64\\makecert.exe");
221. // 获取证书
222. X509Certificate2 c1 = DataCertificate.GetCertificateFromStore("foo");
223. string keyPublic = c1.PublicKey.Key.ToXmlString(false);  // 公钥
224. string keyPrivate = c1.PrivateKey.ToXmlString(true);  // 私钥
225. string cypher = RSAEncrypt(keyPublic, "程序员");  // 加密
226. string plain = RSADecrypt(keyPrivate, cypher);  // 解密
227. Debug.Assert(plain == "程序员");
228. // 生成一个cert文件
229. DataCertificate.ExportToCerFile("foo", "d:\\mycert\\foo.cer");
230. X509Certificate2 c2 = DataCertificate.GetCertFromCerFile("d:\\mycert\\foo.cer");
231. string keyPublic2 = c2.PublicKey.Key.ToXmlString(false);
232. bool b = keyPublic2 == keyPublic;
233. string cypher2 = RSAEncrypt(keyPublic2, "程序员2");  // 加密
234. string plain2 = RSADecrypt(keyPrivate, cypher2);  // 解密, cer里面并没有私钥，所以这里使用前面得到的私钥来解密
235. Debug.Assert(plain2 == "程序员2");
236. // 生成一个pfx， 并且从store里面删除
237. DataCertificate.ExportToPfxFile("foo", "d:\\mycert\\foo.pfx", "111", true);
238. X509Certificate2 c3 = DataCertificate.GetCertificateFromPfxFile("d:\\mycert\\foo.pfx", "111");
239. string keyPublic3 = c3.PublicKey.Key.ToXmlString(false);  // 公钥
240. string keyPrivate3 = c3.PrivateKey.ToXmlString(true);  // 私钥
241. string cypher3 = RSAEncrypt(keyPublic3, "程序员3");  // 加密
242. string plain3 = RSADecrypt(keyPrivate3, cypher3);  // 解密
243. Debug.Assert(plain3 == "程序员3");
244. }
245. }
246. }