3DES和AES加密实现(一)

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

  • DES是安全的。在密码分析的40年后,还没有一个可行的破解方法。如果有人已经破解了它,他们也会保密的:)。不幸的是,56bitkey是固化在算法中的。如果需要增加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加密算法需要的168bitkey,让后将它拆分成356bit的部分,每部分独立进行使用。但是3DES加密算法规范也允许使用3个同样的56bitkey,也允许使用2个不同的56bitkey,然后挑选其中一个来重复使用一次。假设我们需要向后兼容(比如:我们已经有了一个DESkey,并且也打算复用它),但是我们可以假定一个最简单的情况,我们已经有了168bit了,这个也是SSL使用3DES加密算法时候所期望的。
  • 3DES加密算法实现一个最重要的窍门就是,我们不是使用3key加密3次,而是利用一个key加密,然后利用第二个key对它进行解密(这肯定会产生一个随机数据),最后再用第3key进行加密。3DES解密时,和加密相反,使用第3key进行解密,然后利用第2key进行加密,最后使用第1key进行解密。这个过程使得密码破解变得更加困难。注意:上面提到的“使用同样的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算法的官方替代品,并把它重新命名为AESAdvanced Encryption StandardNIST考查了多个加密算法,不仅仅看其安全性,还查看其实现,性能以及潜在的市场价值。
  • DES一样,AES也对其输入做了很多轮的类似于置换或位移操作,每一轮都通过key-schedule来生成一个不同的key,最后对输出做一个非线性s-box转换。同样的,AES也非常依赖于XOR操作,特别是它的反转操作。但是,它操作于更长的keyAESkey可以是128192256bit。假定暴力攻击是最有效的攻击手段,128bitkey3DES加密算法的安全性要差,192bit则相当,256bit安全性就高很多了。

AES Key Schedule

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

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

    }

    • 替换操作:对每个字节都去查找转换表(AESs-box),然后将查找到的值对原有值进行替换。转换表是16*16的,表的行对应原字节的高位部分,列对应原字节的低位部分。比如:原始字节为0x1A,那么行为1,列为100xc5,行为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次迭代)等等。因此,第一个roundconstant0x01000000,如果key长度为128bit,则作用于第4个迭代;如果key长度为192,则作用于第6次迭代;如果可以长度为256bit,则作用于第8次迭代。第二个round constant0x02000000,分别作用于第81216次迭代;第3round constant0x04000000,分别作用于第121824次迭代等等。

    • 对于128bitkey,如果按照上面的round constant生成(左移第一个字节)方案,对于128bitkey,需要做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次迭代之后为8d8d左移一位就是1b(回到1b了),这样可以重复进行了。

    • 这个奇怪的迭代方式,使得我们能够在很短的时间内,简单快速的产生唯一的值。
    • 对于key长度为128bit时,key-schedule的过程大致如下图所示:
    3DES和AES加密实现(一)_第5张图片
    • 对于192bitkeykey-schedule过程也是类似的,就是每6次迭代做一次,而256bitkey则优点不一样,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次(对于128bit256bitkey是如此,对于192bitkey5次),则rcon置为0x1b

    if ( !( i %36) )

    {

    rcon =0x1b;

    }

    //round constant做异或操作

    w[ i][0] ^= rcon;

    //round constant左移1

    rcon <<=1;

    }

    //如果是256bitkey,并且位置是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];

    }


你可能感兴趣的:(安全)