使用openssl的EVP接口使用sm2算法加解密等操作

最新推荐文章于 2025-02-28 10:01:23 发布
最新推荐文章于 2025-02-28 10:01:23 发布
阅读量1.8w 收藏 66
点赞数 7
分类专栏： Qt c++开发实战 文章标签： openssl sm2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41761608/article/details/107623909
版权
本文详细介绍了如何使用OpenSSL的EVP接口实现国密SM2算法的加解密、签名验证及秘钥对生成。通过具体代码示例，展示了如何利用PEM格式的公私钥进行数据加密、解密、签名和验证，适用于Ubuntu 18.04环境下OpenSSL 1.1.1b的开发者。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

OpenSSL 1.1.1版本提供了对国密SM2算法的支持。但是不知为什么这么设计，将sm2.h sm3.h sm4.h这些头文件放在源码的cryto/include/internall目录下，这样导致用户不能直接调用到sm2.crypt.c中实现的函数。鉴于此，若需要SM2加解密，需要用统一的EVP抽象接口。

本篇主要介绍如何用EVP接口实现国密SM2算法的加解密，签名验签，秘钥对生成等操作。公私钥以PEM格式形式传递。PEM相比于HEX数组具有更容易存储和分发等优点。

#pragma once
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/ec.h>
#include <openssl/ossl_typ.h>
#include <openssl/bn.h>
#include <openssl/crypto.h>
#include <openssl/opensslconf.h>
#include <openssl/obj_mac.h>
#include <openssl/err.h>
#include "log.h"

class SM2 {
private:
	/// <summary>
/// 通过公钥/私钥返回EVP_PKEY
/// </summary>
/// <param name="key">pem格式</param>
/// <param name="is_public"></param>
/// <param name="out_ecKey"></param>
/// <returns></returns>
	static bool CreateEVP_PKEY(unsigned char* key, int is_public, EVP_PKEY** out_ecKey);
public:	
	/// <summary>
	/// 根据私钥计算出公钥
	/// </summary>
	/// <param name="in_priKey"></param>
	/// <param name="out_pubKey"></param>
	/// <returns></returns>
	static bool PriKey2PubKey(string in_priKey, string& out_pubKey);
	/// <summary>
	/// 生成EC秘钥对 
	/// </summary>
	/// <param name="privKey">pem格式的私钥</param>
	/// <param name="pubKey">pem格式的公钥</param>
	/// <returns></returns>
	static int GenEcPairKey(string& out_priKey, string& out_pubKey);

	/// <summary>
	/// 签名 私钥加密 0成功
	/// </summary>
	/// <param name="in_buf">待签名数据</param>
	/// <param name="in_buflen">长度</param>
	/// <param name="out_sig">签名后数据</param>
	/// <param name="len_sig">签名数据长度</param>
	/// <param name="priKey">私钥pem格式</param>
	/// <returns></returns>
	static int Sign(string in_buf, int in_buflen, string& out_sig, int& len_sig, string priKey);

	/// <summary>
	/// 验签 公钥解密 0成功
	/// </summary>
	/// <param name="in_buf">待验签数据 明文</param>
	/// <param name="buflen">数据长度</param>
	/// <param name="sig">签名数据</param>
	/// <param name="siglen">签名数据长度</param>
	/// <param name="pubkey">公钥</param>
	/// <param name="keylen">公钥长度</param>
	/// <returns></returns>
	static int Verify(string in_buf, const int buflen, string sig, const int siglen, 
		string pubkey, const int keylen);

	/// <summary>
	/// 加密 公钥加密 0成功
	/// </summary>
	/// <param name="in_buf"></param>
	/// <param name="in_buflen"></param>
	/// <param name="out_encrypted"></param>
	/// <param name="len_encrypted"></param>
	/// <param name="pubKey">pem格式公钥</param>
	/// <returns></returns>
	static int Encrypt(string in_buf, int in_buflen, string& out_encrypted, int& len_encrypted, string pubKey);

