ChinaUWBProject.git

#include "aes.h"
 
 
const unsigned char kTable[32] =
{
    0x21, 0x05, 0x04, 0x19, 0x89, 0x12, 0x13, 0x00,
    0x18, 0xDE, 0xCA, 0x01, 0x30, 0x52, 0x01, 0x23,
    0x13, 0x05, 0x33, 0x19, 0x93, 0x07, 0x08, 0x00,
    0x20, 0x5B, 0xA3, 0x4A, 0x21, 0xBA, 0xF9, 0xFC
};
/*
21 05 04 19 89 12 13 00 18 DE CA 01 30 52 01 23 13 05 33 19 93 07 08 00 20 5B A3 4A 21 BA F9 FC
*/
 
unsigned char block1[256]; //!< Workspace 1.
unsigned char block2[256]; //!< Worksapce 2.
unsigned char tempbuf[256];
 
unsigned char *powTbl; //!< Final location of exponentiation lookup table.
unsigned char *logTbl; //!< Final location of logarithm lookup table.
unsigned char *sBox; //!< Final location of s-box.
unsigned char *sBoxInv; //!< Final location of inverse s-box.
unsigned char *expandedKey; //!< Final location of expanded key.
 
void CalcPowLog(unsigned char *powTbl, unsigned char *logTbl)
{
    unsigned char i = 0;
    unsigned char t = 1;
 
    do {
        // Use 0x03 as root for exponentiation and logarithms.
        powTbl[i] = t;
        logTbl[t] = i;
        i++;
 
        // Muliply t by 3 in GF(2^8).
        t ^= (t << 1) ^ (t & 0x80 ? BPOLY : 0);
    } while( t != 1 ); // Cyclic properties ensure that i < 255.
 
    powTbl[255] = powTbl[0]; // 255 = '-0', 254 = -1, etc.
}
 
 
 
void CalcSBox( unsigned char * sBox )
{
    unsigned char i, rot;
    unsigned char temp;
    unsigned char result;
 
    // Fill all entries of sBox[].
    i = 0;
    do {
        //Inverse in GF(2^8).
        if( i > 0 )
        {
            temp = powTbl[ 255 - logTbl[i] ];
        }
        else
        {
            temp = 0;
        }
 
        // Affine transformation in GF(2).
        result = temp ^ 0x63; // Start with adding a vector in GF(2).
        for( rot = 4; rot > 0; rot-- )
        {
            // Rotate left.
            temp = (temp<<1) | (temp>>7);
 
            // Add rotated byte in GF(2).
            result ^= temp;
        }
 
        // Put result in table.
        sBox[i] = result;
    } while( ++i != 0 );
}
 
 
 
void CalcSBoxInv( unsigned char * sBox, unsigned char * sBoxInv )
{
    unsigned char i = 0;
    unsigned char j = 0;
 
    // Iterate through all elements in sBoxInv using  i.
    do {
        // Search through sBox using j.
        do {
            // Check if current j is the inverse of current i.
            if( sBox[ j ] == i )
            {
                // If so, set sBoxInc and indicate search finished.
                sBoxInv[ i ] = j;
                j = 255;
            }
        } while( ++j != 0 );
    } while( ++i != 0 );
}
 
 
 
void CycleLeft( unsigned char * row )
{
    // Cycle 4 bytes in an array left once.
    unsigned char temp = row[0];
 
    row[0] = row[1];
    row[1] = row[2];
    row[2] = row[3];
    row[3] = temp;
}
 
 
void CalcCols(unsigned char *col)
{
    unsigned char i;
 
    for(i = 4; i > 0; i--)
    {
        *col = (*col << 1) ^ (*col & 0x80 ? BPOLY : 0);
        col++;
    }
}
 
