bakalarska_praca/kniznica/kryptografia.c

//////////////////////////////////////////////////
// Bakalarska praca                             //
// Meno studenta: Tomas Lukac                   //
// Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
// Skola: KEMT FEI TUKE                         //
// Datum poslednej upravy: 6.5.2020             //
//////////////////////////////////////////////////

#include "kryptografia.h"
#include <wolfssl/user_settings.h>


WOLFSSL_CTX* nastavit_ctx_klient()
{
  WOLFSSL_METHOD* method;
  wolfSSL_Init();
  method = wolfTLSv1_2_client_method();
  WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
  if (ctx == NULL) 
  {
    printf("Nepodarilo sa inicializovat WOLFSSL_CTX\n");
    return NULL;
  }
  return ctx;
}
 
WOLFSSL_CTX* nastavit_ctx_server()
{
  WOLFSSL_METHOD* method;
  wolfSSL_Init();
  method = wolfTLSv1_2_server_method();
  WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);

  if (ctx == NULL) 
  {
    printf("Nepodarilo sa inicializovat WOLFSSL_CTX\n");
    return NULL;
  }
  return ctx;
}

void nastav_typ_aplikacie(nastavenia_aplikacie* nastavenia, typ_aplikacie typ_a)
{
  nastavenia->typ_a = typ_a;
}

void nastav_sifry(WOLFSSL_CTX* ctx, const char* sifry)
{
  wolfSSL_CTX_set_cipher_list(ctx, sifry);
}

void nastav_funkciu(nastavenia_aplikacie* nastavenia, char* typ_vypoctu, hashovacia_funkcia h_funkcia, crc_funkcia c_funkcia)
{
  strcpy(nastavenia->typ_vypoctu, typ_vypoctu);
  if(!strcmp(typ_vypoctu, "hash"))
  {
    nastavenia->h_funkcia = h_funkcia;
  }
  else if(!strcmp(typ_vypoctu, "crc"))
  {
    nastavenia->c_funkcia = c_funkcia;
  }
  else
  {
    fprintf(stderr, "Nepodarilo sa nastavit funkciu pre vypocet kontrolneho suctu.\n");
  }
}

void zobraz_sifru(WOLFSSL* ssl)
{
  printf ("Pouzita sifra: %s\n", wolfSSL_get_cipher(ssl));
}

