3.2 对称密钥算法详解

对称密钥加密就是使用对称密码编码技术的加密算法，特点是文件加密和解密使用相同的密钥，即加密密钥也就是解密密钥。对称加密算法使用起来简单快捷，密钥较短，而且破解起来也有一定的难度。对称密钥算法的速度非常快，非常适于加密大型的数据流。这些算法可以加密数据，也可以解密数据。对称加密技术数据的两个交换方（即加密方和解密方）必须使用一个保密的私有密钥。

3.2.1 对称密钥算法

对称密钥算法有时又叫传统密码算法，就是解密密钥能够从加密密钥中推算出来，反过来也成立。在大多数对称算法中，加密密钥和解密密钥是相同的，这些算法也叫单密钥算法，它要求发送者和接收者在安全通信之前，商定一个共同的密钥。对称算法的安全性完全依赖于密钥，泄露密钥就意味着任何人都能对消息进行加密解密（密钥必须保密）。

对称算法可分为两类：一类是只对明文中的单个位（有时对字节）运算的算法称为序列算法或序列密码；另一类算法是对明文的一组位进行运算，这些位称为分组，相应的算法称为分组算法或分组密码算法。现代计算机密码算法的典型分组长度为64位，这个长度大到足以防止分析破译，但又小到便于作用。

采用对称密钥算法的常用加密方案有5个组成部分。

① 明文：原始信息。

② 加密算法：以密钥为参数，对明文进行多种置换和转换的规则和步骤，变换结果为密文。

③ 密钥：加密与解密算法的参数，直接影响对明文进行变换的结果。

④ 密文：对明文进行变换的结果。

⑤ 解密算法：加密算法的逆变换，以密文为输入、密钥为参数，变换结果为明文。

对称密码术的优点在于效率高，算法简单，系统开销小，适合加密大量数据。尽管对称密码学有一些很好的特性，但其仍然存在着明显的缺陷，主要表现如下。

· 进行安全通信前，密钥交换的交换必须是在安全的方式下进行。虽然在某种情况下是可行的，但有时却非常困难，甚至无法实现。

· 密钥的规模庞大。举例来说，A与B两人之间的密钥必须不同于A和C两人之间的密钥，否则对B的消息的安全性就会受到威胁。在有1000个用户的团体中，A需要保持至少999个密钥。对于该团体中的其他用户，此种情况同样存在。推而广之，n个用户的团体需要N2/2个不同的密钥。

目前比较著名的对称密钥密码算法有DES、RC4、IDEA、FEAL及AES等，都是常用的对称密钥算法。

3.2.2 对称密钥的加密模式

在现代对称加密算法中，主要有4种加密处理模式，分别如下：电子密码本模式（ECB）、加密块链模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB），这4种加密处理模式一般是针对块加密算法而言的（如DES加密算法）。

1．电子密码本模式

这是一种最古老的加密模式，也是最简单的加密模式，它将加密的数据分成若干组，每组的大小跟加密密钥长度相同，进行加密的密钥也相同。如DES算法，一个64位的密钥，如果采用该模式加密，就是将要加密的数据分成每组64位的数据，如果最后一组不够64位，那么就补齐为64位，然后每组数据都采用DES算法的64位密钥进行加密。每8个字符（64位）作为一块，再使用一个相同的64位密钥对每个块进行加密，最后一块补足64位，补齐后再进行加密。

这种模式存在明显的缺陷，因为ECB方式每64位使用的密钥都是相同的，所以非常容易获得密文进行密码破解。此外，因为每64位是相互独立的，甚至不用破解密码，只要简单地将其中一块替换就可以达到目的。

2．加密块链模式

如下图所示即为加密块链模式加密过程和解密过程。

从这两个图中可以看到，CBC模式的加密也是将明文分成固定长度（64位）的块（P0, P1...）之后，再将前面一个加密块输出的密文与下一个要加密的明文块进行XOR（异或）操作计算，将计算结果用密钥进行加密得到密文。

加密块链模式加密过程

加密块链模式解密过程

