AES算法的实现与分析

        随着现代密码分析水平、芯片处理能力和计算技术的不断进步，高级加密标准AES的Rijndael算法将在各行业各部门获得广泛的应用，成为虚拟专用网、SONET、远程访问服务器、高速ATM/以太路由器、移动通信、卫星通信、电子金融业务等的加密算法，并逐渐取代DES在IPSec、SSL和ATM中的加密功能。目前，IEEE 802.11i草案已经定义了AES加密的两种不同运行模式，成功解决了无限局域网标准中的诸多安全问题。在这种情形下，AES算法的安全性及其快速实现问题显得格外突出，本文对此进行了全面的论述，希望能为有意进行这一方面研究和应用的同行提供有益的参考。

       文章阐述了Rijndael算法的设计特色，介绍了AES在密码分析方面国内外已有的一些理论分析成果，描述了AES算法采用软件和硬件实现方案。此外，本文章从数学基础的知识上阐明了AES算法的四个步骤。从AES算法抵抗强力攻击能力，抵抗差分分析和线性密码分析的能力，抵抗渗透攻击能力，抵抗代数计算攻击能力，抵抗XSL攻击能力，弱密钥的分析这几个方面进行了分析从而说明AES的安全性能。我们根据算法的安全性、代价以及算法与实现特性的原则实现了AES的算法，从密钥编排方案分析了密钥的设计准则和选取。

       随着对称密码的发展，3DES用软件实现速度相对较慢，它使用的64位分组长度显得不够高效和安全的缺点使得需要一种新的高级加密标准来替代它。AES的全称是 Advanced Encryption Standard，即高级加密标准。该项目由美国国家标准技术研究所 (NIST)于1997年开始启动并征集算法，在2000年确定采用Rijndael作为其最终算法，并于 2001年被美国商务部部长批准为新的联邦信息加密标准 (FIPS PUB 197)，该标准的正式生效日期是2002年5月26日。2000年10月2日，NIST对Rijndael做 出了最终评估。

       AES是一个迭代的、对称密钥分组的密码，它可以使用128、192和256位密钥，并且用128位(16字节)分组加密和解密数据。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换(permutations)和替换(substitutions)输入数据。

       一个密码算法的有效性首先体现在可靠的安全性上。Rijndael算法设计采用针对差分和线性密码分析提出的宽轨迹策略(WTS)，其最大优势是可以给出算法最佳差分特征的概率以及最佳线性逼近偏差的界；使用简单的部件组织成清晰的结构，便于算法安全性的分析。当然，在密码学界永远没有绝对的安全，Rijndael算法也不例外，如其明显的代数结构对安全性的潜在威胁已经受到一些学者的质疑。本文从简化算法攻击、算法结构性质分析以及密码分析的进展等方面对AES算法的密码分析状况进行讨论。

简化算法攻击

       目前尚未出现对完整Rijndael算法的成功攻击，只提出了几种针对简化算法的攻击方法。最有名的当数密码设计者自己提出的Square攻击，其主要思想是利用第4轮字节替换前后平衡性的改变来猜测密钥字节，对128比特密钥下4到6轮简化算法有效。Biham[2]等对Square攻击进行改进，时间复杂度降为原来的一半，并认为颠倒轮密钥的顺序可将攻击复杂度降低28。Lucks[3]利用密钥生成算法的弱点，将Square攻击的密钥长度扩展到192和256比特，攻击7轮简化算法比穷尽搜索快。Ferguson[4]利用“部分和”技术将6轮Square攻击的复杂度从272降到244，并推广到7轮和8轮简化算法，指出密钥生成算法中几个违背设计准则的特性，利用慢扩散性设计了一个针对256比特密钥下9轮简化算法的密钥相关攻击方案。

       Gilbert[5]利用局部函数间的冲突特性对4到7轮简化算法进行了攻击。Cheon等将5轮不可能差分攻击推广到6轮，复杂度高于相应的Square攻击，但仍快于密钥穷尽搜索。Koeune[6]描述了一种计时攻击，通过对每个密钥数千次的测量，展现攻破一个不良的现实设计的过程。Golic[7]则指出AES算法虽然能够通过乘法掩盖来抵抗简单能量攻击(SPA)，对差分能量攻击(DPA)却无能为力。

 

 

1. 首先声明一个Aes的类

功能描述：以面向对象的方式，建立了一个类对象，包含了AES加密过程中要实现各项功能的函数，这样能够清晰的看到整个加密程序的结构，有利于对程序的模块化管理。

实现代码：

class Aes 

{

 public:

      ~Aes();

      Aes();

   Aes();   //构造函数用密钥长度keySize和密钥内容keyBytes作为参数。

void Cipher();  // 加密函数，input 为16位为要加密的明文

InvCipher();  // 解密函数，input 为16位要解密的密文

private:

