当前位置：首页 > news >正文

OpenSSL 3.5.2实战：C++集成SM2国密算法完整指南

news 2026/7/1 0:42:36

1. 项目概述与核心价值

最近在做一个需要国密算法支持的项目，SM2加密是绕不开的一环。虽然网上有不少关于SM2的理论介绍，但真到了用C++和OpenSSL动手实现的时候，发现能跑通、注释清晰、还附带完整源码的实战案例并不多。要么是代码片段残缺不全，要么是依赖的OpenSSL版本太老，接口对不上，调试起来非常痛苦。所以，我决定结合OpenSSL 3.5.2这个较新的稳定版本，把从环境搭建、密钥生成、数据加密解密到错误处理的完整流程彻底走一遍，并把过程中所有踩过的坑和关键细节记录下来，最终整理成这份可以直接“抄作业”的实战笔记。

这份笔记的核心价值在于“可复现性”。你不需要再去纠结OpenSSL的编译选项、头文件路径，或者面对一堆晦涩的API文档发愁。我会提供完整的、经过验证的C++源码，每一行关键代码都附有详细的注释，解释它在做什么、为什么这么做。无论你是需要在C++项目中集成国密算法，还是单纯想学习OpenSSL的EVP（高级加密接口）如何使用，这份笔记都能提供一个清晰的、从零到一的路径。我们不止讲“怎么做”，更会深入“为什么”，比如为什么选择EVP接口而不是底层的EC接口，为什么密钥格式转换是必须的，以及如何优雅地处理OpenSSL可能抛出的各种错误。

2. 环境准备与OpenSSL 3.5.2配置

2.1 OpenSSL 3.5.2的获取与编译

OpenSSL的官网下载速度有时确实令人头疼，尤其是在没有科学上网环境的情况下。一个更稳定的替代方案是使用国内的镜像源，比如清华大学开源软件镜像站。你可以直接搜索“openssl 清华大学镜像”找到下载页面，选择3.5.2版本的源码压缩包（通常是openssl-3.5.2.tar.gz），下载速度会快很多。

下载完成后，在Linux或WSL（Windows Subsystem for Linux）环境下进行编译是最推荐的方式，因为过程最清晰，依赖问题最少。如果你必须在纯Windows上使用，也可以使用MSYS2或Cygwin环境来模拟，但步骤会复杂一些。这里以Ubuntu/WSL环境为例：

# 1. 解压源码 tar -xzf openssl-3.5.2.tar.gz cd openssl-3.5.2 # 2. 配置编译选项 # `--prefix` 指定安装目录，方便管理，我通常放在 `/usr/local/openssl-3.5.2` # `shared` 生成动态链接库（.so文件），方便程序链接 # `no-asm` 对于初学者，可以先禁用汇编优化，避免因环境问题编译失败 ./config --prefix=/usr/local/openssl-3.5.2 shared no-asm # 3. 编译。`-j$(nproc)` 表示使用所有CPU核心并行编译，加快速度 make -j$(nproc) # 4. 安装到指定目录 sudo make install

编译安装完成后，关键是要让你的编译器和链接器能找到它。你需要设置两个环境变量：

export OPENSSL_ROOT_DIR=/usr/local/openssl-3.5.2 export LD_LIBRARY_PATH=$OPENSSL_ROOT_DIR/lib:$LD_LIBRARY_PATH

OPENSSL_ROOT_DIR用于告诉CMake或直接告诉g++头文件和库文件在哪里。LD_LIBRARY_PATH是为了让系统在运行时能找到我们新编译的动态库，否则运行程序时会报“找不到libcrypto.so”之类的错误。你可以把这两行加到你的~/.bashrc文件中，使其永久生效。

注意：OpenSSL 3.x 版本与老旧的 1.0.x 或 1.1.x 版本在API和库结构上有显著区别。3.x 版本引入了Provider（提供者）概念，模块化更强，默认的算法集也可能不同。确保你的系统没有安装其他版本OpenSSL的干扰，尤其是/usr/lib或/usr/local/lib下的旧版本libcrypto.so文件，可能会造成链接或运行时冲突。一个检查方法是运行/usr/local/openssl-3.5.2/bin/openssl version，确认输出是 “OpenSSL 3.5.2”。

