1. 项目概述

最近在做一个需要集成国密算法的项目，客户明确要求使用SM2进行数字签名和验签，SM3作为哈希算法。一开始我琢磨着直接用GmSSL，毕竟它是国产密码库的标杆。但项目有个硬性要求：必须基于OpenSSL 3.x进行开发，因为整个技术栈已经深度绑定了OpenSSL，迁移成本太高。这就有点尴尬了，OpenSSL原生并不支持国密算法。于是，我花了几天时间，把OpenSSL 3.x的引擎机制、EVP框架和国密标准文档翻了个遍，最终成功封装了一套C++的SM2/SM3工具类。踩了不少坑，也总结了一些心得，今天就把从密钥生成、签名到验签的完整流程，以及如何用C++进行优雅封装的经验分享出来。

这套封装的核心目标是：在OpenSSL 3.x的框架下，无缝集成SM2和SM3算法，提供一套接口清晰、易于使用、且符合现代C++风格的类库。它适合那些已经在使用OpenSSL，但又需要满足国密合规要求的开发者，比如金融、政务、物联网等领域的应用。你不用去动底层庞大的OpenSSL源码，而是通过引擎加载和EVP高层接口来“嫁接”国密能力。接下来，我会详细拆解每一步的实现思路和关键代码。

2. 环境准备与国密引擎集成

要在OpenSSL中使用国密算法，第一步不是写代码，而是准备好“翻译官”——国密算法引擎。OpenSSL本身不认识SM2/SM3，我们需要一个实现了这些算法的动态库（引擎），并告诉OpenSSL如何加载和使用它。

2.1 国密引擎的选择与编译

目前社区里比较成熟的OpenSSL国密引擎主要有两个选择：gmssl-engine或tongsuo（原名BabaSSL）中的引擎模块。我这里以gmssl-engine为例，因为它相对轻量，专注于提供算法引擎。

首先，你需要获取引擎源码。通常可以从GitHub上找到相关项目。编译过程类似于编译一个普通的动态库。

# 假设你已经下载了 gmssl-engine 源码并进入其目录 mkdir build && cd build cmake .. -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl # 指向你的OpenSSL 3.x安装路径 make

编译成功后，你会得到类似libgmssl_engine.so（Linux）或gmssl_engine.dll（Windows）的动态库文件。关键一步：把这个引擎库文件放到OpenSSL能找到的目录下，通常是OpenSSL安装目录下的engines文件夹（例如/usr/local/openssl/lib/engines-3/）。

注意：OpenSSL 3.x 的引擎目录结构和命名可能与 1.1.x 不同，务必确认路径。你可以通过命令openssl version -a查看OPENSSLDIR来确定引擎目录。

2.2 在代码中动态加载引擎

引擎编译好了，接下来就是在我们的C++程序中动态加载它。OpenSSL提供了丰富的引擎API。我们希望在程序初始化时就完成引擎加载，确保后续所有SM2/SM3操作都能使用。

#include <openssl/engine.h> #include <openssl/evp.h> #include <openssl/err.h> #include <iostream> #include <memory> // 利用RAII思想管理引擎句柄，避免内存泄漏 struct EngineDeleter { void operator()(ENGINE* e) const { if (e) { ENGINE_finish(e); ENGINE_free(e); } } }; using EnginePtr = std::unique_ptr<ENGINE, EngineDeleter>; bool LoadGmEngine() { // 1. 查找并加载引擎动态库 ENGINE* gm_engine = ENGINE_by_id("dynamic"); if (!gm_engine) { std::cerr << "Failed to create dynamic engine" << std::endl; return false; } EnginePtr engine(gm_engine); // 用智能指针接管 // 2. 设置引擎动态库的路径 // 这里的路径需要替换成你实际的引擎库文件路径 if (!ENGINE_ctrl_cmd_string(engine.get(), "SO_PATH", "/path/to/libgmssl_engine.so", 0)) { std::cerr << "Failed to set SO_PATH for engine" << std::endl; return false; } // 3. 指示引擎加载 if (!ENGINE_ctrl_cmd_string(engine.get(), "LOAD", nullptr, 0)) { std::cerr << "Failed to LOAD engine" << std::endl; return false; } // 4. 将引擎添加到OpenSSL的全局引擎表中，并设置为默认用于SM2等算法 if (!ENGINE_set_default(engine.get(), ENGINE_METHOD_ALL)) { std::cerr << "Failed to set engine as default" << std::endl; return false; } // 5. 增加引用计数，防止智能指针释放后引擎被意外卸载 ENGINE_up_ref(engine.get()); // 可以将 engine.release() 后的指针存储在一个全局或静态变量中，供后续使用。 // 但更常见的做法是，只要引擎成功设置默认，后续EVP接口会自动使用它。 // 这里我们确保引擎在程序生命周期内存在即可。 std::cout << "国密引擎加载成功。" << std::endl; return true; }