在对第一明文块加密时，因为前面没有加密的密文，所以需要一个初始化向量（IV）。跟ECB方式不一样，通过链接关系，使得密文和明文不再是一一对应的关系，增加了破解的难度，而且克服了只要简单调换密文块就可能达到攻击的目的。

该加密模式的最明显缺点是不能实时解密，即必须要等到每8个字节全部接收到之后，才能开始加密，否则不能得到正确的结果。这在要求实时性比较高时就显得不合适了。

3．加密反馈模式

加密反馈模式为了克服必须等待8个字节全部得到才能进行解密的缺点，采用了一个64位（8个字节）的位移寄存器来获得密文，如图所示即为加密反馈模式加密过程和解密过程。

加密反馈模式加密过程

加密反馈模式解密过程

上面两个图中，C2、C3以及P10等都是一个字节（8位）的数据，所以能够实现字符的实时加密和解密，不用再等到8个字节都接收到之后再进行解密。如在进行第10个字节数据的加密和解密过程中，先从移位寄存器取8个字节的数据（C2到C9）用密钥进行加密之后，再取加密数据最左边的一个字节与输入的明文P10进行XOR（异或）操作，将得到的值作为输出密文C10，同时将C10送入到移位寄存器中。

4．输出反馈模式

输出反馈模式OFB跟加密反馈模式CFB大致是一样的，每一个区块的明文与之前区块加密后的密文作异或运算后产生密文。不同之处在于，加密反馈模式区块加密后的密文为独立产生，每一个区块的加密结果不受之前所有区块内容的影响，即使有区块在传输过程中发生错误或丢失，不至于无法完全解密。下图所示即为输出反馈模式的加密过程，下图所示即为输出反馈模式的解密过程。

输出反馈模式加密过程

输出反馈模式解密过程

可以看到，这种输出反馈模式因为没有采用密文作为加密的数据，所以克服了传输过程中由于单个比特导致64个相关比特解密失败的情况，在这种模式下，如果一个比特发生了错误，那么只会影响对应的一个比特，而不会影响别的。但相对于其他模式，因为数据之间相关性小，这种加密模式仍然存在一定的危险性，所以一般不使用OFB加密模式。

5．三重加密

只有56位的密钥长度的DES算法，就目前看来有些简单，而且加密速度快。但是随着计算机技术的快速发展，DES加密算法的密钥长度破解起来并不困难，在还没有找到更加安全的加密算法以前，使用重复加密方式提高DES的密钥长度是必要的解决方法。经过研究发现，DES有效位达到112位就可以增加其安全度，所以说，同时利用三把不同的密钥的三重加密，是比较安全的方法。

使用DES进行三重加密时，其效率只有原来DES的1/3。因此，RSA公司提出了一种DESX，它的结构如下。

DESXk1,k2,k3（M）=K2⊕DES加密k（k1⊕M）

明文M的每一个数据块，在使用密钥k加密前，必须先与密钥k1做一次异或运算，加密之后的结果再与密钥k2做一次异或，经过三个步骤完成DESX运算，才输出相应密文。由此运算可以将DESX的密钥长度扩展为184位。

3.2.3 RC4流密码

RC4加密算法是大名鼎鼎的RSA三人组中的人物Ronald Rivest在1987年设计的密钥长度可变的流加密算法簇。之所以称其为簇，是由于其核心部分的S-box长度可为任意，但一般为256字节。该算法的速度可以达到DES加密的10倍左右，且具有很高级别的非线性。RC4起初是用于保护商业机密的，但是在1994年9月，它的算法被发布在互联网上，也就不再有什么商业机密了。RC4也被叫作ARC4（Alleged RC4，所谓的RC4），因为RSA从来就没有正式发布过这个算法。

RC4算法的原理很简单，包括初始化算法（KSA）和伪随机子密码生成算法（PRGA）两大部分。假设S-box的长度为256，密钥长度为Len。先来看看算法的初始化部分（用C代码表示）。

