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

基于 gmssl实现的sm2加密（C++）_gmssl sm2

作者：IT小白 | 2024-04-08 21:32:52

赞

踩

gmssl sm2

项目中需要用到sm2加密，在网上搜索了一下相关的库，发现只有openssl和gmssl这两个库可以用，于是基于gmssl库做了封装，gmssl的版本是：GmSSL 2.5.4 - OpenSSL 1.1.0d  19 Jun 2019

搞这个库的确要费不少功夫，现在分享出来给需要的人。目前我是用在linux环境中，因此编译成linux动态库，并且屏蔽相关库的头文件和符号，只暴露sm2加解密相关的接口符号，gmssl库通过静态库的方式引用。

关于sm2加密有几个比较重要的参数，第一个是椭圆曲线参数，第二个是密文编码方式，第三个是哈希算法，目前我们用的都是固定的参数，所以封装的时候没有提供参数选择这些功能，需要的可以自行扩展。下面的sm2加密相关参数为：使用默认的椭圆曲线参数(sm2p256v1)，ASN.1/DER编码方式(C1|C3|C2编码方式) ，哈希（杂凑）算法使用sm3

一些初学者可能还不大懂怎么引用外部库，我把我自己的工程上传到github上了，可以作为参考，gmssl库我已经编译好，生成的是静态库，但是gmssl库的编译其实还是应该用自己的机器去编译的，因为自己拿我编译好的静态库去用的话，不同的linux版本有可能不兼容。gmssl库文件我也放在该工程下了，可以不用去官网找，文件为：GmSSL-master.zip。 github地址：qingfeng1992/gmutil: 基于gmssl加密库封装sm2加解密方法 (github.com)

可以直接使用git clone git@github.com:qingfeng1992/gmutil.git 拉取代码

下载下来后请先看README.txt后再操作

gmutil.h头文件：

  1. #ifndef __GM_UTIL_H__
  2. #define __GM_UTIL_H__
  3. #include <string>
  4. using namespace std;
  5.  
  6. #ifdef _WIN32
  7. #define UNIX_EXPORT
  8. #else
  9. #define UNIX_EXPORT __attribute__((visibility("default")))
  10. #endif
  11. // namespace GM
  12. //{
  13.  
  14. // 错误码
  15. enum EGMErrorCode
  16. {
  17.     GM_UTIL_CODE_OK = 0,
  18.     GM_UTIL_CODE_CREATE_EV_KEY_FAILED, // 密钥解析失败
  19.     GM_UTIL_CODE_SM2_ENCRYPT_FAILED,   // SM2加密失败
  20.     GM_UTIL_CODE_SM2_DECRYPT_FAILED,   // SM2解密失败
  21.     GM_UTIL_CODE_NOT_SM2P256V1,        // 不是默认的sm2p256v1椭圆曲线参数
  22.     GM_UTIL_CODE_INIT_BIO_FAILED,      // 初始化BIO失败
  23.     GM_UTIL_CODE_CIPHER_TEXT_TO_BIO_FAILED,      // 加密数据存储到BIO失败
  24.     GM_UTIL_CODE_BIO_DATA_TO_MEM_FAILED,      // BIO数据转存到缓冲区失败
  25.     GM_UTIL_CODE_BIO_DATA_TO_CIPHER_TEXT_FAILED,      // BIO数据转成Ciphertext结构失败
  26. };
  27. extern "C"
  28. {
  29.     // 从文件中读入公钥/私钥数据到string中,失败返回空字符串
  30.     UNIX_EXPORT string GmReadKeyFromFile(string strFileName);
  31.  
  32.     /**
  33.      * @brief sm2加密，使用默认的椭圆曲线参数(NID_sm2p256v1)，ASN.1/DER编码方式(C1|C3|C2编码方式) ，哈希（杂凑）算法使用sm3
  34.      * @param strPubKey 公钥数据
  35.      * @param strIn 需要加密的数据
  36.      * @param strCiphertext 密文,加密后的密文不是可见字符
  37.      * @return 返回GM_UTIL_ERR_OK表示加密成功，否则失败，具体见EGMErrorCode定义
  38.      */
  39.     UNIX_EXPORT int GmSm2Encrypt(string strPubKey, const string &strIn, string &strCiphertext);
  40.  
  41.     /**
  42.      * @brief sm2解密，使用默认的椭圆曲线参数(NID_sm2p256v1)，ASN.1/DER编码方式(C1|C3|C2编码方式)，哈希（杂凑）算法使用sm3
  43.      * @param strPubKeyFile 私钥数据
  44.      * @param strCiphertext 需要解密的数据(不是可见字符)
  45.      * @param strOut 解密后的明文
  46.      * @return 返回GM_UTIL_ERR_OK表示解密成功，否则失败，具体见EGMErrorCode定义
  47.      */
  48.     UNIX_EXPORT int GmSm2Decrypt(string strPriKey, const string &strCiphertext, string &strOut);
  49.  
  50.     // 将二进制数据转换成十六进制字符串
  51.     UNIX_EXPORT string GmByte2HexStr(const string &data, bool bLowerCase = true);
  52.  
  53.     // 将十六进制字符串转换成二进制
  54.     UNIX_EXPORT string GmHexStr2Byte(const string& hex, bool bLowerCase = true);
  55. }
  56.  
  57. // } // namespace GM
  58. #endif // end __GM_UTIL_H__

