// GF(2^8)
static BYTE product(WORD x, WORD y)
{
BYTE* xb = (BYTE*)&x;
BYTE* yb = (BYTE*)&y;
return bmul(xb[0], yb[0]) ^ bmul(xb[1], yb[1]) ^
bmul(xb[2], yb[2]) ^ bmul(xb[3], yb[3]);
}
static BYTE product(WORD x,WORD y)
{ /* dot product of two 4-byte arrays */
BYTE xb[4],yb[4];
unpack(x,xb);
unpack(y,yb);
return bmul(xb[0],yb[0])^bmul(xb[1],yb[1])^bmul(xb[2],yb[2])^bmul(xb[3],yb[3]);
}
static u8 product(u32 x,u32 y)
{ /* dot product of two 4-byte arrays */
u8 xb[4],yb[4];
unpack(x,xb);
unpack(y,yb);
return bmul(xb[0],yb[0])^bmul(xb[1],yb[1])^bmul(xb[2],yb[2])^bmul(xb[3],yb[3]);
}
//==============================================================================
uint8_t product(uint32_t x, uint32_t y, uint8_t mod) //Вспомогательная функция перемешивающая данные в колонке
{
uint8_t xb[4], yb[4];
unpack(x, xb);
unpack(y, yb);
return bmul(xb[0], yb[0], mod) ^ bmul(xb[1], yb[1], mod) ^ bmul(xb[2], yb[2], mod) ^ bmul(xb[3], yb[3], mod);
}
static void gentables(void)
{ /* generate tables */
int i;
u8 y,b[4];
/* use 3 as primitive root to generate power and log tables */
ltab[0]=0;
ptab[0]=1;
ltab[1]=0;
ptab[1]=3;
ltab[3]=1;
for (i=2; i<256; i++)
{
ptab[i]=ptab[i-1]^xtime(ptab[i-1]);
ltab[ptab[i]]=i;
}
/* affine transformation:- each bit is xored with itself shifted one bit */
fbsub[0]=0x63;
rbsub[0x63]=0;
for (i=1; i<256; i++)
{
y=ByteSub((u8)i);
fbsub[i]=y;
rbsub[y]=i;
}
for (i=0,y=1; i<30; i++)
{
rco[i]=y;
y=xtime(y);
}
/* calculate forward and reverse tables */
for (i=0; i<256; i++)
{
y=fbsub[i];
b[3]=y^xtime(y);
b[2]=y;
b[1]=y;
b[0]=xtime(y);
ftable[i]=pack(b);
y=rbsub[i];
b[3]=bmul(InCo[0],y);
b[2]=bmul(InCo[1],y);
b[1]=bmul(InCo[2],y);
b[0]=bmul(InCo[3],y);
rtable[i]=pack(b);
}
}
static WORD MixCol(BYTE b[4])
{
BYTE s[4];
s[0] = bmul(0x2, b[0]) ^ bmul(0x3, b[1]) ^ b[2] ^ b[3];
s[1] = b[0] ^ bmul(0x2, b[1]) ^ bmul(0x3, b[2]) ^ b[3];
s[2] = b[0] ^ b[1] ^ bmul(0x2, b[2]) ^ bmul(0x3, b[3]);
s[3] = bmul(0x3, b[0]) ^ b[1] ^ b[2] ^ bmul(0x2, b[3]);
return pack(s);
}
/*初始化*/
void gentables(void)
{ //初始化矩阵
int i;
BYTE y,b[4];
ltab[0]=0;
ptab[0]=1;
ptab[1]=3;
ltab[1]=0;
ltab[3]=1;
for (i=2;i<256;i++)
{
ptab[i]=ptab[i-1]^xtime(ptab[i-1]);
ltab[ptab[i]]=i;
}
// 进行移位操作
fbsub[0]=0x63;
rbsub[0x63]=0;
for (i=1;i<256;i++)
{
y=ByteSub((BYTE)i);
fbsub[i]=y;
rbsub[y]=i;
}
for (i=0,y=1;i<30;i++)
{
rco[i]=y;
y=xtime(y);
}
for (i=0;i<256;i++)
{
y=fbsub[i];
b[3]=y^xtime(y);
b[2]=y;
b[1]=y;
ftable[i]=pack(b);
b[0]=xtime(y);
y=rbsub[i];
b[3]=bmul(InCo[0],y);
b[2]=bmul(InCo[1],y);
b[1]=bmul(InCo[2],y);
b[0]=bmul(InCo[3],y);
rtable[i]=pack(b);
}
}
QWMatrix &QWMatrix::rotate( double a )
{
double b = deg2rad*a; // convert to radians
#if defined(_WS_X11_)
double sina = qsincos(b,FALSE); // fast and convenient
double cosa = qsincos(b,TRUE);
#else
double sina = sin(b);
double cosa = cos(b);
#endif
QWMatrix result( cosa, sina, -sina, cosa, 0.0F, 0.0F );
return bmul( result );
}
QWMatrix &QWMatrix::rotate( float a )
{
double b = deg2rad*a; // convert to radians
#if defined(_WS_X11_)
float sina = qsincos(b,FALSE); // fast and convenient
float cosa = qsincos(b,TRUE);
#else
float sina = (float)sin(b);
float cosa = (float)cos(b);
#endif
QWMatrix result( cosa, sina, -sina, cosa, 0.0F, 0.0F );
return bmul( result );
}
static WORD InvMixCol(BYTE b[4])
{
BYTE s[4];
s[0] = bmul(0xe, b[0]) ^ bmul(0xb, b[1]) ^ bmul(0xd, b[2]) ^ bmul(0x9, b[3]);
s[1] = bmul(0x9, b[0]) ^ bmul(0xe, b[1]) ^ bmul(0xb, b[2]) ^ bmul(0xd, b[3]);
s[2] = bmul(0xd, b[0]) ^ bmul(0x9, b[1]) ^ bmul(0xe, b[2]) ^ bmul(0xb, b[3]);
s[3] = bmul(0xb, b[0]) ^ bmul(0xd, b[1]) ^ bmul(0x9, b[2]) ^ bmul(0xe, b[3]);
return pack(s);
}
QWMatrix &QWMatrix::shear( double sh, double sv )
{
QWMatrix result( 1.0F, sv, sh, 1.0F, 0.0F, 0.0F );
return bmul( result );
}
QWMatrix &QWMatrix::scale( double sx, double sy )
{
QWMatrix result( sx, 0.0F, 0.0F, sy, 0.0F, 0.0F );
return bmul( result );
}
QWMatrix &QWMatrix::translate( double dx, double dy )
{
QWMatrix result( 1.0F, 0.0F, 0.0F, 1.0F, dx, dy );
return bmul( result );
}
QWMatrix &QWMatrix::shear( float sh, float sv )
{
QWMatrix result( 1.0F, sv, sh, 1.0F, 0.0F, 0.0F );
return bmul( result );
}
QWMatrix &QWMatrix::scale( float sx, float sy )
{
QWMatrix result( sx, 0.0F, 0.0F, sy, 0.0F, 0.0F );
return bmul( result );
}
QWMatrix &QWMatrix::translate( float dx, float dy )
{
QWMatrix result( 1.0F, 0.0F, 0.0F, 1.0F, dx, dy );
return bmul( result );
}
