现代密码学实验报告

现代密码学实验报告

学生姓名

学号

专业班级

指导教师

学院信息科学与工程学院

完成时间2014年5月

实验一对称密码算法实验

[实验目的]

1.掌握密码学中经典的对称密码算法DES、AES、RC4的算法原理。

2.掌握DES、AES、RC4的算法流程和实现方法。

[实验预备]

1.DES算法有什么特点？算法中的哪些结构保证了其混淆和扩散的特性？

答：分组比较短、密钥太短、密码生命周期短、运算速度较慢。采用替代和置换的方法简单有效地遵循了香农定理，替代操作通过S盒达到了混淆效果，置换操作通过P盒扩散效果。

2.AES算法的基本原理和特点。

答：AES加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）。AES加密有很多轮的重复和变换。大致步骤如下：1、密钥扩展（KeyExpansion），2、初始轮（Initial Round），3、重复轮（Rounds），每一轮又包括：SubBytes、ShiftRows、MixColumns、AddRoundKey，4、最终轮（Final Round），最终轮没有MixColumns。

3.流密码RC4的密钥流生成以及S盒初始化过程。

答：RC4由伪随机数生成器和异或运算组成。RC4的密钥长度可变，围是[1,255]。RC4一个字节一个字节地加解密。给定一个密钥，伪随机数生成器接受密钥并产生一个S盒。S盒用来加密数据，而且在加密过程中S盒会变化。初始化长度为256的S盒。第一个for循环将0到255的互不重复的元素装入S盒。第二个for循环根据密钥打乱S盒。下面i,j是两个指针。每收到一个字节，就进行while循环。通过一定的算法（(a),(b)）定位S盒中的一个元素，并与输入字节异或，得到k。循环中还改变了S盒（(c)）。如果输入的是明文，输出的就是密文；如果输入的是密文，输出的就是明文。

[实验容]

1.分析DES、AES、RC4、SHA的实现过程。

2. 用程序设计语言将算法过程编程实现。

3. 完成字符串数据的加密运算和解密运算

输入明文：Idolikethisbook

输入密钥：cryption

[实验步骤]

1. 预习DES、AES、RC4算法。

2. 写出算法流程，用程序设计语言将算法过程编程实现。

DES算法流程：

代码：

#include "memory.h"

#include "stdio.h"

#include

#include

#include

using namespace std;

enum{encrypt,decrypt};

//ENCRYPT:加密，DECRYPT：解密

void des_run(char out[8],char in[8],bool type=encrypt);

//设置密钥

void des_setkey(const char key[8]);

static void f_func(bool in[32],const bool ki[48]);

//f函数

static void s_func(bool out[32],const bool in[48]);

//s盒代替

//变换

static void transform(bool *out, bool *in, const char *table, int len); static void xor(bool *ina, const bool *inb, int len);

//异或

static void rotatel(bool *in, int len, int loop);

//循环左移

//字节组转换成位组

static void bytetobit(bool *out,const char *in, int bits);

//位组转换成字节组

static void bittobyte(char *out, const bool *in, int bits);

//置换IP表

const static char ip_table[64]={58,50,42,34,26,18,10,2,

60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6,

64,56,48,40,32,24,16,8,

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};

//逆置换IP-1表

const static char ipr_table[64]={40,8,48,16,56,24,64,32,

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};

//E位选择表

static const char e_table[48]={32,1,2,3,4,5,4,5,

6,7,8,9,8,9,10,11,

12,13,12,13,14,15,

16,17,16,17,18,19,

20,21,20,21,22,23,

24,25,24,25,26,27,

28,29,28,29,30,31,32,1};

//P换位表

const static char p_table[32]={16,7,20,21,29,12,28,

17,1,15,23,26,5,18,

31,10,2,8,24,14,32,

27,3,9,19,13,30,6,22,11,4,25}; //pc1选位表

const static char pc1_table[56]={57,49,41,33,25,17,9,

1,58,50,42,34,26,18,

10,2,59,51,43,35,27,

19,11,3,60,52,44,36,

63,55,47,39,31,23,15,

7,62,54,46,38,30,22,

14,6,61,53,45,37,29,

21,13,5,28,20,12,4};

//pc2选位表

