AES128加密算法與實(shí)現(xiàn)2

RobinKQin

/*F*****************************************************************************
* PARAMS:   state       4*4的狀態(tài)表首指針
*
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 列混合操作。事實(shí)上是一種替代操作，用 State 字節(jié)列的值進(jìn)行數(shù)學(xué)域加
*           和域乘的結(jié)果代替每個(gè)字節(jié)。
*           包括S-box變換，行變換，列變換
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     MixColumns 使用特殊的加法和乘法，是基于近代數(shù)學(xué)的域論的有限域GF(28).
*           GF(28)由一組從 0x00 到 0xff 的256個(gè)值組成，加上加法和乘法。 GF代表
*           伽羅瓦域，以發(fā)明這一理論的數(shù)學(xué)家的名字命名。GF(28) 的一個(gè)特性是一個(gè)
*           加法或乘法的操作的結(jié)果必須是在{0x00 ... 0xff}這組數(shù)中。雖然域論是相
*           當(dāng)深?yuàn)W的，但GF(28)加法的最終結(jié)果卻很簡單。GF(28) 加法就是異或（XOR）
*           操作。
*
*       　　GF(28)的乘法有點(diǎn)繁難。AES的加密和解密例程需要知道怎樣只用七個(gè)常量
*           0x01、0x02、0x03、0x09、0x0b、0x0d 和 0x0e 來相乘。只是針對這七種特殊
*           情況進(jìn)行說明。
*
*       　　在GF(28)中用0x01的乘法是特殊的；它相當(dāng)于普通算術(shù)中用1做乘法并且結(jié)果
*           也同樣—任何值乘0x01等于其自身。
*
*       　　用0x02做乘法。和加法的情況相同，理論是深?yuàn)W的，但最終結(jié)果十分簡單。只要
*           被乘的值小于0x80，這時(shí)乘法的結(jié)果就是該值左移1比特位。如果被乘的值大于
*           或等于0x80，這時(shí)乘法的結(jié)果就是左移1比特位再用值0x1b異或。它防止了“域溢
*           出”并保持乘法的乘積在范圍以內(nèi)。
*
*           清楚在GF(28)中用0x02建立了加法和乘法，就可以用任何常量去定義乘法。用
*           0x03做乘法時(shí)，你可以將0x03分解為2的冪之和。為了用0x03乘以任意字節(jié)b， 
*           因?yàn)?0x03 = 0x02 + 0x01，因此： 
*               b * 0x03 = b * (0x02 + 0x01) = (b * 0x02) + (b * 0x01)
*******************************************************************************/
static void MixSubColumns(AES_U8 *state)
{
AES_U8 newstate[4 * Nc];    //用于緩存新的"state"數(shù)組

    // mixing column 0
    newstate[0] = Xtime2Sbox[state[0]] ^ Xtime3Sbox[state[5]] ^ Sbox[state[10]] ^ Sbox[state[15]];
    newstate[1] = Sbox[state[0]] ^ Xtime2Sbox[state[5]] ^ Xtime3Sbox[state[10]] ^ Sbox[state[15]];
    newstate[2] = Sbox[state[0]] ^ Sbox[state[5]] ^ Xtime2Sbox[state[10]] ^ Xtime3Sbox[state[15]];
    newstate[3] = Xtime3Sbox[state[0]] ^ Sbox[state[5]] ^ Sbox[state[10]] ^ Xtime2Sbox[state[15]];

    // mixing column 1
    newstate[4] = Xtime2Sbox[state[4]] ^ Xtime3Sbox[state[9]] ^ Sbox[state[14]] ^ Sbox[state[3]];
    newstate[5] = Sbox[state[4]] ^ Xtime2Sbox[state[9]] ^ Xtime3Sbox[state[14]] ^ Sbox[state[3]];
    newstate[6] = Sbox[state[4]] ^ Sbox[state[9]] ^ Xtime2Sbox[state[14]] ^ Xtime3Sbox[state[3]];
    newstate[7] = Xtime3Sbox[state[4]] ^ Sbox[state[9]] ^ Sbox[state[14]] ^ Xtime2Sbox[state[3]];

    // mixing column 2
    newstate[8] = Xtime2Sbox[state[8]] ^ Xtime3Sbox[state[13]] ^ Sbox[state[2]] ^ Sbox[state[7]];
    newstate[9] = Sbox[state[8]] ^ Xtime2Sbox[state[13]] ^ Xtime3Sbox[state[2]] ^ Sbox[state[7]];
    newstate[10] = Sbox[state[8]] ^ Sbox[state[13]] ^ Xtime2Sbox[state[2]] ^ Xtime3Sbox[state[7]];
    newstate[11] = Xtime3Sbox[state[8]] ^ Sbox[state[13]] ^ Sbox[state[2]] ^ Xtime2Sbox[state[7]];

    // mixing column 3
    newstate[12] = Xtime2Sbox[state[12]] ^ Xtime3Sbox[state[1]] ^ Sbox[state[6]] ^ Sbox[state[11]];
    newstate[13] = Sbox[state[12]] ^ Xtime2Sbox[state[1]] ^ Xtime3Sbox[state[6]] ^ Sbox[state[11]];
    newstate[14] = Sbox[state[12]] ^ Sbox[state[1]] ^ Xtime2Sbox[state[6]] ^ Xtime3Sbox[state[11]];
    newstate[15] = Xtime3Sbox[state[12]] ^ Sbox[state[1]] ^ Sbox[state[6]] ^ Xtime2Sbox[state[11]];

    memcpy (state, newstate, sizeof(newstate));
}