void InvMixColumn( unsigned char * column )
{
    unsigned char r[4];
 
    r[0] = column[1] ^ column[2] ^ column[3];
    r[1] = column[0] ^ column[2] ^ column[3];
    r[2] = column[0] ^ column[1] ^ column[3];
    r[3] = column[0] ^ column[1] ^ column[2];
 
    /*column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
    column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
    column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
    column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);*/
    CalcCols(column);
 
    r[0] ^= column[0] ^ column[1];
    r[1] ^= column[1] ^ column[2];
    r[2] ^= column[2] ^ column[3];
    r[3] ^= column[0] ^ column[3];
 
    /*column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
    column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
    column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
    column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);*/
    CalcCols(column);
 
    r[0] ^= column[0] ^ column[2];
    r[1] ^= column[1] ^ column[3];
    r[2] ^= column[0] ^ column[2];
    r[3] ^= column[1] ^ column[3];
 
    /*column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
    column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
    column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
    column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);*/
    CalcCols(column);
 
    column[0] ^= column[1] ^ column[2] ^ column[3];
    r[0] ^= column[0];
    r[1] ^= column[0];
    r[2] ^= column[0];
    r[3] ^= column[0];
 
    column[0] = r[0];
    column[1] = r[1];
    column[2] = r[2];
    column[3] = r[3];
 
    //CopyBytes(column, r, 4);
}
 
 
 
void SubBytes( unsigned char * bytes, unsigned char count )
{
    do {
        *bytes = sBox[ *bytes ]; // Substitute every byte in state.
        bytes++;
    } while( --count );
}
 
 
 
void InvSubBytesAndXOR( unsigned char * bytes, unsigned char * key, unsigned char count )
{
    do {
        // *bytes = sBoxInv[ *bytes ] ^ *key; // Inverse substitute every byte in state and add key.
        *bytes = block2[ *bytes ] ^ *key; // Use block2 directly. Increases speed.
        bytes++;
        key++;
    } while( --count );
}
 
 
void InvShiftRows( unsigned char * state )
{
    unsigned char temp;
 
    // Note: State is arranged column by column.
 
    // Cycle second row right one time.
    temp = state[ 1 + 3*4 ];
    state[ 1 + 3*4 ] = state[ 1 + 2*4 ];
    state[ 1 + 2*4 ] = state[ 1 + 1*4 ];
    state[ 1 + 1*4 ] = state[ 1 + 0*4 ];
    state[ 1 + 0*4 ] = temp;
 
    // Cycle third row right two times.
    temp = state[ 2 + 0*4 ];
    state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
    state[ 2 + 2*4 ] = temp;
    temp = state[ 2 + 1*4 ];
    state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
    state[ 2 + 3*4 ] = temp;
 
    // Cycle fourth row right three times, ie. left once.
    temp = state[ 3 + 0*4 ];
    state[ 3 + 0*4 ] = state[ 3 + 1*4 ];
    state[ 3 + 1*4 ] = state[ 3 + 2*4 ];
    state[ 3 + 2*4 ] = state[ 3 + 3*4 ];
    state[ 3 + 3*4 ] = temp;
}
 
 
/*
void InvMixColumns( unsigned char * state )
{
  InvMixColumn( state + 0*4 );
  InvMixColumn( state + 1*4 );
  InvMixColumn( state + 2*4 );
  InvMixColumn( state + 3*4 );
}
*/
 
 
void XORBytes( unsigned char * bytes1, unsigned char * bytes2, unsigned char count )
{
    do {
        *bytes1 ^= *bytes2; // Add in GF(2), ie. XOR.
        bytes1++;
        bytes2++;
    } while( --count );
}
 
 
 
void CopyBytes( unsigned char * to, unsigned char * from, unsigned char count )
{
    do {
        *to = *from;
        to++;
        from++;
    } while( --count );
}
 
 
 
