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

gmssl国密sm2(生成密钥对-私钥签字-证书验签)_gmssl sm2身份验证

作者：菜鸟追梦旅行 | 2024-02-20 03:21:48

赞

踩

gmssl sm2身份验证

生成密钥对：

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include "e_os.h"
  5. #include "sm2ToOC.h"
  6. #include "string.h"
  7. # include <openssl/bn.h>
  8. # include <openssl/ec.h>
  9. # include <openssl/evp.h>
  10. # include <openssl/rand.h>
  11. # include <openssl/engine.h>
  12. # include <openssl/sm2.h>
  13. # include "sm2_lcl.h"
  14. # include "pkcs12.h"
  15. #include <openssl/pem.h>
  16. #include "ec/ec_lcl.h"
  17. #include "bn/bn_lcl.h"
  18.  
  19. int genkey()
  20. {
  21.     EC_KEY *keypair = NULL;
  22.     EC_GROUP *group1 = NULL;
  23.  
  24.     keypair = EC_KEY_new();
  25.     if(!keypair) {
  26.         printf("Failed to Gen Key");
  27.         exit(1);
  28.     }
  29.  
  30.     group1 = EC_GROUP_new_by_curve_name(NID_sm2p256v1);
  31.  
  32.     if(group1 == NULL){
  33.         printf("Failed to Gen Key");
  34.         exit(1);
  35.     }
  36.  
  37.     int ret1 = EC_KEY_set_group(keypair, group1);
  38.     if(ret1 != 1){
  39.         printf("Failed to Gen Key");
  40.         exit(1);
  41.     }
  42.  
  43.     int ret2 = EC_KEY_generate_key(keypair);
  44.     if(ret2 != 1){
  45.         printf("Failed to Gen Key");
  46.         exit(1);
  47.     }
  48.  
  49.     size_t pri_len;
  50.     size_t pub_len;
  51.     char *pri_key = NULL;
  52.     char *pub_key = NULL;
  53.  
  54. 	BIO *pri = BIO_new(BIO_s_mem());
  55. 	BIO *pub = BIO_new(BIO_s_mem());
  56.  
  57. 	PEM_write_bio_ECPrivateKey(pri, keypair, NULL, NULL, 0, NULL, NULL);
  58. 	PEM_write_bio_EC_PUBKEY(pub, keypair);
  59.  
  60.     BIO *bio_out = BIO_new_file("private.key", "w");
  61. 	PEM_write_bio_ECPrivateKey(bio_out, keypair, NULL, NULL, 0, NULL, NULL);
  62.     BIO_free(bio_out);
  63.     bio_out = BIO_new_file("public.key", "w");
  64. 	PEM_write_bio_EC_PUBKEY(bio_out, keypair);
  65.     BIO_free(bio_out);
  66.  
  67. 	pri_len = BIO_pending(pri);
  68. 	pub_len = BIO_pending(pub);
  69.  
  70. 	pri_key = (char *)malloc(pri_len + 1);
  71. 	pub_key = (char *)malloc(pub_len + 1);
  72.  
  73. 	BIO_read(pri, pri_key, pri_len);
  74. 	BIO_read(pub, pub_key, pub_len);
  75.  
  76. 	pri_key[pri_len] = '\0';
  77. 	pub_key[pub_len] = '\0';
  78.  
  79. 	EC_KEY_free(keypair);
  80. 	BIO_free_all(pub);
  81. 	BIO_free_all(pri);
  82. 	
  83. 	free(pri_key);
  84. 	free(pub_key);
  85.     
  86.     return 1;
  87. }
  88.  
  89. void main(void)
  90. {
  91.     genkey();
  92. }

