User Tools

Site Tools


sk2:openssl_ssl_api

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
sk2:openssl_ssl_api [2024/11/22 07:15] – jkonczaksk2:openssl_ssl_api [2026/11/17 22:22] (current) – [Klucze i certyfikaty] jkonczak
Line 10: Line 10:
 Wygeneruj potrzebne pliki za pomocą powyższego skryptu. Wygeneruj potrzebne pliki za pomocą powyższego skryptu.
 Wyświetl informacje o certyfikatach komendą: \\ Wyświetl informacje o certyfikatach komendą: \\
-''openssl x509 -noout -text -certopt no_sigdump,no_pubkey -in <scieżka do certyfikatu>'' +''openssl x509 -noout -text -certopt no_sigdump,no_pubkey -in <scieżka do pliku certyfikatu>'' 
  
 ==== Gotowe narzędzia do tworzenia prostych połączeń TLS w powłoce ==== ==== Gotowe narzędzia do tworzenia prostych połączeń TLS w powłoce ====
Line 32: Line 32:
 ''-quiet'' wyłącza zupełnie komunikaty diagnostyczne, ''-quiet'' wyłącza zupełnie komunikaty diagnostyczne,
 ''-brief'' skraca komunikaty diagnostyczne; bez tych przełączników są pokazywane ''-brief'' skraca komunikaty diagnostyczne; bez tych przełączników są pokazywane
-długie komunkty+długie komunkaty
 \\ \\
 ''[-connect] <host>:<port>'' wskazuje gdzie się połączyć; słowo kluczowe ''[-connect] <host>:<port>'' wskazuje gdzie się połączyć; słowo kluczowe
Line 38: Line 38:
 </small> </small>
  
-''**socat** [open]ssl://put.poznan.pl//://443//,verify=0[,crlf] stdio''+''**socat** [-ddd] [open]ssl://put.poznan.pl//://443//[,verify=0][,crlf] stdio''
 \\ \\
 np. ''socat ssl:mail.put.poznan.pl:imaps,verify=0 stdio'' np. ''socat ssl:mail.put.poznan.pl:imaps,verify=0 stdio''
 \\ \\
 <small> <small>
-''verify=0'' wyłącza sprawdzanie certyfikatu serwera+''-ddd'' włącza komunikaty diagnostyczne (3 poziomu) programu ''socat'' 
 +\\ 
 +''verify=0'' wyłącza sprawdzanie certyfikatu drugiej strony (tutaj: serwera)
 \\ \\
 ''crlf'' zamienia w wysyłanych danych ''\n'' na ''\r\n'' ''crlf'' zamienia w wysyłanych danych ''\n'' na ''\r\n''
Line 49: Line 51:
  
 ~~Zadanie.#~~ ~~Zadanie.#~~
-Połącz się z serwerem stron internetowych i otrzymaj od niego odpowiedź.+Połącz się z dowolnym serwerem stron internetowych programem ''openssl'' lub 
 +''socat'' i  otrzymaj od niego odpowiedź.
 \\ \\
 Kto podpisał certyfikat tego serwera? Czy certyfikat został zweryfikowany poprawnie? Kto podpisał certyfikat tego serwera? Czy certyfikat został zweryfikowany poprawnie?
Line 77: Line 80:
 \\ \\
 ''cert=<chain>'' podaje ścieżkę do (łańcucha) certyfikatów które podpisały certyfikat serwera ''cert=<chain>'' podaje ścieżkę do (łańcucha) certyfikatów które podpisały certyfikat serwera
 +\\
 +''verify=0'' wyłącza sprawdzanie certyfikatu drugiej strony (tutaj: klienta)
 \\ \\
 ''fork'' nakazuje socatowi się sklonować po nawiązaniu połączenia; jeden proces ''fork'' nakazuje socatowi się sklonować po nawiązaniu połączenia; jeden proces
Line 147: Line 152:
 trzeba linkować do bibliotek ''libssl'' oraz ''libcrypto'', np: trzeba linkować do bibliotek ''libssl'' oraz ''libcrypto'', np:
 \\ \\
