sk2:openssl_ssl_api
Differences
This shows you the differences between two versions of the page.
| Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
| sk2:openssl_ssl_api [2024/11/22 08:46] – [Kolejne przykładowe programy] jkonczak | sk2: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ą: \\ | ||
| - | '' | + | '' |
| ==== 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: | ||
| '' | '' | ||
| '' | '' | ||
| - | długie | + | długie |
| \\ | \\ | ||
| '' | '' | ||
| Line 38: | Line 38: | ||
| </ | </ | ||
| - | '' | + | '' |
| \\ | \\ | ||
| np. '' | np. '' | ||
| \\ | \\ | ||
| < | < | ||
| - | '' | + | '' |
| + | \\ | ||
| + | '' | ||
| \\ | \\ | ||
| '' | '' | ||
| Line 49: | Line 51: | ||
| ~~Zadanie.# | ~~Zadanie.# | ||
| - | Połącz się z serwerem stron internetowych i otrzymaj od niego odpowiedź. | + | Połącz się z dowolnym |
| + | '' | ||
| \\ | \\ | ||
| Kto podpisał certyfikat tego serwera? Czy certyfikat został zweryfikowany poprawnie? | Kto podpisał certyfikat tego serwera? Czy certyfikat został zweryfikowany poprawnie? | ||
| Line 77: | Line 80: | ||
| \\ | \\ | ||
| '' | '' | ||
| + | \\ | ||
| + | '' | ||
| \\ | \\ | ||
| '' | '' | ||
| Line 147: | Line 152: | ||
| trzeba linkować do bibliotek '' | trzeba linkować do bibliotek '' | ||
| \\ | \\ | ||
| - | '' | + | '' |
| Przy użyciu CMake należy dodać do pliku '' | Przy użyciu CMake należy dodać do pliku '' | ||
| Line 264: | Line 269: | ||
| internetową. | internetową. | ||
| - | ==== Kolejne przykładowe programy ==== | + | ==== Kolejne przykładowe programy |
| === Iteracyjny serwer z minimalną obsługą błędów === | === Iteracyjny serwer z minimalną obsługą błędów === | ||
| Line 295: | 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, | ||
| // Ładuje klucz prywatny serwera | // Ładuje klucz prywatny serwera | ||
| Line 353: | Line 357: | ||
| std:: | std:: | ||
| return std:: | return std:: | ||
| - | "HTTP/2 200\r\n" | + | "HTTP/1.1 200 Ok\r\n" |
| " | " | ||
| " | " | ||
| Line 364: | Line 368: | ||
| ~~Zadanie.# | ~~Zadanie.# | ||
| - | === Klient z obsługą błędów === | + | ==== Zadania – klient ==== |
| + | |||
| + | |||
| + | ~~Zadanie.# | ||
| + | serwera i wyświetlający podsumowanie odpowiedzi. Zmień ten kod tak, żeby: | ||
| + | * łączył się na port '' | ||
| + | * nawiązywał połączenie szyfrowane | ||
| + | |||
| + | <code cpp http_client.cpp> | ||
| + | #include < | ||
| + | #include < | ||
| + | #include < | ||
| + | #include < | ||
| + | |||
| + | #include < | ||
| + | #include < | ||
| + | #include < | ||
| + | #include < | ||
| + | using namespace std:: | ||
| + | |||
| + | #include < | ||
| + | #include < | ||
| + | |||
| + | void die(const char *format, ...) { | ||
| + | va_list args; | ||
| + | va_start(args, | ||
| + | vfprintf(stderr, | ||
| + | va_end(args); | ||
| + | exit(1); | ||
| + | } | ||
| + | |||
| + | void summarizeHttpResponse(const std::string & | ||
| + | auto eos = response.find(" | ||
| + | auto eoh = response.find(" | ||
| + | if (eos != std:: | ||
| + | std::string status | ||
| + | std::string headers (response.data() + eos + 2, eoh - eos - 2); | ||
| + | std::string body (response.data() + eoh + 4, response.length() - eoh - 4); | ||
| + | |||
| + | printf(" | ||
| + | if (std:: | ||
| + | printf(" | ||
| + | if (std:: | ||
| + | printf(" | ||
| + | } else | ||
| + | printf(" | ||
| + | } | ||
| + | |||
| + | int main(int argc, char **argv) { | ||
| + | if (argc != 2) | ||
| + | die(" | ||
| + | |||
| + | addrinfo *res; | ||
| + | if (int ec = getaddrinfo(argv[1], | ||
| + | die(" | ||
| + | int sock = socket(res-> | ||
| + | if (connect(sock, | ||
| + | die(" | ||
| + | freeaddrinfo(res); | ||
| + | |||
| + | std::string httpRequest; | ||
| + | httpRequest += "GET / HTTP/ | ||
| + | httpRequest += "Host: "s + argv[1] + " | ||
| + | httpRequest += " | ||
| + | httpRequest += " | ||
| + | |||
| + | write(sock, httpRequest.data(), | ||
| + | |||
| + | std::string response; | ||
| + | while (1) { | ||
| + | char buf[2048]; | ||
| + | int cnt = read(sock, buf, 2048); | ||
| + | if (cnt <= 0) | ||
| + | break; | ||
| + | response += std:: | ||
| + | } | ||
| + | summarizeHttpResponse(response); | ||
| + | |||
| + | shutdown(sock, | ||
| + | close(sock); | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | |||
| + | ~~Zadanie.# | ||
| + | Czy twoja przeglądarka uznaje to połączenie za bezpieczne? | ||
| + | A czy twój program uznaje to połączenie za bezpieczne? | ||
| + | |||
| + | ~~Zadanie.# | ||
| + | W tym celu musisz: | ||
| + | * załadować certyfikaty urzędów certyfikacji; | ||
| + | </ | ||
| + | * poinformować bibliotekę openssl czyjego certyfikatu się spodziewasz – jeżeli samodzielnie tworzysz< | ||
| + | </ | ||
| + | </ | ||
| + | * sprawdzić czy certyfikat otrzymany od serwera podczas nawiązywania połączenia jest w porządku< | ||
| + | </ | ||
| + | * jeżeli nie, to możesz przerobić kod błędy zwrócony przez '' | ||
| + | </ | ||
| + | < | ||
| + | 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.# | ||
| + | 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). | ||
| + | \\ | ||
| + | < | ||
| + | albo na e-learningu [[https:// | ||
| + | |||
| + | ~~Zadanie.# | ||
| + | w momencie nawiązywania połączenia TLS informacji do kogo klient chce się połączyć | ||
| + | funkcją [[https:// | ||
| + | |||
| + | |||
| + | ==== [ekstra] Przykładowe programy klienta ==== | ||
| + | |||
| + | === Klient | ||
| + | |||
| + | ++++ Rozwiń… | | ||
| Poniższy kod klienta: | Poniższy kod klienta: | ||
| Line 378: | Line 504: | ||
| #include < | #include < | ||
| #include < | #include < | ||
| + | #include < | ||
| #include < | #include < | ||
| #include < | #include < | ||
| + | | ||
| #include < | #include < | ||
| #include < | #include < | ||
| + | | ||
| void die(const char *format, ...) { | void die(const char *format, ...) { | ||
| va_list args; | va_list args; | ||
| Line 391: | 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(" | die(" | ||
| + | | ||
| // tworzy gniazdo i nawiązuje połączenie TCP | // tworzy gniazdo i nawiązuje połączenie TCP | ||
| addrinfo *res; | addrinfo *res; | ||
| Line 404: | Line 531: | ||
| die(" | die(" | ||
| freeaddrinfo(res); | freeaddrinfo(res); | ||
| + | | ||
| /* ───────────────────────────────────────────────────────────────────── */ | /* ───────────────────────────────────────────────────────────────────── */ | ||
| + | | ||
| // wybiera konfigurację warstwy szyfrującej | // wybiera konfigurację warstwy szyfrującej | ||
| SSL_CTX *ctx = SSL_CTX_new(TLS_client_method()); | SSL_CTX *ctx = SSL_CTX_new(TLS_client_method()); | ||
| SSL_CTX_set_default_verify_paths(ctx); | SSL_CTX_set_default_verify_paths(ctx); | ||
| + | | ||
| // ż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(" | if (getenv(" | ||
| SSL_CTX_load_verify_file(ctx, | SSL_CTX_load_verify_file(ctx, | ||
| + | | ||
| /* ───────────────────────────────────────────────────────────────────── */ | /* ───────────────────────────────────────────────────────────────────── */ | ||
| + | | ||
| // tworzy obiekt reprezentujący warstwę szyfrującą i nakazuje mu czytać/ | // tworzy obiekt reprezentujący warstwę szyfrującą i nakazuje mu czytać/ | ||
| SSL *encryption_layer = SSL_new(ctx); | SSL *encryption_layer = SSL_new(ctx); | ||
| SSL_set_fd(encryption_layer, | SSL_set_fd(encryption_layer, | ||
| + | | ||
| // informuje bibliotekę jakiej nazwie powinien odpowiadać certyfikat | // informuje bibliotekę jakiej nazwie powinien odpowiadać certyfikat | ||
| SSL_set1_host(encryption_layer, | SSL_set1_host(encryption_layer, | ||
| + | | ||
| // 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(" | die(" | ||
| + | | ||
| // 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 434: | Line 561: | ||
| fprintf(stderr, | fprintf(stderr, | ||
| X509_verify_cert_error_string(serverCertStatus)); | X509_verify_cert_error_string(serverCertStatus)); | ||
| + | | ||
| /* ───────────────────────────────────────────────────────────────────── */ | /* ───────────────────────────────────────────────────────────────────── */ | ||
| | | ||
| Line 446: | 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, | {.fd = 0, | ||
| {.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 | + | |
| - | 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 463: | 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; | // trzeba je powtórzyć z identycznymi argumentami; | ||
| + | | ||
| // 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 469: | 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) { | ||
| - | | + | dataWaitingToBeWritten += std:: |
| - | | + | |
| 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 491: | 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 | ||
| } | } | ||
| } | } | ||
| + | | ||
| /* ───────────────────────────────────────────────────────────────────── */ | /* ───────────────────────────────────────────────────────────────────── */ | ||
| - | + | | |
| - | | + | |
| - | if (pfds[1].revents & writeNeeds | + | if (pfds[1].revents & writeNeeds) { |
| writeNeeds = 0; | writeNeeds = 0; | ||
| + | | ||
| if (dataBeingWritten.empty()) | if (dataBeingWritten.empty()) | ||
| std:: | std:: | ||
| + | | ||
| int result = SSL_write(encryption_layer, | int result = SSL_write(encryption_layer, | ||
| + | | ||
| // obsługa niepowodzenia funkcji SSL_write | // obsługa niepowodzenia funkcji SSL_write | ||
| switch (SSL_get_error(encryption_layer, | switch (SSL_get_error(encryption_layer, | ||
| Line 519: | 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 532: | 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, | int result = SSL_read(encryption_layer, | ||
| if (result > 0) { | if (result > 0) { | ||
| Line 565: | Line 702: | ||
| } | } | ||
| } | } | ||
| + | | ||
| /* ───────────────────────────────────────────────────────────────────── */ | /* ───────────────────────────────────────────────────────────────────── */ | ||
| + | | ||
| pfds[1].events = readNeeds | writeNeeds; | pfds[1].events = readNeeds | writeNeeds; | ||
| + | pfds[1].events &= ~mask; | ||
| } | } | ||
| + | | ||
| close_connection: | close_connection: | ||
| shutdown(cli, | shutdown(cli, | ||
| Line 578: | Line 716: | ||
| </ | </ | ||
| + | < | ||
| ~~Zadanie.# | ~~Zadanie.# | ||
| 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. | ||
| + | </ | ||
| + | |||
| + | ++++ | ||
| + | |||
| + | === 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 636: | Line 780: | ||
| </ | </ | ||
| - | ==== Zadania ==== | + | ++++ |
| + | |||
| + | ==== Zadania | ||
| ~~Zadanie.# | ~~Zadanie.# | ||
| Line 728: | Line 874: | ||
| </ | </ | ||
| - | ~~Zadanie.# | + | ~~Zadanie.# |
| - | wielu klientów | + | na nowych klientów i na żądania od już połączonych |
| - | zdarzenia przez select/ | + | Załóż że po zgłoszeniu odpowiedniego zdarzenia |
| - | bez czekania (sukcesem lub błędem uniemożliwiającym dalszą komunikację). | + | wszystkie |
| + | uniemożliwiającym dalszą komunikację). | ||
| < | < | ||
| Line 741: | Line 888: | ||
| kod klienta wyżej). | kod klienta wyżej). | ||
| </ | </ | ||
| + | |||
| + | ==== [ekstra] SSLKEYLOGFILE ==== | ||
| + | |||
| + | Biblioteki do szyfrowanych połączeń potrafią przekazać | ||
| + | programiście klucze użyte do szyfrowania danych w | ||
| + | [[https:// | ||
| + | Część aplikacji/ | ||
| + | i tworzy plik pod wskazaną tam nazwą, do którego wpisuje klucze wszystkich | ||
| + | szyfrowanych połączeń. Pozwala to np. | ||
| + | [[https:// | ||
| + | |||
| + | Ż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, | ||
| + | \\ | ||
| + | Przykładowy prosty kod realizujący takie zachowanie jest zaprezentowany poniżej: | ||
| + | < | ||
| + | <code cpp> | ||
| + | … | ||
| + | int keylogFd; | ||
| + | … | ||
| + | int main() { | ||
| + | … | ||
| + | SSL_CTX *ctx = …; | ||
| + | … | ||
| + | if (getenv(" | ||
| + | keylogFd = open(getenv(" | ||
| + | if (keylogFd == -1) | ||
| + | die(" | ||
| + | SSL_CTX_set_keylog_callback(ctx, | ||
| + | write(keylogFd, | ||
| + | write(keylogFd, | ||
| + | }); | ||
| + | } | ||
| + | … | ||
| + | </ | ||
sk2/openssl_ssl_api.1732265201.txt.gz · Last modified: (external edit)