2.2 C++开发环境与项目配置

我个人的主力开发环境是VSCode + CMake，这套组合在管理C++项目，特别是处理像OpenSSL这样的外部依赖时非常高效。你不需要去手动配置复杂的c_cpp_properties.json来设置包含路径，CMake可以帮你搞定一切。

首先，确保你的系统安装了必要的编译工具链和CMake。在Ubuntu上，可以运行：

sudo apt update sudo apt install build-essential cmake

接下来，我们创建一个最简单的项目结构，并使用CMake来定位和链接OpenSSL。项目目录结构如下：

sm2_demo/ ├── CMakeLists.txt ├── include/ │ └── sm2_crypto.h └── src/ ├── sm2_crypto.cpp └── main.cpp

最核心的是CMakeLists.txt文件，它的内容如下：

cmake_minimum_required(VERSION 3.10) project(SM2Demo LANGUAGES CXX) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 关键步骤：查找OpenSSL库 # 这里显式指定了我们自定义的安装路径 set(OPENSSL_ROOT_DIR /usr/local/openssl-3.5.2) find_package(OpenSSL REQUIRED) # 打印找到的OpenSSL信息，用于确认 message(STATUS "OpenSSL include dir: ${OPENSSL_INCLUDE_DIR}") message(STATUS "OpenSSL libraries: ${OPENSSL_LIBRARIES}") # 添加可执行文件 add_executable(sm2_demo src/main.cpp src/sm2_crypto.cpp ) # 将头文件目录包含进来 target_include_directories(sm2_demo PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include ${OPENSSL_INCLUDE_DIR} ) # 链接OpenSSL库 target_link_libraries(sm2_demo PRIVATE ${OPENSSL_LIBRARIES} )

这个CMake脚本做了几件关键事：1）通过find_package命令，利用我们设置的OPENSSL_ROOT_DIR变量来定位OpenSSL。2）将找到的头文件路径和库文件自动关联到我们的sm2_demo目标上。这样，在sm2_crypto.cpp中，你就可以直接#include <openssl/evp.h>而不会报错了。

实操心得：如果你在Windows上使用Visual Studio，并且通过vcpkg安装了OpenSSL，CMake的find_package命令通常也能正常工作，但可能需要额外传递-DCMAKE_TOOLCHAIN_FILE=[vcpkg路径]/scripts/buildsystems/vcpkg.cmake参数给cmake命令。另一个常见错误是“error: Microsoft Visual C++ 14.0 or greater is required”，这通常意味着你的CMake在尝试使用MSVC编译器，但你的Visual Studio Build Tools版本太旧或没安装完整。确保安装了最新版的Visual Studio 2022并包含了“使用C++的桌面开发”工作负载。

3. SM2加密核心原理与OpenSSL EVP接口设计

3.1 SM2算法简介与密钥体系

SM2是国家密码管理局发布的一套非对称密码算法标准，属于椭圆曲线密码（ECC）的一种。它包含数字签名、密钥交换和公钥加密三个功能。我们这里实现的是公钥加密算法。与RSA不同，SM2基于椭圆曲线离散对数问题，在同等安全强度下，所需的密钥长度更短（256位SM2约等于3072位RSA），加解密速度也更有优势。

SM2的密钥对包括一个私钥（一个随机生成的大整数）和一个公钥（由私钥和椭圆曲线基点计算得到的一个曲线上的点）。在OpenSSL中，椭圆曲线相关的操作都在crypto/ec.h中，但OpenSSL 3.x 强烈推荐使用更高级、更统一的EVP（Enveloped）接口。EVP接口抽象了具体的算法实现，通过“算法名称”和“操作类型”（加密、解密、签名等）来调用，代码更简洁，且更容易切换算法（比如从SM2换成RSA）。

我们的设计目标是封装一个SM2Crypto类，提供以下功能：

生成SM2密钥对。
将密钥对以PEM格式保存到文件或从文件加载。
使用公钥加密任意长度的数据。
使用私钥解密数据。
完善的错误处理和内存管理。

3.2 核心数据结构与内存管理

