C: AES对称加密算法代码

说明：本文提供基于C代码的 AES 加密、解密代码，并附带测试案例。

简介：AES加密是一种对称加密算法，全称为Advanced Encryption Standard，是美国联邦政府采用的一种区块加密标准。这种算法使用相同的秘钥进行加密和解密，加密和解密的速度非常快，适用于大量数据的加密。

        AES加密使用128位、192位或256位密钥，对数据进行加密。这些密钥长度提供了不同的安全级别和性能特性。AES加密支持多种块大小，最常见的是128位块大小。

        AES加密基于分组加密的工作原理，将明文分成固定大小的块，然后使用相同的密钥和算法对每个块进行加密。每个块独立进行加密，因此加密和解密操作可以并行进行，提高了加密和解密的速度。

        AES加密的算法非常复杂，包括一系列的数学运算，如模加、字节替换、行移位、列混淆等。这些操作使用特定的参数和算法实现，保证了加密的安全性和强度。

        总之，AES加密是一种高效、安全、可靠的对称加密算法，广泛应用于数据存储、传输和保护等领域。

#include 
#include 
#include 

//----------------------------------------------------------------------------------------------------------------------------------------

//                        "0123456789ABCDEF"                  /* 长度参考 */
#define TEST_TINY_AES_IV  "0123456789ABCDEF"                  /* 初始向量IV,定长 */

//                        "0123456789ABCDEF0123456789ABCDEF"  /* 长度参考 */
#define TEST_TINY_AES_KEY "0123456789ABCDEF0123456789ABCDEF"  /* AES key,定长 */

#define AES_DATA_LEN   (16)                                   /* KEY 加密后的数据长度 */
#define AES_DEC_LEN    (16)                                   /* AES 数据解密后长度 */

#define AES_ENCRYPT     1
#define AES_DECRYPT     0



typedef struct
{
    int nr; /*!<  number of rounds  */
    uint32_t *rk; /*!<  AES round keys    */
    uint32_t buf[68]; /*!<  unaligned data    */
} tiny_aes_context;


/* aes.h ---------------------------------------------------------------- */
void tiny_aes_setkey_enc(tiny_aes_context * ctx, uint8_t *key, int keysize);
void tiny_aes_setkey_dec(tiny_aes_context * ctx, uint8_t *key, int keysize);
void tiny_aes_crypt_ecb(tiny_aes_context * ctx,int mode,uint8_t input[16], uint8_t output[16]);
void tiny_aes_crypt_cbc(tiny_aes_context * ctx,int mode,int length,uint8_t iv[16],uint8_t *input, uint8_t *output);
void tiny_aes_crypt_cfb128(tiny_aes_context * ctx,int mode,int length,int *iv_off,uint8_t iv[16],uint8_t *input, uint8_t *output);



/* aes.c ---------------------------------------------------------------- */
//#include 
#define TINY_CRYPT_AES

#if 0
#define AES_ENCRYPT     1
#define AES_DECRYPT     0

typedef struct {
    int nr;         /*!<  number of rounds  */
    uint32_t *rk;  /*!<  AES round keys    */
    uint32_t buf[68];  /*!<  unaligned data    */
} tiny_aes_context;
#endif

#if defined(TINY_CRYPT_AES)

/*
 * 32-bit integer manipulation macros (little endian)
 */
#ifndef GET_ULONG_LE
#define GET_ULONG_LE(n,b,i)                             \
{                                                       \
    (n) = ( (uint32_t) (b)[(i)    ]       )        \
        | ( (uint32_t) (b)[(i) + 1] <<  8 )        \
        | ( (uint32_t) (b)[(i) + 2] << 16 )        \
        | ( (uint32_t) (b)[(i) + 3] << 24 );       \
}
#endif

#ifndef PUT_ULONG_LE
#define PUT_ULONG_LE(n,b,i)                             \
{                                                       \
    (b)[(i)    ] = (uint8_t) ( (n)       );       \
    (b)[(i) + 1] = (uint8_t) ( (n) >>  8 );       \
    (b)[(i) + 2] = (uint8_t) ( (n) >> 16 );       \
    (b)[(i) + 3] = (uint8_t) ( (n) >> 24 );       \
}
#endif

