aes.c

一种基于keygen的加密算法

 * AES block encryption (ECB mode)
 */
void aes_encrypt( aes_context *ctx,
                  unsigned char input[16],
                  unsigned char output[16] )
{
    uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;

    RK = ctx->erk;

    GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
    GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
    GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
    GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];

#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)             \
{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ FT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X1 = RK[1] ^ FT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y0       ) ];           \
                                                        \
    X2 = RK[2] ^ FT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X3 = RK[3] ^ FT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y2       ) ];           \
}

    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );

    if( ctx->nr > 10 )
    {
        AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }

    if( ctx->nr > 12 )
    {
        AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }

    RK += 4;

    X0 = RK[0] ^ ( FSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y3       ) ]       );

    X1 = RK[1] ^ ( FSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y0       ) ]       );

    X2 = RK[2] ^ ( FSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y1       ) ]       );

    X3 = RK[3] ^ ( FSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y2       ) ]       );

    PUT_UINT32_BE( X0, output,  0 );
    PUT_UINT32_BE( X1, output,  4 );
    PUT_UINT32_BE( X2, output,  8 );
    PUT_UINT32_BE( X3, output, 12 );
}

/*
 * AES block decryption (ECB mode)
 */
void aes_decrypt( aes_context *ctx,
                  unsigned char input[16],
                  unsigned char output[16] )
{
    uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;

    RK = ctx->drk;

    GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
    GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
    GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
    GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];

#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)             \
{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ RT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X1 = RK[1] ^ RT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y2       ) ];           \
                                                        \
    X2 = RK[2] ^ RT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X3 = RK[3] ^ RT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y0       ) ];           \
}

    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );

    if( ctx->nr > 10 )
    {
        AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }

    if( ctx->nr > 12 )
    {
        AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }

    RK += 4;

    X0 = RK[0] ^ ( RSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y1       ) ]       );

    X1 = RK[1] ^ ( RSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y2       ) ]       );

    X2 = RK[2] ^ ( RSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y3       ) ]       );

    X3 = RK[3] ^ ( RSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y0       ) ]       );

    PUT_UINT32_BE( X0, output,  0 );
    PUT_UINT32_BE( X1, output,  4 );
    PUT_UINT32_BE( X2, output,  8 );
    PUT_UINT32_BE( X3, output, 12 );
}

/*
 * AES-CBC buffer encryption
 */
void aes_cbc_encrypt( aes_context *ctx,
                      unsigned char iv[16],
                      unsigned char *input,
                      unsigned char *output,
                      int len )
{
    int i;

    while( len > 0 )
    {
        for( i = 0; i < 16; i++ )
            output[i] = input[i] ^ iv[i];

        aes_encrypt( ctx, output, output );
        memcpy( iv, output, 16 );

        input  += 16;
        output += 16;
        len    -= 16;
    }
}

/*
 * AES-CBC buffer decryption
 */
void aes_cbc_decrypt( aes_context *ctx,
                      unsigned char iv[16],
                      unsigned char *input,
                      unsigned char *output,
                      int len )
{
    int i;
    unsigned char temp[16];

    while( len > 0 )
    {
        memcpy( temp, input, 16 );
        aes_decrypt( ctx, input, output );

        for( i = 0; i < 16; i++ )
            output[i] = output[i] ^ iv[i];

        memcpy( iv, temp, 16 );

        input  += 16;
        output += 16;
        len    -= 16;
    }
}

#ifdef SELF_TEST

#include <stdio.h>

/*
 * AES-ECB test vectors (source: NIST, rijndael-vals.zip)
 */
static const uint8 aes_enc_test[3][16] =
{
    { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
      0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
    { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
      0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
    { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
      0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
};
    
static const uint8 aes_dec_test[3][16] =
{
    { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
      0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
    { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
      0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
    { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
      0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
};

/*
 * Checkup routine
 */
int aes_self_test( void )
{
    int i, j, u, v;
    aes_context ctx;
    unsigned char buf[32];

    for( i = 0; i < 6; i++ )
    {
        u = i >> 1;
        v = i & 1;

        printf( "  AES-ECB-%3d (%s): ", 128 + u * 64,
                ( v == 0 ) ? "enc" : "dec" );

        memset( buf, 0, 32 );
        aes_set_key( &ctx, buf, 128 + u * 64 );

        for( j = 0; j < 10000; j++ )
        {
            if( v == 0 ) aes_encrypt( &ctx, buf, buf );
            if( v == 1 ) aes_decrypt( &ctx, buf, buf );
        }

        if( ( v == 0 && memcmp( buf, aes_enc_test[u], 16 ) != 0 ) ||
            ( v == 1 && memcmp( buf, aes_dec_test[u], 16 ) != 0 ) )
        {
            printf( "failed\n" );
            return( 1 );
        }

        printf( "passed\n" );
    }

    printf( "\n" );
    return( 0 );
}
#else
int aes_self_test( void )
{
    return( 0 );
}
#endif