      int Nb;  int Nk; int Nr;       

      unsigned char key[32];

      unsigned char w[16*15];

 

      SetNbNkNr(int keySize);      //设置轮数

      AddRoundKey(int round);      //轮密钥加

      SubBytes();                  //S盒字节代换

      InvSubBytes();               //逆S盒字节代换

      ShiftRows();                 //行移位

      InvShiftRows();

      MixColumns();                //列混淆

      InvMixColumns();

KeyExpansion();              //密钥扩展

      unsigned char* SubWord(unsigned char* word);         //密钥S盒字代换

      unsigned char* RotWord(unsigned char* word);         //密钥移位

}

1. 成员函数的实现：

1. 迭代分组列数、密钥列数、迭代次数设置函数

功能描述：因为AES分组长度为128 bits，Nb固定为4。再根据界面密钥长度窗口keySize的选择，判断是密钥是128、192、256比特，然后设置密钥列数Nk，然后可得到Nr。（根据第2章“轮数的确定”一节）

实现代码：

Aes::SetNbNkNr(int keySize)

{

   Nb=4;

   if(keySize==Bits128)

   {

       Nk=4;    //4*4字节，128位密钥，10轮加密

       Nr=10;

   }

   else if(keySize==Bits192)

   {

       Nk=6;    //6*4字节，192位密钥，12轮加密

       Nr=12;

   }

   else if(keySize==Bits256)

   {

       Nk=8;    //8*4字节，256位密钥，14轮加密

       Nr=14;

   }

}

1. 构造函数

功能描述：实现了设置密钥块数，轮数，并且将设定了密码，和为密钥扩展提前做的初始化。

实现代码：

Aes::Aes(int keysize,unsigned char* keyBytes)

{

      SetNbNkNr(keysize);                         //设置密钥块数，轮数

      memcpy(key,keyBytes,keysize);                          //字符串拷贝函数，把keyBytes的keysize个字符复制到key中

      KeyExpansion();                                                  //密钥扩展，必须提前做的初始化

}

1. 密钥扩展函数

功能描述：加密和解密过程分别需要Nr+1个子密钥。所以需要对密钥进行扩展。

实现方式：主密钥的扩展首先将从界面输入的子密钥拷贝，并按一维数组排成4*Nk矩阵，然后取Nk列，进行RotWord()移位变换，将第一位移到第四位，再进行SubWord() 字节代换，最后再和上一个密钥的第1列做模二加法，得到新的子密钥块的第1列密钥，然后第2、3、4列是直接由前一列和上一子密钥模二加法得到。

实现代码 ：

Aes::KeyExpansion()

{

      memset(w,0,16*15);

      for(int row=0;row<Nk;row++)       //拷贝seed 密钥

      {

             w[4*row+0] =  key[4*row];

             w[4*row+1] =  key[4*row+1];

             w[4*row+2] =  key[4*row+2];

             w[4*row+3] =  key[4*row+3];

      }

      byte* temp = new byte[4];

      for(row=Nk;row<4*(Nr+1);row++)

      {

             temp[0]=w[4*row-4];     //当前列的前一列 

             temp[1]=w[4*row-3];

             temp[2]=w[4*row-2];

             temp[3]=w[4*row-1];

             if(row%Nk==0)           //逢nk时，对当前列的前一列作特殊处理

             {

                    temp=SubWord(RotWord(temp));//先移位，再代换，最后和轮常量异或

                    temp[0] = (byte)( (int)temp[0] ^ (int) AesRcon[4*(row/Nk)+0] );  

                    temp[1] = (byte)( (int)temp[1] ^ (int) AesRcon[4*(row/Nk)+1] );

                    temp[2] = (byte)( (int)temp[2] ^ (int) AesRcon[4*(row/Nk)+2] );

                    temp[3] = (byte)( (int)temp[3] ^ (int) AesRcon[4*(row/Nk)+3] );

        }

             else if ( Nk > 6 && (row % Nk == 4) )  //这个还没有搞清楚

        {

                    temp = SubWord(temp);

        }

        // w[row] = w[row-Nk] xor temp

        w[4*row+0] = (byte) ( (int) w[4*(row-Nk)+0] ^ (int)temp[0] );

             w[4*row+1] = (byte) ( (int) w[4*(row-Nk)+1] ^ (int)temp[1] );

             w[4*row+2] = (byte) ( (int) w[4*(row-Nk)+2] ^ (int)temp[2] );

             w[4*row+3] = (byte) ( (int) w[4*(row-Nk)+3] ^ (int)temp[3] );

      }  // for loop

}

1. 轮密钥加

功能描述：在每一轮的加密过程实现了将分组的待加密字符串的第一列与一个密钥字进行按位异或。