#if defined(TINY_CRYPT_AES_ROM_TABLES)

#else

/*
 * Forward S-box & tables
 */
static uint8_t FSb[256];
static uint32_t FT0[256];
static uint32_t FT1[256];
static uint32_t FT2[256];
static uint32_t FT3[256];

/*
 * Reverse S-box & tables
 */
static uint8_t RSb[256];
static uint32_t RT0[256];
static uint32_t RT1[256];
static uint32_t RT2[256];
static uint32_t RT3[256];

/*
 * Round constants
 */
static uint32_t RCON[10];

/*
 * Tables generation code
 */
#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )

static int aes_init_done = 0;

static void aes_gen_tables(void)
{
    int i, x, y, z;
    int pow[256];
    int log[256];

    /*
     * compute pow and log tables over GF(2^8)
     */
    for (i = 0, x = 1; i < 256; i++) {
        pow[i] = x;
        log[x] = i;
        x = (x ^ XTIME(x)) & 0xFF;
    }

    /*
     * calculate the round constants
     */
    for (i = 0, x = 1; i < 10; i++) {
        RCON[i] = (uint32_t)x;
        x = XTIME(x) & 0xFF;
    }

    /*
     * generate the forward and reverse S-boxes
     */
    FSb[0x00] = 0x63;
    RSb[0x63] = 0x00;

    for (i = 1; i < 256; i++) {
        x = pow[255 - log[i]];

        y = x;
        y = ((y << 1) | (y >> 7)) & 0xFF;
        x ^= y;
        y = ((y << 1) | (y >> 7)) & 0xFF;
        x ^= y;
        y = ((y << 1) | (y >> 7)) & 0xFF;
        x ^= y;
        y = ((y << 1) | (y >> 7)) & 0xFF;
        x ^= y ^ 0x63;

        FSb[i] = (uint8_t)x;
        RSb[x] = (uint8_t)i;
    }

    /*
     * generate the forward and reverse tables
     */
    for (i = 0; i < 256; i++) {
        x = FSb[i];
        y = XTIME(x) & 0xFF;
        z = (y ^ x) & 0xFF;

        FT0[i] = ((uint32_t)y) ^
            ((uint32_t)x << 8) ^
            ((uint32_t)x << 16) ^ ((uint32_t)z << 24);

        FT1[i] = ROTL8(FT0[i]);
        FT2[i] = ROTL8(FT1[i]);
        FT3[i] = ROTL8(FT2[i]);

        x = RSb[i];

        RT0[i] = ((uint32_t)MUL(0x0E, x)) ^
            ((uint32_t)MUL(0x09, x) << 8) ^
            ((uint32_t)MUL(0x0D, x) << 16) ^
            ((uint32_t)MUL(0x0B, x) << 24);

        RT1[i] = ROTL8(RT0[i]);
        RT2[i] = ROTL8(RT1[i]);
        RT3[i] = ROTL8(RT2[i]);
    }
}

#endif

/*
 * AES key schedule (encryption)
 */