const static char pc2_table[48]={14,17,11,24,1,5,3,28,

15,6,21,10,23,19,12,4,

26,8,16,7,27,20,13,2,

41,52,31,37,47,55,30,

40,51,45,33,48,44,49,

39,56,34,53,46,42,50,36,29,32};

//左移位数表

const static char loop_table[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

//S盒

const static char s_box[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};

static bool subkey[16][48];

//16圈子密钥

void des_run(char out[8],char in[8],bool type)

{

static bool m[64],tmp[32],*li=&m[0],*ri=&m[32];bytetobit(m,in,64);

transform(m,m,ip_table,64);

if(type==encrypt)

{

for(int i=0;i<16;i++)

{

memcpy(tmp,ri,32);

f_func(ri,subkey[i]);

xor(ri,li,32);

memcpy(li,tmp,32);

}

}else

{

for(int i=15;i>=0;i--)

{

memcpy(tmp,li,32);

f_func(li,subkey[i]);

xor(li,ri,32);

memcpy(ri,tmp,32);

}

}

transform(m,m,ipr_table,64);

bittobyte(out,m,64);

}

void des_setkey(const char key[8])

{

static bool k[64], *kl=&k[0], *kr=&k[28];

bytetobit(k,key,64);

transform(k,k,pc1_table,56);

for(int i=0;i<16;i++)

{

rotatel(kl,28,loop_table[i]);

rotatel(kr,28,loop_table[i]);

transform(subkey[i],k,pc2_table,48);

}

}

void f_func(bool in[32],const bool ki[48])

{

static bool mr[48];

transform(mr,in,e_table,48);

xor(mr,ki,48);

s_func(in,mr);

transform(in,in,p_table,32);

}

void s_func(bool out[32],const bool in[48])

{

for(char i=0,j,k;i<8;i++,in+=6,out+=4)

{

j=(in[0]<<1)+in[5];

k=(in[1]<<3)+(in[2]<<2)+(in[3]<<1)+in[4];

bytetobit(out,&s_box[i][j][k],4);

}

}

void transform(bool *out,bool *in,const char *table,int len) {

static bool tmp[256];

for(int i=0;i

tmp[i]=in[table[i]-1];

memcpy(out,tmp,len);

}

void xor(bool *ina,const bool *inb,int len)

{

for(int i=0;i

ina[i]^=inb[i];

}

void rotatel(bool *in,int len,int loop)

{

static bool tmp[256];

memcpy(tmp,in,loop);

memcpy(in,in+loop,len-loop);

memcpy(in+len-loop,tmp,loop);

}

void bytetobit(bool *out,const char *in,int bits)

{

for(int i=0;i

out[i]=(in[i/8]>>(i%8))&1;

}

void bittobyte(char *out,const bool *in,int bits)

{

memset(out,0,(bits+7)/8);

for(int i=0;i

out[i/8]|=in[i]<<(i%8);

}

void main()

{

string str;

puts("*****************DES***********************");

cout<

puts("please input your words");

cin>>str;

// getline(cin,str);

printf("\n");

char key[8];

cout<<"please input your key(8):";

for(int p=0;p<=7;p++)

cin>>key[p];

des_setkey(key);

int m=str.size();

int n=m/8+1;

str=str.substr(0,m);

int i=0;

string aw,mw;

for(n;n>0;n--)

{

char *str1=new char[8];

string temp;

temp=str.substr(i,8);

i=i+8;

strcpy(str1,temp.c_str());

des_run(str1,str1,encrypt);

aw=aw+str1;

aw=aw.substr(0,m+6);//m+1-->m+6

des_run(str1,str1,decrypt);

mw=mw+str1;

string temp1;

strcpy(str1,temp1.c_str());

str1="";

temp="";

}

puts("after encrypting:");

cout<

puts("after decrypting:");

cout<

}

AES算法流程图：

代码：

#include

#include

#include

#define null 0

const unsigned char Sbox[256] = { // forward s-box

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};

const unsigned char ISbox[256] = { // inverse s-box

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};

static unsigned char AesRcon[11*4]=

{

0x00, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00,

0x02, 0x00, 0x00, 0x00,

0x04, 0x00, 0x00, 0x00,

0x08, 0x00, 0x00, 0x00,

0x10, 0x00, 0x00, 0x00,

0x20, 0x00, 0x00, 0x00,

0x40, 0x00, 0x00, 0x00,

0x80, 0x00, 0x00, 0x00,

0x1b, 0x00, 0x00, 0x00,

0x36, 0x00, 0x00, 0x00

};

static unsigned char gfmultby01(unsigned char b)

{

return b;

}

static unsigned char gfmultby02(unsigned char b)

{

if (b < 0x80)

return (unsigned char)(int)(b <<1);

else

return (unsigned char)( (int)(b << 1) ^ (int)(0x11B) );

}

static unsigned char gfmultby03(unsigned char b)

{

return (unsigned char) ( (int)gfmultby02(b) ^ (int)b );

}

static unsigned char gfmultby09(unsigned char b)

{

return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^

(int)b );

}

static unsigned char gfmultby0b(unsigned char b)

{

return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^

(int)gfmultby02(b) ^

(int)b );

}

static unsigned char gfmultby0d(unsigned char b)

{

return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^

(int)gfmultby02(gfmultby02(b)) ^

(int)(b) );

}

static unsigned char gfmultby0e(unsigned char b)

{

return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^

(int)gfmultby02(gfmultby02(b)) ^

(int)gfmultby02(b) );

}

//密钥移位函数

unsigned char* RotWord(unsigned char* word)

{

unsigned char* temp = new unsigned char[4];

temp[0] = word[1];

temp[1] = word[2];

temp[2] = word[3];

temp[3] = word[0];

return temp;

}

unsigned char* SubWord(unsigned char* word)

{

unsigned char* temp = new unsigned char[4];

for(int j=0;j<4;j++)

{

temp[j] = Sbox[word[j]];

}

return temp;

}

void chartomatrix(unsigned char*str,unsigned char Base[][4]) {

int r,c;

for(c=0;c<4;c++)

{

for(r=0;r<4;r++)

Base[r][c]=str[4 * c+r];

}

}

void ByteSub(unsigned char a[4][4],unsigned char b[4][4])

//字节转换

{

int r,c;

for(r=0;r<4;r++)

for(c=0;c<4;c++)

b[r][c]=(Sbox[a[r][c]]);

}

void IvByteSub(unsigned char a[][4],unsigned char b[][4])

//逆字节转换

{

int r,c;

for(r=0;r<4;r++)

for(c=0;c<4;c++)

b[r][c]=ISbox[a[r][c]];

}

void ShiftRow(unsigned char b[][4],unsigned char C[][4])

//行变换

{

int r,c;

for(r=0;r<4;r++)

{

for(c=0;c<4;c++)

C[r][c]=b[r][(c+r)%4];

}

}

void IvShiftRow(unsigned char b[][4],unsigned char C[][4])

//逆移动行变换

{

int r,c;

for(r=0;r<4;r++)

{

for(c=0;c<4;c++)

C[r][c]=b[r][(c+4-r)%4];

}

}

void MixColumn(unsigned char C[][4],unsigned char d[][4])

//混合列变换

{

int c;

for(c=0;c<4;c++)

d[0][c]=(unsigned char)((int)gfmultby02(C[0][c]) ^ (int)gfmultby03(C[1][c]) ^ (int)gfmultby01(C[2][c]) ^ (int)gfmultby01(C[3][c]));

for(c=0;c<4;c++)

d[1][c]=(unsigned char)((int)gfmultby01(C[0][c]) ^ (int)gfmultby02(C[1][c]) ^ (int)gfmultby03(C[2][c]) ^ (int)gfmultby01(C[3][c]));

for(c=0;c<4;c++)

d[2][c]=(unsigned char)((int)gfmultby01(C[0][c]) ^ (int)gfmultby01(C[1][c]) ^ (int)gfmultby02(C[2][c]) ^ (int)gfmultby03(C[3][c]));

for(c=0;c<4;c++)

d[3][c]=(unsigned char)((int)gfmultby03(C[0][c]) ^ (int)gfmultby01(C[1][c]) ^ (int)gfmultby01(C[2][c]) ^ (int)gfmultby02(C[3][c]));

}

void IvMixColumn(unsigned char C[][4],unsigned char d[][4])

//逆混合列变换

{

int c;

for(c=0;c<4;c++)

d[0][c]=(unsigned char)((int)gfmultby0e(C[0][c]) ^ (int)gfmultby0b(C[1][c]) ^ (int)gfmultby0d(C[2][c]) ^ (int)gfmultby09(C[3][c]));

for(c=0;c<4;c++)

d[1][c]=(unsigned char)((int)gfmultby09(C[0][c]) ^ (int)gfmultby0e(C[1][c]) ^ (int)gfmultby0b(C[2][c]) ^ (int)gfmultby0d(C[3][c]));

for(c=0;c<4;c++)

d[2][c]=(unsigned char)((int)gfmultby0d(C[0][c]) ^ (int)gfmultby09(C[1][c]) ^ (int)gfmultby0e(C[2][c]) ^ (int)gfmultby0b(C[3][c]));

for(c=0;c<4;c++)

d[3][c]=(unsigned char)((int)gfmultby0b(C[0][c]) ^ (int)gfmultby0d(C[1][c]) ^ (int)gfmultby09(C[2][c]) ^ (int)gfmultby0e(C[3][c]));

}

void AddRoundKey(unsigned char d[][4],unsigned char key[][4],unsigned char e[][4]) //加循环密钥

{

int r,c;

for(r=0;r<4;r++)

for(c=0;c<4;c++)

e[r][c]=(unsigned char)((int)d[r][c]^(int)key[r][c]);

}

void KeyProducing(unsigned char*key,unsigned char K[4][44])

//扩展初始密钥到44列

{

unsigned char BaseK[4][4]={0};

chartomatrix(key,BaseK);

int r,c;

unsigned char *temp=new unsigned char[4];

for(c=0;c<4;++c)

{

for(r=0;r<4;++r)

K[r][c]=BaseK[r][c];

}

for(c=4;c<44;c++)

{

if(c%4!=0)

for(r=0;r<4;r++)

K[r][c]=(unsigned char)((int)K[r][c-4] ^ (int)K[r][c-1]);

else

{ for(r=0;r<4;r++)

temp[r]=K[r][c-1];

temp=SubWord(RotWord(temp));

temp[0] = (unsigned char)( (int)temp[0] ^ (int) AesRcon[c+0] );

temp[1] = (unsigned char)( (int)temp[1] ^ (int) AesRcon[c+1] );

temp[2] = (unsigned char)( (int)temp[2] ^ (int) AesRcon[c+2] );

temp[3] = (unsigned char)( (int)temp[3] ^ (int) AesRcon[c+3] );

for(r=0;r<4;r++)

K[r][c]=(unsigned char)((int)K[r][c-4] ^ temp[r]);

}

}

}

void Encode(unsigned char *Mwen,unsigned char K[][44],unsigned char*out) {

unsigned char BaseM[4][4]={0};

int round,r,c;

unsigned char Ki[4][4]={0};

unsigned char e[4][4]={0},b[4][4]={0},C[4][4]={0},d[4][4]={0};

chartomatrix(Mwen,BaseM);

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][c];

//第0个循环密钥

AddRoundKey(BaseM,Ki,e);

//ARK,使用第0个循环密钥

for(round=1;round<10;round++)

{

ByteSub(e,b);

//字节转换

ShiftRow(b,C);

//移动行变换

MixColumn(C,d);

//混合列变换

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][4*round+c];

//产生第round轮循环的密钥Ki

AddRoundKey(d,Ki,e);

//roundth循环加密

}