int generovat_rsa_certifikat(const char* subor_certifikat, const char* subor_kluc, int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
{
  int uspech = 0;

  //premenne pre ukladanie dat autority
  RsaKey kluc_autorita;
  byte der_autorita_certifikat[VELKOST_BUFFERA];
  int der_autorita_certifikat_velkost;
  byte der_autorita_kluc[VELKOST_BUFFERA];
  int der_autorita_kluc_velkost;
  
  //nacitanie certifikatu autority vo formate DER ulozeneho v subore certifikaty/autorita/autorita_rsa.der
  printf("Nacitavanie certifikatu autority zo suboru.\n");
  FILE* subor = fopen("../../certifikaty/autorita/autorita_rsa.der", "rb");
  der_autorita_certifikat_velkost = fread(der_autorita_certifikat, 1, VELKOST_BUFFERA , subor);
  if(der_autorita_certifikat_velkost < 0)
  {
    fprintf(stderr, "Nepodarilo sa nacitat obsah suboru. \n");
    return -1;
  }
  fclose(subor);
  printf("Nacitanie ukoncene. Bolo nacitanych %d bajtov.\n", der_autorita_certifikat_velkost);

  //vytvorenie struktury RsaKey autority zo sukromneho kluca vo formate DER ulozeneho v subore certifikaty/autorita/autorita_kluc_rsa.der
  printf("Nacitavanie sukromneho kluca autority zo suboru.\n");
  subor = fopen("../../certifikaty/autorita/autorita_kluc_rsa.der", "rb");
  der_autorita_kluc_velkost = fread(der_autorita_kluc, 1, VELKOST_BUFFERA , subor);
  if(der_autorita_kluc_velkost < 0)
  {
    fprintf(stderr, "Nepodarilo sa nacitat obsah suboru. \n");
    return -1;
  }
  fclose(subor);
  printf("Nacitanie ukoncene. Bolo nacitanych %d bajtov.\n", der_autorita_kluc_velkost);
  
  word32 index = 0; //nastavi odkial zacat citat buffer
  wc_InitRsaKey(&kluc_autorita, 0);
  uspech = wc_RsaPrivateKeyDecode(der_autorita_kluc, &index, &kluc_autorita, der_autorita_kluc_velkost);
  if(uspech != 0)
  {
    fprintf(stderr, "Nepodarilo sa vytvorit RsaKey strukturu z kluca autority\n");
    return -1;
  }
  
  //generator nahodnych cisel
  WC_RNG generator;
  wc_InitRng(&generator);
  
  //premenne pre ukladanie dat vygenerovaneho kluca
  RsaKey kluc;
  byte der_kluc[VELKOST_BUFFERA];
  word32 der_kluc_velkost;
  byte pem_kluc[VELKOST_BUFFERA];
  word32 pem_kluc_velkost;

  //vygenerovanie kluca
  wc_InitRsaKey(&kluc, 0);
  uspech = wc_MakeRsaKey(&kluc, pocet_bitov, exponent, &generator);
  if(uspech != 0)
  {
    fprintf(stderr, "Chyba pri generovani kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_RsaKeyToDer(&kluc, der_kluc, sizeof(der_kluc));
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\n");
    return -1;
  }
  der_kluc_velkost = uspech;
  memset(pem_kluc, 0, sizeof(pem_kluc));
  uspech = wc_DerToPem(der_kluc, der_kluc_velkost, pem_kluc, sizeof(pem_kluc), PRIVATEKEY_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so sukromnym klucom\n");
    return -1;
  }
  pem_kluc_velkost = uspech;

  //zapis vygenerovaneho klucu do suboru
  subor = fopen(subor_kluc, "wb+");
  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
  fclose(subor);
  
  printf("RSA kluc bol uspesne vygenerovany.\n");
  
  //premenne pre ukladanie dat certifikatu
  Cert certifikat;
  byte der_certifikat[VELKOST_BUFFERA];
  word32 der_certifikat_velkost;
  byte pem_certifikat[VELKOST_BUFFERA];
  word32 pem_certifikat_velkost;

  //vygenerovanie a podpis certifikatu
  wc_InitCert(&certifikat);
  strncpy(certifikat.subject.country, krajina, CTC_NAME_SIZE);
  strncpy(certifikat.subject.state, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.locality, mesto, CTC_NAME_SIZE);
  strncpy(certifikat.subject.org, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.unit, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.commonName, domena, CTC_NAME_SIZE);
  strncpy(certifikat.subject.email, email, CTC_NAME_SIZE);
  certifikat.isCA = 0;
  certifikat.sigType = algoritmus;
  certifikat.daysValid = 1825;
  uspech = wc_SetIssuerBuffer(&certifikat, der_autorita_certifikat, der_autorita_certifikat_velkost);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri nastaveni autority.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_MakeCert(&certifikat, der_certifikat, sizeof(der_certifikat), &kluc, NULL, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER s certifikatom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_SignCert(certifikat.bodySz, certifikat.sigType, der_certifikat, sizeof(der_certifikat), &kluc_autorita, NULL, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri podpisovani certifikatu.\n");
    return -1;
  }
  der_certifikat_velkost = uspech;
  memset(pem_certifikat, 0, sizeof(pem_certifikat));
  uspech = wc_DerToPem(der_certifikat, der_certifikat_velkost, pem_certifikat, sizeof(pem_certifikat), CERT_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM s certifikatom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  pem_certifikat_velkost = uspech;

  //zapis vygenerovaneho certifikatu do suboru
  subor = fopen(subor_certifikat, "wb+");
  fwrite(pem_certifikat, 1, pem_certifikat_velkost, subor);
  fclose(subor);

  printf("Certifikat bol uspesne vygenerovany\n");
  
  return 0;
}

int generovat_ecc_certifikat(const char* subor_certifikat, const char* subor_kluc, int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
{
  int uspech = 0 ;

  //premenne pre ukladanie dat autority
  ecc_key kluc_autorita;
  byte der_autorita_certifikat[VELKOST_BUFFERA];
  int der_autorita_certifikat_velkost;
  byte der_autorita_kluc[VELKOST_BUFFERA];
  int der_autorita_kluc_velkost;
  
  //nacitanie certifikatu autority vo formate DER ulozeneho v subore certifikaty/autorita/autorita_ecc.der
  printf("Nacitavanie certifikatu autority zo suboru.\n");
  FILE* subor = fopen("../certifikaty/autorita/autorita_ecc.der", "rb");
  der_autorita_certifikat_velkost = fread(der_autorita_certifikat, 1, VELKOST_BUFFERA , subor);
  if(der_autorita_certifikat_velkost < 0)
  {
    fprintf(stderr, "Nepodarilo sa nacitat obsah suboru. \n");
    return -1;
  }
  fclose(subor);
  printf("Nacitanie ukoncene. Bolo nacitanych %d bajtov.\n", der_autorita_certifikat_velkost);

  //vytvorenie struktury ecc_key autority zo sukromneho kluca vo formate DER ulozeneho v subore certifikaty/autorita/autorita_kluc_ecc.der
  printf("Nacitavanie sukromneho kluca autority zo suboru.\n");
  subor = fopen("../certifikaty/autorita/autorita_kluc_ecc.der", "rb");
  der_autorita_kluc_velkost = fread(der_autorita_kluc, 1, VELKOST_BUFFERA , subor);
  if(der_autorita_kluc_velkost < 0)
  {
    fprintf(stderr, "Nepodarilo sa nacitat obsah suboru. \n");
    return -1;
  }
  fclose(subor);
  printf("Nacitanie ukoncene. Bolo nacitanych %d bajtov.\n", der_autorita_kluc_velkost);

  word32 index = 0; //nastavi odkial zacat citat buffer
  wc_ecc_init(&kluc_autorita);
  uspech = wc_EccPrivateKeyDecode(der_autorita_kluc, &index, &kluc_autorita, (word32)der_autorita_kluc_velkost);
  if(uspech != 0)
  {
    fprintf(stderr, "Chyba pri dekodovani kluca autority.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  
  //generator nahodnych cisel
  WC_RNG generator;
  wc_InitRng(&generator);
  
  //premenne pre ukladanie dat vygenerovaneho kluca
  ecc_key kluc;
  byte der_kluc[VELKOST_BUFFERA];
  word32 der_kluc_velkost;
  byte pem_kluc[VELKOST_BUFFERA];
  word32 pem_kluc_velkost;

  //vygenerovanie kluca
  wc_ecc_init(&kluc);
  uspech = wc_ecc_make_key_ex(&generator, pocet_bitov, &kluc, kluc_krivka);
  if(uspech != 0)
  {
    fprintf(stderr, "Chyba pri generovani kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_EccKeyToDer(&kluc, der_kluc, sizeof(der_kluc));
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_kluc_velkost = uspech;
  uspech = wc_DerToPem(der_kluc, der_kluc_velkost, pem_kluc, sizeof(pem_kluc), ECC_PRIVATEKEY_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so sukromnym klucom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  pem_kluc_velkost = uspech;

  //zapis vygenerovaneho kluca do suboru
  subor = fopen(subor_kluc, "wb+");
  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
  fclose(subor);
  
  printf("ECC kluc bol uspesne vygenerovany.\n");

  //premenne pre ukladanie dat certifikatu
  Cert certifikat;
  unsigned char der_certifikat[VELKOST_BUFFERA];
  word32 der_certifikat_velkost;
  unsigned char pem_certifikat[VELKOST_BUFFERA];
  word32 pem_certifikat_velkost;
 
  //vygenerovanie a podpis certifikatu
  wc_InitCert(&certifikat);
  strncpy(certifikat.subject.country, krajina, CTC_NAME_SIZE);
  strncpy(certifikat.subject.state, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.locality, mesto, CTC_NAME_SIZE);
  strncpy(certifikat.subject.org, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.unit, "-", CTC_NAME_SIZE);
  strncpy(certifikat.subject.commonName, domena, CTC_NAME_SIZE);
  strncpy(certifikat.subject.email, email, CTC_NAME_SIZE);
  certifikat.isCA = 0;
  certifikat.sigType = algoritmus;
  certifikat.daysValid = 1825;
  uspech = wc_SetIssuerBuffer(&certifikat, der_autorita_certifikat, der_autorita_certifikat_velkost);
  if(uspech != 0)
  {
    fprintf(stderr, "Nastala chyba pri nastaveni autority.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_MakeCert(&certifikat, der_certifikat, sizeof(der_certifikat), NULL, &kluc, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER s certifikatom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_SignCert(certifikat.bodySz, certifikat.sigType, der_certifikat, sizeof(der_certifikat), NULL, &kluc_autorita, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri podpisovani certifikatu.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_certifikat_velkost = uspech;
  memset(pem_certifikat, 0, sizeof(pem_certifikat));
  uspech = wc_DerToPem(der_certifikat, der_certifikat_velkost, pem_certifikat, sizeof(pem_certifikat), CERT_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM s certifikatom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  pem_certifikat_velkost = uspech;

  //zapis vygenerovaneho klucu do suboru
  subor = fopen(subor_certifikat, "wb+");
  fwrite(pem_certifikat, 1, pem_certifikat_velkost, subor);
  fclose(subor);

  return 0; 
}

int vygenerovat_rsa_ziadost(const char* subor_ziadost, const char* subor_kluc, int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
{
  int uspech = 0;

  //generator nahodnych cisel
  WC_RNG generator;
  wc_InitRng(&generator);

  //premenne pre ukladanie dat vygenerovaneho kluca
  RsaKey kluc;
  unsigned char der_kluc[VELKOST_BUFFERA];
  word32 der_kluc_velkost;
  unsigned char pem_kluc[VELKOST_BUFFERA];
  word32 pem_kluc_velkost;

  //vygenerovanie kluca
  wc_InitRsaKey(&kluc, 0);
  uspech = wc_MakeRsaKey(&kluc, pocet_bitov, exponent, &generator);
  if(uspech != 0)
  {
    fprintf(stderr, "Chyba pri generovani kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_RsaKeyToDer(&kluc, der_kluc, sizeof(der_kluc));
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_kluc_velkost = uspech;
  memset(pem_kluc, 0, sizeof(pem_kluc));
  pem_kluc_velkost = wc_DerToPem(der_kluc, der_kluc_velkost, pem_kluc, sizeof(pem_kluc), PRIVATEKEY_TYPE);
  if(pem_kluc_velkost < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so sukromnym klucom\n");
    return -1;
  }

  FILE* subor = fopen(subor_kluc, "wb+");
  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
  fclose(subor);
  printf("RSA kluc bol uspesne vygenerovany\n");

  //premenne pre ukladanie dat ziadosti
  Cert ziadost;
  unsigned char der_ziadost[VELKOST_BUFFERA];
  word32 der_ziadost_velkost;
  unsigned char pem_ziadost[VELKOST_BUFFERA];
  word32 pem_ziadost_velkost;
 
  //vygenerovanie a podpis ziadosti
  wc_InitCert(&ziadost);
  strncpy(ziadost.subject.country, krajina, CTC_NAME_SIZE);
  strncpy(ziadost.subject.state, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.locality, mesto, CTC_NAME_SIZE);
  strncpy(ziadost.subject.org, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.unit, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.commonName, domena, CTC_NAME_SIZE);
  strncpy(ziadost.subject.email, email, CTC_NAME_SIZE);
  ziadost.sigType = algoritmus;
  uspech = wc_MakeCertReq(&ziadost, der_ziadost, sizeof(der_ziadost), &kluc, NULL);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri generovani ziadosti.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_SignCert(ziadost.bodySz, ziadost.sigType, der_ziadost, sizeof(der_ziadost), &kluc, NULL, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri podpisovani ziadosti.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_ziadost_velkost = uspech;
  memset(pem_ziadost, 0, sizeof(pem_ziadost));
  uspech = wc_DerToPem(der_ziadost, der_ziadost_velkost, pem_ziadost, sizeof(pem_ziadost), CERTREQ_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so ziadostou.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  pem_ziadost_velkost = uspech;
  subor = fopen(subor_ziadost, "wb+");
  fwrite(pem_ziadost, 1, pem_ziadost_velkost, subor);
  fclose(subor);
}

int vygenerovat_ecc_ziadost(const char* subor_ziadost, const char* subor_kluc, int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
{
  int uspech = 0;

  //generator nahodnych cisel
  WC_RNG generator;
  wc_InitRng(&generator);

  //premenne pre ukladanie dat vygenerovaneho kluca
  ecc_key kluc;
  unsigned char der_kluc[VELKOST_BUFFERA];
  word32 der_kluc_velkost;
  unsigned char pem_kluc[VELKOST_BUFFERA];
  word32 pem_kluc_velkost;

  //vygenerovanie kluca
  wc_ecc_init(&kluc);
  uspech = wc_ecc_make_key_ex(&generator, pocet_bitov, &kluc, kluc_krivka);
  if(uspech != 0)
  {
    fprintf(stderr, "Chyba pri generovani kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_EccKeyToDer(&kluc, der_kluc, sizeof(der_kluc));
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_kluc_velkost = uspech;
  memset(pem_kluc, 0, sizeof(pem_kluc));
  pem_kluc_velkost = wc_DerToPem(der_kluc, der_kluc_velkost, pem_kluc, sizeof(pem_kluc), ECC_PRIVATEKEY_TYPE);
  if(pem_kluc_velkost < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so sukromnym klucom\n");
    return -1;
  }

  FILE* subor = fopen(subor_kluc, "wb+");
  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
  fclose(subor);
  printf("ECC kluc bol uspesne vygenerovany\n");

  //premenne pre ukladanie dat ziadosti
  Cert ziadost;
  unsigned char der_ziadost[VELKOST_BUFFERA];
  word32 der_ziadost_velkost;
  unsigned char pem_ziadost[VELKOST_BUFFERA];
  word32 pem_ziadost_velkost;
 
  //vygenerovanie a podpis ziadosti
  wc_InitCert(&ziadost);
  strncpy(ziadost.subject.country, krajina, CTC_NAME_SIZE);
  strncpy(ziadost.subject.state, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.locality, mesto, CTC_NAME_SIZE);
  strncpy(ziadost.subject.org, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.unit, "-", CTC_NAME_SIZE);
  strncpy(ziadost.subject.commonName, domena, CTC_NAME_SIZE);
  strncpy(ziadost.subject.email, email, CTC_NAME_SIZE);
  ziadost.sigType = algoritmus;
  uspech = wc_MakeCertReq(&ziadost, der_ziadost, sizeof(der_ziadost), NULL, &kluc);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri generovani ziadosti.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  uspech = wc_SignCert(ziadost.bodySz, ziadost.sigType, der_ziadost, sizeof(der_ziadost), NULL, &kluc, &generator);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri podpisovani ziadosti.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  der_ziadost_velkost = uspech;
  memset(pem_ziadost, 0, sizeof(pem_ziadost));
  uspech = wc_DerToPem(der_ziadost, der_ziadost_velkost, pem_ziadost, sizeof(pem_ziadost), CERTREQ_TYPE);
  if(uspech < 0)
  {
    fprintf(stderr, "Nastala chyba pri vytvoreni suboru PEM so ziadostou.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
    return -1;
  }
  pem_ziadost_velkost = uspech;
  subor = fopen(subor_ziadost, "wb+");
  fwrite(pem_ziadost, 1, pem_ziadost_velkost, subor);
  fclose(subor);
}

int nacitat_certifikaty(WOLFSSL_CTX* ctx, const char* subor_certifikat, const char* subor_kluc)
{
  int uspech = 0;
  
  //nacitanie certifikatu do WOLFSSL_CTX struktury, cesta ku suboru sa predava z argumentu funkcie
  uspech = wolfSSL_CTX_use_certificate_file(ctx, subor_certifikat, SSL_FILETYPE_PEM);
  if(uspech != SSL_SUCCESS)
  {
    printf("Chyba pri nacitani certifikatu\n");
    return -1;
  }
  
  //nacitanie sukromneho kluca do WOLFSSL_CTX struktury, cesta ku suboru sa predava z argumentu funkcie
  uspech = wolfSSL_CTX_use_PrivateKey_file(ctx, subor_kluc, SSL_FILETYPE_PEM);
  if(uspech != SSL_SUCCESS)
  {
    printf("Chyba pri nacitani kluca\n");
    return -1;
  }
  
  printf("Certifikat a kluc boli uspesne nacitane\n");
  
  //kontrola sukromneho kluca
  if(!wolfSSL_CTX_check_private_key(ctx))
  {
    fprintf(stderr, "Sukromny kluc sa nezhoduje s certifikatom\n");
    return -1;
  } 
  return 0;
}

void zobraz_certifikat(WOLFSSL* ssl)
{
  WOLFSSL_X509 *certifikat = wolfSSL_get_peer_certificate(ssl);
  char* pole;
  if (!certifikat)
  {
    fprintf(stderr, "Nebolo mozne ziskat ziadny certifikat\n");
  }
  if ((pole = wolfSSL_X509_NAME_oneline(wolfSSL_X509_get_subject_name(certifikat), 0, 0))) 
  {
    printf("Subjekt: %s\n", pole);
  }
  if ((pole = wolfSSL_X509_NAME_oneline(wolfSSL_X509_get_issuer_name(certifikat), 0, 0))) 
  {
    printf("Certifikacna autorita: %s\n", pole);
  }
  X509_free(certifikat);
}

unsigned char* generovat_kontrolny_sucet_suboru(nastavenia_aplikacie* nastavenia, const char* cesta, int velkost_suboru, int* velkost)
{
  int pocet_bajtov;
  FILE* subor = fopen(cesta, "rb");
  unsigned char data[velkost_suboru];
  memset(data, 0, velkost_suboru);
  unsigned char* vysledok;
  if(!strcmp(nastavenia->typ_vypoctu, "crc"))
  {
    if(nastavenia->c_funkcia == funkcia_CRC32)
    {
      *velkost = CRC32_VELKOST;
      vysledok = calloc(CRC32_VELKOST, sizeof(unsigned char));
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      unsigned int crc = crc32(0L, Z_NULL, 0);
      crc = crc32(crc, data, 10);
      sprintf(vysledok, "%u", crc);
    }
    else
    {
      fprintf(stderr, "Nepodarilo sa vybrat funkciu pre vypocet kontrolneho suctu.\n");
      return NULL;
    }  
  }
  else if(!strcmp(nastavenia->typ_vypoctu, "hash"))
  {
    if(nastavenia->h_funkcia == funkcia_SHA)
    {
      *velkost = SHA_DIGEST_SIZE;
      vysledok = calloc(SHA_DIGEST_SIZE, sizeof(unsigned char));
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      Sha sha;
      wc_InitSha(&sha);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_ShaUpdate(&sha, data, pocet_bajtov);  
      wc_ShaFinal(&sha, vysledok);
    }
    else if(nastavenia->h_funkcia == funkcia_SHA224)
    {
      *velkost = SHA224_DIGEST_SIZE;
      vysledok = calloc(SHA224_DIGEST_SIZE, sizeof(unsigned char));
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      Sha224 sha;
      wc_InitSha224(&sha);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_Sha224Update(&sha, data, pocet_bajtov);  
      wc_Sha224Final(&sha, vysledok);
    }
    else if(nastavenia->h_funkcia == funkcia_SHA256)
    {
      *velkost = SHA256_DIGEST_SIZE;
      vysledok = calloc(SHA256_DIGEST_SIZE, sizeof(unsigned char));
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      Sha256 sha;
      wc_InitSha256(&sha);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_Sha256Update(&sha, data, pocet_bajtov);  
      wc_Sha256Final(&sha, vysledok);
    }
    else if(nastavenia->h_funkcia == funkcia_SHA384)
    {
      *velkost = SHA384_DIGEST_SIZE;
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      Sha384 sha;
      wc_InitSha384(&sha);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_Sha384Update(&sha, data, pocet_bajtov);  
      wc_Sha384Final(&sha, vysledok);
    }
    else if(nastavenia->h_funkcia == funkcia_SHA512)
    {
      *velkost = WC_SHA512_DIGEST_SIZE;
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      wc_Sha512 sha;
      wc_InitSha512(&sha);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_Sha512Update(&sha, data, pocet_bajtov);  
      wc_Sha512Final(&sha, vysledok);
    }
    else if(nastavenia->h_funkcia == funkcia_BLAKE2B)
    {
      *velkost = BLAKE2B_VELKOST;
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      Blake2b b2b;
      wc_InitBlake2b(&b2b, BLAKE2B_VELKOST);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_Blake2bUpdate(&b2b, data, pocet_bajtov);  
      wc_Blake2bFinal(&b2b, vysledok, BLAKE2B_VELKOST);
    }
    else if(nastavenia->h_funkcia == funkcia_RIPEMD160)
    {
      *velkost = RIPEMD_DIGEST_SIZE;
      if(vysledok == NULL) 
      {
        fprintf(stderr, "Nepodarilo sa dynamicky alokovat pamat pre vysledok\n");
        return NULL;
      }
      RipeMd ripemd;
      wc_InitRipeMd(&ripemd);
      while ((pocet_bajtov = fread (data, 1, velkost_suboru, subor)) != 0)
      wc_RipeMdUpdate(&ripemd, data, pocet_bajtov);  
      wc_RipeMdFinal(&ripemd, vysledok);
    }
    else
    {
      fprintf(stderr, "Nepodarilo sa vybrat funkciu pre vypocet kontrolneho suctu.\n");
      return NULL;
    }
  }
  else
  {
    fprintf(stderr, "Nepodarilo sa vybrat funkciu pre vypocet kontrolneho suctu.\n");
    return NULL;
  }
  fclose(subor);
  return vysledok;
}

void ukoncit_spojenie(WOLFSSL *ssl, WOLFSSL_CTX *ctx)
{
  printf("Ukoncujem program.\n");
  wolfSSL_shutdown(ssl);
  wolfSSL_free(ssl);
  printf("Spojenie ukoncene.\n");
  wolfSSL_CTX_free(ctx);
  wolfSSL_Cleanup();
  printf("Program bol ukonceny.\n");
}