void tiny_aes_setkey_enc(tiny_aes_context * ctx, uint8_t *key, int keysize)
{
    int i;
    uint32_t *RK;

#if !defined(TINY_CRYPT_AES_ROM_TABLES)
    if (aes_init_done == 0) {
        aes_gen_tables();
        aes_init_done = 1;
    }
#endif

    switch (keysize) {
    case 128:
        ctx->nr = 10;
        break;
    case 192:
        ctx->nr = 12;
        break;
    case 256:
        ctx->nr = 14;
        break;
    default:
        return;
    }

    ctx->rk = RK = ctx->buf;

    for (i = 0; i < (keysize >> 5); i++) {
        GET_ULONG_LE(RK[i], key, i << 2);
    }

    switch (ctx->nr) {
    case 10:

        for (i = 0; i < 10; i++, RK += 4) {
            RK[4] = RK[0] ^ RCON[i] ^
                ((uint32_t)FSb[(RK[3] >> 8) & 0xFF]) ^
                ((uint32_t)FSb[(RK[3] >> 16) & 0xFF] << 8) ^
                ((uint32_t)FSb[(RK[3] >> 24) & 0xFF] << 16) ^
                ((uint32_t)FSb[(RK[3]) & 0xFF] << 24);

            RK[5] = RK[1] ^ RK[4];
            RK[6] = RK[2] ^ RK[5];
            RK[7] = RK[3] ^ RK[6];
        }
        break;

    case 12:

        for (i = 0; i < 8; i++, RK += 6) {
            RK[6] = RK[0] ^ RCON[i] ^
                ((uint32_t)FSb[(RK[5] >> 8) & 0xFF]) ^
                ((uint32_t)FSb[(RK[5] >> 16) & 0xFF] << 8) ^
                ((uint32_t)FSb[(RK[5] >> 24) & 0xFF] << 16) ^
                ((uint32_t)FSb[(RK[5]) & 0xFF] << 24);

            RK[7] = RK[1] ^ RK[6];
            RK[8] = RK[2] ^ RK[7];
            RK[9] = RK[3] ^ RK[8];
            RK[10] = RK[4] ^ RK[9];
            RK[11] = RK[5] ^ RK[10];
        }
        break;

    case 14:

        for (i = 0; i < 7; i++, RK += 8) {
            RK[8] = RK[0] ^ RCON[i] ^
                ((uint32_t)FSb[(RK[7] >> 8) & 0xFF]) ^
                ((uint32_t)FSb[(RK[7] >> 16) & 0xFF] << 8) ^
                ((uint32_t)FSb[(RK[7] >> 24) & 0xFF] << 16) ^
                ((uint32_t)FSb[(RK[7]) & 0xFF] << 24);

            RK[9] = RK[1] ^ RK[8];
            RK[10] = RK[2] ^ RK[9];
            RK[11] = RK[3] ^ RK[10];

            RK[12] = RK[4] ^
                ((uint32_t)FSb[(RK[11]) & 0xFF]) ^
                ((uint32_t)FSb[(RK[11] >> 8) & 0xFF] << 8) ^
                ((uint32_t)FSb[(RK[11] >> 16) & 0xFF] << 16) ^
                ((uint32_t)FSb[(RK[11] >> 24) & 0xFF] << 24);

            RK[13] = RK[5] ^ RK[12];
            RK[14] = RK[6] ^ RK[13];
            RK[15] = RK[7] ^ RK[14];
        }
        break;

    default:

        break;
    }
}

/*
 * AES key schedule (decryption)
 */
void tiny_aes_setkey_dec(tiny_aes_context * ctx, uint8_t *key, int keysize)
{
    int i, j;
    tiny_aes_context cty;
    uint32_t *RK;
    uint32_t *SK;

    switch (keysize) {
    case 128:
        ctx->nr = 10;
        break;
    case 192:
        ctx->nr = 12;
        break;
    case 256:
        ctx->nr = 14;
        break;
    default:
        return;
    }

    ctx->rk = RK = ctx->buf;

    tiny_aes_setkey_enc(&cty, key, keysize);
    SK = cty.rk + cty.nr * 4;

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    for (i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8) {
        for (j = 0; j < 4; j++, SK++) {
            *RK++ = RT0[FSb[(*SK) & 0xFF]] ^
                RT1[FSb[(*SK >> 8) & 0xFF]] ^
                RT2[FSb[(*SK >> 16) & 0xFF]] ^
                RT3[FSb[(*SK >> 24) & 0xFF]];
        }
    }

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    memset(&cty, 0, sizeof(tiny_aes_context));
}

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

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

/*
 * AES-ECB block encryption/decryption
 */
