手把手教你用纯C语言（只用stdio.h）实现SM4国密算法，附完整可运行代码

从零构建SM4国密算法：极简C语言实现指南

在嵌入式开发和密码学学习过程中，我们经常遇到一个困境：算法实现要么依赖复杂的第三方库，要么需要繁琐的环境配置。本文将展示如何仅用C语言标准库中的stdio.h，实现完整的SM4国密算法加密解密功能。这种极简实现方式特别适合资源受限的嵌入式环境，也便于学习者深入理解算法本质。

1. SM4算法核心模块拆解

1.1 S盒的非线性变换实现

SM4的S盒是算法中唯一的非线性部件，其本质是一个256字节的置换表。我们需要将其硬编码在程序中：

const unsigned char SBOX[256] = { 0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05, // ... 完整S盒数据 0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48 };

实现S盒查询函数时，需要注意处理字节序：

uint32_t sbox_lookup(uint32_t word) { uint8_t bytes[4]; bytes[0] = (word >> 24) & 0xFF; bytes[1] = (word >> 16) & 0xFF; bytes[2] = (word >> 8) & 0xFF; bytes[3] = word & 0xFF; return (SBOX[bytes[0]] << 24) | (SBOX[bytes[1]] << 16) | (SBOX[bytes[2]] << 8) | SBOX[bytes[3]]; }

1.2 关键位运算技巧

在无专用密码库支持下，位运算成为核心工具。以下是几个关键实现技巧：

• 循环左移：SM4需要大量使用32位字的循环左移操作
• 异或运算：用于多轮密钥混合和Feistel结构
• 字节操作：处理数据的分组和拼接

循环左移的高效实现：

uint32_t rotate_left(uint32_t x, int n) { return (x << n) | (x >> (32 - n)); }

2. 完整算法实现架构

2.1 密钥扩展系统设计

SM4的密钥扩展过程需要生成32个轮密钥，我们采用分步实现：

1. 初始化系统参数
2. 执行初始密钥混合
3. 迭代生成轮密钥

void key_expansion(uint32_t mk[4], uint32_t rk[32]) { uint32_t k[36]; const uint32_t fk[4] = {0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc}; // 初始密钥混合 for(int i=0; i<4; i++) { k[i] = mk[i] ^ fk[i]; } // 轮密钥生成 for(int i=0; i<32; i++) { uint32_t tmp = k[i+1] ^ k[i+2] ^ k[i+3] ^ CK[i]; tmp = sbox_lookup(tmp); tmp = tmp ^ rotate_left(tmp, 13) ^ rotate_left(tmp, 23); k[i+4] = k[i] ^ tmp; rk[i] = k[i+4]; } }

2.2 轮函数实现细节

SM4的轮函数采用Feistel结构，每轮处理流程如下：

1. 输入4个字(X0-X3)和轮密钥RK
2. 执行T变换（S盒+线性变换）
3. 更新寄存器值

uint32_t t_transform(uint32_t x, int is_encrypt) { x = sbox_lookup(x); if(is_encrypt) { return x ^ rotate_left(x, 2) ^ rotate_left(x, 10) ^ rotate_left(x, 18); } else { return x ^ rotate_left(x, 13) ^ rotate_left(x, 23); } } void round_function(uint32_t x[4], uint32_t rk) { uint32_t tmp = x[1] ^ x[2] ^ x[3] ^ rk; tmp = t_transform(tmp, 1); uint32_t new_x = x[0] ^ tmp; // 寄存器移位 x[0] = x[1]; x[1] = x[2]; x[2] = x[3]; x[3] = new_x; }

3. 完整加解密流程实现

3.1 加密过程代码实现

加密过程需要32轮迭代，最后执行反序输出：

void sm4_encrypt(uint32_t plaintext[4], uint32_t ciphertext[4], uint32_t rk[32]) { uint32_t x[4]; memcpy(x, plaintext, 16); for(int i=0; i<32; i++) { round_function(x, rk[i]); } // 反序输出 ciphertext[0] = x[3]; ciphertext[1] = x[2]; ciphertext[2] = x[1]; ciphertext[3] = x[0]; }

3.2 解密过程特殊处理

SM4算法的一个特点是加解密结构相同，只需逆序使用轮密钥：

void sm4_decrypt(uint32_t ciphertext[4], uint32_t plaintext[4], uint32_t rk[32]) { uint32_t reverse_rk[32]; for(int i=0; i<32; i++) { reverse_rk[i] = rk[31-i]; } sm4_encrypt(ciphertext, plaintext, reverse_rk); }

4. 工程实践与测试验证

4.1 测试用例设计

使用标准测试向量验证实现正确性：

void test_vectors() { uint32_t plain[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210}; uint32_t key[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210}; uint32_t rk[32]; uint32_t cipher[4]; uint32_t decrypted[4]; key_expansion(key, rk); sm4_encrypt(plain, cipher, rk); sm4_decrypt(cipher, decrypted, rk); printf("加密结果: %08x %08x %08x %08x\n", cipher[0], cipher[1], cipher[2], cipher[3]); printf("解密结果: %08x %08x %08x %08x\n", decrypted[0], decrypted[1], decrypted[2], decrypted[3]); }

4.2 性能优化技巧

在资源受限环境中，可以考虑以下优化：

1. S盒内存优化：将S盒存放在程序存储区而非RAM
2. 循环展开：对关键循环进行部分展开
3. 寄存器重用：减少内存访问次数
4. 指令级优化：利用处理器特有指令

// 优化后的轮函数实现示例 void optimized_round(uint32_t x[4], uint32_t rk) { uint32_t tmp = x[1] ^ x[2] ^ x[3] ^ rk; // 手动展开S盒查询 uint8_t b0 = SBOX[(tmp >> 24) & 0xFF]; uint8_t b1 = SBOX[(tmp >> 16) & 0xFF]; uint8_t b2 = SBOX[(tmp >> 8) & 0xFF]; uint8_t b3 = SBOX[tmp & 0xFF]; tmp = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; tmp = tmp ^ rotate_left(tmp, 2) ^ rotate_left(tmp, 10) ^ rotate_left(tmp, 18); x[3] = x[0] ^ tmp; x[0] = x[1]; x[1] = x[2]; x[2] = x[3]; }

5. 实际应用场景扩展

5.1 文件加密工具实现

基于核心算法，我们可以构建简单的文件加密工具：

void file_encrypt(const char* input, const char* output, uint32_t key[4]) { FILE* fin = fopen(input, "rb"); FILE* fout = fopen(output, "wb"); uint32_t block[4], cipher[4], rk[32]; key_expansion(key, rk); while(1) { size_t read = fread(block, 1, 16, fin); if(read == 0) break; // 处理不足16字节的尾部数据 if(read < 16) { memset((char*)block + read, 0, 16 - read); } sm4_encrypt(block, cipher, rk); fwrite(cipher, 1, 16, fout); } fclose(fin); fclose(fout); }

5.2 网络通信加密方案

在嵌入式网络通信中，可以这样应用SM4：

1. 预共享密钥或密钥协商
2. 分组加密应用数据
3. 添加适当的填充和校验

void secure_send(int socket, uint32_t key[4], const void* data, size_t len) { uint32_t rk[32]; key_expansion(key, rk); size_t blocks = (len + 15) / 16; uint8_t* encrypted = malloc(blocks * 16); for(size_t i=0; i<blocks; i++) { uint32_t block[4]; size_t copy_len = (i == blocks-1) ? (len - i*16) : 16; memcpy(block, (char*)data + i*16, copy_len); if(copy_len < 16) { memset((char*)block + copy_len, 0, 16 - copy_len); } sm4_encrypt(block, (uint32_t*)(encrypted + i*16), rk); } send(socket, encrypted, blocks*16, 0); free(encrypted); }

6. 安全注意事项与最佳实践

6.1 密钥管理方案

在极简环境中，密钥安全尤为重要：

1. 避免硬编码密钥
2. 实现简单的密钥派生功能
3. 定期更换会话密钥
4. 使用物理安全措施保护密钥

void derive_key(const char* password, uint32_t key[4]) { // 简化的密钥派生示例 uint32_t hash = 0; for(int i=0; password[i]; i++) { hash = (hash << 5) - hash + password[i]; } for(int i=0; i<4; i++) { key[i] = hash ^ (i * 0x9e3779b9); } }

6.2 侧信道攻击防护

即使在这种极简实现中，也应考虑基本防护：

1. 避免密钥相关的分支判断
2. 保持恒定时间的操作
3. 随机化执行顺序（如可能）
4. 清除敏感内存区域

void secure_erase(void* ptr, size_t size) { volatile uint8_t* p = (volatile uint8_t*)ptr; while(size--) { *p++ = 0; } }

7. 跨平台兼容性处理

7.1 字节序问题解决方案

不同平台可能有不同的字节序，需要统一处理：

uint32_t read_uint32(const uint8_t* bytes) { #if defined(BIG_ENDIAN) return *(uint32_t*)bytes; #else return (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]; #endif } void write_uint32(uint8_t* bytes, uint32_t value) { #if defined(BIG_ENDIAN) *(uint32_t*)bytes = value; #else bytes[0] = (value >> 24) & 0xFF; bytes[1] = (value >> 16) & 0xFF; bytes[2] = (value >> 8) & 0xFF; bytes[3] = value & 0xFF; #endif }

7.2 内存对齐处理

某些平台对内存访问有对齐要求，需要特殊处理：

void aligned_copy(uint32_t* dst, const uint8_t* src) { uint8_t* p = (uint8_t*)dst; for(int i=0; i<4; i++) { p[0] = src[0]; p[1] = src[1]; p[2] = src[2]; p[3] = src[3]; p += 4; src += 4; } }

8. 调试与问题排查

8.1 常见问题及解决方法

在实现过程中可能遇到的问题：

1. 加密结果不正确：

   • 检查S盒数据是否完整
   • 验证轮密钥生成顺序
   • 确认字节序处理一致

2. 解密失败：

   • 确保轮密钥使用顺序相反
   • 检查填充方案是否一致
   • 验证数据块边界处理

3. 性能问题：

   • 分析热点函数
   • 减少不必要的内存拷贝
   • 考虑循环展开

8.2 调试辅助工具

即使在极简环境中，也可以实现基本调试功能：

void print_block(const char* label, uint32_t block[4]) { printf("%s: ", label); for(int i=0; i<4; i++) { printf("%08x ", block[i]); } printf("\n"); } void debug_round(int round, uint32_t x[4], uint32_t rk) { printf("Round %2d: X0=%08x X1=%08x X2=%08x X3=%08x RK=%08x\n", round, x[0], x[1], x[2], x[3], rk); }