实现代码：

Aes::AddRoundKey(int round)

{

      int i,j;  //i行 j列           //因为密钥w是一列一列排列的，即 k0 k4 k8 k12

      for(j=0;j<4;j++)                   //                                             k1 k5 k9 k13

      {                                                 //                                             k2 k6 k10k14

             for(i=0;i<4;i++)            //                                             k3 k7 k11k15

             {                                          // 所以i行j列的下标是4*((round*4)+j)+i即16*round+4*j+i

                    State[i][j]=(unsigned char)((int)State[i][j]^(int)w[4*((round*4)+j)+i]); 

             }

      }

}

1. 字节代换函数

功能描述：字节代换是基于S盒（见附录）的非线性转换，它用于将输入的每一个字节通过一个简单的查表操作，将其映射为别一个字节。映射方法是：把输入的字节高4位作为S盒的行值，低4位作为列值，然后取出对应行和列的元素作为输出。

代码实现：

Aes::SubBytes()                             {

      int i,j;

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

      {

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

             {

                    State[i][j]=AesSbox[State[i][j]];

                    //因为 16*(State[i][j]>>4)+State[i][j]&0x0f=State[i][j]

             }

      }

}

1. 行移位函数

功能描述：实现了行的循环移位操作，变换方法为：第0行不动，第1行循环左移一个字节，第2行循环左移2个字节，第3行循环左移3个字节。

代码实现：

Aes::ShiftRows()

{

      unsigned char temp[4*4];                                        

      int i,j;

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

      {

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

             {

                    temp[4*i+j]=State[i][j];

             }

}

      for(i=1;i<4;i++)

      {

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

             {

                    if(i==1)State[i][j]=temp[4*i+(j+1)%4];                      //第二行左移1位

                    else if(i==2)State[i][j]=temp[4*i+(j+2)%4];               //第三行左移2位

                    else if(i==3)State[i][j]=temp[4*i+(j+3)%4];               //第四行左移3位

             }

      }

}

1. 列混合变换函数

功能描述：列混合变换是一个替代操作，将原矩阵中的每个元素都是一行和一列对应元素的乘积之和。在MixColumns变换中，乘法和加法都是定义在GF()上的。（详细原理请参考经“第二章6.4节”）

实现伪码：

Aes::MixColumns(byte state[4,Nc])

{

begin

byte t[4]

for c=0 step Nc -1

for r=0 step 1 to 3

t[4]=state[r,c]

end for

for r=o step 1 to 3

state[r,c]=Ffmul(0x02,t[r])xor //Ffmul(x,y)返回两个元素x和y的积

Ffmul(0x03,t[(r+1)mod 4]) xor

t[(r+2)mod 4] xor t[(r+3) mod 4]

end for

end for

end

      }

1. 加密函数

功能描述：

1. 对给定的一个明文X，用State初始化为标准格式，并进行AddRoundKey()操作，将轮密钥与State异或。
2. 对前Nr-1轮中的每一轮，用S盒进行一次SubBytes代换操作；对State做一次ShiftRows行移位操作gmf对State做一次MixColumns列混淆操作；然后进行AddRoundKey操作。
3. 依次进行SubBytes,ShiftRows,AddRoundKey操作。
4. 将最后的State中的内容定义为密文。

代码实现：

void Aes::Cipher(unsigned char* input, unsigned char* output)

{

      memset(&State[0][0],0,16);

      for(int i=0;i<4*Nb;i++)   //这里是先写列后写行的，即输入是一列一列的进来的

      {

      State[i%4][i/4]=input[i];    //换成先写行后写列也是可以的，只要在输出时也是这样就可以了

      }

      AddRoundKey(0);                                                            //轮密钥加

     

      for (int round = 1; round <= (Nr - 1); round++)  // main round loop

      {

        SubBytes();                                                              //字节代换

        ShiftRows();                                                     //行移位

        MixColumns();                                                  //列混淆

        AddRoundKey(round);                                           //轮密钥加

      }  // main round loop

     

      SubBytes();                                                                 //字节代换

      ShiftRows();                                                               //行移位

      AddRoundKey(Nr);                                                   //轮密钥加

     

      // output = state

      for (i = 0; i < (4 * Nb); i++)

      {

        output[i] =  State[i % 4][ i / 4];

      }

 

}

1. MFC中主函数的实现

功能描述：实现了将可视界面中的输入的信息关联变量、函数，并调用AES类中的各成员函数进行加密运算，最后再将结果在界面上显示出来。

代码实现：

void CAesCodeDlg::OnBAesEn()

