diamond.cpp

各种加密算法的集合

	y[4] = (x[4] & 1) | (x[5] & 2) | (x[6] & 4) | 
			(x[7] & 8) | (x[8] & 16) | (x[9] & 32) | 
			(x[10] & 64) | (x[11] & 128); 
	y[5] = (x[5] & 1) | (x[6] & 2) | (x[7] & 4) | 
			(x[8] & 8) | (x[9] & 16) | (x[10] & 32) | 
			(x[11] & 64) | (x[12] & 128); 
	y[6] = (x[6] & 1) | (x[7] & 2) | (x[8] & 4) | 
			(x[9] & 8) | (x[10] & 16) | (x[11] & 32) | 
			(x[12] & 64) | (x[13] & 128); 
	y[7] = (x[7] & 1) | (x[8] & 2) | (x[9] & 4) | 
			(x[10] & 8) | (x[11] & 16) | (x[12] & 32) | 
			(x[13] & 64) | (x[14] & 128); 
	y[8] = (x[8] & 1) | (x[9] & 2) | (x[10] & 4) | 
			(x[11] & 8) | (x[12] & 16) | (x[13] & 32) | 
			(x[14] & 64) | (x[15] & 128); 
	y[9] = (x[9] & 1) | (x[10] & 2) | (x[11] & 4) | 
			(x[12] & 8) | (x[13] & 16) | (x[14] & 32) | 
			(x[15] & 64) | (x[0] & 128); 
	y[10] = (x[10] & 1) | (x[11] & 2) | (x[12] & 4) | 
			(x[13] & 8) | (x[14] & 16) | (x[15] & 32) | 
			(x[0] & 64) | (x[1] & 128); 
	y[11] = (x[11] & 1) | (x[12] & 2) | (x[13] & 4) | 
			(x[14] & 8) | (x[15] & 16) | (x[0] & 32) | 
			(x[1] & 64) | (x[2] & 128); 
	y[12] = (x[12] & 1) | (x[13] & 2) | (x[14] & 4) | 
			(x[15] & 8) | (x[0] & 16) | (x[1] & 32) | 
			(x[2] & 64) | (x[3] & 128); 
	y[13] = (x[13] & 1) | (x[14] & 2) | (x[15] & 4) | 
			(x[0] & 8) | (x[1] & 16) | (x[2] & 32) | 
			(x[3] & 64) | (x[4] & 128); 
	y[14] = (x[14] & 1) | (x[15] & 2) | (x[0] & 4) | 
			(x[1] & 8) | (x[2] & 16) | (x[3] & 32) | 
			(x[4] & 64) | (x[5] & 128); 
	y[15] = (x[15] & 1) | (x[0] & 2) | (x[1] & 4) | 
			(x[2] & 8) | (x[3] & 16) | (x[4] & 32) | 
			(x[5] & 64) | (x[6] & 128); 
 
	memcpy(x, y, 16); 
} 
 
