#include<stdio.h>
#include<stdint.h>
#include<fcntl.h>
#include<unistd.h>

uint64_t undo_permute(uint64_t block){
	uint64_t result;
	char* result_bytes = (char*)&result;
	char* input_bytes = (char*)&block;
	result_bytes[2] = input_bytes[0];
	result_bytes[5] = input_bytes[1];
	result_bytes[1] = input_bytes[2];
	result_bytes[4] = input_bytes[3];
	result_bytes[7] = input_bytes[4];
	result_bytes[3] = input_bytes[5];
	result_bytes[6] = input_bytes[6];
	result_bytes[0] = input_bytes[7];
	return result;
}

uint64_t permute(uint64_t block){
	uint64_t result;
	char* result_bytes = (char*)&result;
	char* input_bytes = (char*)&block;
	result_bytes[0] = input_bytes[2];
	result_bytes[1] = input_bytes[5];
	result_bytes[2] = input_bytes[1];
	result_bytes[3] = input_bytes[4];
	result_bytes[4] = input_bytes[7];
	result_bytes[5] = input_bytes[3];
	result_bytes[6] = input_bytes[6];
	result_bytes[7] = input_bytes[0];
	return result;
}

uint64_t transform_key(uint64_t key){
	key = permute(key);
	uint64_t t1 = (key * key ^ key);
	t1 += (t1 << 31 & t1);
	return t1;
}

uint64_t encrypt_block(uint64_t plaintext, uint64_t iv, uint64_t key){
	plaintext ^= iv;
	plaintext += transform_key(key);
	return permute(plaintext);	
}

uint64_t decrypt_block(uint64_t ciphertext, uint64_t iv, uint64_t key){
	uint64_t in_process = undo_permute(ciphertext);
	in_process -= transform_key(key);
	return in_process ^ iv;
}

int main(){
	uint64_t iv;
	int rfd = open("/dev/random", O_RDONLY);
	read(rfd, &iv, 8);
	close(rfd);
	uint64_t p1 = 123456788;
	uint64_t key = 147;
	/* Loop through every block in the file:
	 * 	p1 = next block
	 * 	iv = previous block (encrypted)
	 * 	key stays the same
	 */
	uint64_t test = encrypt_block(p1, iv, key);
	printf("Initialization Vector:  %lu\n", iv);
	printf("Encrypted:  %lu\n", test);
	uint64_t r1 = decrypt_block(test, iv, key);
	printf("Decrypted:  %lu\n", r1);
	return 0;
}