-''c++ //prog.cpp// -o //prog// **-lssl -lcrypto**''+''c%%++%% //prog.cpp// -o //prog// **-lssl -lcrypto**''
  
 Przy użyciu CMake należy dodać do pliku ''CMakeLists.txt'' wyszukanie biblioteki Przy użyciu CMake należy dodać do pliku ''CMakeLists.txt'' wyszukanie biblioteki
Line 264: Line 269:
 internetową. internetową.
  
-==== Kolejne przykładowe programy ====+==== Kolejne przykładowe programy serwera ====
  
 === Iteracyjny serwer z minimalną obsługą błędów === === Iteracyjny serwer z minimalną obsługą błędów ===
  
 +
 +__Uwaga__: kompiluj  poniższy kod ze standardem %%C++20%% lub nowszym (opcja ''--std=c%%++%%20'')
 <code cpp daytime_tls_server.cpp> <code cpp daytime_tls_server.cpp>
 #include <cstdio> #include <cstdio>
Line 293: Line 300:
     // Wybiera konfigurację dla serwera     // Wybiera konfigurację dla serwera
     SSL_CTX *ctx = SSL_CTX_new(TLS_server_method());     SSL_CTX *ctx = SSL_CTX_new(TLS_server_method());
-    SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY); 
  
     // Ładuje klucz prywatny serwera     // Ładuje klucz prywatny serwera