inline void Diamond2Base::ipermute(byte *x) 
{ 
	byte y[16]; 
 
	y[0] = (x[0] & 1) | (x[15] & 2) | (x[14] & 4) | 
			(x[13] & 8) | (x[12] & 16) | (x[11] & 32) | 
			(x[10] & 64) | (x[9] & 128); 
	y[1] = (x[1] & 1) | (x[0] & 2) | (x[15] & 4) | 
			(x[14] & 8) | (x[13] & 16) | (x[12] & 32) | 
			(x[11] & 64) | (x[10] & 128); 
	y[2] = (x[2] & 1) | (x[1] & 2) | (x[0] & 4) | 
			(x[15] & 8) | (x[14] & 16) | (x[13] & 32) | 
			(x[12] & 64) | (x[11] & 128); 
	y[3] = (x[3] & 1) | (x[2] & 2) | (x[1] & 4) | 
			(x[0] & 8) | (x[15] & 16) | (x[14] & 32) | 
			(x[13] & 64) | (x[12] & 128); 
	y[4] = (x[4] & 1) | (x[3] & 2) | (x[2] & 4) | 
			(x[1] & 8) | (x[0] & 16) | (x[15] & 32) | 
			(x[14] & 64) | (x[13] & 128); 
	y[5] = (x[5] & 1) | (x[4] & 2) | (x[3] & 4) | 
			(x[2] & 8) | (x[1] & 16) | (x[0] & 32) | 
			(x[15] & 64) | (x[14] & 128); 
	y[6] = (x[6] & 1) | (x[5] & 2) | (x[4] & 4) | 
			(x[3] & 8) | (x[2] & 16) | (x[1] & 32) | 
			(x[0] & 64) | (x[15] & 128); 
	y[7] = (x[7] & 1) | (x[6] & 2) | (x[5] & 4) | 
			(x[4] & 8) | (x[3] & 16) | (x[2] & 32) | 
			(x[1] & 64) | (x[0] & 128); 
	y[8] = (x[8] & 1) | (x[7] & 2) | (x[6] & 4) | 
			(x[5] & 8) | (x[4] & 16) | (x[3] & 32) | 
			(x[2] & 64) | (x[1] & 128); 
	y[9] = (x[9] & 1) | (x[8] & 2) | (x[7] & 4) | 
			(x[6] & 8) | (x[5] & 16) | (x[4] & 32) | 
			(x[3] & 64) | (x[2] & 128); 
	y[10] = (x[10] & 1) | (x[9] & 2) | (x[8] & 4) | 
			(x[7] & 8) | (x[6] & 16) | (x[5] & 32) | 
			(x[4] & 64) | (x[3] & 128); 
	y[11] = (x[11] & 1) | (x[10] & 2) | (x[9] & 4) | 
			(x[8] & 8) | (x[7] & 16) | (x[6] & 32) | 
			(x[5] & 64) | (x[4] & 128); 
	y[12] = (x[12] & 1) | (x[11] & 2) | (x[10] & 4) | 
			(x[9] & 8) | (x[8] & 16) | (x[7] & 32) | 
			(x[6] & 64) | (x[5] & 128); 
	y[13] = (x[13] & 1) | (x[12] & 2) | (x[11] & 4) | 
			(x[10] & 8) | (x[9] & 16) | (x[8] & 32) | 
			(x[7] & 64) | (x[6] & 128); 
	y[14] = (x[14] & 1) | (x[13] & 2) | (x[12] & 4) | 
			(x[11] & 8) | (x[10] & 16) | (x[9] & 32) | 
			(x[8] & 64) | (x[7] & 128); 
	y[15] = (x[15] & 1) | (x[14] & 2) | (x[13] & 4) | 
			(x[12] & 8) | (x[11] & 16) | (x[10] & 32) | 
			(x[9] & 64) | (x[8] & 128); 
 
	memcpy(x, y, 16); 
} 
 
#endif // DIAMOND_USE_PERMTABLE 
 
void Diamond2Encryption::ProcessBlock(byte *y) const 
{ 
	substitute(0, y); 
	for (int round=1; round < numrounds; round++) 
	{ 
		permute(y); 
		substitute(round, y); 
	} 
} 
 
void Diamond2Encryption::ProcessBlock(const byte *x, byte *y) const 
{ 
	memcpy(y, x, BLOCKSIZE); 
	Diamond2Encryption::ProcessBlock(y); 
} 
 
void Diamond2Decryption::ProcessBlock(byte *y) const 
{ 
	substitute(numrounds-1, y); 
	for (int round=numrounds-2; round >= 0; round--) 
	{ 
		ipermute(y); 
		substitute(round, y); 
	} 
} 
 
void Diamond2Decryption::ProcessBlock(const byte *x, byte *y) const 
{ 
	memcpy(y, x, BLOCKSIZE); 
	Diamond2Decryption::ProcessBlock(y); 
} 
 