OpenSSL中，EVP接口的核心对象是EVP_PKEY，它代表一个非对称密钥，可以承载RSA、EC（包括SM2）等类型的密钥。对于SM2，其底层是EC_KEY。我们的类将围绕EVP_PKEY进行封装。

OpenSSL 1.1.x 之后，很多对象提供了引用计数自动管理（如EVP_PKEY用EVP_PKEY_free）。但为了绝对的安全和清晰的资源生命周期，我倾向于遵循“谁申请，谁释放”和“成对出现”的原则。我们将使用C++的RAII（Resource Acquisition Is Initialization）思想，在构造函数中分配资源，在析构函数中释放。但为了代码清晰和专注于OpenSSL API本身，笔记中的示例会显式调用EVP_PKEY_free()等函数，在实际项目中你可以用std::unique_ptr配合自定义删除器来包装。

一个关键点是，SM2加密并非直接加密原始数据，它通常需要一个对称加密算法（如SM4或AES）来加密数据本体，然后用SM2公钥加密这个对称密钥。这就是所谓的“混合加密”机制。但OpenSSL的EVP接口在调用EVP_PKEY_encrypt时，其实内部已经帮我们处理了这套流程（使用一个内置的密钥派生函数和对称加密），我们只需要关心输入数据和输出缓冲区即可。

4. 完整代码实现与逐行解析

4.1 头文件定义与类设计

首先，我们来看头文件include/sm2_crypto.h：

#ifndef SM2_CRYPTO_H #define SM2_CRYPTO_H #include <string> #include <vector> #include <memory> /** * @brief SM2加密解密工具类 (基于OpenSSL 3.x EVP接口) * * 这个类封装了SM2密钥生成、PEM格式读写、数据加密和解密的核心操作。 * 注意：本类方法非线程安全，在多线程环境下使用需外部加锁。 */ class SM2Crypto { public: SM2Crypto(); ~SM2Crypto(); // 禁止拷贝构造和赋值，因为管理着OpenSSL资源 SM2Crypto(const SM2Crypto&) = delete; SM2Crypto& operator=(const SM2Crypto&) = delete; // 允许移动语义 SM2Crypto(SM2Crypto&& other) noexcept; SM2Crypto& operator=(SM2Crypto&& other) noexcept; /** * @brief 生成一个新的SM2密钥对 * @return bool 成功返回true，失败返回false */ bool generateKey(); /** * @brief 从PEM格式文件加载私钥 * @param privKeyPath 私钥文件路径 * @return bool 成功返回true，失败返回false */ bool loadPrivateKeyFromFile(const std::string& privKeyPath); /** * @brief 从PEM格式文件加载公钥 * @param pubKeyPath 公钥文件路径 * @return bool 成功返回true，失败返回false */ bool loadPublicKeyFromFile(const std::string& pubKeyPath); /** * @brief 将私钥保存为PEM格式文件 * @param privKeyPath 目标文件路径 * @return bool 成功返回true，失败返回false */ bool savePrivateKeyToFile(const std::string& privKeyPath) const; /** * @brief 将公钥保存为PEM格式文件 * @param pubKeyPath 目标文件路径 * @return bool 成功返回true，失败返回false */ bool savePublicKeyToFile(const std::string& pubKeyPath) const; /** * @brief 使用当前公钥加密数据 * @param plaintext 明文字符串 * @return std::vector<unsigned char> 成功返回密文数据，失败返回空vector */ std::vector<unsigned char> encrypt(const std::string& plaintext); /** * @brief 使用当前私钥解密数据 * @param ciphertext 密文数据 * @return std::string 成功返回明文字符串，失败返回空字符串 */ std::string decrypt(const std::vector<unsigned char>& ciphertext); /** * @brief 获取最后一条错误信息 * @return std::string 错误描述 */ std::string getLastError() const { return lastError_; } private: // 内部的OpenSSL密钥对象 void* pkey_ = nullptr; // 实际是 EVP_PKEY*，这里用void*避免暴露OpenSSL类型 // 存储最后一次操作的错误信息 mutable std::string lastError_; // 内部方法：清理资源 void cleanup(); // 内部方法：记录错误 void setError(const std::string& msg) const; }; #endif // SM2_CRYPTO_H

