FALLEN/WinRFCOMM_client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WinRFCOMM_client/AES.cpp
xfallen a9d7d4a816 first commit
2024-02-15 12:00:37 +08:00

460 lines
12 KiB
C++
Raw Blame History

#include "StdAfx.h"
#include "aes.h"
typedef struct {
DWORD k_len;
DWORD RK[64];
} RIJNDAEL_CIPHER_KEY;
#define u1byte BYTE
#define u4byte DWORD
#define rotl ROTL_DWORD
#define rotr ROTR_DWORD
#define byte(x,n) ((u1byte)((x) >> (8 * n)))
#define LARGE_TABLES
#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0)
#ifdef LARGE_TABLES
#define ls_box(x) \
( fl_tab[0][byte(x, 0)] ^ \
fl_tab[1][byte(x, 1)] ^ \
fl_tab[2][byte(x, 2)] ^ \
fl_tab[3][byte(x, 3)] )
#else
#define ls_box(x) \
((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \
((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \
((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \
((u4byte)sbx_tab[byte(x, 3)] << 24)
#endif
static u1byte log_tab[256];
static u1byte pow_tab[256];
static u1byte sbx_tab[256];
static u1byte isb_tab[256];
static u4byte rco_tab[ 10];
static u4byte ft_tab[4][256];
static u4byte it_tab[4][256];
#ifdef LARGE_TABLES
static u4byte fl_tab[4][256];
static u4byte il_tab[4][256];
#endif
static u4byte tab_gen = 0;
static void gen_tabs(void)
{
u4byte i, t;
u1byte p, q;
log_tab[7] = 0;
for(i = 0,p = 1; i < 256; ++i)
{
pow_tab[i] = (BYTE)p;
log_tab[p] = (BYTE)i;
p = (BYTE)(p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0));
}
log_tab[1] = 0;
p = 1;
for(i = 0; i < 10; ++i)
{
rco_tab[i] = p;
p = (BYTE)((p << 1) ^ (p & 0x80 ? 0x1b : 0));
}
for(i = 0; i < 256; ++i)
{
p = (BYTE)(i ? pow_tab[255 - log_tab[i]] : 0);
q = p;
q = (BYTE)((q >> 7) | (q << 1));
p ^= q;
q = (BYTE)((q >> 7) | (q << 1));
p ^= q;
q = (BYTE)((q >> 7) | (q << 1));
p ^= q;
q = (BYTE)((q >> 7) | (q << 1));
p ^= q ^ 0x63;
sbx_tab[i] = (u1byte)p;
isb_tab[p] = (u1byte)i;
}
for(i = 0; i < 256; ++i)
{
p = sbx_tab[i];
#ifdef LARGE_TABLES
t = p;
fl_tab[0][i] = t;
fl_tab[1][i] = rotl(t, 8);
fl_tab[2][i] = rotl(t, 16);
fl_tab[3][i] = rotl(t, 24);
#endif
t = ((u4byte)ff_mult(2, p)) |
((u4byte)p << 8) |
((u4byte)p << 16) |
((u4byte)ff_mult(3, p) << 24);
ft_tab[0][i] = t;
ft_tab[1][i] = rotl(t, 8);
ft_tab[2][i] = rotl(t, 16);
ft_tab[3][i] = rotl(t, 24);
p = isb_tab[i];
#ifdef LARGE_TABLES
t = p; il_tab[0][i] = t;
il_tab[1][i] = rotl(t, 8);
il_tab[2][i] = rotl(t, 16);
il_tab[3][i] = rotl(t, 24);
#endif
t = ((u4byte)ff_mult(14, p)) |
((u4byte)ff_mult( 9, p) << 8) |
((u4byte)ff_mult(13, p) << 16) |
((u4byte)ff_mult(11, p) << 24);
it_tab[0][i] = t;
it_tab[1][i] = rotl(t, 8);
it_tab[2][i] = rotl(t, 16);
it_tab[3][i] = rotl(t, 24);
}
tab_gen = 1;
};
#define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b)
#define imix_col(y,x) \
u = star_x(x); \
v = star_x(u); \
w = star_x(v); \
t = w ^ (x); \
(y) = u ^ v ^ w; \
(y) ^= rotr(u ^ t, 8) ^ \
rotr(v ^ t, 16) ^ \
rotr(t,24)
static void RIJNDAEL_KeySchedule(
BYTE *UserKey,
DWORD k_len,
DWORD *e_key)
{
u4byte i, t;
if(!tab_gen)
gen_tabs();
LITTLE_B2D(&(UserKey[ 0]), e_key[0]);
LITTLE_B2D(&(UserKey[ 4]), e_key[1]);
LITTLE_B2D(&(UserKey[ 8]), e_key[2]);
LITTLE_B2D(&(UserKey[12]), e_key[3]);
switch(k_len)
{
case 4:
t = e_key[3];
for(i = 0; i < 10; ++i) {
t = ls_box(rotr(t, 8)) ^ rco_tab[i];
t ^= e_key[4 * i]; e_key[4 * i + 4] = t;
t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t;
t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t;
t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t;
}
break;
case 6:
LITTLE_B2D(&(UserKey[16]), e_key[4]);
LITTLE_B2D(&(UserKey[20]), e_key[5]);
t = e_key[5];
for(i = 0; i < 8; ++i) {
t = ls_box(rotr(t, 8)) ^ rco_tab[i];
t ^= e_key[6 * i]; e_key[6 * i + 6] = t;
t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t;
t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t;
t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t;
t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t;
t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t;
}
break;
case 8:
LITTLE_B2D(&(UserKey[16]), e_key[4]);
LITTLE_B2D(&(UserKey[20]), e_key[5]);
LITTLE_B2D(&(UserKey[24]), e_key[6]);
LITTLE_B2D(&(UserKey[28]), e_key[7]);
t = e_key[7];
for(i = 0; i < 7; ++i) {
t = ls_box(rotr(t, 8)) ^ rco_tab[i];
t ^= e_key[8 * i]; e_key[8 * i + 8] = t;
t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t;
t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t;
t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t;
t = e_key[8 * i + 4] ^ ls_box(t);
e_key[8 * i + 12] = t;
t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t;
t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t;
t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t;
}
break;
}
}
RET_VAL AES_EncKeySchedule(
BYTE *UserKey,
DWORD UserKeyLen,
AES_ALG_INFO *AlgInfo)
{
RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey;
DWORD *e_key=RK_Struct->RK;
DWORD k_len;
if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) )
return CTR_INVALID_USERKEYLEN;
k_len = (UserKeyLen + 3) / 4;
RK_Struct->k_len = k_len;
RIJNDAEL_KeySchedule(UserKey, k_len, e_key);
return CTR_SUCCESS;
}
RET_VAL AES_DecKeySchedule(
BYTE *UserKey,
DWORD UserKeyLen,
AES_ALG_INFO *AlgInfo)
{
RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey;
DWORD *d_key=RK_Struct->RK;
DWORD k_len, t_key[64];
u4byte i, t, u, v, w;
if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) )
return CTR_INVALID_USERKEYLEN;
k_len = (UserKeyLen + 3) / 4;
RK_Struct->k_len = k_len;
RIJNDAEL_KeySchedule(UserKey, k_len, t_key);
d_key[0] = t_key[4 * k_len + 24];
d_key[1] = t_key[4 * k_len + 25];
d_key[2] = t_key[4 * k_len + 26];
d_key[3] = t_key[4 * k_len + 27];
for( i=4; i<4*(k_len+6); i+=4) {
imix_col(d_key[i+0], t_key[4*k_len+24-i+0]);
imix_col(d_key[i+1], t_key[4*k_len+24-i+1]);
imix_col(d_key[i+2], t_key[4*k_len+24-i+2]);
imix_col(d_key[i+3], t_key[4*k_len+24-i+3]);
}
d_key[i+0] = t_key[4*k_len+24-i+0];
d_key[i+1] = t_key[4*k_len+24-i+1];
d_key[i+2] = t_key[4*k_len+24-i+2];
d_key[i+3] = t_key[4*k_len+24-i+3];
return CTR_SUCCESS;
}
#define f_nround(bo, bi, k) { \
bo[0] = ft_tab[0][byte(bi[0],0)] \
^ ft_tab[1][byte(bi[1],1)] \
^ ft_tab[2][byte(bi[2],2)] \
^ ft_tab[3][byte(bi[3],3)] ^ k[0];\
bo[1] = ft_tab[0][byte(bi[1],0)] \
^ ft_tab[1][byte(bi[2],1)] \
^ ft_tab[2][byte(bi[3],2)] \
^ ft_tab[3][byte(bi[0],3)] ^ k[1];\
bo[2] = ft_tab[0][byte(bi[2],0)] \
^ ft_tab[1][byte(bi[3],1)] \
^ ft_tab[2][byte(bi[0],2)] \
^ ft_tab[3][byte(bi[1],3)] ^ k[2];\
bo[3] = ft_tab[0][byte(bi[3],0)] \
^ ft_tab[1][byte(bi[0],1)] \
^ ft_tab[2][byte(bi[1],2)] \
^ ft_tab[3][byte(bi[2],3)] ^ k[3];\
k += 4; \
}
#define i_nround(bo, bi, k) { \
bo[0] = it_tab[0][byte(bi[0],0)] \
^ it_tab[1][byte(bi[3],1)] \
^ it_tab[2][byte(bi[2],2)] \
^ it_tab[3][byte(bi[1],3)] ^ k[0];\
bo[1] = it_tab[0][byte(bi[1],0)] \
^ it_tab[1][byte(bi[0],1)] \
^ it_tab[2][byte(bi[3],2)] \
^ it_tab[3][byte(bi[2],3)] ^ k[1];\
bo[2] = it_tab[0][byte(bi[2],0)] \
^ it_tab[1][byte(bi[1],1)] \
^ it_tab[2][byte(bi[0],2)] \
^ it_tab[3][byte(bi[3],3)] ^ k[2];\
bo[3] = it_tab[0][byte(bi[3],0)] \
^ it_tab[1][byte(bi[2],1)] \
^ it_tab[2][byte(bi[1],2)] \
^ it_tab[3][byte(bi[0],3)] ^ k[3];\
k += 4; \
}
#ifdef LARGE_TABLES
#define f_lround(bo, bi, k) { \
bo[0] = fl_tab[0][byte(bi[0],0)] \
^ fl_tab[1][byte(bi[1],1)] \
^ fl_tab[2][byte(bi[2],2)] \
^ fl_tab[3][byte(bi[3],3)] ^ k[0];\
bo[1] = fl_tab[0][byte(bi[1],0)] \
^ fl_tab[1][byte(bi[2],1)] \
^ fl_tab[2][byte(bi[3],2)] \
^ fl_tab[3][byte(bi[0],3)] ^ k[1];\
bo[2] = fl_tab[0][byte(bi[2],0)] \
^ fl_tab[1][byte(bi[3],1)] \
^ fl_tab[2][byte(bi[0],2)] \
^ fl_tab[3][byte(bi[1],3)] ^ k[2];\
bo[3] = fl_tab[0][byte(bi[3],0)] \
^ fl_tab[1][byte(bi[0],1)] \
^ fl_tab[2][byte(bi[1],2)] \
^ fl_tab[3][byte(bi[2],3)] ^ k[3];\
}
#define i_lround(bo, bi, k) { \
bo[0] = il_tab[0][byte(bi[0],0)] \
^ il_tab[1][byte(bi[3],1)] \
^ il_tab[2][byte(bi[2],2)] \
^ il_tab[3][byte(bi[1],3)] ^ k[0];\
bo[1] = il_tab[0][byte(bi[1],0)] \
^ il_tab[1][byte(bi[0],1)] \
^ il_tab[2][byte(bi[3],2)] \
^ il_tab[3][byte(bi[2],3)] ^ k[1];\
bo[2] = il_tab[0][byte(bi[2],0)] \
^ il_tab[1][byte(bi[1],1)] \
^ il_tab[2][byte(bi[0],2)] \
^ il_tab[3][byte(bi[3],3)] ^ k[2];\
bo[3] = il_tab[0][byte(bi[3],0)] \
^ il_tab[1][byte(bi[2],1)] \
^ il_tab[2][byte(bi[1],2)] \
^ il_tab[3][byte(bi[0],3)] ^ k[3];\
}
#else
#define f_rl(bo, bi, n, k) \
bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n)
#define i_rl(bo, bi, n, k) \
bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
#define f_lround(bo, bi, k) \
f_rl(bo, bi, 0, k); \
f_rl(bo, bi, 1, k); \
f_rl(bo, bi, 2, k); \
f_rl(bo, bi, 3, k)
#define i_lround(bo, bi, k) \
i_rl(bo, bi, 0, k); \
i_rl(bo, bi, 1, k); \
i_rl(bo, bi, 2, k); \
i_rl(bo, bi, 3, k)
#endif
void AES_Encrypt(
void *CipherKey,
BYTE *Data)
{
RIJNDAEL_CIPHER_KEY *RK_Struct= (RIJNDAEL_CIPHER_KEY*)CipherKey;
DWORD *e_key=RK_Struct->RK;
DWORD k_len=RK_Struct->k_len;
u4byte b0[4], b1[4], *kp;
LITTLE_B2D(&(Data[ 0]), b0[0]);
LITTLE_B2D(&(Data[ 4]), b0[1]);
LITTLE_B2D(&(Data[ 8]), b0[2]);
LITTLE_B2D(&(Data[12]), b0[3]);
b0[0] ^= e_key[0];
b0[1] ^= e_key[1];
b0[2] ^= e_key[2];
b0[3] ^= e_key[3];
kp = e_key + 4;
switch( k_len ) {
case 8 :
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
case 6 :
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
case 4 :
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_lround(b0, b1, kp);
}
LITTLE_D2B(b0[0], &(Data[ 0]));
LITTLE_D2B(b0[1], &(Data[ 4]));
LITTLE_D2B(b0[2], &(Data[ 8]));
LITTLE_D2B(b0[3], &(Data[12]));
}
void AES_Decrypt(
void *CipherKey,
BYTE *Data)
{
RIJNDAEL_CIPHER_KEY *RK_Struct= (RIJNDAEL_CIPHER_KEY*)CipherKey;
DWORD *d_key=RK_Struct->RK;
DWORD k_len=RK_Struct->k_len;
u4byte b0[4], b1[4], *kp;
LITTLE_B2D(&(Data[ 0]), b0[0]);
LITTLE_B2D(&(Data[ 4]), b0[1]);
LITTLE_B2D(&(Data[ 8]), b0[2]);
LITTLE_B2D(&(Data[12]), b0[3]);
b0[0] ^= d_key[0];
b0[1] ^= d_key[1];
b0[2] ^= d_key[2];
b0[3] ^= d_key[3];
kp = d_key + 4;
switch( k_len ) {
case 8 :
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
case 6 :
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
case 4 :
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_lround(b0, b1, kp);
}
LITTLE_D2B(b0[0], &(Data[ 0]));
LITTLE_D2B(b0[1], &(Data[ 4]));
LITTLE_D2B(b0[2], &(Data[ 8]));
LITTLE_D2B(b0[3], &(Data[12]));
}
Reference in New Issue View Git Blame Copy Permalink