这段代码有几个要点：

1. 使用ENGINE_by_id("dynamic")：我们使用的是OpenSSL的“动态”引擎，它本身不实现算法，但可以加载外部实现了算法的动态库。
2. SO_PATH命令：这是告诉动态引擎，真正的算法实现在哪个.so或.dll文件里。
3. ENGINE_set_default：这是最关键的一步。它将我们加载的引擎设置为所有相关算法的默认实现。这样，当我们后续使用EVP_PKEY_CTX_new_id(EVP_PKEY_EC)并指定SM2参数时，OpenSSL就会自动路由到这个引擎来执行操作。
4. 错误处理：OpenSSL的错误信息通常存储在错误队列中，使用ERR_error_string(ERR_get_error(), nullptr)可以获取更详细的错误描述，调试时非常有用。

实操心得：引擎加载失败最常见的原因就是路径问题。一定要确保SO_PATH指定的路径绝对正确，并且程序有该文件的读取权限。在Windows上，还需要注意DLL的依赖关系，可能需要将引擎依赖的其他库（如libcrypto）也放在可访问路径下。

3. SM2密钥对生成与管理

引擎加载成功后，我们就可以开始使用SM2算法了。SM2基于椭圆曲线密码学（ECC），在OpenSSL中，它被当作一种特殊的ECC曲线来对待。密钥生成的核心是确定使用哪条曲线参数。

3.1 理解SM2的曲线参数

国密SM2标准定义了一条特定的椭圆曲线，其参数是公开的。在OpenSSL中，我们需要通过对象标识符（OID）或显式的曲线参数来创建这个椭圆曲线上下文（EC_GROUP）。幸运的是，一个正确实现的国密引擎会在内部注册这条曲线，我们只需要通过名称SM2来引用它。

3.2 生成SM2密钥对的C++封装

下面是一个Sm2KeyPair类的实现，用于生成和管理SM2密钥对。