其中，参数"s"是一个256长度的char型数组，定义为： unsigned char sBox[256];
        参数"key"是密钥，其内容可以随便定义：char key[256];
        参数"Len"是密钥的长度，Len = strlen(key);
        /＊初始化函数＊/
        void rc4_init(unsigned char＊s, unsigned char＊key, unsigned long Len)
        {
            int i=0, j=0;
            char k[256]={0};
            unsigned char tmp=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;
                tmp=s[i];
                s[i]=s[j]; //交换s[i]和s[j]
                s[j]=tmp;
            }
        }

在初始化的过程中，密钥的主要功能是将S-box搅乱，i确保S-box的每个元素都得到处理，j保证S-box的搅乱是随机的。而不同的S-box在经过伪随机子密码生成算法的处理后可以得到不同的子密钥序列，将S-box和明文进行XOR运算，得到密文，解密过程也完全相同。

再来看看算法的加密部分（用C代码表示）。

其中，参数"s"是上边rc4_init函数中，被搅乱的S-box;
        参数"Data"是需要加密的数据data;
        参数"Len"是data的长度．
        /＊加解密＊/
        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 tmp;
            for(k=0; k<Len; k++)
            {
                i=(i+1)%256;
                j=(j+s[i])%256;
                tmp=s[i];
                s[i]=s[j]; //交换s[x]和s[y]
                s[j]=tmp;
                t=(s[i]+s[j])%256;
                Data[k]^=s[t];
            }
        }

最后，在main函数中，调用顺序如下。

int main()
        {
          unsigned char s[256]={0}, s2[256]={0}; //S-box
          char key[256]={"justfortest"};
          char pData[512]="这是一个用来加密的数据Data";
          unsigned long len=strlen(pData);
          int i;
          printf("pData=%s\n", pData);
          printf("key=%s, length=%d\n\n", key, strlen(key));
          rc4_init(s, (unsigned char＊)key, strlen(key)); //已经完成了初始化
          printf("完成对S[i]的初始化，如下：\n\n");
      for(i=0; i<256; i++)
      {
          printf("%02X", s[i]);
          if(i&&(i+1)%16==0)putchar('\n');
      }
      printf("\n\n");
      for(i=0; i<256; i++)//用s2[i]暂时保留经过初始化的s[i]，这一点很重要
      {
          s2[i]=s[i];
      }
      printf("已经初始化，现在加密：\n\n");
      rc4_crypt(s, (unsigned char＊)pData, len); //加密
      printf("pData=%s\n\n", pData);
      printf("已经加密，现在解密：\n\n");
      //rc4_init(s, (unsigned char＊)key, strlen(key)); //初始化密钥
      rc4_crypt(s2, (unsigned char＊)pData, len); //解密
      printf("pData=%s\n\n", pData);
      return0;
    }

因此最终的完整程序如下。

//程序开始
    #include<stdio.h>
    #include<string.h>
    typedef unsigned longULONG;
    /＊初始化函数＊/
    void rc4_init(unsigned char＊s, unsigned char＊key, unsigned long Len)
    {
        int i = 0, j = 0;
        char k[256] = { 0 };
        unsigned char tmp = 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;
            tmp = s[i];
            s[i] = s[j]; //交换s[i]和s[j]
            s[j] = tmp;
        }
    }
    /＊加解密＊/
    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 tmp;
        for (k = 0; k<Len; k++)
        {
            i = (i + 1) % 256;
            j = (j + s[i]) % 256;
            tmp = s[i];
            s[i] = s[j]; //交换s[x]和s[y]
            s[j] = tmp;
            t = (s[i] + s[j]) % 256;
            Data[k] ^= s[t];
        }
    }
    int main()
    {
        unsigned char s[256] = { 0 }, s2[256] = { 0 }; //S-box
        char key[256] = { "justfortest" };
        char pData[512] = "这是一个用来加密的数据Data";
        unsigned long len = strlen(pData);
        int i;
        printf("pData=%s\n", pData);
        printf("key=%s, length=%d\n\n", key, strlen(key));
        rc4_init(s, (unsigned char＊)key, strlen(key)); //已经完成了初始化
        printf("完成对S[i]的初始化，如下：\n\n");
        for (i = 0; i<256; i++)
        {
            printf("%02X", s[i]);
            if (i && (i + 1) % 16 == 0)putchar('\n');
        }
        printf("\n\n");
        for(i = 0; i<256; i++)//用s2[i]暂时保留经过初始化的s[i]，这一点很重要
        {
            s2[i] = s[i];
        }
        printf("已经初始化，现在加密：\n\n");
        rc4_crypt(s, (unsigned char＊)pData, len); //加密
        printf("pData=%s\n\n", pData);
        printf("已经加密，现在解密：\n\n");
        //rc4_init(s, (unsignedchar＊)key, strlen(key)); //初始化密钥
        rc4_crypt(s2, (unsigned char＊)pData, len); //解密
        printf("pData=%s\n\n", pData);
        return 0;
    }
    //程序结束

