AES加密算法代码实现
作业目标
C语言实现AES加密算法，并将其优化到尽量快的速度。
算法描述
AES简介
高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法，又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。
对称加密算法：加密和解密用相同的密钥。加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。
对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。
- 整体流程
在对称加密算法中，数据发信方将明文（原始数据）和加密密钥（mi yao）一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。如下图所示：
- 加密流程
图中轮函数由三层组成：- 第一层是S盒变换 ByteSub，是非线性的字符变换，有__混淆__作用
- 第二层是行移位变换ShiftRow + 列混合变换MixColumn，确保多轮之上的高度__扩散__
- 第三层是轮密钥加变换AddRoundKey，将轮密钥简单地异或到中间状态上，实现密钥的__加密控制__作用
注意：可以看到最后一次变换，指向第二层，实际上并不进行列混合
- 解密流程
与加密类似，如下图：
实验设计
- 所需常量：
- 数组定义S盒以及S盒逆
- 轮常数，防止不同轮的轮密钥存在相似性
- 列混合（加密）；逆列混合（解密）
- 所需函数
- 字节替代SubBytes
- 逆字节替代InvSubBytes
- 行移位和逆行移位ShiftRows
- 列混合MixColumns
- 逆列混合InvMixColumns
- 密钥加AddRoundKey
- 密钥扩展KeyExpansion
- 获取轮密钥GetRoundKey
- 加密函数Encrypt（调用字节替代、行移位、列混合、密钥加、密钥扩展、获取轮密钥）
- 解密函数Decrypt（调用逆字节替代、逆行移位、逆列混合、密钥加、密钥扩展、获取轮密钥）
- 主函数main
- 调用 x( )：控制流程，方便递归使用
S盒 与 S盒逆
用数列定义：
int s_box[256] =
{ 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
int Invers_box[256] =
{ 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
字节替换与逆字节替换
void SubBytes(int a[4][4],int s_box[256])
{
int i,j;
for (i = 0; i < 4; i++){
for (j = 0; j < 4; j++){
a[i][j] =s_box[a[i][j]];
}
}
}
可以看到，a数组是我们输入的要加密的明文，把a中每一位上的数字对应换成S盒中的数字，即完成转换。
void InvSubBytes(int a[4][4],int InverS_box[256])/* InverS_box[256]是逆S盒*/
{
int i,j;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
a[i][j] = InverS_box [a[i][j]];
}
行移位和逆行移位
void ShiftRows(int a[4][4],int decrypt)
使用变量decrypt，加密时decrypt = 0，进行行移位；解密时decrypt = 1，进行逆行移位。
实现加密行移位功能
if(decrypt==0){
/* 此时实现加密行移位功能 */
for(i=1;i<4;i++) {
if(i==1){
j=a[i][0];
a[i][0]=a[i][1];
a[i][1]=a[i][2];
a[i][2]=a[i][3];
a[i][3]=j;}
if(i==2){
j=a[i][0];
b=a[i][1];
a[i][0]=a[i][2];
a[i][1]=a[i][3];
a[i][2]=j;
a[i][3]=b;}
if(i==3){
j= a[i][3];
a[i][3]=a[i][2];
a[i][2]=a[i][1];
a[i][1]=a[i][0];
a[i][0]=j;}
}
}
很容易看出来，就是第一行不动，把第2，3，4行每一列对应的数右移1，2，3位。如下图所示：
解密逆行移位功能
if(decrypt==1) {
/* 此时实现解密逆行移位功能 */
for(i=1;i<4;i++) {
if(i==1){
j=a[i][3];
a[i][3]=a[i][2];
a[i][2]=a[i][1];
a[i][1]=a[i][0];
a[i][0]=j;}
if(i==2){
j=a[i][0];
b=a[i][1];
a[i][0]=a[i][2];
a[i][1]=a[i][3];
a[i][2]=j;
a[i][3]=b;}
if(i==3){
j=a[i][0];
a[i][0]=a[i][1];
a[i][1]=a[i][2];
a[i][2]=a[i][3];
a[i][3]=j;}
}
}
解密的行移位就是逆同理再转回去
列混合与列逆混合
在AES算法中，需要模多项式m(x)=x8+x4+x^3+x+1。列混合即是用一个常矩阵乘以第二步变换后的矩阵，以达到矩阵中每一个元素都是该元素原所在列所有元素的加权和。如下图所示：
c(x) = 0x03*x^3 + 0x01*x^2 + 0x01*x + 0x02
01=1
02 = x
03 = x + 1
b[4][4]为列混合时的固定矩阵
int b[4][4]={0x02,0x03,0x01,0x01,
0x01,0x02,0x03,0x01,
0x01,0x01,0x02,0x03,
0x03,0x01,0x01,0x02};
列混合具体函数
void MixColumns(int a[4][4],int b[4][4]) /*b[4][4]为列混合时的固定矩阵*/
{
int temp[4][4]={0};
int d[3]={0x80,0x1B,0x02};
int i,j,m,k;
for(m=0;m<4;m++){
for (i = 0; i<4;i++){
for (j = 0;j<4;j++){
if(b[i][j]==1)
temp[i][m]=a[j][m]^temp[i][m];
else {
if(b[i][j]==2){
if(a[j][m]<d[0]){
temp[i][m]=(b[i][j]*a[j][m])^temp[i][m];
}
else{
k=a[j][m]^d[0];
temp[i][m]=((b[i][j]*k)^d[1])^temp[i][m];
}
}
else{
if(a[j][m]<d[0])
temp[i][m]=((a[j][m]*d[2])^a[j][m])^temp[i][m];
else{
k=a[j][m]^d[0];
temp[i][m]=(((k*d[2])^d[1])^a[j][m])^temp[i][m];
}
}
}
}
}
}
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=temp[i][j];
}
利用矩阵乘法，对应位置相乘，再相加，注意相加是异或操作。
先要声明一个空白的temp矩阵，在计算中临时存储每一步的结果，并将最终结果导入a中其中
int d[3]={0x80,0x1B,0x02}是一个用来实现x乘法的数组，用来判断处理溢出和进位
解密时逆向列混合同理：
列逆矩阵
int c[4][4]={0x0E,0x0B,0x0D,0x09,
0x09,0x0E,0x0B,0x0D,
0x0D,0x09,0x0E,0x0B,
0x0B,0x0D,0x09,0x0E};
列逆混合函数
void InvMixColumns(int a[4][4],int c[4][4]) /*c[4][4]为逆列混合时的固定矩阵*/
{
int temp[4][4]={0};
int d[7]={0x80,0x1B,0x02,0x0e,0x0b,0x0d,0x09};
int i,j,m,n,e,k,p,q,x,y;
for(m = 0;m < 4;m++)
for (i = 0; i < 4;i++)
for (j = 0;j < 4;j++){
e=a[j][m];y=a[j][m];
if(c[i][j]==d[3]){
for(n=0;n<3;n++){
if(y<d[0])
y=y*d[2];
else{
k=y^d[0];
y=(k*d[2])^d[1];}
if(n==0)
{p=y;}
else
if(n==1)
{q=y;}
else
{ x=y;}
}
temp[i][m]=p^q^x^temp[i][m];}
if(c[i][j]==d[4])
{for(n=0;n<3;n++)
{
if(y<d[0])
y=y*d[2];
else
{k=y^d[0];
y=(k*d[2])^d[1];}
if(n==0)
q=y;
if(n==2)
x=y;}
temp[i][m]=e^q^x^temp[i][m];}
if(c[i][j]==d[5])
{for(n=0;n<3;n++)
{
if(y<d[0])
y=y*d[2];
else
{k=y^d[0];
y=(k*d[2])^d[1];}
if(n==1)
q=y;
if(n==2)
x=y;}
temp[i][m]=e^q^x^temp[i][m];}
if(c[i][j]==d[6]){
for(n=0;n<3;n++){
if(y<d[0])
y=y*d[2];
else{
k=y^d[0];
y=(k*d[2])^d[1];}
}
temp[i][m]=e^y^temp[i][m];
}
}
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=temp[i][j];
}
密钥扩展
void KeyExpansion(int roundkey[4][4],int s_box[256], int temp[4][44])
{
int i,j,n,m,a,b,x,y;
int w[4],r[4],q[4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
{temp[i][j]= roundkey[i][j];}
for(i=4;i<44;i++){
a=i-4;b=i-1;
if(i%4!=0){/*i不是4的倍数*/
for(j=0;j<4;j++)
q[j]=temp[j][a]^temp[j][b];
for(y=0;y<4;y++)
temp[y][i]=q[y];
}
else{ /*i是4的倍数*/
for(x=0;x<4;x++)
w[x]=temp[x][b];
n=w[0]; /*左移一位*/
w[0]= w[1];
w[1]= w[2];
w[2]= w[3];
w[3]=n;
for(j=0;j<4;j++)
w[j]=s_box[w[j]];/*字节替代*/
w[0]= rcon[(i-4)/4]^w[0];
for(m=0;m<4;m++)
r[m]=temp[m][a]^w[m];
for(y=0;y<4;y++)
temp[y][i]=r[y];
}
}
}
AES首先将初始密钥输入到一个44的状态矩阵中，这个44矩阵的每一列的4个字节组成一个字，矩阵4列的4个字依次命名为W[0]、W[1]、W[2]和W[3]，它们构成一个以字为单位的数组W。
接着，对W数组扩充40个新列，构成总共44列的扩展密钥数组。新列以如下的规则产生：
- 如果i不是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁W[i-1] - 如果i是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁T(W[i-1])
其中，T是一个有点复杂的函数。
函数T由3部分组成：字循环、字节代换和轮常量异或，这3部分的作用分别如下。- a.字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
- b.字节代换：对字循环的结果使用S盒进行字节代换。
- c.轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
伦常量如下：
最终4的倍数位，都经过了S盒增强加密，而其他位则仅取决于上一位和上一轮对应位的异或。/*轮常数，防止不同轮的轮密钥存在相似性*/ const int rcon[10]={0x01,0x02,0x04, 0x08,0x10,0x20,0x40, 0x80,0x1B,0x36};
获取轮密钥
/*获取轮密钥*/
void GetRoundKey(int roundKey[4][4], int temp[4][44],int n)
{
int i,j;
for(i=0;i<4;i++)
for(j=0;j<4;j++)
roundKey[i][j]=temp[i][j+4*n];
}
密钥加
void AddRoundKey(int a[4][4],int roundKey[4][4])
{
int i,j;
for (i = 0;i < 4; i++)
for (j = 0; j < 4; j++)
a[i][j] = a[i][j] ^ roundKey[i][j];
}
轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作
注意：轮密钥加的逆运算同正向的轮密钥加运算完全一致，这是因为异或的逆操作是其自身。轮密钥加非常简单，但却能够影响S数组中的每一位。
加密函数
void Encrypt(int a[4][4],int roundKey[4][4],int temp[4][44])
{
int i,j,n;
int decrypt = 0;
AddRoundKey(a,roundKey);/* 轮密钥加*/
for(n=1;n<=10;n++)
{
if(n==10){
SubBytes(a,s_box); /* 字节替代*/
ShiftRows(a,decrypt); /*行移位*/
GetRoundKey(roundKey,temp,n); /* 获取轮密钥*/
AddRoundKey(a,roundKey); /* 轮密钥加*/
}
else{
SubBytes(a,s_box); /* 字节替代*/
ShiftRows(a,decrypt); /*行移位*/
MixColumns(a,b); /* 列混合*/
GetRoundKey(roundKey,temp,n); /* 获取轮密钥*/
AddRoundKey(a,roundKey); /* 轮密钥加*/
}
}
}
去掉显示的提示信息可以发线，就是之前画好的流程图，并且区别开最后一轮没有列混合
注意：decrypt = 0表示加密
解密函数
与加密函数类似
void Decrypt(int a[4][4],int roundKey[4][4],int temp[4][44])
{
int i,j,n,m;
int decrypt = 1;
int r[10]={0,9,8,7,6,5,4,3,2,1};
m=10;
GetRoundKey(roundKey, temp,m);
AddRoundKey(a,roundKey);
for(n=1;n<=10;n++) {
if(n==10)
{ ShiftRows(a,decrypt);
InvSubBytes(a,Invers_box);
m=0;
GetRoundKey(roundKey,temp,m);
AddRoundKey(a,roundKey);
}
else{
ShiftRows(a,decrypt);
InvSubBytes(a,Invers_box);
m=r[n];
GetRoundKey(roundKey, temp,m);
AddRoundKey(a,roundKey);
InvMixColumns(a,c);
}
}
}
注意获取轮密钥时需要对应反序
m = 10 -n，每次都运算应该是没有建立数组查表快的。
流程函数x()
-
控制流程，方便递归使用
-
输入明文和初始密钥，进行最初的加密
-
输入初始密钥(注:需输入32个字符,且每个字符必须在0-a之间,否则出错)，转化为16进制矩阵
scanf("%s",k); for(j=0;j<32;j++) { if(k[j]!='\0'&&k[j]<='f') if(k[j]<'a') l[j]=k[j]-'0'; else l[j]=10+(k[j]-'a'); else { printf(" 输入出错\n"); x(); }} for(n=0;n<32;n=n+2){ m=n/2; l[m]=l[n]*16+l[n+1]; } for(i=0;i<4;i++) for(j=0;j<4;j++) key[j][i]=l[j+i*4];需要扩展加密
KeyExpansion(key,s_box,Temp); Decrypt(w,key,Temp); x();- 输入明文块(注:需输入32个字符,且每个字符必须在0-a之间,否则出错,检查类似)
for(i=0;i<32;i++) p[i]='0'; scanf("%s",o);//char o[32] for(i=0;o[i]!='\0';i++) p[i]=o[i]; for(i=0;i<32;i++){ if(p[i]!='\0'&&p[i]<='f') if(p[i]<'a') s[i]=p[i]-'0'; else s[i]=10+(p[i]-'a'); else{ printf(" 输入出错\n"); x(); } for(n=0;n<32;n=n+2){ m=n/2; s[m]=s[n]*16+s[n+1];//int s[32] } for(i=0;i<4;i++) for(j=0;j<4;j++) w[j][i]=s[j+i*4];将输入的字符（0-10的字符串例如’123a’）一个一个到处转化为数字（例如’1’‘2’‘3’‘10’），再将两位拼成16进制数（例如’0x12（16+2）’‘0x3a（3*16+10）’）,最后将int s[16]按列放入int w[4][4]。
-
优化技巧
打破输入限制，加入时间计算
原先是输入32个字符,且每个字符必须在0-a之间,否则出错，我们直接把它们都删掉，写一个导入加密文件的函数，再将文件内容转化为ascii码，将内容切片成需要的大小128位（）
if (fp != NULL) {
while ((ch = fgetc(fp)) != EOF){
s[num % 16] = (uint8_t)ch;
for(i=0;i<4;i++)
for(j=0;j<4;j++)
w[j][i]=(int)s[j+i*4];
if (num != 0 && num % 16 == 0) {
ftime(&ts1);
KeyExpansion(key,s_box,Temp);
Encrypt(w,key,Temp);
ftime(&ts2);
t_sec = ts2.time - ts1.time;
t_ms = ts2.millitm - ts1.millitm;
ti += t_sec * 1000 + t_ms;
}
num++;
}
}
目前只完成了加密部分的改写
S盒查表
使用查表法能大幅提升加密速度
int s_box[256] = [...]
列混合优化
使用固定矩阵乘法更方便
int b[4][4]={0x02,0x03,0x01,0x01,
0x01,0x02,0x03,0x01,
0x01,0x01,0x02,0x03,
0x03,0x01,0x01,0x02};
没有实现列混合查表，放一个目标参考（表如下：）
参考：https://gitee.com/lee_ka/AES/blob/master/1gai.cpp
unsigned char L_box(int i,unsigned char j)
{
return L_boxx[i][j];
}
static void MixColumns(unsigned char *col)//列混合
{
unsigned char tmp[4],xt[4];
int i;
for(i=0;i<4;i++,col+=4) //col代表一列的基地址，col+4:下一列的基地址
{
tmp[0]=L_box(1,col[0])^L_box(2,col[1])^col[2]^col[3];
tmp[1]=col[0]^L_box(1,col[1])^L_box(2,col[2])^col[3];
tmp[2]=col[0]^col[1]^L_box(1,col[2])^L_box(2,col[3]);
tmp[3]=L_box(2,col[0])^col[1]^col[2]^L_box(1,col[3]);
//修改后的值 直接在原矩阵上修改
col[0]=tmp[0];
col[1]=tmp[1];
col[2]=tmp[2];
col[3]=tmp[3];
}
}
转置输入
AES的数据是按列输入的，而这样在计算机中操作并不方便，将AES转置后可以按行输入数据，这样可以使用指针的强制类型转换来减少循环的轮次，注意在转置后的部分操作也要进行转置的变化，包括行移位和列混淆(见行移位和列混淆代码)，AES的转置实现见-AES转置实现。注意在对指针进行强行转换后会出现int内部的字节倒序的现象。
for(i=0;i<4;i++)
for(j=0;j<4;j++)
w[j][i]=(int)s[j+i*4];
函数表达更清晰(还没有改)
unsigned char xtime(unsigned char st)
{
return (st<<1)^((st&0x80)?0x1b:0x00);
//x乘法 二进制串左移一位，判断最高位是否溢出，溢出要异或0x1b
}
void mixcolumns(unsigned char state[4][4],unsigned char cipher[4][4])
{
for(int j=0;j<4;j++)
{
for(int i=0;i<4;i++)
{
cipher[i][j]=
xtime(state[i%4][j]) //0x02乘法
^(state[(i+1)%4][j])^xtime(state[(i+1)%4][j])//0x03乘法
^state[(i+2)%4][j] //0x01乘法
^state[(i+3)%4][j]; //0x01乘法
}
}
}
实验结果与反思
实验结果
2963 ms v = 3538.89976 Byte/ms
总结
本次实验实现了AES对文本的加密，更加深入地学习了AES算法的使用流程以及加密过程，在列混淆以及加密密钥环节遇到了诸多困难，对于矩阵乘法和异或操作有了更深入的认识，由此也想到了很多优化的方法。由于时间的限制优化并没有完全完成：没有实现列混合查表；列混淆那里的矩阵乘法代码看上去有些混乱，可能可以加一个函数调用会更易读；没有保存加密好的新文件并对其解密。
完整代码
见压缩包
备注：aes_1:有解密，但是输入限制。
aes_2:用于测试，可以加密文件。
478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
