SM4算法的原理与C/C++实现_国产对称密码sm4算法原理

一、原理

SM4算法是一种由中国国家密码管理局于2012年发布的对称块加密标准，主要用于信息安全领域，尤其在金融和物联网等关键领域有着广泛的应用。这种算法以其强大的安全性和较快的计算速度而著称，使用128位的密钥和32位的块大小进行数据加密，确保了数据传输和存储的安全性。

SM4算法的工作流程主要包括以下几个步骤：

1. 密钥扩展：算法首先将用户提供的128位密钥通过密钥扩展算法扩展成32个轮密钥，这些轮密钥将用于加密过程中的每一轮操作。

2. 轮密钥加（AddRoundKey）：在每一轮加密开始时，都会将数据块（当前状态）与相应的轮密钥进行异或操作，这一步是加密过程的第一步，也是实现加密的基础。

3. 非线性变换：每一轮中，数据块会经过四个非线性变换过程，包括：

   • S盒替代：将数据块中的每个字节通过一个预定义的替代盒（S盒）进行替代，S盒操作是非线性的，增加了加密的复杂度和安全性。
   • 行移位：数据块被视为一个矩阵，矩阵的每一行将根据固定规则进行循环左移，增加了数据的扩散性。
   • 列混合：对数据矩阵的每一列应用一个线性变换，进一步混合了行移位后的数据。
   • 轮常数异或：将一个预定义的轮常数与数据块的第一个字节进行异或操作，为每一轮加密引入了额外的变化，提高了算法的安全性。

4. 重复轮操作：整个加密过程包括10轮这样的操作，每一轮都包括轮密钥加和上述的非线性变换步骤，通过多轮的迭代，确保了高度的安全性。

5. 最终输出：在完成所有轮的操作后，输出最终的加密数据，这些数据可以通过相应的解密过程恢复原始数据。

总的来说，SM4算法通过其精心设计的轮函数和非线性变换，以及有效的密钥扩展机制，提供了一种既安全又高效的加密手段，适用于多种安全敏感的应用场景。

二、C/C++实现

SM4.h

#pragma once
#ifndef SM4_H
#define SM4_H
 
#include <stdint.h>
 
typedef struct {
    uint32_t rk[32];
} sm4_context;
 
void sm4_setkey_enc(sm4_context* ctx, const uint8_t key[16]);
void sm4_encrypt(const sm4_context* ctx, const uint8_t input[16], uint8_t output[16]);
 
#endif 

SM4.cpp

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "SM4.h"
 
#define GETU32(pc)  (*((uint32_t*)(pc)))
#define PUTU32(st, ct)  { *((uint32_t*)(ct)) = *((uint32_t*)(st)); }
 
typedef struct {
    uint32_t rk[32];
} sm4_context;
 
static const uint8_t SboxTable[16][16] = {
    {0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05},
    {0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99},
    {0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62},
    {0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0fa, 0x75, 0x8f, 0x3f, 0xa6},
    {0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8},
    {0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35},
    {0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87},
    {0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e},
    {0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1},
    {0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3},
    {0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f},
    {0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51},
    {0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8},
    {0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0},
    {0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84},
    {0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48}
};
 
static const uint32_t FK[4] = {
    0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC
};
 
static const uint32_t CK[32] = {
    0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
    0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
    0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
    0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
    0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
    0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
    0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
    0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
};
 
static uint32_t SM4_T(uint32_t value) {
    return value ^ (value << 13) ^ (value << 23);
}
 
static uint32_t SM4_LTransformation(uint32_t value) {
    return value ^ (value << 2) ^ (value << 10) ^ (value << 18) ^ (value << 24);
}
 
static void SM4_KeySchedule(const uint32_t MK[4], uint32_t rk[32]) {
    uint32_t K[36];
 
    K[0] = MK[0] ^ FK[0];
    K[1] = MK[1] ^ FK[1];
    K[2] = MK[2] ^ FK[2];
    K[3] = MK[3] ^ FK[3];
 
    for (int i = 0; i < 32; ++i) {
        K[i + 4] = K[i] ^ SM4_T(K[i + 1] ^ K[i + 2] ^ K[i + 3] ^ CK[i]);
        rk[i] = K[i + 4];
    }
}
 
static void SM4_Encrypt(const uint32_t X[4], const uint32_t rk[32], uint32_t Y[4]) {
    uint32_t b[36];
 
    b[0] = X[0] ^ rk[0];
    b[1] = X[1] ^ rk[1];
    b[2] = X[2] ^ rk[2];
    b[3] = X[3] ^ rk[3];
 
    for (int i = 0; i < 32; ++i) {
        b[i + 4] = SM4_LTransformation(b[i] ^ b[i + 1] ^ b[i + 2] ^ b[i + 3]);
        Y[i % 4] = b[i + 4];
    }
}
 
void sm4_setkey_enc(sm4_context* ctx, const uint8_t key[16]) {
    uint32_t MK[4];
    uint32_t rk[32];
 
    MK[0] = GETU32(key);
    MK[1] = GETU32(key + 4);
    MK[2] = GETU32(key + 8);
    MK[3] = GETU32(key + 12);
 
    SM4_KeySchedule(MK, rk);
    memcpy(ctx->rk, rk, sizeof(rk));
}
 
void sm4_encrypt(const sm4_context* ctx, const uint8_t input[16], uint8_t output[16]) {
    uint32_t X[4];
    uint32_t Y[4];
 
    X[0] = GETU32(input);
    X[1] = GETU32(input + 4);
    X[2] = GETU32(input + 8);
    X[3] = GETU32(input + 12);
 
    SM4_Encrypt(X, ctx->rk, Y);
 
    PUTU32(Y, output);
    PUTU32(Y + 1, output + 4);
    PUTU32(Y + 2, output + 8);
    PUTU32(Y + 3, output + 12);
}