hi

//============================================================================
// Name        : wolfssl_SHA256.cpp
// Author      :
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <wolfssl/wolfcrypt/sha256.h>
#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>

typedef unsigned char byte;
typedef unsigned char uint8_t;
const int SHA256_HASH_BYTES = 32;

uint8_t password[] = {										// heslo 32bytu
	        'D', 'i', 'p', 'l', 'o', 'm', 'o', 'v',
	        'a', 'P', 'r', 'a', 'c', 'e', '2', '0',
	        '1', '8', 'V', 'U', 'T', 'F', 'E', 'K',
	        'T', 'B', 'r', 'n', 'o', 'P', 'C', 'h'};
uint8_t message[37];
uint8_t messageFromServer[34];
uint8_t keySession[SHA256_HASH_BYTES];
uint8_t id[] = {0x11, 0x12, 0x13, 0x14};                    /// id   4 byty
long int secventionNumber = 0x12345678;					// sekvenční server ....n  ...4 byty

int send()												// simulace odesilani
{
	return 1;
}

void imagMessage02()				// fiktivní přijetí zprávy 0x02 od serveru (vytvoření této zprávy)    client<- server  0x02,OK,h(0x02,OK,heslo,n+1)
{
	uint8_t messageHash[42];
	uint8_t hash[SHA256_HASH_BYTES];

	int i, j;

	for(i = 0; i < sizeof(messageFromServer); i++)		//nulování proměných
	{
		messageFromServer[i] = 0x00;
	}

	for(i = 0; i < sizeof(messageHash); i++)
	{
		messageHash[i] = 0x00;
	}
														// přidání návěští a stavu OK
	messageFromServer[0] = 0x02;
	messageFromServer[1] = 0x01;

	messageHash[0] = 0x02;
	messageHash[1] = 0x01;
														// přidání hesla
	for(j = 0; j < sizeof(password); j++)
	{
		messageHash[j+2] = password[j];
	}
														// přidání sekvenčního čísla
	messageHash[j+2] = ((secventionNumber+1) & 0xFF000000) >> 4*6;
	messageHash[j+3] = ((secventionNumber+1) & 0x00FF0000) >> 4*4;
	messageHash[j+4] = ((secventionNumber+1) & 0x0000FF00) >> 4*2;
	messageHash[j+5] = ((secventionNumber+1) & 0x000000FF);
														// zahashování
	Sha256 sha;
	wc_InitSha256(&sha);
	wc_Sha256Update(&sha, messageHash, sizeof(messageHash));
	wc_Sha256Final(&sha, hash);

	for(i = 0; i < sizeof(hash); i++)					// spojení hashe se zprávu
	{
		messageFromServer[i+2] = hash[i];
	}
}

void createMessage01()    /// client-> server  0x01,ID,h(0x01,ID,heslo,n)
{
	uint8_t messageHash[45];
	uint8_t hash[SHA256_HASH_BYTES];

	int i, j;

	for(i = 0; i < sizeof(messageHash); i++) // nulování proměných ( pracovní )
	{
		messageHash[i] = 0x00;
	}

	for(i = 0; i < sizeof(message); i++)
	{
		message[i] = 0x00;
	}

	messageHash[0] = 0x01;    				// přidání návěští
	message[0] = 0x01;


	for(i = 0; i < sizeof(id); i++)			// přidání ID klienta
	{
		messageHash[i+1] = id[i];
		message[i+1] = id[i];
	}

	for(j = 0; j < sizeof(password); j++)	//  přidání hesla
	{
		messageHash[i+j+1] = password[j];
	}

	messageHash[i+j+1] = (secventionNumber & 0xFF000000) >> 4*6;    // přidání sekvenčního čísla (nutno postupně bitově šoupat při ukládání)
	messageHash[i+j+2] = (secventionNumber & 0x00FF0000) >> 4*4;
	messageHash[i+j+3] = (secventionNumber & 0x0000FF00) >> 4*2;
	messageHash[i+j+4] = (secventionNumber & 0x000000FF);
			// hash

	Sha256 sha;
	wc_InitSha256(&sha);
	wc_Sha256Update(&sha, messageHash, sizeof(messageHash));
	wc_Sha256Final(&sha, hash);

	for(j = 0; j < sizeof(hash); j++)								// spojení hashe se zprávou
	{
		message[i+j+1] = hash[j];
	}

}