	/// <summary>
	/// 解密 私钥解密 0成功
	/// </summary>
	/// <param name="in_buf"></param>
	/// <param name="in_buflen"></param>
	/// <param name="out_plaint"></param>
	/// <param name="len_plaint"></param>
	/// <param name="prikey">pem格式私钥</param>
	/// <returns></returns>
	static int Decrypt(string in_buf, int in_buflen, string& out_plaint, int& len_plaint, string prikey);
};

inline int SM2::GenEcPairKey(string& out_priKey, string& out_pubKey)
{
	EC_KEY* ecKey;
	EC_GROUP* ecGroup;
	int ret_val = -1;
	if (NULL == (ecKey = EC_KEY_new()))
	{
		return -1;
	}

	if (NULL == (ecGroup = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)))
	{
		EC_KEY_free(ecKey);
		return -2;
	}

	if (EC_KEY_set_group(ecKey, ecGroup) != 1)
	{
		EC_GROUP_free(ecGroup);
		EC_KEY_free(ecKey);
		return -3;
	}

	if (!EC_KEY_generate_key(ecKey))
	{
		EC_GROUP_free(ecGroup);
		EC_KEY_free(ecKey);
		return -3;
	}

	//可以从EC_KEY类型返回char*数组
	size_t pri_len;
	size_t pub_len;
	char* pri_key = NULL;
	char* pub_key = NULL;

	BIO* pri = BIO_new(BIO_s_mem());
	BIO* pub = BIO_new(BIO_s_mem());

	PEM_write_bio_ECPrivateKey(pri, ecKey, NULL, NULL, 0, NULL, NULL);
	PEM_write_bio_EC_PUBKEY(pub, ecKey);

	pri_len = BIO_pending(pri);
	pub_len = BIO_pending(pub);

	pri_key = new char[pri_len + 1];
	pub_key = new char[pub_len + 1];

	BIO_read(pri, pri_key, pri_len);
	BIO_read(pub, pub_key, pub_len);

	pri_key[pri_len] = '\0';
	pub_key[pub_len] = '\0';

	out_pubKey = pub_key;
	out_priKey = pri_key;

	BIO_free_all(pub);
	BIO_free_all(pri);
	delete[] pri_key;
	delete[] pub_key;
	EC_GROUP_free(ecGroup);
	EC_KEY_free(ecKey);
	return 0;
}

inline bool SM2::CreateEVP_PKEY(unsigned char* key, int is_public, EVP_PKEY** out_pKey)
{
	BIO* keybio = NULL;
	keybio = BIO_new_mem_buf(key, -1);

	if (keybio == NULL) {
		LOGE("BIO_new_mem_buf failed.\n");
		return false;
	}

	if (is_public) {
		//*out_ecKey = PEM_read_bio_EC_PUBKEY(keybio, NULL, NULL, NULL);
		*out_pKey = PEM_read_bio_PUBKEY(keybio, NULL, NULL, NULL);
	}
	else {
		//*out_ecKey = PEM_read_bio_ECPrivateKey(keybio, NULL, NULL, NULL);
		*out_pKey = PEM_read_bio_PrivateKey(keybio, NULL, NULL, NULL);
	}

	if (*out_pKey == NULL) {
		LOGE("Failed to Get Key");
		BIO_free(keybio);
		return false;
	}

	BIO_free(keybio);
	return true;
}

