0
0

使用OPENSSL实现SM2生成PEM格式公私钥对并用于签名验签

  1.     使用OPENSSL实现SM2生成PEM格式公私钥对并用于签名验签：
  3.     操作系统：centos7.9
  5.     openssl版本：v1.1.1u
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <openssl/ec.h>
  4. #include <openssl/evp.h>
  5. #include <openssl/pem.h>
  6. #include <string.h>
  8. // 全局变量，存储公私钥对的 PEM 格式数据
  9. char *publicKeyPEM = NULL;
  10. char *privateKeyPEM = NULL;
  12. // 辅助函数，用于从 EC_KEY 转换为 EVP_PKEY
  13. EVP_PKEY *EC_KEY_to_EVP_PKEY(EC_KEY *ec_key) {
  14.     EVP_PKEY *pkey = EVP_PKEY_new();
  15.     if (!pkey) {
  16.         fprintf(stderr, "Error: Failed to create EVP_PKEY.\n");
  17.         return NULL;
  18.     }
  20.     if (!EVP_PKEY_set1_EC_KEY(pkey, ec_key)) {
  21.         EVP_PKEY_free(pkey);
  22.         fprintf(stderr, "Error: Failed to set EVP_PKEY with EC_KEY.\n");
  23.         return NULL;
  24.     }
  26.     return pkey;
  27. }
  29. int SM2_sign(const char *sourcefilename, const char *sigfilename) {
  30.     int ret = 0;
  32.     // 从全局变量中获取私钥
  33.     BIO *bio_mem = BIO_new(BIO_s_mem());
  34.     BIO_write(bio_mem, privateKeyPEM, strlen(privateKeyPEM));
  35.     EVP_PKEY *pkey = PEM_read_bio_PrivateKey(bio_mem, NULL, NULL, NULL);
  36.     BIO_free_all(bio_mem);
  37.     if (pkey == NULL) {
  38.         fprintf(stderr, "Error: Unable to read private key from global variable.\n");
  39.         return -1;
  40.     }
  42.     /* compute SM2 signature */
  43.     EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2);
  45.     EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(pkey, NULL);
  46.     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
  47.     EVP_MD_CTX_set_pkey_ctx(mctx, ctx);
  49.     ret = EVP_DigestSignInit(mctx, NULL, EVP_sm3(), NULL, pkey);
  51.     // 打开源文件，计算文件的哈希值
  52.     FILE *fp2 = fopen(sourcefilename, "rb");
  53.     if (fp2 == NULL) {
  54.         fprintf(stderr, "Error: Unable to open source file %s\n", sourcefilename);
  55.         EVP_PKEY_free(pkey);
  56.         return -1;
  57.     }
  58.     int n = 0;
  59.     unsigned char buffer[1024];
  60.     while ((n = fread(buffer, 1, sizeof(buffer), fp2)) > 0) {
  61.         EVP_DigestSignUpdate(mctx, buffer, n);
  62.     }
  63.     fclose(fp2);
  65.     // 计算文件的签名值
  66.     size_t sig_len;
  67.     EVP_DigestSignFinal(mctx, NULL, &sig_len);
  68.     unsigned char *sig = (unsigned char *)malloc(sig_len);
  69.     EVP_DigestSignFinal(mctx, sig, &sig_len);
  71.     // 打印签名值长度和签名值
  72.     printf("签名值长度：%d\n", sig_len);
  73.     printf("签名值：");
  74.     for (int i = 0; i < sig_len; i++) {
  75.         printf("%02x", sig[i]);
  76.     }
  77.     printf("\n");
  79.     // 将文件的签名值和长度写入到输出文件
  80.     FILE *fp3 = fopen(sigfilename, "wb");
  81.     if (fp3 == NULL) {
  82.         fprintf(stderr, "Error: Unable to open signature file %s\n", sigfilename);
  83.         free(sig);
  84.         EVP_MD_CTX_free(mctx);
  85.         EVP_PKEY_CTX_free(ctx);
  86.         EVP_PKEY_free(pkey);
  87.         return -1;
  88.     }
  89.     fwrite(&sig_len, sizeof(sig_len), 1, fp3);
  90.     fwrite(sig, 1, sig_len, fp3);
  91.     fflush(fp3);
  92.     fclose(fp3);
  94.     // 释放资源
  95.     free(sig);
  96.     EVP_MD_CTX_free(mctx);
  97.     EVP_PKEY_CTX_free(ctx);
  98.     EVP_PKEY_free(pkey);
  99.     return 1;
  100. }
  102. int SM2_verify(const char *sourcefile, const char *sigfilename) {
  103.     // 从全局变量中获取公钥
  104.     BIO *bio_mem = BIO_new(BIO_s_mem());
  105.     BIO_write(bio_mem, publicKeyPEM, strlen(publicKeyPEM));
  106.     EVP_PKEY *pkey = NULL;
  107.     EC_KEY *ec_key = PEM_read_bio_EC_PUBKEY(bio_mem, NULL, NULL, NULL);
  108.     BIO_free_all(bio_mem);
  109.     if (ec_key == NULL) {
  110.         fprintf(stderr, "Error: Unable to read public key from global variable.\n");
  111.         return -1;
  112.     }
  113.     
  114.     pkey = EC_KEY_to_EVP_PKEY(ec_key);
  116.     // 打开存储签名值的文件，读出签名值
  117.     FILE *fp2 = fopen(sigfilename, "rb");
  118.     if (fp2 == NULL) {
  119.         fprintf(stderr, "Error: Unable to open signature file %s\n", sigfilename);
  120.         EVP_PKEY_free(pkey);
  121.         return -1;
  122.     }
  123.     size_t sig_len;
  124.     fread(&sig_len, sizeof(sig_len), 1, fp2);
  125.     unsigned char *sig = (unsigned char *)malloc(sig_len);
  126.     fread(sig, 1, sig_len, fp2);
  127.     fclose(fp2);
  129.     /* verify SM2 signature */
  130.     EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2);
  132.     EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(pkey, NULL);
  133.     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
  134.     EVP_MD_CTX_set_pkey_ctx(mctx, ctx);
  136.     EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey);
  138.     // 打开源文件，计算哈希值
  139.     FILE *fp3 = fopen(sourcefile, "rb");
  140.     if (fp3 == NULL) {
  141.         fprintf(stderr, "Error: Unable to open source file %s\n", sourcefile);
  142.         free(sig);
  143.         EVP_MD_CTX_free(mctx);
  144.         EVP_PKEY_CTX_free(ctx);
  145.         EVP_PKEY_free(pkey);
  146.         return -1;
  147.     }
  148.     int n = 0;
  149.     unsigned char buffer[1024];
  150.     while ((n = fread(buffer, 1, sizeof(buffer), fp3)) > 0) {
  151.         EVP_DigestVerifyUpdate(mctx, buffer, n);
  152.     }
  153.     fclose(fp3);
  155.     // 计算签名值，并和源签名值比对，验签
  156.     int ret = 0;
  157.     if ((EVP_DigestVerifyFinal(mctx, sig, sig_len)) != 1) {
  158.         printf("Verify SM2 signature failed!\n");
  159.         ret = 0;
  160.     } else {
  161.         printf("Verify SM2 signature succeeded!\n");
  162.         ret = 1;
  163.     }
  164.     fflush(stdout);
  166.     // 释放资源
  167.     free(sig);
  168.     EVP_MD_CTX_free(mctx);
  169.     EVP_PKEY_CTX_free(ctx);
  170.     EVP_PKEY_free(pkey);
  171.     return ret;
  172. }
  174. // 辅助函数，用于从 EVP_PKEY 中提取 EC_KEY
  175. EC_KEY *EVP_PKEY_to_EC_KEY(EVP_PKEY *pkey) {
  176.     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC) {
  177.         fprintf(stderr, "Error: The key is not an EC key.\n");
  178.         return NULL;
  179.     }
  180.     return EVP_PKEY_get1_EC_KEY(pkey);
  181. }
  183. int main(int argc, const char *argv[]) {
  184.     // 生成 SM2 密钥对
  185.     EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
  186.     EVP_PKEY_paramgen_init(pctx);
  187.     EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2);
  189.     EVP_PKEY *pkey = EVP_PKEY_new();
  190.     EVP_PKEY_keygen_init(pctx);
  191.     EVP_PKEY_keygen(pctx, &pkey);
  193.     // 将公私钥对保存到 PEM 格式字符串
  194.     BIO *bio_mem = BIO_new(BIO_s_mem());
  195.     PEM_write_bio_PrivateKey(bio_mem, pkey, NULL, NULL, 0, NULL, NULL);
  197.     // 获取 PEM 格式字符串
  198.     char *pem_data;
  199.     int len = BIO_get_mem_data(bio_mem, &pem_data); // 获取数据指针和长度
  200.     privateKeyPEM = (char *)malloc(len + 1);
  201.     memcpy(privateKeyPEM, pem_data, len); // 将数据复制到 privateKeyPEM
  202.     privateKeyPEM[len] = '\0';
  203.     printf("privateKeyPEM:\n%s\n", privateKeyPEM);
  205.     // 从 EVP_PKEY 提取出 EC_KEY
  206.     EC_KEY *ec_key = EVP_PKEY_to_EC_KEY(pkey);
  207.     BIO_reset(bio_mem);
  208.     PEM_write_bio_EC_PUBKEY(bio_mem, ec_key);
  209.     //PEM_write_bio_PrivateKey(bio_mem, pkey, NULL, NULL, 0, NULL, NULL);
  210.     
  212.     // 获取 PEM 格式字符串
  213.     len = BIO_get_mem_data(bio_mem, &pem_data); // 获取数据指针和长度
  214.     publicKeyPEM = (char *)malloc(len + 1);
  215.     memcpy(publicKeyPEM, pem_data, len); // 将数据复制到 publicKeyPEM
  216.     publicKeyPEM[len] = '\0';
  217.     printf("publicKeyPEM:\n%s\n", publicKeyPEM);
  218.     BIO_free_all(bio_mem);
  220.     EVP_PKEY_free(pkey);
  221.     EVP_PKEY_CTX_free(pctx);
  223.     // 使用全局变量进行签名和验签
  224.     SM2_sign(argv[1], argv[2]);
  225.     SM2_verify(argv[1], argv[2]);
  227.     // 释放全局变量
  228.     free(publicKeyPEM);
  229.     free(privateKeyPEM);
  231.     return 0;
  232. }