#include <openssl/ec.h> #include <openssl/evp.h> #include <openssl/pem.h> #include <vector> #include <string> class Sm2KeyPair { public: Sm2KeyPair() : pkey_(nullptr) {} ~Sm2KeyPair() { EVP_PKEY_free(pkey_); } // 禁用拷贝，支持移动 Sm2KeyPair(const Sm2KeyPair&) = delete; Sm2KeyPair& operator=(const Sm2KeyPair&) = delete; Sm2KeyPair(Sm2KeyPair&& other) noexcept : pkey_(other.pkey_) { other.pkey_ = nullptr; } Sm2KeyPair& operator=(Sm2KeyPair&& other) noexcept { if (this != &other) { EVP_PKEY_free(pkey_); pkey_ = other.pkey_; other.pkey_ = nullptr; } return *this; } // 生成新的SM2密钥对 bool Generate() { EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr); if (!ctx) return false; if (EVP_PKEY_keygen_init(ctx) <= 0) { EVP_PKEY_CTX_free(ctx); return false; } // 关键步骤：设置曲线参数为SM2 // 引擎加载后，OpenSSL应能识别"SM2"这个曲线名称 if (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, OBJ_sn2nid("SM2")) <= 0) { // 如果通过SN（短名称）失败，可以尝试用NID直接设置。 // 一些引擎可能将SM2曲线的NID注册为特定的值，如1172（需查引擎头文件）。 // 更通用的方法是使用引擎特定的曲线名称字符串。 EVP_PKEY_CTX_free(ctx); return false; } EVP_PKEY* pkey = nullptr; if (EVP_PKEY_keygen(ctx, &pkey) <= 0) { EVP_PKEY_CTX_free(ctx); return false; } EVP_PKEY_CTX_free(ctx); pkey_ = pkey; // 接管生成的密钥 return true; } // 从PEM文件加载私钥（支持加密的PEM） bool LoadPrivateKeyFromFile(const std::string& filepath, const char* passphrase = nullptr) { FILE* fp = fopen(filepath.c_str(), "r"); if (!fp) return false; EVP_PKEY* pkey = PEM_read_PrivateKey(fp, nullptr, nullptr, const_cast<char*>(passphrase)); fclose(fp); if (!pkey) return false; EVP_PKEY_free(pkey_); // 释放旧的 pkey_ = pkey; return true; } // 从PEM文件加载公钥 bool LoadPublicKeyFromFile(const std::string& filepath) { FILE* fp = fopen(filepath.c_str(), "r"); if (!fp) return false; EVP_PKEY* pkey = PEM_read_PUBKEY(fp, nullptr, nullptr, nullptr); fclose(fp); if (!pkey) return false; EVP_PKEY_free(pkey_); pkey_ = pkey; return true; } // 将私钥保存到PEM文件（可选项：用口令加密） bool SavePrivateKeyToFile(const std::string& filepath, const char* passphrase = nullptr, const EVP_CIPHER* cipher = EVP_aes_256_cbc()) const { if (!pkey_) return false; FILE* fp = fopen(filepath.c_str(), "w"); if (!fp) return false; int ret = PEM_write_PrivateKey(fp, pkey_, cipher, const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(passphrase)), passphrase ? strlen(passphrase) : 0, nullptr, nullptr); fclose(fp); return ret == 1; } // 将公钥保存到PEM文件 bool SavePublicKeyToFile(const std::string& filepath) const { if (!pkey_) return false; FILE* fp = fopen(filepath.c_str(), "w"); if (!fp) return false; int ret = PEM_write_PUBKEY(fp, pkey_); fclose(fp); return ret == 1; } // 获取内部的EVP_PKEY指针（只读，用于后续操作） const EVP_PKEY* GetKey() const { return pkey_; } EVP_PKEY* GetKey() { return pkey_; } // 谨慎使用 private: EVP_PKEY* pkey_; };

关键点解析：

1. EVP_PKEY_CTX_set_ec_paramgen_curve_nid：这是生成SM2密钥的核心。OBJ_sn2nid("SM2")尝试通过短名称“SM2”查找对应的曲线NID。这要求国密引擎已经正确地向OpenSSL注册了这条曲线。如果失败，你可能需要查看引擎提供的头文件，找到确切的NID数值（例如#define NID_sm2 1172）并直接使用。
2. 密钥存储格式：我们使用PEM格式，这是OpenSSL中最常见、可读性较好的格式。私钥可以（也应该）用口令进行加密存储，这里示例使用了AES-256-CBC算法。
3. 资源管理：类内部使用EVP_PKEY*管理密钥，并在析构函数中释放。我们禁用了拷贝构造和拷贝赋值，但提供了移动语义，这符合资源管理类的常见做法，能有效避免双重释放。

注意事项：生成密钥对是一个比较耗时的操作（相对于对称加密）。在实际应用中，通常是在部署阶段生成一次，然后将公钥分发，私钥安全存储。不要在每次签名时都临时生成。

4. SM3哈希算法的C++封装

SM3是国密哈希算法，输出为256位（32字节）的摘要值。在OpenSSL的EVP框架下，使用SM3与使用SHA256等算法在流程上几乎一模一样，这体现了EVP接口设计的优越性。

4.1 实现Sm3Hasher类