但是，RC4算法有一定的漏洞，由于RC4算法加密是采用的XOR，所以，一旦子密钥序列出现了重复，密文就有可能被破解。那么，RC4算法生成的子密钥序列是否会出现重复呢？由于存在部分弱密钥，使得子密钥序列在不到100万字节内就发生了完全的重复，如果是部分重复，则可能在不到10万字节内就能发生重复，因此，推荐在使用RC4算法时，必须对加密密钥进行测试，判断其是否为弱密钥。其不足主要体现于，在无线网络中IV（初始化向量）不变性漏洞。

根据目前的分析结果，没有任何的分析对于密钥长度达到128位的RC4有效，所以，RC4是目前最安全的加密算法之一，大家可以放心使用。

3.2.4 TEA算法

在安全学领域，TEA（Tiny Encryption Algorithm）是一种分组加密算法，它的实现非常简单，通常只需要很精短的几行代码。TEA算法最初是由剑桥计算机实验室的David Wheeler和Roger Needham在1994 年设计的。

TEA算法使用64位的明文分组和128位的密钥，它使用Feistel分组加密框架，需要进行64 轮迭代，尽管作者认为32 轮已经足够了。该算法使用了一个神秘常数δ作为倍数，它来源于黄金比率，以保证每一轮加密都不相同。但δ的精确值似乎并不重要，这里TEA把它定义为 δ=「( √5-1)231」（也就是程序中的0×9E3779B9）。

之后TEA算法被发现存在缺陷，作为回应，设计者提出了一个TEA的升级版本——XTEA（有时也称为“tean”）。XTEA跟TEA使用了相同的简单运算，但它采用了截然不同的顺序，为了阻止密钥表攻击，4个子密钥（在加密过程中，原128 位的密钥被拆分为4 个32位的子密钥）采用了一种不太正规的方式进行混合，但速度更慢了。

C语言的Tea算法（原始）如下。

void encrypt(uint32_t＊v, uint32_t＊k) {
            uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /＊setup＊/
            uint32_t delta = 0x9e3779b9; /＊akeyscheduleconstant＊/
            uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /＊cachekey＊/
            for(i=0; i<32; i++) {
                /＊basiccyclestart＊/
                sum += delta;
                v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
                v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
            } /＊endcycle＊/
            v[0] = v0;
            v[1] = v1;
        }
        void decrypt(uint32_t＊v, uint32_t＊k) {
            uint32_t v0 = v[0], v1 = v[1], sum = 0xC6EF3720, i; /＊setup＊/
            uint32_t delta = 0x9e3779b9; /＊akeyscheduleconstant＊/
            uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /＊cachekey＊/
            for(i = 0; i < 32; i++) {
                /＊basiccyclestart＊/
                v1-= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
                v0-= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
                sum -= delta;
            } /＊endcycle＊/
            v[0] = v0;
            v[1] = v1;
        }

3.2.5 数据加密算法

数据加密算法（DES）为密码体制中的对称密码体制，又称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

因为DES算法只有56位的密钥容量，因此，针对其不具备足够安全性的弱点，后来又提出了三重DES或3DES系统，使用了3个不同的密钥对数据块进行2次或3次加密，该方法比进行普通加密的3次要快许多。

在DES算法中，用到了8个S-BOX，列出如下。

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,

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,