编译参数(我的openssl是自己编译的，且存放在当前目录下)：

  1. gcc -std=gnu99 -g -O0 sm2-pem.c -o sm2-pem -L./lib -lcrypto -I./include -Wl,-rpath=./lib

验证(sig.in为待签名文件， sig.out为存放签名值文件)：

  1. ./sm2-pem sig.in sig.out
  2. privateKeyPEM:
  3. -----BEGIN PRIVATE KEY-----
  4. MIGHAgEAMBMGByqGSM49AgEGCCqBHM9VAYItBG0wawIBAQQggaj9z7vLVE71ab3Q
  5. ax67pps1j4v1eZKJbtRD/OIp0rihRANCAAS8q/3Al0aDdMB3Rl81a/7+MeYyWwYw
  6. L2JFdNYPMljd8jkANchRPc1n5hg8uE7kBMD0PRZO/vU9CPAWRrlbvDn7
  7. -----END PRIVATE KEY-----
  9. publicKeyPEM:
  10. -----BEGIN PUBLIC KEY-----
  11. MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEvKv9wJdGg3TAd0ZfNWv+/jHmMlsG
  12. MC9iRXTWDzJY3fI5ADXIUT3NZ+YYPLhO5ATA9D0WTv71PQjwFka5W7w5+w==
  13. -----END PUBLIC KEY-----
  15. 签名值长度：71
  16. 签名值：3045022100bb13af9eb17f61c3568cef795c618ba052256b0d2e56e15a1143a688bacbbd7702203564eb64157d2403172474cc74473c0cee64436bcbf1fee77b97138b5229734d
  17. Verify SM2 signature succeeded!
标签： 算法 ssl 密码学
本文转载自: https://blog.csdn.net/weixin_38700215/article/details/140740988
版权归原作者 weixin_38700215 所有， 如有侵权，请联系我们删除。
登录后发布评论

“使用OPENSSL实现SM2生成PEM格式公私钥对并用于签名验签”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。