ByteSub(e,b);

//第10次循环加密的移动行变换

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][4*10+c];

//产生第10轮循环的密钥Ki

AddRoundKey(C,Ki,e);

//10th循环加密

for(c=0;c<4;c++)

{

for(r=0;r<4;r++)

out[r+4*c]=e[r][c];

//加密结果转换成输入

}

}

void Decode(unsigned char*Miwen,unsigned char K[][44],unsigned char*out) {

unsigned char BaseM[4][4]={0};

unsigned char Ki[4][4]={0};

unsigned char e[4][4]={0},b[4][4]={0},C[4][4]={0},d[4][4]={0};

int round,r,c;

chartomatrix(Miwen,BaseM);

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][4*10+c];

//产生第10轮循环的密钥Ki

AddRoundKey(BaseM,Ki,e);

//10th循环解密

for(round=9;round>0;round--)

{

IvShiftRow(e,b);

IvByteSub(b,C);

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][4*round+c];

//产生第round轮循环的密钥Ki

AddRoundKey(C,Ki,d);

IvMixColumn(d,e);

}

IvShiftRow(e,b);

IvByteSub(b,C);

for(r=0;r<4;r++)

for(c=0;c<4;c++)

Ki[r][c]=K[r][c];

//产生第round轮循环的密钥Ki