inline bool SM2::PriKey2PubKey(string in_priKey, string& out_pubKey)
{
	BIO* keybio = NULL;
	keybio = BIO_new_mem_buf(in_priKey.c_str(), -1);

	if (keybio == NULL) {
		LOGE("BIO_new_mem_buf failed.\n");
		return false;
	}

	EC_KEY* ecKey = PEM_read_bio_ECPrivateKey(keybio, NULL, NULL, NULL);
	if (ecKey == NULL)
	{
		LOGE("PEM_read_bio_ECPrivateKey failed.");
		BIO_free(keybio);
		return false;
	}

	BIO* pub = BIO_new(BIO_s_mem());
	PEM_write_bio_EC_PUBKEY(pub, ecKey);
	int pub_len = BIO_pending(pub);
	char* pub_key = new char[pub_len + 1];
	BIO_read(pub, pub_key, pub_len);
	pub_key[pub_len] = '\0';

	out_pubKey = pub_key;

	delete[] pub_key;
	BIO_free(pub);
	BIO_free(keybio);
	return true;
}

inline int SM2::Sign(string in_buf, int in_buflen, string& out_sig, int& len_sig, string priKey)
{
	int ret_val = 0;
	//通过私钥得到EC_KEY
	EC_KEY* eckey = NULL;
	BIO* keybio = NULL;
	keybio = BIO_new_mem_buf(priKey.c_str(), -1);
	if (keybio == NULL)
	{
		LOGE("BIO_new_mem_buf failed\n");
		return -1;
	}
	eckey = PEM_read_bio_ECPrivateKey(keybio, NULL, NULL, NULL);
	if (eckey==NULL)
	{
		LOGE("PEM_read_bio_ECPrivateKey failed\n");
		BIO_free(keybio);
		return -2;
	}

	unsigned char szSign[256] = { 0 };
	if (1 != ECDSA_sign(0, (const unsigned char*)in_buf.c_str(), in_buflen, szSign, (unsigned int*)&len_sig, eckey)) {
		LOGE("ECDSA_sign failed\n");
		ret_val = -3;
	}
	else
	{
		out_sig = string((char*)szSign, len_sig);
		ret_val = 0;
	}
	BIO_free(keybio);
	EC_KEY_free(eckey);
	return ret_val;
}

inline int SM2::Verify(string in_buf, const int buflen, string sig, const int siglen,
	string pubkey, const int keylen)
{
	int ret_val = 0;
	//通过公钥得到EC_KEY
	EC_KEY* eckey = NULL;
	BIO* keybio = NULL;
	keybio = BIO_new_mem_buf(pubkey.c_str(), -1);
	if (keybio == NULL)
	{
		LOGE("BIO_new_mem_buf failed\n");
		return -1;
	}
	eckey = PEM_read_bio_EC_PUBKEY(keybio, NULL, NULL, NULL);
	if (eckey == NULL)
	{
		LOGE("PEM_read_bio_EC_PUBKEY failed\n");
		BIO_free(keybio);
		return -2;
	}
	if (1 != ECDSA_verify(0, (const unsigned char*)in_buf.c_str(), buflen, 
		(const unsigned char*)sig.c_str(), siglen, eckey))
	{
		LOGE("ECDSA_verify failed\n");
		ret_val = -3;
	}
	else
	{
		ret_val = 0;
	}
	BIO_free(keybio);
	EC_KEY_free(eckey);

	return ret_val;
}


inline int SM2::Encrypt(string in_buf, int in_buflen, string& out_encrypted, int& len_encrypted, string pubKey)
{
	int ret = -1, i;
	EVP_PKEY_CTX * ectx = NULL;
	EVP_PKEY* pkey = NULL;
	EC_KEY* key_pair = NULL;
	unsigned char* ciphertext = NULL;
	size_t ciphertext_len, plaintext_len;

	CreateEVP_PKEY((unsigned char*)pubKey.c_str(), 1, &pkey);

	/* compute SM2 encryption */
	if ((EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)) != 1)
	{
		LOGE("EVP_PKEY_set_alias_type failed.");
		goto clean_up;
	}

	if (!(ectx = EVP_PKEY_CTX_new(pkey, NULL)))
	{
		LOGE("EVP_PKEY_CTX_new failed.");
		goto clean_up;
	}

	if ((EVP_PKEY_encrypt_init(ectx)) != 1)
	{
		LOGE("EVP_PKEY_encrypt failed.");
		goto clean_up;
	}

	if ((EVP_PKEY_encrypt(ectx, NULL, &ciphertext_len, (const unsigned char*)in_buf.c_str(), in_buflen)) != 1)
	{
		LOGE("EVP_PKEY_set_alias_type failed.");
		goto clean_up;
	}

	if (!(ciphertext = (unsigned char*)malloc(ciphertext_len)))
	{
		goto clean_up;
	}

	if ((EVP_PKEY_encrypt(ectx, ciphertext, &ciphertext_len, (const unsigned char*)in_buf.c_str(), in_buflen)) != 1)
	{
		LOGE("EVP_PKEY_encrypt failed.");
		goto clean_up;
	}
	out_encrypted = string((char*)ciphertext, ciphertext_len);
	len_encrypted = ciphertext_len;
	ret = 0;