签字验签：

  1.  
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <openssl/ssl.h>
  5. #include <openssl/err.h>
  6. #include <openssl/pem.h>
  7. #include <openssl/conf.h>
  8. #include <openssl/x509v3.h>
  9.  
  10. #include <openssl/bn.h>
  11. #include <openssl/crypto.h>
  12. #include <openssl/evp.h>
  13. #include <openssl/ecdsa.h>
  14. #include <openssl/sha.h>
  15. #include <openssl/asn1.h>
  16. #include <openssl/x509.h>
  17. #include <openssl/objects.h>
  18. #include <openssl/buffer.h>
  19. #include <openssl/sm2.h>
  20.  
  21. #include <apps/apps.h>
  22.  
  23. int bio_to_mem(unsigned char **out, int maxlen, BIO *in)
  24. {
  25.     BIO *mem;
  26.     int len, ret;
  27.     unsigned char tbuf[1024];
  28.  
  29.     mem = BIO_new(BIO_s_mem());
  30.     if (mem == NULL)
  31.         return -1;
  32.     for (;;) {
  33.         if ((maxlen != -1) && maxlen < 1024)
  34.             len = maxlen;
  35.         else
  36.             len = 1024;
  37.         len = BIO_read(in, tbuf, len);
  38.         if (len < 0) {
  39.             BIO_free(mem);
  40.             return -1;
  41.         }
  42.         if (len == 0)
  43.             break;
  44.         if (BIO_write(mem, tbuf, len) != len) {
  45.             BIO_free(mem);
  46.             return -1;
  47.         }
  48.         maxlen -= len;
  49.  
  50.         if (maxlen == 0)
  51.             break;
  52.     }
  53.     ret = BIO_get_mem_data(mem, (char **)out);
  54.     BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY);
  55.     BIO_free(mem);
  56.     return ret;
  57. }
  58.  
  59.  
  60. static int sm2utl_sign(const EVP_MD *md, BIO *in, BIO *out, const char *id,
  61. 	ENGINE *e, EC_KEY *ec_key, int sign)
  62. {
  63. 	int ret = 0;
  64. 	EVP_MD_CTX *md_ctx = NULL;
  65. 	ECDSA_SIG *sig = NULL;
  66. 	unsigned char buf[1024];
  67. 	size_t siz = sizeof(buf);
  68. 	unsigned int ulen = sizeof(buf);
  69. 	int len;
  70.  
  71. 	printf("sm2utl_sign\n");
  72.  
  73. 	if (!(md_ctx = EVP_MD_CTX_new())
  74. 		|| !EVP_DigestInit_ex(md_ctx, md, e)
  75. 		|| !SM2_compute_id_digest(md, id, strlen(id), buf, &siz, ec_key)
  76. 		|| !EVP_DigestUpdate(md_ctx, buf, siz)) {
  77. 	}
  78. 	while ((len = BIO_read(in, buf, sizeof(buf))) > 0) {
  79. 		if (!EVP_DigestUpdate(md_ctx, buf, len)) {
  80. 		}
  81. 	}
  82. 	if (!EVP_DigestFinal_ex(md_ctx, buf, &ulen)) {
  83. 	}
  84. 	len = (int)ulen;
  85.  
  86. 	if (sign) {
  87. 		unsigned char *p = buf;
  88. 		if (!(sig = SM2_do_sign(buf, len, ec_key))
  89. 			|| (len = i2d_ECDSA_SIG(sig, &p)) <= 0) {
  90. 		}
  91. 	}
  92. 	if (BIO_write(out, buf, len) != len) {
  93. 	}
  94.  
  95. 	ret = 1;
  96. end:
  97. 	EVP_MD_CTX_free(md_ctx);
  98. 	ECDSA_SIG_free(sig);
  99. 	return ret;
  100. }
  101.  
  102. static int sm2utl_verify(const EVP_MD *md, BIO *in, BIO *out, BIO *sig,
  103. 	const char *id, ENGINE *e, EC_KEY *ec_key)
  104. {
  105. 	int ret = 0;
  106. 	EVP_MD_CTX *md_ctx = NULL;
  107. 	unsigned char *sigbuf = NULL;
  108. 	unsigned char buf[1024];
  109. 	size_t siz = sizeof(buf);
  110. 	unsigned int ulen = sizeof(buf);
  111. 	int siglen, len;
  112.  
  113. 	siglen = bio_to_mem(&sigbuf, 256, sig);
  114. 	if (siglen < 0) {
  115. 	}
  116.  
  117. 	if (!(md_ctx = EVP_MD_CTX_new())
  118. 		|| !EVP_DigestInit_ex(md_ctx, md, e)
  119. 		|| !SM2_compute_id_digest(md, id, strlen(id), buf, &siz, ec_key)
  120. 		|| !EVP_DigestUpdate(md_ctx, buf, siz)) {
  121. 	}
  122. 	while ((len = BIO_read(in, buf, sizeof(buf))) > 0) {
  123. 		if (!EVP_DigestUpdate(md_ctx, buf, len)) {
  124. 		}
  125. 	}
  126. 	siz = sizeof(buf);
  127. 	if (!EVP_DigestFinal_ex(md_ctx, buf, &ulen)) {
  128. 	}
  129. 	/* SM2_verify() can check no suffix on signature */
  130. 	ret = SM2_verify(NID_undef, buf, ulen, sigbuf, siglen, ec_key);
  131. 	if (ret == 1) {
  132. 		printf("Signature Verification Successful\n");
  133. 	} else {
  134. 		printf("Signature Verification Failure\n");
  135. 		ret = 0;
  136. 	}
  137.  
  138. end:
  139. 	OPENSSL_free(sigbuf);
  140. 	EVP_MD_CTX_free(md_ctx);
  141. 	return ret;
  142. }
  143.  
  144. int signature(char *msg)
  145. {
  146.     BIO *in = NULL, *out = NULL, *sig = NULL;
  147.     char *keyfile = NULL;
  148.     EVP_PKEY *pkey = NULL;
  149.     EC_KEY *ec_key = NULL;
  150.     int keyform = FORMAT_PEM;
  151.     const EVP_MD *md = EVP_sm3();
  152.     
  153.     in  =  BIO_new_file("text.txt", "rb"); 
  154.     out = BIO_new_file("text.sig", "wb");
  155.     
  156.     BIO  * key  =  NULL;
  157.     key = BIO_new_file("private.key", "r");
  158.     pkey=PEM_read_bio_PrivateKey(key, NULL, 0, NULL);
  159.  
  160. 	if (!(ec_key = EVP_PKEY_get0_EC_KEY(pkey))
  161. 		|| !EC_KEY_is_sm2p256v1(ec_key)) {
  162. 		printf("Invalid key type\n");
  163. 		return -1;
  164. 	}
  165.     
  166.     sm2utl_sign(md, in, out, "1234567812345678", 0, ec_key, 1);
  167.  
  168.     return 1;
  169. }
  170.  
  171. int verify_sig(void)
  172. {
  173.     const EVP_MD *md = EVP_sm3();
  174.     BIO *in = NULL, *out = NULL, *sig = NULL;
  175.     
  176.     in  =  BIO_new_file("text.txt", "rb"); 
  177.     sig = BIO_new_file("text_1.sig", "rb");
  178.  
  179.     //FILE *fp = fopen("public_cert.pem", "r");
  180.     //X509 *cert = PEM_read_X509(fp, NULL, NULL, NULL);
  181.     FILE *fp = fopen("public.cer", "r");
  182.     X509 *cert = d2i_X509_fp(fp, NULL);
  183.  
  184.     EVP_PKEY *evk = X509_get_pubkey(cert);
  185.     EC_KEY *ec_key=EVP_PKEY_get0_EC_KEY(evk);
  186.     if (1==sm2utl_verify(md, in, out, sig, "1234567812345678", 0, ec_key))
  187.     {
  188.         printf("verify success\n");
  189.     }
  190.     else
  191.     {
  192.         printf("verify fail\n");
  193.     }
  194.     return 1;
  195. }
  196.  
  197. void main(void)
  198. {
  199.     signature("1234567890123456");
  200.     //verify_sig();
  201. }

