#include "lib4.h"
#include "lib3.h"
#include "lib2.h"
#include "lib.h"
/**
  * encrypt always with the same key, same nonce?
  *
  **/
int aes_ctr_edit(char *ciphertext, int ciphertext_length, int offset, char *newtext)
{
	// do not allow greater ciphertexts
	if((strlen(newtext)+offset) > ciphertext_length)
		return 1;
		
	// insert newtext at offset and reencrpyt
	char *plaintext = malloc(ciphertext_length);
	aes_ctr(ciphertext, ciphertext_length, plaintext, key, nonce);
	memcpy(&plaintext[offset], newtext, strlen(newtext));

	aes_ctr(plaintext, ciphertext_length, ciphertext, key, nonce);
	return 0;
}


unsigned int left_rotate(int shift, int value)
{
	// TODO make use of the x86 instruction rol, ror
	unsigned int ret = value;
	unsigned int mask = 0xFFFFFFFF << shift;
	ret = ret << shift;
	ret |= ((value & mask) >> (32-shift));
	return ret;
}

void sha1_helper_copy_chunk(char *chunk, int *dest)
{
	int i;
	for(i=0;i<16;i++) {
		memcpy(&dest[i], &chunk[i], 4);
	}
}

void sha1_hash(char *text, int text_length)
{
	unsigned char *padding;
	char *hash;
	int padding_len = sha1_padding(text_length, &padding);

	char *to_hash = malloc(text_length + padding_len);

	memcpy(to_hash, text, text_length);
	memcpy(&to_hash[text_length], padding, padding_len);
	hash_sha1_core(to_hash, (text_length + padding_len), &hash);
	int i;
	for(i=0;i<64;i++)
		printf("%02x", hash[i]);
	printf("\n");
}

void hash_sha1_core(char *text, int text_length, char **sha1_hash)
{
	*sha1_hash = malloc(20);
	int i,j;
	unsigned int h0 = 0x67452301;
	unsigned int h1 = 0xEFCDAB89;
	unsigned int h2 = 0x98BADCFE;
	unsigned int h3 = 0x10325476;
	unsigned int h4 = 0xC3D2E1F0;

	unsigned int temp;
	int chunks = (text_length*8) / 512;
	unsigned int w[80];
	unsigned int a,b,c,d,e,f,k;
	char *chunk;

	for(i=0;i<chunks;i++) {
		// chunk is text[i*512]
		// fill the first w[0]...w[15]
		sha1_helper_copy_chunk(&text[i*512], w);

		for(j=16;j<80;j++) {
			w[j] = (w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16]);
			w[j] = left_rotate(1, w[j]);
		}

		a = h0;
		b = h1;
		c = h2;
		d = h3;
		c = h4;

		for(j=0;j<80;j++) {
			if (i >= 0 && i <= 19) {
				f = (b & c) | ((~b) & d);
				k = 0x5A827999;
			}
			else if (i >= 20 && i <= 39) {
				f = b ^ c ^ d;
				k = 0x6ED9EBA1;
			}
			else if (i>= 40 && i <= 59) {
				f = (b & c) | (b & d) | (c & d);
				k = 0x8F1BBCDC;
			}
			else if (i >= 60 && i <= 79) {
				f = b ^ c ^ d;
				k = 0xCA62C1D6;
			}

			temp = left_rotate(5 ,a);
			temp += f + e + k + w[j];
			e = d;
			d = c;
			c = left_rotate(30, b);
			b = a;
			a = temp;

		}

		h0 += a;
		h1 += b;
		h2 += c;
		h3 += d;
		h4 += e;
	}

	// copy h_i into sha_hash
	memcpy(*sha1_hash, &h0, 4);
	memcpy(&((*sha1_hash)[4]), &h1, 4);
	memcpy(&((*sha1_hash)[8]), &h2, 4);
	memcpy(&((*sha1_hash)[12]), &h3, 4);
	memcpy(&((*sha1_hash)[16]), &h4, 4);
}

