#include "stdio.h"
#include "memory.h"
#include "time.h"岩宽
#include "stdlib.h"
#define PLAIN_FILE_OPEN_ERROR -1
#define KEY_FILE_OPEN_ERROR -2
#define CIPHER_FILE_OPEN_ERROR -3
#define OK 1
typedef char ElemType
/*初始置换亏枣销表IP*/
int IP_Table[64] = { 57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6}
/*逆初始置换表IP^-1*/
int IP_1_Table[64] = {39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,
32,0,40,8,48,16,56,24}
/*扩充置换表E*/
int E_Table[48] = {31, 0, 1, 2, 3, 4,
3, 4, 5, 6, 7, 8,
7, 8,9,10,11,12,
11,12,13,14,15,16,
15,16,17,18,19,20,
19,20,21,22,23,24,
23,24,25,26,27,28,
27,28,29,30,31, 0}
/*置换函数P*/
int P_Table[32] = {15,6,19,20,28,11,27,16,
0,14,22,25,4,17,30,9,
1,7,23,13,31,26,2,8,
18,12,29,5,21,10,3,24}
/*S盒*/
int S[8][4][16] =
/*S1*/
{{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
/*S2*/
{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
/销游*S3*/
{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
/*S4*/
{{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
/*S5*/
{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
/*S6*/
{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
/*S7*/
{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
/*S8*/
{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}}
/*置换选择1*/
int PC_1[56] = {56,48,40,32,24,16,8,
0,57,49,41,33,25,17,
9,1,58,50,42,34,26,
18,10,2,59,51,43,35,
62,54,46,38,30,22,14,
6,61,53,45,37,29,21,
13,5,60,52,44,36,28,
20,12,4,27,19,11,3}
/*置换选择2*/
int PC_2[48] = {13,16,10,23,0,4,2,27,
14,5,20,9,22,18,11,3,
25,7,15,6,26,19,12,1,
40,51,30,36,46,54,29,39,
50,44,32,46,43,48,38,55,
33,52,45,41,49,35,28,31}
/*对左移次数的规定*/
int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1}
int ByteToBit(ElemType ch,ElemType bit[8])
int BitToByte(ElemType bit[8],ElemType *ch)
int Char8ToBit64(ElemType ch[8],ElemType bit[64])
int Bit64ToChar8(ElemType bit[64],ElemType ch[8])
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48])
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56])
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48])
int DES_ROL(ElemType data[56], int time)
int DES_IP_Transform(ElemType data[64])
int DES_IP_1_Transform(ElemType data[64])
int DES_E_Transform(ElemType data[48])
int DES_P_Transform(ElemType data[32])
int DES_SBOX(ElemType data[48])
int DES_XOR(ElemType R[48], ElemType L[48],int count)
int DES_Swap(ElemType left[32],ElemType right[32])
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8])
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8])
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile)
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile)
/*字节转换成二进制*/
int ByteToBit(ElemType ch, ElemType bit[8]){
int cnt
for(cnt = 0cnt <8cnt++){
*(bit+cnt) = (ch>>cnt)&1
}
return 0
}
/*二进制转换成字节*/
int BitToByte(ElemType bit[8],ElemType *ch){
int cnt
for(cnt = 0cnt <8cnt++){
*ch |= *(bit + cnt)<<cnt
}
return 0
}
/*将长度为8的字符串转为二进制位串*/
int Char8ToBit64(ElemType ch[8],ElemType bit[64]){
int cnt
for(cnt = 0cnt <8cnt++){
ByteToBit(*(ch+cnt),bit+(cnt<<3))
}
return 0
}
/*将二进制位串转为长度为8的字符串*/
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
int cnt
memset(ch,0,8)
for(cnt = 0cnt <8cnt++){
BitToByte(bit+(cnt<<3),ch+cnt)
}
return 0
}
/*生成子密钥*/
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
ElemType temp[56]
int cnt
DES_PC1_Transform(key,temp)/*PC1置换*/
for(cnt = 0cnt <16cnt++){/*16轮跌代，产生16个子密钥*/
DES_ROL(temp,MOVE_TIMES[cnt])/*循环左移*/
DES_PC2_Transform(temp,subKeys[cnt])/*PC2置换，产生子密钥*/
}
return 0
}
/*密钥置换1*/
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
int cnt
for(cnt = 0cnt <56cnt++){
tempbts[cnt] = key[PC_1[cnt]]
}
return 0
}
/*密钥置换2*/
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
int cnt
for(cnt = 0cnt <48cnt++){
tempbts[cnt] = key[PC_2[cnt]]
}
return 0
}
/*循环左移*/
int DES_ROL(ElemType data[56], int time){
ElemType temp[56]
/*保存将要循环移动到右边的位*/
memcpy(temp,data,time)
memcpy(temp+time,data+28,time)
/*前28位移动*/
memcpy(data,data+time,28-time)
memcpy(data+28-time,temp,time)
/*后28位移动*/
memcpy(data+28,data+28+time,28-time)
memcpy(data+56-time,temp+time,time)
return 0
}
/*IP置换*/
int DES_IP_Transform(ElemType data[64]){
int cnt
ElemType temp[64]
for(cnt = 0cnt <64cnt++){
temp[cnt] = data[IP_Table[cnt]]
}
memcpy(data,temp,64)
return 0
}
/*IP逆置换*/
int DES_IP_1_Transform(ElemType data[64]){
int cnt
ElemType temp[64]
for(cnt = 0cnt <64cnt++){
temp[cnt] = data[IP_1_Table[cnt]]
}
memcpy(data,temp,64)
return 0
}
/*扩展置换*/
int DES_E_Transform(ElemType data[48]){
int cnt
ElemType temp[48]
for(cnt = 0cnt <48cnt++){
temp[cnt] = data[E_Table[cnt]]
}
memcpy(data,temp,48)
return 0
}
/*P置换*/
int DES_P_Transform(ElemType data[32]){
int cnt
ElemType temp[32]
for(cnt = 0cnt <32cnt++){
temp[cnt] = data[P_Table[cnt]]
}
memcpy(data,temp,32)
return 0
}
/*异或*/
int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
int cnt
for(cnt = 0cnt <countcnt++){
R[cnt] ^= L[cnt]
}
return 0
}
/*S盒置换*/
int DES_SBOX(ElemType data[48]){
int cnt
int line,row,output
int cur1,cur2
for(cnt = 0cnt <8cnt++){
cur1 = cnt*6
cur2 = cnt<<2
/*计算在S盒中的行与列*/
line = (data[cur1]<<1) + data[cur1+5]
row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
+ (data[cur1+3]<<1) + data[cur1+4]
output = S[cnt][line][row]
/*化为2进制*/
data[cur2] = (output&0X08)>>3
data[cur2+1] = (output&0X04)>>2
data[cur2+2] = (output&0X02)>>1
data[cur2+3] = output&0x01
}
return 0
}
/*交换*/
int DES_Swap(ElemType left[32], ElemType right[32]){
ElemType temp[32]
memcpy(temp,left,32)
memcpy(left,right,32)
memcpy(right,temp,32)
return 0
}
/*加密单个分组*/
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){
ElemType plainBits[64]
ElemType copyRight[48]
int cnt
Char8ToBit64(plainBlock,plainBits)
/*初始置换（IP置换）*/
DES_IP_Transform(plainBits)
/*16轮迭代*/
for(cnt = 0cnt <16cnt++){
memcpy(copyRight,plainBits+32,32)
/*将右半部分进行扩展置换，从32位扩展到48位*/
DES_E_Transform(copyRight)
/*将右半部分与子密钥进行异或 *** 作*/
DES_XOR(copyRight,subKeys[cnt],48)
/*异或结果进入S盒，输出32位结果*/
DES_SBOX(copyRight)
/*P置换*/
DES_P_Transform(copyRight)
/*将明文左半部分与右半部分进行异或*/
DES_XOR(plainBits,copyRight,32)
if(cnt != 15){
/*最终完成左右部的交换*/
DES_Swap(plainBits,plainBits+32)
}
}
/*逆初始置换（IP^1置换）*/
DES_IP_1_Transform(plainBits)
Bit64ToChar8(plainBits,cipherBlock)
return 0
}
/*解密单个分组*/
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
ElemType cipherBits[64]
ElemType copyRight[48]
int cnt
Char8ToBit64(cipherBlock,cipherBits)
/*初始置换（IP置换）*/
DES_IP_Transform(cipherBits)
/*16轮迭代*/
for(cnt = 15cnt >= 0cnt--){
memcpy(copyRight,cipherBits+32,32)
/*将右半部分进行扩展置换，从32位扩展到48位*/
DES_E_Transform(copyRight)
/*将右半部分与子密钥进行异或 *** 作*/
DES_XOR(copyRight,subKeys[cnt],48)
/*异或结果进入S盒，输出32位结果*/
DES_SBOX(copyRight)
/*P置换*/
DES_P_Transform(copyRight)
/*将明文左半部分与右半部分进行异或*/
DES_XOR(cipherBits,copyRight,32)
if(cnt != 0){
/*最终完成左右部的交换*/
DES_Swap(cipherBits,cipherBits+32)
}
}
/*逆初始置换（IP^1置换）*/
DES_IP_1_Transform(cipherBits)
Bit64ToChar8(cipherBits,plainBlock)
return 0
}
/*加密文件*/
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
FILE *plain,*cipher
int count
ElemType plainBlock[8],cipherBlock[8],keyBlock[8]
ElemType bKey[64]
ElemType subKeys[16][48]
if((plain = fopen(plainFile,"rb")) == NULL){
return PLAIN_FILE_OPEN_ERROR
}
if((cipher = fopen(cipherFile,"wb")) == NULL){
return CIPHER_FILE_OPEN_ERROR
}
/*设置密钥*/
memcpy(keyBlock,keyStr,8)
/*将密钥转换为二进制流*/
Char8ToBit64(keyBlock,bKey)
/*生成子密钥*/
DES_MakeSubKeys(bKey,subKeys)
while(!feof(plain)){
/*每次读8个字节，并返回成功读取的字节数*/
if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
DES_EncryptBlock(plainBlock,subKeys,cipherBlock)
fwrite(cipherBlock,sizeof(char),8,cipher)
}
}
if(count){
/*填充*/
memset(plainBlock + count,'\0',7 - count)
/*最后一个字符保存包括最后一个字符在内的所填充的字符数量*/
plainBlock[7] = 8 - count
DES_EncryptBlock(plainBlock,subKeys,cipherBlock)
fwrite(cipherBlock,sizeof(char),8,cipher)
}
fclose(plain)
fclose(cipher)
return OK
}
/*解密文件*/
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
FILE *plain, *cipher
int count,times = 0
long fileLen
ElemType plainBlock[8],cipherBlock[8],keyBlock[8]
ElemType bKey[64]
ElemType subKeys[16][48]
if((cipher = fopen(cipherFile,"rb")) == NULL){
return CIPHER_FILE_OPEN_ERROR
}
if((plain = fopen(plainFile,"wb")) == NULL){
return PLAIN_FILE_OPEN_ERROR
}
/*设置密钥*/
memcpy(keyBlock,keyStr,8)
/*将密钥转换为二进制流*/
Char8ToBit64(keyBlock,bKey)
/*生成子密钥*/
DES_MakeSubKeys(bKey,subKeys)
/*取文件长度 */
fseek(cipher,0,SEEK_END)/*将文件指针置尾*/
fileLen = ftell(cipher)/*取文件指针当前位置*/
rewind(cipher)/*将文件指针重指向文件头*/
while(1){
/*密文的字节数一定是8的整数倍*/
fread(cipherBlock,sizeof(char),8,cipher)
DES_DecryptBlock(cipherBlock,subKeys,plainBlock)
times += 8
if(times <fileLen){
fwrite(plainBlock,sizeof(char),8,plain)
}
else{
break
}
}
/*判断末尾是否被填充*/
if(plainBlock[7] <8){
for(count = 8 - plainBlock[7]count <7count++){
if(plainBlock[count] != '\0'){
break
}
}
}
if(count == 7){/*有填充*/
fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain)
}
else{/*无填充*/
fwrite(plainBlock,sizeof(char),8,plain)
}
fclose(plain)
fclose(cipher)
return OK
}
int main()
{
clock_t a,b
a = clock()
DES_Encrypt("1.txt","key.txt","2.txt")
b = clock()
printf("加密消耗%d毫秒\n",b-a)
system("pause")
a = clock()
DES_Decrypt("2.txt","key.txt","3.txt")
b = clock()
printf("解密消耗%d毫秒\n",b-a)
getchar()
return 0
}
按照AES算法，完成AES算法S盒、行移位、列混合、轮密钥加 *** 作
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对租缺卖称密钥加密中最流行的算法之一。
AES采用对称分组密码体制，密钥的长度最弊逗少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。
AES加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）。AES加密有很多轮的重复和变换。大致步骤如下：1、密钥扩展（KeyExpansion），2、扮腊初始轮（Initial Round），3、重复轮（Rounds），每一轮又包括：字节替代（SubBytes）、行移位（ShiftRows）、列混合（MixColumns）、轮密钥加（AddRoundKey），4、最终轮（Final Round），最终轮没有MixColumns。
AES算法的加密整体结构
字节替代（SubBytes）：使用一个S盒进行非线性置换，S盒是一个16×16的矩阵，如表4-9所示。字节替代将输入的状态矩阵的每一个字节通过一个简单查表 *** 作，映射为另外一个字节。
输入字节的前4bits指定S盒的行值，后4bits指定S盒的列值，行和列所确定S盒位置的元素作为输出，例如输入字节“03”，行值为0，列值为3，根据表4-9可知第0行第3列对应的值为 “7B”，因此输出字节为“7B”。
举例
在上面的示例中，第1个基本元素为”F5”，它将被S盒行为第”F行”、列为第”5”列的元素“E6“代替，其余的输出也用相同的方法确定。
状态阵列的4个行循环以字节为基本单位进行左移，而每行循环做移的偏移量是由明文分组的大小和所在行数共同确定，即列数Nb和行号确定。
举例
举例
轮密钥加 *** 作是将密钥与明文按比特异或，轮密钥通过密钥扩展得到
和fips-192(AES)的标准一样
1 AES加密、解密算法原理和AVR实现AES是分组密钥，算法输入128位数据，密钥长度也是128位。用Nr表示对一个数据分组加密的轮数（加密轮数与密钥长度的关系如表1所列）。每一轮都需要一个与输入分组具有相同长度的扩展密钥Expandedkey(i)的参与。由于外部输入的加密密钥K长度有限,所以在算法中要用一个密钥扩展程序(Keyexpansion)把外部密钥K扩展成更长的比特串,以生成各轮的加密和解密密钥。
1.1圈变化
AES每一个圈变换由以下三个层组成:
非线性层——进行Subbyte变换；
线行混合层——进行ShiftRow和MixColumn运算；
密钥加层——进行AddRoundKey运算。
① Subbyte变换是作用在状态中每个字节上的一种非线性字节转换,可以通过计算出来的S盒进行映射。携冲山
Schange:
ldi zh,＄01将指针指向S盒的首地址
mov zl,r2；将要查找的数据作为指针低地址
ldtemp,z+；取出这个对应的数据
mov r2,temp；交换数据完成查表
.
.
.
ret
② ShiftRow是一个字节换位。它将状态中的行按照不同的偏移量进行循环移位，而这个偏移量也是根据Nb的不同而选择的[3]。
shiftrow:这是一个字节换位的子程序
mov temp,r3因为是4×4
mov r3,r7r2 r6 r10 r14 r2 r6 r10 r14
mov r7,r11r3 r7 r11 r15---r7 r11 r15 r3
mov r11,r15r4 r8 r12 r17 r12 r17 r4 r8
mov r15,tempr5 r9 r13 r18 r18 r5 r9 r13
mov temp,r4
mov temp1,r8
mov r4,r12
mov r8,r17
mov r12,temp
mov r17,temp1
mov temp,r18
mov r18,r13
mov r13,r9
mov r9,r5
mov r5,temp
ret
③ 在MixColumn变换中,把状态中的每一列看作GF(28)上的多项式a(x)与固定多项式c(x)相乘的结果辩中。b(x)=c(x)*a(x)的系数这样计算:*运算不是普通的乘法运算,而是特殊的运算，即
b(x)=c(x)·a(x)(mod x4+1)
对于这个运算
b0=02。a0+03。a1+a2+a3
令xtime(a0)=02。a0
其中，符号“。”表示模一个八次不可约多项式的同余乘法[3]。
mov temp,a0这是一个mixcolimn子程序
rcall xtime调用xtime程序
mov a0,temp
mov temp,a1
rcall xtime
eor a0,a1
eor a0,temp
eor a0,a2
eor a0,a3完成b(x)的计算
.
.
.
xtime:这是一个子程序
ldi temp1,＄1b
lsl temp
brcs next1如果最高位是1,则转移
next: ret否则什么也不变化
next1:eor temp,temp1
rjmp next
对于逆变化,其矩阵C要改变成相应的D,即b(x)=d(x)＊a(x)。
④ 密钥加层运算(addround)是将圈密钥状态中的对应字节按位“异或”。
⑤ 根据线性变化的性质[1],解密运算是加密变化的逆变化。这里不再详细叙述。
1.2轮变化
对不同的分判仿组长度，其对应的轮变化次数是不同的,如表1所列。
1.3密钥扩展
AES算法利用外部输入密钥K(密钥串的字数为Nk),通过密钥的扩展程序得到共计4(Nr+1)字的扩展密钥。它涉及如下三个模块:
① 位置变换(rotword)——把一个4字节的序列[A,B,C,D]变化成[B,C,D,A]；
② S盒变换(subword)——对一个4字节进行S盒代替；
③ 变换Rcon[i]——Rcon[i]表示32位比特字[xi-1,00,00,00]。这里的x是（02），如
Rcon[1]=[01000000]；Rcon[2]=[02000000]；Rcon[3]=[04000000]……
扩展密钥的生成：扩展密钥的前Nk个字就是外部密钥K；以后的字W[[i]]等于它前一个字W[[i-1]]与前第Nk个字W[[i-Nk]]的“异或”,即W[[i]]=W[[i-1]]�W[[i- Nk]]。但是若i为Nk的倍数,则W[i]=W[i-Nk]�Subword(Rotword(W[[i-1]]))�Rcon[i/Nk]。
程序执行的时候,主要调用以上几个子程序，具体实现如下：
Keyexpansion:
rcall rotwoed
rcall subword
rcall Rcon
.
.
.
2 AES加密、解密算法的优化
由以上算法的流程中可以清楚地看到，整个算法中程序耗时最多的就是圈变化部分，因此对于算法的优化也就在此；而圈变化部分可以优化的也就是列变化。因为列变化是一个模乘同余规则。由于AES加密和解密是不对称的,如果不对其进行优化,会使算法的解密速度远远大于加密的速度[1]。
① 加密运算。对列变换（Mixcolumn）可以通过调用xtime子程序进行优化。
另一种有效的优化方法就是离线构造一个表格，即列变化表格。这样只要通过查表的方式就可以提高加密速度。
② 解密算法的优化。由于解密的列变换的系数分别是09、0E、0B和0D。在AVR单片机上实现以上的乘法显然是需要很多的时间,从而导致了解密的性能降低。
优化方法一：对列变化进行分解使倍乘次数降低。
仔细研究解密矩阵的系数，不难发现解密矩阵和加密矩阵有着一定的联系，即解密矩阵等于加密矩阵和一个矩阵的相乘。通过这样的联系，就可以对算法进行优化：
这样一来,只用几个简单的“异或”就可以实现列变化，使倍乘的次数降低,提高解密的速度。
优化方法二：构造表格。
同加密构造方法一样，可以构造四个表格T[ea]=e×aT[9a]=9×aT[9a]=9×aT[ba]=b×a。这样一来，也只需要进行查表和简单的异或就可以完成解密的任务。虽然这种方法将增加额外的开销,但是它却是一种有效的方法。
3 AES加密与解密的实验仿真
根据以上实验步骤和优化方法得出表2、3所列实验结果。
设主密钥为:000102030405060708090a0b0c0d0e0f(128bit)。
加密明文:00112233445566778899AABBCCDDEEFF。
密文:69C4E0D86A7B0430D8CDB78070B4C55A。
解密密文:69C4E0D86A7B0430D8CDB78070B4C55A。
明文:00112233445566778899AABBCCDDEEFF。
总之,AES密码是一个非对称密码体制，它的解密要比加密复杂和费时。解密优化算法没有增加存储空间的基础上,以列变化为基础进行处理，程序比原始的要小，而且节约了时间。解密优化方法速度最快，效率最高，但要增加系统的存储空间,因此它的程序也是最大的一个
流程图省略 朋友参考吧
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）