/*F*****************************************************************************
* PARAMS:   state       4*4的狀態(tài)表首指針
*
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 反列混合運(yùn)算
*           包括
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     
*******************************************************************************/
static void InvMixSubColumns(AES_U8 *state)
{
AES_U8 newstate[4 * Nc];   //用于緩存新的"state"數(shù)組
AES_U16 i;                 

    // restore column 0
    newstate[0] = XtimeE[state[0]] ^ XtimeB[state[1]] ^ XtimeD[state[2]] ^ Xtime9[state[3]];
    newstate[5] = Xtime9[state[0]] ^ XtimeE[state[1]] ^ XtimeB[state[2]] ^ XtimeD[state[3]];
    newstate[10] = XtimeD[state[0]] ^ Xtime9[state[1]] ^ XtimeE[state[2]] ^ XtimeB[state[3]];
    newstate[15] = XtimeB[state[0]] ^ XtimeD[state[1]] ^ Xtime9[state[2]] ^ XtimeE[state[3]];

    // restore column 1
    newstate[4] = XtimeE[state[4]] ^ XtimeB[state[5]] ^ XtimeD[state[6]] ^ Xtime9[state[7]];
    newstate[9] = Xtime9[state[4]] ^ XtimeE[state[5]] ^ XtimeB[state[6]] ^ XtimeD[state[7]];
    newstate[14] = XtimeD[state[4]] ^ Xtime9[state[5]] ^ XtimeE[state[6]] ^ XtimeB[state[7]];
    newstate[3] = XtimeB[state[4]] ^ XtimeD[state[5]] ^ Xtime9[state[6]] ^ XtimeE[state[7]];

    // restore column 2
    newstate[8] = XtimeE[state[8]] ^ XtimeB[state[9]] ^ XtimeD[state[10]] ^ Xtime9[state[11]];
    newstate[13] = Xtime9[state[8]] ^ XtimeE[state[9]] ^ XtimeB[state[10]] ^ XtimeD[state[11]];
    newstate[2] = XtimeD[state[8]] ^ Xtime9[state[9]] ^ XtimeE[state[10]] ^ XtimeB[state[11]];
    newstate[7] = XtimeB[state[8]] ^ XtimeD[state[9]] ^ Xtime9[state[10]] ^ XtimeE[state[11]];

    // restore column 3
    newstate[12] = XtimeE[state[12]] ^ XtimeB[state[13]] ^ XtimeD[state[14]] ^ Xtime9[state[15]];
    newstate[1] = Xtime9[state[12]] ^ XtimeE[state[13]] ^ XtimeB[state[14]] ^ XtimeD[state[15]];
    newstate[6] = XtimeD[state[12]] ^ Xtime9[state[13]] ^ XtimeE[state[14]] ^ XtimeB[state[15]];
    newstate[11] = XtimeB[state[12]] ^ XtimeD[state[13]] ^ Xtime9[state[14]] ^ XtimeE[state[15]];

    for (i=0; i<(4 * Nc); i++)
    {
        state[i] = InvSbox[newstate[i]];
    }
}

/*F*****************************************************************************
* PARAMS:   state       4*4的狀態(tài)表首指針
*           key         密鑰表首指針
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 輪密鑰加操作
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     在加密和解密過程中均用到
*******************************************************************************/
static void AddRoundKey(AES_U8 *state, AES_U8 *key)
{
AES_U16 idx;    //索引

    for (idx=0; idx<4; idx++)
    {
        state[idx] ^= key[idx];
    }
}