void KeyExpansion( unsigned char * expandedKey )
{
    unsigned char temp[4];
    unsigned char i;
    unsigned char Rcon[4] = { 0x01, 0x00, 0x00, 0x00 }; // Round constant.
 
    const unsigned char * key = kTable;
 
    // Copy key to start of expanded key.
    i = KEYLENGTH;
    do {
        *expandedKey = *key;
        expandedKey++;
        key++;
    } while( --i );
 
    // Prepare last 4 bytes of key in temp.
    /*expandedKey -= 4;
    temp[0] = *(expandedKey++);
    temp[1] = *(expandedKey++);
    temp[2] = *(expandedKey++);
    temp[3] = *(expandedKey++);*/
    CopyBytes(temp, expandedKey-4, 4);
 
    // Expand key.
    i = KEYLENGTH;
    //j = BLOCKSIZE*(ROUNDS+1) - KEYLENGTH;
    while( i < BLOCKSIZE*(ROUNDS+1) )
    {
        // Are we at the start of a multiple of the key size?
        if( (i % KEYLENGTH) == 0 )
        {
            CycleLeft( temp ); // Cycle left once.
            SubBytes( temp, 4 ); // Substitute each byte.
            XORBytes( temp, Rcon, 4 ); // Add constant in GF(2).
            *Rcon = (*Rcon << 1) ^ (*Rcon & 0x80 ? BPOLY : 0);
        }
 
        // Keysize larger than 24 bytes, ie. larger that 192 bits?
#if KEYLENGTH > 24
        // Are we right past a block size?
        else if( (i % KEYLENGTH) == BLOCKSIZE ) {
            SubBytes( temp, 4 ); // Substitute each byte.
        }
#endif
 
        // Add bytes in GF(2) one KEYLENGTH away.
        XORBytes( temp, expandedKey - KEYLENGTH, 4 );
 
        // Copy result to current 4 bytes.
        *(expandedKey++) = temp[ 0 ];
        *(expandedKey++) = temp[ 1 ];
        *(expandedKey++) = temp[ 2 ];
        *(expandedKey++) = temp[ 3 ];
        //CopyBytes(expandedKey, temp, 4);
        //expandedKey += 4;
 
        i += 4; // Next 4 bytes.
    }
}
 
 
 
void InvCipher( unsigned char * block, unsigned char * expandedKey )
{
    unsigned char i, j;
    unsigned char round = ROUNDS-1;
    expandedKey += BLOCKSIZE * ROUNDS;
 
    XORBytes( block, expandedKey, 16 );
    expandedKey -= BLOCKSIZE;
 
    do {
        InvShiftRows( block );
        InvSubBytesAndXOR( block, expandedKey, 16 );
        expandedKey -= BLOCKSIZE;
        //InvMixColumns( block );
        for(i = 4, j = 0; i > 0; i--, j+=4)
            InvMixColumn( block + j );
    } while( --round );
 
    InvShiftRows( block );
    InvSubBytesAndXOR( block, expandedKey, 16 );
}
 
 
void aesDecInit(void)
{
    powTbl = block1;
    logTbl = block2;
    CalcPowLog( powTbl, logTbl );
 
    sBox = tempbuf;
    CalcSBox( sBox );
 
    expandedKey = block1;
    KeyExpansion( expandedKey );
 
    sBoxInv = block2; // Must be block2.
    CalcSBoxInv( sBox, sBoxInv );
}
 
void aesDecrypt( unsigned char * buffer, unsigned char * chainBlock )
{
    aesDecInit();
    CopyBytes( tempbuf, buffer, BLOCKSIZE );
    InvCipher( buffer, expandedKey );
    XORBytes( buffer, chainBlock, BLOCKSIZE );
    CopyBytes( chainBlock, tempbuf, BLOCKSIZE );
}
 