Diamond2LiteBase::Diamond2LiteBase(const byte *key, unsigned int key_size, 
								 unsigned int rounds, CipherDir direction) 
	: numrounds(rounds), 
	  s(numrounds * ROUNDSIZE) 
{ 
	Diamond2SboxMaker m(key, key_size, rounds, true); 
	m.MakeSbox(s, direction); 
} 
 
inline void Diamond2LiteBase::substitute(int round, byte *y) const 
{ 
	const byte *sbox = s + (ROUNDSIZE*round); 
	y[0] = sbox[0*256+y[0]]; 
	y[1] = sbox[1*256+y[1]]; 
	y[2] = sbox[2*256+y[2]]; 
	y[3] = sbox[3*256+y[3]]; 
	y[4] = sbox[4*256+y[4]]; 
	y[5] = sbox[5*256+y[5]]; 
	y[6] = sbox[6*256+y[6]]; 
	y[7] = sbox[7*256+y[7]]; 
} 
 
#ifdef DIAMOND_USE_PERMTABLE 
 
inline void Diamond2LiteBase::permute(byte *a) 
{ 
	word32 temp      = permtable[0][a[0]] | permtable[1][a[1]] | 
					   permtable[2][a[2]] | permtable[3][a[3]] | 
					   permtable[4][a[4]] | permtable[5][a[5]] | 
					   permtable[6][a[6]] | permtable[7][a[7]]; 
 
	((word32 *)a)[1] = permtable[0][a[4]] | permtable[1][a[5]] | 
					   permtable[2][a[6]] | permtable[3][a[7]] | 
					   permtable[4][a[0]] | permtable[5][a[1]] | 
					   permtable[6][a[2]] | permtable[7][a[3]]; 
 
	((word32 *)a)[0] = temp; 
} 
 
inline void Diamond2LiteBase::ipermute(byte *a) 
{ 
	word32 temp      = ipermtable[0][a[0]] | ipermtable[1][a[1]] | 
					   ipermtable[2][a[2]] | ipermtable[3][a[3]] | 
					   ipermtable[4][a[4]] | ipermtable[5][a[5]] | 
					   ipermtable[6][a[6]] | ipermtable[7][a[7]]; 
 
	((word32 *)a)[1] = ipermtable[0][a[4]] | ipermtable[1][a[5]] | 
					   ipermtable[2][a[6]] | ipermtable[3][a[7]] | 
					   ipermtable[4][a[0]] | ipermtable[5][a[1]] | 
					   ipermtable[6][a[2]] | ipermtable[7][a[3]]; 
 
	((word32 *)a)[0] = temp; 
} 
 
#else 
 
inline void Diamond2LiteBase::permute(byte *a) 
{ 
	byte b[8]; 
 
	b[0] = (a[0] & 1) + (a[1] & 2) + (a[2] & 4) + (a[3] & 8) + (a[4] & 0x10) + 
		(a[5] & 0x20) + (a[6] & 0x40) + (a[7] & 0x80); 
	b[1] = (a[1] & 1) + (a[2] & 2) + (a[3] & 4) + (a[4] & 8) + (a[5] & 0x10) + 
		(a[6] & 0x20) + (a[7] & 0x40) + (a[0] & 0x80); 
	b[2] = (a[2] & 1) + (a[3] & 2) + (a[4] & 4) + (a[5] & 8) + (a[6] & 0x10) + 
		(a[7] & 0x20) + (a[0] & 0x40) + (a[1] & 0x80); 
	b[3] = (a[3] & 1) + (a[4] & 2) + (a[5] & 4) + (a[6] & 8) + (a[7] & 0x10) + 
		(a[0] & 0x20) + (a[1] & 0x40) + (a[2] & 0x80); 
	b[4] = (a[4] & 1) + (a[5] & 2) + (a[6] & 4) + (a[7] & 8) + (a[0] & 0x10) + 
		(a[1] & 0x20) + (a[2] & 0x40) + (a[3] & 0x80); 
	b[5] = (a[5] & 1) + (a[6] & 2) + (a[7] & 4) + (a[0] & 8) + (a[1] & 0x10) + 
		(a[2] & 0x20) + (a[3] & 0x40) + (a[4] & 0x80); 
	b[6] = (a[6] & 1) + (a[7] & 2) + (a[0] & 4) + (a[1] & 8) + (a[2] & 0x10) + 
		(a[3] & 0x20) + (a[4] & 0x40) + (a[5] & 0x80); 
	b[7] = (a[7] & 1) + (a[0] & 2) + (a[1] & 4) + (a[2] & 8) + (a[3] & 0x10) + 
		(a[4] & 0x20) + (a[5] & 0x40) + (a[6] & 0x80); 
 
	memcpy(a, b, 8); 
} 
 