我们封装一个简单的Sm3Hasher类，提供流式（多次更新）和一次性哈希两种接口。

#include <openssl/evp.h> #include <string> #include <vector> #include <array> class Sm3Hasher { public: Sm3Hasher() { ctx_ = EVP_MD_CTX_new(); if (ctx_) { EVP_DigestInit_ex(ctx_, EVP_sm3(), nullptr); } } ~Sm3Hasher() { if (ctx_) EVP_MD_CTX_free(ctx_); } // 重置哈希上下文，开始一次新的哈希计算 bool Reset() { return EVP_DigestInit_ex(ctx_, EVP_sm3(), nullptr) == 1; } // 更新哈希计算，可以多次调用 bool Update(const void* data, size_t len) { return EVP_DigestUpdate(ctx_, data, len) == 1; } bool Update(const std::string& str) { return Update(str.data(), str.length()); } bool Update(const std::vector<unsigned char>& vec) { return Update(vec.data(), vec.size()); } // 完成哈希计算，输出最终摘要 bool Final(std::array<unsigned char, 32>& out_digest) { // SM3输出固定32字节 unsigned int len = 32; return EVP_DigestFinal_ex(ctx_, out_digest.data(), &len) == 1 && len == 32; } // 一次性计算哈希的便捷函数 static std::array<unsigned char, 32> Calculate(const void* data, size_t len) { std::array<unsigned char, 32> digest{}; EVP_MD_CTX* ctx = EVP_MD_CTX_new(); if (ctx) { if (EVP_DigestInit_ex(ctx, EVP_sm3(), nullptr) == 1 && EVP_DigestUpdate(ctx, data, len) == 1) { unsigned int dlen = 32; EVP_DigestFinal_ex(ctx, digest.data(), &dlen); } EVP_MD_CTX_free(ctx); } return digest; } // 获取哈希上下文，用于高级操作（谨慎使用） EVP_MD_CTX* GetCtx() { return ctx_; } private: EVP_MD_CTX* ctx_; };

代码说明：

1. EVP_sm3()：这个函数返回SM3算法的EVP_MD结构体指针。同样，这依赖于国密引擎的成功加载和注册。如果引擎未加载或注册失败，此函数可能返回NULL。
2. 流式接口：Update方法允许你对大数据进行分块哈希，这对于处理文件或网络流非常有用，无需将全部数据加载到内存。
3. 输出固定：SM3的输出是固定的32字节，我们使用std::array<unsigned char, 32>来存储，比裸数组更安全方便。
4. 错误处理：示例中为了简洁，返回值是bool。在生产代码中，你可能需要更详细的错误日志，可以检查OpenSSL的错误队列。

4.2 SM3使用的简单示例

// 一次性计算字符串哈希 std::string message = "Hello, SM3!"; auto digest = Sm3Hasher::Calculate(message.data(), message.length()); // 以十六进制形式打印摘要 for (unsigned char byte : digest) { printf("%02x", byte); } printf("\n"); // 流式处理文件哈希 Sm3Hasher hasher; std::ifstream file("largefile.bin", std::ios::binary); const size_t buffer_size = 4096; std::vector<char> buffer(buffer_size); while (file.read(buffer.data(), buffer_size) || file.gcount() > 0) { hasher.Update(buffer.data(), file.gcount()); } std::array<unsigned char, 32> file_digest; if (hasher.Final(file_digest)) { // 处理文件摘要 }

5. SM2签名与验签的完整实现

有了密钥和哈希算法，我们就可以实现SM2的数字签名了。SM2的签名算法本身包含了对消息的哈希处理（通常使用SM3），并且其签名结果由两个大整数(r, s)组成。在OpenSSL EVP框架下，这些细节被很好地封装了。

5.1 签名过程的封装

SM2签名通常作用于原始消息，内部会先对消息进行SM3哈希。我们需要指定摘要算法为SM3。

