-

certifikaty/vygenerovany_certifikat.pem

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICcTCCAdqgAwIBAgIQCOhPCtiT+OzqOZ9/zm15UDANBgkqhkiG9w0BAQsFADBz
+MQswCQYDVQQGEwJTSzEKMAgGA1UECAwBLTEPMA0GA1UEBwwGS29zaWNlMREwDwYD
+VQQKDAhBdXRvcml0YTESMBAGA1UEAwwJbG9jYWwuZGV2MSAwHgYJKoZIhvcNAQkB
+FhFhdXRvcml0YUB0dWtlLmNvbTAiGA8yMDIwMDMxMTE0NTY0MloYDzIwMjUwMzEx
+MTQ1NjQyWjB3MQswCQYDVQQGEwJTUjEKMAgGA1UECAwBLTEPMA0GA1UEBwwGS29z
+aWNlMQowCAYDVQQKDAEtMQowCAYDVQQLDAEtMRIwEAYDVQQDDAlTZXJ2ZXIuc2sx
+HzAdBgkqhkiG9w0BCQEWEHNlcnZlckBzZXJ2ZXIuc2swgZ8wDQYJKoZIhvcNAQEB
+BQADgY0AMIGJAoGBAN9gCoWWm5DDSo/7cSTbzhfbWsInC1kqj+5JKUy264iFbCnu
+lcmD4w6EfClH5RYnqg+dHxuft2yEo0SvAMRyFpPs+J30m3m6TyLSAtTkoqYARFA3
+UcMm1mGFPHfeJIWnJXSFMVEixrY8xy2PoHjBiB90MqcsEJBNRgeGiLDsJFmVAgMB
+AAEwDQYJKoZIhvcNAQELBQADgYEAYKUghhJs93klzeFlJVArHPpUyuYcIAsre6B9
+5opSgCyhztxUoRYp/ti+QnnyCPK6EuYzwFRY6KRAsBM2w1bSaK3qmtMQmoANK/n1
+tD6FravK9ufb760hsB659iiKJrKFqZcQD34f0rjhIImBscK4KKMp8wmesBUxVidG
+HsHDRKM=
+-----END CERTIFICATE-----

certifikaty/vygenerovany_kluc.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDfYAqFlpuQw0qP+3Ek284X21rCJwtZKo/uSSlMtuuIhWwp7pXJ
+g+MOhHwpR+UWJ6oPnR8bn7dshKNErwDEchaT7Pid9Jt5uk8i0gLU5KKmAERQN1HD
+JtZhhTx33iSFpyV0hTFRIsa2PMctj6B4wYgfdDKnLBCQTUYHhoiw7CRZlQIDAQAB
+AoGAEal1zjAapFS2D6eSv8FBLN87Wvh8hqQdeyVIm/LRsaV/vYVfzW4oH6TSRBmr
+GjhFfim5r4o5K14wd6o7uLde+VTy/eJhS0xNtHDyfrAsg0Eb3EleS/D6SrX81err
+vCXxC9DScOsCxuI0KIzzWdy9pB4yAfpN1S7SZ/BcOJwm3mECQQD79TbvsVO3buce
+I5V31SkvYA7ZhGj9e5hHosoENzxW/DLK2rJTkfJ5gA19Toiyy3Y+aEFOeJ/EZuje
+aIE8WKNhAkEA4vVwHZhCUGelWtfzN6K2bPxYITOhCE4eDAKbSsRl8g9sRzrjuFoW
+5VwCj3yAz5Axe5tRI18kzI6Si89l6H6WtQJBAKAKFicSH/b3/t3qBFrljw+EmGoZ
+7QZ1pzh5cpBS9YTbFPg9CeCDZ909NVROug23pxfk6PaLMBB0vZ3oC47lToECQQDO
+z4ZNgXwUFo4n/JZFgUCoiT2pa4l2rvBUU1+8vsCC1aj+M1xklbs9Xx16MKKUAToF
+/57tE3rN57EEM4YSWJ/tAkEAh1FG42L+UNVEXc88S6419iDpCkFzdu6Fl+tghASc
+Re0kEW6wMYtV9HKPCnHWymklB6YbaaeEUomOe5d1Bw8O4A==
+-----END RSA PRIVATE KEY-----

kniznica/komunikacia.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include "komunikacia.h"
@@ -11,7 +11,15 @@
 
 int poslat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx, char* cesta)
 {
-  wolfSSL_write(ssl, cesta, 64);
+  int uspech;
+  
+  //odoslanie nazvu (resp. cesty) suboru
+  uspech = wolfSSL_write(ssl, cesta, VELKOST_CESTY);
+  if(uspech <= 0)
+  {
+    fprintf(stderr, "Nastala chyba pri posielani dat o subore.\n");
+    return -1;
+  }
   
   FILE* subor = fopen(cesta, "r");
   if(subor == NULL)
@@ -28,10 +36,10 @@ int poslat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx, char* cesta)
     //a zisti velkost suboru
     fseek(subor, 0, SEEK_END);
     long velkost = ftell(subor);
-    char velkost_suboru[32];
+    char velkost_suboru[VELKOST_SUBOR];
     sprintf(velkost_suboru, "%ld", velkost);
     printf("Velkost suboru: %s bajtov\n", velkost_suboru);
-    wolfSSL_write(ssl, velkost_suboru, 32);
+    wolfSSL_write(ssl, velkost_suboru, VELKOST_SUBOR);
     
     //nastavi ukazovatel na zaciatok suboru
     //a nacita data zo suboru do pola
@@ -41,10 +49,25 @@ int poslat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx, char* cesta)
     fread(pole, 1, velkost, subor);
     fclose(subor);
     
+    //generovanie a poslanie kontrolneho suctu serveru pre kontrolu
+    byte* hash;
+    hash = generovat_hash(cesta);
+    wolfSSL_write(ssl, hash, VELKOST_HASHU);
+    if(uspech <= 0)
+    {
+      fprintf(stderr, "Nastala chyba pri posielani hashu.\n");
+      return -1;
+    }
+
     //posielanie jednotlivych bajtov
     for(int i = 0; i < velkost + 1; ++i)
     {
       wolfSSL_write(ssl, pole_uk, velkost);
+      if(uspech <= 0)
+      {
+        fprintf(stderr, "Nastala chyba pri posielani suboru.\n");
+        return -1;
+      }
       pole_uk += 1;
     }
     printf("Subor bol uspesne odoslany.\n");