clean_up:
	if (pkey)
	{
		EVP_PKEY_free(pkey);
	}

	if (ectx)
	{
		EVP_PKEY_CTX_free(ectx);
	}

	if (ciphertext)
	{
		free(ciphertext);
	}

	return ret;
}

inline int SM2::Decrypt(string in_buf, int in_buflen, string& out_plaint, int& len_plaint, string prikey)
{
	int ret = -1, i;
	EVP_PKEY_CTX* pctx = NULL, * ectx = NULL;
	EVP_PKEY* pkey = NULL;
	EC_KEY* key_pair = NULL;
	unsigned char * plaintext = NULL;
	size_t ciphertext_len, plaintext_len;

	CreateEVP_PKEY((unsigned char*)prikey.c_str(), 0, &pkey);

	if ((EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)) != 1)
	{
		LOGE("EVP_PKEY_set_alias_type failed.");
		goto clean_up;
	}

	if (!(ectx = EVP_PKEY_CTX_new(pkey, NULL)))
	{
		LOGE("EVP_PKEY_CTX_new failed.");
		goto clean_up;
	}

	/* compute SM2 decryption */
	if ((EVP_PKEY_decrypt_init(ectx)) != 1)
	{
		LOGE("EVP_PKEY_decrypt_init failed.");
		goto clean_up;
	}

	if ((EVP_PKEY_decrypt(ectx, NULL, &plaintext_len, (const unsigned char*)in_buf.c_str(), in_buflen)) != 1)
	{
		LOGE("EVP_PKEY_decrypt failed.");
		goto clean_up;
	}

	if (!(plaintext = (unsigned char*)malloc(plaintext_len)))
	{
		goto clean_up;
	}

	if ((EVP_PKEY_decrypt(ectx, plaintext, &plaintext_len, (const unsigned char*)in_buf.c_str(), in_buflen)) != 1)
	{
		LOGE("EVP_PKEY_decrypt failed.");
		goto clean_up;
	}
	out_plaint = string((char*)plaintext, plaintext_len);
	len_plaint = plaintext_len;
	ret = 0;
clean_up:
	if (pctx)
	{
		EVP_PKEY_CTX_free(pctx);
	}

	if (pkey)
	{
		EVP_PKEY_free(pkey);
	}

	if (ectx)
	{
		EVP_PKEY_CTX_free(ectx);
	}

	if (plaintext)
	{
		free(plaintext);
	}

	return ret;
}

主要参考文章：

https://blog.csdn.net/u012849539/article/details/105207489

https://blog.csdn.net/henter/article/details/84970970

但网上也有人使用sm2.h中的API进行加解密，但我不会操作，我的环境是ubuntu18.04 openssl1.1.1b，如有知道的请告知。

SM2.h定义如下

int sm2_encrypt(const EC_KEY *key, const EVP_MD *digest, const uint8_t *msg,size_t msg_len, uint8_t *ciphertext_buf, size_t *ciphertext_len);
int sm2_decrypt(const EC_KEY *key, const EVP_MD *digest, const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *ptext_buf, size_t *ptext_len);

包含头文件如下：