在此以S1为例说明其功能，可以看到，在S1中，共有4行数据，命名为0,1,2,3行；每行有16列，命名为0,1,2,3,...,14,15列。

现设输入为：D=D1D2D3D4D5D6

假设：列=D2D3D4D5行=D1D6

然后在S1表中查得对应的数，以4位二进制表示，此即为选择函数S1的输出。

DES加密算法加密的单位是64位，因此在执行DES加密时，必须先将明文分成每64位一个区块段。DES加密算法在解密时和加密时完全相同，解密时输入密钥的位顺序与加密时正好相反。

DES算法具有极高的安全性，到目前为止，除了用穷举搜索法对DES算法进行攻击外，还没有发现更有效的办法。而56位长的密钥的穷举空间为256，这意味着如果一台计算机的速度是每一秒钟检测一百万个密钥，则它搜索完全部密钥就需要将近2285年的时间，可见，这是难以实现的。然而，这并不等于说DES是不可破解的。而实际上，随着硬件技术和Internet的发展，其破解的可能性越来越大，而且，所需要的时间越来越少。使用经过特殊设计的硬件并行处理要几个小时。

3.2.6 高级加密标准算法概述

高级加密标准（Advanced Encryption Standard,AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已经成为对称密钥加密中最流行的算法之一。

Rijndael是由Daemen和Rijmen早期所设计的Square改良而来，而Square则是由SHARK发展而来。

不同于它的前任标准DES,Rijndael使用的是代换——置换网络，而非Feistel架构。AES在软件及硬件上都能快速地加解密，相对来说较易于实作，且只需要很少的存储器。作为一个新的加密标准，目前正被部署应用到更广大的范围。

Rijndael密码的设计力求满足以下3条标准。

· 抵抗所有已知的攻击。

· 在多个平台上速度快，编码紧凑。

· 设计简单。

当前的大多数分组密码，其轮函数是Feistel结构。Rijndael没有这种结构。Rijndael轮函数是由3个不同的可逆均匀变换。

可逆均匀变换

Rijndael (State, ExpandedKey)
        {
          AddRoundKey (State, ExpandedKey);
          for (i=1; i <Nr; i ++)
          Round (State, ExpandedKey+Nb＊ i);
          FinalRound (State, ExpandedKey+Nb＊Nr)
        }
        Round (State, RoundKey)
        {
          ByteSub (State);
          ShiftRow (State);
          MixColumn (State);
          AddRoundKey (State, RoundKey)
        }
        FinalRound (State, RoundKey)
        {
          ByteSub (State);
          ShiftRow (State);
          AddRoundKey (State, RoundKey)
        }

严格地说，AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支持更大范围的区块和密钥长度，AES的区块长度固定为128位，密钥长度则可以是128,192或256位；而Rijndael使用的密钥和区块长度可以是32位的整数倍，以128位为下限，256位为上限。加密过程中使用的密钥是由Rijndael密钥生成方案产生。

大多数AES计算是在一个特别的有限域完成的。

AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“状态（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。Rijndael加密法因支持更大的区块，其矩阵行数可视情况增加。加密时，各轮AES加密循环（除最后一轮外）均包含4个步骤。

① AddRoundKey：矩阵中的每一个字节都与该次轮秘钥（Round Key）做XOR运算；每个子密钥由密钥生成方案产生。

② SubBytes：通过一个非线性的替换函数，用查找表的方式把每个字节替换成对应的字节。

③ ShiftRows：将矩阵中的每个横列进行循环式移位。

④ MixColumns：为了充分混合矩阵中各个直行的操作。这个步骤使用线性转换来混合每列的4个字节。

最后一个加密循环中省略MixColumns步骤，而以另一个AddRoundKey取代。

AES的基本要求是，采用对称分组密码体制，密钥长度的最少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。1998年NIST开始AES第一轮分析、测试和征集，共产生了15个候选算法。1999年3月完成了第二轮AES2的分析、测试。2000年10月2日美国政府正式宣布选中比利时密码学家Joan Daemen和Vincent Rijmen提出的一种密码算法Rijndael作为AES。