SM2签名及验证过程中，并不是直接计算被签名数据的摘要，而是要经过专门的预处理过程得到摘要。此过程包含两个阶段的摘要计算：

1）Z = SM3(ENTL || ID || a || b || x_G || y_G || x_A || y_A)

ENTL || ID || a || b || x_G || y_G || x_A || y_A表示签名元素数据的拼接（级联）。

其中，ENTL 是签名者 ID 的位长度，占两个字节；ID是签名者ID，国密标准里定义的缺省签名者ID用UFT_8字符串表示是“1234567812345678”，用十六进制表示是0x31323334353637383132333435363738。所以在缺省情况下，ENTL值是0x0080.a, b, x_G, y_G 都是SM2算法标准中给定的值。a和b是椭圆曲线y=x+ax+b的系数，x_G, y_G是SM2算法选定的基点的坐标。上述参数都是固定值：a=0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC

b=0x28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93

x_G= 0x32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7

y_G=0xBC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0

x_A || y_A就是公钥两部分值的拼接，注意，没有0x04的部分;将上述各元素拼接值进行SM3运算，得到结果Z。2) H=SM3(Z || M)

Z是第一步运算得到的摘要，M是签名的原文，将两者拼接，再进行SM3摘要运算。得到的摘要就是预处理得到的结果，将用于后续的签名及验证运算。

参考：

基于Gmssl的SM2加解密算法Demo - 程序员大本营
GitHub - guanzhi/GmSSL: 支持国密SM2/SM3/SM4/SM9/SSL的密码工具箱

百度安全验证

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

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

  

闽ICP备14008679号