diff --git a/Makefile b/Makefile index fd5e185..57bb69c 100644 --- a/Makefile +++ b/Makefile @@ -1,11 +1,11 @@ CROSS_COMPILE ?= CC := $(CROSS_COMPILE)gcc STRIP := $(CROSS_COMPILE)strip -CFLAGS += -g -Wall +CFLAGS += -g -Wall -Os LIBS = -static OBJ := sha -all: sha.o +all: aes.o sha.o $(CC) $(CFLAGS) -o $(OBJ) $^ $(LIBS) .c.o: $(CC) $(CFLAGS) -c $< diff --git a/aes.c b/aes.c new file mode 100644 index 0000000..bbdd886 --- /dev/null +++ b/aes.c @@ -0,0 +1,416 @@ +#include + +#include "aes.h" + + +#define Nb 4 + +#if defined(AES256) && (AES256 == 1) +#define Nk 8 +#define Nr 14 +#elif defined(AES192) && (AES192 == 1) +#define Nk 6 +#define Nr 12 +#else +#define Nk 4 // The number of 32 bit words in a key. +#define Nr 10 // The number of rounds in AES Cipher. +#endif + +#ifndef MULTIPLY_AS_A_FUNCTION +#define MULTIPLY_AS_A_FUNCTION 0 +#endif + +typedef uint8_t state_t[4][4]; + +static const uint8_t sbox[256] = { + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 +}; + +#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1) +static const uint8_t rsbox[256] = { + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d +}; +#endif + +static const uint8_t Rcon[11] = { + 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 +}; + +#define getSBoxValue(num) (sbox[(num)]) + +static void KeyExpansion(uint8_t * RoundKey, const uint8_t * Key) +{ + unsigned i, j, k; + uint8_t tempa[4]; // Used for the column/row operations + + for (i = 0; i < Nk; ++i) { + RoundKey[(i * 4) + 0] = Key[(i * 4) + 0]; + RoundKey[(i * 4) + 1] = Key[(i * 4) + 1]; + RoundKey[(i * 4) + 2] = Key[(i * 4) + 2]; + RoundKey[(i * 4) + 3] = Key[(i * 4) + 3]; + } + + for (i = Nk; i < Nb * (Nr + 1); ++i) { + { + k = (i - 1) * 4; + tempa[0] = RoundKey[k + 0]; + tempa[1] = RoundKey[k + 1]; + tempa[2] = RoundKey[k + 2]; + tempa[3] = RoundKey[k + 3]; + + } + + if (i % Nk == 0) { + { + const uint8_t u8tmp = tempa[0]; + tempa[0] = tempa[1]; + tempa[1] = tempa[2]; + tempa[2] = tempa[3]; + tempa[3] = u8tmp; + } + + { + tempa[0] = getSBoxValue(tempa[0]); + tempa[1] = getSBoxValue(tempa[1]); + tempa[2] = getSBoxValue(tempa[2]); + tempa[3] = getSBoxValue(tempa[3]); + } + + tempa[0] = tempa[0] ^ Rcon[i / Nk]; + } +#if defined(AES256) && (AES256 == 1) + if (i % Nk == 4) { + { + tempa[0] = getSBoxValue(tempa[0]); + tempa[1] = getSBoxValue(tempa[1]); + tempa[2] = getSBoxValue(tempa[2]); + tempa[3] = getSBoxValue(tempa[3]); + } + } +#endif + j = i * 4; + k = (i - Nk) * 4; + RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0]; + RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1]; + RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2]; + RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3]; + } +} + +void AES_init_ctx(struct AES_ctx *ctx, const uint8_t * key) +{ + KeyExpansion(ctx->RoundKey, key); +} + +#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1)) +void AES_init_ctx_iv(struct AES_ctx *ctx, const uint8_t * key, const uint8_t * iv) +{ + KeyExpansion(ctx->RoundKey, key); + memcpy(ctx->Iv, iv, AES_BLOCKLEN); +} + +void AES_ctx_set_iv(struct AES_ctx *ctx, const uint8_t * iv) +{ + memcpy(ctx->Iv, iv, AES_BLOCKLEN); +} +#endif + +static void AddRoundKey(uint8_t round, state_t * state, const uint8_t * RoundKey) +{ + uint8_t i, j; + for (i = 0; i < 4; ++i) { + for (j = 0; j < 4; ++j) { + (*state)[i][j] ^= RoundKey[(round * Nb * 4) + (i * Nb) + j]; + } + } +} + +static void SubBytes(state_t * state) +{ + uint8_t i, j; + for (i = 0; i < 4; ++i) { + for (j = 0; j < 4; ++j) { + (*state)[j][i] = getSBoxValue((*state)[j][i]); + } + } +} + +static void ShiftRows(state_t * state) +{ + uint8_t temp; + + temp = (*state)[0][1]; + (*state)[0][1] = (*state)[1][1]; + (*state)[1][1] = (*state)[2][1]; + (*state)[2][1] = (*state)[3][1]; + (*state)[3][1] = temp; + + temp = (*state)[0][2]; + (*state)[0][2] = (*state)[2][2]; + (*state)[2][2] = temp; + + temp = (*state)[1][2]; + (*state)[1][2] = (*state)[3][2]; + (*state)[3][2] = temp; + + temp = (*state)[0][3]; + (*state)[0][3] = (*state)[3][3]; + (*state)[3][3] = (*state)[2][3]; + (*state)[2][3] = (*state)[1][3]; + (*state)[1][3] = temp; +} + +static uint8_t xtime(uint8_t x) +{ + return ((x << 1) ^ (((x >> 7) & 1) * 0x1b)); +} + +static void MixColumns(state_t * state) +{ + uint8_t i; + uint8_t Tmp, Tm, t; + for (i = 0; i < 4; ++i) { + t = (*state)[i][0]; + Tmp = (*state)[i][0] ^ (*state)[i][1] ^ (*state)[i][2] ^ (*state)[i][3]; + Tm = (*state)[i][0] ^ (*state)[i][1]; + Tm = xtime(Tm); + (*state)[i][0] ^= Tm ^ Tmp; + Tm = (*state)[i][1] ^ (*state)[i][2]; + Tm = xtime(Tm); + (*state)[i][1] ^= Tm ^ Tmp; + Tm = (*state)[i][2] ^ (*state)[i][3]; + Tm = xtime(Tm); + (*state)[i][2] ^= Tm ^ Tmp; + Tm = (*state)[i][3] ^ t; + Tm = xtime(Tm); + (*state)[i][3] ^= Tm ^ Tmp; + } +} + +#if MULTIPLY_AS_A_FUNCTION +static uint8_t Multiply(uint8_t x, uint8_t y) +{ + return (((y & 1) * x) ^ ((y >> 1 & 1) * xtime(x)) ^ ((y >> 2 & 1) * xtime(xtime(x))) ^ ((y >> 3 & 1) * xtime(xtime(xtime(x)))) ^ ((y >> 4 & 1) * xtime(xtime(xtime(xtime(x)))))); /* this last call to xtime() can be omitted */ +} +#else +#define Multiply(x, y) \ + ( ((y & 1) * x) ^ \ + ((y>>1 & 1) * xtime(x)) ^ \ + ((y>>2 & 1) * xtime(xtime(x))) ^ \ + ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ \ + ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))) \ + +#endif + +#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1) + +#define getSBoxInvert(num) (rsbox[(num)]) + +static void InvMixColumns(state_t * state) +{ + int i; + uint8_t a, b, c, d; + for (i = 0; i < 4; ++i) { + a = (*state)[i][0]; + b = (*state)[i][1]; + c = (*state)[i][2]; + d = (*state)[i][3]; + + (*state)[i][0] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09); + (*state)[i][1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d); + (*state)[i][2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b); + (*state)[i][3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e); + } +} + +static void InvSubBytes(state_t * state) +{ + uint8_t i, j; + for (i = 0; i < 4; ++i) { + for (j = 0; j < 4; ++j) { + (*state)[j][i] = getSBoxInvert((*state)[j][i]); + } + } +} + +static void InvShiftRows(state_t * state) +{ + uint8_t temp; + + temp = (*state)[3][1]; + (*state)[3][1] = (*state)[2][1]; + (*state)[2][1] = (*state)[1][1]; + (*state)[1][1] = (*state)[0][1]; + (*state)[0][1] = temp; + + temp = (*state)[0][2]; + (*state)[0][2] = (*state)[2][2]; + (*state)[2][2] = temp; + + temp = (*state)[1][2]; + (*state)[1][2] = (*state)[3][2]; + (*state)[3][2] = temp; + + temp = (*state)[0][3]; + (*state)[0][3] = (*state)[1][3]; + (*state)[1][3] = (*state)[2][3]; + (*state)[2][3] = (*state)[3][3]; + (*state)[3][3] = temp; +} +#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1) + +static void Cipher(state_t * state, const uint8_t * RoundKey) +{ + uint8_t round = 0; + + AddRoundKey(0, state, RoundKey); + + for (round = 1;; ++round) { + SubBytes(state); + ShiftRows(state); + if (round == Nr) { + break; + } + MixColumns(state); + AddRoundKey(round, state, RoundKey); + } + AddRoundKey(Nr, state, RoundKey); +} + +#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1) +static void InvCipher(state_t * state, const uint8_t * RoundKey) +{ + uint8_t round = 0; + + AddRoundKey(Nr, state, RoundKey); + + for (round = (Nr - 1);; --round) { + InvShiftRows(state); + InvSubBytes(state); + AddRoundKey(round, state, RoundKey); + if (round == 0) { + break; + } + InvMixColumns(state); + } + +} +#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1) + +#if defined(ECB) && (ECB == 1) + +void AES_ECB_encrypt(const struct AES_ctx *ctx, uint8_t * buf) +{ + Cipher((state_t *) buf, ctx->RoundKey); +} + +void AES_ECB_decrypt(const struct AES_ctx *ctx, uint8_t * buf) +{ + // The next function call decrypts the PlainText with the Key using AES algorithm. + InvCipher((state_t *) buf, ctx->RoundKey); +} + +#endif // #if defined(ECB) && (ECB == 1) + +#if defined(CBC) && (CBC == 1) + +static void XorWithIv(uint8_t * buf, const uint8_t * Iv) +{ + uint8_t i; + for (i = 0; i < AES_BLOCKLEN; ++i) // The block in AES is always 128bit no matter the key size + { + buf[i] ^= Iv[i]; + } +} + +void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length) +{ + size_t i; + uint8_t *Iv = ctx->Iv; + for (i = 0; i < length; i += AES_BLOCKLEN) { + XorWithIv(buf, Iv); + Cipher((state_t *) buf, ctx->RoundKey); + Iv = buf; + buf += AES_BLOCKLEN; + } + /* store Iv in ctx for next call */ + memcpy(ctx->Iv, Iv, AES_BLOCKLEN); +} + +void AES_CBC_decrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length) +{ + size_t i; + uint8_t storeNextIv[AES_BLOCKLEN]; + for (i = 0; i < length; i += AES_BLOCKLEN) { + memcpy(storeNextIv, buf, AES_BLOCKLEN); + InvCipher((state_t *) buf, ctx->RoundKey); + XorWithIv(buf, ctx->Iv); + memcpy(ctx->Iv, storeNextIv, AES_BLOCKLEN); + buf += AES_BLOCKLEN; + } + +} + +#endif // #if defined(CBC) && (CBC == 1) + +#if defined(CTR) && (CTR == 1) + +void AES_CTR_xcrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length) +{ + uint8_t buffer[AES_BLOCKLEN]; + + size_t i; + int bi; + for (i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi) { + if (bi == AES_BLOCKLEN) { /* we need to regen xor compliment in buffer */ + memcpy(buffer, ctx->Iv, AES_BLOCKLEN); + Cipher((state_t *) buffer, ctx->RoundKey); + + /* Increment Iv and handle overflow */ + for (bi = (AES_BLOCKLEN - 1); bi >= 0; --bi) { + /* inc will overflow */ + if (ctx->Iv[bi] == 255) { + ctx->Iv[bi] = 0; + continue; + } + ctx->Iv[bi] += 1; + break; + } + bi = 0; + } + + buf[i] = (buf[i] ^ buffer[bi]); + } +} + +#endif // #if defined(CTR) && (CTR == 1) diff --git a/aes.h b/aes.h new file mode 100644 index 0000000..d905832 --- /dev/null +++ b/aes.h @@ -0,0 +1,67 @@ +#ifndef _AES_H_ +#define _AES_H_ + +#include +#include + +#ifndef CBC +#define CBC 1 +#endif + +#ifndef ECB +#define ECB 1 +#endif + +#ifndef CTR +#define CTR 1 +#endif + +#define AES128 1 +//#define AES192 1 +//#define AES256 1 + +#define AES_BLOCKLEN 16 // Block length in bytes - AES is 128b block only + +#if defined(AES256) && (AES256 == 1) +#define AES_KEYLEN 32 +#define AES_keyExpSize 240 +#elif defined(AES192) && (AES192 == 1) +#define AES_KEYLEN 24 +#define AES_keyExpSize 208 +#else +#define AES_KEYLEN 16 // Key length in bytes +#define AES_keyExpSize 176 +#endif + +struct AES_ctx { + uint8_t RoundKey[AES_keyExpSize]; +#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1)) + uint8_t Iv[AES_BLOCKLEN]; +#endif +}; + +void AES_init_ctx(struct AES_ctx *ctx, const uint8_t * key); +#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1)) +void AES_init_ctx_iv(struct AES_ctx *ctx, const uint8_t * key, const uint8_t * iv); +void AES_ctx_set_iv(struct AES_ctx *ctx, const uint8_t * iv); +#endif + +#if defined(ECB) && (ECB == 1) +void AES_ECB_encrypt(const struct AES_ctx *ctx, uint8_t * buf); +void AES_ECB_decrypt(const struct AES_ctx *ctx, uint8_t * buf); + +#endif // #if defined(ECB) && (ECB == !) + +#if defined(CBC) && (CBC == 1) +void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length); +void AES_CBC_decrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length); + +#endif // #if defined(CBC) && (CBC == 1) + +#if defined(CTR) && (CTR == 1) + +void AES_CTR_xcrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length); + +#endif // #if defined(CTR) && (CTR == 1) + +#endif // _AES_H_ diff --git a/sha.c b/sha.c index c723f46..6d3d007 100644 --- a/sha.c +++ b/sha.c @@ -1,396 +1,35 @@ #include -#include -#include -#include #include +#include +#include +#include #include #include +#include +#include + +#define CBC 1 +#define CTR 1 +#define ECB 1 + +#include "aes.h" #define BUFFER_SIZE 270 -static uint8_t key[] = "aixiao"; + char *buff; long file_size; -static int Nb = 4; -static int Nk = 4; -static int Nr = 10; -bool EncryptDataToCipherTxt(uint8_t * orign, uint8_t * result, uint16_t length); -uint8_t gadd(uint8_t a, uint8_t b) +static void hex2str(uint8_t * input, uint16_t input_len, char *output) { - return a ^ b; -} + char *hexEncode = "0123456789ABCDEF"; + int i = 0, j = 0; -uint8_t gsub(uint8_t a, uint8_t b) -{ - return a ^ b; -} - -uint8_t gmult(uint8_t a, uint8_t b) -{ - uint8_t p = 0, i = 0, hbs = 0; - - for (i = 0; i < 8; i++) { - if (b & 1) { - p ^= a; - } - - hbs = a & 0x80; - a <<= 1; - if (hbs) - a ^= 0x1b; - b >>= 1; + for (i = 0; i < input_len; i++) { + output[j++] = hexEncode[(input[i] >> 4) & 0xf]; + output[j++] = hexEncode[(input[i]) & 0xf]; } - - return (uint8_t) p; -} - -void coef_add(uint8_t a[], uint8_t b[], uint8_t d[]) -{ - d[0] = a[0] ^ b[0]; - d[1] = a[1] ^ b[1]; - d[2] = a[2] ^ b[2]; - d[3] = a[3] ^ b[3]; -} - -void coef_mult(uint8_t * a, uint8_t * b, uint8_t * d) -{ - d[0] = gmult(a[0], b[0]) ^ gmult(a[3], b[1]) ^ gmult(a[2], b[2]) ^ gmult(a[1], b[3]); - d[1] = gmult(a[1], b[0]) ^ gmult(a[0], b[1]) ^ gmult(a[3], b[2]) ^ gmult(a[2], b[3]); - d[2] = gmult(a[2], b[0]) ^ gmult(a[1], b[1]) ^ gmult(a[0], b[2]) ^ gmult(a[3], b[3]); - d[3] = gmult(a[3], b[0]) ^ gmult(a[2], b[1]) ^ gmult(a[1], b[2]) ^ gmult(a[0], b[3]); -} - -static uint8_t s_box[256] = { - 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, - 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, - 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, - 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, - 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, - 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, - 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, - 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, - 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, - 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, - 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, - 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, - 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, - 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, - 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, - 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 -}; - -static uint8_t inv_s_box[256] = { - 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, - 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, - 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, - 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, - 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, - 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, - 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, - 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, - 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, - 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, - 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, - 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, - 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, - 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, - 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, - 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d -}; - -uint8_t R[] = { 0x02, 0x00, 0x00, 0x00 }; - -uint8_t *Rcon(uint8_t i) -{ - if (i == 1) { - R[0] = 0x01; - } else if (i > 1) { - R[0] = 0x02; - i--; - while (i - 1 > 0) { - R[0] = gmult(R[0], 0x02); - i--; - } - } - - return R; -} - -void add_round_key(uint8_t * state, uint8_t * w, uint8_t r) -{ - uint8_t c; - - for (c = 0; c < Nb; c++) { - state[Nb * 0 + c] = state[Nb * 0 + c] ^ w[4 * Nb * r + 4 * c + 0]; - state[Nb * 1 + c] = state[Nb * 1 + c] ^ w[4 * Nb * r + 4 * c + 1]; - state[Nb * 2 + c] = state[Nb * 2 + c] ^ w[4 * Nb * r + 4 * c + 2]; - state[Nb * 3 + c] = state[Nb * 3 + c] ^ w[4 * Nb * r + 4 * c + 3]; - } -} - -void mix_columns(uint8_t * state) -{ - uint8_t a[] = { 0x02, 0x01, 0x01, 0x03 }; - uint8_t i, j, col[4], res[4]; - - for (j = 0; j < Nb; j++) { - for (i = 0; i < 4; i++) { - col[i] = state[Nb * i + j]; - } - - coef_mult(a, col, res); - - for (i = 0; i < 4; i++) { - state[Nb * i + j] = res[i]; - } - } -} - -void inv_mix_columns(uint8_t * state) -{ - uint8_t a[] = { 0x0e, 0x09, 0x0d, 0x0b }; - uint8_t i, j, col[4], res[4]; - - for (j = 0; j < Nb; j++) { - for (i = 0; i < 4; i++) { - col[i] = state[Nb * i + j]; - } - - coef_mult(a, col, res); - - for (i = 0; i < 4; i++) { - state[Nb * i + j] = res[i]; - } - } -} - -void shift_rows(uint8_t * state) -{ - uint8_t i, k, s, tmp; - - for (i = 1; i < 4; i++) { - s = 0; - while (s < i) { - tmp = state[Nb * i + 0]; - - for (k = 1; k < Nb; k++) { - state[Nb * i + k - 1] = state[Nb * i + k]; - } - - state[Nb * i + Nb - 1] = tmp; - s++; - } - } -} - -void inv_shift_rows(uint8_t * state) -{ - uint8_t i, k, s, tmp; - - for (i = 1; i < 4; i++) { - s = 0; - while (s < i) { - tmp = state[Nb * i + Nb - 1]; - - for (k = Nb - 1; k > 0; k--) { - state[Nb * i + k] = state[Nb * i + k - 1]; - } - - state[Nb * i + 0] = tmp; - s++; - } - } -} - -void sub_bytes(uint8_t * state) -{ - uint8_t i, j; - uint8_t row, col; - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - row = (state[Nb * i + j] & 0xf0) >> 4; - col = state[Nb * i + j] & 0x0f; - state[Nb * i + j] = s_box[16 * row + col]; - } - } -} - -void inv_sub_bytes(uint8_t * state) -{ - uint8_t i, j; - uint8_t row, col; - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - row = (state[Nb * i + j] & 0xf0) >> 4; - col = state[Nb * i + j] & 0x0f; - state[Nb * i + j] = inv_s_box[16 * row + col]; - } - } -} - -void sub_word(uint8_t * w) -{ - uint8_t i; - - for (i = 0; i < 4; i++) { - w[i] = s_box[16 * ((w[i] & 0xf0) >> 4) + (w[i] & 0x0f)]; - } -} - -void rot_word(uint8_t * w) -{ - uint8_t tmp; - uint8_t i; - - tmp = w[0]; - - for (i = 0; i < 3; i++) { - w[i] = w[i + 1]; - } - - w[3] = tmp; -} - -void key_expansion(uint8_t * key, uint8_t * w) -{ - uint8_t tmp[4]; - uint8_t i; - uint8_t len = Nb * (Nr + 1); - - for (i = 0; i < Nk; i++) { - w[4 * i + 0] = key[4 * i + 0]; - w[4 * i + 1] = key[4 * i + 1]; - w[4 * i + 2] = key[4 * i + 2]; - w[4 * i + 3] = key[4 * i + 3]; - } - - for (i = Nk; i < len; i++) { - tmp[0] = w[4 * (i - 1) + 0]; - tmp[1] = w[4 * (i - 1) + 1]; - tmp[2] = w[4 * (i - 1) + 2]; - tmp[3] = w[4 * (i - 1) + 3]; - - if (i % Nk == 0) { - - rot_word(tmp); - sub_word(tmp); - coef_add(tmp, Rcon(i / Nk), tmp); - - } else if (Nk > 6 && i % Nk == 4) { - - sub_word(tmp); - - } - - w[4 * i + 0] = w[4 * (i - Nk) + 0] ^ tmp[0]; - w[4 * i + 1] = w[4 * (i - Nk) + 1] ^ tmp[1]; - w[4 * i + 2] = w[4 * (i - Nk) + 2] ^ tmp[2]; - w[4 * i + 3] = w[4 * (i - Nk) + 3] ^ tmp[3]; - } -} - -void cipher(uint8_t * in, uint8_t * out, uint8_t * w) -{ - uint8_t state[4 * Nb]; - uint8_t r, i, j; - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - state[Nb * i + j] = in[i + 4 * j]; - } - } - - add_round_key(state, w, 0); - - for (r = 1; r < Nr; r++) { - sub_bytes(state); - shift_rows(state); - mix_columns(state); - add_round_key(state, w, r); - } - - sub_bytes(state); - shift_rows(state); - add_round_key(state, w, Nr); - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - out[i + 4 * j] = state[Nb * i + j]; - } - } -} - -void inv_cipher(uint8_t * in, uint8_t * out, uint8_t * w) -{ - uint8_t state[4 * Nb]; - uint8_t r, i, j; - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - state[Nb * i + j] = in[i + 4 * j]; - } - } - - add_round_key(state, w, Nr); - - for (r = Nr - 1; r >= 1; r--) { - inv_shift_rows(state); - inv_sub_bytes(state); - add_round_key(state, w, r); - inv_mix_columns(state); - } - - inv_shift_rows(state); - inv_sub_bytes(state); - add_round_key(state, w, 0); - - for (i = 0; i < 4; i++) { - for (j = 0; j < Nb; j++) { - out[i + 4 * j] = state[Nb * i + j]; - } - } -} - -bool EncryptDataToCipherTxt(uint8_t * orign, uint8_t * result, uint16_t length) -{ - uint8_t w[240]; - - switch (sizeof(key)) { - default: - case 16: - Nk = 4; - Nr = 10; - break; - case 24: - Nk = 6; - Nr = 12; - break; - case 32: - Nk = 8; - Nr = 14; - break; - } - - key_expansion(key, w); - - if (length % 16 == 0) { - uint16_t i; - uint16_t counter = length / 16; - uint8_t *p, *q; - - for (i = 0; i < counter; i++) { - p = &orign[16 * i]; - q = &result[16 * i]; - cipher(p, q, w); - } - } else { - return false; - } - return true; } int open_file(char *filename) @@ -418,428 +57,498 @@ int open_file(char *filename) } char *source_c[] = { - "", - "#include ", - "#include ", - "#include ", - "#include ", - "#include ", - "#include ", - "#include ", - "#include ", - "", - "static uint8_t key[] = \"aixiao\";", - "char *buff;", - "long file_size;", - "", +"#include ", +"#include ", +"#include ", +"#include ", +"#include ", +"#include ", +"#include ", +"#define CBC 1", +"#define CTR 1", +"#define ECB 1", - "static int Nb = 4;", - "static int Nk = 4;", - "static int Nr = 10;", - "", - "", - "uint8_t gadd(uint8_t a, uint8_t b)", - "{", - " return a ^ b;", - "}", - "", - "uint8_t gsub(uint8_t a, uint8_t b)", - "{", - " return a ^ b;", - "}", - "", - "uint8_t gmult(uint8_t a, uint8_t b)", - "{", - " uint8_t p = 0, i = 0, hbs = 0;", - "", - " for (i = 0; i < 8; i++) {", - " if (b & 1) {", - " p ^= a;", - " }", - "", - " hbs = a & 0x80;", - " a <<= 1;", - " if (hbs)", - " a ^= 0x1b;", - " b >>= 1;", - " }", - "", - " return (uint8_t) p;", - "}", - "", - "void coef_add(uint8_t a[], uint8_t b[], uint8_t d[])", - "{", - " d[0] = a[0] ^ b[0];", - " d[1] = a[1] ^ b[1];", - " d[2] = a[2] ^ b[2];", - " d[3] = a[3] ^ b[3];", - "}", - "", - "void coef_mult(uint8_t * a, uint8_t * b, uint8_t * d)", - "{", - " d[0] = gmult(a[0], b[0]) ^ gmult(a[3], b[1]) ^ gmult(a[2], b[2]) ^ gmult(a[1], b[3]);", - " d[1] = gmult(a[1], b[0]) ^ gmult(a[0], b[1]) ^ gmult(a[3], b[2]) ^ gmult(a[2], b[3]);", - " d[2] = gmult(a[2], b[0]) ^ gmult(a[1], b[1]) ^ gmult(a[0], b[2]) ^ gmult(a[3], b[3]);", - " d[3] = gmult(a[3], b[0]) ^ gmult(a[2], b[1]) ^ gmult(a[1], b[2]) ^ gmult(a[0], b[3]);", - "}", - "", - "static uint8_t s_box[256] = {", - " 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,", - " 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,", - " 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,", - " 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,", - " 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,", - " 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,", - " 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,", - " 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,", - " 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,", - " 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,", - " 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,", - " 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,", - " 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,", - " 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,", - " 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,", - " 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16", - "};", - "", - "static uint8_t inv_s_box[256] = {", - " 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,", - " 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,", - " 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,", - " 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,", - " 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,", - " 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,", - " 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,", - " 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,", - " 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,", - " 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,", - " 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,", - " 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,", - " 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,", - " 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,", - " 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,", - " 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d", - "};", - "", - "uint8_t R[] = { 0x02, 0x00, 0x00, 0x00 };", - "", - "uint8_t *Rcon(uint8_t i)", - "{", - " if (i == 1) {", - " R[0] = 0x01;", - " } else if (i > 1) {", - " R[0] = 0x02;", - " i--;", - " while (i - 1 > 0) {", - " R[0] = gmult(R[0], 0x02);", - " i--;", - " }", - " }", - "", - " return R;", - "}", - "", - "void add_round_key(uint8_t * state, uint8_t * w, uint8_t r)", - "{", - " uint8_t c;", - "", - " for (c = 0; c < Nb; c++) {", - " state[Nb * 0 + c] = state[Nb * 0 + c] ^ w[4 * Nb * r + 4 * c + 0];", - " state[Nb * 1 + c] = state[Nb * 1 + c] ^ w[4 * Nb * r + 4 * c + 1];", - " state[Nb * 2 + c] = state[Nb * 2 + c] ^ w[4 * Nb * r + 4 * c + 2];", - " state[Nb * 3 + c] = state[Nb * 3 + c] ^ w[4 * Nb * r + 4 * c + 3];", - " }", - "}", - "", - "void mix_columns(uint8_t * state)", - "{", - " uint8_t a[] = { 0x02, 0x01, 0x01, 0x03 };", - " uint8_t i, j, col[4], res[4];", - "", - " for (j = 0; j < Nb; j++) {", - " for (i = 0; i < 4; i++) {", - " col[i] = state[Nb * i + j];", - " }", - "", - " coef_mult(a, col, res);", - "", - " for (i = 0; i < 4; i++) {", - " state[Nb * i + j] = res[i];", - " }", - " }", - "}", - "", - "void inv_mix_columns(uint8_t * state)", - "{", - " uint8_t a[] = { 0x0e, 0x09, 0x0d, 0x0b };", - " uint8_t i, j, col[4], res[4];", - "", - " for (j = 0; j < Nb; j++) {", - " for (i = 0; i < 4; i++) {", - " col[i] = state[Nb * i + j];", - " }", - "", - " coef_mult(a, col, res);", - "", - " for (i = 0; i < 4; i++) {", - " state[Nb * i + j] = res[i];", - " }", - " }", - "}", - "", - "void shift_rows(uint8_t * state)", - "{", - " uint8_t i, k, s, tmp;", - "", - " for (i = 1; i < 4; i++) {", - "", - " s = 0;", - " while (s < i) {", - " tmp = state[Nb * i + 0];", - "", - " for (k = 1; k < Nb; k++) {", - " state[Nb * i + k - 1] = state[Nb * i + k];", - " }", - "", - " state[Nb * i + Nb - 1] = tmp;", - " s++;", - " }", - " }", - "}", - "", - "void inv_shift_rows(uint8_t * state)", - "{", - " uint8_t i, k, s, tmp;", - "", - " for (i = 1; i < 4; i++) {", - " s = 0;", - " while (s < i) {", - " tmp = state[Nb * i + Nb - 1];", - "", - " for (k = Nb - 1; k > 0; k--) {", - " state[Nb * i + k] = state[Nb * i + k - 1];", - " }", - "", - " state[Nb * i + 0] = tmp;", - " s++;", - " }", - " }", - "}", - "", - "void sub_bytes(uint8_t * state)", - "{", - " uint8_t i, j;", - " uint8_t row, col;", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " row = (state[Nb * i + j] & 0xf0) >> 4;", - " col = state[Nb * i + j] & 0x0f;", - " state[Nb * i + j] = s_box[16 * row + col];", - " }", - " }", - "}", - "", - "void inv_sub_bytes(uint8_t * state)", - "{", - " uint8_t i, j;", - " uint8_t row, col;", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " row = (state[Nb * i + j] & 0xf0) >> 4;", - " col = state[Nb * i + j] & 0x0f;", - " state[Nb * i + j] = inv_s_box[16 * row + col];", - " }", - " }", - "}", - "", - "void sub_word(uint8_t * w)", - "{", - " uint8_t i;", +"#ifndef _AES_H_", +"#define _AES_H_", +"", +"#include ", +"#include ", +"", +"#ifndef CBC", +"#define CBC 1", +"#endif", +"", +"#ifndef ECB", +"#define ECB 1", +"#endif", +"", +"#ifndef CTR", +"#define CTR 1", +"#endif", +"", +"#define AES128 1", +"//#define AES192 1", +"//#define AES256 1", +"", +"#define AES_BLOCKLEN 16 // Block length in bytes - AES is 128b block only", +"", +"#if defined(AES256) && (AES256 == 1)", +"#define AES_KEYLEN 32", +"#define AES_keyExpSize 240", +"#elif defined(AES192) && (AES192 == 1)", +"#define AES_KEYLEN 24", +"#define AES_keyExpSize 208", +"#else", +"#define AES_KEYLEN 16 // Key length in bytes", +"#define AES_keyExpSize 176", +"#endif", +"", +"struct AES_ctx {", +" uint8_t RoundKey[AES_keyExpSize];", +"#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))", +" uint8_t Iv[AES_BLOCKLEN];", +"#endif", +"};", +"", +"void AES_init_ctx(struct AES_ctx *ctx, const uint8_t * key);", +"#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))", +"void AES_init_ctx_iv(struct AES_ctx *ctx, const uint8_t * key, const uint8_t * iv);", +"void AES_ctx_set_iv(struct AES_ctx *ctx, const uint8_t * iv);", +"#endif", +"", +"#if defined(ECB) && (ECB == 1)", +"void AES_ECB_encrypt(const struct AES_ctx *ctx, uint8_t * buf);", +"void AES_ECB_decrypt(const struct AES_ctx *ctx, uint8_t * buf);", +"", +"#endif // #if defined(ECB) && (ECB == !)", +"", +"#if defined(CBC) && (CBC == 1)", +"void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length);", +"void AES_CBC_decrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length);", +"", +"#endif // #if defined(CBC) && (CBC == 1)", +"", +"#if defined(CTR) && (CTR == 1)", +"", +"void AES_CTR_xcrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length);", +"", +"#endif // #if defined(CTR) && (CTR == 1)", +"", +"#endif // _AES_H_", +"", +"", +"#define Nb 4", +"", +"#if defined(AES256) && (AES256 == 1)", +"#define Nk 8", +"#define Nr 14", +"#elif defined(AES192) && (AES192 == 1)", +"#define Nk 6", +"#define Nr 12", +"#else", +"#define Nk 4 // The number of 32 bit words in a key.", +"#define Nr 10 // The number of rounds in AES Cipher.", +"#endif", +"", +"#ifndef MULTIPLY_AS_A_FUNCTION", +"#define MULTIPLY_AS_A_FUNCTION 0", +"#endif", +"", +"typedef uint8_t state_t[4][4];", +"", +"static const uint8_t sbox[256] = {", +" 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,", +" 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,", +" 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,", +" 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,", +" 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,", +" 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,", +" 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,", +" 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,", +" 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,", +" 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,", +" 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,", +" 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,", +" 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,", +" 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,", +" 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,", +" 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16", +"};", +"", +"#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)", +"static const uint8_t rsbox[256] = {", +" 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,", +" 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,", +" 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,", +" 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,", +" 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,", +" 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,", +" 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,", +" 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,", +" 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,", +" 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,", +" 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,", +" 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,", +" 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,", +" 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,", +" 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,", +" 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d", +"};", +"#endif", +"", +"static const uint8_t Rcon[11] = {", +" 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36", +"};", +"", +"#define getSBoxValue(num) (sbox[(num)])", +"", +"static void KeyExpansion(uint8_t * RoundKey, const uint8_t * Key)", +"{", +" unsigned i, j, k;", +" uint8_t tempa[4]; // Used for the column/row operations", +"", +" for (i = 0; i < Nk; ++i) {", +" RoundKey[(i * 4) + 0] = Key[(i * 4) + 0];", +" RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];", +" RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];", +" RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];", +" }", +"", +" for (i = Nk; i < Nb * (Nr + 1); ++i) {", +" {", +" k = (i - 1) * 4;", +" tempa[0] = RoundKey[k + 0];", +" tempa[1] = RoundKey[k + 1];", +" tempa[2] = RoundKey[k + 2];", +" tempa[3] = RoundKey[k + 3];", +"", +" }", +"", +" if (i % Nk == 0) {", +" {", +" const uint8_t u8tmp = tempa[0];", +" tempa[0] = tempa[1];", +" tempa[1] = tempa[2];", +" tempa[2] = tempa[3];", +" tempa[3] = u8tmp;", +" }", +"", +" {", +" tempa[0] = getSBoxValue(tempa[0]);", +" tempa[1] = getSBoxValue(tempa[1]);", +" tempa[2] = getSBoxValue(tempa[2]);", +" tempa[3] = getSBoxValue(tempa[3]);", +" }", +"", +" tempa[0] = tempa[0] ^ Rcon[i / Nk];", +" }", +"#if defined(AES256) && (AES256 == 1)", +" if (i % Nk == 4) {", +" {", +" tempa[0] = getSBoxValue(tempa[0]);", +" tempa[1] = getSBoxValue(tempa[1]);", +" tempa[2] = getSBoxValue(tempa[2]);", +" tempa[3] = getSBoxValue(tempa[3]);", +" }", +" }", +"#endif", +" j = i * 4;", +" k = (i - Nk) * 4;", +" RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0];", +" RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1];", +" RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2];", +" RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3];", +" }", +"}", +"", +"void AES_init_ctx(struct AES_ctx *ctx, const uint8_t * key)", +"{", +" KeyExpansion(ctx->RoundKey, key);", +"}", +"", +"#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))", +"void AES_init_ctx_iv(struct AES_ctx *ctx, const uint8_t * key, const uint8_t * iv)", +"{", +" KeyExpansion(ctx->RoundKey, key);", +" memcpy(ctx->Iv, iv, AES_BLOCKLEN);", +"}", +"", +"void AES_ctx_set_iv(struct AES_ctx *ctx, const uint8_t * iv)", +"{", +" memcpy(ctx->Iv, iv, AES_BLOCKLEN);", +"}", +"#endif", +"", +"static void AddRoundKey(uint8_t round, state_t * state, const uint8_t * RoundKey)", +"{", +" uint8_t i, j;", +" for (i = 0; i < 4; ++i) {", +" for (j = 0; j < 4; ++j) {", +" (*state)[i][j] ^= RoundKey[(round * Nb * 4) + (i * Nb) + j];", +" }", +" }", +"}", +"", +"static void SubBytes(state_t * state)", +"{", +" uint8_t i, j;", +" for (i = 0; i < 4; ++i) {", +" for (j = 0; j < 4; ++j) {", +" (*state)[j][i] = getSBoxValue((*state)[j][i]);", +" }", +" }", +"}", +"", +"static void ShiftRows(state_t * state)", +"{", +" uint8_t temp;", +"", +" temp = (*state)[0][1];", +" (*state)[0][1] = (*state)[1][1];", +" (*state)[1][1] = (*state)[2][1];", +" (*state)[2][1] = (*state)[3][1];", +" (*state)[3][1] = temp;", +" ", +" temp = (*state)[0][2];", +" (*state)[0][2] = (*state)[2][2];", +" (*state)[2][2] = temp;", +"", +" temp = (*state)[1][2];", +" (*state)[1][2] = (*state)[3][2];", +" (*state)[3][2] = temp;", +"", +" temp = (*state)[0][3];", +" (*state)[0][3] = (*state)[3][3];", +" (*state)[3][3] = (*state)[2][3];", +" (*state)[2][3] = (*state)[1][3];", +" (*state)[1][3] = temp;", +"}", +"", +"static uint8_t xtime(uint8_t x)", +"{", +" return ((x << 1) ^ (((x >> 7) & 1) * 0x1b));", +"}", +"", +"static void MixColumns(state_t * state)", +"{", +" uint8_t i;", +" uint8_t Tmp, Tm, t;", +" for (i = 0; i < 4; ++i) {", +" t = (*state)[i][0];", +" Tmp = (*state)[i][0] ^ (*state)[i][1] ^ (*state)[i][2] ^ (*state)[i][3];", +" Tm = (*state)[i][0] ^ (*state)[i][1];", +" Tm = xtime(Tm);", +" (*state)[i][0] ^= Tm ^ Tmp;", +" Tm = (*state)[i][1] ^ (*state)[i][2];", +" Tm = xtime(Tm);", +" (*state)[i][1] ^= Tm ^ Tmp;", +" Tm = (*state)[i][2] ^ (*state)[i][3];", +" Tm = xtime(Tm);", +" (*state)[i][2] ^= Tm ^ Tmp;", +" Tm = (*state)[i][3] ^ t;", +" Tm = xtime(Tm);", +" (*state)[i][3] ^= Tm ^ Tmp;", +" }", +"}", +"", +"#if MULTIPLY_AS_A_FUNCTION", +"static uint8_t Multiply(uint8_t x, uint8_t y)", +"{", +" return (((y & 1) * x) ^ ((y >> 1 & 1) * xtime(x)) ^ ((y >> 2 & 1) * xtime(xtime(x))) ^ ((y >> 3 & 1) * xtime(xtime(xtime(x)))) ^ ((y >> 4 & 1) * xtime(xtime(xtime(xtime(x)))))); /* this last call to xtime() can be omitted */", +"}", +"#else", +"#define Multiply(x, y) \\", +" ( ((y & 1) * x) ^ \\", +" ((y>>1 & 1) * xtime(x)) ^ \\", +" ((y>>2 & 1) * xtime(xtime(x))) ^ \\", +" ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ \\", +" ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))) \\", +"", +"#endif", +"", +"#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)", +"", +"#define getSBoxInvert(num) (rsbox[(num)])", +"", +"static void InvMixColumns(state_t * state)", +"{", +" int i;", +" uint8_t a, b, c, d;", +" for (i = 0; i < 4; ++i) {", +" a = (*state)[i][0];", +" b = (*state)[i][1];", +" c = (*state)[i][2];", +" d = (*state)[i][3];", +"", +" (*state)[i][0] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09);", +" (*state)[i][1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);", +" (*state)[i][2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);", +" (*state)[i][3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e);", +" }", +"}", +"", +"static void InvSubBytes(state_t * state)", +"{", +" uint8_t i, j;", +" for (i = 0; i < 4; ++i) {", +" for (j = 0; j < 4; ++j) {", +" (*state)[j][i] = getSBoxInvert((*state)[j][i]);", +" }", +" }", +"}", +"", +"static void InvShiftRows(state_t * state)", +"{", +" uint8_t temp;", +"", +" temp = (*state)[3][1];", +" (*state)[3][1] = (*state)[2][1];", +" (*state)[2][1] = (*state)[1][1];", +" (*state)[1][1] = (*state)[0][1];", +" (*state)[0][1] = temp;", +"", +" temp = (*state)[0][2];", +" (*state)[0][2] = (*state)[2][2];", +" (*state)[2][2] = temp;", +"", +" temp = (*state)[1][2];", +" (*state)[1][2] = (*state)[3][2];", +" (*state)[3][2] = temp;", +"", +" temp = (*state)[0][3];", +" (*state)[0][3] = (*state)[1][3];", +" (*state)[1][3] = (*state)[2][3];", +" (*state)[2][3] = (*state)[3][3];", +" (*state)[3][3] = temp;", +"}", +"#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)", +"", +"static void Cipher(state_t * state, const uint8_t * RoundKey)", +"{", +" uint8_t round = 0;", +"", +" AddRoundKey(0, state, RoundKey);", +"", +" for (round = 1;; ++round) {", +" SubBytes(state);", +" ShiftRows(state);", +" if (round == Nr) {", +" break;", +" }", +" MixColumns(state);", +" AddRoundKey(round, state, RoundKey);", +" }", +" AddRoundKey(Nr, state, RoundKey);", +"}", +"", +"#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)", +"static void InvCipher(state_t * state, const uint8_t * RoundKey)", +"{", +" uint8_t round = 0;", +"", +" AddRoundKey(Nr, state, RoundKey);", +"", +" for (round = (Nr - 1);; --round) {", +" InvShiftRows(state);", +" InvSubBytes(state);", +" AddRoundKey(round, state, RoundKey);", +" if (round == 0) {", +" break;", +" }", +" InvMixColumns(state);", +" }", +"", +"}", +"#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)", +"", +"#if defined(ECB) && (ECB == 1)", +"", +"void AES_ECB_encrypt(const struct AES_ctx *ctx, uint8_t * buf)", +"{", +" Cipher((state_t *) buf, ctx->RoundKey);", +"}", +"", +"void AES_ECB_decrypt(const struct AES_ctx *ctx, uint8_t * buf)", +"{", +" // The next function call decrypts the PlainText with the Key using AES algorithm.", +" InvCipher((state_t *) buf, ctx->RoundKey);", +"}", +"", +"#endif // #if defined(ECB) && (ECB == 1)", +"", +"#if defined(CBC) && (CBC == 1)", +"", +"static void XorWithIv(uint8_t * buf, const uint8_t * Iv)", +"{", +" uint8_t i;", +" for (i = 0; i < AES_BLOCKLEN; ++i) // The block in AES is always 128bit no matter the key size", +" {", +" buf[i] ^= Iv[i];", +" }", +"}", +"", +"void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length)", +"{", +" size_t i;", +" uint8_t *Iv = ctx->Iv;", +" for (i = 0; i < length; i += AES_BLOCKLEN) {", +" XorWithIv(buf, Iv);", +" Cipher((state_t *) buf, ctx->RoundKey);", +" Iv = buf;", +" buf += AES_BLOCKLEN;", +" }", +" /* store Iv in ctx for next call */", +" memcpy(ctx->Iv, Iv, AES_BLOCKLEN);", +"}", +"", +"void AES_CBC_decrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length)", +"{", +" size_t i;", +" uint8_t storeNextIv[AES_BLOCKLEN];", +" for (i = 0; i < length; i += AES_BLOCKLEN) {", +" memcpy(storeNextIv, buf, AES_BLOCKLEN);", +" InvCipher((state_t *) buf, ctx->RoundKey);", +" XorWithIv(buf, ctx->Iv);", +" memcpy(ctx->Iv, storeNextIv, AES_BLOCKLEN);", +" buf += AES_BLOCKLEN;", +" }", +"", +"}", +"", +"#endif // #if defined(CBC) && (CBC == 1)", +"", +"#if defined(CTR) && (CTR == 1)", +"", +"void AES_CTR_xcrypt_buffer(struct AES_ctx *ctx, uint8_t * buf, size_t length)", +"{", +" uint8_t buffer[AES_BLOCKLEN];", +"", +" size_t i;", +" int bi;", +" for (i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi) {", +" if (bi == AES_BLOCKLEN) { /* we need to regen xor compliment in buffer */", +" memcpy(buffer, ctx->Iv, AES_BLOCKLEN);", +" Cipher((state_t *) buffer, ctx->RoundKey);", +"", +" /* Increment Iv and handle overflow */", +" for (bi = (AES_BLOCKLEN - 1); bi >= 0; --bi) {", +" /* inc will overflow */", +" if (ctx->Iv[bi] == 255) {", +" ctx->Iv[bi] = 0;", +" continue;", +" }", +" ctx->Iv[bi] += 1;", +" break;", +" }", +" bi = 0;", +" }", +"", +" buf[i] = (buf[i] ^ buffer[bi]);", +" }", +"}", +"", +"#endif // #if defined(CTR) && (CTR == 1)", - " for (i = 0; i < 4; i++) {", - " w[i] = s_box[16 * ((w[i] & 0xf0) >> 4) + (w[i] & 0x0f)];", - " }", - "}", - "", - "void rot_word(uint8_t * w)", - "{", - " uint8_t tmp;", - " uint8_t i;", - "", - " tmp = w[0];", - "", - " for (i = 0; i < 3; i++) {", - " w[i] = w[i + 1];", - " }", - "", - " w[3] = tmp;", - "}", - "", - "void key_expansion(uint8_t * key, uint8_t * w)", - "{", - " uint8_t tmp[4];", - " uint8_t i;", - " uint8_t len = Nb * (Nr + 1);", - "", - " for (i = 0; i < Nk; i++) {", - " w[4 * i + 0] = key[4 * i + 0];", - " w[4 * i + 1] = key[4 * i + 1];", - " w[4 * i + 2] = key[4 * i + 2];", - " w[4 * i + 3] = key[4 * i + 3];", - " }", - "", - " for (i = Nk; i < len; i++) {", - " tmp[0] = w[4 * (i - 1) + 0];", - " tmp[1] = w[4 * (i - 1) + 1];", - " tmp[2] = w[4 * (i - 1) + 2];", - " tmp[3] = w[4 * (i - 1) + 3];", - "", - " if (i % Nk == 0) {", - "", - " rot_word(tmp);", - " sub_word(tmp);", - " coef_add(tmp, Rcon(i / Nk), tmp);", - "", - " } else if (Nk > 6 && i % Nk == 4) {", - "", - " sub_word(tmp);", - "", - " }", - "", - " w[4 * i + 0] = w[4 * (i - Nk) + 0] ^ tmp[0];", - " w[4 * i + 1] = w[4 * (i - Nk) + 1] ^ tmp[1];", - " w[4 * i + 2] = w[4 * (i - Nk) + 2] ^ tmp[2];", - " w[4 * i + 3] = w[4 * (i - Nk) + 3] ^ tmp[3];", - " }", - "}", - "", - "void cipher(uint8_t * in, uint8_t * out, uint8_t * w)", - "{", - " uint8_t state[4 * Nb];", - " uint8_t r, i, j;", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " state[Nb * i + j] = in[i + 4 * j];", - " }", - " }", - "", - " add_round_key(state, w, 0);", - "", - " for (r = 1; r < Nr; r++) {", - " sub_bytes(state);", - " shift_rows(state);", - " mix_columns(state);", - " add_round_key(state, w, r);", - " }", - "", - " sub_bytes(state);", - " shift_rows(state);", - " add_round_key(state, w, Nr);", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " out[i + 4 * j] = state[Nb * i + j];", - " }", - " }", - "}", - "", - "void inv_cipher(uint8_t * in, uint8_t * out, uint8_t * w)", - "{", - " uint8_t state[4 * Nb];", - " uint8_t r, i, j;", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " state[Nb * i + j] = in[i + 4 * j];", - " }", - " }", - "", - " add_round_key(state, w, Nr);", - "", - " for (r = Nr - 1; r >= 1; r--) {", - " inv_shift_rows(state);", - " inv_sub_bytes(state);", - " add_round_key(state, w, r);", - " inv_mix_columns(state);", - " }", - "", - " inv_shift_rows(state);", - " inv_sub_bytes(state);", - " add_round_key(state, w, 0);", - "", - " for (i = 0; i < 4; i++) {", - " for (j = 0; j < Nb; j++) {", - " out[i + 4 * j] = state[Nb * i + j];", - " }", - " }", - "}", - - "", - "bool DecryptCipherTxtToData(uint8_t * orign, uint8_t * result, uint16_t length)", - "{", - " uint8_t w[240];", - "", - " switch (sizeof(key)) {", - " default:", - " case 16:", - " Nk = 4;", - " Nr = 10;", - " break;", - " case 24:", - " Nk = 6;", - " Nr = 12;", - " break;", - " case 32:", - " Nk = 8;", - " Nr = 14;", - " break;", - " }", - "", - " key_expansion(key, w);", - - " if (length % 16 == 0) {", - " uint16_t i;", - " uint16_t counter = length / 16;", - " uint8_t *p, *q;", - "", - " for (i = 0; i < counter; i++) {", - " p = &orign[16 * i];", - " q = &result[16 * i];", - " inv_cipher(p, q, w);", - " }", - " } else {", - " return false;", - " }", - " return true;", - "}", - "", - "int open_file(char *filename)", - "{", - " FILE *file;", - "", - " file = fopen(filename, \"r\");", - " if (file == NULL) {", - " perror(\"cannot open config file.\");", - " exit(-1);", - " }", - " fseek(file, 0, SEEK_END);", - " file_size = ftell(file);", - " buff = (char *)malloc(file_size + 1);", - " if (buff == NULL)", - " perror(\"out of memory.\");", - " rewind(file);", - " if (fread(buff, file_size, 1, file) < 1) {", - " perror(\"fread\");", - " }", - " fclose(file);", - " buff[file_size] = '\\0';", - " return 0;", - "}", - "", - "", "static int oneHexChar2Hex(char hex)", "{", " int outHex = 0;", @@ -886,45 +595,44 @@ char *source_c[] = { " return ret;", "}", "", - "int main(int argc, char *argv[])", - "{", - " uint8_t *Hex_string = (uint8_t *) malloc(encrypted_text_len*2);", - " memset(Hex_string, 0, encrypted_text_len*2);", - "", - " uint8_t *Decrypt_data = (uint8_t *) malloc(encrypted_text_len*2);", - " memset(Decrypt_data, 0, encrypted_text_len*2);", - "", - " int l = strlen((const char *)Encrypted_data);", - " HexString2Hex((char *)Encrypted_data, (char *)Hex_string, l);", - "", - " DecryptCipherTxtToData(Hex_string, (uint8_t *)Decrypt_data, encrypted_text_len);", - " //printf(\"%s\\n\", Decrypt_data);", - "", - " execlp(\"bash\", argv[0], \"-c\", Decrypt_data, (char *)0);", + +"int main(int argc, char *argv[])", +"{", +" uint8_t *Hex_string = (uint8_t *) malloc(encrypted_text_len*2);", +" memset(Hex_string, 0, encrypted_text_len*2);", - "", - " free(buff);", - " free(Hex_string);", - " free(Decrypt_data);", - "", - " return 0;", - "}", - 0 +" static uint8_t key[16] = \"aixiao\";", +" struct AES_ctx ctx;", +" AES_init_ctx(&ctx, key);", + + + +" HexString2Hex((char *)Encrypted_data, (char *)Hex_string, sizeof(Encrypted_data));", + + + + +" AES_ECB_decrypt(&ctx, Hex_string);", +" //printf(\"%s\\n\", Hex_string);", + +" execlp(\"bash\", argv[0], \"-c\", Hex_string, (char *)0);", + + +" free(Hex_string);", + +" return 0;", +"}", +0 }; -static void hex2str(uint8_t * input, uint16_t input_len, char *output) -{ - char *hexEncode = "0123456789ABCDEF"; - int i = 0, j = 0; - for (i = 0; i < input_len; i++) { - output[j++] = hexEncode[(input[i] >> 4) & 0xf]; - output[j++] = hexEncode[(input[i]) & 0xf]; - } -} + + + int main(int argc, char *argv[]) { + if (argv[1] == NULL) { printf("%s \"shell script file\"\n", argv[0]); @@ -933,8 +641,8 @@ int main(int argc, char *argv[]) open_file(argv[1]); - - char text_content[file_size * 2]; + static uint8_t key[16] = "aixiao"; + uint8_t text_content[file_size * 2]; uint8_t text_content_out[file_size * 2]; uint16_t text_content_length = file_size; unsigned char encrypted_text[file_size * 3]; @@ -961,16 +669,18 @@ int main(int argc, char *argv[]) memcpy(text_content, buff, strlen(buff)); - while (text_content_length % 16) { - strcat(text_content, "\0"); - text_content_length++; - } - EncryptDataToCipherTxt((uint8_t *) text_content, text_content_out, text_content_length); + + + struct AES_ctx ctx; + AES_init_ctx(&ctx, key); + AES_ECB_encrypt(&ctx, text_content); - //16进制字符串 - hex2str(text_content_out, text_content_length, (char *)hexString); - //printf("%s\n", hexString); + //转16进制字符串 + + hex2str(text_content, file_size, (char *)hexString); + printf("%s\n", hexString); + //拼接 strcat((char *)encrypted_text, "char Encrypted_data[]=\""); @@ -1005,7 +715,7 @@ int main(int argc, char *argv[]) strcat(binfile, ".x"); sleep(1); - sprintf(buildcmd, "gcc -Wall %s -o %s -static", sourcefile, binfile); + sprintf(buildcmd, "gcc -Wall -Os %s -o %s -static", sourcefile, binfile); system(buildcmd); //压缩 @@ -1015,11 +725,14 @@ int main(int argc, char *argv[]) strcat(upxcommand, binfile); sleep(1); system(upxcommand); - remove(sourcefile); + //remove(sourcefile); free(buff); return 0; + } + +