#include <openssl/evp.h>
#include <openssl/sm2.h>
#include <openssl/sm3.h>

 

openssl+SM2开发实例一（含源码）
N阶二进制的博客
11-11 6952
是中国国家密码管理局（CNCA）颁布的椭圆曲线密码算法标准，属于非对称加密算法。它基于椭圆曲线离散对数问题，提供了安全可靠的数字签名、密钥交换和公钥加密等功能。SM2被设计为适用于各种场景下的密码学应用，包括数字证书、数据加密、数字签名、身份认证等。SM2是一种非对称加密算法，意味着它使用两个密钥：公钥和私钥。公钥用于加密数据和验证签名，而私钥用于解密数据和生成签名。SM2基于椭圆曲线密码学（Elliptic Curve Cryptography，ECC），使用椭圆曲线上的点运算来实现加密和签名操作。
openssl gmssl SM2 公私钥生成 签名验签加密解密命令
择一事终一生
10-19 1万+
国密SM2 OpenSSL EVP接口例子 使用openssl的EVP接口使用sm2算法加解密等操作 生成密钥 gmssl ecparam -genkey -name sm2p256v1 -text -out sm2.key 生成公钥 gmssl ec -in sm2.key -pubout -out pk.pem 创建测试文件 echo "jasonruan" >> readme.txt 签名 gmssl dgst -sm3 -sign sm2.key -out sm2.sig readm.
openssl sm2 加解密
sheng199463的博客
05-05 1万+
1.SM2算法 openssl 1.1.1以后版本提供了对国密SM2算法的支持。源码的cryto/include/internall目录下有sm2,sm3,sm4的设计实现，但是无法直接调用，因此通过openssl的evp接口实现国密SM2算法的加解密。 SM2公钥格式：公钥：04|X|Y，共65字节；私钥格式：整数，共32字节。密文格式结构体为，typedef struct SM2Cipher_st { ASN1_INTEGER *xCoordinate; .........
【详解】解决CannotfindOpenSSL‘s＜evp.h＞
最新发布
牛肉胡辣汤
02-28 1029
​的问题时，首先确认OpenSSL是否已正确安装，其次检查环境变量配置是否正确，最后确保编译命令中指定了正确的路径。如果你在 Linux 系统上开发，并且遇到了这个错误，首先需要确保已经安装了 OpenSSL 开发库。如果你使用的是集成开发环境（如Visual Studio、CLion等），确保项目的构建配置中包含了正确的头文件和库文件路径。如果你使用的是包管理器（如Conan、vcpkg等），确保它们正确配置了OpenSSL的路径。​这样的编译器，确保在编译命令中指定了正确的包含路径和库路径。
在openssl中对SM2的公私钥进行加解密的验证
热门推荐
dong_beijing的博客
08-03 1万+
在上一篇文章中《通过openssl生成sm2的公私钥的方法》介绍了如何在openssl系统中生成公私钥对，如何对生成的公私钥对进行验证呢？ 在ecparam.c中，添加加解密的代码就可以了，还在《通过openssl生成sm2的公私钥的方法》添加公钥的地方，432行，在生成公钥之后，添加代码如下： i = PEM_write_bio_ECPrivateKey(out, ...
openssl使用sm2算法
06-16
openssl使用sm2算法，其中带有openssl头文件及动态库，可直接编译运行。
OpenSSL 3.1.1 ECC 加密、解密、签名、验签（国密 sm2、sm3）
Linuxsisohard的博客
06-05 9539
openssl 3 默认废弃了 旧版本 （opessl 1.x) 的部分api 导致部分旧ecc 代码无法使用（可以通过配置编译选项打开）新接口是真的方便，基本上你都不需要懂啥密码学知识，对我们这种密码白痴来说太好了。，这里展示如何使用新接口用ECC 进行加密解密。
openssl SM2 加解密的坑
择一事终一生
10-18 5413
1、密文结构，有些算法实现输出的密文结构为 C1C2C3 ，有些为 C1C3C2 , 需要先转换密文格式，再做解密操作。 2、有些算法实现，公钥前加 04 ，私钥前加 00，密文前加 04 ，在处理时候，可以根据长度处理，尤其 04 的处理。 3、有些算法实现加密的密文是裸数据，有些是加了 asn flag 的，两边对接时也得注意格式的转换。 注： C1C2C3 是旧标准，新标准的是C1C3C2 公钥前面的 04 代表秘钥为未经过压缩的秘钥，长度为 64，加上 04 后长度 65. 03 代表秘钥为经过压
sm2加密，解密，签名，验签,sm3哈希,基于openssl的C语言实现
10-27
sm2加密，解密，签名，验签,sm3哈希,基于openssl的C语言实现
基于OpenSSL 1.1.1版实现的SM2加密与解密C程序
henter的专栏
12-12 1万+
    OpenSSL 1.1.1 版提供了对国密 SM2 算法的支持。对于 SM2 加解密算法，在源码的 crypto/sm2 目录下，sm2_crypt.c 文件中实现了 SM2 加密与解密。OpenSSL源码是很好的学习范例，但是 sm2.h, sm3.h, sm4.h 这些头文件是放在源码的 crypto/include/internal 目录下，这就导致用户不能直接调用到 sm2_cry...
基于Openssl的SM2实现
08-30
基于OpenSSL的SM2软实现库及测试程序
使用openssl 1.1.1版本,调试国密SM2签名、验签、加密解密、SM3
11-20
OpenSSL 1.1.1 新特性: 全面支持国密SM2/SM3/SM4加密算法,最近的项目涉及到国密，又局限于资源有限，只能只能上了。
国密SM2算法基于Openssl实现（优化版）
03-05
和goldboar老兄的一样东西，优化如下： 1.附加了Openssl的Win32库。 2.修改了其中一个小BUG。 3.只需要3分资源分，呵呵。
SM2加解密算法代码实现
04-29
基于openssl的国密SM2加解密算法实现 linux C代码编程
Openssl源码方式添加国密SM2算法
Network/Storage/Linux Kernel
06-17 1万+
1：源码方式，只需要添加2部分，第一部分是 国密sm2的oid，第二部分是group。 1：添加sm2的oid cd crypto/objects/ 编辑  objects.txt ，添加: 1 2 156 10197 1 301 : SM2 : SM2 随便加在哪里即可，我添加在文件最后。 然后在当前目录下执行： perl objects.pl objec
通过OpenSSL生成SM2公私钥对
y2000sc的博客
08-23 3026
Openssl 1.1.1+ 版本增加了对SM2 的支持，所以我们就能直接使用这些版本的opsnssl 生成 SM2的公私钥对。 首先我们得在服务器中安装对应版本的openssl库，具体过程略。 软件包请到官网下载 : https://www.openssl.org/ 安装完成后，使用下列命令查看该版本的openssl 是否支持SM2参数： openssl ecparam -list_curves | grep SM2 如果查询结果有内容，则说明该版本支持SM2参数，也就可以生成SM2的公私钥对。 在安装
openssl+ SM2 + linux 签名校验开发实例（C++）
N阶二进制的博客
11-23 2361
SM2签名使用消息摘要算法对原始消息进行哈希，通常采用SM3算法。在校验过程中，验证者也需要使用相同的哈希算法对接收到的消息进行哈希。
openssl采用sm2进行自签名的方法
dong_beijing的博客
08-05 1万+
自签名有两种方法: 1 用自己会话生成的私钥,来签发自己的csr生成证书，也可以直接生成私钥和证书 2 自己做一个CA. 1,2的差别在于私钥的生成和存活的时间. 以1的方法如下: 生成私钥 ./openssl ecparam -genkey -name SM2 -out priv.key 生成证书 ./openssl req -new -x509 -sha256 -key ...
openssl sm2 国密算法
ughome的专栏
04-07 1499
openssl sm2 国密算法
基于openssl3.0版本之后的sm2算法实现，给出C++代码
09-07
基于OpenSSL 3.0版本的SM2算法实现涉及到使用OpenSSL提供的API来完成SM2加密和解密操作。下面是一个简单的示例代码，展示了如何使用OpenSSL 3.0 API进行SM2的加密和解密。 ```cpp #include <iostream> #include <openssl/ec.h> #include <openssl/pem.h> #include <openssl/evp.h> #include <openssl/bn.h> // 初始化EVP加密上下文 static EVP_CIPHER_CTX *create_sm2_context() { EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); if (!ctx) { std::cerr << "EVP_CIPHER_CTX_new failed" << std::endl; return nullptr; } if (1 != EVP_EncryptInit_ex(ctx, EVP_sm4_ecb(), nullptr, nullptr, nullptr)) { std::cerr << "EVP_EncryptInit_ex failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return nullptr; } return ctx; } // SM2加密 bool sm2_encrypt(const unsigned char *plaintext, int plaintext_len, const unsigned char *key, unsigned char *ciphertext) { EVP_CIPHER_CTX *ctx = create_sm2_context(); if (!ctx) { return false; } int len = 0; int ciphertext_len = 0; if (1 != EVP_EncryptInit_ex(ctx, nullptr, nullptr, key, nullptr)) { std::cerr << "EVP_EncryptInit_ex failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) { std::cerr << "EVP_EncryptUpdate failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } ciphertext_len = len; if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) { std::cerr << "EVP_EncryptFinal_ex failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } ciphertext_len += len; EVP_CIPHER_CTX_free(ctx); return true; } // SM2解密 bool sm2_decrypt(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, unsigned char *plaintext) { EVP_CIPHER_CTX *ctx = create_sm2_context(); if (!ctx) { return false; } int len = 0; int plaintext_len = 0; if (1 != EVP_DecryptInit_ex(ctx, nullptr, nullptr, key, nullptr)) { std::cerr << "EVP_DecryptInit_ex failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } if (1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len)) { std::cerr << "EVP_DecryptUpdate failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } plaintext_len = len; if (1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) { std::cerr << "EVP_DecryptFinal_ex failed" << std::endl; EVP_CIPHER_CTX_free(ctx); return false; } plaintext_len += len; EVP_CIPHER_CTX_free(ctx); return true; } int main() { // 这里需要提供SM2公钥和私钥来完成加密和解密 // 以下是示例密钥，实际使用时应使用有效的密钥对 const unsigned char public_key[] = { /* 公钥数据 */ }; const unsigned char private_key[] = { /* 私钥数据 */ }; const unsigned char data[] = "This is a test message for SM2 encryption."; unsigned char encrypted[256]; unsigned char decrypted[256]; int encrypted_len, decrypted_len; // 加密 if (sm2_encrypt(data, sizeof(data), public_key, encrypted)) { encrypted_len = sizeof(data); std::cout << "Encrypted text is: "; for (int i = 0; i < encrypted_len; i++) { std::cout << std::hex << static_cast<int>(encrypted[i]); } std::cout << std::endl; } // 解密 if (sm2_decrypt(encrypted, encrypted_len, private_key, decrypted)) { decrypted_len = sizeof(data); std::cout << "Decrypted text is: "; std::cout.write(reinterpret_cast<const char*>(decrypted), decrypted_len); std::cout << std::endl; } return 0; } ``` 注意： 1. 上述代码仅作为示例，实际使用时需要替换示例中的`public_key`和`private_key`为实际有效的SM2公钥和私钥数据。 2. 代码中的加密和解密函数是简化版本，没有处理错误情况和资源释放的完整逻辑。 3. 在实际环境中，密钥和数据的处理需要更加安全和完整，可能涉及到密钥存储、数据填充和错误处理等。
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zy100Papa

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值