unsigned char Multiply( unsigned char num, unsigned char factor )
{
    unsigned char mask = 1;
    unsigned char result = 0;
 
    while( mask != 0 )
    {
        // Check bit of factor given by mask.
        if( mask & factor )
        {
            // Add current multiple of num in GF(2).
            result ^= num;
        }
 
        // Shift mask to indicate next bit.
        mask <<= 1;
 
        // Double num.
        num = (num << 1) ^ (num & 0x80 ? BPOLY : 0);
    }
 
    return result;
}
 
 
unsigned char DotProduct( const unsigned char * vector1, unsigned char * vector2 )
{
    unsigned char result = 0 ,i;
 
    //result ^= Multiply( *vector1++, *vector2++ );
    //result ^= Multiply( *vector1++, *vector2++ );
    //result ^= Multiply( *vector1++, *vector2++ );
    //result ^= Multiply( *vector1  , *vector2   );
 
    for(i = 4; i > 0; i--)
        result ^= Multiply( *vector1++, *vector2++ );
 
    return result;
}
 
 
void MixColumn( unsigned char * column )
{
    const unsigned char row[8] = {
        0x02, 0x03, 0x01, 0x01,
        0x02, 0x03, 0x01, 0x01
    }; // Prepare first row of matrix twice, to eliminate need for cycling.
 
    unsigned char result[4];
 
    // Take dot products of each matrix row and the column vector.
    result[0] = DotProduct( row+0, column );
    result[1] = DotProduct( row+3, column );
    result[2] = DotProduct( row+2, column );
    result[3] = DotProduct( row+1, column );
 
    // Copy temporary result to original column.
    //column[0] = result[0];
    //column[1] = result[1];
    //column[2] = result[2];
    //column[3] = result[3];
    CopyBytes(column, result, 4);
}
/*
void MixColumns( unsigned char * state )
{
  MixColumn( state + 0*4 );
  MixColumn( state + 1*4 );
  MixColumn( state + 2*4 );
  MixColumn( state + 3*4 );
}
*/
void ShiftRows( unsigned char * state )
{
    unsigned char temp;
 
    // Note: State is arranged column by column.
 
    // Cycle second row left one time.
    temp = state[ 1 + 0*4 ];
    state[ 1 + 0*4 ] = state[ 1 + 1*4 ];
    state[ 1 + 1*4 ] = state[ 1 + 2*4 ];
    state[ 1 + 2*4 ] = state[ 1 + 3*4 ];
    state[ 1 + 3*4 ] = temp;
 
    // Cycle third row left two times.
    temp = state[ 2 + 0*4 ];
    state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
    state[ 2 + 2*4 ] = temp;
    temp = state[ 2 + 1*4 ];
    state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
    state[ 2 + 3*4 ] = temp;
 
    // Cycle fourth row left three times, ie. right once.
    temp = state[ 3 + 3*4 ];
    state[ 3 + 3*4 ] = state[ 3 + 2*4 ];
    state[ 3 + 2*4 ] = state[ 3 + 1*4 ];
    state[ 3 + 1*4 ] = state[ 3 + 0*4 ];
    state[ 3 + 0*4 ] = temp;
}
 
 
void Cipher( unsigned char * block, unsigned char * expandedKey )
{
    unsigned char i, j;
    unsigned char round = ROUNDS-1;
 
    XORBytes( block, expandedKey, 16 );
    expandedKey += BLOCKSIZE;
 
    do {
        SubBytes( block, 16 );
        ShiftRows( block );
        //MixColumns( block );
        for(i = 4, j = 0; i > 0; i--, j+=4)
            MixColumn( block + j );
        XORBytes( block, expandedKey, 16 );
        expandedKey += BLOCKSIZE;
    } while( --round );
 
    SubBytes( block, 16 );
    ShiftRows( block );
    XORBytes( block, expandedKey, 16 );
}
 
void aesEncInit(void)
{
    powTbl = block1;
    logTbl = block2;
    CalcPowLog( powTbl, logTbl );
 
    sBox = block2;
    CalcSBox( sBox );
 
    expandedKey = block1;
    KeyExpansion( expandedKey );
}
 
void aesEncrypt( unsigned char * buffer, unsigned char * chainBlock )
{
    aesEncInit();
    XORBytes( buffer, chainBlock, BLOCKSIZE );
    Cipher( buffer, expandedKey );
    CopyBytes( chainBlock, buffer, BLOCKSIZE );
}