Poziom: ocena 4.0 - programowanie protokołów, dekonstrukcja binarna i audyt bezpieczeństwa

Zestaw 10 praktycznych zadań laboratoryjnych do wykonania w trakcie zajęć (90–100 minut).
Kierunek: Informatyka, semestr 7, przedmiot: Kryptologia.
Podstawa materiałowa: wykład część 5 (bezpieczna wymiana informacji: PKI, TLS i uwierzytelnianie).

1. 01.Parser i walidator łańcucha certyfikatów X.509 w języku Python (analiza ASN.1 DER, okresów ważności i podpisów)
2. 02.Budowa i programowa obsługa lokalnego respondera OCSP oraz symulacja mechanizmu OCSP Stapling w Pythonie
3. 03.Implementacja klienta protokołu ACME i automatyzacja wyzwań HTTP-01 / DNS-01 w Pythonie
4. 04.Ręczna dekonstrukcja i analiza rekordów pakietu TLS Handshake (ClientHello, ServerHello) w Pythonie i Scapy
5. 05.Symulacja protokołu uwierzytelniania Kerberos (KDC: Authentication Server i Ticket Granting Server) w Pythonie
6. 06.Kryptograficzna generacja i walidacja tokenów JWT (HS256 vs RS256) oraz test podatności 'alg: none' w Pythonie
7. 07.Implementacja mechanizmu jednorazowych haseł opartych na czasie TOTP (RFC 6238) i integracja z kodem QR w Pythonie
8. 08.Podpisywanie i weryfikacja wiadomości pocztowych w standardzie S/MIME oraz weryfikacja sygnatury DKIM w Pythonie
9. 09.Kryptoanalityczna walidacja łańcucha DNSSEC (rekordy DNSKEY, DS, RRSIG) od roota do domeny w Pythonie
10. 10.Skrypt audytujący i profilujący bezpieczeństwo konfiguracji serwera TLS (szyfry, PFS, nagłówki HSTS) w Pythonie

Cel

Celem zadania jest samodzielna implementacja skryptu w języku Python weryfikującego poprawność formalną i kryptograficzną łańcucha certyfikatów X.509. Student parsuje certyfikaty zakodowane w formatach PEM i DER, sprawdza okna ważności czasowej notBefore i notAfter, weryfikuje dopasowanie nazw wystawcy i podmiotu oraz kryptograficznie sprawdza podpis cyfrowy certyfikatu podrzędnego kluczem publicznym wystawcy.

Scenariusz – opis

Weryfikacja certyfikatów X.509 w aplikacjach sieciowych jest krytycznym zadaniem bibliotek kryptograficznych. Wielu programistów traktuje funkcje weryfikujące jako czarne skrzynki, nie rozumiejąc wewnętrznych kroków algorytmu RFC 5280. Każdy certyfikat X.509 składa się z części podpisywanej TBSCertificate, identyfikatora algorytmu podpisu oraz samego podpisu cyfrowego. W procesie walidacji klient musi najpierw sprawdzić okres ważności czasowej względem bieżącego czasu systemowego UTC. Następnie weryfikator sprawdza, czy pole Issuer badanego certyfikatu jest identyczne z polem Subject certyfikatu nadrzędnego. Kolejnym fundamentalnym krokiem jest kryptograficzna weryfikacja asymetrycznego podpisu cyfrowego.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Uruchom konsolę i utwórz plik validator.py w dedykowanym katalogu roboczym.
2. Zaimportuj niezbędne moduły: from cryptography import x509 oraz cryptography.hazmat.primitives.asymmetric.
3. Zaimplementuj funkcję wczytującą plik PEM: cert = x509.load_pem_x509_certificate(f.read()).
4. Napisz funkcję check_validity_dates( cert), sprawdzającą czy cert.not_valid_before_utc <= now <= cert.not_valid_after_utc.
5. Wypisz sformatowane daty ważności certyfikatu oraz bieżący czas systemowy.
6. Napisz funkcję check_issuer_match( cert, issuer_cert) porównującą cert.issuer.public_bytes() z issuer_cert.subject.public_bytes().
7. Wyodrębnij klucz publiczny urzędu wystawcy: issuer_pubkey = issuer_cert.public_key().
8. Zaimplementuj procedurę weryfikacji podpisu cyfrowego z obsługą dopełnienia PKCS#1 v1.5 lub RSA-PSS.
9. Użyj metody: issuer_pubkey.verify(cert.signature, cert.tbs_certificate_bytes, padding.PKCS1v15(), cert.signature_hash_algorithm).
10. Dołącz kod źródłowy skryptu oraz zrzuty ekranu z wykonania testu pozytywnego i negatywnego do sprawozdania.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Głębokie zrozumienie algorytmu weryfikacji łańcucha zaufania X.509 zgodnie ze specyfikacją RFC 5280.
• Umiejętność programowej manipulacji obiektami ASN.1, kluczami publicznymi i podpisami w bibliotece cryptography.
• Zrozumienie technicznego podziału certyfikatu na blok danych TBSCertificate oraz sygnaturę cyfrową.
• Praktyczna weryfikacja odporności kryptograficznej na próby podstawienia fałszywego wystawcy o tożsamej nazwie podmiotu.

Cel

Celem zadania jest praktyczne zrozumienie działania protokołu OCSP (Online Certificate Status Protocol) oraz optymalizacji OCSP Stapling. Student tworzy w Pythonie prostą usługę respondera OCSP odpowiadającą na zapytania klientów, generuje kryptograficznie podpisane odpowiedzi ze statusem certyfikatu oraz symuluje proces dołączania zszytej odpowiedzi do procedury uzgadniania połączenia.

Scenariusz – opis

Pobieranie całych list unieważnień CRL wiąże się z opóźnieniami oraz dużym narzutem transmisyjnym. Standard RFC 6960 wprowadził protokół OCSP umożliwiający odpytywanie respondera o stan pojedynczego certyfikatu w czasie rzeczywistym. Klient TLS wysyła zapytanie zawierające skrót nazwy wystawcy, skrót klucza wystawcy oraz numer seryjny badanego certyfikatu. Responder działający w imieniu CA weryfikuje bazę statusów i odsyła podpisaną odpowiedź: good, revoked lub unknown. Choć OCSP zapewnia świeżość danych, niesie ze sobą istotne wady: opóźnia nawiązywanie sesji oraz ujawnia responderowi strony odwiedzane przez użytkownika. Rozwiązaniem tych problemów jest technika OCSP Stapling opisana w RFC 6066, zwana formalnie Certificate Status Request.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik skryptu ocsp_demo.py w katalogu projektowym.
2. Zaimportuj moduły: from cryptography.x509 import ocsp, hashes, load_pem_x509_certificate.
3. Wczytaj certyfikat serwera oraz certyfikat wystawcy z dysku.
4. Zbuduj zapytanie OCSP: builder = ocsp.OCSPRequestBuilder().add_certificate( cert, issuer_cert, hashes.SHA256()).
5. Wygeneruj obiekt żądania: req = builder.build() i zapisz go w formacie DER: req_der = req.public_bytes(serialization.Encoding.DER).
6. Wypisz rozmiar żądania DER w bajtach (zauważ, że wynosi on zazwyczaj poniżej 100 bajtów).
7. Zaimplementuj generator odpowiedzi respondera: resp_builder = ocsp.OCSPResponseBuilder().
8. Ustaw status GOOD dla badanego certyfikatu oraz określ czasy this_update i next_update (np. ważne przez 24 godziny).
9. Podpisz odpowiedź kluczem CA: ocsp_resp = resp_builder.sign(ca_key, hashes.SHA256()).
10. Zapisz zrzuty ekranu prezentujące działanie skryptu oraz sporządź diagram sekwencji protokołu OCSP Stapling.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Zrozumienie zalet protokołu OCSP w stosunku do statycznych list CRL pod kątem świeżości i rozmiaru danych.
• Praktyczna znajomość problemów prywatności i wydajności tradycyjnego OCSP rozwiązanych przez mechanizm OCSP Stapling.
• Umiejętność programowej generacji i kryptograficznej walidacji odpowiedzi OCSP w języku Python.
• Zrozumienie roli pól czasowych thisUpdate i nextUpdate w zapobieganiu atakom powtórzenia starych poświadczeń statusu.

Cel

Celem zadania jest dekonstrukcja i implementacja kluczowych elementów kryptograficznych protokołu ACME (Automated Certificate Management Environment). Student programuje w języku Python mechanizm autoryzacji konta, generuje thumbprint klucza publicznego, wylicza wartość autoryzacji wyzwania keyAuthorization oraz implementuje symulację obsługi wyzwania HTTP-01 oraz DNS-01.

Scenariusz – opis

Pojawienie się inicjatywy Let's Encrypt zrewolucjonizowało wdrażanie kryptografii w internecie dzięki pełnej automatyzacji. Sercem tego ekosystemu jest protokół ACME ustandaryzowany w dokumencie RFC 8555 przez organizację IETF. W protokole ACME administrator serwera nie wypełnia formularzy ani nie wysyła ręcznych wiadomości e-mail. Zamiast tego klient ACME komunikuje się z serwerem urzędu za pomocą podpisanych kryptograficznie komunikatów JSON Web Signature. Aby potwierdzić prawo do dysponowania domeną, serwer CA stawia przed klientem kryptograficzne wyzwanie challenge. Najpopularniejszym wyzwaniem jest HTTP-01 polegające na udostępnieniu wskazanego pliku pod ustandaryzowaną ścieżką /.well-known/acme-challenge/.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik acme_client.py i zaimportuj moduły: hashlib, json, base64, socket z biblioteki standardowej Pythona.
2. Użyj biblioteki cryptography do wygenerowania klucza konta: acct_key = ec.generate_private_key(ec.SECP256R1()).
3. Wyodrębnij współrzędne x i y klucza publicznego krzywej eliptycznej.
4. Zbuduj słownik JWK zawierający pola: {'crv': 'P-256', 'kty': 'EC', 'x': x_b64, 'y': y_b64}.
5. Zapewnij kanoniczną postać JSON: kanon_json = json.dumps(jwk, sort_keys=True, separators=(',', ':')).
6. Oblicz thumbprint konta: thumbprint = base64_url_encode(hashlib.sha256(kanon_json.encode()).digest()).
7. Zdefiniuj przykładowy token wyzwania otrzymany z CA: token = 'DqlZmKXjpGnDYr7ngB0r_w'.
8. Wyznacz ciąg autoryzacyjny: key_auth = f'{token}.{thumbprint}'.
9. Napisz funkcję dla wyzwania DNS-01: dns_record_value = base64_url_encode(hashlib.sha256(key_auth.encode()).digest()).
10. Zapisz zrzuty ekranu z konsoli oraz pełny kod skryptu do sprawozdania laboratoryjnego.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Głębokie zrozumienie kryptograficznych podstaw automatyzacji certyfikacji w protokole ACME (RFC 8555).
• Praktyczna znajomość metody wyliczania JWK Thumbprint (RFC 7638) oraz formatowania danych Base64URL.
• Zrozumienie technicznych różnic pomiędzy wyzwaniem webowym HTTP-01 a wyzwaniem domenowym DNS-01.
• Umiejętność samodzielnej implementacji endpointu weryfikacyjnego dla automatycznych robotów certyfikacyjnych.

Cel

Celem zadania jest dogłębna analiza struktury binarnej rekordów protokołu TLS na poziomie warstwy transportowej. Student pisze skrypt w Pythonie analizujący surowe pakiety TLS Handshake (ClientHello i ServerHello), dekomponuje nagłówki warstwy rekordów, identyfikuje wartości losowe Random, odczytuje listę proponowanych ciphersuites oraz parsuje rozszerzenia binarne.

Scenariusz – opis

Większość administratorów i deweloperów postrzega protokół TLS jedynie przez pryzmat interfejsu gniazd sieciowych. Jednak w celu rzetelnej analizy bezpieczeństwa i rozwiązywania problemów sieciowych niezbędne jest zrozumienie binarnej budowy pakietów. Wszystkie komunikaty TLS są hermetyzowane w strukturach zwanych rekordami TLS Record Layer. Rekord rozpoczyna się od 5-bajtowego nagłówka zawierającego ContentType, wersję protokołu oraz długość ładunku. Podprotokół Handshake odpowiada za najważniejszą fazę negocjacji i wymiany parametrów kryptograficznych. Pierwszym pakietem wysyłanym przez klienta jest ClientHello, zawierający 32-bajtową wartość losową Client Random.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik tls_parser.py i zaimportuj moduł struct oraz moduł socket.
2. Przygotuj funkcję rozpakowującą nagłówek rekordu TLS: content_type, version, length = struct.unpack('!BHH', data[:5]).
3. Sprawdź, czy content_type == 22 (Handshake). Wypisz wersję bazową i rozmiar ramki.
4. Rozpakuj nagłówek Handshake: hs_type, hs_length = struct.unpack('!B3s', data[5:9]).
5. Potwierdź, że hs_type == 1 (ClientHello).
6. Wyodrębnij 32 bajty losowe: client_random = data[11:43].hex(). Wypisz uzyskany ciąg.
7. Odczytaj długość Session ID: session_id_len = data[43], a następnie pomiń ten segment bajtów.
8. Odczytaj 2-bajtową długość listy szyfrów: cipher_suites_len = struct.unpack('!H', data[offset:offset+2])[0].
9. Zaimplementuj pętlę odczytującą kolejne 2-bajtowe kody ciphersuites: for i in range(0, cipher_suites_len, 2): code = struct.unpack('!H', ...).
10. Wykonaj zrzut ekranu prezentujący zdekodowane pola Client Random, listę ciphersuites oraz nazwę domeny z SNI.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Szczegółowa znajomość binarnej budowy ramki TLS Record Layer oraz komunikatów fazy Handshake.
• Zrozumienie roli pola Client Random w generowaniu kluczy sesyjnych i przeciwdziałaniu atakom powtórzeniowym.
• Praktyczna umiejętność binarnego parsowania protokołów sieciowych w języku Python z użyciem modułu struct.
• Świadomość struktury rozszerzeń TLV (Type-Length-Value) stanowiących fundament elastyczności standardu TLS.

Cel

Celem zadania jest praktyczne zrozumienie działania protokołu uwierzytelniania w sieciach rozproszonych Kerberos v5. Student implementuje w języku Python kompletną symulację wymiany komunikatów pomiędzy Klientem, serwerem Authentication Server (AS), serwerem biletowym Ticket Granting Server (TGS) oraz Serwerem Usługi, badając rolę biletu TGT oraz kluczy sesyjnych.

Scenariusz – opis

W wielkich sieciach korporacyjnych i domenach Active Directory standardem uwierzytelniania jest protokół Kerberos. Kerberos rozwiązuje problem logowania w niezaufanej sieci bez konieczności przesyłania haseł użytkowników do serwerów aplikacji. Architektura opiera się na zaufanej trzeciej stronie zwanej Key Distribution Center KDC. W skład KDC wchodzą dwa logiczne moduły: serwer uwierzytelniania Authentication Server AS oraz serwer nadawania biletów Ticket Granting Server TGS. W pierwszym etapie klient uwierzytelnia się w AS za pomocą klucza wyprowadzonego ze swojego hasła. W odpowiedzi klient otrzymuje tymczasowy klucz sesyjny TGT oraz zaszyfrowany tajnym kluczem KDC bilet Ticket Granting Ticket TGT.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik kerberos_sim.py i zaimportuj moduły: os, time, json z biblioteki standardowej oraz AESGCM z biblioteki cryptography.
2. Zdefiniuj klucze długoterminowe uczestników: K_client = os.urandom(32), K_kdc = os.urandom(32), K_service = os.urandom(32).
3. Napisz funkcję pomocniczą encrypt(key, dict_data) oraz decrypt(key, ciphertext) realizujące szyfrowanie AEAD.
4. Zaimplementuj komunikat KRB_AS_REQ: klient wysyła nazwę użytkownika 'alice' oraz identyfikator realm 'LAB.LOCAL'.
5. W module AS wygeneruj sesyjny klucz biletowy: K_client_tgs = os.urandom(32).
6. Zbuduj strukturę biletu TGT: {'user': 'alice', 'k_session': K_client_tgs.hex(), 'expiry': time.time() + 36000}.
7. Zaszyfruj bilet TGT kluczem K_kdc: enc_tgt = encrypt(K_kdc, tgt_data).
8. Przygotuj odpowiedź KRB_AS_REP zaszyfrowaną kluczem K_client: {'k_session': K_client_tgs.hex(), 'tgt': enc_tgt}.
9. Po stronie klienta odszyfruj odpowiedź i wyodrębnij sesyjny klucz K_client_tgs oraz zachowaj nienaruszony bilet TGT.
10. Wykonaj zrzuty ekranu prezentujące komunikaty konsoli dla każdego etapu symulacji i umieść je w sprawozdaniu.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Głębokie zrozumienie wieloetapowego procesu uwierzytelniania w protokole Kerberos v5.
• Zrozumienie kluczowej roli biletu TGT w unikaniu wielokrotnego wprowadzania hasła przez użytkownika (model Single Sign-On).
• Świadomość roli Authenticatora i znaczników czasu w uniemożliwianiu ataków powtórzeniowych (Replay Attacks).
• Zrozumienie hierarchii kluczy: klucze długoterminowe uczestników vs krótkoterminowe klucze sesyjne.

Cel

Celem ćwiczenia jest programowa implementacja mechanizmów generowania oraz kryptograficznej walidacji tokenów JWT w języku Python. Student implementuje weryfikację podpisów symetrycznych HS256 oraz asymetrycznych RS256, bada proces sprawdzania roszczeń czasowych oraz przeprowadza test bezpieczeństwa demonstrujący krytyczną podatność akceptacji niepodpisanego tokena z nagłówkiem 'alg: none'.

Scenariusz – opis

W architekturach REST API tokeny JWT stały się podstawowym nośnikiem tożsamości i uprawnień użytkowników. Wzorzec implementacyjny wymaga od serwera rygorystycznego sprawdzania kryptograficznego podpisu przed odczytaniem jakichkolwiek roszczeń. W algorytmie HS256 podpis jest wyliczany za pomocą funkcji HMAC ze wspólnym kluczem symetrycznym. W zastosowaniach rozproszonych preferowany jest algorytm asymetryczny RS256, w którym dostawca tożsamości podpisuje token kluczem prywatnym. Dzięki temu serwery aplikacji mogą weryfikować tokeny wyłącznie za pomocą publicznie dostępnego klucza RSA bez ryzyka wycieku uprawnień. Jedną z najsłynniejszych podatności w historii bibliotek webowych była podatność akceptacji tokenów z deklaracją algorytmu o wartości 'none'.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik jwt_engine.py i zaimportuj moduły: hmac, hashlib, json, base64, time oraz cryptography.
2. Napisz funkcje pomocnicze: b64url_encode( data) oraz b64url_decode(str_data) poprawnie obsługujące padding '='.
3. Zaimplementuj generator JWT z algorytmem HS256: generate_hs256( payload, secret).
4. Wygeneruj parę kluczy RSA 2048-bit za pomocą modułu cryptography.hazmat.primitives.asymmetric.rsa.
5. Zaimplementuj generator JWT z algorytmem RS256: generate_rs256( payload, private_key).
6. Napisz funkcję weryfikacji RS256 sprawdzającą podpis kluczem publicznym oraz roszczenie exp: verify_rs256( token, pubkey).
7. Napisz funkcję podatną vulnerable_verify( token, secret, pubkey), która dla header['alg'] == 'none' pomija sprawdzanie podpisu.
8. Wygeneruj sfałszowany token z nagłówkiem: {'alg': 'none', 'typ': 'JWT'} oraz payloadem: {'user': 'attacker', 'role': 'admin'}.
9. Zbuduj token ataku: token_malic = b64url_encode( header) + '.' + b64url_encode( payload) + '.'.
10. Zapisz zrzuty ekranu z konsoli dokumentujące udany atak na podatny kod oraz jego skuteczne zablokowanie.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Zrozumienie mechanizmu kryptograficznego podpisywania tokenów JWT algorytmami symetrycznymi i asymetrycznymi.
• Świadomość historycznej podatności 'alg: none' i przyczyn jej powszechnego występowania w bibliotekach webowych.
• Praktyczna umiejętność implementacji rygorystycznej walidacji nagłówków kryptograficznych w języku Python.
• Zrozumienie konieczności wymuszania oczekiwanego algorytmu po stronie serwera aplikacji wbrew deklaracjom klienta.

Cel

Celem zadania jest samodzielna implementacja algorytmu generowania i weryfikacji haseł jednorazowych TOTP od podstaw w języku Python zgodnie ze specyfikacją RFC 6238. Student implementuje algorytm dynamicznego obcinania Dynamic Truncation, oblicza kody w oknach czasowych 30 sekund, generuje format URI otpauth:// oraz testuje tolerancję na przesunięcia zegara systemowego.

Scenariusz – opis

Tradycyjne uwierzytelnianie jednoskładnikowe oparte wyłącznie na haśle jest wysoce podatne na wycieki i ataki phishingowe. Współczesnym standardem ochrony kont jest wieloskładnikowe uwierzytelnianie MFA, wykorzystujące drugi czynnik posiadania. Najpowszechniejszym rozwiązaniem drugiego składnika są 6-cyfrowe kody generowane przez aplikacje mobilne (np. Google Authenticator). Działają one w oparciu o algorytm TOTP Time-based One-Time Password ustandaryzowany w dokumencie RFC 6238. TOTP jest rozwinięciem algorytmu HOTP, w którym licznik zdarzeń został zastąpiony liczbą 30-sekundowych interwałów czasowych od epoki Uniksa.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik totp_engine.py i zaimportuj moduły: hmac, hashlib, time, struct, base64.
2. Zdefiniuj funkcję generate_secret(): wygeneruj 20 losowych bajtów i zwróć je w formacie base64.b32encode().
3. Napisz funkcję hotp(secret_bytes, counter): oblicz HMAC-SHA1 z 8-bajtowego spakowanego licznika struct.pack('>Q', counter).
4. Zaimplementuj w funkcji hotp procedurę dynamicznego obcinania: offset = hmac_result[-1] & 0x0F.
5. Wyodrębnij 4 bajty: code_int = struct.unpack('>I', hmac_result[ offset:offset+4])[0] & 0x7FFFFFFF.
6. Zwróć sformatowany kod: f'{code_int % 1000000:06d}'.
7. Napisz funkcję totp(secret_b32, time_step=30): oblicz counter = int(time.time() / time_step) i wywołaj hotp.
8. Przetestuj implementację na oficjalnych wektorach testowych RFC 6238 dla podanych znaczników czasu.
9. Upewnij się, że dla znacznika czasu T=59s i zadanego klucza testowego funkcja zwraca poprawny wektor z RFC.
10. Zapisz zrzut ekranu działania pętli monitorującej oraz dołącz kod skryptu do sprawozdania.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Głębokie zrozumienie matematycznych podstaw algorytmów HOTP (RFC 4226) oraz TOTP (RFC 6238).
• Praktyczna znajomość procedury Dynamic Truncation przekształcającej skrót kryptograficzny w krótki kod PIN.
• Zrozumienie znaczenia okien czasowych (30s) oraz tolerancji zegarowej w implementacjach serwerowych.
• Umiejętność integracji algorytmów kryptograficznych z ekosystemem aplikacji uwierzytelniania wieloskładnikowego MFA.

Cel

Celem zadania jest praktyczne zbadanie dwóch kluczowych technologii kryptograficznych zabezpieczających pocztę elektroniczną: standardu S/MIME oraz protokołu DKIM. Student implementuje w języku Python podpisywanie wiadomości e-mail certyfikatem X.509 w formacie S/MIME oraz weryfikuje kryptograficzny podpis DKIM-Signature pobierając publiczny klucz nadawcy.

Scenariusz – opis

Poczta elektroniczna pozostaje jednym z najbardziej wrażliwych kanałów komunikacji biznesowej i urzędowej. Dla zapewnienia integralności i niezaprzeczalności przesyłanych wiadomości stosuje się dwa odrębne podejścia kryptograficzne. Pierwsze z nich, S/MIME, działa na poziomie użytkownika końcowego (end-to-end), zabezpieczając treść za pomocą certyfikatu osobistego X.509. Podpis S/MIME jest hermetyzowany w strukturze Cryptographic Message Syntax CMS w formacie wieloczęściowym multipart/signed. Drugie rozwiązanie, DKIM DomainKeys Identified Mail, działa na poziomie serwerów pocztowych infrastruktury domeny. Serwer nadawczy sygnuje nagłówki i treść wiadomości asymetrycznym kluczem prywatnym domeny, umieszczając nagłówek DKIM-Signature.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik email_crypto.py i zaimportuj moduły: email, hashlib, base64 oraz cryptography.
2. Zbuduj prostą wiadomość e-mail: msg = EmailMessage(), dodając nagłówki From, To, Subject oraz treść.
3. Wczytaj certyfikat użytkownika i klucz prywatny z plików PEM.
4. Przygotuj funkcję tworzącą podpis CMS: uzyj PKCS7SignatureBuilder lub wywołaj polecenie openssl smime -sign.
5. Zapisz podpisaną wiadomość do pliku wiadomosc_smime.eml.
6. Wyświetl zawartość pliku eml, identyfikując nagłówek Content-Type: multipart/signed oraz załącznik smime.p7s.
7. Zweryfikuj integralność wiadomości S/MIME: sprawdź poprawność podpisu względem certyfikatu wystawcy.
8. Przygotuj przykładowy nagłówek DKIM-Signature zawierający tagi: v=1; a=rsa-sha256; c=relaxed/relaxed; d=domena.pl; s=s2024; bh=...; b=...
9. Napisz funkcję kanonizacji treści canonicalize_body_relaxed(body_bytes), usuwającą spacje na końcach linii i redukującą puste wiersze.
10. Zapisz zrzuty ekranu prezentujące strukturę pliku S/MIME oraz raport z weryfikacji skrótu i podpisu DKIM.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Zrozumienie fundamentalnych różnic pomiędzy podpisem użytkownika S/MIME a podpisem domeny DKIM.
• Praktyczna znajomość budowy wiadomości multipart/signed oraz struktur CMS / PKCS#7.
• Zrozumienie roli procesu kanonizacji nagłówków i treści w zapewnianiu odporności podpisów DKIM na modyfikacje MTA.
• Umiejętność samodzielnej weryfikacji kryptograficznej poszczególnych składowych nagłówka DKIM-Signature.

Cel

Celem zadania jest praktyczne prześledzenie i weryfikacja kryptograficznego łańcucha zaufania DNSSEC od strefy głównej root aż do domeny końcowej. Student bada strukturę rekordów DNSKEY, DS oraz RRSIG, implementuje w języku Python weryfikację skrótu rekordu DS względem klucza KSK oraz weryfikuje podpis cyfrowy rekordu adresowego A za pomocą klucza ZSK.

Scenariusz – opis

Klasyczny system nazw domenowych DNS przesyła zapytania i odpowiedzi otwartym tekstem przez protokół UDP. Brak uwierzytelniania umożliwił ataki zatruwania pamięci podręcznej DNS Cache Poisoning, kierujące ruch użytkowników na fałszywe serwery. Odpowiedzią na to zagrożenie jest rozszerzenie bezpieczeństwa DNSSEC ustandaryzowane w dokumentach RFC 4033 do 4035. DNSSEC nie szyfruje zapytań w celu zapewnienia poufności, lecz gwarantuje autentyczność i integralność odpowiedzi poprzez podpisy cyfrowe. W każdej zabezpieczonej strefie rekordy są grupowane w zestawy RRSET i podpisywane kluczem strefowym ZSK Zone Signing Key. Podpis cyfrowy każdego zestawu rekordów jest publikowany w powiązanym rekordzie RRSIG.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik dnssec_verify.py i zaimportuj moduły: dns.resolver, dns.dnssec, hashlib.
2. Skonfiguruj resolver DNS z włączoną obsługą DNSSEC: res = dns.resolver.Resolver(); res.use_edns(0, dns.flags.DO, 4096).
3. Pobierz rekord A oraz rekord RRSIG dla domeny: q = res.resolve('iana.org', 'A').
4. Wypisz zawartość rekordu A oraz pola rekordu RRSIG: algorytm, etykiety, daty ważności i wartość podpisu.
5. Pobierz rekordy DNSKEY strefy: dnskey_rr = res.resolve('iana.org', 'DNSKEY').
6. Zidentyfikuj klucze: znajdź klucz z flagą 256 (ZSK) oraz klucz z flagą 257 (KSK).
7. Pobierz rekord DS ze strefy nadrzędnej: ds_rr = res.resolve('iana.org', 'DS').
8. Napisz funkcję obliczającą skrót KSK: wylicz SHA-256 z danych kanonicznych klucza KSK.
9. Porównaj wyliczony skrót z polem digest rekordu DS i potwierdź dopasowanie: print('Dopasowanie KSK do rekordu DS: ZGODNE').
10. Zapisz zrzuty ekranu z konsoli oraz dołącz kod skryptu do sprawozdania laboratoryjnego.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Zrozumienie architektury bezpieczeństwa rozszerzenia DNSSEC i eliminacji zagrożenia DNS Cache Poisoning.
• Praktyczna znajomość ról kluczy ZSK (Zone Signing Key) oraz KSK (Key Signing Key).
• Zrozumienie kryptograficznej funkcji rekordu DS (Delegation Signer) jako kotwicy zaufania pomiędzy strefami.
• Umiejętność programowej weryfikacji rekordów i podpisów RRSIG z wykorzystaniem dedykowanych bibliotek sieciowych.

Cel

Celem zadania jest zaprojektowanie i implementacja w języku Python kompleksowego skryptu audytującego konfigurację kryptograficzną serwerów WWW. Student bada obsługiwane wersje protokołów (TLS 1.2, TLS 1.3), sprawdza obecność bezpiecznych zestawów szyfrów gwarantujących Perfect Forward Secrecy, wykrywa przestarzałe algorytmy oraz weryfikuje nagłówek ochronny HSTS.

Scenariusz – opis

Samo zainstalowanie ważnego certyfikatu X.509 na serwerze WWW nie gwarantuje jeszcze pełnego bezpieczeństwa transmisji. Kluczowe znaczenie ma poprawna konfiguracja parametrów silnika TLS po stronie serwera aplikacji. Nieprawidłowo skonfigurowany serwer może dopuszczać podatne wersje protokołów (TLS 1.0, TLS 1.1) lub przestarzałe szyfry blokowe. Współczesne standardy bezpieczeństwa wymagają bezwzględnego stosowania mechanizmu Perfect Forward Secrecy PFS opartego na ECDHE. PFS gwarantuje, że ewentualne przejęcie klucza prywatnego serwera w przyszłości nie pozwoli na odszyfrowanie nagranych wcześniej sesji. Ponadto aplikacje muszą wymuszać szyfrowanie za pomocą nagłówka HTTP Strict Transport Security HSTS zdefiniowanego w RFC 6797.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. Utwórz plik tls_auditor.py i zaimportuj moduły: ssl, socket, urllib.request, json.
2. Zdefiniuj funkcję test_tls_version( hostname, port, version): skonfiguruj ssl.SSLContext i spróbuj nawiązać połączenie.
3. Przetestuj obsługę protokołów: sprawdź kolejno TLSv1, TLSv1_1, TLSv1_2 oraz TLSv1_3.
4. Zarejestruj, które wersje protokołów zostały zaakceptowane przez badany serwer.
5. Dla protokołu TLS 1.2 wyodrębnij wynegocjowany ciphersuite za pomocą metody sslobj.cipher().
6. Sprawdź, czy nazwa szyfru zawiera ciąg 'ECDHE', potwierdzając właściwość Perfect Forward Secrecy.
7. Napisz funkcję sprawdzającą podatne szyfry: spróbuj wymusić zestaw ciphers='RC4:3DES:DES' i upewnij się, że serwer odrzuca próbę.
8. Napisz funkcję badającą nagłówki HTTP: wyślij żądanie urllib.request.Request(f'https://{hostname}') z metodą HEAD.
9. Odczytaj nagłówek 'Strict-Transport-Security' z odpowiedzi serwera.
10. Zapisz zrzut ekranu z wykonania audytu oraz dołącz wygenerowany plik JSON do sprawozdania laboratoryjnego.

Sugerowane wnioski i podsumowanie - co student ma osiągnąć

Sprawozdanie z realizacji zadania musi zawierać następujące kluczowe wnioski i osiągnięcia:

• Praktyczna umiejętność programowego audytowania konfiguracji TLS serwerów za pomocą języka Python.
• Zrozumienie krytycznej roli mechanizmu Perfect Forward Secrecy (PFS) w ochronie nagranych danych historycznych.
• Świadomość zagrożeń wynikających ze wspierania przestarzałych wersji protokołów SSLv3, TLS 1.0 i TLS 1.1.
• Znajomość działania nagłówka HSTS oraz jego roli w uniemożliwianiu ataków typu SSL Stripping.