void tiny_aes_crypt_ecb(tiny_aes_context * ctx,
           int mode, uint8_t input[16], uint8_t output[16])
{
    int i;
    uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;

    RK = ctx->rk;

    GET_ULONG_LE(X0, input, 0);
    X0 ^= *RK++;
    GET_ULONG_LE(X1, input, 4);
    X1 ^= *RK++;
    GET_ULONG_LE(X2, input, 8);
    X2 ^= *RK++;
    GET_ULONG_LE(X3, input, 12);
    X3 ^= *RK++;

    if (mode == AES_DECRYPT) {
        for (i = (ctx->nr >> 1) - 1; i > 0; i--) {
            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);

        X0 = *RK++ ^
            ((uint32_t)RSb[(Y0) & 0xFF]) ^
            ((uint32_t)RSb[(Y3 >> 8) & 0xFF] << 8) ^
            ((uint32_t)RSb[(Y2 >> 16) & 0xFF] << 16) ^
            ((uint32_t)RSb[(Y1 >> 24) & 0xFF] << 24);

        X1 = *RK++ ^
            ((uint32_t)RSb[(Y1) & 0xFF]) ^
            ((uint32_t)RSb[(Y0 >> 8) & 0xFF] << 8) ^
            ((uint32_t)RSb[(Y3 >> 16) & 0xFF] << 16) ^
            ((uint32_t)RSb[(Y2 >> 24) & 0xFF] << 24);

        X2 = *RK++ ^
            ((uint32_t)RSb[(Y2) & 0xFF]) ^
            ((uint32_t)RSb[(Y1 >> 8) & 0xFF] << 8) ^
            ((uint32_t)RSb[(Y0 >> 16) & 0xFF] << 16) ^
            ((uint32_t)RSb[(Y3 >> 24) & 0xFF] << 24);

        X3 = *RK++ ^
            ((uint32_t)RSb[(Y3) & 0xFF]) ^
            ((uint32_t)RSb[(Y2 >> 8) & 0xFF] << 8) ^
            ((uint32_t)RSb[(Y1 >> 16) & 0xFF] << 16) ^
            ((uint32_t)RSb[(Y0 >> 24) & 0xFF] << 24);
    } else {        /* AES_ENCRYPT */
        for (i = (ctx->nr >> 1) - 1; i > 0; i--) {
            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);

        X0 = *RK++ ^
            ((uint32_t)FSb[(Y0) & 0xFF]) ^
            ((uint32_t)FSb[(Y1 >> 8) & 0xFF] << 8) ^
            ((uint32_t)FSb[(Y2 >> 16) & 0xFF] << 16) ^
            ((uint32_t)FSb[(Y3 >> 24) & 0xFF] << 24);

        X1 = *RK++ ^
            ((uint32_t)FSb[(Y1) & 0xFF]) ^
            ((uint32_t)FSb[(Y2 >> 8) & 0xFF] << 8) ^
            ((uint32_t)FSb[(Y3 >> 16) & 0xFF] << 16) ^
            ((uint32_t)FSb[(Y0 >> 24) & 0xFF] << 24);

        X2 = *RK++ ^
            ((uint32_t)FSb[(Y2) & 0xFF]) ^
            ((uint32_t)FSb[(Y3 >> 8) & 0xFF] << 8) ^
            ((uint32_t)FSb[(Y0 >> 16) & 0xFF] << 16) ^
            ((uint32_t)FSb[(Y1 >> 24) & 0xFF] << 24);

        X3 = *RK++ ^
            ((uint32_t)FSb[(Y3) & 0xFF]) ^
            ((uint32_t)FSb[(Y0 >> 8) & 0xFF] << 8) ^
            ((uint32_t)FSb[(Y1 >> 16) & 0xFF] << 16) ^
            ((uint32_t)FSb[(Y2 >> 24) & 0xFF] << 24);
    }

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

/*
 * AES-CBC buffer encryption/decryption
 */
void tiny_aes_crypt_cbc(tiny_aes_context * ctx,
           int mode,
           int length,
           uint8_t iv[16],
           uint8_t *input, uint8_t *output)
{
    int i;
    uint8_t temp[16];

    if (mode == AES_DECRYPT) {
        while (length > 0) {
            memcpy(temp, input, 16);
            tiny_aes_crypt_ecb(ctx, mode, input, output);

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

            memcpy(iv, temp, 16);

            input += 16;
            output += 16;
            length -= 16;
        }
    } else {
        while (length > 0) {
            for (i = 0; i < 16; i++)
                output[i] = (uint8_t)(input[i] ^ iv[i]);

            tiny_aes_crypt_ecb(ctx, mode, output, output);
            memcpy(iv, output, 16);

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

/*
 * AES-CFB128 buffer encryption/decryption
 */
void tiny_aes_crypt_cfb128(tiny_aes_context * ctx,
              int mode,
              int length,
              int *iv_off,
              uint8_t iv[16],
              uint8_t *input, uint8_t *output)
{
    int c, n = *iv_off;

    if (mode == AES_DECRYPT) {
        while (length--) {
            if (n == 0)
                tiny_aes_crypt_ecb(ctx, AES_ENCRYPT, iv, iv);

            c = *input++;
            *output++ = (uint8_t)(c ^ iv[n]);
            iv[n] = (uint8_t)c;

            n = (n + 1) & 0x0F;
        }
    } else {
        while (length--) {
            if (n == 0)
                tiny_aes_crypt_ecb(ctx, AES_ENCRYPT, iv, iv);

            iv[n] = *output++ = (uint8_t)(iv[n] ^ *input++);

            n = (n + 1) & 0x0F;
        }
    }

    *iv_off = n;
}

#endif

/* mode: 0 dec 解密, 1 enc 加密
 * k_check_t *cd   ：输入数据
 * uint8_t *enc_db ：输出数据
 * */
uint8_t key_aes_enc_dec(uint8_t mode,uint8_t *cd,uint8_t *enc_db)
{
    tiny_aes_context ctx;
    uint8_t iv[16 + 1];
    uint8_t private_key[32 + 1];

#if 1
    if ((mode == 1)&&(enc_db != NULL))
    {
        /* encrypt */
        memcpy(iv, TEST_TINY_AES_IV, strlen(TEST_TINY_AES_IV));
        iv[sizeof(iv) - 1] = '\0';
        memcpy(private_key, TEST_TINY_AES_KEY, strlen(TEST_TINY_AES_KEY));
        private_key[sizeof(private_key) - 1] = '\0';

        memset(enc_db, 0x0, sizeof(AES_DATA_LEN));
        tiny_aes_setkey_enc(&ctx, (uint8_t *) private_key, 256);
        tiny_aes_crypt_cbc(&ctx, AES_ENCRYPT, AES_DEC_LEN, iv, (uint8_t *)cd, enc_db);
    }
#endif

    if ((mode == 0)&&(enc_db != NULL))
    {
        /* decrypt */
        memcpy(iv, TEST_TINY_AES_IV, strlen(TEST_TINY_AES_IV));
        iv[sizeof(iv) - 1] = '\0';

        memcpy(private_key, TEST_TINY_AES_KEY, strlen(TEST_TINY_AES_KEY));

        private_key[sizeof(private_key) - 1] = '\0';

        tiny_aes_setkey_dec(&ctx, (uint8_t *) private_key, 256);
        tiny_aes_crypt_cbc(&ctx, AES_DECRYPT, AES_DEC_LEN, iv,(uint8_t *)cd ,(uint8_t *)enc_db);
    }
    return 1;
}

//测试
int main()
{
	uint8_t data[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
	uint8_t output_enc[16]; // 加密数据
	uint8_t output_dec[16]; // 解密数据
	
	key_aes_enc_dec(1,data,output_enc); //加密
	printf("enc：");
    for (uint8_t var = 0; var < 16; ++var)
    {
   		 printf("%02X",output_enc[var]);
    }
	printf("\n");
	
	key_aes_enc_dec(0,output_enc,output_dec); //解密
	printf("dec：");
    for (uint8_t var = 0; var < 16; ++var)
    {
   		 printf("%02X",output_dec[var]);
    }
	printf("\n");
  
    return 0;
}

//计算结果
//enc：7A34715E1C18847155B58997C76E3ECC
//dec：000102030405060708090A0B0C0D0E0F