AddRoundKey(C,Ki,e);

//ARK,使用第0个循环密钥

for(c=0;c<4;c++)

for(r=0;r<4;r++)

out[r+4*c]=e[r][c];

//加密结果转换成输入

}

void main()

{

unsigned char K[4][44]={0};

unsigned char *Mwen=new unsigned char[17];

unsigned char key[]="1234567890123456";

unsigned char outjiam[16]={0};

unsigned char outjiem[16]={0};

int i;

char filename[15] ;

cout<<"请输入待加密字符串所在文件的文件名：(文件名的长度不要超过15个字符)"<

cin>>filename;

ifstream file;

file.open(filename,ios::binary,0);

file.seekg(0,ios::beg);

file.get(Mwen,17,'#');

file.close();

cout<<"加密前的明文:"<

cout<

KeyProducing(key,K);

Encode(Mwen,K,outjiam);

cout<<"\n加密后的密文:\n";

for(i=0;i<16;i++)

cout<

cout<

Decode(outjiam,K,outjiem);

cout<<"\n密文解密后的明文:\n";

for(i=0;i<16;i++)

{

if(outjiem[i] >=128)

cout<<(char)(outjiem[i]%128);

else

cout<<(char)(outjiem[i]);

}

cout<

}

RC4算法流程：