@@ -54,13 +77,21 @@ int poslat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx, char* cesta)
 
 int prijat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx)
 {
-  char* cesta = calloc(100, sizeof(char));
+  int uspech;
-  wolfSSL_read(ssl, cesta, 64);
+
+  //prijem dat o velkosti suboru
+  char* cesta = calloc(VELKOST_CESTY, sizeof(char));
+  uspech = wolfSSL_read(ssl, cesta, VELKOST_CESTY);
+  if(uspech <= 0)
+  {
+    fprintf(stderr, "Nastala chyba pri prijati velkosti suboru\n");
+    return -1;
+  }
   printf("Prebieha prijimanie suboru %s\n", cesta);
 
   //ziskanie informacie od klienta o velkosti odoslaneho suboru
   char velkost_suboru[32];
-  wolfSSL_read(ssl, velkost_suboru, 32);
+  wolfSSL_read(ssl, velkost_suboru, VELKOST_SUBOR);
   long velkost = atol(velkost_suboru);
   if(velkost < 1)
   {
@@ -72,16 +103,43 @@ int prijat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx)
     printf("Velkost suboru: %s bajtov\n", velkost_suboru);
   }
 
+  //prijem hashu, ktory vypocital server
+  char* prijaty_hash = calloc(VELKOST_HASHU, sizeof(char));
+  uspech = wolfSSL_read(ssl, prijaty_hash, VELKOST_HASHU);
+  if(uspech <= 0)
+  {
+    fprintf(stderr, "Nastala chyba pri prijati hashu\n");
+    return -1;
+  }
+
   //prijem jednotlivych bajtov
   char* pole = malloc(velkost);
   char* pole_uk = pole;
   for(int i = 0; i < velkost + 1; ++i)
   {
-    wolfSSL_read(ssl, pole_uk, velkost);
+    uspech = wolfSSL_read(ssl, pole_uk, velkost);
+    if(uspech <= 0)
+    {
+      fprintf(stderr, "Nastala chyba pri prijimani suboru\n");
+      return -1;
+    }
     pole_uk += 1;
   }
   printf("Subor bol uspesne prijaty.\n");
   
+  //kontrola ci sa prijaty a vypocitany kontrolny sucet suboru zhoduju
+  byte* vypocitany_hash;
+  vypocitany_hash = generovat_hash(cesta);
+  if(!strcmp(prijaty_hash, (char*)vypocitany_hash))
+  {
+    printf("Subor prisiel v poriadku.\n");
+  }
+  else
+  {
+    printf("Subor neprisiel v poriadku.\n");
+    return -1;
+  }
+
   //zapis nacitanych dat do suboru
   FILE* subor = fopen(cesta, "w");
   fwrite(pole, 1, velkost, subor);
@@ -186,7 +244,10 @@ int cakat_na_komunikaciu(int cislo_portu)
     return 0;
   }
 
