des.cpp

aes和des加密的小程序：可以加密文件

#define WORD2BYTE(n,b,i)                       \
{                                              \
    (b)[(i)    ] = (byte) ( (n) >> 24 );       \
    (b)[(i) + 1] = (byte) ( (n) >> 16 );       \
    (b)[(i) + 2] = (byte) ( (n) >>  8 );       \
    (b)[(i) + 3] = (byte) ( (n)       );       \
}


/*
    说明：下面置换的主要技巧：
    t=((l>>size)^r)&(mask);
    r^=t;
    l^=(t<<size);
    上面的一段代码可以在两个word之间交换数据
    （至于怎么交换，取决于mask的值和size的大小）

    举个例子：
       l =  0  1  2  3   r = 16 17 18 19
            4  5  6  7       20 21 22 23
            8  9 10 11       24 25 26 27
            12 13 14 15      28 29 30 31
    当size=2和mask=0x3333的时候可以将l和r交换为如下的
       t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
             6^20  7^21 -- --        4  5 20 21       6  7 22 23
             10^24 11^25 -- --       8  9 24 25      10 11 26 27
             14^28 15^29 -- --       12 13 28 29      14 15 30 31

    由于初始的IP置换和最后的FP置换是有一定规律的，所以可以由几次上面的变换得到
*/
/* 初始置换宏 */
#define IP(x,y)                                                     \
{                                                                   \
    word tt;                                                        \
    tt = ((x >>  4) ^ y) & 0x0F0F0F0F; y ^= tt; x ^= (tt <<  4);    \
    tt = ((x >> 16) ^ y) & 0x0000FFFF; y ^= tt; x ^= (tt << 16);    \
    tt = ((y >>  2) ^ x) & 0x33333333; x ^= tt; y ^= (tt <<  2);    \
    tt = ((y >>  8) ^ x) & 0x00FF00FF; x ^= tt; y ^= (tt <<  8);    \
    y = ((y << 1) | (y >> 31)) & 0xFFFFFFFF;                        \
    tt = (x ^ y) & 0xAAAAAAAA; y ^= tt; x ^= tt;                    \
    x = ((x << 1) | (x >> 31)) & 0xFFFFFFFF;                        \
}

/* 最后置换宏 */
#define FP(l,r)                                                     \
{                                                                   \
    word tt;                                                        \
    l = ((l << 31) | (l >> 1)) & 0xFFFFFFFF;                        \
    tt = (l ^ r) & 0xAAAAAAAA; l ^= tt; r ^= tt;                    \
    r = ((r << 31) | (r >> 1)) & 0xFFFFFFFF;                        \
    tt = ((r >>  8) ^ l) & 0x00FF00FF; l ^= tt; r ^= (tt <<  8);    \
    tt = ((r >>  2) ^ l) & 0x33333333; l ^= tt; r ^= (tt <<  2);    \
    tt = ((l >> 16) ^ r) & 0x0000FFFF; r ^= tt; l ^= (tt << 16);    \
    tt = ((l >>  4) ^ r) & 0x0F0F0F0F; r ^= tt; l ^= (tt <<  4);    \
}

/* 每一轮的加密的运算 */

#define DES_ROUND(x,y)                          \
{                                               \
    t = *sk++ ^ x;                              \
    y ^= SB8[ (t      ) & 0x3F ] ^              \
         SB6[ (t >>  8) & 0x3F ] ^              \
         SB4[ (t >> 16) & 0x3F ] ^              \
         SB2[ (t >> 24) & 0x3F ];               \
                                                \
    t = *sk++ ^ ((x << 28) | (x >> 4));         \
    y ^= SB7[ (t      ) & 0x3F ] ^              \
         SB5[ (t >>  8) & 0x3F ] ^              \
         SB3[ (t >> 16) & 0x3F ] ^              \
         SB1[ (t >> 24) & 0x3F ];               \
}

