#include <stdio.h> 
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>

//-----------------------------------------
// Swap Values
// 
#define swap(X,Y) { uint8_t T = X; X = Y; Y = T; }

//  Returns 1 if LITTLE-ENDIAN or 0 if BIG-ENDIAN 
#include <inttypes.h>
int is_little_endian() {
  union { uint8_t c[4]; uint32_t i; } data;
  data.i = 0x12345678;
  return (data.c[0] == 0x78);
}

static uint8_t  a, b, c, d, j;
static uint8_t  SBox[256];

void SBox8_PIA(uint32_t seed);
void SBox8_KSA(uint8_t key[], uint16_t keyLen);
uint8_t  SBox8_PRGA();

//-----------------------------------------
// PIA = Permutation Initialisation Algorithm
//
void SBox8_PIA(uint32_t seed) {
	
	if (seed == 0) {
		a = 14;
		b = 59;
		c = 23;
		d = 77;	
	} else {	
		a = ( seed        & 0xff);
		b = ((seed >>  8) & 0xff);
		c = ((seed >> 16) & 0xff);
		d = ((seed >> 24) & 0xff);
	}
	
	// Shifting to the next odd Value of each Variable
	// in Order to generate an alternating Permutation
	uint8_t t = ((b ^ c) + d);
	t |= 1;

	// Initialise the alternating Permutation
	for (int i=0; i<256; i++) {
		a += t;
		SBox[i] = a;
	}
}


//-----------------------------------------
// KSA = Key Schedule Algorithm
//
void SBox8_KSA(uint8_t key[], uint16_t keyLen) {
	
	// Shuffle the key into the Permutation
	for (int i=0; i<256; i++) {
		d  = i % keyLen;
		
		a += SBox[b];
		b += SBox[a];
		c  = a + b + i + key[d];
		
		swap(SBox[c], SBox[i]);		
	}
	
	j=0;
}


//-----------------------------------------
// PRGA = Pseudo-Random Generation Algorithm
//
uint8_t SBox8_PRGA() {
	a += SBox[b];
	b += SBox[a];
	c  = a + b + j + SBox[j];
	
	swap(SBox[c], SBox[j]);		
	
	d  = SBox[(SBox[c] + SBox[d]) &0xff];
	
	j++;
	
	return ((a + b) ^ (c + d));
}

//----------------------------------------------------------------------------
// SBox8 8bit Hash
void p8(const void *data, int len, uint32_t seed, void *out) {
	const uint8_t * dataByte = (const uint8_t*)data;
	
	// DEBUG
	uint8_t debug = 0;
	
	if (debug) {
		fprintf(stderr, "\n-------------------------------\n");
		fprintf(stderr, "seed ==> %08x\n", seed);

		fprintf(stderr, "data ==> ");
		
		for (int n=0; n<len; n++) {
			fprintf(stderr, "%02x", dataByte[n]);
		}
		fprintf(stderr, "\n");
	}
	
	// Desired Hash Size in Byte
	uint8_t hSize = 8;
	// Hash Result Array
	uint8_t h[hSize];
	memset(h, 0, sizeof(h));

	uint8_t Key[256];
	uint16_t keyLen = 256;
	memset(Key, 0, sizeof(Key));
	
	// If a Seed is passed, but no Key, use the Seed additionally as Initial Key
	if (seed == 0){
		// no Seed, no Key, just initialise the SBoxes
		SBox8_PIA(0);
	}
	else {
		// Build the Key[]
		Key[0] = ((seed >> 24) & 0xff);
		Key[1] = ((seed >> 16) & 0xff);
		Key[2] = ((seed >>  8) & 0xff);
		Key[3] = ( seed        & 0xff);
				
		// Initialisation of SBoxes
		SBox8_PIA(seed);
		
		// Shuffle the Key into the SBox Permutation
		SBox8_KSA(Key, 4);	
	}
	
	// Reset the Key Length
	keyLen = 256;

	// Offset for j
	j = 0;
	
	// Hash the Content
	for (int i=0; i<len; i++) {
		// Inject the Data into the internal State
		a += b + dataByte[i];
		
		// Collect the Key Byte
		Key[j] ^= SBox[a];
		
		// Update the internal State
		SBox8_PRGA();
		
		//if (debug) fprintf(stderr, "c=%3d j=%3d SBox[c]=%3d SBox[j]=%3d\n", c, j, SBox[c], SBox[j]);
	}
	
	// First Drop of the complete Internal State
	for (int i=0; i<256; i++) SBox8_PRGA();
	
 	// Update the Key
	for (int i=0; i<keyLen; i++) Key[i] ^= SBox8_PRGA();
	if (debug) for (int i=0; i<keyLen; i++) fprintf(stderr, "%02x:", Key[i]);
	if (debug) fprintf(stderr, "\n");
	
	//  Shuffle the Key into the SBox8 Permutation
  SBox8_KSA(Key, keyLen);
	if (debug) for (int i=0; i<keyLen; i++) fprintf(stderr, "%02x:", SBox[i]);;
	if (debug) fprintf(stderr, "\n");
	
  // Second Drop of the complete Internal State
  // in Order to have a poper Avalanche Effect
  for (int i=0; i<(hSize*8); i++) SBox8_PRGA();
	
	// Final Hash Output
	uint32_t hash = 0; 
	uint8_t k=0;
	
 for (int i=0; i<hSize; i++) h[i] = SBox8_PRGA();
	
	if (debug) fprintf(stderr, "hash ==> ");
	
	for (int i=0; i<hSize; i++) {
		if (debug) fprintf(stderr, "%02x", h[i]);

		if (is_little_endian()) {
			// Hash Output (LittleInt32)
			hash = hash | (uint32_t)h[i] << ((i%4)*8);
		} else {
			// Hash Output (BigInt32)
			hash = hash | (uint32_t)h[i] << ((hSize-1-(i%4))*8);
		}		
		
		if (((i+1)%4) == 0) {
			//if (debug) fprintf(stderr, "%08x", hash);
			((uint32_t*)out)[k] = hash;
			//if (debug) fprintf(stderr, "%08x", ((uint32_t*)out)[k]);
			k++;
			hash = 0;
		}
	}
	
	if (debug) {
		fprintf(stderr, "\n");
		sleep(1);
	}
}