如何在嵌入式设备中精简OpenSSL？手把手教你只移植SM4算法（附VS工程配置）
嵌入式国密SM4算法移植实战：从OpenSSL库中精准剥离与工程化构建
在嵌入式开发领域，资源受限是常态。无论是微控制器（MCU）还是边缘计算设备，内存和存储空间往往捉襟见肘。当项目需要加密功能时，直接引入完整的OpenSSL库显然不现实——动辄数兆的二进制体积对大多数嵌入式平台来说都是难以承受之重。SM4作为我国自主设计的商用密码算法，因其高效性和安全性在物联网、工业控制等领域应用日益广泛。如何在保证功能完整性的前提下，将SM4算法从庞大的OpenSSL库中精准剥离，实现最小化移植，是每个嵌入式开发者都需要掌握的核心技能。
这篇文章将带你深入OpenSSL源码结构，手把手教你如何从零开始提取SM4算法模块，构建独立的、可移植的C语言实现。不同于简单的代码复制粘贴，我们将从工程化角度出发，探讨模块化设计、依赖解耦、跨平台适配等实际问题，并提供完整的Visual Studio工程配置方案。无论你是正在开发智能家居设备的安全通信模块，还是为工业控制器添加数据加密功能，这套方法论都能为你提供切实可行的技术路径。
1. 理解OpenSSL源码结构与SM4算法定位
OpenSSL作为一个功能齐全的密码学工具箱，其源码组织遵循着清晰的模块化设计。理解这种结构是成功提取特定算法的前提。整个库的核心目录包括crypto/、include/、ssl/等，其中crypto/目录包含了所有密码学算法的实现。
1.1 OpenSSL源码目录解析
让我们先看看OpenSSL 3.x版本的典型目录结构：
openssl/
├── crypto/ # 密码算法核心实现
│ ├── sm4/ # SM4算法实现目录
│ │ ├── sm4.c
│ │ ├── sm4_local.h
│ │ └── build.info
│ ├── modes/ # 加密模式（CBC、CTR、GCM等）
│ ├── evp/ # 高层加密接口
│ └── ...
├── include/ # 公共头文件
│ ├── openssl/
│ │ ├── sm4.h # SM4公共API头文件
│ │ └── ...
│ └── crypto/ # 内部头文件
│ └── sm4.h # SM4内部头文件
└── ...
SM4算法的实现主要分布在两个关键位置：crypto/sm4/目录下的实现文件，以及include/crypto/sm4.h这个内部头文件。公开的API头文件include/openssl/sm4.h通常只是对内部头文件的简单包装。
注意：OpenSSL 1.1.x和3.x版本在源码组织上有显著差异。3.x版本引入了更多的模块化设计，但基本算法实现的位置相对稳定。建议使用较新的3.x版本进行提取，因为其代码结构更清晰，依赖关系更明确。
1.2 SM4算法在OpenSSL中的实现特点
SM4在OpenSSL中的实现有几个值得注意的技术特点：
- 纯C语言实现：没有依赖特定平台的汇编优化，这为跨平台移植提供了便利
- 分组密码结构：标准的Feistel网络结构，32轮迭代
- 密钥扩展算法：将128位主密钥扩展为32个32位轮密钥
- 加解密对称性：加密和解密使用相同的算法结构，只是轮密钥的使用顺序相反
在代码层面，SM4的核心函数通常以ossl_sm4_前缀开头，这是OpenSSL 3.x版本的命名约定。主要函数包括：
// 密钥扩展函数
int ossl_sm4_set_key(const uint8_t *key, SM4_KEY *ks);
// 加密函数（ECB模式）
void ossl_sm4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
// 解密函数（ECB模式）
void ossl_sm4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
这些函数构成了SM4算法的核心，但OpenSSL的实现中还包含了许多优化技巧，比如使用预计算的S盒查找表、循环展开等。理解这些实现细节对于后续的裁剪和优化至关重要。
1.3 依赖关系分析
在开始提取之前，我们需要分析SM4模块的依赖关系。通过查看sm4.c的包含头文件，可以发现几个关键依赖：
#include "crypto/sm4.h"
#include <openssl/e_os2.h>
#include <stdint.h>
其中e_os2.h主要定义了平台相关的宏和类型别名，而stdint.h是C99标准头文件。更重要的是，我们需要检查sm4.h中是否引入了其他OpenSSL特定的依赖。
通过分析，SM4算法的依赖相对简单，主要涉及：
- 基本数据类型定义（uint32_t等）
- 字节序处理宏
- 内联函数支持
这种相对简单的依赖关系使得SM4成为从OpenSSL中提取的较理想候选算法。
2. 工程化提取：构建独立的SM4模块
直接从OpenSSL复制文件到你的项目只是第一步，真正的挑战在于如何将这些代码改造成一个自包含的、可移植的模块。这个过程需要系统性的思考和精细的操作。
2.1 创建最小化文件集合
首先，我们需要确定必需的文件清单。对于SM4算法，最少需要以下文件：
| 文件 | 来源路径 | 作用 |
|---|---|---|
sm4.c | crypto/sm4/ | SM4算法核心实现 |
sm4.h | include/crypto/ | SM4算法内部头文件 |
sm4_local.h | crypto/sm4/ | SM4算法本地头文件（如果存在） |
在实际操作中，我建议创建一个专门的目录结构来管理提取的算法：
your_project/
├── src/
│ ├── crypto/
│ │ └── sm4/
│ │ ├── sm4.c
│ │ └── sm4_local.h
│ └── main.c
├── include/
│ └── crypto/
│ └── sm4.h
└── build/
└── ... (构建文件)
这种结构保持了与OpenSSL相似的目录布局，便于后续维护和更新。
2.2 头文件改造：移除OpenSSL特定依赖
OpenSSL的头文件通常包含大量条件编译和平台检测代码，我们需要将其精简为最简形式。以sm4.h为例，原始文件可能包含：
#ifndef OPENSSL_NO_SM4
# ifdef __cplusplus
extern "C" {
# endif
# include <openssl/opensslconf.h>
# include <openssl/e_os2.h>
# define SM4_BLOCK_SIZE 16
# define SM4_KEY_SCHEDULE 32
typedef struct sm4_key_st {
uint32_t rk[SM4_KEY_SCHEDULE];
} SM4_KEY;
int SM4_set_key(const uint8_t *key, SM4_KEY *ks);
void SM4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
void SM4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
# ifdef __cplusplus
}
# endif
#endif
改造后的版本应该移除所有OpenSSL特定的宏和条件编译：
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stddef.h>
#define SM4_BLOCK_SIZE 16
#define SM4_KEY_SCHEDULE 32
typedef struct {
uint32_t rk[SM4_KEY_SCHEDULE];
} SM4_KEY;
int sm4_set_key(const uint8_t key[16], SM4_KEY *ks);
void sm4_encrypt(const uint8_t in[16], uint8_t out[16], const SM4_KEY *ks);
void sm4_decrypt(const uint8_t in[16], uint8_t out[16], const SM4_KEY *ks);
#ifdef __cplusplus
}
#endif
关键改造点包括：
- 移除
OPENSSL_NO_SM4等OpenSSL特定的条件编译 - 替换
openssl/opensslconf.h和openssl/e_os2.h为标准C头文件 - 简化函数命名前缀（从
SM4_或ossl_sm4_改为sm4_） - 明确参数数组长度，增强类型安全性
2.3 实现文件适配
sm4.c文件的改造相对复杂，需要处理具体的依赖关系。原始实现可能包含：
#include "crypto/sm4.h"
#include <openssl/e_os2.h>
#include "crypto/sm4_local.h"
/* 内联函数定义 */
#ifndef ossl_inline
# ifdef OPENSSL_INLINE
# define ossl_inline OPENSSL_INLINE
# else
# define ossl_inline inline
# endif
#endif
/* 具体的算法实现... */
我们需要将其改造为：
#include "sm4.h"
#include "sm4_local.h"
/* 定义内联宏 */
#ifndef ossl_inline
#define ossl_inline static inline
#endif
/* 保留算法核心逻辑，移除平台特定代码 */
特别要注意的是，OpenSSL中可能使用了一些平台特定的优化，比如使用OPENSSL_ia32cap_P检测CPU特性。在嵌入式环境中，这些通常不需要，可以直接使用通用的C实现。
2.4 处理字节序问题
SM4算法设计为大端序（Big-Endian）操作，但现代处理器大多是小端序。OpenSSL通过宏来处理字节序转换：
static ossl_inline uint32_t load_u32_be(const uint8_t *b, uint32_t n)
{
return ((uint32_t)b[4 * n] << 24) |
((uint32_t)b[4 * n + 1] << 16) |
((uint32_t)b[4 * n + 2] << 8) |
((uint32_t)b[4 * n + 3]);
}
static ossl_inline void store_u32_be(uint32_t v, uint8_t *b)
{
b[0] = (uint8_t)(v >> 24);
b[1] = (uint8_t)(v >> 16);
b[2] = (uint8_t)(v >> 8);
b[3] = (uint8_t)(v);
}
这些函数在提取后应该完整保留，因为它们不依赖任何OpenSSL特定功能，是纯C的可移植实现。
3. Visual Studio工程配置实战
Windows平台下的嵌入式开发往往需要先在PC上进行算法验证和调试，Visual Studio提供了完善的开发环境。下面我将详细展示如何配置一个最小化的SM4测试工程。
3.1 创建新项目与文件组织
首先在Visual Studio中创建一个新的"C++控制台应用"项目，我将其命名为sm4_standalone。然后按照以下结构组织文件：
sm4_standalone/
├── sm4_standalone.sln # Visual Studio解决方案
├── sm4_standalone.vcxproj # 项目文件
├── src/
│ ├── sm4/
│ │ ├── sm4.c
│ │ └── sm4_local.h
│ └── main.c
├── include/
│ └── sm4.h
└── README.md
在Visual Studio的解决方案资源管理器中，右键点击"源文件"文件夹，选择"添加"→"现有项"，将src/sm4/sm4.c和src/main.c添加到项目中。对于头文件，同样添加到"头文件"文件夹。
3.2 配置项目属性
正确的项目配置是编译成功的关键。右键点击项目名称，选择"属性"，进行以下配置：
C/C++ → 常规 → 附加包含目录：
$(ProjectDir)include
$(ProjectDir)src
这确保编译器能找到我们的头文件。
C/C++ → 预处理器 → 预处理器定义：
_CRT_SECURE_NO_WARNINGS
_USE_MATH_DEFINES
第一个定义禁用某些安全警告，第二个确保数学常量可用。
C/C++ → 所有选项 → 符合模式：设置为"否"
这对于使用标准C库函数是必要的。
链接器 → 系统 → 子系统：设置为"控制台 (/SUBSYSTEM:CONSOLE)"
因为我们创建的是控制台应用。
3.3 编写测试代码
在main.c中，我们编写一个完整的测试程序来验证SM4算法的正确性：
#include <stdio.h>
#include <string.h>
#include "sm4.h"
// 测试向量来自GM/T 0002-2012标准
static const uint8_t test_key[16] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
};
static const uint8_t test_plaintext[16] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
};
static const uint8_t expected_ciphertext[16] = {
0x68, 0x1E, 0xDF, 0x34, 0xD2, 0x06, 0x96, 0x5E,
0x86, 0xB3, 0xE9, 0x4F, 0x53, 0x6E, 0x42, 0x46
};
void print_hex(const char* label, const uint8_t* data, size_t len) {
printf("%s: ", label);
for (size_t i = 0; i < len; i++) {
printf("%02X", data[i]);
if ((i + 1) % 4 == 0 && i + 1 != len) {
printf(" ");
}
}
printf("\n");
}
int test_sm4_basic(void) {
SM4_KEY enc_key, dec_key;
uint8_t ciphertext[16];
uint8_t decrypted[16];
printf("=== SM4算法基本功能测试 ===\n");
// 打印测试数据
print_hex("测试密钥", test_key, 16);
print_hex("测试明文", test_plaintext, 16);
// 设置加密密钥
if (sm4_set_key(test_key, &enc_key) != 1) {
printf("错误: 密钥设置失败\n");
return -1;
}
// 加密
sm4_encrypt(test_plaintext, ciphertext, &enc_key);
print_hex("加密结果", ciphertext, 16);
// 验证加密结果
if (memcmp(ciphertext, expected_ciphertext, 16) != 0) {
printf("错误: 加密结果不符合预期\n");
print_hex("期望结果", expected_ciphertext, 16);
return -1;
}
printf("✓ 加密测试通过\n");
// 设置解密密钥（SM4加解密使用相同密钥）
if (sm4_set_key(test_key, &dec_key) != 1) {
printf("错误: 解密密钥设置失败\n");
return -1;
}
// 解密
sm4_decrypt(ciphertext, decrypted, &dec_key);
print_hex("解密结果", decrypted, 16);
// 验证解密结果
if (memcmp(decrypted, test_plaintext, 16) != 0) {
printf("错误: 解密结果与原始明文不匹配\n");
return -1;
}
printf("✓ 解密测试通过\n");
return 0;
}
int test_sm4_ecb_multiblock(void) {
SM4_KEY key;
uint8_t custom_key[16] = {0};
uint8_t plaintext[64]; // 4个SM4分组
uint8_t ciphertext[64];
uint8_t decrypted[64];
printf("\n=== SM4 ECB模式多分组测试 ===\n");
// 使用全零密钥
memset(custom_key, 0xAA, 16);
// 生成测试数据
for (int i = 0; i < 64; i++) {
plaintext[i] = (uint8_t)i;
}
if (sm4_set_key(custom_key, &key) != 1) {
printf("错误: 密钥设置失败\n");
return -1;
}
// ECB模式加密（分组独立）
for (int i = 0; i < 4; i++) {
sm4_encrypt(plaintext + i * 16, ciphertext + i * 16, &key);
}
print_hex("多分组明文前32字节", plaintext, 32);
print_hex("多分组密文前32字节", ciphertext, 32);
// ECB模式解密
for (int i = 0; i < 4; i++) {
sm4_decrypt(ciphertext + i * 16, decrypted + i * 16, &key);
}
// 验证
if (memcmp(decrypted, plaintext, 64) != 0) {
printf("错误: 多分组解密失败\n");
return -1;
}
printf("✓ 多分组ECB测试通过\n");
return 0;
}
int main(void) {
int ret = 0;
printf("SM4独立模块测试程序\n");
printf("====================\n\n");
// 运行基本功能测试
if (test_sm4_basic() != 0) {
printf("\n基本功能测试失败!\n");
ret = -1;
} else {
printf("\n基本功能测试全部通过!\n");
}
// 运行多分组测试
if (test_sm4_ecb_multiblock() != 0) {
printf("\n多分组测试失败!\n");
ret = -1;
} else {
printf("\n多分组测试通过!\n");
}
if (ret == 0) {
printf("\n✅ 所有测试通过！SM4模块功能正常。\n");
} else {
printf("\n❌ 测试失败，请检查实现。\n");
}
return ret;
}
这个测试程序不仅验证了算法的正确性，还展示了SM4 ECB模式的基本用法。在实际嵌入式开发中，你还需要根据具体需求实现CBC、CTR等加密模式。
3.4 编译与调试技巧
在Visual Studio中编译时，可能会遇到一些常见问题：
问题1：C4996安全警告
error C4996: 'sprintf': This function or variable may be unsafe.
解决方案：在文件开头添加#define _CRT_SECURE_NO_WARNINGS，或按照上面提到的在项目属性中设置预处理器定义。
问题2：内联函数链接错误
error LNK2005: _sm4_encrypt already defined in sm4.obj
这通常是因为内联函数在头文件中定义，但在多个源文件中包含。确保sm4.h中的内联函数使用static inline修饰，或者将实现移到.c文件中。
问题3：字节序相关的问题
如果测试结果不符合预期，可能是字节序处理有问题。可以在sm4.c中添加调试输出，验证load_u32_be和store_u32_be函数的正确性。
调试时，我习惯在关键函数入口添加条件编译的调试代码：
#ifdef SM4_DEBUG
#include <stdio.h>
#define SM4_DEBUG_PRINT(fmt, ...) printf("[SM4] " fmt "\n", ##__VA_ARGS__)
#else
#define SM4_DEBUG_PRINT(fmt, ...)
#endif
int sm4_set_key(const uint8_t key[16], SM4_KEY *ks) {
SM4_DEBUG_PRINT("设置密钥: %02X%02X...%02X%02X",
key[0], key[1], key[14], key[15]);
// ... 实际实现
}
这样可以通过定义SM4_DEBUG宏来启用详细的调试输出。
4. 嵌入式平台适配与优化策略
将SM4算法移植到真正的嵌入式平台时，我们需要考虑更多的实际问题：内存限制、性能要求、安全考量等。这一部分将深入探讨如何为不同的嵌入式环境优化SM4实现。
4.1 内存优化策略
嵌入式系统的内存通常非常有限，特别是RAM资源。SM4算法本身的内存需求相对固定，但我们可以通过一些技巧进一步优化：
静态内存分配 vs 动态内存分配
在资源受限的嵌入式系统中，应尽量避免动态内存分配。SM4算法的所有数据结构都可以在栈上或静态存储区分配：
// 推荐：静态或栈上分配
SM4_KEY key;
uint8_t buffer[SM4_BLOCK_SIZE];
// 不推荐：动态分配
// SM4_KEY *key = malloc(sizeof(SM4_KEY));
查找表优化
SM4算法使用S盒进行非线性变换。OpenSSL的实现通常使用两个查找表：SM4_S（256字节）和SM4_SBOX_T（1024字节）。我们可以根据实际情况进行取舍：
| 实现方式 | 代码大小 | 数据大小 | 速度 | 适用场景 |
|---|---|---|---|---|
| 完整查找表 | 小 | 1280字节 | 快 | RAM充足，要求高性能 |
| 仅S盒表 | 中等 | 256字节 | 中等 | RAM有限，需要平衡 |
| 计算S盒值 | 大 | 0字节 | 慢 | 极度RAM受限 |
如果RAM非常紧张，可以考虑动态计算S盒值，但这会显著降低性能：
static uint8_t sm4_sbox(uint8_t x) {
static const uint8_t sbox_table[256] = {
0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7,
// ... 完整的S盒数据
};
return sbox_table[x];
}
// 动态计算T变换
static uint32_t sm4_t_slow(uint32_t x) {
uint32_t t = 0;
t |= ((uint32_t)sm4_sbox((uint8_t)(x >> 24))) << 24;
t |= ((uint32_t)sm4_sbox((uint8_t)(x >> 16))) << 16;
t |= ((uint32_t)sm4_sbox((uint8_t)(x >> 8))) << 8;
t |= sm4_sbox((uint8_t)x);
// 线性变换L
return t ^ rotl(t, 2) ^ rotl(t, 10) ^ rotl(t, 18) ^ rotl(t, 24);
}
代码大小优化
对于Flash空间有限的MCU，可以考虑以下优化：
- 函数内联策略：只对最热点的函数使用内联，避免过度内联导致代码膨胀
- 循环展开控制：适当减少循环展开程度
- 移除调试代码：确保发布版本中所有调试输出都被移除
- 编译器优化选项：使用
-Os（优化大小）而非-O3（优化速度）
4.2 性能优化技巧
虽然嵌入式设备通常不追求极致性能，但在某些实时性要求高的场景下，SM4算法的执行速度仍然很重要。
平台特定优化
不同的CPU架构有不同的优化策略：
对于ARM Cortex-M系列：
// 使用ARM特有的指令优化旋转操作
static inline uint32_t rotl(uint32_t x, uint8_t n) {
// Cortex-M3/M4支持硬件位旋转指令
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
uint32_t result;
__asm volatile ("ror %0, %1, %2" : "=r" (result) : "r" (x), "r" (32-n));
return result;
#else
return (x << n) | (x >> (32 - n));
#endif
}
对于RISC-V架构：
// RISC-V的位操作指令
static inline uint32_t rotl(uint32_t x, uint8_t n) {
// 使用RISC-V的ROL指令（如果编译器支持）
#if defined(__riscv) && __riscv_xlen >= 32
uint32_t result;
__asm volatile ("rol %0, %1, %2" : "=r" (result) : "r" (x), "r" (n));
return result;
#else
return (x << n) | (x >> (32 - n));
#endif
}
缓存友好的实现
即使在没有缓存的小型MCU上，内存访问模式也会影响性能。SM4的轮函数可以重新组织以减少内存访问：
// 优化后的轮函数，减少内存访问
static inline void sm4_round(uint32_t *block, const uint32_t *rk, int round) {
uint32_t x0 = block[0];
uint32_t x1 = block[1];
uint32_t x2 = block[2];
uint32_t x3 = block[3];
// 一次性加载所有需要的轮密钥
uint32_t rk0 = rk[round * 4];
uint32_t rk1 = rk[round * 4 + 1];
uint32_t rk2 = rk[round * 4 + 2];
uint32_t rk3 = rk[round * 4 + 3];
// 并行计算（如果平台支持）
uint32_t t0 = sm4_t(x1 ^ x2 ^ x3 ^ rk0);
uint32_t t1 = sm4_t(x0 ^ x2 ^ x3 ^ rk1);
uint32_t t2 = sm4_t(x0 ^ x1 ^ x3 ^ rk2);
uint32_t t3 = sm4_t(x0 ^ x1 ^ x2 ^ rk3);
block[0] = x0 ^ t0;
block[1] = x1 ^ t1;
block[2] = x2 ^ t2;
block[3] = x3 ^ t3;
}
4.3 安全考量与侧信道攻击防护
在安全敏感的嵌入式应用中，算法实现不仅要正确，还要能够抵抗各种侧信道攻击。
定时攻击防护
基本的SM4实现可能因为分支或查找表访问时间差异而泄露密钥信息。我们可以通过以下方式增加防护：
// 恒定时间的S盒查找
static inline uint32_t sm4_t_constant_time(uint32_t x) {
uint32_t result = 0;
// 对每个字节进行恒定时间的查找
for (int i = 0; i < 4; i++) {
uint8_t byte = (x >> (24 - i * 8)) & 0xFF;
uint32_t sbox_val = 0;
// 恒定时间的表查找
for (int j = 0; j < 256; j++) {
uint32_t mask = (uint32_t)((byte ^ j) - 1) >> 31;
sbox_val |= (SM4_SBOX_T[j] & mask);
}
result |= (sbox_val << (24 - i * 8));
}
return result ^ rotl(result, 2) ^ rotl(result, 10) ^
rotl(result, 18) ^ rotl(result, 24);
}
内存访问模式防护
缓存定时攻击可以通过随机化内存访问模式来缓解：
// 随机化S盒访问顺序（简化示例）
static uint32_t sm4_t_cache_hardened(uint32_t x, uint32_t random_offset) {
uint32_t t = 0;
// 使用随机偏移访问S盒
uint8_t b0 = (x >> 24) & 0xFF;
uint8_t b1 = (x >> 16) & 0xFF;
uint8_t b2 = (x >> 8) & 0xFF;
uint8_t b3 = x & 0xFF;
// 应用随机置换（实际实现需要更复杂的置换函数）
b0 = (b0 + random_offset) & 0xFF;
b1 = (b1 + random_offset) & 0xFF;
b2 = (b2 + random_offset) & 0xFF;
b3 = (b3 + random_offset) & 0xFF;
t |= ((uint32_t)SM4_S[b0]) << 24;
t |= ((uint32_t)SM4_S[b1]) << 16;
t |= ((uint32_t)SM4_S[b2]) << 8;
t |= SM4_S[b3];
return t ^ rotl(t, 2) ^ rotl(t, 10) ^ rotl(t, 18) ^ rotl(t, 24);
}
4.4 跨平台构建系统
为了支持多种嵌入式平台，我们需要一个灵活的构建系统。以下是使用CMake的示例：
cmake_minimum_required(VERSION 3.10)
project(sm4_embedded C)
# 检测目标平台
if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
set(PLATFORM_ARM TRUE)
add_definitions(-DARM_CORTEX_M)
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv")
set(PLATFORM_RISCV TRUE)
add_definitions(-DRISCV)
endif()
# 配置选项
option(SM4_USE_LOOKUP_TABLE "使用查找表优化性能" ON)
option(SM4_CONSTANT_TIME "恒定时间实现（防侧信道）" OFF)
option(SM4_SMALL_MEMORY "内存优化模式" OFF)
# 根据选项配置编译定义
if(SM4_USE_LOOKUP_TABLE)
add_definitions(-DSM4_USE_LOOKUP_TABLE)
endif()
if(SM4_CONSTANT_TIME)
add_definitions(-DSM4_CONSTANT_TIME)
endif()
if(SM4_SMALL_MEMORY)
add_definitions(-DSM4_SMALL_MEMORY)
# 小内存模式下优化编译器设置
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Os")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
endif()
# 添加源文件
add_library(sm4 STATIC
src/sm4/sm4.c
)
# 包含目录
target_include_directories(sm4 PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/include
)
# 创建测试可执行文件
add_executable(sm4_test
tests/test_sm4.c
)
target_link_libraries(sm4_test sm4)
# 安装目标
install(TARGETS sm4
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib
RUNTIME DESTINATION bin
)
install(DIRECTORY include/ DESTINATION include)
这个CMake配置支持：
- 自动检测ARM或RISC-V平台
- 根据内存限制选择优化策略
- 可选的安全特性（恒定时间实现）
- 灵活的安装选项
4.5 实际嵌入式集成示例
让我们看一个在STM32上集成SM4的实际示例。假设我们使用STM32CubeIDE和HAL库：
// sm4_stm32.h
#ifndef SM4_STM32_H
#define SM4_STM32_H
#include "stm32f4xx_hal.h"
#include "sm4.h"
// 硬件加速支持检测
#ifdef STM32F4_CRYPTO
#define SM4_HW_ACCELERATED 1
#else
#define SM4_HW_ACCELERATED 0
#endif
typedef struct {
SM4_KEY soft_key; // 软件密钥
#if SM4_HW_ACCELERATED
CRYP_HandleTypeDef hcryp; // 硬件加密句柄
uint8_t hw_initialized; // 硬件初始化标志
#endif
} SM4_CTX;
// 初始化SM4上下文
int sm4_ctx_init(SM4_CTX *ctx);
// 设置密钥（自动选择硬件或软件实现）
int sm4_ctx_set_key(SM4_CTX *ctx, const uint8_t key[16]);
// ECB模式加密
int sm4_ctx_encrypt_ecb(SM4_CTX *ctx,
const uint8_t *input,
uint8_t *output,
size_t length);
// 清理上下文
void sm4_ctx_cleanup(SM4_CTX *ctx);
#endif // SM4_STM32_H
// sm4_stm32.c
#include "sm4_stm32.h"
#include <string.h>
#if SM4_HW_ACCELERATED
#include "stm32f4xx_hal_cryp.h"
// 硬件加速实现
static int sm4_hw_init(SM4_CTX *ctx) {
ctx->hcryp.Instance = CRYP;
ctx->hcryp.Init.DataType = CRYP_DATATYPE_8B;
ctx->hcryp.Init.KeySize = CRYP_KEYSIZE_128B;
ctx->hcryp.Init.pKey = NULL; // 稍后设置
if (HAL_CRYP_Init(&ctx->hcryp) != HAL_OK) {
return 0;
}
ctx->hw_initialized = 1;
return 1;
}
static int sm4_hw_encrypt(SM4_CTX *ctx,
const uint8_t *input,
uint8_t *output,
size_t length) {
if (!ctx->hw_initialized) {
return 0;
}
// 注意：STM32的CRYP模块不支持SM4，这里需要软件回退
// 实际项目中应使用支持SM4的芯片或外部加密模块
return 0;
}
#endif // SM4_HW_ACCELERATED
int sm4_ctx_init(SM4_CTX *ctx) {
if (!ctx) return 0;
memset(ctx, 0, sizeof(SM4_CTX));
#if SM4_HW_ACCELERATED
// 尝试初始化硬件加速
if (sm4_hw_init(ctx)) {
return 1;
}
#endif
// 回退到软件实现
return 1;
}
int sm4_ctx_set_key(SM4_CTX *ctx, const uint8_t key[16]) {
if (!ctx || !key) return 0;
#if SM4_HW_ACCELERATED
if (ctx->hw_initialized) {
// 设置硬件密钥
memcpy(ctx->hcryp.Init.pKey, key, 16);
if (HAL_CRYP_SetKey(&ctx->hcryp, key, 16) != HAL_OK) {
return 0;
}
return 1;
}
#endif
// 软件密钥设置
return sm4_set_key(key, &ctx->soft_key);
}
int sm4_ctx_encrypt_ecb(SM4_CTX *ctx,
const uint8_t *input,
uint8_t *output,
size_t length) {
if (!ctx || !input || !output || length % SM4_BLOCK_SIZE != 0) {
return 0;
}
#if SM4_HW_ACCELERATED
if (ctx->hw_initialized) {
return sm4_hw_encrypt(ctx, input, output, length);
}
#endif
// 软件ECB模式加密
size_t blocks = length / SM4_BLOCK_SIZE;
for (size_t i = 0; i < blocks; i++) {
sm4_encrypt(input + i * SM4_BLOCK_SIZE,
output + i * SM4_BLOCK_SIZE,
&ctx->soft_key);
}
return 1;
}
void sm4_ctx_cleanup(SM4_CTX *ctx) {
if (!ctx) return;
#if SM4_HW_ACCELERATED
if (ctx->hw_initialized) {
HAL_CRYP_DeInit(&ctx->hcryp);
ctx->hw_initialized = 0;
}
#endif
// 清理软件密钥（安全擦除）
memset(&ctx->soft_key, 0, sizeof(SM4_KEY));
}
这个示例展示了如何创建一个硬件抽象的SM4接口，能够根据实际硬件能力自动选择最优实现。在实际项目中，你还需要考虑错误处理、中断安全、DMA传输等更多细节。
通过以上四个部分的详细探讨，我们不仅完成了从OpenSSL中提取SM4算法的技术过程，还深入到了工程实践中的各种考量。从Visual Studio的工程配置到嵌入式平台的深度优化，这套方法论可以应用于各种国密算法的移植工作。记住，好的移植不仅仅是让代码跑起来，更是要在资源限制、性能要求和安全性之间找到最佳平衡点。
更多推荐
1
0- 0
已为社区贡献8条内容
所有评论(0)