使用 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];
}
}