inline void Diamond2LiteBase::ipermute(byte *b) 
{ 
	byte a[8]; 
 
	a[0] = (b[0] & 1) + (b[7] & 2) + (b[6] & 4) + (b[5] & 8) + (b[4] & 0x10) + 
		(b[3] & 0x20) + (b[2] & 0x40) + (b[1] & 0x80); 
	a[1] = (b[1] & 1) + (b[0] & 2) + (b[7] & 4) + (b[6] & 8) + (b[5] & 0x10) + 
		(b[4] & 0x20) + (b[3] & 0x40) + (b[2] & 0x80); 
	a[2] = (b[2] & 1) + (b[1] & 2) + (b[0] & 4) + (b[7] & 8) + (b[6] & 0x10) + 
		(b[5] & 0x20) + (b[4] & 0x40) + (b[3] & 0x80); 
	a[3] = (b[3] & 1) + (b[2] & 2) + (b[1] & 4) + (b[0] & 8) + (b[7] & 0x10) + 
		(b[6] & 0x20) + (b[5] & 0x40) + (b[4] & 0x80); 
	a[4] = (b[4] & 1) + (b[3] & 2) + (b[2] & 4) + (b[1] & 8) + (b[0] & 0x10) + 
		(b[7] & 0x20) + (b[6] & 0x40) + (b[5] & 0x80); 
	a[5] = (b[5] & 1) + (b[4] & 2) + (b[3] & 4) + (b[2] & 8) + (b[1] & 0x10) + 
		(b[0] & 0x20) + (b[7] & 0x40) + (b[6] & 0x80); 
	a[6] = (b[6] & 1) + (b[5] & 2) + (b[4] & 4) + (b[3] & 8) + (b[2] & 0x10) + 
		(b[1] & 0x20) + (b[0] & 0x40) + (b[7] & 0x80); 
	a[7] = (b[7] & 1) + (b[6] & 2) + (b[5] & 4) + (b[4] & 8) + (b[3] & 0x10) + 
		(b[2] & 0x20) + (b[1] & 0x40) + (b[0] & 0x80); 
 
	memcpy(b, a, 8); 
} 
 
#endif // DIAMOND_USE_PERMTABLE 
 
void Diamond2LiteEncryption::ProcessBlock(byte *y) const 
{ 
	substitute(0, y); 
	for (int round=1; round < numrounds; round++) 
	{ 
		permute(y); 
		substitute(round, y); 
	} 
} 
 
void Diamond2LiteEncryption::ProcessBlock(const byte *x, byte *y) const 
{ 
	memcpy(y, x, BLOCKSIZE); 
	Diamond2LiteEncryption::ProcessBlock(y); 
} 
 
void Diamond2LiteDecryption::ProcessBlock(byte *y) const 
{ 
	substitute(numrounds-1, y); 
	for (int round=numrounds-2; round >= 0; round--) 
	{ 
		ipermute(y); 
		substitute(round, y); 
	} 
} 
 
void Diamond2LiteDecryption::ProcessBlock(const byte *x, byte *y) const 
{ 
	memcpy(y, x, BLOCKSIZE); 
	Diamond2LiteDecryption::ProcessBlock(y); 
} 
 
NAMESPACE_END