gmutil.cpp文件：

  1. #include "gmutil.h"
  2. #include <iostream>
  3. #include<fstream>
  4. #include<sstream>
  5. #include <stdio.h>
  6. #include <openssl/evp.h>
  7. #include <openssl/pem.h>
  8. #include <openssl/sm2.h>
  9. #include <openssl/bio.h>
  10. //using namespace GM;
  11.  
  12. /**
  13.  * @brief 使用公钥/私钥数据获取EV_KEY对象
  14.  * @param key 公钥/私钥数据
  15.  * @param is_public 是否公钥
  16.  * @return 失败返回NULL
  17.  */
  18. static EC_KEY *CreateEC(unsigned char *key, int is_public)
  19. {
  20.     EC_KEY *ec_key = NULL;
  21.     BIO *keybio = NULL;
  22.     keybio = BIO_new_mem_buf(key, -1);
  23.  
  24.     if (keybio == NULL) {
  25.         printf("%s", "[BIO_new_mem_buf]->key len=%d,Failed to Get Key", strlen((char *) key));
  26.         return NULL;
  27.     }
  28.  
  29.     if (is_public) {
  30.         ec_key = PEM_read_bio_EC_PUBKEY(keybio, NULL, NULL, NULL);
  31.     } else {
  32.         ec_key = PEM_read_bio_ECPrivateKey(keybio, NULL, NULL, NULL);
  33.     }
  34.  
  35.     if (ec_key == NULL) {
  36.         printf("Failed to Get Key");
  37.         BIO_free_all(keybio);
  38.         return NULL;
  39.     }
  40.  
  41.     BIO_free_all(keybio); // 此处是不是要free?
  42.     return ec_key;
  43. }
  44.  
  45. int GmSm2Encrypt(string strPubKey, const string &strIn, string &strCiphertext)
  46. {
  47.     EC_KEY *evKey = CreateEC((unsigned char *)strPubKey.c_str(), 1);
  48.     if (NULL == evKey)
  49.     {
  50.         return GM_UTIL_CODE_CREATE_EV_KEY_FAILED;
  51.     }
  52.     
  53.     // 目前只支持默认的sm2p256v1椭圆曲线参数
  54.     if (!EC_KEY_is_sm2p256v1(evKey))
  55.     {
  56.         EC_KEY_free(evKey);
  57.         return GM_UTIL_CODE_NOT_SM2P256V1;
  58.     }
  59.  
  60.     // 加密后的密文会比明文长97字节
  61.     unsigned char *buff = NULL;
  62.     size_t outLen = 0;
  63.     SM2CiphertextValue *cval = NULL;
  64.     size_t mlen, clen;
  65.     unsigned char *p;
  66.  
  67.     if (NULL == (cval = SM2_do_encrypt(EVP_sm3(), (const unsigned char *)strIn.c_str(), strIn.size(), evKey)))
  68.     {
  69.         EC_KEY_free(evKey);
  70.         return GM_UTIL_CODE_SM2_ENCRYPT_FAILED;
  71.     }
  72.     
  73.     BIO *bOut = BIO_new(BIO_s_mem());
  74.     if (NULL == bOut)
  75.     {
  76.         EC_KEY_free(evKey);
  77.         SM2CiphertextValue_free(cval);
  78.         return GM_UTIL_CODE_INIT_BIO_FAILED;
  79.     }
  80.  
  81.     if (i2d_SM2CiphertextValue_bio(bOut, cval) <= 0)
  82.     {
  83.         SM2CiphertextValue_free(cval);
  84.         BIO_free(bOut);
  85.         EC_KEY_free(evKey);
  86.         return GM_UTIL_CODE_CIPHER_TEXT_TO_BIO_FAILED;
  87.     }
  88.  
  89.     if (0 == (outLen = BIO_get_mem_data(bOut, (char **)&buff)))
  90.     {
  91.         SM2CiphertextValue_free(cval);
  92.         BIO_free(bOut);
  93.         EC_KEY_free(evKey);
  94.         return GM_UTIL_CODE_BIO_DATA_TO_MEM_FAILED;
  95.     }
  96.  
  97.     strCiphertext.assign((char *)buff, outLen);
  98.     // 释放内存
  99.     SM2CiphertextValue_free(cval);
  100.     BIO_free(bOut);
  101.     EC_KEY_free(evKey);
  102.     // OPENSSL_free(buff); //此处释放会挂掉，不应该free，应该是在BIO_free的时候内存已经被释放掉
  103.     return GM_UTIL_CODE_OK;
  104. }
  105.  
  106.  
  107. int GmSm2Decrypt(string strPriKey, const string &strCiphertext, string &strOut)
  108. {
  109.     EC_KEY *evKey = CreateEC((unsigned char *)strPriKey.c_str(), 0);
  110.     if (NULL == evKey)
  111.     {
  112.         return GM_UTIL_CODE_CREATE_EV_KEY_FAILED;
  113.     }
  114.  
  115.     if (!EC_KEY_is_sm2p256v1(evKey))
  116.     {
  117.         EC_KEY_free(evKey);
  118.         return GM_UTIL_CODE_NOT_SM2P256V1;
  119.     }
  120.     BIO *bIn = NULL;
  121.     bIn = BIO_new_mem_buf(strCiphertext.c_str(), strCiphertext.size());
  122.     if (bIn == NULL)
  123.     {
  124.         EC_KEY_free(evKey);
  125.         return GM_UTIL_CODE_INIT_BIO_FAILED;
  126.     }
  127.  
  128.     int ret = 0;
  129. 	SM2CiphertextValue *cval = NULL;
  130. 	void *buf = NULL;
  131. 	size_t siz;
  132.     const EVP_MD* md = EVP_sm3();
  133.  
  134.     if (NULL == (cval = d2i_SM2CiphertextValue_bio(bIn, NULL)))
  135.     {
  136.         BIO_free(bIn);
  137.         EC_KEY_free(evKey);
  138.         return GM_UTIL_CODE_BIO_DATA_TO_CIPHER_TEXT_FAILED;
  139.     }
  140.  
  141. 	if (0 == SM2_do_decrypt(md, cval, NULL, &siz, evKey) || !(buf = OPENSSL_malloc(siz)))
  142.     {
  143.         BIO_free(bIn);
  144.         SM2CiphertextValue_free(cval);
  145.         EC_KEY_free(evKey);
  146. 		return GM_UTIL_CODE_SM2_DECRYPT_FAILED;
  147. 	}
  148.  
  149.     if (0 == SM2_do_decrypt(md, cval, (unsigned char*)buf, &siz, evKey))
  150.     {
  151.         BIO_free(bIn);
  152.         SM2CiphertextValue_free(cval);
  153.         OPENSSL_free(buf);
  154.         EC_KEY_free(evKey);
  155.         return GM_UTIL_CODE_SM2_DECRYPT_FAILED;
  156.     }
  157.     
  158.     strOut.assign((char*)buf, siz);
  159.     // 释放内存
  160.     BIO_free(bIn);
  161.     SM2CiphertextValue_free(cval);
  162. 	OPENSSL_free(buf);
  163.     EC_KEY_free(evKey);
  164.     return GM_UTIL_CODE_OK;
  165. }
  166.  
  167. static streamsize Read(istream &stream, char *buffer, streamsize count)
  168. {
  169.     streamsize reads = stream.rdbuf()->sgetn(buffer, count);
  170.     stream.rdstate();
  171.     stream.peek();
  172.     return reads;
  173. }
  174.  
  175. string GmReadKeyFromFile(string strFileName)
  176. {
  177.     fstream myfile;
  178. 	myfile.open(strFileName, ifstream::in | ifstream::binary);
  179. 	if (!myfile.is_open())
  180.     {
  181.         return "";
  182.     }
  183.  
  184.     char buff[1024];
  185.     std::ostringstream oss;
  186.     int len;
  187.     while (!myfile.eof())
  188.     {
  189.         size_t read = Read(myfile, buff, sizeof(buff));
  190.         oss << string(buff, read);
  191.     }
  192.  
  193.     myfile.close();
  194.     return oss.str();
  195. }
  196.  
  197. static char sDigit1[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  198. static char sDigit2[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  199. string GmByte2HexStr(const string& data, bool bLowerCase)
  200. {
  201.     char *sDigit = sDigit1;
  202.     if (!bLowerCase)
  203.     {
  204.         sDigit = sDigit2;
  205.     }
  206.     const char* pData = data.c_str();
  207.     char cTemp;
  208.     string strHex;
  209.     for (unsigned int i = 0; i < data.size(); i++)
  210.     {
  211.         cTemp = *pData;
  212.         pData++;
  213.         strHex += sDigit[(cTemp >> 4) & 0x0F];
  214.         strHex += sDigit[cTemp & 0x0F];
  215.     }
  216.  
  217.     return strHex;
  218. }
  219.  
  220. string GmHexStr2Byte(const string& hex, bool bLowerCase)
  221. {
  222.     if (hex.size() % 2 != 0)
  223.     {
  224.         // 十六进制字符串必须是偶数长度
  225.         return "";
  226.     }
  227.  
  228.     char chA = 'a';
  229.     if (!bLowerCase)
  230.     {
  231.         chA = 'A';
  232.     }
  233.  
  234.     std::ostringstream oss;
  235.     for (int i = 0; i < hex.size(); i += 2)
  236.     {
  237.         unsigned int highBit;
  238.         if (hex[i] >= '0' && hex[i] <= '9')
  239.         {
  240.             highBit = hex[i] - '0';
  241.         }
  242.         else
  243.         {
  244.             highBit = hex[i] - chA + 10;
  245.         }
  246.         unsigned int lowBit;
  247.         if (hex[i + 1] >= '0' && hex[i + 1] <= '9')
  248.         {
  249.             lowBit = hex[i + 1] - '0';
  250.         }
  251.         else
  252.         {
  253.             lowBit = hex[i + 1] - chA + 10;
  254.         }
  255.         unsigned char ch = (highBit << 4) + lowBit; 
  256.         oss << ch;
  257.     }
  258.  
  259.     return oss.str();
  260. }

下面是测试验证test.cpp:

  1. #include "gmutil.h"
  2. #include <iostream>
  3. #include <sstream>
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     string strPriKey = GmReadKeyFromFile("sm2_server_private_key.key");
  8.     string strPubKey = GmReadKeyFromFile("sm2_server_public_key.key");
  9.     string strText = "hello world, this is a test";
  10.     string strCipher;
  11.     string strOut;
  12.     std::cout << "plaintext:" << strText << std::endl;
  13.     int nRet = GmSm2Encrypt(strPubKey, strText, strCipher);
  14.     if (GM_UTIL_CODE_OK != nRet)
  15.     {
  16.         cout << "GmSm2Encrypt fail" << endl;
  17.     }
  18.     string strCipherTextHex = GmByte2HexStr(strCipher);
  19.     cout << "hex ciper text:" << strCipherTextHex << endl;
  20.     string strCipher1 = GmHexStr2Byte(strCipherTextHex);
  21.     if (strCipher1 == strCipher)
  22.     {
  23.         cout << "conver hex str to byte sucess" << endl;
  24.     }
  25.     nRet = GmSm2Decrypt(strPriKey, strCipher1, strOut);
  26.     std::cout << "after decrypt:" << strOut << std::endl;
  27.  
  28.     return 0;
  29. }

编译的时候要加这几个关键的编译参数：-fvisibility=hidden -Wl,-Bsymbolic -Wl,--exclude-libs,ALL

用来屏蔽动态库中的符号的。

gmssl库相关函数的文档可以参考官网：国密SM2椭圆曲线密码标准 (gmssl.org)

还有可以直接参考gmssl源码中的sm2test.c以及sm2utl.c，里面有相关的代码

还有gmssl库用到openssl库的很多函数比如BIO等，可以参数openssl官网来使用

参考文章：

(20条消息) 基于GMSSL的SM2加解密测试_viqjeee的博客-CSDN博客_gmssl sm2

(20条消息) C语言SM2算法实现（基于GMSSL）_张志翔 ̮的博客-CSDN博客_sm2实现 --这个最详细，直接有完整代码

(25条消息) SM2算法全套（基于GMSSL）_wincent1的博客-CSDN博客_gmssl sm2算法

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

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

  

闽ICP备14008679号