Line 351: Line 357:
         std::chrono::system_clock::now());         std::chrono::system_clock::now());
     return std::format(     return std::format(
-        "HTTP/2 200\r\n"+        "HTTP/1.1 200 Ok\r\n"
         "content-type: text/plain\r\n"         "content-type: text/plain\r\n"
         "content-length: {}\r\n"         "content-length: {}\r\n"
Line 362: Line 368:
 ~~Zadanie.#~~ Powtórz poprzednie zadanie używając kodu tego serwera. ~~Zadanie.#~~ Powtórz poprzednie zadanie używając kodu tego serwera.
  
-=== Klient z obsługą błędów ===+==== Zadania – klient ==== 
 + 
 + 
 +~~Zadanie.#~~ Poniżej znajduje się kod wysyłający jedno żądanie HTTP do podanego 
 +serwera i wyświetlający podsumowanie odpowiedzi. Zmień ten kod tak, żeby: 
 +  * łączył się na port ''https'' zamiast ''http'' 
 +  * nawiązywał połączenie szyfrowane 
 +   
 +<code cpp http_client.cpp> 
 +#include <errno.h> 
 +#include <netdb.h> 
 +#include <sys/socket.h> 
 +#include <unistd.h> 
 + 
 +#include <cstdio> 
 +#include <regex> 
 +#include <string> 
 +#include <string_view> 
 +using namespace std::literals; 
 + 
 +#include <openssl/err.h> 
 +#include <openssl/ssl.h> 
 + 
 +void die(const char *format, ...) { 
 +  va_list args; 
 +  va_start(args, format); 
 +  vfprintf(stderr, format, args); 
 +  va_end(args); 
 +  exit(1); 
 +} 
 + 
 +void summarizeHttpResponse(const std::string &response) { 
 +  auto eos = response.find("\r\n"); 
 +  auto eoh = response.find("\r\n\r\n"); 
 +  if (eos != std::string::npos && eoh != std::string::npos) { 
 +    std::string status  (response.data()          , eos                        ); 
 +    std::string headers (response.data() + eos + 2, eoh               - eos - 2); 
 +    std::string body    (response.data() + eoh + 4, response.length() - eoh - 4); 
 + 
 +    printf("%s\n", status.data()); 
 +    if (std::smatch m; std::regex_search(headers, m, std::regex("(?:^|\n)(Location:.*)"))) 
 +      printf("%s\n", m[1].str().data()); 
 +    if (std::smatch m; std::regex_search(body,    m, std::regex("<title[>\\s][^]*?</title>"))) 
 +      printf("\n%s\n", m[0].str().data()); 
 +  } else 
 +    printf("%s", response.data()); 
 +} 
 + 
 +int main(int argc, char **argv) { 
 +  if (argc != 2) 
 +    die("Usage: %s <hostname>\n", argv[0]); 
 + 
 +  addrinfo *res; 
 +  if (int ec = getaddrinfo(argv[1], "http", 0, &res)) 
 +    die("getaddrinfo failed: %s\n", gai_strerror(ec)); 
 +  int sock = socket(res->ai_family, SOCK_STREAM, 0); 
 +  if (connect(sock, res->ai_addr, res->ai_addrlen) != 0) 
 +    die("connect failed: %s\n", strerror(errno)); 
 +  freeaddrinfo(res); 
 + 
 +  std::string httpRequest; 
 +  httpRequest += "GET / HTTP/1.1\r\n"; 
 +  httpRequest += "Host: "s + argv[1] + "\r\n"; 
 +  httpRequest += "Connection: close\r\n"; 
 +  httpRequest += "\r\n"; 
 + 
 +  write(sock, httpRequest.data(), httpRequest.length()); 
 + 
 +  std::string response; 
 +  while (1) { 
 +    char buf[2048]; 
 +    int cnt = read(sock, buf, 2048); 
 +    if (cnt <= 0) 
 +      break; 
 +    response += std::string_view(buf, cnt); 
 +  } 
 +  summarizeHttpResponse(response); 
 + 
 +  shutdown(sock, SHUT_RDWR); 
 +  close(sock); 
 +  return 0; 
 +} 
 +</code> 
 + 
 +~~Zadanie.#~~ Otwórz w przeglądarce internetowej adres [[https://maxine.put.poznan.pl]]. 
 +Czy twoja przeglądarka uznaje to połączenie za bezpieczne? 
 +A czy twój program uznaje to połączenie za bezpieczne? 
 + 
 +~~Zadanie.#~~ Zmień program z zadania 9 tak, by sprawdzał czy można ufać serwerowi. 
 +W tym celu musisz: 
 +  * załadować certyfikaty urzędów certyfikacji; openssl pozwala załadować systemowy zbiór certyfikatów CA<html> 
 +    </html>funkcją ''[[https://docs.openssl.org/master/man3/SSL_CTX_load_verify_locations/|SSL_CTX_set_default_verify_paths]]'', 
 +  * poinformować bibliotekę openssl czyjego certyfikatu się spodziewasz – jeżeli samodzielnie tworzysz<html> 
 +    </html>połączenie sieciowe, to openssl nie wie czyj certyfikat powinien otrzymać; możesz to określić<html> 
 +    </html>funkcją ''[[https://docs.openssl.org/master/man3/SSL_set1_host/|SSL_set1_host]]'', 
 +  * sprawdzić czy certyfikat otrzymany od serwera podczas nawiązywania połączenia jest w porządku<html> 
 +    </html>używając funkcji ''[[https://docs.openssl.org/master/man3/SSL_get_verify_result/|SSL_get_verify_result]]'', 
 +  * jeżeli nie, to możesz przerobić kod błędy zwrócony przez ''SSL_get_verify_result'' na krótki<html> 
 +    </html>tekst z przyczyną błędu funkcją ''[[https://docs.openssl.org/master/man3/X509_STORE_CTX_get_error/|X509_verify_cert_error_string]]'' 
 +<html><div style="margin-top:-1.4em"></div></html> 
 +Sprawdź czy po takiej zmianie kodu połączenie do maxine.put.poznan.pl zwraca błąd, 
 +a połączenie do put.poznan.pl jest zaufane. 
 + 
 +~~Zadanie.#~~a Czy program z poprzedniego zadania uważa połączenie z cat.put.poznan.pl 
 +za bezpieczne? 
 + 
 +Jeżeli serwer pod jednym adresem adresem IP obsługuje wiele domen, to musi od klienta 
 +się dowiedzieć którym certyfikatem się ma przedstawić. W tym celu klient musi podać 
 +nazwę serwera do której się łączy w rozszerzeniu SNI (Server Name Indication). 
 +\\ 
 +<small>Szczegóły możesz docztać na [[https://en.wikipedia.org/wiki/Server_Name_Indication|wikipedii]] 
 +albo na e-learningu [[https://www.cloudflare.com/learning/ssl/what-is-sni/|cloudflare]].</small> 
 + 
 +~~Zadanie.#12~~b Dodaj do programu z poprzedniego zadania przesyłanie do serwera 
 +w momencie nawiązywania połączenia TLS informacji do kogo klient chce się połączyć 
 +funkcją [[https://docs.openssl.org/master/man3/SSL_CTX_set_tlsext_servername_callback/|SSL_set_tlsext_host_name]]. 
 + 
 +     
 +==== [ekstra] Przykładowe programy klienta ==== 
 + 
 +=== Klient wykorzystujący zdarzenia i nieblokującą komunikację, z obsługą błędów === 
 + 
 +++++ Rozwiń… |
  
 Poniższy kod klienta: Poniższy kod klienta:
Line 376: Line 504:
 #include <poll.h> #include <poll.h>
 #include <string> #include <string>
 +#include <string_view>
 #include <sys/socket.h> #include <sys/socket.h>
 #include <unistd.h> #include <unistd.h>
 +    
 #include <openssl/err.h> #include <openssl/err.h>
 #include <openssl/ssl.h> #include <openssl/ssl.h>
 +    
 void die(const char *format, ...) { void die(const char *format, ...) {
     va_list args;     va_list args;
Line 389: Line 518:
     exit(1);     exit(1);
 } }
 +    
 int main(int argc, char **argv) { int main(int argc, char **argv) {
     if (argc != 3)     if (argc != 3)
         die("Usage: %s <ip> <port>\n", argv[0]);         die("Usage: %s <ip> <port>\n", argv[0]);
 +    
     // tworzy gniazdo i nawiązuje połączenie TCP     // tworzy gniazdo i nawiązuje połączenie TCP
     addrinfo *res;     addrinfo *res;
Line 402: Line 531:
         die("connect failed\n");         die("connect failed\n");
     freeaddrinfo(res);     freeaddrinfo(res);
 +    
     /* ───────────────────────────────────────────────────────────────────── */     /* ───────────────────────────────────────────────────────────────────── */
 +    
     // wybiera konfigurację warstwy szyfrującej     // wybiera konfigurację warstwy szyfrującej
     SSL_CTX *ctx = SSL_CTX_new(TLS_client_method()); // podstawowe ustawienia dla klienta TLS     SSL_CTX *ctx = SSL_CTX_new(TLS_client_method()); // podstawowe ustawienia dla klienta TLS
     SSL_CTX_set_default_verify_paths(ctx); // nakazuje użyć systemowych certyfikatów CA     SSL_CTX_set_default_verify_paths(ctx); // nakazuje użyć systemowych certyfikatów CA
 +    
     // żeby przetestować weryfikację certyfikatu bez instalowania certyfikatu CA w systemie:     // żeby przetestować weryfikację certyfikatu bez instalowania certyfikatu CA w systemie:
     // ustaw zmienną środowiskową MY_ROGUE_CA ma ścieżkę do własnego certyfikatu CA     // ustaw zmienną środowiskową MY_ROGUE_CA ma ścieżkę do własnego certyfikatu CA
     if (getenv("MY_ROGUE_CA"))     if (getenv("MY_ROGUE_CA"))
         SSL_CTX_load_verify_file(ctx, getenv("MY_ROGUE_CA"));         SSL_CTX_load_verify_file(ctx, getenv("MY_ROGUE_CA"));
 +    
     /* ───────────────────────────────────────────────────────────────────── */     /* ───────────────────────────────────────────────────────────────────── */
 +    
     // tworzy obiekt reprezentujący warstwę szyfrującą i nakazuje mu czytać/pisać do pliku gniazda     // tworzy obiekt reprezentujący warstwę szyfrującą i nakazuje mu czytać/pisać do pliku gniazda
     SSL *encryption_layer = SSL_new(ctx);     SSL *encryption_layer = SSL_new(ctx);
     SSL_set_fd(encryption_layer, cli);     SSL_set_fd(encryption_layer, cli);
 +    
     // informuje bibliotekę jakiej nazwie powinien odpowiadać certyfikat     // informuje bibliotekę jakiej nazwie powinien odpowiadać certyfikat
     SSL_set1_host(encryption_layer, argv[1]);     SSL_set1_host(encryption_layer, argv[1]);
 +    
     // ustanawia komunikację szyfrowaną TLS (na wskazanym połączeniu TCP) wykonując handshake     // ustanawia komunikację szyfrowaną TLS (na wskazanym połączeniu TCP) wykonując handshake
     if (SSL_connect(encryption_layer) != 1)     if (SSL_connect(encryption_layer) != 1)
         die("TLS handshake failed!\n");         die("TLS handshake failed!\n");
 +    
     // odbiera wyniki weryfikacji poprawności otrzymanego od serwera certyfikatu     // odbiera wyniki weryfikacji poprawności otrzymanego od serwera certyfikatu
     long serverCertStatus = SSL_get_verify_result(encryption_layer);     long serverCertStatus = SSL_get_verify_result(encryption_layer);
Line 432: Line 561:
         fprintf(stderr, "[Warning: server certificate verification failed - %s!]\n",         fprintf(stderr, "[Warning: server certificate verification failed - %s!]\n",
                 X509_verify_cert_error_string(serverCertStatus));                 X509_verify_cert_error_string(serverCertStatus));
 +    
     /* ───────────────────────────────────────────────────────────────────── */     /* ───────────────────────────────────────────────────────────────────── */
          
Line 444: Line 573:
         ERR_print_errors_fp(stderr);                               \         ERR_print_errors_fp(stderr);                               \
         goto close_connection;         goto close_connection;
 +    
     pollfd pfds[2]{     pollfd pfds[2]{
         {.fd = 0,   .events = POLLIN},         {.fd = 0,   .events = POLLIN},
         {.fd = cli, .events = POLLIN},         {.fd = cli, .events = POLLIN},
     };     };
 +    
     // zdarzenia które są potrzebne do odczytania i zapisu danych przez warstwę szyfrującą     // zdarzenia które są potrzebne do odczytania i zapisu danych przez warstwę szyfrującą
-    int readNeeds = POLLIN; // uwaga: TLS może potrzebować zrobić zapis do gniazda żeby odebrać dane +    short int readNeeds = POLLIN; // uwaga: TLS może potrzebować zrobić zapis do gniazda żeby odebrać dane 
-    int writeNeeds = 0; // uwaga: TLS może potrzebować zrobić odczyt do gniazda żeby wysłać dane +    short int writeNeeds = 0;     // uwaga: TLS może potrzebować zrobić odczyt do gniazda żeby wysłać dane 
 +    short int mask; 
 +    
     // bufor na odbierane dane     // bufor na odbierane dane
     char recvBuffer[255];     char recvBuffer[255];
Line 461: Line 591:
     // uwaga: jeśli nieblokujące SSL_write się nie powiodło bo musiałoby czekać,     // uwaga: jeśli nieblokujące SSL_write się nie powiodło bo musiałoby czekać,
     //        trzeba je powtórzyć z identycznymi argumentami; stąd dwa bufory     //        trzeba je powtórzyć z identycznymi argumentami; stąd dwa bufory
 +    
     // ustawia gniazdo w tryb nieblokujący (!)     // ustawia gniazdo w tryb nieblokujący (!)
     fcntl(cli, F_SETFL, fcntl(cli, F_GETFL) | O_NONBLOCK);     fcntl(cli, F_SETFL, fcntl(cli, F_GETFL) | O_NONBLOCK);
Line 467: Line 597:
     // gnieździe, co przy blokującym trybie i użyciu zdarzeń mogłoby zablokować     // gnieździe, co przy blokującym trybie i użyciu zdarzeń mogłoby zablokować
     // program na obsłudze któregoś zdarzenia; stąd tryb nieblokujący     // program na obsłudze któregoś zdarzenia; stąd tryb nieblokujący
 +    
     while (1) {     while (1) {
         poll(pfds, 2, -1);         poll(pfds, 2, -1);
 +    
         if (pfds[0].revents) {         if (pfds[0].revents) {
-            char buf[256];+            char buf[255];
             int c = read(0, buf, 255);             int c = read(0, buf, 255);
             if (c > 0) {             if (c > 0) {
-                buf[c] = 0; +                dataWaitingToBeWritten += std::string_view(buf, c);
-                dataWaitingToBeWritten += buf;+
                 writeNeeds |= POLLOUT;                 writeNeeds |= POLLOUT;
                 // dane będą wysłane dopiero w następnej iteracji pętli zdarzeń (to upraszcza kod)                 // dane będą wysłane dopiero w następnej iteracji pętli zdarzeń (to upraszcza kod)
Line 489: Line 618:
                     pfds[0].fd = -1;                     pfds[0].fd = -1;
                 } else                  } else 
-                    usleep(1000);+                    usleep(10000);
                 // aktywne czekanie (powtarzana próba odczytu z zamkniętego standardowego                 // aktywne czekanie (powtarzana próba odczytu z zamkniętego standardowego
                 // wejścia) na wepchnięcie do bufora nadawczego TCP zaszyfrowanych danych                 // wejścia) na wepchnięcie do bufora nadawczego TCP zaszyfrowanych danych
-                // przed włożeniem tam wiadomości zamknięciem warstwy szyfrującej jest tutaj+                // przed włożeniem tam wiadomości zamknięcia warstwy szyfrującej jest tutaj
                 // pozostawione dla uproszczenia kodu                 // pozostawione dla uproszczenia kodu
             }             }
         }         }
 +    
         /* ───────────────────────────────────────────────────────────────────── */         /* ───────────────────────────────────────────────────────────────────── */
- +         
-        bool isThereAnyDataToWrite = (!dataBeingWritten.empty() || !dataWaitingToBeWritten.empty()); +        mask = 0; 
-        if (pfds[1].revents & writeNeeds && isThereAnyDataToWrite) {+        if (pfds[1].revents & writeNeeds) {
             writeNeeds = 0;             writeNeeds = 0;
 +    
             if (dataBeingWritten.empty())             if (dataBeingWritten.empty())
                 std::swap(dataBeingWritten, dataWaitingToBeWritten);                 std::swap(dataBeingWritten, dataWaitingToBeWritten);
 +    
             int result = SSL_write(encryption_layer, dataBeingWritten.c_str(), dataBeingWritten.length());             int result = SSL_write(encryption_layer, dataBeingWritten.c_str(), dataBeingWritten.length());
 +    
             // obsługa niepowodzenia funkcji SSL_write             // obsługa niepowodzenia funkcji SSL_write
             switch (SSL_get_error(encryption_layer, result)) {             switch (SSL_get_error(encryption_layer, result)) {
Line 517: Line 646:
                 case SSL_ERROR_WANT_WRITE:                 case SSL_ERROR_WANT_WRITE:
                     writeNeeds = POLLOUT;                     writeNeeds = POLLOUT;
 +                    // jeżeli SSL_write zwrócił WANT_WRITE, nie można wywołać
 +                    // innych I/O przed kolejnym SSL_write
 +                    pfds[1].revents = 0;
 +                    mask = POLLIN;
                     break;                     break;
                 MY_ERROR_HANDLING_SWITCH_MISC                 MY_ERROR_HANDLING_SWITCH_MISC
             }             }
             ERR_clear_error();             ERR_clear_error();
 +    
             // obsługa jeśli udało się wysłać dane             // obsługa jeśli udało się wysłać dane
             if (result > 0) {             if (result > 0) {
Line 530: Line 663:
                     writeNeeds = POLLOUT;                     writeNeeds = POLLOUT;
             }             }
 +            
 +            // przypadek brzegowy: jeżeli SSL_read chciał zapisu ale równocześnie
 +            // pojawiły się dane do wysłania i SSL_write wysłał te dane, to SSL_read
 +            // może już nie potrzebować zapisu, tylko odczyt
 +            if (readNeeds == POLLOUT)
 +                readNeeds &= POLLIN;
         }         }
 +    
         /* ───────────────────────────────────────────────────────────────────── */         /* ───────────────────────────────────────────────────────────────────── */
 +    
         if (pfds[1].revents & readNeeds) {         if (pfds[1].revents & readNeeds) {
             readNeeds = POLLIN;             readNeeds = POLLIN;
 +    
             int result = SSL_read(encryption_layer, recvBuffer, 255);             int result = SSL_read(encryption_layer, recvBuffer, 255);
             if (result > 0) {             if (result > 0) {
Line 563: Line 702:
             }             }
         }         }
 +    
         /* ───────────────────────────────────────────────────────────────────── */         /* ───────────────────────────────────────────────────────────────────── */
 +    
         pfds[1].events = readNeeds | writeNeeds;         pfds[1].events = readNeeds | writeNeeds;
 +        pfds[1].events &= ~mask;
     }     }
 +    
 close_connection: close_connection:
     shutdown(cli, SHUT_RDWR);     shutdown(cli, SHUT_RDWR);
Line 576: Line 716:
 </code> </code>
  
 +<small>
 ~~Zadanie.#~~ Przeczytaj kod klienta. ~~Zadanie.#~~ Przeczytaj kod klienta.
 Zwróć szczególnie uwagę na komentarze – przybliżają działanie API biblioteki Zwróć szczególnie uwagę na komentarze – przybliżają działanie API biblioteki
 OpenSSL. Przetestuj kod. OpenSSL. Przetestuj kod.
 +</small>
 +
 +++++
 +
 +=== przykład użycia BIO w kliencie TLS ===
  
-=== [ekstra] przykład użycia BIO w kliencie TLS ===+++++ Rozwiń… |
  
 <code cpp ssl_client_bio.cpp> <code cpp ssl_client_bio.cpp>
Line 634: Line 780:
 </code> </code>
  
-==== Zadania ====+++++ 
 + 
 +==== Zadania – serwer ====
  
 ~~Zadanie.#~~ Poniżej znajduje się program realizujący prostą sieciową ~~Zadanie.#~~ Poniżej znajduje się program realizujący prostą sieciową
Line 726: Line 874:
 </code> </code>
  
-~~Zadanie.#~~ Zmień program z poprzedniego zadania tak, żeby program obsługiwał +~~Zadanie.#~~ Zmień program z poprzedniego zadania tak, żeby obsługiwał oczekiwanie 
-wielu klientów naraz używając zdarzeń. Załóż że po zgłoszeniu odpowiedniego +na nowych klientów i na żądania od już połączonych klientów używając zdarzeń. 
-zdarzenia przez select/pool/epoll_wait wszystkie funkcje ''SSL_…'' kończą się +Załóż że po zgłoszeniu odpowiedniego zdarzenia odczytu przez ''select''/''pool''/''epoll_wait'' 
-bez czekania (sukcesem lub błędem uniemożliwiającym dalszą komunikację).+wszystkie potrzebne funkcje ''SSL_…'' kończą się bez czekania (sukcesem lub błędem 
 +uniemożliwiającym dalszą komunikację).
  
 <small> <small>
Line 739: Line 888:
 kod klienta wyżej). kod klienta wyżej).
 </small> </small>
 +
 +==== [ekstra] SSLKEYLOGFILE ====
 +
 +Biblioteki do szyfrowanych połączeń potrafią przekazać
 +programiście klucze użyte do szyfrowania danych w
 +[[https://tlswg.org/sslkeylogfile/draft-ietf-tls-keylogfile.html|(już de facto) standardowym formacie]].
 +Część aplikacji/bibliotek odczytuje zmienną środowiskową ''SSLKEYLOGFILE''
 +i tworzy plik pod wskazaną tam nazwą, do którego wpisuje klucze wszystkich
 +szyfrowanych połączeń. Pozwala to np. 
 +[[https://wiki.wireshark.org/TLS#tls-decryption|odszyfrować komunikację w programie wireshark]].
 +
 +Żeby zaimplementować takie zapisywanie kluczy do pliku w OpenSSL, należy
 +zarejestrować funkcję która będzie wywoływana ilekroć OpenSSL wygenruje klucz
 +do szyfrowania, i która dostanie gotową linię do wpisania do pliku.
 +\\
 +Przykładowy prosty kod realizujący takie zachowanie jest zaprezentowany poniżej:
 +<html><div style=margin-top:-1.4em></div></html>
 +<code cpp>
 +…
 +int keylogFd;
 +…
 +int main() {
 +    …
 +    SSL_CTX *ctx = …;
 +    …
 +    if (getenv("SSLKEYLOGFILE")) {
 +        keylogFd = open(getenv("SSLKEYLOGFILE"), O_CREAT | O_WRONLY | O_APPEND, 0666);
 +        if (keylogFd == -1)
 +            die("SSLKEYLOGFILE file opening failed with: %s", strerror(errno));
 +        SSL_CTX_set_keylog_callback(ctx, [](const SSL *ssl, const char *line) {
 +            write(keylogFd, line, strlen(line));
 +            write(keylogFd, "\n", 1);
 +        });
 +    }
 +    …
 +</code>
  
sk2/openssl_ssl_api.1732259759.txt.gz · Last modified: (external edit)