在应用方面，尽管DES在安全上是脆弱的，但由于快速DES芯片的大量生产，使得DES仍能暂时继续使用，为提高安全强度，通常使用独立密钥的三级DES。但是DES迟早要被AES代替。流密码体制较之分组密码在理论上成熟且安全，但未被列入下一代加密标准。

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

3.2.7 IDEA加密算法

国际数据加密算法（International Data Encryption Algorithm,IDEA）是由研究员Xuejia Lai和James L. Massey在苏黎世的ETH开发的，一家瑞士公司Ascom Systec拥有其专利权。IDEA是作为迭代的分组密码实现的，使用128位的密钥和8个循环。通过支付专利使用费，可以在全世界广泛使用IDEA。这些费用是在某些区域中适用，而其他区域并不适用。IDEA被认为是极为安全的。使用128位的密钥，蛮力攻击中需要进行的测试次数与DES相比会明显增大，甚至允许对弱密钥测试。而且，它本身也显示了尤其能抵抗专业形式的分析性攻击。

IDEA加密算法简介

IDEA在密码学中属于数据块加密算法（Block Cipher）类。IDEA使用长度为128bit的密钥，数据块大小为64bit。从理论上讲，IDEA属于“强”加密算法，至今还没有出现对该算法的有效攻击算法。

早在1990年，Xuejia Lai等人在EuroCrypt'90年会上提出了分组密码建议PES（Porposed Encryption Standard）。在EuroCrypt'91年会上，Xuejia Lai等人又提出了PES的修正版IPES（Improved PES）。目前IPES已经商品化，并改名为IDEA。IDEA已由瑞士的Ascom公司注册专利，以商业目的使用IDEA算法必须向该公司申请许可。

IDEA是一种由8个相似圈（Round）和一个输出变换（Output Transformation）组成的迭代算法。IDEA的每个圈都由三种函数：模（216+1）乘法、模216加法和按位XOR组成。

在加密之前，IDEA通过密钥扩展将128bit的密钥扩展为52Byte的加密密钥EK（Encryption Key），然后由EK计算出解密密钥DK（Decryption Key）。EK和DK分为8组半密钥，每组长度为6Byte，前8组密钥用于8圈加密，最后半组密钥（4Byte）用于输出变换。IDEA的加密过程和解密过程是一样的，只不过使用不同的密钥（加密时用EK，解密时用DK）。

密钥扩展的过程如下。

① 将128bit的密钥作为EK的前8byte。

② 将前8byte循环左移25bit，得到下一8byte，将这个过程循环7次。

③ 在第7次循环时，取前4byte作为EK的最后4byte。

④ 至此52byte的EK生成完毕。

IDEA算法相对来说是一个比较新的算法，其安全性研究也在不断进行之中。在IDEA算法公布后不久，就有学者指出：IDEA的密钥扩展算法存在缺陷，导致在IDEA算法中存在大量弱密钥类，但这个弱点通过简单的修改密钥扩展算法（加入异或算子）即可克服。在1997年的EuroCrypt'97年会上，John Borst等人提出了对圈数减少的IDEA的两种攻击算法：对3.5圈IDEA的截短差分攻击（Truncate Diffrential Attack）和对3圈IDEA的差分线性攻击（Diffrential Linear Attack）。但作者也同时指出，这两种攻击算法对整8.5圈的IDEA算法不可能取得实质性的攻击效果。目前尚未出现新的攻击算法，一般认为攻击整8.5圈IDEA算法唯一有效的方法是穷尽搜索128bit的密钥空间。

目前IDEA在工程中已有大量应用实例，PGP（Pretty Good Privacy）就使用IDEA作为其分组加密算法；安全套接字层（Secure Socket Layer,SSL）也将IDEA包含在其加密算法库SSLRef中；IDEA算法专利的所有者Ascom公司也推出了一系列基于IDEA算法的安全产品，包括基于IDEA的Exchange安全插件、IDEA加密芯片、IDEA加密软件包等。IDEA算法的应用和研究正在不断走向成熟。