-  if(listen(cislo_soketu, 10) != 0)
+  //maximalna velkost do ktorej rada cakajucich spojeni pre soket moze rast
+  int velkost_radu = 10;
+
+  if(listen(cislo_soketu, velkost_radu) != 0)
   {
     fprintf(stderr, "Na danom porte nie je mozne cakat na komunikaciu.\n");
     return 0;

kniznica/komunikacia.h

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #ifndef __KOMUNIKACIA_H__
@@ -14,6 +14,10 @@
 #include <string.h>
 #include <wolfssl/ssl.h>
 
+#define VELKOST_CESTY 64 //velkost retazca, kt. uklada lokaciu suboru
+#define VELKOST_SUBOR 32 //velkost retazca, kt. uklada velkost prenasaneho suboru
+#define VELKOST_HASHU 20 
+
 #if defined(_WIN32)
   //makro ktore urcuje win distribuciu ak nieje detekovana
   #ifndef _WIN32_WINNT 

kniznica/kryptografia.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include "kryptografia.h"
@@ -14,7 +14,7 @@ WOLFSSL_CTX* nastavit_ctx_klient()
   wolfSSL_Init();
   method = wolfTLSv1_2_client_method();
   WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
-  wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, 0);
+  wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
   if (ctx == NULL) 
   {
     printf("Nepodarilo sa inicializovat WOLFSSL_CTX\n");
@@ -29,8 +29,8 @@ WOLFSSL_CTX* nastavit_ctx_server()
   wolfSSL_Init();
   method = wolfTLSv1_2_server_method();
   WOLFSSL_CTX *ctx = wolfSSL_CTX_new(method);
+  wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
 
-  wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
   if (ctx == NULL) 
   {
     printf("Nepodarilo sa inicializovat WOLFSSL_CTX\n");
@@ -49,21 +49,21 @@ void zobraz_sifru(WOLFSSL* ssl)
   printf ("Pouzita sifra: %s\n", wolfSSL_get_cipher(ssl));
 }
 
-int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
+int generovat_rsa_certifikat(int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
 {
   int uspech;
 
   //premenne pre ukladanie dat autority
   RsaKey kluc_autorita;
-  byte pem_autorita[4096];
+  byte pem_autorita[VELKOST_BUFFERA];
   word32 pem_autorita_velkost;
-  byte der_autorita[4096];
+  byte der_autorita[VELKOST_BUFFERA];
   word32 der_autorita_velkost;
   
   //vytvorenie struktury RsaKey autority zo sukromneho kluca vo formate PEM ulozeneho v subore certifikaty/autorita.key
   memset(pem_autorita, 0, sizeof(pem_autorita));
   FILE* subor = fopen("../certifikaty/autorita_rsa.key", "rb");
-  pem_autorita_velkost = fread(pem_autorita, 1, 4096, subor);
+  pem_autorita_velkost = fread(pem_autorita, 1, VELKOST_BUFFERA, subor);
   if(pem_autorita_velkost < 0)
   {
     fprintf(stderr, "Nepodarilo sa nacitat obsah suboru\n");
@@ -91,9 +91,9 @@ int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, in
   
   //premenne pre ukladanie dat vygenerovaneho kluca
   RsaKey kluc;
-  byte der_kluc[4096];
+  byte der_kluc[VELKOST_BUFFERA];
   word32 der_kluc_velkost;
-  byte pem_kluc[4096];
+  byte pem_kluc[VELKOST_BUFFERA];
   word32 pem_kluc_velkost;
 
   //vygenerovanie kluca
@@ -110,6 +110,7 @@ int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, in
     fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\n");
     return -1;
   }
+  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)
   {
@@ -117,21 +118,18 @@ int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, in
     return -1;
   }
 
-  //nacitanie vygenerovaneho kluca do WOLFSSL_CTX struktury
+  //zapis vygenerovaneho klucu do suboru
-  uspech = wolfSSL_CTX_use_PrivateKey_buffer(ctx, pem_kluc, pem_kluc_velkost, SSL_FILETYPE_PEM);
+  subor = fopen("../certifikaty/vygenerovany_kluc.key", "wb");
-  if(uspech != SSL_SUCCESS) 
+  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
-  {
+  fclose(subor);
-    fprintf(stderr, "Chyba pri nacitani vygenerovaneho kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
-    return -1;
-  }
   
-  printf("RSA kluc bol uspesne vygenerovany a nacitany.\n");
+  printf("RSA kluc bol uspesne vygenerovany.\n");
   
   //premenne pre ukladanie dat certifikatu
   Cert certifikat;
-  byte der_certifikat[4096];
+  byte der_certifikat[VELKOST_BUFFERA];
   word32 der_certifikat_velkost;
-  byte pem_certifikat[4096];
+  byte pem_certifikat[VELKOST_BUFFERA];
   word32 pem_certifikat_velkost;
 
   //vygenerovanie a podpis certifikatu
@@ -143,8 +141,9 @@ int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, in
   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.isCA = 0;
   certifikat.sigType = algoritmus;
+  certifikat.daysValid = 1825;
   uspech = wc_SetIssuer(&certifikat, "../certifikaty/autorita_rsa.pem");
   if(uspech < 0)
   {
@@ -171,38 +170,35 @@ int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, in
     return -1;
   }
 
-  //nacitanie vygenerovaneho certifikatu do WOLFSSL_CTX struktury
+  //zapis vygenerovaneho klucu do suboru
-  uspech = wolfSSL_CTX_use_certificate_buffer(ctx, pem_certifikat, pem_certifikat_velkost, SSL_FILETYPE_PEM);
+  subor = fopen("../certifikaty/vygenerovany_certifikat.pem", "wb");
-  if(uspech != SSL_SUCCESS) 
+  fwrite(pem_certifikat, 1, pem_certifikat_velkost, subor);
-  {
+  fclose(subor);
-    fprintf(stderr, "Chyba pri generovani certifikatu.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
-    return -1;
-  }
-  printf("Certifikat bol uspesne vygenerovany a podpisany\n");
 
-  if(!wolfSSL_CTX_check_private_key(ctx))
+  printf("Certifikat bol uspesne vygenerovany\n");
-  {
-    fprintf(stderr, "Sukromny kluc sa nezhoduje s certifikatom\n");
-    return -1;
-  } 
   
   return 0;
 }
 
-int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
+int generovat_ecc_certifikat(int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email)
 {
-  int uspech = 0;
+  int uspech = 0 ;
 
   //premenne pre ukladanie dat autority
   ecc_key kluc_autorita;
-  byte pem_autorita[4096];
+  byte pem_autorita[VELKOST_BUFFERA];
-  byte der_autorita[4096];
+  word32 pem_autorita_velkost;
+  byte der_autorita[VELKOST_BUFFERA];
   word32 der_autorita_velkost;
   
   //vytvorenie struktury ecc_key autority zo sukromneho kluca vo formate PEM ulozeneho v subore certifikaty/autorita_ecc.key
   memset(pem_autorita, 0, sizeof(pem_autorita));
   FILE* subor = fopen("../certifikaty/autorita_ecc.key", "rb");
-  fread(pem_autorita, 1, 4096 , subor);
+  pem_autorita_velkost = fread(pem_autorita, 1, VELKOST_BUFFERA , subor);
+  if(pem_autorita_velkost < 0)
+  {
+    fprintf(stderr, "Nepodarilo sa nacitat obsah suboru\n");
+  }
   fclose(subor);
   word32 index = 0; //nastavi odkial zacat citat buffer
   der_autorita_velkost = wolfSSL_KeyPemToDer(pem_autorita, sizeof(pem_autorita), der_autorita, sizeof(der_autorita), "");
@@ -220,9 +216,9 @@ int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id klu
   
   //premenne pre ukladanie dat vygenerovaneho kluca
   ecc_key kluc;
-  byte der_kluc[4096];
+  byte der_kluc[VELKOST_BUFFERA];
   word32 der_kluc_velkost;
-  byte pem_kluc[4096];
+  byte pem_kluc[VELKOST_BUFFERA];
   word32 pem_kluc_velkost;
 
   //vygenerovanie kluca
@@ -234,23 +230,30 @@ int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id klu
     return -1;
   }
   der_kluc_velkost = wc_EccKeyToDer(&kluc, der_kluc, sizeof(der_kluc));
-  pem_kluc_velkost = wc_DerToPem(der_kluc, der_kluc_velkost, pem_kluc, sizeof(pem_kluc), ECC_PRIVATEKEY_TYPE);
+  if(der_kluc_velkost < 0)
-
-  //nacitanie vygenerovaneho kluca do WOLFSSL_CTX struktury
-  uspech = wolfSSL_CTX_use_PrivateKey_buffer(ctx, pem_kluc, pem_kluc_velkost, SSL_FILETYPE_PEM);
-  if(uspech != SSL_SUCCESS) 
   {
-    fprintf(stderr, "Chyba pri nacitani vygenerovaneho kluca.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
+    fprintf(stderr, "Nastala chyba pri vytvoreni suboru DER so sukromnym klucom.\n");
     return -1;
   }
+  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;
+  }
+
+  //zapis vygenerovaneho kluca do suboru
+  subor = fopen("../certifikaty/vygenerovany_kluc.key", "wb");
+  fwrite(pem_kluc, 1, pem_kluc_velkost, subor);
+  fclose(subor);
   
   printf("ECC kluc bol uspesne vygenerovany a nacitany.\n");
 
   //premenne pre ukladanie dat certifikatu
   Cert certifikat;
-  byte der_certifikat[4096];
+  byte der_certifikat[VELKOST_BUFFERA];
   word32 der_certifikat_velkost;
-  byte pem_certifikat[4096];
+  byte pem_certifikat[VELKOST_BUFFERA];
   word32 pem_certifikat_velkost;
 
   //vygenerovanie a podpis certifikatu
@@ -264,6 +267,8 @@ int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id klu
   strncpy(certifikat.subject.email, email, CTC_NAME_SIZE);
   certifikat.isCA = 0;
   certifikat.sigType = algoritmus;
+  certifikat.daysValid = 1825;
+
   uspech = wc_SetIssuer(&certifikat, "../certifikaty/autorita_ecc.pem");
   if(uspech != 0)
   {
@@ -290,20 +295,11 @@ int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id klu
     return -1;
   }
 
-  //nacitanie vygenerovaneho certifikatu do WOLFSSL_CTX struktury
+  //zapis vygenerovaneho klucu do suboru
-  uspech = wolfSSL_CTX_use_certificate_buffer(ctx, pem_certifikat, pem_certifikat_velkost, SSL_FILETYPE_PEM);
+  subor = fopen("../certifikaty/vygenerovany_certifikat.pem", "wb");
-  if(uspech != SSL_SUCCESS) 
+  fwrite(pem_certifikat, 1, pem_certifikat_velkost, subor);
-  {
+  fclose(subor);
-    fprintf(stderr, "Chyba pri generovani certifikatu.\nCislo chyby: %d\nDovod chyby: %s\n", uspech, wc_GetErrorString(uspech));
-    return -1;
-  }
-  printf("Certifikat bol uspesne vygenerovany a podpisany\n");
 
-  if(!wolfSSL_CTX_check_private_key(ctx))
-  {
-    fprintf(stderr, "Sukromny kluc sa nezhoduje s certifikatom\n");
-    return -1;
-  } 
   return 0;
 }
 
@@ -360,6 +356,19 @@ void zobraz_certifikat(WOLFSSL* ssl)
   X509_free(certifikat);
 }
 
+byte* generovat_hash(char* cesta)
+{
+  int pocet_bajtov;
+  FILE* subor = fopen(cesta, "rb");
+  unsigned char data[1024];
+  byte* vysledok = calloc(SHA_DIGEST_SIZE, sizeof(byte));
+  Sha sha;
+  wc_InitSha(&sha);
+  while ((pocet_bajtov = fread (data, 1, 1024, subor)) != 0)
+  wc_ShaUpdate(&sha, data, pocet_bajtov);  
+  wc_ShaFinal(&sha, vysledok);
+  return vysledok;
+}
 
 void ukoncit_spojenie(WOLFSSL *ssl, WOLFSSL_CTX *ctx)
 {

kniznica/kryptografia.h

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #ifndef __KRYPTOGRAFIA_H__
@@ -16,9 +16,36 @@
 #include <wolfssl/wolfcrypt/rsa.h>
 #include <wolfssl/wolfcrypt/asn_public.h>
 #include <wolfssl/wolfcrypt/error-crypt.h>
+#include <wolfssl/wolfcrypt/sha.h>
 
-int generovat_ecc_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email);
+#define VELKOST_BUFFERA 4096
-int generovat_rsa_certifikat(WOLFSSL_CTX* ctx, int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email);
+
+/**
+ * generovat_hash: realizuje vypocet kontrolneho suctu zo suboru, ktoreho lokacia je predana v argumente
+ * @parameter char* cesta : lokacia suboru
+ * @vrati smernik na vygenerovany hash
+ */
+byte* generovat_hash(char* cesta);
+
+/**
+ * generovat_ecc_certifikat: realizuje vygenerovania sukromneho kluca, nacitanie sukromneho kluca autority,
+ *  vygenerovanie a podpis ecc certifikatu pomocou sukromneho kluca a certifikatu autority
+ * @parameter int pocet_bitov : velkost kluca
+ * @parameter ecc-curve_id kluc_krivka: kod krivky pre generovanie sukromneho kluca
+ * @parameter int algoritmus: kod algoritmu, sluziaceho na vymenu klucov
+ * @vrati int: operacia bola uspesna(0), neuspesna(-1)
+ */
+int generovat_ecc_certifikat(int pocet_bitov, ecc_curve_id kluc_krivka, int algoritmus, char* krajina, char* mesto, char* domena, char* email);
+
+/**
+ * generovat_rsa_certifikat: realizuje vygenerovania sukromneho kluca, nacitanie sukromneho kluca autority,
+ *  vygenerovanie a podpis rsa certifikatu pomocou sukromneho kluca a certifikatu autority
+ * @parameter int pocet_bitov : velkost kluca
+ * @parameter int exponent : hodnota exponentu
+ * @parameter int algoritmus : kod algoritmu, sluziaceho na vymenu klucov
+ * @vrati int : operacia bola uspesna(0), neuspesna(-1)
+ */
+int generovat_rsa_certifikat(int pocet_bitov, int exponent, int algoritmus, char* krajina, char* mesto, char* domena, char* email);
 
 /**
  * nastav_ctx_klient : realizuje vytvorenie a inicializaciu CTX struktury 

readme.txt

@@ -1,11 +1,23 @@
-Repozitar: Bakalarska praca
+Bakalarska praca                             
 Meno studenta: Tomas Lukac                   
-Datum poslednej upravy: 24.2.2020
+Veduci BP: prof. Ing. Milos Drutarovsky CSc. 
+Skola: KEMT FEI TUKE                         
+Datum poslednej upravy: 12.3.2020
 ----------------------------
 Zoznam zdrojovych suborov
   certifikaty
-    |__server.pem
+    |__autorita_ecc.pem
-    |__server.key 
+    |__autorita_ecc.key
+    |__autorita_rsa.pem
+    |__autorita_rsa.key 
+    |__server_ecc.pem
+    |__server_ecc.key 
+    |__server_rsa.pem
+    |__server_rsa.key 
+    |__klient_ecc.pem
+    |__klient_ecc.key
+    |__klient_rsa.pem
+    |__klient_rsa.key 
   kniznica
     |__komunikacia.h
     |__komunikacia.c
@@ -13,42 +25,82 @@ Zoznam zdrojovych suborov
     |__kryptografia.c
     |__vstup.h
     |__vstup.c
-  klient.c
+  tcpip_kanal
-  server.c
+    |__klient.c
-  Makefile
+    |__server.c
+    |__Makefile
+  rs232_kanal
+    |__klient.c
+    |__server.c
+    |__Makefile
 
 Opis aplikacie
-  Realizuje zabezpecenu vymenu sprav medzi klientom a serverom
+  Realizuje zabezpecenu vymenu sprav medzi klientom a serverom a autentizaciu servera klientom vyuzitim kniznice WolfSSL. Ako prvu je 
-  a autentizaciu servera klientom vyuzitim kniznice WolfSSL
+  potrebne spustit aplikaciu na strane servera s prepinacom port s hodnotou, ktora urcuje ake bude cislo portu, na ktorom bude server
+  cakar na prichadzajucu komunikaciu. Dalsim potrebnym prepinacom je bud -n (nacitanie certifikatov z adresaru /certifikaty) alebo 
+  -g (vygenerovanie a podpis certifikatov pomocou certifikatu a kluca autority, ktore sa nachadzaju taktiez v adresari /certifikaty).
+  Sukromne kluce a certifikaty su ulozene vo formate Privacy-Enhanced Mail (PEM). Nasledne je potrebne spustit aplikaciu na strane 
+  klienta, ktora okrem predchadzajucich parametrov vyzaduje parameter pre ip adresu: -ip adresa. Po vytvoreni zabezpeceneho prenosoveho
+  kanalu sa klient pokusi odoslat subor, ktoreho lokacia mu bola predana pri spusteni pomocou parametru -s subor. Pred samotnym poslanim
+  klient najprv vyhotovi kontrolny sucet suboru, ktory odosle po zabezpecenom kanali serveru. Ten po prijati suboru overi ci sa zhoduje
+  prijaty kontrolny sucet s jeho, ktory vyhotovil po prijati suboru. Ak pri prijati suboru nenastala chyba a kontrolne sucty sa zhoduju
+  server oznami ze prijem bol uspesny a dalej caka na komunikaciu. Klientsky program po odoslani suboru ukonci svoju cinnost. 
+
+Generovanie certifikatov RSA (OpenSSL)
+  openssl genrsa -out autorita_rsa.key 2048
+  openssl req -x509 -new -nodes -key autorita_rsa.key -sha256 -days 1825 -out autorita_rsa.pem
+  openssl x509 -outform pem -in autorita_rsa.pem -out autorita_rsa.crt
+  openssl genrsa -out server_rsa.key 2048
+  openssl req -new -key server_rsa.key -out server_rsa.csr
+  openssl x509 -req -in server_rsa.csr -CA autorita_rsa.pem -CAkey autorita_rsa.key -CAcreateserial -out server_rsa.pem -days 1825 -sha256 
+  openssl x509 -outform pem -in server_rsa.pem -out server_rsa.crt
+  openssl genrsa -out klient_rsa.key 2048
+  openssl req -new -key klient_rsa.key -out klient_rsa.csr
+  openssl x509 -req -in klient_rsa.csr -CA autorita_rsa.pem -CAkey autorita_rsa.key -CAcreateserial -out klient_rsa.pem -days 1825 -sha256 
+  openssl pkcs12 -inkey klient_rsa.key -in klient_rsa.pem -export -out klient_rsa.pfx
+
+Generovanie certifikatov ECC (OpenSSL)
+  openssl ecparam -genkey -name prime256v1 -out autorita_ecc.key
+  openssl req -x509 -new -nodes -key autorita_ecc.key -sha256 -days 1825 -out autorita_ecc.pem
+  openssl x509 -outform pem -in autorita_ecc.pem -out autorita_ecc.crt
+  openssl ecparam -genkey -name prime256v1 -out server_ecc.key
+  openssl req -new -key server_ecc.key -out server_ecc.csr
+  openssl x509 -req -in server_ecc.csr -CA autorita_ecc.pem -CAkey autorita_ecc.key -CAcreateserial -out server_ecc.pem -days 1825 -sha256 
+  openssl x509 -outform pem -in server_ecc.pem -out server_ecc.crt
+  openssl ecparam -genkey -name prime256v1 -out klient_ecc.key
+  openssl req -new -key klient_ecc.key -out klient_ecc.csr
+  openssl x509 -req -in klient_ecc.csr -CA autorita_ecc.pem -CAkey autorita_ecc.key -CAcreateserial -out klient_ecc.pem -days 1825 -sha256 
+  openssl pkcs12 -inkey klient_ecc.key -in klient_ecc.pem -export -out klient_ecc.pfx
+
 
 Navod na prelozenie a spustenie (Linux)
   1. prelozenie kniznice wolfssl s podporou OpenSSL (v adresari s kniznicou)
     ./configure --enable-opensslextra --enable-certgen --enable-keygen
     make
     sudo make install
-  2. prelozenie programov (v adresari)
+  2. prelozenie programov (v podadresari tcpip_kanal alebo rs232_kanal)
     make all
   3. spustenie
-    ./server -port port
+    ./server -port port -n rsa|ecc
-    ./server -port -g rsa|ecc
+    ./server -port port -g rsa|ecc
-    ./klient -ip 127.0.0.1 -port
+    ./klient -ip 127.0.0.1 -port port -n rsa|ecc -s subor
+    ./klient -ip 127.0.0.1 -port port -g rsa|ecc -s subor
 
 Navod na prelozenie a spustenie (Windows)
-  1. prelozenie programov (v adresari)
+  1. prelozenie programov (v podadresari tcpip_kanal alebo rs232_kanal)
     mingw32-make all
   2. spustenie
-    server -port port
+    server -port port -n rsa|ecc
-    server -port -g rsa|ecc
+    server -port port -g rsa|ecc
-    klient -ip 127.0.0.1 -port port
+    klient -ip 127.0.0.1 -port port -n rsa|ecc -s subor
+    klient -ip 127.0.0.1 -port port -g rsa|ecc -s subor
+
+Zoznam DLL suborov potrebnych pre spustenie (Windows)
+  1. vcruntime140.dll
+  2. wolfssl.dll
+  3. ws2_32.dll
+  Poznamka:
+    pre preklad na 64bit architekturach je nutne premennovat subory s koncovkami *_64.dll na nazvy DLLiek uvedenych vyssie
+    a povodne DLLka premenovat na ine nazvy, najlepsie *_32.dll
 
-Postup prace:
-  1. Spracovanie chyb pomocou stderr
-  2. Doplnenie hlavicky do zdrojovych suborov
-  3. Vytvorenie rutiny pre odosielanie suborov namiesto sprav
-  4. Upravenie Makefile pre kompilovanie na platforme Windows
-  5. Implementacia generovania certifikatov
-  6. Implementacia obojsmernej autentizacie
  
-TODO:
-  4. vytvorenie rozhrania pre komunikacny kanal rs232 pomocou wolfssl abstraction layer
-    (wolfssl.com/docs/wolfssl-manual/ch5)

rs232_kanal/Makefile

@@ -3,7 +3,7 @@
 ## Meno studenta: Tomas Lukac                   ##
 ## Veduci BP: prof. Ing. Milos Drutarovsky CSc. ##
 ## Skola: KEMT FEI TUKE                         ##
-## Datum poslednej upravy: 9.3.2020             ##
+## Datum poslednej upravy: 12.3.2020            ##
 ##################################################
 
 #prekladac

rs232_kanal/klient.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include <stdio.h>
@@ -28,39 +28,6 @@ int cislo_portu = 2;
 int baud_frekvencia = 9600;
 char rezim[]={'8','N','1', 0};
 
-/**
- * rs232_zapis: umoznuje zapis dat do serialoveho portu
- * @parameter WOLSSL* ssl : ukazuje na aktualnu relaciu
- * @parameter char* buf : ukazuje na buffer, do kt. zapise wolfssl zasifrovany text na odoslanie
- * @parameter int sz : velkost buffera
- * @vrati int
- */
-int rs232_zapis(WOLFSSL *ssl, char *buf, int sz, void *ctx)
-{ 
-  printf("Klient posiela ...\n");
-  int n = RS232_SendBuf(cislo_portu, buf, sz);  
-  printf("Klient poslal %d bajtov...\n", n);
-  return n;
-}
-
-/**
- * rs232_citanie: umoznuje citanie dat zo serialoveho portu
- * @parameter WOLFSSL* ssl : ukazuje na aktualnu relaciu
- * @parameter char* buf : ukazuje na buffer, kde prichadzajuci zasifrovany text by mal byt nakopirovany 
- *   aby ho wolfssl mohla odsifrovat
- * @parameter int sz : velkost buffera
- * @vrati int
- */
-int rs232_citanie(WOLFSSL *ssl, char *buf, int sz, void *ctx)
-{
-  printf("Klienta prijima...\n");
-  int n;
-  while(n <= 0)
-  n = RS232_PollComport(cislo_portu, buf, sz);
-  printf("Klienta prijal %d bajtov.\n", n);
-  return n;
-}
-
 int main(int argc, char const *argv[])
 {
   WOLFSSL *ssl; 
@@ -96,7 +63,7 @@ int main(int argc, char const *argv[])
   int uspech = 0;
   if(wolfSSL_connect(ssl) != SSL_SUCCESS)
   {
-    printf("nepodarilo sa pripojit\n");
+    printf("Nepodarilo sa pripojit\n");
     return -1;
   }
 

rs232_kanal/server.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include <stdio.h>
@@ -27,56 +27,6 @@ int cislo_portu = 3;
 int baud_frekvencia = 9600;
 char rezim[]={'8','N','1', 0};
 
-/**
- * rs232_zapis: umoznuje zapis dat do serialoveho portu
- * @parameter WOLSSL* ssl : ukazuje na aktualnu relaciu
- * @parameter char* buf : ukazuje na buffer, do kt. zapise wolfssl zasifrovany text na odoslanie
- * @parameter int sz : velkost buffera
- * @vrati int
- */
-int rs232_zapis(WOLFSSL *ssl, char *buf, int sz, void *ctx)
-{ 
-  printf("Server posiela ...\n");
-  int n = RS232_SendBuf(cislo_portu, buf, sz);
-  printf("Server poslal %d bajtov\n", n);
-  return n;
-}
-
-/**
- * rs232_citanie: umoznuje citanie dat zo serialoveho portu
- * @parameter WOLFSSL* ssl : ukazuje na aktualnu relaciu
- * @parameter char* buf : ukazuje na buffer, kde prichadzajuci zasifrovany text by mal byt nakopirovany 
- *   aby ho wolfssl mohla odsifrovat
- * @parameter int sz : velkost buffera
- * @vrati int
- */
-int rs232_citanie(WOLFSSL *ssl, char *buf, int sz, void *ctx)
-{
-  printf("Server prijima...\n");
-  int n;
-  int prijal = 0;
-  while(1)
-  {
-    n = RS232_PollComport(cislo_portu, buf, sz);
-    if(n > 0)
-    {
-      buf[n] = '\0';   /* always put a "null" at the end of a string! */
-      for(int i=0; i < n; i++)
-      {
-        if(buf[i] < 32)  /* replace unreadable control-codes by dots */
-        {
-          buf[i] = '.';
-        }
-      }
-      printf("received %i bytes: %s\n", n, (char *)buf);
-    }
-    prijal += n;
-
-  }
-  return n;
-}
-
-
 int main(int argc, char const *argv[])
 {
   WOLFSSL *ssl; 

tcpip_kanal/Makefile

@@ -3,36 +3,36 @@
 ## Meno studenta: Tomas Lukac                   ##
 ## Veduci BP: prof. Ing. Milos Drutarovsky CSc. ##
 ## Skola: KEMT FEI TUKE                         ##
-## Datum poslednej upravy: 9.3.2020             ##
+## Datum poslednej upravy: 12.3.2020            ##
 ##################################################
 
 #prekladac
 CC = gcc
 
 #prepinace pre prekladac
-CFLAGS = -Wall -Wcpp -fPIC -DREPLICATION_ENABLED -DJOURNALING_ENABLED -I./../wolfssl_hlavickove_subory/
+CFLAGS = -Wcpp -I./../wolfssl_hlavickove_subory/
 LIB32 = -L. -lwolfssl -lws2_32 -Os
 LIB64 = -L. -lwolfssl -lws2_32 -m64
 
 all: klient server
 
 klient: klient.o kryptografia.o komunikacia.o
-	$(CC) $(CFLAGS) -o klient klient.o kryptografia.o komunikacia.o $(LIB64)
+	$(CC) $(CFLAGS) -o klient klient.o kryptografia.o komunikacia.o $(LIB32)
 
 server: server.o kryptografia.o komunikacia.o
-	$(CC) $(CFLAGS) -o server server.o kryptografia.o komunikacia.o $(LIB64)
+	$(CC) $(CFLAGS) -o server server.o kryptografia.o komunikacia.o $(LIB32)
 
 klient.o: klient.c
-	$(CC) $(CFLAGS) -c klient.c $(LIB64)
+	$(CC) $(CFLAGS) -c klient.c $(LIB32)
 
 server.o: server.c
-	$(CC) $(CFLAGS) -c server.c $(LIB64) 
+	$(CC) $(CFLAGS) -c server.c $(LIB32) 
 
 kryptografia.o: ../kniznica/kryptografia.c ../kniznica/kryptografia.h
-	$(CC) $(CFLAGS) -c ../kniznica/kryptografia.c $(LIB64)
+	$(CC) $(CFLAGS) -c ../kniznica/kryptografia.c $(LIB32)
 
 komunikacia.o: ../kniznica/komunikacia.c ../kniznica/komunikacia.h
-	$(CC) $(CFLAGS) -c ../kniznica/komunikacia.c $(LIB64)
+	$(CC) $(CFLAGS) -c ../kniznica/komunikacia.c $(LIB32)
 
 .PHONY: clean
 

tcpip_kanal/klient.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include "../kniznica/kryptografia.h"
@@ -17,9 +17,9 @@
 
 int main(int argc, char** argv)
 {
-  int autentizacia_klienta = 0;
   int generovanie_certifikatu = 0;
   int nacitanie_zo_suboru = 0;
+  int uvedeny_subor = 0;
   int ip = 0;
   int port = 0;
 
@@ -34,8 +34,9 @@ int main(int argc, char** argv)
   
   int cislo_soketu = 0;
   int cislo_portu = 0;
-  char *ip_adresa = NULL;
+  char* ip_adresa = NULL;
-   const char *subor_certifikat = NULL;
+  char* subor = NULL;
+  const char *subor_certifikat = NULL;
   const char *subor_kluc = NULL;
   WOLFSSL *ssl; WOLFSSL_CTX *ctx;
   
@@ -49,6 +50,19 @@ int main(int argc, char** argv)
     //ak ano pozrie aky typ certifikatu (v CLI argument hned za nim) bol zvoleny
     for(int i = 0; i < argc; i++)
     {
+     if( (!strcmp(argv[i], "-s")) )
+      {
+        uvedeny_subor = 1;
+        if((argv[i+1] == NULL) )
+        {
+          printf("Nezadali ste cestu ku suboru\n");
+          return -1;
+        }
+        else
+        {
+          subor = argv[i+1];
+        }
+      } 
       if( (!strcmp(argv[i], "-ip")) )
       {
         port = 1;
@@ -119,14 +133,18 @@ int main(int argc, char** argv)
         else if(!strcmp(argv[i+1], "rsa"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_rsa.pem", NULL);
-          if(generovat_rsa_certifikat(ctx, RSA_VELKOST, RSA_EXPONENT, CTC_SHA256wRSA, "SR", "Kosice", "Klient.sk", "klient@klient.sk") == -1)
+          if(generovat_rsa_certifikat(RSA_VELKOST, RSA_EXPONENT, CTC_SHA256wRSA, "SR", "Kosice", "Klient.sk", "klient@klient.sk") == -1) return -1;
-          return -1;
+          subor_certifikat = "../certifikaty/vygenerovany_certifikat.pem";
+          subor_kluc = "../certifikaty/vygenerovany_kluc.key";
+          if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
         }
         else if(!strcmp(argv[i+1], "ecc"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_ecc.pem", NULL);
-          if(generovat_ecc_certifikat(ctx, ECC_VELKOST, ECC_PRIME239V1, CTC_SHAwECDSA, "SR", "Kosice", "Klient.sk", "klient@klient.sk") == -1)
+          if(generovat_ecc_certifikat(ECC_VELKOST, ECC_SECP256R1, CTC_SHAwECDSA, "SR", "Kosice", "Klient.sk", "klient@klient.sk") == -1) return -1;
-          return -1;
+          subor_certifikat = "../certifikaty/vygenerovany_certifikat.pem";
+          subor_kluc = "../certifikaty/vygenerovany_kluc.key";
+          if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
         }
         else
         {
@@ -146,12 +164,17 @@ int main(int argc, char** argv)
       printf("Nebol urceny port\n");
       return -1;
     }
-    if(!generovanie_certifikatu && !nacitanie_zo_suboru)
+    else if(!generovanie_certifikatu && !nacitanie_zo_suboru)
     {
       fprintf(stderr, "Nebola zvolena metoda nacitania certifikatov\n");
       printf("Zadajde prepinac -g (generovanie), alebo -n (nacitanie_zo_suboru) s parametrom rsa alebo ecc\n");
       return -1;
     }
+    else if(!uvedeny_subor)
+    {
+      fprintf(stderr, "Nebola uvedena cesta ku suboru na odoslanie\n");
+      return -1;
+    }
     //umoznuje vybrat sifry ktore sa budu nachadzat v sifrovacom subore
     //nastav_sifry(ctx, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256");
 
@@ -169,7 +192,7 @@ int main(int argc, char** argv)
     } 
     zobraz_sifru(ssl);
     zobraz_certifikat(ssl);
-    if(poslat_subor(ssl, ctx, "nieco.txt") == -1) return -1;
+    if(poslat_subor(ssl, ctx, subor) == -1) return -1;
     ukoncit_spojenie(ssl, ctx);
   }
   

tcpip_kanal/server.c

@@ -3,7 +3,7 @@
 // Meno studenta: Tomas Lukac                   //
 // Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
 // Skola: KEMT FEI TUKE                         //
-// Datum poslednej upravy: 9.3.2020             //
+// Datum poslednej upravy: 12.3.2020            //
 //////////////////////////////////////////////////
 
 #include "../kniznica/kryptografia.h"
@@ -77,6 +77,7 @@ int main(int argc, char **argv)
         else if(!strcmp(argv[i+1], "rsa"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_rsa.pem", NULL);
+          wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, 0);
           subor_certifikat = "../certifikaty/server_rsa.pem";
           subor_kluc = "../certifikaty/server_rsa.key";
           if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
@@ -84,6 +85,7 @@ int main(int argc, char **argv)
         else if(!strcmp(argv[i+1], "ecc"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_ecc.pem", NULL);
+          wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, 0);
           subor_certifikat = "../certifikaty/server_ecc.pem";
           subor_kluc = "../certifikaty/server_ecc.key";
           if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
@@ -110,16 +112,18 @@ int main(int argc, char **argv)
         else if(!strcmp(argv[i+1], "rsa"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_rsa.pem", NULL);
-          if(generovat_rsa_certifikat(ctx, RSA_VELKOST, RSA_EXPONENT, CTC_SHA256wRSA, "SR", "Kosice", "Server.sk", "server@server.sk") == -1)
+          if(generovat_rsa_certifikat(RSA_VELKOST, RSA_EXPONENT, CTC_SHA256wRSA, "SR", "Kosice", "Server.sk", "server@server.sk") == -1) return -1;
-          return -1;
+          subor_certifikat = "../certifikaty/vygenerovany_certifikat.pem";
-
+          subor_kluc = "../certifikaty/vygenerovany_kluc.key";
+          if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
         }
         else if(!strcmp(argv[i+1], "ecc"))
         {
           wolfSSL_CTX_load_verify_locations(ctx, "../certifikaty/autorita_ecc.pem", NULL);
-          if(generovat_ecc_certifikat(ctx, ECC_VELKOST, ECC_PRIME239V1, CTC_SHAwECDSA, "SR", "Kosice", "Server.sk", "server@server.sk") == -1)
+          if(generovat_ecc_certifikat(ECC_VELKOST, ECC_SECP256R1, CTC_SHAwECDSA, "SR", "Kosice", "Server.sk", "server@server.sk") == -1) return -1;
-          return -1;
+          subor_certifikat = "../certifikaty/vygenerovany_certifikat.pem";
-
+          subor_kluc = "../certifikaty/vygenerovany_kluc.key";
+          if(nacitat_certifikaty(ctx, subor_certifikat, subor_kluc) == -1) return -1;
         }
         else
         {
@@ -134,7 +138,7 @@ int main(int argc, char **argv)
       fprintf(stderr, "Nebol urceny port\n");
       return -1;
     }
-    if(!generovanie_certifikatu && !nacitanie_zo_suboru)
+    else if(!generovanie_certifikatu && !nacitanie_zo_suboru)
     {
       fprintf(stderr, "Nebola zvolena metoda nacitania certifikatov\n");
       printf("Zadajde prepinac -g (generovanie), alebo -n (nacitanie_zo_suboru) s parametrom rsa alebo ecc\n");

tcpip_kanal/spustit_klient.bat

@@ -7,8 +7,9 @@
 ::::::::::::::::::::::::::::::::::::::::::::::::::
 
 :: Program je mozne spustit s prepinacmi:
-:: -g rsa|ecc sluzi na generovanie certifikatu, ak ho neuvedieme program sa pokusi nacitat certifikaty z adresara /certifikaty
+:: -g rsa|ecc sluzi na generovanie certifikatu
+:: -n rsa|ecc sluzi na nacitanie uz vygenerovanych certifikatov z adresara /certifikaty
 :: -s cesta-ku-suboru sluzi na nacitanie cesty k suboru, ktory chceme odoslat (este nie je)
 
 ::Priklady spustenia:
-klient -ip 127.0.0.1 -port 8080
+klient -ip 127.0.0.1 -port 8080 -n rsa

tcpip_kanal/spustit_server.bat

@@ -7,9 +7,9 @@
 ::::::::::::::::::::::::::::::::::::::::::::::::::
 
 :: Program server je mozne spustit s prepinacmi:
-:: -g rsa|ecc sluzi na generovanie certifikatu, ak ho neuvedieme program sa pokusi nacitat certifikaty z adresara /certifikaty
+:: -g rsa|ecc sluzi na generovanie certifikatu
+:: -n rsa|ecc sluzi na nacitanie uz vygenerovanych certifikatov z adresara /certifikaty
 
 ::Priklady spustenia:
-server -port 8080 
+server -port 8080 -n rsa 
 ::server -port 8080 -g ecc 
-::server -port 8080 

teoria.txt

@@ -1,16 +0,0 @@
-I/O rutiny
-  - implicitne su pouzite recv() a send() funkcie ktore realizuju citanie zapis do file descriptoru nastavenho pomocou wolfssl_set_fd()
-  - prototypy vlastnych funkcii
-    int CBIORecv(CYASSL* ssl, char* buf, int sz, void* ctx)
-    int CBIOSend(CYASSL* ssl, char* buf, int sz, void* ctx)
-  - implicitne je descriptor sietoveho soketu posunuty do i/o rutiny v ctx parametri
-  - ssl je ukazovatel na aktualnu relaciu
-  - receive
-    - buf -> ukazuje na buffer, kde prichadzajuci zasifrovany text by mal byt nakopirovany aby ho wolfssl mohla odsifrovat
-    - sz -> velkost bufferu
-  - send
-    - buf -> ukazuje na buffer do ktoreho wolfssl zapisala zasifrovany text na odoslanie
-    - sz -> velkost bufferu
-  - registracia funkcii
-    wolfSSL_SetIORecv(ctx, myCBIORecv)
-    wolfSSL_SetIOSend(ctx, myCBIOSend)