void sha1_set_magic_nr(SHA1Context *sh, unsigned int *magic)
{
	sh->Message_Digest[0] = magic[0];
	sh->Message_Digest[1] = magic[1];
	sh->Message_Digest[2] = magic[2];
	sh->Message_Digest[3] = magic[3];
	sh->Message_Digest[4] = magic[4];
}


void sha1_hmac(unsigned int *mac, unsigned char *message, unsigned int msg_len,
		unsigned char *key, unsigned int key_len)
{
	char *res = malloc(msg_len + key_len);

	memcpy(res, key, key_len);
	memcpy(&res[key_len], message, msg_len);

	SHA1Context sh;

	SHA1Reset(&sh);

	SHA1Input(&sh, res, (msg_len + key_len));
	SHA1Result(&sh);

	memcpy(mac, &(sh.Message_Digest), 20);
}

int sha1_hmac_verify(unsigned int *mac, unsigned char *msg, unsigned int msg_len,
		unsigned char *key, unsigned int key_len)
{
	unsigned int com_mac[5];

	sha1_hmac(com_mac, msg, msg_len, key, key_len);

	printf("mac of msg is:\n");
	int i;
	for(i=0;i<5;i++)
		printf("%02x", com_mac[i]);
	printf("\n");
	printf("to compate with\n");
	for(i=0;i<5;i++)
		printf("%02x", mac[i]);
	printf("\n");

	return !memcmp(com_mac, mac, 20);

}

int sha1_padding(unsigned long msg_len, unsigned char **result)
{
	int i;
	unsigned int padding_len = 64 - (msg_len % 64);
	// enough sapce for the length of the message?
	padding_len = padding_len < 9 ? padding_len+64 : padding_len;

	(*result) = malloc(padding_len);

	memset((*result), 0x00, padding_len);
	// append 1
	(*result)[0] = 0x80;

	// write the 8 byte msg_len at the end bytewise
	for(i=0;i<8;i++) {
		(*result)[padding_len-i-1] = (msg_len*8 >> (i*8)) & 0xFF;
	}

	return padding_len;
}

void sha1_hmac_forge(unsigned int *mac, unsigned char *text, unsigned int text_len,
		unsigned int *sha1_registers)
{
	SHA1Context sh;
	SHA1Reset_Mod(&sh, sha1_registers);


	SHA1Input(&sh, text, text_len);
	SHA1Result_Forged(&sh);

	memcpy(mac, &(sh.Message_Digest), 20);
}

void md4_prefix_key_mac(uint32_t **mac, unsigned char *text, unsigned int text_len,
		unsigned char *key, unsigned int key_len)
{
	char *res = malloc(text_len + key_len);

	memcpy(res, text, text_len);
	memcpy(res+text_len, key, key_len);

	MD4(res, (text_len + key_len), mac, NULL);
}

int md4_prefix_key_verify(uint32_t *mac, unsigned char *text, unsigned int text_len,
		unsigned char *key, unsigned int key_len)
{
	uint32_t *hash;

	MD4(text, text_len, &hash, NULL);
	printf("computed mac is:\n");
	int i;
	for(i=0;i<4;i++)
		printf("%02x", hash[i]);
	printf("\n");
	return !memcmp(hash, mac, 4*sizeof(uint32_t));
}

void md4_prefix_key_forge(uint32_t **mac, unsigned char *text, unsigned int text_len,
		unsigned int *md4_registers)
{
	MD4(text, text_len, mac, md4_registers);
}
 
uint32_t stringToUint32(char *s){
	uint32_t l;
	int i;
	l=0;
	for(i=0; i<4; i++){
		l = l|(((uint32_t)((unsigned char)s[i]))<<(8*(3-i)));
	}
	return l;
}

uint32_t changeEndianness(uint32_t x){
	return ((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24);
}

int md4_padding(unsigned long msg_len, unsigned char **result)
{
	int len = sha1_padding(msg_len, result);
	int i;
	//change endianess
	for(i=0;i<len;i+=4)
		(*result)[i] = changeEndianness(stringToUint32(&(*result)[i]));

	return len;
}