devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于OpenSSL，实现C语言SM2的PKCS8的公私钥编码_在线sm2私钥pkcs8转换工具

作者：Monodyee | 2024-04-05 04:00:47

赞

踩

在线sm2私钥pkcs8转换工具

基于OpenSSL， 实现算法的 Engine专栏

基于OpenSSL， 实现数据编码转换专栏

本专栏订阅后可查看以下文章 

基于OpenSSL，实现C语言RSA的PKCS10的证书请求

基于OpenSSL，实现C语言SM2的PKCS10的证书请求 

基于OpenSSL，实现C语言RSA的PKCS8的公私钥编码

在日常工作中使用密码，就一定会接触到OpenSSL，这个算法库带给我们的东西太多太多，不管是密码算法层面，还有代码框架和使用技巧上更是值得我们去学习和专研。

在接触密码学中，就会涉及到证书，我们在虚拟网络中产生信任，就要有一个信任源，而在密码层面，信任源就是颁布证书的认证中心，从而，证书就是我们可以相信的虚拟对象。

在自己的学习过程中，可以参考网络中，自己创建一个CA中心，自己产生一个证书请求，自己用CA中心颁发一个自签名的证书，这样在验证过程中，就可以验证此证书了。这里的证书请求就是PKCS10，简称为P10。下面我将给出针对C语言产生P10的实例。

主要函数如下：

  1. // 获得内存中公钥的PKCS8编码字符串
  2. // 调用者需要释放ppucDer变量的内存
  3. int lbxx_pkcs8_i2d_sm2_memory_prikey(unsigned char *pucPrikey, unsigned int uiKeylen, unsigned char **ppucDer, unsigned int *puiLen);
  4. // 获得内存中公钥的PKCS8编码字符串
  5. // 调用者需要释放ppucDer变量的内存
  6. int lbxx_pkcs8_i2d_sm2_memory_pubkey(unsigned char *pucPubkey, unsigned int uiKeylen, unsigned char **ppucDer, unsigned int *puiLen);
  7. // 从PKCS8编码中获得私钥
  8. int lbxx_pkcs8_d2i_sm2_prikey(unsigned char *pucDer, unsigned int puiLen, unsigned char *pucPrikey, unsigned int *uiKeylen);
  9. // 从PKCS8编码中获得公钥
  10. int lbxx_pkcs8_d2i_sm2_pubkey(unsigned char *pucDer, unsigned int puiLen, unsigned char *pucPubkey, unsigned int *uiKeylen);
  11. // 获得新密钥私钥的PKCS8编码字符串
  12. // 调用者需要释放ppucDer变量的内存
  13. int lbxx_pkcs8_i2d_sm2_generate_prikey(unsigned char **ppucDer, unsigned int *puiLen);
  14. // 获得新密钥公钥的PKCS8编码字符串
  15. // 调用者需要释放ppucDer变量的内存
  16. int lbxx_pkcs8_i2d_sm2_generate_pubkey(unsigned char **ppucDer, unsigned int *puiLen);