/* DES 加密的key扩展部分  */
int DES_enc_keyschedule(byte key[8], word enc_key[32])
{
    int i;
    word x, y, t;

    BYTE2WORD( x, key, 0 );
    BYTE2WORD( y, key, 4 );

    t =  ((y >>  4) ^ x) & 0x0F0F0F0F;  x ^= t; y ^= (t <<  4);
    t =  ((y      ) ^ x) & 0x10101010;  x ^= t; y ^= (t      );

    x =   (LHs[ (x      ) & 0xF] << 3) | (LHs[ (x >>  8) & 0xF ] << 2)
        | (LHs[ (x >> 16) & 0xF] << 1) | (LHs[ (x >> 24) & 0xF ]     )
        | (LHs[ (x >>  5) & 0xF] << 7) | (LHs[ (x >> 13) & 0xF ] << 6)
        | (LHs[ (x >> 21) & 0xF] << 5) | (LHs[ (x >> 29) & 0xF ] << 4);

    y =   (RHs[ (y >>  1) & 0xF] << 3) | (RHs[ (y >>  9) & 0xF ] << 2)
        | (RHs[ (y >> 17) & 0xF] << 1) | (RHs[ (y >> 25) & 0xF ]     )
        | (RHs[ (y >>  4) & 0xF] << 7) | (RHs[ (y >> 12) & 0xF ] << 6)
        | (RHs[ (y >> 20) & 0xF] << 5) | (RHs[ (y >> 28) & 0xF ] << 4);

    x &= 0x0FFFFFFF;
    y &= 0x0FFFFFFF;

    for( i = 0; i < 16; i++ )
    {
        if( i < 2 || i == 8 || i == 15 )
        {
            x = ((x <<  1) | (x >> 27)) & 0x0FFFFFFF;
            y = ((y <<  1) | (y >> 27)) & 0x0FFFFFFF;
        }
        else
        {
            x = ((x <<  2) | (x >> 26)) & 0x0FFFFFFF;
            y = ((y <<  2) | (y >> 26)) & 0x0FFFFFFF;
        }

        *enc_key++ =   ((x <<  4) & 0x24000000) | ((x << 28) & 0x10000000)
                | ((x << 14) & 0x08000000) | ((x << 18) & 0x02080000)
                | ((x <<  6) & 0x01000000) | ((x <<  9) & 0x00200000)
                | ((x >>  1) & 0x00100000) | ((x << 10) & 0x00040000)
                | ((x <<  2) & 0x00020000) | ((x >> 10) & 0x00010000)
                | ((y >> 13) & 0x00002000) | ((y >>  4) & 0x00001000)
                | ((y <<  6) & 0x00000800) | ((y >>  1) & 0x00000400)
                | ((y >> 14) & 0x00000200) | ((y      ) & 0x00000100)
                | ((y >>  5) & 0x00000020) | ((y >> 10) & 0x00000010)
                | ((y >>  3) & 0x00000008) | ((y >> 18) & 0x00000004)
                | ((y >> 26) & 0x00000002) | ((y >> 24) & 0x00000001);

        *enc_key++ =   ((x << 15) & 0x20000000) | ((x << 17) & 0x10000000)
                | ((x << 10) & 0x08000000) | ((x << 22) & 0x04000000)
                | ((x >>  2) & 0x02000000) | ((x <<  1) & 0x01000000)
                | ((x << 16) & 0x00200000) | ((x << 11) & 0x00100000)
                | ((x <<  3) & 0x00080000) | ((x >>  6) & 0x00040000)
                | ((x << 15) & 0x00020000) | ((x >>  4) & 0x00010000)
                | ((y >>  2) & 0x00002000) | ((y <<  8) & 0x00001000)
                | ((y >> 14) & 0x00000808) | ((y >>  9) & 0x00000400)
                | ((y      ) & 0x00000200) | ((y <<  7) & 0x00000100)
                | ((y >>  7) & 0x00000020) | ((y >>  3) & 0x00000011)
                | ((y <<  2) & 0x00000004) | ((y >> 21) & 0x00000002);
    }

    return 0;
}

/* DES 解密的key扩展部分  */
int DES_dec_keyschedule(byte key[8], word dec_key[32])
{
    int i;
    word enc_key[32];

    DES_enc_keyschedule(key, enc_key);

    for( i = 0; i < 32; i += 2 )
    {
        dec_key[i  ] = enc_key[30-i];
        dec_key[i+1] = enc_key[31-i];
    }

    return 0;
}

/*根据扩展的des Key来计算加密(加密和解密的步骤是一样的，只不过是扩展key调用顺序不一样)*/
void des_crypt(word sk[32], byte input[8], byte output[8])
{
    word x, y, t;

    BYTE2WORD( x, input, 0 );
    BYTE2WORD( y, input, 4 );

    IP(x, y );

    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );
    DES_ROUND( y, x );  DES_ROUND( x, y );

    FP(y, x);

    WORD2BYTE( y, output, 0 );
    WORD2BYTE( x, output, 4 );
}

/*DES 的加密函数*/
void DES_encrypt(byte in[8], byte out[8], byte key[8])
{
    word enc_key[32];
    DES_enc_keyschedule(key, enc_key);

    des_crypt(enc_key, in, out);
}

/*DES 的解密函数*/
void DES_decrypt(byte in[8], byte out[8], byte key[8])
{
    word dec_key[32];
    DES_dec_keyschedule(key, dec_key);

    des_crypt(dec_key, in, out);
}