{

      CString   Text;  

    int keysize;

  ((CComboBox*)GetDlgItem(IDC_COMBO1))->GetWindowText(Text);  

//将界面信息关联变量的函数

  if (Text=="128bits") keysize=16;      //选择密钥长度

  else if (Text=="192bits") keysize=24;

  else if (Text=="256bits") keysize=32;

  else MessageBox("请选择密钥长度");

 

unsigned char inBuff[33],ouBuff[33];  

          memset(inBuff,0,33);

      memset(ouBuff,0,33);

unsigned char keykey[35] ;

GetDlgItemText(IDC_key,( char*)keykey,keysize);

 

      Aes aes(keysize,(unsigned char *)keykey);  //声明Aes类对象

 

      GetDlgItemText(IDC_Input,(char*)inBuff,keysize);

      if(strlen((char*)inBuff)>16)MessageBox("本例只能加密16字节的字符串，大于截断");

 

      aes.Cipher(inBuff,ouBuff); //  调用Aes成员函数Cipher进行加密

      CString str="",strTmp;             //实际输出是32个字母或数字,否则ASCII码值超出127的会变成乱码。

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

      {

             strTmp.Format("%02x",ouBuff[i]);   //其实相当于把ouBuff的ASCII值这个数字以16进制的形式输出

             str+=strTmp;

      }

      //MessageBox(str,"加密后");

      SetDlgItemText(IDC_EAesEn,str);

}

加密使用的S盒

static unsigned char AesSbox[16*16]=

{// populate the Sbox matrix

/* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */

/*0*/  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,

/*1*/  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,

/*2*/  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,

/*3*/  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,

/*4*/  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,

/*5*/  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,

/*6*/  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,

/*7*/  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,

/*8*/  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,

/*9*/  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,

/*a*/  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,

/*b*/  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,

/*c*/  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,

/*d*/  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,

/*e*/  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,

/*f*/  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16

};

密钥扩展的实现代码

密钥移位函数

unsigned char* Aes::RotWord(unsigned char* word)

{

      byte* temp = new byte[4];

      temp[0] = word[1];

      temp[1] = word[2];

      temp[2] = word[3];

      temp[3] = word[0];

      return temp;

}

密钥字代换函数

unsigned char* Aes::SubWord(unsigned char* word)

{

      byte* temp = new byte[4];

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

      {

             temp[j] = AesSbox[16*(word[j] >> 4)+(word[j] & 0x0f)];  //实际上也可以写成AesSbox[[j]];因为两者相等

      }

      return temp;

}

列混淆的实现代码

Aes::MixColumns()

{

      unsigned char temp[4*4];

      int i,j;

      for(j=0;j<4;j++)                       //2 3 1 1  列混淆矩阵  Page107

      {                                                                                         //1 2 3 1

             for(i=0;i<4;i++)                                                    //1 1 2 3

             {                                                                                  //3 1 1 2

                    temp[4*i+j]=State[i][j];

             }

      }

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

      {

             State[0][j] = (unsigned char) ( (int)gfmultby02(temp[0+j]) ^ (int)gfmultby03(temp[4*1+j]) ^

                    (int)gfmultby01(temp[4*2+j]) ^ (int)gfmultby01(temp[4*3+j]) );

             State[1][j] = (unsigned char) ( (int)gfmultby01(temp[0+j]) ^ (int)gfmultby02(temp[4*1+j]) ^

                    (int)gfmultby03(temp[4*2+j]) ^ (int)gfmultby01(temp[4*3+j]) );

             State[2][j] = (unsigned char) ( (int)gfmultby01(temp[0+j]) ^ (int)gfmultby01(temp[4*1+j]) ^

                    (int)gfmultby02(temp[4*2+j]) ^ (int)gfmultby03(temp[4*3+j]) );

             State[3][j] = (unsigned char) ( (int)gfmultby03(temp[0+j]) ^ (int)gfmultby01(temp[4*1+j]) ^

                    (int)gfmultby01(temp[4*2+j]) ^ (int)gfmultby02(temp[4*3+j]) );

      }

}

unsigned char Aes::gfmultby01(unsigned char b)

{

      return b;

}

unsigned char Aes::gfmultby02(unsigned char b)

{

      if (b < 0x80)

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

      else

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

}

unsigned char Aes::gfmultby03(unsigned char b)

{

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

}

unsigned char Aes::gfmultby09(unsigned char b)

{

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

}

unsigned char Aes::gfmultby0b(unsigned char b)

{

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

             (int)gfmultby02(b) ^ (int)b );

}

unsigned char Aes::gfmultby0d(unsigned char b)

{

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

             (int)gfmultby02(gfmultby02(b)) ^ (int)(b) );

}

unsigned char Aes::gfmultby0e(unsigned char b)

{

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

             (int)gfmultby02(gfmultby02(b)) ^(int)gfmultby02(b) );

}