具体调用方式如下，我添加了一些注释，便于理解，这里需要使用带有国密算法SM2/3/4的OpenSSL库编译，否则会报错误。

  1. /****************************************************************
  2.  * FileName:    pkcs8_sm2.c
  3.  * Author:      labixiaoxin1849
  4.  * Date:        2023-04-23
  5.  * Description: SM2 key for pkcs8 algorithm call of OpenSSL
  6.  ****************************************************************/
  7.  
  8. #include <string.h>
  9. #include <openssl/ec.h>
  10. #include <openssl/evp.h>
  11. #include <openssl/x509.h>
  12.  
  13. static unsigned char sPrikey[] = { 
  14. 	0xfc, 0x0b, 0xe0, 0x52, 0x8b, 0x6e, 0xab, 0x7c, 0xf8, 0x92, 0xf0, 0x5c, 0xc2, 0xfe, 0x94, 0xa0, 
  15. 	0x47, 0x1a, 0x12, 0x8b, 0x29, 0xb5, 0xcb, 0xb8, 0x92, 0x99, 0x0c, 0x7f, 0x4c, 0x2a, 0x2b, 0x7b
  16. };
  17. static unsigned int sPrikeyLen = 32;
  18.  
  19.  
  20. static unsigned char sPubkey[] = {
  21. 	0x04, 0x90, 0x0b, 0x0d, 0x87, 0xc0, 0xbd, 0x5d, 0x57, 0x60, 0x7a, 0x2a, 0xe1, 0x43, 0x14, 0x4d, 
  22. 	0xa4, 0xe1, 0x2f, 0xe5, 0x9d, 0xbd, 0x02, 0x2c, 0xc3, 0x97, 0x8a, 0x71, 0xb1, 0x52, 0xc6, 0xf2, 
  23. 	0xb4, 0x52, 0x14, 0xaa, 0x1e, 0xee, 0x78, 0x5f, 0x1f, 0xe8, 0x5b, 0x44, 0x63, 0x68, 0x2b, 0x6e, 
  24. 	0x07, 0x80, 0x7a, 0xfd, 0x61, 0x9e, 0xca, 0x94, 0xcb, 0x41, 0x7d, 0xe7, 0xe4, 0x49, 0xbf, 0x3c, 
  25. 	0xda,
  26. };
  27. static unsigned int sPubkeyLen = 65;
  28.  
  29.  
  30. // 获得内存中公钥的PKCS8编码字符串
  31. // 调用者需要释放ppucDer变量的内存
  32. int lbxx_pkcs8_i2d_sm2_memory_prikey(unsigned char *pucPrikey, unsigned int uiKeylen, unsigned char **ppucDer, unsigned int *puiLen)
  33. {
  34. 	int ret = -1;
  35. 	EC_KEY *pSM2 = NULL;
  36. 	EVP_PKEY *pKey = NULL;
  37. 	PKCS8_PRIV_KEY_INFO *p8 = NULL;
  38. 	
  39. 	do{
  40. 		/* 根据nid创建EC_KEY */
  41. 		pSM2 = EC_KEY_new_by_curve_name(EVP_PKEY_SM2);
  42. 		if (!pSM2) {
  43. 			break;
  44. 		}
  45. 		/* 从内存设置私钥 */
  46. 		ret = EC_KEY_oct2priv(pSM2, pucPrikey, uiKeylen);
  47. 		if (ret != 1) {
  48. 			break;
  49. 		}
  50.  
  51. 		const EC_GROUP *ecGroup = EC_KEY_get0_group(pSM2);
  52. 		EC_POINT *ecPubPoint = EC_POINT_new(ecGroup);
  53. 		const BIGNUM *ecPriKey = EC_KEY_get0_private_key(pSM2);
  54. 		ret = EC_POINT_mul(ecGroup, ecPubPoint, ecPriKey, NULL, NULL, NULL);
  55. 		if (ret) {
  56. 			EC_KEY_set_public_key(pSM2, ecPubPoint);
  57. 		}
  58. 		EC_POINT_free(ecPubPoint);
  59.  
  60. 		/* 创建EVP_PKEY并设置密钥 */
  61. 		pKey = EVP_PKEY_new();
  62. 		if (!pKey) {
  63. 			break;
  64. 		}
  65. 		if (!EVP_PKEY_set1_EC_KEY(pKey, pSM2)){
  66. 			break;
  67. 		}
  68. 		
  69. 		/* EVP_PKEY转为PKCS8 */
  70. 		p8 = EVP_PKEY2PKCS8(pKey);
  71. 		if (!p8) {
  72. 			break;
  73. 		}
  74. 		*puiLen = i2d_PKCS8_PRIV_KEY_INFO(p8, ppucDer);
  75. 		
  76. 		ret = 0;
  77. 		
  78. 	}while(0);
  79. 	
  80. 	EC_KEY_free(pSM2);
  81. 	EVP_PKEY_free(pKey);
  82. 	PKCS8_PRIV_KEY_INFO_free(p8);
  83. 	
  84. 	return ret;
  85. }
  86.  
  87. // 获得内存中公钥的PKCS8编码字符串
  88. // 调用者需要释放ppucDer变量的内存
  89. int lbxx_pkcs8_i2d_sm2_memory_pubkey(unsigned char *pucPubkey, unsigned int uiKeylen, unsigned char **ppucDer, unsigned int *puiLen)
  90. {
  91. 	int ret = -1;
  92. 	EC_KEY *pSM2 = NULL;
  93. 	EVP_PKEY *pKey = NULL;
  94. 	
  95. 	do{
  96. 		/* 根据nid创建EC_KEY */
  97. 		pSM2 = EC_KEY_new_by_curve_name(EVP_PKEY_SM2);
  98. 		if (!pSM2) {
  99. 			break;
  100. 		}
  101. 		/* 从内存设置公钥 */
  102. 		const unsigned char *pp = pucPubkey;
  103. 		if (!o2i_ECPublicKey(&pSM2, &pp, (long)uiKeylen)) {
  104. 			break;
  105. 		}
  106.  
  107. 		/* 创建EVP_PKEY并设置密钥 */
  108. 		pKey = EVP_PKEY_new();
  109. 		if (!pKey) {
  110. 			break;
  111. 		}
  112. 		if (!EVP_PKEY_set1_EC_KEY(pKey, pSM2)){
  113. 			break;
  114. 		}
  115. 		
  116. 		/* EVP_PKEY转为PKCS8 */
  117. 		*puiLen = i2d_PUBKEY(pKey, ppucDer);
  118. 		
  119. 		ret = 0;
  120. 		
  121. 	}while(0);
  122. 	
  123. 	EC_KEY_free(pSM2);
  124. 	EVP_PKEY_free(pKey);
  125. 	
  126. 	return ret;
  127. }
  128.  
  129. // 从PKCS8编码中获得私钥
  130. int lbxx_pkcs8_d2i_sm2_prikey(unsigned char *pucDer, unsigned int puiLen, unsigned char *pucPrikey, unsigned int *uiKeylen)
  131. {
  132. 	EC_KEY *pSM2 = NULL;
  133. 	EVP_PKEY *pKey = NULL;
  134. 	unsigned char *buf = NULL;
  135. 	unsigned int len = 0;
  136. 	
  137. 	pKey = d2i_AutoPrivateKey(NULL, (const unsigned char **)&pucDer, puiLen);
  138. 	if(!pKey) {
  139. 		return 1;
  140. 	}
  141. 	if (EVP_PKEY_id(pKey) != EVP_PKEY_EC && EVP_PKEY_id(pKey) != EVP_PKEY_SM2){
  142. 		return 1;
  143. 	}
  144. 	pSM2 = (EC_KEY *)EVP_PKEY_get0(pKey);
  145. 	if(!pSM2) {
  146. 		return 1;
  147. 	}
  148. 	len = EC_KEY_priv2buf(pSM2, &buf);
  149. 	if(*uiKeylen < len) {
  150. 		return 1;
  151. 	}
  152. 	memcpy(pucPrikey, buf, len);
  153. 	*uiKeylen = len;
  154. 	
  155. 	return 0;
  156. }
  157.  
  158. // 从PKCS8编码中获得公钥
  159. int lbxx_pkcs8_d2i_sm2_pubkey(unsigned char *pucDer, unsigned int puiLen, unsigned char *pucPubkey, unsigned int *uiKeylen)
  160. {
  161. 	int len = 0;
  162. 	unsigned char *buf = NULL;
  163. 	EVP_PKEY *pKey = NULL;
  164. 	
  165. 	pKey = d2i_PUBKEY(NULL, (const unsigned char **)&pucDer, puiLen);
  166. 	if(!pKey) {
  167. 		return 1;
  168. 	}
  169. 	len = i2o_ECPublicKey((EC_KEY *)EVP_PKEY_get0(pKey), &buf);
  170. 	if(*uiKeylen < len) {
  171. 		return 1;
  172. 	}
  173. 	memcpy(pucPubkey, buf, len);
  174. 	*uiKeylen = len;
  175. 	
  176. 	return 0;
  177. }
  178.  
  179. // 获得新密钥私钥的PKCS8编码字符串
  180. // 调用者需要释放ppucDer变量的内存
  181. int lbxx_pkcs8_i2d_sm2_generate_prikey(unsigned char **ppucDer, unsigned int *puiLen)
  182. {
  183. 	int ret = -1;
  184. 	EVP_PKEY *pKey = NULL;
  185. 	EVP_PKEY_CTX *pkey_ctx = NULL;
  186. 	PKCS8_PRIV_KEY_INFO *p8 = NULL;
  187.  
  188. 	do{
  189. 		/* 
  190. 		 * 创建ECC类型的EVP用于生成SM2密钥对
  191. 		 * 使用ECC类型是因为SM2操作函数中并没有提供生成算法
  192. 		 * 在生成密钥对时，设置group同样可以产生SM2类型密钥对
  193. 		 */ 
  194. 		pkey_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
  195. 		if (!pkey_ctx) {
  196. 			break;
  197. 		}
  198. 		/* 必须调用init，内部设置操作类型 */
  199. 		if (EVP_PKEY_keygen_init(pkey_ctx) <= 0){
  200. 			break;
  201. 		}
  202. 		/* 设置SM2类型GROUP */
  203. 		EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pkey_ctx, EVP_PKEY_SM2);
  204. 		/* 获取密钥对,结果存放于pKey中 */
  205. 		if (EVP_PKEY_keygen(pkey_ctx, &pKey) <= 0) {
  206. 			break;
  207. 		}
  208.  
  209. 		/* EVP_PKEY转为PKCS8 */
  210. 		p8 = EVP_PKEY2PKCS8(pKey);
  211. 		if (!p8) {
  212. 			break;
  213. 		}
  214. 		*puiLen = i2d_PKCS8_PRIV_KEY_INFO(p8, ppucDer);
  215. 		
  216. 		ret = 0;
  217. 		
  218. 	}while(0);
  219. 	
  220. 	EVP_PKEY_free(pKey);
  221. 	EVP_PKEY_CTX_free(pkey_ctx);
  222. 	PKCS8_PRIV_KEY_INFO_free(p8);
  223.  
  224. 	return ret;
  225. }
  226.  
  227. // 获得新密钥公钥的PKCS8编码字符串
  228. // 调用者需要释放ppucDer变量的内存
  229. int lbxx_pkcs8_i2d_sm2_generate_pubkey(unsigned char **ppucDer, unsigned int *puiLen)
  230. {
  231. 	int ret = -1;
  232. 	EVP_PKEY *pKey = NULL;
  233. 	EVP_PKEY_CTX *pkey_ctx = NULL;
  234.  
  235. 	do{
  236. 		/* 
  237. 		 * 创建ECC类型的EVP用于生成SM2密钥对
  238. 		 * 使用ECC类型是因为SM2操作函数中并没有提供生成算法
  239. 		 * 在生成密钥对时，设置group同样可以产生SM2类型密钥对
  240. 		 */ 
  241. 		pkey_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
  242. 		if (!pkey_ctx) {
  243. 			break;
  244. 		}
  245. 		/* 必须调用init，内部设置操作类型 */
  246. 		if (EVP_PKEY_keygen_init(pkey_ctx) <= 0){
  247. 			break;
  248. 		}
  249. 		/* 设置SM2类型GROUP */
  250. 		EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pkey_ctx, EVP_PKEY_SM2);
  251. 		/* 获取密钥对,结果存放于pKey中 */
  252. 		if (EVP_PKEY_keygen(pkey_ctx, &pKey) <= 0) {
  253. 			break;
  254. 		}
  255.  
  256. 		/* EVP_PKEY转为PKCS8 */
  257. 		*puiLen = i2d_PUBKEY(pKey, ppucDer);
  258. 		
  259. 		ret = 0;
  260. 		
  261. 	}while(0);
  262. 	
  263. 	EVP_PKEY_free(pKey);
  264. 	EVP_PKEY_CTX_free(pkey_ctx);
  265.  
  266. 	return ret;
  267. }
  268.  
  269. int main(int argc, char *argv[])
  270. {
  271. 	int ret = 0;
  272. 	// 必须为NULL
  273. 	unsigned char *pucDer = NULL;
  274. 	unsigned int uiDerlen = 0;
  275. 	unsigned char buf[128] = { 0 };
  276. 	unsigned int len = sizeof(buf);
  277. 	
  278. 	ret = lbxx_pkcs8_i2d_sm2_generate_prikey(&pucDer, &uiDerlen);
  279. 	if(ret != 0) {
  280. 		printf("call lbxx_pkcs8_i2d_sm2_generate_prikey() error\n");
  281. 		return 1;
  282. 	}
  283. 	OPENSSL_free(pucDer);
  284. 	pucDer = NULL;
  285. 	
  286. 	ret = lbxx_pkcs8_i2d_sm2_generate_pubkey(&pucDer, &uiDerlen);
  287. 	if(ret != 0) {
  288. 		printf("call lbxx_pkcs8_i2d_sm2_generate_pubkey() error\n");
  289. 		return 1;
  290. 	}
  291. 	OPENSSL_free(pucDer);
  292. 	pucDer = NULL;
  293. 	
  294. 	ret = lbxx_pkcs8_i2d_sm2_memory_prikey(sPrikey, sPrikeyLen, &pucDer, &uiDerlen);
  295. 	if(ret != 0) {
  296. 		printf("call lbxx_pkcs8_i2d_sm2_memory_prikey() error\n");
  297. 		return 1;
  298. 	}
  299. 	ret = lbxx_pkcs8_d2i_sm2_prikey(pucDer, uiDerlen, buf, &len);
  300. 	if(ret != 0) {
  301. 		printf("call lbxx_pkcs8_d2i_sm2_prikey() error\n");
  302. 		return 1;
  303. 	}
  304. 	if(sPrikeyLen != len || memcmp(sPrikey, buf, len) != 0) {
  305. 		printf("sm2 pkcs8 private key encode or decode error!!!!\n");
  306. 		return 1;
  307. 	}
  308. 	OPENSSL_free(pucDer);
  309. 	pucDer = NULL;
  310. 	
  311. 	memset(buf, 0x00, sizeof(buf));
  312. 	len = sizeof(buf);
  313. 	ret = lbxx_pkcs8_i2d_sm2_memory_pubkey(sPubkey, sPubkeyLen, &pucDer, &uiDerlen);
  314. 	if(ret != 0) {
  315. 		printf("call lbxx_pkcs8_i2d_sm2_memory_pubkey() error\n");
  316. 		return 1;
  317. 	}
  318. 	ret = lbxx_pkcs8_d2i_sm2_pubkey(pucDer, uiDerlen, buf, &len);
  319. 	if(ret != 0) {
  320. 		printf("call lbxx_pkcs8_d2i_sm2_pubkey() error\n");
  321. 		return 1;
  322. 	}
  323. 	if(sPubkeyLen != len || memcmp(sPubkey, buf, len) != 0) {
  324. 		printf("sm2 pkcs8 public key encode or decode error!!!!\n");
  325. 		return 1;
  326. 	}
  327. 	OPENSSL_free(pucDer);
  328. 	pucDer = NULL;
  329. 	
  330. 	printf("sm2 pkcs8 test success!!!\n");
  331. 	return 0;
  332. }

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/363208
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号