算法的初始化部分（用类C伪代码表示）：

for (i=0; i

s[i]=i;

}

j=0;

for (i=0; i

{

j=(j+s[i]+k[i])%n;

swap(s[i], s[j]);

}

在初始化的过程中，密钥的主要功能是将S-box搅乱，i确保S-box的每个元素都得到处理，j保证S-box的搅乱是随机的。而不同的S-box在经过伪随机子密码生成算法的处理后可以得到不同的子密钥序列，并且，该序列是随机的：

i=j=0;

while (明文未结束)

{

++i%=n;

j=(j+s)%n;

swap(s, s[j]);

sub_k=s((s+s[j])%n);

}

得到的子密码sub_k用以和明文进行xor运算，得到密文，解密过程也完全相同。

代码：

#include

#include

#include

using namespace std;

typedef unsigned long ULONG;

void rc4_init(unsigned char *s, unsigned char *key, unsigned long Len) {

int i = 0, j = 0;

char k[256] = {0};

unsigned char temp = 0;

for(i = 0; i < 256; i++)

{

s[i] = i;

k[i] = key[i % Len];

}

for (i = 0; i < 256; i++)

{

j = (j + s[i] + k[i]) % 256;

temp = s[i];

s[i] = s[j];

s[j] = temp;

}

}

void rc4_crypt(unsigned char *s, unsigned char *Data, unsigned long Len) {

int i = 0, j = 0, t = 0;

unsigned long k = 0;

unsigned char temp;

for(k = 0; k < Len; k++)

{

i = (i + 1) % 256;

j = (j + s[i]) % 256;

temp = s[i];

s[i] = s[j];

s[j] = temp;

t = (s[i] + s[j]) % 256;

Data[k] ^= s[t];

}

}

int main()

{

unsigned char s[256] = {0}, s2[256] = {0};

cout<<"****************RC4****************"<

cout<<"请输入加密容："<

char pData[600];

cin>>pData;

cout<<"请输入密钥："<

char key[256];

cin>>key;

cout<

ULONG len = strlen(pData);

int i;

system("cls");

cout<<"****************RC4****************"<

cout<<"明文为:"<

cout<<"密钥为:"<

cout<<"密钥长度为:"<

rc4_init(s, (unsigned char *)key, strlen(key));

cout<<"S盒初始化填充完毕……"<

for(i = 0; i < 256; i++)

{

s2[i] = s[i];

}

cout<<"加密后:"<

rc4_crypt(s, (unsigned char *)pData, len);

cout<<"密文为："<

cout<<"解密后:"<

rc4_crypt(s2, (unsigned char *)pData, len);

cout<<"解密为："<

return 0;

}

3.输入指定的明文、密钥进行实验，验证结果。DES运行截图：

AES