设计解析：

资源管理：使用void*隐藏EVP_PKEY*类型细节，避免用户代码直接依赖OpenSSL头文件。析构函数和cleanup()方法确保资源释放。
错误处理：每个公开方法都返回bool或有效数据，通过getLastError()获取详细错误信息，这比直接抛出异常或返回错误码更符合很多C++项目的习惯。
移动语义：提供了移动构造和移动赋值，方便在容器中高效存储对象或进行所有权转移。
接口简洁：加密解密接口直接接受std::string和std::vector<unsigned char>，这是C++中最常用的二进制数据容器，避免了手动管理C风格数组的麻烦。

4.2 核心实现：密钥生成与PEM文件操作

接下来是核心的实现文件src/sm2_crypto.cpp。我们首先包含必要的头文件并定义一些内部辅助函数：

#include "sm2_crypto.h" #include <openssl/evp.h> #include <openssl/pem.h> #include <openssl/err.h> #include <openssl/ec.h> #include <fstream> #include <sstream> #include <cstring> // 为了方便，在内部将void*转换回EVP_PKEY* #define INTERNAL_KEY (reinterpret_cast<EVP_PKEY*>(pkey_)) SM2Crypto::SM2Crypto() : pkey_(nullptr) {} SM2Crypto::~SM2Crypto() { cleanup(); } void SM2Crypto::cleanup() { if (pkey_) { EVP_PKEY_free(INTERNAL_KEY); pkey_ = nullptr; } } void SM2Crypto::setError(const std::string& msg) const { lastError_ = msg; // 可以附加OpenSSL的错误队列信息，更利于调试 char errBuf[256]; ERR_error_string_n(ERR_get_error(), errBuf, sizeof(errBuf)); lastError_ += " (OpenSSL: "; lastError_ += errBuf; lastError_ += ")"; }

关键点1：错误信息获取。ERR_get_error()和ERR_error_string_n()是获取OpenSSL内部错误队列信息的标准方法，它能提供比简单返回false详细得多的调试信息，比如是文件读写出错还是密钥格式解析出错。

现在来看密钥生成函数generateKey()：

