📄 rijndael.cpp
字号:
// Rijndael.cpp: implementation of the CRijndael class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
//#include "AES.h"
#include "Rijndael.h"
#define CTR_MODE 2
#define ECB_MODE 0
#define CBC_MODE 1
#define GetBitofbin2( i ) ( bin2 & mask[ i ] ) >> i
#define GetTopBitofb( i ) ( b[i] & mask[ 7 ] ) >> 7
#define InvByteSub( ch ) invsbox[ ch/16 ][ ch-ch/16*16 ]
#define ByteSub( ch ) sbox[ ch/16 ][ ch - ch/16*16 ]
#define ShiftRow1 \
{ \
BYTE t; \
t = p[1][0]; \
p[1][0] = p[1][1]; \
p[1][1] = p[1][2]; \
p[1][2] = p[1][3]; \
p[1][3] = t; \
}
#define ShiftRow2 \
{ \
BYTE t; \
t = p[2][0]; \
p[2][0] = p[2][2]; \
p[2][2] = t; \
t = p[2][1]; \
p[2][1] = p[2][3]; \
p[2][3] = t; \
}
#define ShiftRow3 \
{ \
BYTE t; \
t = p[3][3]; \
p[3][3] = p[3][2]; \
p[3][2] = p[3][1]; \
p[3][1] = p[3][0]; \
p[3][0] = t; \
}
#define InvShiftRow1 \
{ \
BYTE t; \
t = p[1][3]; \
p[1][3] = p[1][2]; \
p[1][2] = p[1][1]; \
p[1][1] = p[1][0]; \
p[1][0] = t; \
}
#define InvShiftRow2 \
{ \
BYTE t; \
t = p[2][0]; \
p[2][0] = p[2][2]; \
p[2][2] = t; \
t = p[2][1]; \
p[2][1] = p[2][3]; \
p[2][3] = t; \
}
#define InvShiftRow3 \
{ \
BYTE t; \
t = p[3][0]; \
p[3][0] = p[3][1]; \
p[3][1] = p[3][2]; \
p[3][2] = p[3][3]; \
p[3][3] = t; \
}
#define ByteSubs \
{ \
p[0][0] = ByteSub( p[0][0] ); \
p[0][1] = ByteSub( p[0][1] ); \
p[0][2] = ByteSub( p[0][2] ); \
p[0][3] = ByteSub( p[0][3] ); \
\
p[1][0] = ByteSub( p[1][0] ); \
p[1][1] = ByteSub( p[1][1] ); \
p[1][2] = ByteSub( p[1][2] ); \
p[1][3] = ByteSub( p[1][3] ); \
\
p[2][0] = ByteSub( p[2][0] ); \
p[2][1] = ByteSub( p[2][1] ); \
p[2][2] = ByteSub( p[2][2] ); \
p[2][3] = ByteSub( p[2][3] ); \
\
p[3][0] = ByteSub( p[3][0] ); \
p[3][1] = ByteSub( p[3][1] ); \
p[3][2] = ByteSub( p[3][2] ); \
p[3][3] = ByteSub( p[3][3] ); \
}
#define AddRoundKey( nRound ) \
{ \
int n=((nRound)-1)*4; \
p[0][0] ^= w[ n + 0 ].b[0]; \
p[1][0] ^= w[ n + 1 ].b[0]; \
p[2][0] ^= w[ n + 2 ].b[0]; \
p[3][0] ^= w[ n + 3 ].b[0]; \
\
p[0][1] ^= w[ n + 0 ].b[1]; \
p[1][1] ^= w[ n + 1 ].b[1]; \
p[2][1] ^= w[ n + 2 ].b[1]; \
p[3][1] ^= w[ n + 3 ].b[1]; \
\
p[0][2] ^= w[ n + 0 ].b[2]; \
p[1][2] ^= w[ n + 1 ].b[2]; \
p[2][2] ^= w[ n + 2 ].b[2]; \
p[3][2] ^= w[ n + 3 ].b[2]; \
\
p[0][3] ^= w[ n + 0 ].b[3]; \
p[1][3] ^= w[ n + 1 ].b[3]; \
p[2][3] ^= w[ n + 2 ].b[3]; \
p[3][3] ^= w[ n + 3 ].b[3]; \
}
const DWORD mask[ 32 ] =
{ 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020, 0x00000040, 0x00000080,
0x00000100, 0x00000200, 0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000, 0x00008000,
0x00010000, 0x00020000, 0x00040000, 0x00080000, 0x00100000, 0x00200000, 0x00400000, 0x00800000,
0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000
};
const BYTE sbox[16][16]=
{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};
const BYTE invsbox[16][16]=
{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};
const BYTE RC[11]={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1B,0x36};
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CRijndael::CRijndael()
{
}
CRijndael::~CRijndael()
{
}
BYTE CRijndael::XMUL2( BYTE bin1 )
{
return (( bin1 & mask[ 7 ] ) >> 7) ? ( (bin1<<1) ^ 0x1b ) : (bin1<<1);
}
BYTE CRijndael::XMUL3( BYTE bin1 )
{
bin1 ^= (( bin1 & mask[ 7 ] ) >> 7) ? ( (bin1<<1) ^ 0x1b ) : (bin1<<1);
return bin1;
}
void CRijndael::XMULP( BYTE bin1, BYTE p[] )
{
BYTE b[4];
b[0] = bin1;
int i;
for( i=1;i<4;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
p[0] = b[1]^b[2]^b[3];
p[1] = b[0]^b[3];
p[2] = b[1]^b[0]^b[3];
p[3] = b[2]^b[0]^b[3];
}
BYTE CRijndael::XMULe( BYTE bin1 )
{
BYTE b[4];
b[0] = bin1;
int i;
for( i=1;i<4;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
return b[1]^b[2]^b[3];
}
BYTE CRijndael::XMUL9( BYTE bin1 )
{
BYTE b[4];
b[0] = bin1;
int i;
for( i=1;i<4;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
return b[0]^b[3];
}
BYTE CRijndael::XMULb( BYTE bin1 )
{
BYTE b[4];
b[0] = bin1;
int i;
for( i=1;i<4;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
return b[1]^b[0]^b[3];
}
BYTE CRijndael::XMULd( BYTE bin1 )
{
BYTE b[4];
b[0] = bin1;
int i;
for( i=1;i<4;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
return b[2]^b[0]^b[3];
}
BYTE CRijndael::XMUL(BYTE bin2,BYTE bin1)
{
BYTE b[8],Res=0;
b[0] = bin1;
int i;
for( i=1;i<8;i++)
{
b[i] = GetTopBitofb( i-1 ) ? ( (b[i-1]<<1) ^ 0x1b ) : (b[i-1]<<1);
}
for( i=0;i<8;i++)
{
Res ^= ( GetBitofbin2( i ) ? b[i] : 0 );
}
return Res;
}
void CRijndael::MixColumn(BYTE p0[],BYTE p1[],BYTE p2[],BYTE p3[])
{
BYTE p[4];
for(int i=0;i<4;i++)
{
p[0]=p0[i]; p[1]=p1[i]; p[2]=p2[i]; p[3]=p3[i];
p0[i] = XMUL2(p[0]) ^ XMUL3(p[1]) ^ p[2] ^ p[3];
p1[i] = p[0] ^ XMUL2(p[1]) ^ XMUL3(p[2]) ^ p[3];
p2[i] = p[0] ^ p[1] ^ XMUL2(p[2]) ^ XMUL3(p[3]);
p3[i] = XMUL3(p[0]) ^ p[1] ^ p[2] ^ XMUL2(p[3]);
}
}
void CRijndael::Init(BYTE key[])
{
BYTE k[4][5];
word wtmp;
BYTE tmp;
int n,i=0,j=0;
for(i=0;i<4;i++)
{
k[i][0]=key[j++];
k[i][1]=key[j++];
k[i][2]=key[j++];
k[i][3]=key[j++];
k[i][4]=0;
}
for(i=0;i<44;i++)
{
w[i].b[4]=0;
}
for(i=0;i<4;i++)
{//第一轮密钥
w[0].b[i]=k[0][i];
w[1].b[i]=k[1][i];
w[2].b[i]=k[2][i];
w[3].b[i]=k[3][i];
}
for(j=2;j<=11;j++)
{//第j-1轮密钥
n=(j-2)*4;
wtmp=w[3+n];
tmp=wtmp.b[0];
for(i=0;i<3;i++)
{
wtmp.b[i]=wtmp.b[i+1];
}
wtmp.b[3]=tmp;
for(i=0;i<4;i++)
{
wtmp.b[i]=ByteSub(wtmp.b[i]);
}
wtmp.b[0]=wtmp.b[0]^RC[j-1];
for(i=0;i<4;i++)
{
w[4+n].b[i]=w[0+n].b[i]^wtmp.b[i];
}
for(i=0;i<4;i++)
{
w[5+n].b[i]=w[1+n].b[i]^w[4+n].b[i];
w[6+n].b[i]=w[2+n].b[i]^w[5+n].b[i];
w[7+n].b[i]=w[3+n].b[i]^w[6+n].b[i];
}
}
}
void CRijndael::Encrypt(BYTE sText[],BYTE sRes[])
{
BYTE p[4][4];
int i=0,j=0;
for(;i<4;i++)
{
p[i][0]=sText[j++];
p[i][1]=sText[j++];
p[i][2]=sText[j++];
p[i][3]=sText[j++];
}
AddRoundKey(1);
for(int k=2;k<=10;k++)
{
//字节代换
ByteSubs;
//行移位
ShiftRow1;
ShiftRow2;
ShiftRow3;
//列混淆变换
MixColumn(p[0],p[1],p[2],p[3]);
//轮密钥加变换
AddRoundKey(k);
}
//字节代换
ByteSubs;
//行移位
ShiftRow1;
ShiftRow2;
ShiftRow3;
//轮密钥加变换
AddRoundKey(11);
j=0;
for(i=0;i<4;i++)
{
sRes[j++]=p[i][0];
sRes[j++]=p[i][1];
sRes[j++]=p[i][2];
sRes[j++]=p[i][3];
}
}
void CRijndael::Decrypt(BYTE sText[],BYTE sRes[])
{
BYTE p[4][4];
int i=0,j=0;
for(;i<4;i++)
{
p[i][0]=sText[j++];
p[i][1]=sText[j++];
p[i][2]=sText[j++];
p[i][3]=sText[j++];
}
AddRoundKey(11);
for(int k=10;k>1;k--)
{
//逆行移位
InvShiftRow1;
InvShiftRow2;
InvShiftRow3;
//逆字节代换
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
p[i][j]=InvByteSub(p[i][j]);
}
}
//轮密钥加变换
AddRoundKey(k);
//逆列混淆变换
InvMixColumn(p[0],p[1],p[2],p[3]);
}
//逆行移位
InvShiftRow1;
InvShiftRow2;
InvShiftRow3;
//逆字节代换
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
p[i][j]=InvByteSub(p[i][j]);
}
}
//轮密钥加变换
AddRoundKey(1);
j=0;
for(i=0;i<4;i++)
{
sRes[j++]=p[i][0];
sRes[j++]=p[i][1];
sRes[j++]=p[i][2];
sRes[j++]=p[i][3];
}
sRes[j]=0;
}
void CRijndael::InvMixColumn(BYTE p0[],BYTE p1[],BYTE p2[],BYTE p3[])
{
BYTE p[4];
for(int i=0;i<4;i++)
{
p[0]=p0[i];p[1]=p1[i];p[2]=p2[i];p[3]=p3[i];
BYTE XMULp[4][4];
XMULP( p[0], XMULp[0] );
XMULP( p[1], XMULp[1] );
XMULP( p[2], XMULp[2] );
XMULP( p[3], XMULp[3] );
p0[i] = XMULp[0][0] ^ XMULp[1][2] ^ XMULp[2][3] ^ XMULp[3][1];
p1[i] = XMULp[0][1] ^ XMULp[1][0] ^ XMULp[2][2] ^ XMULp[3][3];
p2[i] = XMULp[0][3] ^ XMULp[1][1] ^ XMULp[2][0] ^ XMULp[3][2];
p3[i] = XMULp[0][2] ^ XMULp[1][3] ^ XMULp[2][1] ^ XMULp[3][0];
}
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -