User Tools

Site Tools


sk2:openssl_ssl_api

This is an old revision of the document!


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 https zamiast http
  • 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_result na 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

Rozwiń…

przykład użycia BIO w kliencie TLS

Rozwiń…

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);
        });
    }
    …
1)
Istnieją też rozwiązania SSL/TLS używające anonimowej wymiany DH, ale nie są one wykorzystywane z powodu nieodporności na ataki man-in-the-middle.
sk2/openssl_ssl_api.1794526626.txt.gz · Last modified: by jkonczak