一．SM4算法加密过程
概述：SM4是一种分组密码算法，其分组长度为128位即16字节，4字），密钥长度也为128位（16字节，4字）。其加解密过程采用了32轮迭代机制，每一轮需要一个轮密钥。

加密过程：
SM分组长度为4字，因此，输入是4字的明文(X0，X1，X2，X3)，加密后，得到的输出是4字的密文(Y0,Y1,Y2,Y3)。
这个加密过程分为两步，由32次轮迭代和1次反序变换组成。

32次轮迭代：

首先，我们要对这个四字明文进行32次轮迭代。每一轮轮迭代都需要一个1字的轮密钥，总共要32个轮密钥，记为(RK0,.....RK31)。之后说明如何由原密钥获取32个轮密钥。

整个轮迭代的过程就是不断的使用轮函数F，往后计算下一个字。轮函数F接收4个一字的明文和一个1字的轮密钥作为参数，生成1个一字的结果。

执行32轮之后，最终可以得到36个字，即(X0,..........X35)，到这里，完成了加密的第一步。

一次反序变换：
加密的第二步是一次简单的反序变换。将迭代得到的最后四个字(X32,X33,X34,X35)进行反序，得到最终密文(Y0,Y1,Y2,Y3) = (X35,X34,X33,X32)

SM4轮函数F的构造：轮函数内部构造：
轮函数需要接收5个1字的参数，即(Xi,Xi+1,Xi+2,Xi+3,rki)，前四个字为明文字或迭代中间值，最后一个参数为1字的轮密钥rki，输出结果为1字。
轮函数内部执行运算为：

后面的T为合成置换：
即接收1字的输入A，得到1字的输出C。它包含非线性变换R和线性变换L，运算过程为：
C = T（A）= L（R（A））
1.非线性变化R：
非线性变换接收1字（即4个字节）的输入，每个字节转换为一个十六进制数，再通过S盒进行变换，转化为另一个十六进制，重复四次，输出一个字。
2.线性变换L：
线性变换接收1字B作为输入，运算后输出一字C。

经过非线性变换和线性变换，就完成了一次迭代，计算出了下一个字的内容。

SM4的密钥扩展算法：
1.与系统参数异或——初始化密钥：
由4字原始密钥生成32个1字的轮密钥，要使用到密钥扩展算法。
初始4字加密密钥位MK = (MK0,MK1,MK2,MK3)。
先需要让原始密钥的每个字MKi与系统参数FKi异或，得到4个新的字（K0，K1，K2，K3）

系统参数在SM4文档中有固定取值

轮迭代生成轮密钥：
在对密钥进行初始化后，得到了4个新的字，之后，与加密过程类似，需要对四个字进行32伦迭代，生成32个轮密钥。
比如，第一轮迭代：

置换T’：
与T类似，非线性变换部分完全相同，线性变换部分如下：

固定CKi取值：
一共有32个，i∈[0,31]，每一轮都要使用不同的CKi。具体取值如下：

二．逆向分析SM4加密算法
将程序导入IDA（这里使用的是64位程序），发现主函数main，点击进入查看逻辑框图：

发现字符串“02x”和“\n”，换行符可能是在输出结束进行，而02x所在代码块是一个循环体，并且两个代码块都调用了sub_140001010，可能是输出函数，文件名是.c后缀，考虑到可能是printf函数，点击F5判断是否可以观察伪代码作进一步佐证，发现可以：

排除sub_140001010是加密函数的可能，转过来研究sub_140001450和sub_140001070，在SM4算法中，最关键的两个步骤就是密钥扩展算法和加密算法，这两个算法又都会调用到轮函数F，可以根据这个特征先找到轮函数F。

查看之后发现两个算法的迭代过程是两个很长的循环，并未使用一个函数，暂时无法区分密钥扩展和加密算法。

但这只是代码上的判断，按照SM4的执行逻辑，必须先生成子密钥才能进行加密算法，二者有固定的执行顺序，所以暂时可以假定sub_140001450是密钥扩展算法，sub_140001070是加密算法。后文中，sub_140001450重命名为KeyExpansion，sub_140001070重命名为Encrypt。

下面分析KeyExpansion：

在获取轮密钥时，会先使用原始4字密钥与与系统参数异或，获取要迭代的初始轮密钥，之后再进入循环，而KeyExpansion的逻辑框图恰好符合这一顺序，所以先观察非循环部分：

可以发现较为明显的是这一部分：

一共循环了8次，应该是一组连续存储的数据，访问了一个字节单元之后进行零拓展，之后存到eax中，再将r8d中的数据逻辑左移八位，与eax中的数据进行或运算。

轮密钥扩展参数的个数是四个，每个是一个字的大小，也就是四个字节，那么异或操作就需要原始密钥也是每个是一个字的大小，而这里的操作是左位移八位再或运算，0与任何数或都是任何数，也就是把四个字节的数字转化为一个字的数字，再存到数组里与系统参数进行异或，这一点可以从如下汇编代码中看出来：

之后进入轮迭代：
（代码过长，只展示关键位置）
轮迭代的显著特征就是T’置换，而T置换中一定会重复用到非线性变换也就是S盒，找到代码中重复出现的地址，很有可能就是S盒。

按地址找到3260h的数据：

可以确定3260为S盒的地址。

一次迭代的主要内容就是密钥之间的异或：

