This is an old revision of the document!
Table of Contents
Generowanie kluczy i certyfikatów co ćwiczeń, TLS z powłoki
Klucze i certyfikaty
Do wygenerowania klucza prywatnego CA i certyfikatu CA oraz klucza prywatnego serwera i podpisanego przez wcześniej wygenerowane CA certyfikatu serwera użyj tego skryptu.
Zadanie 1
Wygeneruj potrzebne pliki za pomocą powyższego skryptu.
Wyświetl informacje o certyfikatach komendą:
openssl x509 -noout -text -certopt no_sigdump,no_pubkey -in <scieżka do certyfikatu>
Gotowe narzędzia do tworzenia prostych połączeń TLS w powłoce
Podobną rolę jak program nc / netcat dla połączeń szyfrowanych spełniają
narzędzia openssl s_client i openssl s_server.
Również program socat pozwala na tworzenie połączeń szyfrowanych.
Klient SSL - openssl s_client / socat
openssl s_client [-verifyCAfile ca.crt] [-crlf] [-quiet|-brief] [-connect] put.poznan.pl:443
np: openssl s_client -brief mail.put.poznan.pl:imaps
-verifyCAfile <CA cert> dodaje plik CA jako zaufany do sprawdzania certyfikatu serwera
-crlf zamienia w danych odczytanych ze standardowego wejścia \n na \r\n
-quiet wyłącza zupełnie komunikaty diagnostyczne,
-brief skraca komunikaty diagnostyczne; bez tych przełączników są pokazywane
długie komunkaty
[-connect] <host>:<port> wskazuje gdzie się połączyć; słowo kluczowe
-connect można pominąć jeśli <host>:<port> jest na końcu komendy
socat [-ddd] [open]ssl:put.poznan.pl:443[,verify=0][,crlf] stdio
np. socat ssl:mail.put.poznan.pl:imaps,verify=0 stdio
-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
Zadanie 2
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?
Serwer SSL - openssl s_server / socat
Pamiętaj że do stworzenia prostego serwera połączeń szyfrowanych potrzebujesz1) klucza prywatnego i certyfikatu.
openssl s_server [-cert_chain chain.pem] -cert s.crt -key s.key [-quiet|-brief] [-naccept 1] -port 4000
-key <key> podaje ścieżkę do klucza prywatnego
-cert <cert> podaje ścieżkę do certyfikatu serwera
-cert_chain <chain> podaje ścieżkę do łańcucha certyfikatów które podpisały certyfikat serwera
-naccept <num> podaje po ilu połączeniach (obsługiwanych sekwencyjnie) serwer ma się zakończyć
socat openssl-listen:4000,key=server.key,cert=chain.pem,reuseaddr,verify=0[,fork] stdio
key=<key> podaje ścieżkę do klucza prywatnego
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
będzie obsługiwał nawiązane połączenie, drugi czekał na nowe;
uwaga: przy łączeniu drugiego końca z stdio wszystkie procesy obsługujące
połączenia będą czytać z tego samego deskryptora (dane trafią niedeterministycznie
do jednego z nich)
Zadanie 3
Uruchom prosty serwer TLS używając wygenerowanych przez siebie certyfikatów.
Połącz się do niego klientem z konsoli.
Zadanie 4
Połącz się do prostego serwera TLS z przeglądarki internetowej.
Dlaczego przeglądarka uważa połączenie za niebezpieczne?
Możesz albo uruchomić serwer (z uprawnieniami administratora) na porcie
443 i w przeglądarce podać https://<nazwa domenowa>/, lub uruchomić na
wybranym porcie i podać https://<nazwa domenowa>:<numer portu>/
Zadanie 5
Zainstaluj certyfikat swojego CA w przeglądarce. Następnie połącz się podając
jako nazwę domenową localhost oraz lab-net-▒▒.
Czy przeglądarka teraz ufa serwerowi?
Intefejs programistyczny biblioteki OpenSSL
Wstęp do API
Biblioteki OpenSSL są oparte o abstrakcję wejścia/wyjścia
BIO.
Tworząc kod używający biblioteki OpenSSL do szyfrowanych połączeń sieciowych TLS
(libssl)
programista musi najpierw stworzyć zwykłe połączenie TCP. Może do tego użyć
albo abstrakcji BIO (klient,
serwer),
albo zwykłego interfejsu gniazd.
Uwaga: tutaj jest opisana ta druga opcja. Często kod przykładowych programów
używa do obsługi gniazd TCP abstrakcji OpenSSL – zwracaj na to uwagę.
Następnie programista musi na już nawiązanym połączeniu TCP ustanowić połączenie TLS.
W tym celu najpierw należy stworzyć "obiekt" SSL, następnie powiązać go z
istniejącym połączeniem TCP (dla zwykłego interfejsu gniazd metodą
SSL_set_fd).
Dalszy sposób użycia "obiektu" SSL do nawiązania bądź przyjęcia połączenia
TLS jest opisany w materiałach z wykładów.
OpenSSL nie wspiera równoległego wykonywania operacji na tym samym "obiekcie"
z wielu wątków (por.
man openssl-threads).
W szczególności nie wolno wykonywać równolegle SSL_read i SSL_write na tym samym
"obiekcie" SSL (i deweloperzy nie są chętni tego zmieniać, bo wymagałoby
to dużych zmian w bibliotece – patrz
ten issue).
Nie należy też zmieniać ustawień "obiektu" SSL_CTX po jego pierwszym użyciu do stworzenia "obiektu" SSL.
Linkowanie programu z biblioteką
Do połączenia skompilowanego kodu używającego OpenSSL do połączeń TLS
trzeba linkować do bibliotek libssl oraz libcrypto, np:
c++ prog.cpp -o prog -lssl -lcrypto
Przy użyciu CMake należy dodać do pliku CMakeLists.txt wyszukanie biblioteki
OpenSSL oraz linkowanie wybranego celu do niej:
find_package ( OpenSSL 1.1 REQUIRED ) target_link_libraries ( prog OpenSSL::SSL )
(Bez tego na etapie linkowania zaczną pojawiać się błędy
undefined reference to… z nazwami funkcji bibliotecznych OpenSSL.)
Przykładowe programy z wykładów
Klient
- kod_z_wykladow__klient.c
#include <stdio.h> #include <netinet/in.h> #include <sys/socket.h> #include <unistd.h> #include <netdb.h> #include <openssl/ssl.h> int main(int argc, char **argv) { SSL_CTX *ctx = SSL_CTX_new(TLS_client_method()); SSL *ssl = SSL_new(ctx); struct hostent *he = gethostbyname(argv[1]); struct sockaddr_in sa; sa.sin_family = AF_INET; sa.sin_port = htons(atoi(argv[2])); memcpy(&sa.sin_addr.s_addr, he->h_addr, he->h_length); int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); connect(fd, (struct sockaddr *)&sa, sizeof(sa)); SSL_set_fd(ssl, fd); SSL_connect(ssl); SSL_write(ssl, "Hello, Server!\n", 15); char buf[1024]; int count = SSL_read(ssl, buf, sizeof(buf)); write(1, buf, count); SSL_shutdown(ssl); close(fd); SSL_free(ssl); SSL_CTX_free(ctx); return 0; }
Zadanie 6
Skompiluj powyższy kod. Uruchom klienta łącząc się do serwera uruchomionego
przy użyciu openssl s_server … lub socat openssl-listen:….
Serwer
- kod_z_wykladow__serwer.c
#include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #include <unistd.h> #include <openssl/ssl.h> int main(int argc, char **argv) { SSL_CTX *ctx = SSL_CTX_new(TLS_server_method()); SSL_CTX_use_certificate_chain_file(ctx, "chain.pem") == 1 || fprintf(stderr, "problem with chain.pem\n"); //SSL_CTX_use_certificate_file(ctx, "server.crt", SSL_FILETYPE_PEM) == 1 || fprintf(stderr, "problem with server.crt\n"); SSL_CTX_use_PrivateKey_file(ctx, "server.key", SSL_FILETYPE_PEM) == 1 || fprintf(stderr, "problem with server.key\n"); struct sockaddr_in sa = {0}; sa.sin_family = AF_INET; sa.sin_addr.s_addr = INADDR_ANY; sa.sin_port = htons(atoi(argv[1])); int sfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); bind(sfd, (struct sockaddr *)&sa, sizeof(sa)) == 0 || fprintf(stderr, "problem with bind\n"); listen(sfd, 10); while (1) { int cfd = accept(sfd, NULL, NULL); SSL *ssl = SSL_new(ctx); SSL_set_fd(ssl, cfd); SSL_accept(ssl); char buf[1024]; SSL_read(ssl, buf, sizeof(buf)); SSL_write(ssl, "Welcome to the SSL/TLS server!\n", 31); SSL_shutdown(ssl); SSL_free(ssl); close(cfd); } }
Zadanie 7
Skompiluj powyższy kod i uruchom serwer. Upewnij się że wszystkie klucze
i certyfikaty zostały poprawnie załadowane i serwer rozpoczął nasłuchiwanie
na właściwym porcie.
Następnie połącz się klientem uruchomionym z terminala oraz przeglądarką
internetową.
Kolejne przykładowe programy serwera
Iteracyjny serwer z minimalną obsługą błędów
Uwaga: kompiluj poniższy kod ze standardem C++20 lub nowszym (opcja --std=c++20)
- daytime_tls_server.cpp
#include <cstdio> #include <netinet/in.h> #include <string> #include <sys/socket.h> #include <unistd.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); } std::string craftHttpAnswer(); int main(int argc, char **argv) { if (argc != 2) die("Usage: %s <port>\n", argv[0]); // Wybiera konfigurację dla serwera SSL_CTX *ctx = SSL_CTX_new(TLS_server_method()); // Ładuje klucz prywatny serwera if (SSL_CTX_use_PrivateKey_file(ctx, "server.key", SSL_FILETYPE_PEM) != 1) die("Loading Private Key from \"server.key\" failed\n"); // Ładuje certyfikaty if (SSL_CTX_use_certificate_chain_file(ctx, "chain.pem") != 1) die("Loading certs from \"chain.pem\" failed\n"); // Tworzy gniazdo i rozpoczyna nasłuchiwanie - zwykły kod z API gniazd int serv = socket(AF_INET, SOCK_STREAM, 0); const int one = 1; setsockopt(serv, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); sockaddr_in sa = {}; sa.sin_family = AF_INET; sa.sin_port = htons(atoi(argv[1])); if (bind(serv, (sockaddr *)&sa, sizeof(sa)) != 0) die("bind failed: %s\n", strerror(errno)); listen(serv, 1); while (1) { // przyjmuje nowe połączenie int cli = accept(serv, 0, 0); // tworzy warstwę szyfrującą i wykonuje handshake SSL *encryption_layer = SSL_new(ctx); SSL_set_fd(encryption_layer, cli); if (SSL_accept(encryption_layer) != 1) { fprintf(stderr, "TLS handshake failed!\n"); continue; } std::string answer = craftHttpAnswer(); // przesyła odpowiedź if (SSL_write(encryption_layer, answer.c_str(), answer.length()) <= 0) { fprintf(stderr, "Problems with write!\n"); continue; } // zamyka warstwę szyfrującą SSL_shutdown(encryption_layer); // zamyka gniazdo shutdown(cli, SHUT_RDWR); close(cli); SSL_free(encryption_layer); } } #include <chrono> #include <format> std::string craftHttpAnswer(void) { std::string content = std::format( "{:%Y.%m.%d %H:%M:%S}\r\n", std::chrono::system_clock::now()); return std::format( "HTTP/1.1 200 Ok\r\n" "content-type: text/plain\r\n" "content-length: {}\r\n" "\r\n" "{}", content.length(), content); }
Zadanie 8 Powtórz poprzednie zadanie używając kodu tego serwera.
Zadania – klient
Zadanie 9 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
httpszamiasthttp - nawiązywał połączenie szyfrowane
- klient_http.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>[^]*?</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; }
Zadanie 10 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 11 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 funkcją
SSL_CTX_set_default_verify_paths, - poinformować bibliotekę openssl czyjego certyfikatu się spodziewasz – jeżeli samodzielnie tworzysz połączenie sieciowe, to openssl nie wie czyj certyfikat powinien otrzymać; możesz to określić funkcją
SSL_set1_host, - sprawdzić czy certyfikat otrzymany od serwera podczas nawiązywania połączenia jest w porządku używając funkcji
SSL_get_verify_result, - jeżeli nie, to możesz przerobić kod błędy zwrócony przez
SSL_get_verify_resultna krótki tekst z przyczyną błędu funkcjąX509_verify_cert_error_string
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 12a 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).
Szczegóły możesz docztać na wikipedii
albo na e-learningu cloudflare.
Zadanie 12b 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ą SSL_set_tlsext_host_name.
[ekstra] Przykładowe programy klienta
Klient wykorzystujący zdarzenia i nieblokującą komunikację, z obsługą błędów
przykład użycia BIO w kliencie TLS
Zadania – serwer
Zadanie 14 Poniżej znajduje się program realizujący prostą sieciową
bazę klucz-wartość
obsługujący sekwencyjnie klientów. Program przyjmuje od klientów dwa rodzaje
żądań: ustawienie klucza (format żądania: klucz wartość) i pobranie
poprzednio ustawionej wartości (format żądania: klucz).
Przerób program tak, by używał połączeń TLS.
- key-value_database.cpp
#include <cstdio> #include <netdb.h> #include <netinet/in.h> #include <string> #include <sys/socket.h> #include <unistd.h> #include <unordered_map> #include <openssl/ssl.h> std::unordered_map<std::string, std::string> key_value_database; int main(int argc, char **argv) { if (argc != 2) { fprintf(stderr, "Usage: %s <port>\n", argv[0]); return 1; } int serv = socket(AF_INET, SOCK_STREAM, 0); const int one = 1; setsockopt(serv, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); sockaddr_in sa = {}; sa.sin_family = AF_INET; sa.sin_port = htons(atoi(argv[1])); if (bind(serv, (sockaddr *)&sa, sizeof(sa))) { perror("bind failed"); return 1; } listen(serv, 1); while (1) { sockaddr_in ca; socklen_t l = sizeof(ca); int cli = accept(serv, (sockaddr *)&ca, &l); char clientName[NI_MAXHOST], clientPort[NI_MAXSERV]; getnameinfo((sockaddr *)&ca, l, clientName, NI_MAXHOST, clientPort, NI_MAXSERV, 0); printf("New client [%s:%s]\n", clientName, clientPort); while (1) { char request[1025]{}; int count = read(cli, request, 1024); if (count <= 0) break; if (request[count - 1] == '\n') request[count - 1] = '\0'; if (!strlen(request)) continue; char *firstSpace = strchr(request, ' '); if (firstSpace != nullptr) { *firstSpace = '\0'; char *key = request; char *value = firstSpace + 1; key_value_database[key] = value; printf("[%s:%s] assigned to '%s' value '%s'\n", clientName, clientPort, key, value); } else { char *key = request; std::string value; if (key_value_database.count(key)) value = key_value_database[key]; else value = "(null)"; std::string response = std::string("[") + key + "] " + value + "\n"; write(cli, response.data(), response.length()); printf("[%s:%s] read from '%s' value '%s'\n", clientName, clientPort, key, value.data()); } } printf("Client [%s:%s] gone\n", clientName, clientPort); shutdown(cli, SHUT_RDWR); close(cli); } }
Zadanie 15 Zmień program z poprzedniego zadania tak, żeby obsługiwał oczekiwanie
na nowych klientów i na żądania od już połączonych klientów używając zdarzeń.
Załóż że po zgłoszeniu odpowiedniego zdarzenia odczytu przez select/pool/epoll_wait
wszystkie potrzebne funkcje SSL_… kończą się bez czekania (sukcesem lub błędem
uniemożliwiającym dalszą komunikację).
Zadanie 16 Zmień program z poprzedniego zadania tak, by działał bez
założenia o natychmiastowym zakończeniu funkcji SSL_… po zgłoszeniu
odpowiedniego zdarzenia.
Zauważ że w tym zadaniu musisz używać gniazd w trybie nieblokującym
i analizować błędy na stosie błędów biblioteki OpensSSL (patrz przykładowy
kod klienta wyżej).
[ekstra] SSLKEYLOGFILE
Biblioteki do szyfrowanych połączeń potrafią przekazać
programiście klucze użyte do szyfrowania danych w
(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.
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:
… 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); }); } …