3DES和AES加密实现(一)

使用 Triple-DES加密算法增加key的长度

• DES是安全的。在密码分析的40年后，还没有一个可行的破解方法。如果有人已经破解了它，他们也会保密的:)。不幸的是，56bit的key是固化在算法中的。如果需要增加key的长度，必须要重新设计算法，因为s-boxes和置换表都是以64bit作为输入。现在，56bit并不多了。2^56可能的key，意味着暴力破解平均需要尝试2^55 (2^56 / 2),或36,028,797,018,963,968次。这并非是不可行的，如果硬件够多，一个DES密码在几天就可以破解出来；虽然这里的硬件投入够大，但是如果数据的价值比这些硬件投入更大，那么我们就得考虑另外一种加密方法了。
• 为了解决这个问题，一种方法是增加key的长度，这里介绍的就是所谓的3DES加密算法，key的长度为：3*56 = 168bit。最显然也是最安全的方式是随机生成3DES加密算法需要的168bit的key，让后将它拆分成3个56bit的部分，每部分独立进行使用。但是3DES加密算法规范也允许使用3个同样的56bit的key，也允许使用2个不同的56bit的key，然后挑选其中一个来重复使用一次。假设我们需要向后兼容（比如：我们已经有了一个DES的key，并且也打算复用它），但是我们可以假定一个最简单的情况，我们已经有了168bit了，这个也是SSL使用3DES加密算法时候所期望的。
• 3DES加密算法实现一个最重要的窍门就是，我们不是使用3个key加密3次，而是利用一个key加密，然后利用第二个key对它进行解密（这肯定会产生一个随机数据），最后再用第3个key进行加密。3DES解密时，和加密相反，使用第3个key进行解密，然后利用第2个key进行加密，最后使用第1个key进行解密。这个过程使得密码破解变得更加困难。注意：上面提到的“使用同样的key3次”是不能起到增加安全作用的。因为使用同样的key进行加密，解密再加密，和用key加密一次的结果是一样的。
• 填充和加密块链没有任何变化。3DES加密算法也是以8字节块为一组进行加密。我们必须关注初始化向量的选取，以确保用同样的key对同一个8字节块加密的结果是不一样的。
• 在 des_operate中增加对3DES加密算法的支持是非常直接的。增加一个标志位triplicate，表示是否进行3DES加密.

static void des_operate( const unsigned char*input,

        int input_len,

        unsignedchar *output,

        constunsigned char *iv,

        constunsigned char *key,

        op_typeoperation,

        inttriplicate)

{

        unsignedchar input_block[ DES_BLOCK_SIZE];

        assert( !(input_len % DES_BLOCK_SIZE));

        

        while(input_len)

        {

                memcpy( (void* ) input_block, ( void*) input, DES_BLOCK_SIZE);

                if(operation== OP_ENCRYPT)

                {

                        xor(input_block, iv,DES_BLOCK_SIZE); // implement CBC

                        des_block_operate( input_block, output, key, operation);

                        if(triplicate)

                        {

                                memcpy(input_block, output,DES_BLOCK_SIZE);

                                des_block_operate(input_block, output, key+DES_KEY_SIZE, OP_DECRYPT );

                                memcpy(input_block, output,DES_BLOCK_SIZE);

                                des_block_operate(input_block, output, key+ (DES_KEY_SIZE* 2),operation);

                        }

                        memcpy( (void* ) iv, (void* ) output,DES_BLOCK_SIZE); // CBC

                }

                

                if(operation== OP_DECRYPT)

                {

                        if(triplicate)

                        {

                                des_block_operate(input_block, output, key+ (DES_KEY_SIZE* 2),operation);

                                memcpy(input_block, output,DES_BLOCK_SIZE);

                                des_block_operate(input_block, output, key+DES_KEY_SIZE, OP_ENCRYPT );

                                memcpy(input_block, output,DES_BLOCK_SIZE);

                                des_block_operate(input_block, output, key,operation);

                        }

                        else

                        {

                                des_block_operate( input_block, output, key, operation);

                        }

                        xor(output, iv,DES_BLOCK_SIZE);

                        memcpy( (void* ) iv, (void* ) input,DES_BLOCK_SIZE); // CBC

                }

                

                input+=DES_BLOCK_SIZE;

                output+= DES_BLOCK_SIZE;

                input_len-= DES_BLOCK_SIZE;

        }

}

 

