/* This is an independent implementation of the DEAL encryption		*/
/* algorithm submitted by Richard Outerbridge and Lars Knudsen as	*/
/* a candidate the NIST AES programme.								*/
/*																	*/
/* Copyright in this implementation is held by Dr B R Gladman but	*/
/* I hereby give permission for its free direct or derivative use	*/
/* subject to aks_keynowledgment of its origin and compliance with	*/
/* any constraints that are placed on the exploitation of DEAL by	*/
/* its designers.													*/
/*																	*/
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 30th Noveember 98	*/

/* Timing Data:

Algorithm: deal (deal0.c)

128 bit key:
Key Setup:    8777 cycles
Encrypt:      2833 cycles =     9.0 mbits/sec
Decrypt:      2836 cycles =     9.0 mbits/sec
Mean:         2835 cycles =     9.0 mbits/sec
192 bit key:
Key Setup:    8812 cycles
Encrypt:      2833 cycles =     9.0 mbits/sec
Decrypt:      2833 cycles =     9.0 mbits/sec
Mean:         2833 cycles =     9.0 mbits/sec
256 bit key:
Key Setup:   11745 cycles
Encrypt:      3758 cycles =     6.8 mbits/sec
Decrypt:      3757 cycles =     6.8 mbits/sec
Mean:         3757 cycles =     6.8 mbits/sec

*/

#include "../std_defs.h"
#include "../des/des.h"

static char	*alg_name[] = { "deal", "deal0.c" };

char **cipher_name()
{
	return alg_name;
}

u4byte  ks_key[2] = { 0x67452301, 0xefcdab89 };

u4byte	ks_ks[32];	/* storage for the local key schedule	*/
u4byte	ks_init = 0;

u4byte	k_len;		/* copy of key_length					*/ 
u4byte	l_key[256];	/* storage for key schedule				*/

/* initialise the key schedule from the user supplied key	*/

u4byte *set_key(const u4byte key_blk[], const u4byte key_len)
{	u4byte	lk[2];

	if(!ks_init)
	{
		des_ky(ks_key, ks_ks); ks_init = 1;
	}

	k_len = (key_len + 63) / 64;

	switch(k_len)
	{
		case 2:
			lk[0] = key_blk[0]; 
			lk[1] = key_blk[1]; 
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key);

			lk[0] ^= key_blk[2]; 
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key + 32);
			  
			lk[0] ^= key_blk[0] ^ 0x00000080;  
			lk[1] ^= key_blk[1];
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key + 64);
			  
			lk[0] ^= key_blk[2] ^ 0x00000040;  
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key + 96);
			  
			lk[0] ^= key_blk[0] ^ 0x00000020;  
			lk[1] ^= key_blk[1];
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key + 128);
			  
			lk[0] ^= key_blk[2] ^ 0x00000010;  
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key + 160);
			break;
		case 3:
			lk[0] = key_blk[0]; 
			lk[1] = key_blk[1]; 
			des_ec(lk, lk, ks_ks); 
			des_ky(lk, l_key);

			lk[0] ^= key_blk[2]; 
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 32);
			  
			lk[0] ^= key_blk[4];  
			lk[1] ^= key_blk[5];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 64);
			  
			lk[0] ^= key_blk[0] ^ 0x00000080;  
			lk[1] ^= key_blk[1];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 96);
			  
			lk[0] ^= key_blk[2] ^ 0x00000040;  
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 128);
			  
			lk[0] ^= key_blk[4] ^ 0x00000020;  
			lk[1] ^= key_blk[5];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 160);
			break;
		case 4:
			lk[0] = key_blk[0]; 
			lk[1] = key_blk[1]; 
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key);

			lk[0] ^= key_blk[2]; 
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 32);
			  
			lk[0] ^= key_blk[4];  
			lk[1] ^= key_blk[5];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 64);
			  
			lk[0] ^= key_blk[6];  
			lk[1] ^= key_blk[7];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 96);
			  
			lk[0] ^= key_blk[0] ^ 0x00000080;  
			lk[1] ^= key_blk[1];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 128);
			  
			lk[0] ^= key_blk[2] ^ 0x00000040;  
			lk[1] ^= key_blk[3];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 160);
			lk[0] ^= key_blk[4] ^ 0x00000020;  
			lk[1] ^= key_blk[5];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 192);
			  
			lk[0] ^= key_blk[6] ^ 0x00000010;  
			lk[1] ^= key_blk[7];
			des_ec(lk, lk, ks_ks); des_ky(lk, l_key + 224);
			break;
	}	
	return l_key;
};

/* encrypt a bloks_key of text	*/

void encrypt(const u4byte in_blk[4], u4byte out_blk[4])
{	u4byte	a[2], b[2], c[2];

	a[0] = in_blk[0]; a[1] = in_blk[1];
	b[0] = in_blk[2]; b[1] = in_blk[3];

	des_ec(a, c, l_key +   0); b[0] ^= c[0]; b[1] ^= c[1];
	des_ec(b, c, l_key +  32); a[0] ^= c[0]; a[1] ^= c[1];

	des_ec(a, c, l_key +  64); b[0] ^= c[0]; b[1] ^= c[1];
	des_ec(b, c, l_key +  96); a[0] ^= c[0]; a[1] ^= c[1];

	des_ec(a, c, l_key + 128); b[0] ^= c[0]; b[1] ^= c[1];
	des_ec(b, c, l_key + 160); a[0] ^= c[0]; a[1] ^= c[1];

	if(k_len == 4)
	{
		des_ec(a, c, l_key + 192); b[0] ^= c[0]; b[1] ^= c[1];
		des_ec(b, c, l_key + 224); a[0] ^= c[0]; a[1] ^= c[1];
	}

	out_blk[0] = a[0]; out_blk[1] = a[1];
	out_blk[2] = b[0]; out_blk[3] = b[1];
};

/* decrypt a bloks_key of text	*/

void decrypt(const u4byte in_blk[4], u4byte out_blk[4])
{	u4byte	a[2], b[2], c[2];

	a[0] = in_blk[0]; a[1] = in_blk[1];
	b[0] = in_blk[2]; b[1] = in_blk[3];

	if(k_len == 4)
	{
		des_ec(b, c, l_key + 224); a[0] ^= c[0]; a[1] ^= c[1];
		des_ec(a, c, l_key + 192); b[0] ^= c[0]; b[1] ^= c[1];
	}

	des_ec(b, c, l_key + 160); a[0] ^= c[0]; a[1] ^= c[1];
	des_ec(a, c, l_key + 128); b[0] ^= c[0]; b[1] ^= c[1];

	des_ec(b, c, l_key +  96); a[0] ^= c[0]; a[1] ^= c[1];
	des_ec(a, c, l_key +  64); b[0] ^= c[0]; b[1] ^= c[1];

	des_ec(b, c, l_key +  32); a[0] ^= c[0]; a[1] ^= c[1];
	des_ec(a, c, l_key +   0); b[0] ^= c[0]; b[1] ^= c[1];

	out_blk[0] = a[0]; out_blk[1] = a[1];
	out_blk[2] = b[0]; out_blk[3] = b[1];
};