bool SM2Crypto::generateKey() { cleanup(); // 生成新密钥前先清理旧的 lastError_.clear(); // 1. 创建椭圆曲线密钥生成上下文 EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr); if (!pctx) { setError("Failed to create EC key generation context"); return false; } // 2. 初始化密钥生成操作 if (EVP_PKEY_keygen_init(pctx) <= 0) { setError("Failed to initialize key generation"); EVP_PKEY_CTX_free(pctx); return false; } // 3. 设置椭圆曲线参数为SM2曲线 // 在OpenSSL中，SM2曲线通常使用`SM2`标识或特定的NID。 // OpenSSL 3.x 中，SM2曲线的标准名称是 "SM2" if (EVP_PKEY_CTX_set_ec_paramgen_curve_name(pctx, NID_sm2) <= 0) { // 如果上面的NID_sm2不可用，可以尝试通过字符串设置 // 但更可靠的方式是检查OpenSSL版本和编译选项是否支持SM2 setError("Failed to set EC curve to SM2. Is OpenSSL compiled with SM2 support?"); EVP_PKEY_CTX_free(pctx); return false; } // 4. 执行密钥生成 EVP_PKEY* pkey = nullptr; if (EVP_PKEY_keygen(pctx, &pkey) <= 0) { setError("Failed to generate SM2 key pair"); EVP_PKEY_CTX_free(pctx); return false; } // 5. 清理上下文，保存生成的密钥 EVP_PKEY_CTX_free(pctx); pkey_ = pkey; // 所有权转移给成员变量 return true; }

关键点2：SM2曲线标识。NID_sm2是OpenSSL中代表SM2曲线的对象标识符。确保你的OpenSSL在编译时启用了SM2支持（默认通常是开启的）。如果编译时未启用，这一步会失败。你可以通过命令openssl ecparam -list_curves | grep -i sm2来验证。

接下来是PEM文件读写。PEM是一种基于Base64编码的文本格式，广泛用于存储证书和密钥。

bool SM2Crypto::savePrivateKeyToFile(const std::string& privKeyPath) const { if (!pkey_) { setError("No key loaded for saving"); return false; } // 使用BIO（Basic I/O）抽象层来写文件，比直接写FILE*更灵活 BIO* bio = BIO_new_file(privKeyPath.c_str(), "w"); if (!bio) { setError("Failed to create BIO for file: " + privKeyPath); return false; } // 将私钥以PEM格式写入BIO（即写入文件） // 第三个参数是加密私钥的密码算法和密码，这里传nullptr表示不加密保存。 // 实际生产环境，私钥必须加密保存！可以使用类似 `EVP_aes_256_cbc()` 和密码。 int ret = PEM_write_bio_PrivateKey(bio, INTERNAL_KEY, nullptr, nullptr, 0, nullptr, nullptr); BIO_free_all(bio); // 释放BIO，无论成功与否 if (ret != 1) { setError("Failed to write private key to PEM file"); return false; } return true; } bool SM2Crypto::savePublicKeyToFile(const std::string& pubKeyPath) const { if (!pkey_) { setError("No key loaded for saving"); return false; } BIO* bio = BIO_new_file(pubKeyPath.c_str(), "w"); if (!bio) { setError("Failed to create BIO for file: " + pubKeyPath); return false; } int ret = PEM_write_bio_PUBKEY(bio, INTERNAL_KEY); // 写入公钥 BIO_free_all(bio); if (ret != 1) { setError("Failed to write public key to PEM file"); return false; } return true; }

关键点3：私钥加密。PEM_write_bio_PrivateKey函数的第3、4个参数用于指定加密算法和密码。示例中传了nullptr，意味着私钥以明文保存。这在任何生产环境都是极度危险的！正确的做法是提供一个密码（passphrase）和一个加密算法（如EVP_aes_256_cbc()）。加载加密私钥时，也需要提供相同的密码。

加载密钥的函数与之对称：

bool SM2Crypto::loadPrivateKeyFromFile(const std::string& privKeyPath) { cleanup(); lastError_.clear(); BIO* bio = BIO_new_file(privKeyPath.c_str(), "r"); if (!bio) { setError("Failed to open private key file: " + privKeyPath); return false; } // 读取PEM格式的私钥。如果私钥文件是加密的，需要提供密码回调函数。 // 这里假设私钥文件未加密。 EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr); BIO_free_all(bio); if (!pkey) { setError("Failed to parse private key from PEM file. Wrong format or encrypted?"); return false; } // 可选：验证加载的密钥是否是EC密钥且曲线是SM2 // 但PEM_read_bio_PrivateKey已经能正确解析，这里为了严谨可以检查 pkey_ = pkey; return true; } bool SM2Crypto::loadPublicKeyFromFile(const std::string& pubKeyPath) { cleanup(); lastError_.clear(); BIO* bio = BIO_new_file(pubKeyPath.c_str(), "r"); if (!bio) { setError("Failed to open public key file: " + pubKeyPath); return false; } EVP_PKEY* pkey = PEM_read_bio_PUBKEY(bio, nullptr, nullptr, nullptr); BIO_free_all(bio); if (!pkey) { setError("Failed to parse public key from PEM file."); return false; } pkey_ = pkey; return true; }

4.3 核心实现：数据加密与解密

这是最核心的部分，展示了如何使用EVP接口进行非对称加密解密。

std::vector<unsigned char> SM2Crypto::encrypt(const std::string& plaintext) { std::vector<unsigned char> ciphertext; if (!pkey_) { setError("No public key loaded for encryption"); return ciphertext; // 返回空vector } lastError_.clear(); // 1. 创建加密上下文 EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(INTERNAL_KEY, nullptr); if (!ctx) { setError("Failed to create encryption context"); return ciphertext; } // 2. 初始化加密操作 if (EVP_PKEY_encrypt_init(ctx) <= 0) { setError("Failed to initialize encryption"); EVP_PKEY_CTX_free(ctx); return ciphertext; } // 3. 设置加密参数（如果需要）。对于SM2，OpenSSL有默认的填充和摘要算法。 // 国密标准中，SM2加密通常使用SM3作为摘要算法。OpenSSL 3.x 的默认Provider可能已配置好。 // 我们可以显式设置摘要算法为SM3，确保符合标准。 if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sm3()) <= 0) { // 如果设置失败，可能是SM3算法不可用，但加密仍可能继续使用默认算法。 // 这里记录警告，但不作为失败。生产环境应确保SM3可用。 // setError("Warning: Failed to set SM3 digest for encryption, using default."); } // 4. 计算加密后所需缓冲区的长度 size_t ciphertext_len = 0; if (EVP_PKEY_encrypt(ctx, nullptr, &ciphertext_len, reinterpret_cast<const unsigned char*>(plaintext.data()), plaintext.size()) <= 0) { setError("Failed to get ciphertext buffer size"); EVP_PKEY_CTX_free(ctx); return ciphertext; } // 5. 分配缓冲区并执行加密 ciphertext.resize(ciphertext_len); if (EVP_PKEY_encrypt(ctx, ciphertext.data(), &ciphertext_len, reinterpret_cast<const unsigned char*>(plaintext.data()), plaintext.size()) <= 0) { setError("Encryption failed"); ciphertext.clear(); EVP_PKEY_CTX_free(ctx); return ciphertext; } // 注意：ciphertext_len 可能小于之前分配的大小，调整vector大小。 ciphertext.resize(ciphertext_len); EVP_PKEY_CTX_free(ctx); return ciphertext; }

关键点4：两次调用模式。这是OpenSSL EVP接口处理变长输出的经典模式：第一次调用时，将输出缓冲区指针设为nullptr，函数会通过ciphertext_len参数返回所需的缓冲区大小。第二次调用才真正执行操作。这避免了缓冲区溢出。

解密过程是加密的逆过程：

std::string SM2Crypto::decrypt(const std::vector<unsigned char>& ciphertext) { std::string plaintext; if (!pkey_) { setError("No private key loaded for decryption"); return plaintext; // 返回空字符串 } lastError_.clear(); EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(INTERNAL_KEY, nullptr); if (!ctx) { setError("Failed to create decryption context"); return plaintext; } if (EVP_PKEY_decrypt_init(ctx) <= 0) { setError("Failed to initialize decryption"); EVP_PKEY_CTX_free(ctx); return plaintext; } // 同样，可以尝试设置摘要算法为SM3以匹配加密端 if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sm3()) <= 0) { // 记录警告 } // 获取解密后明文长度 size_t plaintext_len = 0; if (EVP_PKEY_decrypt(ctx, nullptr, &plaintext_len, ciphertext.data(), ciphertext.size()) <= 0) { setError("Failed to get plaintext buffer size"); EVP_PKEY_CTX_free(ctx); return plaintext; } // 分配缓冲区并执行解密 std::vector<unsigned char> plaintext_buf(plaintext_len); if (EVP_PKEY_decrypt(ctx, plaintext_buf.data(), &plaintext_len, ciphertext.data(), ciphertext.size()) <= 0) { setError("Decryption failed. Invalid ciphertext or key mismatch?"); EVP_PKEY_CTX_free(ctx); return plaintext; } plaintext_buf.resize(plaintext_len); plaintext.assign(reinterpret_cast<const char*>(plaintext_buf.data()), plaintext_len); EVP_PKEY_CTX_free(ctx); return plaintext; }

关键点5：解密失败的原因。解密失败最常见的原因有三个：1）使用的私钥与加密公钥不配对。2）密文在传输或存储过程中被损坏。3）加密和解密时使用的算法参数（如摘要算法）不一致。我们的代码中尝试设置了SM3摘要算法，但如果加密端使用的是OpenSSL默认算法（可能是SHA256），而解密端强制设置SM3，就会导致失败。在实际跨系统、跨库（如用Java的Hutool加密，C++解密）时，必须严格约定并测试算法参数。

4.4 主程序示例与测试

最后，我们写一个简单的main.cpp来测试整个流程：

#include "sm2_crypto.h" #include <iostream> #include <iomanip> int main() { SM2Crypto crypto; std::cout << "1. Generating SM2 key pair..." << std::endl; if (!crypto.generateKey()) { std::cerr << "Key generation failed: " << crypto.getLastError() << std::endl; return 1; } std::cout << " Key pair generated successfully." << std::endl; std::cout << "2. Saving keys to files..." << std::endl; if (!crypto.savePrivateKeyToFile("sm2_private.pem")) { std::cerr << "Failed to save private key: " << crypto.getLastError() << std::endl; return 1; } if (!crypto.savePublicKeyToFile("sm2_public.pem")) { std::cerr << "Failed to save public key: " << crypto.getLastError() << std::endl; return 1; } std::cout << " Keys saved as 'sm2_private.pem' and 'sm2_public.pem'." << std::endl; std::string originalText = "这是一段需要加密的敏感数据，Hello SM2!"; std::cout << "3. Original text: \"" << originalText << "\"" << std::endl; std::cout << "4. Encrypting with public key..." << std::endl; auto ciphertext = crypto.encrypt(originalText); if (ciphertext.empty()) { std::cerr << "Encryption failed: " << crypto.getLastError() << std::endl; return 1; } std::cout << " Encryption succeeded. Ciphertext (hex): "; for (unsigned char c : ciphertext) { std::cout << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(c); } std::cout << std::dec << std::endl; // 模拟：现在用另一个SM2Crypto实例加载私钥来解密 std::cout << "\n5. Creating a new crypto instance to load private key and decrypt..." << std::endl; SM2Crypto decryptor; if (!decryptor.loadPrivateKeyFromFile("sm2_private.pem")) { std::cerr << "Failed to load private key for decryption: " << decryptor.getLastError() << std::endl; return 1; } std::cout << "6. Decrypting ciphertext..." << std::endl; std::string decryptedText = decryptor.decrypt(ciphertext); if (decryptedText.empty()) { std::cerr << "Decryption failed: " << decryptor.getLastError() << std::endl; return 1; } std::cout << " Decryption succeeded." << std::endl; std::cout << "7. Decrypted text: \"" << decryptedText << "\"" << std::endl; if (originalText == decryptedText) { std::cout << "\nSUCCESS: Original and decrypted texts match!" << std::endl; } else { std::cout << "\nFAILURE: Texts do not match!" << std::endl; return 1; } return 0; }

使用CMake构建并运行：

mkdir build && cd build cmake .. -DCMAKE_BUILD_TYPE=Release make ./sm2_demo

如果一切顺利，你将看到密钥生成、保存、加密、解密的完整流程，并最终验证原文和解密文一致。

5. 常见问题排查与进阶技巧

5.1 编译与链接问题

问题1：fatal error: openssl/evp.h: No such file or directory

原因：编译器找不到OpenSSL头文件。
解决：确保OPENSSL_ROOT_DIR环境变量或CMake中的路径设置正确，并且find_package(OpenSSL REQUIRED)成功。可以在CMake输出中查看OpenSSL include dir:的路径是否正确。

问题2：undefined reference toEVP_PKEY_CTX_new_id‘` 等链接错误

原因：链接器找不到OpenSSL库文件（libcrypto.so）。
解决：
1. 确认CMake的target_link_libraries包含了${OPENSSL_LIBRARIES}。
2. 确认OpenSSL已正确编译安装，并且LD_LIBRARY_PATH包含了其lib目录。
3. 运行时如果还报错，可以尝试ldd ./sm2_demo查看libcrypto.so的链接路径是否正确。

问题3：EVP_PKEY_CTX_set_ec_paramgen_curve_name失败，返回0

原因：OpenSSL编译时未包含SM2支持，或者曲线名称NID_sm2未定义。
解决：
1. 检查OpenSSL版本和编译配置。可以运行/usr/local/openssl-3.5.2/bin/openssl list -public-key-algorithms查看是否包含SM2。
2. 尝试使用曲线名称字符串：EVP_PKEY_CTX_ctrl_str(pctx, "ec_paramgen_curve_name", "SM2")。但更根本的解决方法是重新编译支持SM2的OpenSSL。

5.2 运行时与逻辑问题

问题4：加密或解密返回空结果，getLastError()显示操作失败

排查步骤：
1. 检查密钥：确认用于加密的是公钥文件，用于解密的是对应的私钥文件。可以用openssl pkey -in sm2_private.pem -text -noout和openssl pkey -pubin -in sm2_public.pem -text -noout查看密钥信息，确认它们是一对。
2. 检查数据：确保待加密的数据不是空字符串。确保传递给解密函数的数据是完整的、未损坏的密文。
3. 启用详细错误：在setError函数中，我们已附加了OpenSSL的错误队列信息。仔细阅读这个错误信息，它通常能指明方向，比如“invalid padding”、“unsupported algorithm”等。
4. 算法参数匹配：这是跨平台/跨语言交互时最常见的问题。SM2加密标准中规定了使用SM3作为摘要算法。如果你用此代码加密，但用另一个默认使用SHA256的库（如早期版本的某些国密库）解密，就会失败。务必在加密和解密两端使用相同的算法参数。在我们的代码中，我们尝试用EVP_PKEY_CTX_set_signature_md(ctx, EVP_sm3())进行设置。确保你的OpenSSL支持SM3（EVP_sm3()函数存在）。

问题5：如何加密更长的数据？

原理：如之前所述，OpenSSL的EVP_PKEY_encrypt内部实现了混合加密机制。它实际上是用SM2公钥加密一个随机生成的对称密钥（比如SM4密钥），然后用这个对称密钥去加密你的原始数据。所以，理论上它可以加密任意长度的数据。你不需要自己分块。OpenSSL内部会处理好的。你直接传入长字符串即可。

5.3 生产环境进阶考量

1. 私钥的安全存储示例代码中私钥以明文保存，这是绝对不允许的。生产环境中必须加密存储。修改savePrivateKeyToFile和loadPrivateKeyFromFile，使用密码和加密算法：

// 加密保存示例 int (*password_callback)(char *buf, int size, int rwflag, void *u) = ...; // 你的密码回调函数 EVP_CIPHER* cipher = EVP_aes_256_cbc(); // 使用AES-256-CBC加密 PEM_write_bio_PrivateKey(bio, INTERNAL_KEY, cipher, nullptr, 0, password_callback, "my_password"); // 加密加载示例 EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio, nullptr, password_callback, (void*)"my_password");

2. 错误处理的增强当前的setError只获取了错误队列中的最后一条错误。OpenSSL的错误可能是一个链。为了更好的调试，可以循环调用ERR_get_error()直到返回0，获取所有错误信息。

3. 性能与线程安全EVP_PKEY_CTX对象不是线程安全的。如果需要在多线程中频繁加解密，每个线程应该创建自己的上下文对象。对于高性能场景，可以考虑缓存初始化后的EVP_PKEY_CTX，但要注意线程隔离。

4. 与其他系统交互（如Java Hutool）如果你需要与此C++代码生成的密文在Java端（例如使用Hutool的SM2工具）进行互操作，最大的挑战在于算法参数标识和编码格式。

曲线标识：双方必须使用同一条SM2曲线（通常是sm2p256v1）。
摘要算法：必须明确指定并使用相同的摘要算法（SM2国标规定使用SM3）。
密文编码：OpenSSL默认输出的密文是DER编码的ASN.1结构（包含C1, C2, C3三个部分）。而有些国密库或Java实现可能使用简单的C1C2C3拼接，或者C1C3C2拼接。这是互操作失败的最常见原因。
- 解决方案：你需要仔细查阅双方库的文档，看密文的输出格式。OpenSSL可以通过EVP_PKEY_CTX_ctrl_str(ctx, "ciphertext-format", "standard")或类似控制命令来尝试调整输出格式（但并非所有版本都支持）。更可靠的方法是，在加密后，自己解析OpenSSL输出的ASN.1结构，然后按照对方要求的顺序（C1C2C3或C1C3C2）重新拼接字节数组。这需要你对SM2密文的结构有深入了解。

实现一个完整的、健壮的、可用于生产环境的SM2加密模块，远不止调用几个API那么简单。它涉及安全的密钥管理、精确的算法参数控制、完善的错误处理以及与外部系统的兼容性考量。这份笔记提供了一个坚实可靠的起点，你可以基于此，根据项目的具体需求进行加固和扩展。

查看全文

http://www.jsqmd.com/news/1099229/