/*F*****************************************************************************
* PARAMS:   key         密鑰表首指針
*           expKey      擴(kuò)展密鑰表首指針
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 擴(kuò)展密鑰加操作，相當(dāng)于初始化AES算法
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     在加密和解密過程中均用到，每輪擴(kuò)展Nk字節(jié)
*******************************************************************************/
void AES_ExpandKey(AES_U8 *key, AES_U8 *expKey)
{
AES_U8 tmp0, tmp1, tmp2, tmp3, tmp4;
AES_U16 idx;    //索引

    for (idx=0; idx<Nk; idx++) //把數(shù)組key中的每個(gè)元素復(fù)制到數(shù)組expKey相對應(yīng)中的位置，Nk=4
    {
        expKey[4*idx+0] = key[4 * idx + 0];
        expKey[4*idx+1] = key[4 * idx + 1];
        expKey[4*idx+2] = key[4 * idx + 2];
        expKey[4*idx+3] = key[4 * idx + 3];
    }

    for (idx=Nk; idx<(Nc * (Nr + 1)); idx++) //
    {
        tmp0 = expKey[4*idx - 4];
        tmp1 = expKey[4*idx - 3];
        tmp2 = expKey[4*idx - 2];
        tmp3 = expKey[4*idx - 1];
        
        if ( !(idx % Nk) )
        {
            tmp4 = tmp3;
            tmp3 = Sbox[tmp0];
            tmp0 = Sbox[tmp1] ^ Rcon[idx/Nk];
            tmp1 = Sbox[tmp2];
            tmp2 = Sbox[tmp4];
        } //End of if

        //convert from longs to bytes
        expKey[4*idx+0] = expKey[4*idx - 4*Nk + 0] ^ tmp0;
        expKey[4*idx+1] = expKey[4*idx - 4*Nk + 1] ^ tmp1;
        expKey[4*idx+2] = expKey[4*idx - 4*Nk + 2] ^ tmp2;
        expKey[4*idx+3] = expKey[4*idx - 4*Nk + 3] ^ tmp3;
    } //End of for
}

/*F*****************************************************************************
* PARAMS:   in          輸入緩沖區(qū)指針
*           expKey      擴(kuò)展密鑰表首指針
*           out         輸出緩沖區(qū)指針
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 128Bit加密函數(shù)
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     每次僅限于128Bit數(shù)據(jù)塊
*******************************************************************************/
void AES_Encrypt(AES_U8 *in, AES_U8 *expKey, AES_U8 *out)
{
AES_U8 state[Nc * 4]; //state數(shù)組，用于數(shù)據(jù)分組
AES_U16 round;          //加密輪數(shù)計(jì)數(shù)器
AES_U16 idx;            //索引

    //128位數(shù)據(jù)分組，把輸入緩沖區(qū)中的數(shù)據(jù)放到4*4state數(shù)組中
    for (idx=0; idx<Nc; idx++ )
    {
        state[4*idx+0] = *in++;
        state[4*idx+1] = *in++;
        state[4*idx+2] = *in++;
        state[4*idx+3] = *in++;
    }

    //與擴(kuò)展密鑰進(jìn)行“異或”操作
    AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey);

    //Nr輪加密操作
    for (round=1; round<(Nr + 1); round++)
    {
        if (round < Nr)
        {
            MixSubColumns(state);   //包含S-box變換，行變換，列變換
        }
        else
        {
            ShiftRows (state);      //S-box變換，行變換，最后一輪不進(jìn)行列變換
        } //End of if 
        
        //與擴(kuò)展密鑰進(jìn)行“異或”操作
        AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey + round * Nc);
    } //End of for

    //輸出128位加密后的數(shù)據(jù)
    for (idx=0; idx<Nc; idx++)
    {
        *out++ = state[4*idx+0];
        *out++ = state[4*idx+1];
        *out++ = state[4*idx+2];
        *out++ = state[4*idx+3];
    }
}

/*F*****************************************************************************
* PARAMS:   in          輸入緩沖區(qū)指針
*           expKey      擴(kuò)展密鑰表首指針
*           out         輸出緩沖區(qū)指針
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 128Bit解密函數(shù)
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     每次僅限于128Bit數(shù)據(jù)塊
*******************************************************************************/
void AES_Decrypt(AES_U8 *in, AES_U8 *expKey, AES_U8 *out)
{
AES_U8 state[Nc * 4]; //state數(shù)組，用于加密數(shù)據(jù)分組
AES_U16 round;          //加密輪數(shù)計(jì)數(shù)器
AES_U16 idx;            //索引

    //128位加密數(shù)據(jù)分組
    for (idx=0; idx<Nc; idx++)
    {
        state[4*idx+0] = *in++;
        state[4*idx+1] = *in++;
        state[4*idx+2] = *in++;
        state[4*idx+3] = *in++;
    }

    //與擴(kuò)展密鑰進(jìn)行“異或”操作
    AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey + Nr * Nc);
    round = Nr;

    //反S-box變換，反行變換
    InvShiftRows(state);

    while (round--)
    {
        //與擴(kuò)展密鑰進(jìn)行“異或”操作
        AddRoundKey((AES_U8 *)state, (AES_U8 *)expKey + round * Nc);
        
        if (round)
        {
            //反S-box變換，反行變換，反列變換
            InvMixSubColumns (state);
        } //End of if
    } //End of while

    //輸出128位解密數(shù)據(jù)
    for (idx=0; idx<Nc; idx++ )
    {
        *out++ = state[4*idx+0];
        *out++ = state[4*idx+1];
        *out++ = state[4*idx+2];
        *out++ = state[4*idx+3];
    }
}