int verify02()												// Ověření přijaté zprávy clientem a ustanovené SessionKey pri uspesne autentizaci
{															// client<- server  0x02,OK,h(0x02,OK,heslo,n+1)
	if(messageFromServer[0] != 0x02)									// ověření návěští zprávy
		return -1;

	if(messageFromServer[1] == 0x01)									// ověření stavu autentizace od servru
	{
													// OK //  zaslaná data servru byla správná a ověřena

		uint8_t messageHash[42];
		uint8_t keySessionMessageHash[64];
		uint8_t hash[SHA256_HASH_BYTES];

		int i, j;

		for(i = 0; i < sizeof(messageHash); i++) 		///  nulování proměných
		{
			messageHash[i] = 0x00;
		}
										///// vytvoření hashe pro ověření otisku od servru ....
		messageHash[0] = 0x02;								// přidání návěští
		messageHash[1] = 0x01;								// přidání stavu OK

		for(j = 0; j < sizeof(password); j++)			// přidání hesla
		{
			messageHash[j+2] = password[j];
		}
															// přidání sekvenčního čísla
		messageHash[j+2] = ((secventionNumber+1) & 0xFF000000) >> 4*6;
		messageHash[j+3] = ((secventionNumber+1) & 0x00FF0000) >> 4*4;
		messageHash[j+4] = ((secventionNumber+1) & 0x0000FF00) >> 4*2;
		messageHash[j+5] = ((secventionNumber+1) & 0x000000FF);
		// hash

		Sha256 sha;
		wc_InitSha256(&sha);
		wc_Sha256Update(&sha, messageHash, sizeof(messageHash));
		wc_Sha256Final(&sha, hash);

		for(i = 0; i < sizeof(keySession); i++)				// nulování proměné
		{
			keySession[i] = 0x00;
		}
																// srovnání příchozího a vytvořeného otisku
		for(i = 0; i < sizeof(hash); i++)
		{
			if(hash[i] != messageFromServer[i+2])
				return -3; 									//  neshoda otisku

			keySessionMessageHash[i] = hash[i];				// překopírovávání hahe ze zprávy 0x02 do proměnné pro výpočet hashe pro keySession
		}

		for(j = 0; j < sizeof(password); j++)
		{
			keySessionMessageHash[i+j+1] = password[j];		// přidání hesla do proměnné pro výpočet hashe pro keySession
		}
		// výpočet keySession
		Sha256 sha2;
		wc_InitSha256(&sha2);
		wc_Sha256Update(&sha2, keySessionMessageHash, sizeof(keySessionMessageHash));
		wc_Sha256Final(&sha2, keySession);

		secventionNumber++;
		return 1;											// uspěšná autentizace
	}
	else
	{
		// ERROR //
		return -2;											// příchozí stav ERROR od servru
	}
}

int authentication()
{
/*mereni*/
	struct timeval start, stop;
	double secs1 = 0;
	double secs2 = 0;
	double secs3 = 0;

	int i = 0;

/*start měření vytvoreni zpravy na klientoovi*/
	gettimeofday(&start, NULL);

	createMessage01();  				  //vytvoření zprávy 0x01         client-> server  0x01,ID,h(0x01,ID,heslo,n)

	gettimeofday(&stop, NULL);
	secs1= ( (double)(stop.tv_usec - start.tv_usec) + (double)(stop.tv_sec - start.tv_sec)*1000000 );
/*konec mereni vytvoreni zpravy na klientoovi*/

	send();				 				  // fiktivní odeslání zprávy 0x01

/* start mereni vytvoreni zpravy na serveru*/
	gettimeofday(&start, NULL);

	imagMessage02();	  // fiktivní přijetí zprávy 0x02 od serveru (vytvoření této zprávy)

	gettimeofday(&stop, NULL);
	secs2= ( (double)(stop.tv_usec - start.tv_usec) + (double)(stop.tv_sec - start.tv_sec)*1000000 );
/* konec mereni vytvoreni zpravy na serveru*/

/* start mereni overeni zpravy na clientovi*/
	gettimeofday(&start, NULL);

	int retVal =  verify02();

	gettimeofday(&stop, NULL);
	secs3= ( (double)(stop.tv_usec - start.tv_usec) + (double)(stop.tv_sec - start.tv_sec)*1000000 );
/* konec mereni overeni zpravy na clientovi*/

    printf("Čas vytvoření zprávy 0x01 na klientoovi: %f\n",secs1);
    printf("Čas vytvoření zprávy 0x02 na serveru: %f\n",secs2);
    printf("Čas ověření zprávy na klientovi: %f\n",secs3);

	return retVal;	 				  // Ověření přijaté zprávy clientem a ustanovené SessionKey pri uspesne autentizaci       client<- server  0x02,OK,h(0x02,OK,heslo,n+1)
}


void print_hex_memory(void *mem, unsigned length) {
	printf("Heslo pro šifrovanou komunikaci uložené v keySession: \n");
    byte *p = (byte *) mem;
    for (unsigned i = 0; i < length; i++) {
        printf("%02x", p[i]);
    }
}

int main(void) {
	int vysledek = 0;

	vysledek = authentication();

	if(vysledek == 1){
		printf("\n Autentizace proběhlo úspěšně, v proměnné keySession je ustanovené heslo pro následnou šifrovanou komunikaci.");
		// keySession v této proměnné je to heslo které slouží pro normalní komunikaci přes šifru
		printf("\n ");
		print_hex_memory(&keySession, 32);
	 } else if (vysledek == -2){
		 printf("\n Server pokus o autentizaci odmítnul.");
	 } else if (vysledek == -3){
		 printf("\n Odpověď od serveru se neshoduje s odpovědí, kterou očekávám, tedy autentizace neśpěšná.");
	 }
    return 0;
}