这一过程在一次循环中出现了四次，每一次xor对应的寄存器分别为r11d，r10d，r9d和ecx，而一次轮迭代的参数有K1，K2，K3和Ck0，恰好对应上，可食看出这里的异或运算是从左到右计算的，四次异或之后，一次迭代结束，存储完数据后程序进入下一次迭代。

下面分析Encrypt算法：

加密算法的迭代过程其实和轮密钥区别不大，主要区别是T置换规则不同一介迭代之后要进行一次反序来得到最终密文。
第一个代码块的主要功能还是把四个字节的数=数据转化为一个1字的数据，主要的重复汇编代码如下：

之后进入循环迭代生成密文：

依旧可以在伪代码中找到3260h，也就是S盒的地址，说明在进行T置换中的非线性变换。
代码块中依旧是重复的异或运算，但这里由于使用的是已经生成的轮密钥，不必再调用系统参数，主要重复如下：

最后进入一次反序，发现如下代码：

这里[rsp+0C8h+var_48+0Ch]的数据很明显，并且可以观察到之后的数据变为了8，也就是0Ch-5，结合数据的移动，可以知道这里是在对数据进行反序，根据相应地址可以找到最终密文的位置。

逆向分析使用到的代码如下：
`#include <string.h>

include <stdio.h>

ifndef GET_ULONG_BE

define GET_ULONG_BE(n,b,i) \

{
(n) = ( (unsigned long) (b)[(i) ] << 24 )
| ( (unsigned long) (b)[(i) + 1] << 16 )
| ( (unsigned long) (b)[(i) + 2] << 8 )
| ( (unsigned long) (b)[(i) + 3] );
}

endif

ifndef PUT_ULONG_BE

define PUT_ULONG_BE(n,b,i) \

{
(b)[(i) ] = (unsigned char) ( (n) >> 24 );
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 );
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 );
(b)[(i) + 3] = (unsigned char) ( (n) );
}

endif

define SHL(x,n) (((x) & 0xFFFFFFFF) << n)

define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))

define SWAP(a,b)

static const unsigned char 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,0xfa,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 unsigned long FK[4] = {0xa3b1bac6,0x56aa3350,0x677d9197,0xb27022dc};

static const unsigned long 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 unsigned char sm4Sbox(unsigned char inch)
{
unsigned char *pTable = (unsigned char *)SboxTable;
unsigned char retVal = (unsigned char)(pTable[inch]);
return retVal;
}

static unsigned long sm4Lt(unsigned long ka)
{
unsigned long bb = 0;
unsigned long c = 0;
unsigned char a[4];
unsigned char b[4];
PUT_ULONG_BE(ka,a,0)
b[0] = sm4Sbox(a[0]);
b[1] = sm4Sbox(a[1]);
b[2] = sm4Sbox(a[2]);
b[3] = sm4Sbox(a[3]);
GET_ULONG_BE(bb,b,0)
c =bb^(ROTL(bb, 2))^(ROTL(bb, 10))^(ROTL(bb, 18))^(ROTL(bb, 24));
return c;
}

static unsigned long sm4F(unsigned long x0, unsigned long x1, unsigned long x2, unsigned long x3, unsigned long rk)
{
return (x0sm4Lt(x1x2x3rk));
}

static void sm4_one_round( unsigned long sk[32],
unsigned char input[16],
unsigned char output[16] )
{
unsigned long i = 0;
unsigned long ulbuf[36];

memset(ulbuf, 0, sizeof(ulbuf));
GET_ULONG_BE( ulbuf[0], input, 0 )
GET_ULONG_BE( ulbuf[1], input, 4 )
GET_ULONG_BE( ulbuf[2], input, 8 )
GET_ULONG_BE( ulbuf[3], input, 12 )while(i<32)
{
    ulbuf[i+4] = sm4F(ulbuf[i], ulbuf[i+1], ulbuf[i+2], ulbuf[i+3], sk[i]);
    i++;
}
PUT_ULONG_BE(ulbuf[35],output,0);
PUT_ULONG_BE(ulbuf[34],output,4);
PUT_ULONG_BE(ulbuf[33],output,8);
PUT_ULONG_BE(ulbuf[32],output,12);

}

static unsigned long sm4CalciRK(unsigned long ka)
{
unsigned long bb = 0;
unsigned long rk = 0;
unsigned char a[4];
unsigned char b[4];
PUT_ULONG_BE(ka,a,0)
b[0] = sm4Sbox(a[0]);
b[1] = sm4Sbox(a[1]);
b[2] = sm4Sbox(a[2]);
b[3] = sm4Sbox(a[3]);
GET_ULONG_BE(bb,b,0)
rk = bb^(ROTL(bb, 13))^(ROTL(bb, 23));
return rk;
}

static void sm4_setkey( unsigned long sk[32], unsigned char key[16] )
{
unsigned long MK[4];
unsigned long k[36];
unsigned long i = 0;

GET_ULONG_BE( MK[0], key, 0 );
GET_ULONG_BE( MK[1], key, 4 );
GET_ULONG_BE( MK[2], key, 8 );
GET_ULONG_BE( MK[3], key, 12 );
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(; i<32; i++)
{    k[i+4] = k[i] ^ (sm4CalciRK(k[i+1]^k[i+2]^k[i+3]^CK[i]));
    sk[i] = k[i+4];
}

}

int main()
{
unsigned char key[16] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
unsigned char input[16] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
unsigned char output[16];
unsigned long sk[32];
unsigned long i;

sm4_setkey(sk,key);sm4_one_round(sk, input,output);for(i=0;i<16;i++)	printf("%02x ", output[i]);printf("\n");

return 0;

}