//加密和解密的入口函数做下修改

void des_encrypt( const unsigned char*plaintext,

…

{

        des_operate( plaintext, plaintext_len, ciphertext, iv, key, OP_ENCRYPT,0);

}

void des3_encrypt( const unsigned char*plaintext,...

{

        des_operate( padded_plaintext,plaintext_len+ padding_len, ciphertext, iv, key, OP_ENCRYPT,1);

}

void des_decrypt( const unsigned char*ciphertext,

...

{

        des_operate( ciphertext, ciphertext_len, plaintext, iv, key, OP_DECRYPT,0);

}

void des3_decrypt( const unsigned char*ciphertext,

...

{

        des_operate( ciphertext, ciphertext_len, plaintext, iv, key, OP_DECRYPT,1);

}

使用AES加快加密速度

• 3DES加密算法是安全的，但是它也大大减慢了加密/解密的速度。为了解决这个问题，在2001年，NIST宣布Rijndael算法将会成为DES算法的官方替代品，并把它重新命名为AES（Advanced Encryption Standard）。NIST考查了多个加密算法，不仅仅看其安全性，还查看其实现，性能以及潜在的市场价值。
• 和DES一样，AES也对其输入做了很多轮的类似于置换或位移操作，每一轮都通过key-schedule来生成一个不同的key，最后对输出做一个非线性s-box转换。同样的，AES也非常依赖于XOR操作，特别是它的反转操作。但是，它操作于更长的key；AES的key可以是128，192或256bit。假定暴力攻击是最有效的攻击手段，128bit的key比3DES加密算法的安全性要差，192bit则相当，256bit安全性就高很多了。

AES Key Schedule

• 不管key的长度是多少，AES只对16字节的块进行操作。但是操作的轮数和key的长度是相关的。如果key为128bit，操作10轮；192bit操作12轮；256bit操作14轮。一般来说，rounds =  (key-size in 4-byte words) + 6。每一轮需要一个16字节的密钥卡片（Keying material）进行工作，因此key-schedule在128bit的key下产生160字节的密钥卡片，192bit为192字节，256bit为224字节（事实上，在最后还会做一次key置换，所以所以AES分别需要176，208和240字节的密钥卡片）。除了轮数之外，key置换是3个算法的唯一区别了。

• 因此，给定一个16字节（128bit）的输入，AES key-schedule需要产生176字节的输出。第一个16字节就是输入本身，剩下的160个字节的生成如下图所示（这里的置换就是简单的XOR操作）.
• 对于192bit的key，key-schedule的计算见下图所示。和128bit基本是类似的。
• • 对于256bit的key进行类推即可。它们需要进行XOR的次数分别为44，52，60（rounds * 4 + 1),(也就是176/4, 208/4, 240/4)。
  • 但是生成key不会这么简单哦；每16个字节的最前面的4个字节，在和之前的4个字节做XOR的时候，会有一个复杂的转换操作。这个操作由2个部分组成：1）先对这4个字节进行轮换 2）然后对所得结果应用于一个置换表（AES的s-box），并和round constant机进行XOR操作。
  
• 轮换（rotation）是非常容易理解的，第一个字节使用第2个字节，第2个字节使用第3个。。。。
  

• static void rot_word(unsigned char *w)

  {

  unsigned char tmp;

  tmp = w[0 ];

  w[0 ] = w[1 ];

  w[1 ] = w[2 ];

  w[2 ] = w[3 ];

  w[3 ] = tmp;

  }

  • 替换操作：对每个字节都去查找转换表（AES的s-box），然后将查找到的值对原有值进行替换。转换表是16*16的，表的行对应原字节的高位部分，列对应原字节的低位部分。比如：原始字节为0x1A，那么行为1，列为10；0xc5，行为12，列为5.
  • 事实上，转换表的值是可以动态进行计算的。但是我们肯定不会进行计算，因为那么做是画蛇添足呀。转换表的内容如下：

  static unsigned char sbox[16 ][16 ]= {

  { 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 },

  };

   

  查找的代码如下：(就是简单地查找上面的表)

  static void sub_word(unsigned char *w)

  {

  int i= 0;

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

  {

  w[ i]= sbox[ ( w[ i ] & 0xF0) >>4 ][ w[ i ]& 0x0F];

  }

  }

   

  最后，将轮换、替换后的值和roundconstant的值做XOR操作。round constant的低3个字节恒为0，高位字节起始位0x1，然后每4个迭代之后，左移1位，也就是变成0x02(第4次迭代）、0x04（第12次迭代）等等。因此，第一个roundconstant为0x01000000，如果key长度为128bit，则作用于第4个迭代；如果key长度为192，则作用于第6次迭代；如果可以长度为256bit，则作用于第8次迭代。第二个round constant为0x02000000,分别作用于第8，12，16次迭代；第3个round constant为0x04000000，分别作用于第12，18，24次迭代等等。

  • 对于128bit的key，如果按照上面的round constant生成（左移第一个字节）方案，对于128bit的key，需要做10次左移操作（因为迭代次数为44）。但是对于一个字节左移10次，会发生溢出（也就是结果始终为0），此时需要将结果和0x1B进行异或操作，而不是0。为什么是0x1B呢？我们看看左移这个操作的前面51个迭代过程：

  01,02,04,08,10,20,40,80,1b,36,6c, d8, ab, 4d,9a,2f,5e, bc,63, c6,97,35,6a,

  d4, b3,7d, fa, ef, c5,91,39,72, e4, d3, bd,61, c2,9f,25,4a,94,33,66, cc,83,1d,

  3a,74, e8, cb, 8d

  如果溢出之后的值为0x1b，那么在51次迭代之后为8d，8d左移一位就是1b（回到1b了），这样可以重复进行了。

  • 这个奇怪的迭代方式，使得我们能够在很短的时间内，简单快速的产生唯一的值。
  • 对于key长度为128bit时，key-schedule的过程大致如下图所示：
  
  • 对于192bit的key，key-schedule过程也是类似的，就是每6次迭代做一次，而256bit的key则优点不一样，sub过程是每4次迭代进行一次，而rotation（轮换）和XOR是每8次迭代进行一次。
  • 上述所有做法带来的结果就是key-schedule过程是非线性的，而不是对输入key的重复、替换。key-schedule的代码如下所示：

  //key_schedule操作，w存放最终的key_schedule结果

  static void compute_key_schedule( const unsigned char*key,

  int key_length,

  unsigned char w[ ][4 ] )

  {

  int i;

  int key_words= key_length>> 2;

  //rcon用来存放round constant

  unsigned char rcon =0x01;

   

  //key_schedule最前面的几个字节就是key本身

  memcpy( w, key,key_length);

  //

  for ( i= key_words;i< 4* (key_words+ 7); i++ )

  {

  //把前面的4个字节拷贝过来

  memcpy( w[ i ], w[ i- 1], 4);

  //如果此时是key_words的整数倍

  if ( !( i % key_words) )

  {

  //做轮换和替换操作（见上面的代码）

  rot_word( w[ i ] );

  sub_word( w[ i ] );

  //如果round constant右移了8次（对于128bit和256bit的key是如此，对于192bit的key是5次），则rcon置为0x1b

  if ( !( i %36) )

  {

  rcon =0x1b;

  }

  //和round constant做异或操作

  w[ i][0] ^= rcon;

  //round constant左移1位

  rcon <<=1;

  }

  //如果是256bit的key，并且位置是4的整数倍，并且不是key_words的整数倍，进行替换操作（见上面的说明）

  else if ( ( key_words> 6) && ( ( i % key_words) == 4) )

  {

  sub_word( w[ i ] );

  }

  //分别和前面key_words个字节求异或

  w[ i][0] ^= w[ i - key_words][ 0];

  w[ i][1] ^= w[ i - key_words][ 1];

  w[ i][2] ^= w[ i - key_words][ 2];

  w[ i][3] ^= w[ i - key_words][ 3];

  }

  }