class Sm2Signer { public: // 使用私钥进行初始化 explicit Sm2Signer(const Sm2KeyPair& key_pair) : pkey_(key_pair.GetKey()) { // 增加引用计数，确保密钥对象在Signer使用期间有效 if (pkey_) EVP_PKEY_up_ref(pkey_); } ~Sm2Signer() { if (pkey_) EVP_PKEY_free(pkey_); } // 对数据进行签名 bool Sign(const unsigned char* data, size_t data_len, std::vector<unsigned char>& out_signature) { if (!pkey_) return false; EVP_MD_CTX* md_ctx = EVP_MD_CTX_new(); if (!md_ctx) return false; // 初始化签名上下文，指定使用SM3作为摘要算法 if (EVP_DigestSignInit(md_ctx, nullptr, EVP_sm3(), nullptr, pkey_) != 1) { EVP_MD_CTX_free(md_ctx); return false; } // 计算签名（EVP_DigestSignUpdate可以省略，因为我们是直接对完整消息签名） // 但为了通用性，保留Update步骤，也可以处理流式数据 if (EVP_DigestSignUpdate(md_ctx, data, data_len) != 1) { EVP_MD_CTX_free(md_ctx); return false; } // 第一次调用，获取签名结果所需的缓冲区长度 size_t sig_len = 0; if (EVP_DigestSignFinal(md_ctx, nullptr, &sig_len) != 1) { EVP_MD_CTX_free(md_ctx); return false; } out_signature.resize(sig_len); // 第二次调用，实际执行签名并填充缓冲区 if (EVP_DigestSignFinal(md_ctx, out_signature.data(), &sig_len) != 1) { EVP_MD_CTX_free(md_ctx); out_signature.clear(); return false; } // 注意：sig_len可能会小于之前分配的空间，调整vector大小 out_signature.resize(sig_len); EVP_MD_CTX_free(md_ctx); return true; } bool Sign(const std::string& message, std::vector<unsigned char>& out_signature) { return Sign(reinterpret_cast<const unsigned char*>(message.data()), message.size(), out_signature); } private: EVP_PKEY* pkey_; };

5.2 验签过程的封装

验签过程与签名对称，但使用公钥。

class Sm2Verifier { public: // 使用公钥进行初始化 explicit Sm2Verifier(const Sm2KeyPair& key_pair) : pkey_(key_pair.GetKey()) { if (pkey_) EVP_PKEY_up_ref(pkey_); } ~Sm2Verifier() { if (pkey_) EVP_PKEY_free(pkey_); } // 验证签名 bool Verify(const unsigned char* data, size_t data_len, const unsigned char* signature, size_t sig_len) { if (!pkey_) return false; EVP_MD_CTX* md_ctx = EVP_MD_CTX_new(); if (!md_ctx) return false; if (EVP_DigestVerifyInit(md_ctx, nullptr, EVP_sm3(), nullptr, pkey_) != 1) { EVP_MD_CTX_free(md_ctx); return false; } if (EVP_DigestVerifyUpdate(md_ctx, data, data_len) != 1) { EVP_MD_CTX_free(md_ctx); return false; } int ret = EVP_DigestVerifyFinal(md_ctx, signature, sig_len); EVP_MD_CTX_free(md_ctx); // ret == 1 表示验证成功， ret == 0 表示验证失败， ret < 0 表示内部错误 return ret == 1; } bool Verify(const std::string& message, const std::vector<unsigned char>& signature) { return Verify(reinterpret_cast<const unsigned char*>(message.data()), message.size(), signature.data(), signature.size()); } private: EVP_PKEY* pkey_; };

5.3 签名验签完整示例

int main() { // 1. 加载国密引擎（程序启动时执行一次） if (!LoadGmEngine()) { std::cerr << "初始化失败：无法加载国密引擎。" << std::endl; return -1; } // 2. 生成或加载SM2密钥对 Sm2KeyPair key_pair; if (!key_pair.Generate()) { std::cerr << "生成SM2密钥对失败。" << std::endl; return -1; } // 可选：保存密钥对到文件 key_pair.SavePrivateKeyToFile("sm2_private.pem", "my_password"); key_pair.SavePublicKeyToFile("sm2_public.pem"); // 3. 准备待签名的消息 std::string message = "这是一条需要签名的关键交易数据。"; // 4. 签名 Sm2Signer signer(key_pair); std::vector<unsigned char> signature; if (!signer.Sign(message, signature)) { std::cerr << "签名失败。" << std::endl; return -1; } std::cout << "签名成功，签名长度: " << signature.size() << " 字节" << std::endl; // 5. 验签（通常发生在另一侧，使用公钥） // 假设我们重新加载了公钥 Sm2KeyPair pub_key_only; if (!pub_key_only.LoadPublicKeyFromFile("sm2_public.pem")) { std::cerr << "加载公钥失败。" << std::endl; return -1; } Sm2Verifier verifier(pub_key_only); if (verifier.Verify(message, signature)) { std::cout << "验签成功！数据完整且来源可信。" << std::endl; } else { std::cout << "验签失败！数据可能被篡改或签名无效。" << std::endl; } return 0; }

6. 高级话题与性能优化

基本的签名验签功能实现后，在实际项目中我们还需要考虑更多。

6.1 签名格式与标准化

OpenSSL EVP接口生成的SM2签名，通常是ASN.1 DER编码的序列，里面包含了r和s两个大整数。这是标准做法，兼容性好。但有些国密应用场景或硬件设备可能要求特定的格式，比如r和s的简单拼接（各32字节，共64字节）。你可能需要根据对接方的要求，对签名结果进行编解码转换。

// 示例：将DER编码的签名解码为r和s的原始字节（假设均为32字节） bool DerSignatureToRaw(const std::vector<unsigned char>& der_sig, std::array<unsigned char, 32>& r, std::array<unsigned char, 32>& s) { const unsigned char* p = der_sig.data(); ECDSA_SIG* ec_sig = d2i_ECDSA_SIG(nullptr, &p, der_sig.size()); if (!ec_sig) return false; const BIGNUM* sig_r = nullptr; const BIGNUM* sig_s = nullptr; ECDSA_SIG_get0(ec_sig, &sig_r, &sig_s); // 将BIGNUM转换为固定长度的字节数组，不足32字节前面补零 BN_bn2binpad(sig_r, r.data(), 32); BN_bn2binpad(sig_s, s.data(), 32); ECDSA_SIG_free(ec_sig); return true; }

6.2 错误处理与日志

上面的示例代码错误处理比较简陋。在生产环境中，必须要有完善的错误处理机制。OpenSSL的错误信息通常以错误码的形式存储在队列中。

#include <openssl/err.h> #include <sstream> std::string GetOpenSSLError() { BIO* bio = BIO_new(BIO_s_mem()); ERR_print_errors(bio); char* buf = nullptr; long len = BIO_get_mem_data(bio, &buf); std::string error_str(buf, len); BIO_free(bio); return error_str; } // 在函数中使用 bool SomeCryptoOperation() { if (/* operation fails */) { std::cerr << "操作失败: " << GetOpenSSLError() << std::endl; return false; } return true; }

6.3 多线程安全

OpenSSL 1.1.0 之后，很多基础函数已经是线程安全的了，但为了确保万无一失，尤其是在多线程环境下频繁创建销毁上下文时，最好进行适当的初始化。

#include <openssl/crypto.h> #include <mutex> std::once_flag ssl_init_flag; void InitializeOpenSSL() { std::call_once(ssl_init_flag, [](){ OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, nullptr); // 如果需要自动种子，可以调用 RAND_poll() 或类似函数 // 但更推荐由应用程序提供可靠的熵源 }); } // 在main函数或动态库加载时调用 InitializeOpenSSL();

6.4 性能考量

SM2的非对称运算比SM3/SM4对称算法慢得多。对于需要高性能签名的场景（如大量交易签名），可以考虑：

1. 异步处理：将签名操作放入线程池，避免阻塞主业务线程。
2. 硬件加速：如果条件允许，使用支持国密算法的密码卡或服务器密码机，通过引擎接口调用硬件，性能会有数量级的提升。
3. 批处理：某些硬件或优化后的软件实现可能支持批量的签名/验签，可以咨询引擎提供方。

7. 常见问题与排查技巧

在实际集成过程中，你肯定会遇到各种问题。这里记录了几个我踩过的坑和解决方法。

7.1 引擎加载失败

• 症状：ENGINE_ctrl_cmd_string返回0，或后续调用EVP_sm3()、OBJ_sn2nid("SM2")返回NULL。
• 排查：
  1. 检查路径：SO_PATH的路径是否正确？文件是否存在？是否有读取权限？
  2. 检查依赖：在Linux下使用ldd /path/to/libgmssl_engine.so，在Windows下使用Dependency Walker等工具，检查引擎依赖的其他库（如libcrypto.so）是否都能找到，且版本匹配（特别是OpenSSL 3.x）。
  3. 检查引擎兼容性：确认你下载编译的引擎版本是否与你的OpenSSL 3.x版本兼容。有些引擎可能只适配OpenSSL 1.1.x。
  4. 查看错误队列：调用GetOpenSSLError()打印详细错误。

7.2 签名或验签结果不符合预期

• 症状：本地签名验签成功，但与第三方（如Java后端、硬件设备）交互时失败。
• 排查：
  1. 数据格式：确认双方对待签名数据的编码是否一致。是原始字节、Hex字符串还是Base64？是否有额外的空格或换行符？
  2. 摘要处理：SM2签名标准（GB/T 32918.2）定义了对消息的预处理（包括对用户ID和公钥的哈希）。OpenSSL的EVP接口在EVP_DigestSignInit时，如果指定了SM2类型的PKEY和SM3摘要，通常会自动处理这个预处理过程。但有些第三方实现可能要求调用者自己完成预处理（即计算 Z = SM3(ENTL || ID || a || b || xG || yG || xA || yA) ，然后对 Z || M 进行SM3哈希）。你需要确认对接方的规范。如果对方要求自己处理，你可能需要绕过EVP接口，使用更底层的SM2_sign和SM2_verify函数（如果引擎提供了的话），并手动计算Z值。
  3. 签名格式：如上文所述，确认签名结果是DER编码格式还是裸的(r, s)拼接格式。使用openssl asn1parse -inform DER -in signature.bin可以解析DER格式的签名，看其结构是否符合预期。

7.3 内存泄漏

• 症状：长时间运行后，程序内存持续增长。
• 排查：
  1. 使用RAII：像示例代码一样，尽量用智能指针或自定义析构函数管理OpenSSL对象（EVP_PKEY_CTX,EVP_MD_CTX,ENGINE,BIO等）。
  2. 检查引用计数：EVP_PKEY_up_ref和EVP_PKEY_free要成对出现。移动语义时要注意所有权的转移。
  3. 工具辅助：在Linux下可以使用Valgrind，在Windows下可以使用Visual Studio的诊断工具来检测内存泄漏。运行程序时，确保清理了所有OpenSSL上下文。

7.4 在Windows下的编译与链接

• 问题：在Visual Studio中编译成功，但运行时崩溃或找不到符号。
• 解决：
  1. 运行时库：确保你的应用程序和所有动态库（OpenSSL、国密引擎）使用相同的运行时库（如/MD或/MDd）。
  2. 链接库：在项目属性中，正确添加OpenSSL的lib文件（如libcrypto.lib,libssl.lib）和国密引擎的lib文件（如果有的话）。
  3. DLL路径：将OpenSSL和国密引擎的DLL文件放在应用程序的可执行文件同级目录，或添加到系统的PATH环境变量中。

封装完成后，这套C++类库在我的项目中运行稳定，成功通过了与第三方系统的联调测试。最大的体会是，理解标准（国密规范）和接口（OpenSSL EVP）的设计意图，比盲目写代码更重要。尤其是在处理签名格式、摘要预处理这些细节上，多花时间阅读规范文档和引擎源码，能省去后期大量的调试时间。另外，密码学相关的代码，安全是第一位的，资源管理、错误处理必须做到滴水不漏，一个微小的泄漏或错误都可能成为安全隐患。