Poziom: ocena 4.0 - programowanie algorytmów macierzy, deduplikacja i kryptografia dyskowa

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ęść 6 (sieciowe systemy składowania danych: SAN, NAS i macierze RAID).

1. 01.Programowa implementacja algorytmu paskowania i parzystości RAID 5 w Pythonie (operacja XOR i rekonstrukcja danych)
2. 02.Implementacja podwójnej parzystości RAID 6 w Pythonie z wykorzystaniem ciał Galois GF(2^8) i kodów Reeda-Solomona
3. 03.Binarny parser i analizator nagłówków wolumenu szyfrowanego LUKS (LUKS1 i LUKS2) w języku Python
4. 04.Algorytm krojenia danych (Chunking) i deduplikacja blokowa w Pythonie w oparciu o sumy kontrolne SHA-256
5. 05.Implementacja zbieżnego szyfrowania (Convergent Encryption) dla deduplikacji zaszyfrowanych danych w chmurze
6. 06.Wykrywanie cichej degradacji danych (Silent Data Corruption / Bit Rot) z użyciem drzewa haszy Merkle w Pythonie
7. 07.Programowy symulator migawek Copy-on-Write (CoW) i zarządzania blokami wirtualnymi w Pythonie
8. 08.Dekonstrukcja protokołu uwierzytelniania CHAP w sieci iSCSI SAN i symulacja weryfikacji hasza w Pythonie
9. 09.Modelowanie niezawodności macierzy dyskowej: skrypt kalkulujący wskaźniki MTBF, AFR, MTTDL i ryzyko błędu URE podczas odbudowy RAID 5
10. 10.Implementacja i analiza trybu szyfrowania dyskowego AES-XTS (IEEE 1619) w Pythonie oraz demonstracja braku integralności

Cel

Celem zadania jest samodzielne zaimplementowanie w języku Python programowego symulatora macierzy RAID 5. Student tworzy mechanizm podziału strumienia bajtów na paski (striping), implementuje wyliczanie bloków parzystości za pomocą operacji bitowej XOR z rotacją lewostronną (left-symmetric), symuluje utratę dowolnego dysku oraz programowo rekonstruuje utracone dane.

Scenariusz – opis

Macierz RAID 5 stanowi jeden z najważniejszych kamieni milowych w rozwoju architektur pamięci masowych wysokiej dostępności. Jej konstrukcja opiera się na rozproszeniu bloków parzystości pomiędzy wszystkie fizyczne nośniki tworzące grupę macierzową. Dzięki wyeliminowaniu pojedynczego dedykowanego dysku parzystości znanego z RAID 4 uniknięto wąskiego gardła podczas operacji zapisu.

Matematyczną podstawą generowania bloku parzystości P jest operacja alternatywy rozłącznej XOR wykonywana na odpowiadających sobie blokach danych. Właściwość inwolucji i łączności operacji XOR sprawia, że mając dany blok parzystości oraz n minus jeden bloków danych, brakujący blok odzyskuje się natychmiastowo. W implementacjach produkcyjnych standardem jest rotacja lewostronna symetryczna określana w dokumentacji jądra Linux jako left-symmetric.

W układzie tym w każdym kolejnym pasku logicznym (stripe) blok parzystości przesuwa się cyklicznie o jeden dysk w lewo. Zrozumienie niskopoziomowego formatu ułożenia danych pozwala programistom diagnozować uszkodzenia systemów plików i budować narzędzia odzyskiwania danych. Programowa symulacja takiego podsystemu w języku Python pozwala prześledzić każdy krok operacji wejścia-wyjścia na poziomie pojedynczych bajtów. Student poznaje mechanizm przetwarzania tablic bajtowych bytearray oraz symulacji wirtualnych nośników pamięci jako plików binarnych.

W tym zadaniu zbudujesz w pełni funkcjonalny skrypt implementujący logikę zapisu, odczytu oraz procedurę rekonstrukcji po awarii w architekturze RAID 5.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/raid5_dev && cd ~/raid5_dev.
2. Utwórz plik skryptu w języku Python: nano raid5_engine.py.
3. Zaimportuj niezbędne moduły standardowe: os, sys, hashlib.
4. Zdefiniuj funkcję xor_blocks( blocks) wykonującą operację bajt po bajcie za pomocą bytearray.
5. Zdefiniuj klasę VirtualRAID5 z parametrami num_disks=4 i stripe_size=64.
6. Zaimplementuj metodę init_disks() tworzącą 4 pliki binarne o stałej pojemności w podkatalogu disks/.
7. Zaimplementuj metodę write_stream( data) dzielącą strumień na fragmenty po 3 bloki danych (dla 4 dysków) i 1 blok parzystości.
8. Zaimplementuj rotację parzystości left-symmetric: parity_disk = (num_disks - 1) - (stripe_index % num_disks).
9. Zapisz dane i parzystość do odpowiednich plików dyskowych.
10. Zaimplementuj metodę read_stream( length) odczytującą i składającą strumień danych z pominięciem bloków parzystości.
11. Zapisz w macierzy próbkę danych: 'Projekt bezpiecznego repozytorium kryptograficznego semestr 7 UAFM'.
12. Oblicz skrót SHA-256 wprowadzonych danych i zapamiętaj wartość wzorcową.
13. Zasymuluj awarię: os.remove('disks/dysk_1.bin') (usunięcie dysku numer 1).
14. Zaimplementuj metodę recover_disk(failed_disk_id) odtwarzającą brakujący plik z pozostałych 3 dysków za pomocą funkcji xor_blocks.
15. Uruchom proces odbudowy i potwierdź utworzenie nowego pliku disks/dysk_1_reconstructed.bin.
16. Zweryfikuj tożsamość zrekonstruowanych danych: hashlib.sha256( odczyt).hexdigest() == sha_wzorcowe.
17. Przetestuj działanie skryptu z różnymi rozmiarami paska stripe_size (16, 64, 512 bajtów).
18. Wykonaj zrzuty ekranu kodu źródłowego, logów działania symulatora oraz weryfikacji sumy SHA-256.

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 matematycznej elegancji operacji XOR w konstrukcji rozproszonej parzystości RAID 5.
• Praktyczna umiejętność programowania geometrii paska (stripe mapping) z rotacją lewostronną left-symmetric.
• Potwierdzenie zdolności macierzy RAID 5 do pełnej rekonstrukcji danych po utracie dokładnie jednego nośnika.
• Świadomość braku możliwości odzyskania informacji w przypadku jednoczesnej utraty dwóch dysków w RAID 5.

Cel

Celem laboratorium jest implementacja zaawansowanego algorytmu podwójnej parzystości P+Q macierzy RAID 6 w języku Python. Student implementuje arytmetykę ciała skończonego Galois GF(2^8) z wielomianem pierwotnym x^8 + x^4 + x^3 + x^2 + 1 (0x11d), wylicza wektory parzystości P oraz Q, symuluje równoczesną awarię dwóch nośników i przeprowadza matematyczną rekonstrukcję brakujących bloków.

Scenariusz – opis

Współczesne dyski twarde o pojemnościach przekraczających kilkanaście terabajtów wymagają kilkunastu godzin na proces odbudowy macierzy RAID 5. W trakcie tak długiego czasu obciążenia prawdopodobieństwo wystąpienia błędu na drugim dysku lub jego całkowitej awarii drastycznie rośnie. Z tego względu standardem bezpieczeństwa w macierzach enterprise stał się poziom RAID 6, gwarantujący odporność na awarię dwóch dowolnych dysków.

O ile pierwszy blok parzystości P jest klasyczną sumą XOR, o tyle drugi blok parzystości Q nie może być wyliczony prostym XOR-em. Wyznaczenie niezależnego drugiego syndromu ochronnego Q wymaga zastosowania algebry liniowej nad ciałem skończonym Galois GF(2^8). Ciało Galois GF(2^8) to zbiór 256 elementów odpowiadających pojedynczym bajtom, na których operacje dodawania i mnożenia zachowują własności ciała.

Dodawanie w GF(2^8) realizowane jest operacją XOR, natomiast mnożenie wymaga redukcji modulo wielomian nierozkładalny, np. 0x11d. W celu optymalizacji wydajności mnożenie w ciele wykonuje się przy użyciu wstępnie wygenerowanych tablic logarytmów i eksponentów (log/alog tables).

Syndrom Q oblicza się jako sumę iloczynów kolejnych bloków danych pomnożonych przez potęgi generatora ciała g równego dwa. Utrata dwóch dysków prowadzi do układu dwóch równań liniowych z dwiema niewiadomymi w GF(2^8), który rozwiązuje się wyznacznikami macierzy.

W tym zadaniu zaimplementujesz pełną arytmetykę GF(2^8) oraz algorytm generowania i rekonstrukcji parzystości P+Q w języku Python.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W katalogu roboczym utwórz plik: nano raid6_galois.py.
2. Zaimplementuj generator tablic Galois GF(2^8): wielomian pierwotny POLYNOMIAL = 0x11D.
3. Wypełnij tablice exp_table i log_table wartościami generatora g = 0x02 dla potęg 0 do 254.
4. Zaimplementuj funkcję mnożenia w ciele: gf_mul(a, b) = exp_table[(log_table[ a] + log_table[b]) % 255] (z obsługą zera).
5. Zaimplementuj funkcję dzielenia: gf_div(a, b) = exp_table[(log_table[ a] - log_table[b] + 255) % 255].
6. Przetestuj właściwości ciała: gf_mul(0x53, 0xCA) oraz upewnij się, że gf_div(x, x) == 1 dla x != 0.
7. Zdefiniuj funkcję compute_p( blocks) zwracającą sumę XOR bloków bajtowych.
8. Zdefiniuj funkcję compute_q( blocks) mnożącą bajty bloku i przez g^i w ciele GF(2^8) i sumującą wyniki operacją XOR.
9. Przygotuj 4 bloki danych D0, D1, D2, D3 o rozmiarze 16 bajtów każdy (np. fragmenty tekstu).
10. Wylicz wektory parzystości P i Q dla przygotowanych danych wejściowych.
11. Zasymuluj podwójną awarię: skasuj bloki D1 oraz D2, traktując je jako utracone.
12. Wyprowadź macierz równań: DeltaP = P XOR D0 XOR D3 = D1 XOR D2 oraz DeltaQ = Q XOR (D0*g^0) XOR (D3*g^3) = (D1*g^1) XOR (D2*g^2).
13. Rozwiąż układ równań liniowych z użyciem wyznacznika det = (g^1 XOR g^2) w ciele GF(2^8).
14. Wyznacz odzyskany blok D2 = gf_div((DeltaQ XOR (DeltaP * g^1)), det).
15. Wyznacz odzyskany blok D1 = DeltaP XOR D2.
16. Sprawdź programowo zgodność: assert D1 == D1_oryginalne and D2 == D2_oryginalne.
17. Przetestuj przypadek awarii jednego dysku danych oraz dysku parzystości P (odzyskanie z Q).
18. Wykonaj zrzuty ekranu kodu algorytmu, tablicy logarytmów oraz pomyślnej rekonstrukcji obu dysków.

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 konieczności wykorzystania ciał Galois GF(2^8) do budowy liniowo niezależnych syndromów parzystości w RAID 6.
• Praktyczna umiejętność implementacji tablic logarytmicznych exp/log dla przyspieszenia operacji mnożenia w ciele skończonym.
• Opanowanie procedury rekonstrukcji dwóch równocześnie utraconych dysków poprzez rozwiązanie układu równań liniowych.
• Świadomość przewagi bezpieczeństwa RAID 6 w nowoczesnych środowiskach pamięci masowych pomimo wyższego narzutu obliczeniowego.

Cel

Celem zadania jest napisanie w języku Python niskopoziomowego parsera binarnego analizującego nagłówki wolumenów szyfrowanych LUKS1 i LUKS2. Student odczytuje surowe struktury nagłówka za pomocą modułu struct, ekstrahuje metadane JSON w LUKS2, analizuje parametry pamięciowe funkcji KDF (Argon2id / PBKDF2), odczytuje wektory soli i weryfikuje status aktywności slotów kluczy.

Scenariusz – opis

Standard LUKS (Linux Unified Key Setup) jest fundamentem bezpieczeństwa danych w spoczynku w ekosystemie linuksowym. Początkowe sektory wolumenu szyfrowanego zawierają ustandaryzowany nagłówek, który definiuje parametry kryptograficzne i przechowuje zaszyfrowany klucz główny. W wersji LUKS1 nagłówek miał ściśle określoną binarną strukturę C struct o stałym rozmiarze pól i ograniczeniu do 8 slotów kluczy.

Wprowadzony standard LUKS2 zrewolucjonizował ten format, wprowadzając elastyczne metadane kodowane w formacie JSON oraz redundantne nagłówki zapobiegające uszkodzeniu. LUKS2 wprowadził również wsparcie dla nowoczesnej funkcji wyprowadzania klucza Argon2id, odpornej na kryptoanalityczne ataki sprzętowe ASIC i GPU. Zrozumienie binarnego i tekstowego układu nagłówka LUKS jest kluczowe w informatyce śledczej oraz audycie bezpieczeństwa pamięci masowej.

Audytor analizujący surowy obraz dysku potrafi wyodrębnić liczbę skonfigurowanych haseł, zastosowany algorytm (np. aes-xts-plain64) oraz koszt obliczeniowy KDF. Niewłaściwa konfiguracja parametrów KDF (zbyt niska liczba iteracji lub mały przydział pamięci RAM) drastycznie obniża odporność hasła na atak słownikowy. Moduł struct w języku Python stanowi doskonałe narzędzie do rozpakowywania surowych struktur bajtowych zdefiniowanych w języku C.

W tym zadaniu przeanalizujesz strukturę binarną nagłówka LUKS1 oraz zdekodujesz hierarchię JSON nagłówka LUKS2 z poziomu autorskiego skryptu. Pozwoli ci to w praktyce zrozumieć, w jaki sposób metadane partycji organizują proces bezpiecznego uwierzytelniania wolumenu blokowego.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/luks_parser && cd ~/luks_parser.
2. Utwórz dwa pliki obrazów po 20 MB: dd if=/dev/zero of=vol1.img bs=1M count=20 && dd if=/dev/zero of=vol2.img bs=1M count=20.
3. Sformatuj pierwszy wolumen w formacie LUKS1: cryptsetup luksFormat --type luks1 --batch-mode vol1.img (hasło: TestHaslo1).
4. Sformatuj drugi wolumen w formacie LUKS2: cryptsetup luksFormat --type luks2 --batch-mode vol2.img (hasło: TestHaslo2).
5. Dodaj drugi slot klucza w wolumenie LUKS2: cryptsetup luksAddKey --batch-mode vol2.img (nowe hasło: DodatkowyKlucz2).
6. Wyodrębnij surowe nagłówki: dd if=vol1.img of=luks1_hdr.bin bs=1M count=2 && dd if=vol2.img of=luks2_hdr.bin bs=1M count=4.
7. Utwórz skrypt parsera w Pythonie: nano parse_luks.py.
8. W skrypcie otwórz plik luks1_hdr.bin w trybie binarnym rb i odczytaj pierwsze 592 bajty.
9. Użyj formatu struct.unpack('>6sH32s32s32sII32s32sII', data[:208]) do zdekodowania pól nagłówka bazowego phdr LUKS1.
10. Sprawdź sygnaturę magiczną: upewnij się, że data[:6] == b'LUKS\xba\xbe'.
11. Wyświetl wersję, szyfr (aes), tryb (xts-plain64) oraz przesunięcie danych payload_offset.
12. Przejdź do analizy pliku luks2_hdr.bin: sprawdź sygnaturę b'LUKS\xba\xb2' i odczytaj nagłówek binarny o rozmiarze 4096 bajtów.
13. Zlokalizuj obszar tekstowy JSON (zaczynający się od klamry '{') w kolejnych sektorach nagłówka LUKS2.
14. Zdekoduj tekst UTF-8 i załaduj obiekt za pomocą biblioteki json: metadata = json.loads(json_string).
15. Przeanalizuj sekcję metadata['keyslots']: wypisz identyfikatory aktywnych slotów, użytą funkcję KDF (argon2id), sól w Base64 oraz przydział pamięci.
16. Przeanalizuj sekcję metadata['segments']: zidentyfikuj sektor początkowy zaszyfrowanych danych (offset).
17. Wykonaj zrzuty ekranu kodu parsera w Pythonie oraz sformatowanego wyjścia konsolowego prezentującego parametry obu wersji LUKS.
18. Sformułuj wnioski porównujące odporność schematu LUKS1 (PBKDF2) i LUKS2 (Argon2id) na ataki z użyciem klastrów GPU.

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 niskopoziomowej organizacji nagłówków kryptograficznych w standardach LUKS1 i LUKS2.
• Praktyczna umiejętność ekstrakcji i parsowania struktur binarnych C za pomocą modułu struct w Pythonie.
• Umiejętność odczytu i interpretacji rozszerzonych metadanych JSON w nowoczesnym standardzie LUKS2.
• Świadomość krytycznego znaczenia parametrów pamięciożernych funkcji KDF (Argon2id) w obronie przed atakami siłowymi.

Cel

Celem laboratorium jest implementacja silnika deduplikacji danych w języku Python w oparciu o kryptograficzne sumy kontrolne SHA-256. Student porównuje skuteczność deduplikacji ze stałym rozmiarem bloku (Fixed-Size Chunking) z algorytmem krojenia zależnego od treści (Content-Defined Chunking), bada zachowanie przy przesunięciach bajtowych w plikach oraz wylicza współczynnik kompresji i deduplikacji magazynu.

Scenariusz – opis

Deduplikacja danych to kluczowa technologia optymalizacji przestrzeni dyskowej we współczesnych systemach pamięci masowych i kopiach zapasowych. Jej istotą jest identyfikacja powtarzających się segmentów danych i przechowywanie tylko jednego fizycznego egzemplarza każdego unikalnego bloku. Wszystkie pozostałe odwołania do identycznej zawartości zastępowane są kompaktowymi wskaźnikami logicznymi w strukturach metadanych.

Najprostsze podejście, Fixed-Size Chunking (FSC), dzieli strumień wejściowy na sztywne bloki o stałej długości (np. 4 KB lub 8 KB). Metoda FSC cierpi jednak na tzw. problem przesunięcia bajtów (boundary shift problem) - wstawienie pojedynczego bajtu na początku pliku zmienia granice wszystkich kolejnych bloków.

Rozwiązaniem tej wady jest algorytm Content-Defined Chunking (CDC), w którym granice bloków wyznaczane są dynamicznie na podstawie samej zawartości danych. Klasyczny CDC wykorzystuje okno przesuwne i haszowanie wielomianowe Rabina lub funkcję Gear, deklarując granicę bloku, gdy dolne bity skrótu osiągają zadaną wartość. Każdy wycięty blok jest następnie haszowany kryptograficzną funkcją SHA-256, która służy jako unikalny identyfikator w tablicy indeksowej.

Prawdopodobieństwo kolizji w 256-bitowej przestrzeni SHA-256 jest pomijalnie małe, co czyni to podejście bezpiecznym dla integralności danych. Implementacja obu algorytmów w języku Python pozwala empirycznie ocenić współczynnik redukcji danych (deduplication ratio) dla różnych typów obciążeń.

W tym zadaniu zbudujesz prototypowy silnik deduplikacji, przetestujesz podatność na boundary shift i wyznaczysz statystyki zysku pojemnościowego.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/dedup_lab && cd ~/dedup_lab.
2. Utwórz plik testowy bazowy: python3 -c 'with open("doc1.txt", "w") as f: f.write("To jest testowy akapit z powtarzajacymi sie danymi uczelni.\n" * 1000)'.
3. Utwórz plik ze wstawką na początku (boundary shift): python3 -c 'with open("doc2.txt", "w") as f: f.write("START" + open("doc1.txt").read())'.
4. Utwórz skrypt w języku Python: nano dedupe_engine.py.
5. Zaimplementuj magazyn bloków: chunk_store = {} (przechowujący hash -> treść_bloku).
6. Zaimplementuj funkcję fsc_chunk( data, chunk_size=1024) zwracającą listę bloków o stałej długości.
7. Zaimplementuj funkcję cdc_chunk( data, min_sz=256, max_sz=2048, mask=0x1FF) z ruchomym oknem i prostym haszem rolling sum.
8. Dla algorytmu CDC zdefiniuj warunek granicy: gdy rolling_hash & mask == 0 lub rozmiar bloku osiągnie max_sz.
9. Przetwórz plik doc1.txt oraz doc2.txt za pomocą algorytmu FSC: zarejestruj hasze SHA-256 bloków w słowniku.
10. Oblicz całkowity rozmiar wejściowy vs rozmiar unikalnych bloków w FSC: dedupe_ratio_fsc = total_bytes / unique_bytes.
11. Odnotuj, jak niska jest efektywność FSC z powodu przesunięcia granic o 5 bajtów.
12. Wyczyść magazyn i przetwórz te same pliki algorytmem CDC.
13. Oblicz współczynnik deduplikacji dla CDC: zaobserwuj radykalny wzrost liczby rozpoznanych wspólnych bloków.
14. Zaimplementuj funkcję odtwarzania oryginalnego pliku na podstawie listy skrótów SHA-256 (rekonstrukcja strumienia).
15. Sprawdź zgodność sumy kontrolnej SHA-256 odtworzonego pliku z oryginałem.
16. Zbadaj odporność na kolizje haszy i wyjaśnij, dlaczego SHA-256 gwarantuje brak kolizji w systemach storage.
17. Wykonaj zrzuty ekranu działania programu, tabeli statystyk bloków oraz dowodu poprawnej rekonstrukcji.
18. Sformułuj rekomendacje wyboru algorytmu chunkingu dla magazynu kopii zapasowych baz danych i maszyn wirtualnych.

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 blokowej deduplikacji danych opartej na kryptograficznych haszach SHA-256.
• Praktyczna identyfikacja problemu przesunięcia granic (boundary shift) w metodzie stałego bloku (FSC).
• Potwierdzenie empirycznej przewagi algorytmu Content-Defined Chunking (CDC) w wykrywaniu duplikatów przy modyfikacjach strumienia.
• Opanowanie procedury rekonstrukcji plików z indeksu bloków unikalnych z gwarancją integralności.

Cel

Celem ćwiczenia jest rozwiązanie fundamentalnego konfliktu pomiędzy prywatnością szyfrowania a efektywnością deduplikacji w chmurze poprzez implementację zbieżnego szyfrowania (Convergent Encryption) w Pythonie. Student implementuje schemat, w którym klucz szyfrujący jest deterministycznie wyprowadzany ze skrótu kryptograficznego zawartości bloku, co pozwala różnym użytkownikom generować identyczne szyfrogramy dla identycznych plików bez ujawniania ich treści dostawcy chmury.

Scenariusz – opis

W erze chmury obliczeniowej dostawcy pamięci masowych masowo stosują deduplikację danych w celu obniżenia kosztów infrastruktury. Równocześnie świadomi użytkownicy i regulacje prawne (np. RODO) wymagają szyfrowania danych przed ich wysłaniem do chmury (klient-side encryption).

W tradycyjnej kryptografii symetrycznej każdy użytkownik stosuje własny, losowy klucz oraz losowy wektor inicjalizujący IV. W efekcie dwa identyczne pliki zaszyfrowane przez dwóch różnych użytkowników stają się całkowicie odmiennymi ciągami pseudolosowych bajtów. Uniemożliwia to dostawcy chmury jakąkolwiek deduplikację, prowadząc do marnotrawstwa przestrzeni dyskowej i wyższych kosztów usługi.

Odpowiedzią na ten dylemat jest technika zbieżnego szyfrowania (Convergent Encryption, CE). W technice tej klucz szyfrujący K wyprowadzany jest w sposób deterministyczny ze skrótu kryptograficznego samej wiadomości: K = SHA256(M). Szyfrowanie realizowane jest algorytmem symetrycznym AES (np. w trybie CTR lub GCM) z wektorem IV również wyliczonym ze skrótu danych.

W rezultacie dowolny użytkownik posiadający dokładnie ten sam plik wygeneruje identyczny klucz oraz identyczny szyfrogram C. Dostawca chmury może bezpiecznie zdeduplikować szyfrogramy na poziomie bloków, nie mając wglądu w tekst jawny bez znajomości danych.

W tym zadaniu zaimplementujesz procedurę zbieżnego szyfrowania, zamodelujesz wielodostęp użytkowników i przeanalizujesz kompromis bezpieczeństwa.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/convergent_lab && cd ~/convergent_lab.
2. Upewnij się o dostępności biblioteki kryptograficznej w Pythonie: python3 -c 'import cryptography' || dnf install -y python3-cryptography.
3. Utwórz plik skryptu: nano convergent_engine.py.
4. Zaimportuj moduły: os, hashlib, json z pakietu cryptography.hazmat.primitives.ciphers (AES, CTR).
5. Zaimplementuj funkcję derive_keys( plaintext): key = hashlib.sha256( plaintext).digest(), iv = hashlib.sha256(key).digest()[:16].
6. Zaimplementuj funkcję ce_encrypt( plaintext): wyprowadź klucz i IV, zaszyfruj dane AES-CTR, zwróć (ciphertext, key).
7. Zaimplementuj funkcję ce_decrypt( ciphertext, key): wyprowadź deterministyczny IV, odszyfruj dane AES-CTR, zwróć plaintext.
8. Zdefiniuj klasę CloudStorage ze słownikiem deduplikacji: storage = {} (mapującym hash_szyfrogramu -> ciphertext).
9. Przygotuj poufny dokument wspólny: doc = b'Raport audytu bezpieczenstwa infrastruktury storage UAFM 2026'.
10. Zasymuluj działanie Klienta 1 (Alice): zaszyfruj dokument, wyślij szyfrogram do chmury, zapisz klucz w lokalnym magazynie Alice.
11. Chmura rejestruje nowy unikalny blok i zwiększa licznik alokacji o 1.
12. Zasymuluj działanie Klienta 2 (Bob): zaszyfruj ten sam dokument metodą CE, wyślij szyfrogram do chmury.
13. Chmura wykrywa duplikat szyfrogramu: deduplication_hit = True, przestrzeń fizyczna nie ulega zwiększeniu.
14. Sprawdź, czy Bob może bez przeszkód odszyfrować plik ze swojego lokalnego klucza: assert ce_decrypt(szyfrogram_z_chmury, klucz_boba) == doc.
15. Zasymuluj próbę ataku podsłuchiwacza chmury: wykaż, że bez znajomości tekstu jawnego chmura widzi jedynie losowy szyfrogram.
16. Przetestuj podatność Dictionary Attack: sprawdź, jak atakujący znający skończony zbiór dokumentów może potwierdzić obecność pliku.
17. Wykonaj zrzuty ekranu kodu źródłowego, symulacji wielodostępnej oraz weryfikacji deduplikacji zaszyfrowanych bloków.
18. Sformułuj wnioski opisujące kompromis pomiędzy semantycznym bezpieczeństwem CPA a deduplikowalnością w chmurze.

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 fundamentalnego konfliktu pomiędzy semantycznym szyfrowaniem a globalną deduplikacją w chmurze.
• Praktyczna umiejętność implementacji zbieżnego szyfrowania (Convergent Encryption) z kluczami deterministycznymi K = H(M).
• Weryfikacja zachowania deduplikacji blokowej po stronie serwera chmurowego przy braku dostępu do tekstu jawnego.
• Świadomość ograniczeń bezpieczeństwa CE (podatność na atak potwierdzenia pliku) oraz znajomość metod mitygacji (DupLESS).

Cel

Celem zadania jest zbudowanie w języku Python mechanizmu wykrywania i lokalizowania cichej korupcji danych (bit rot) za pomocą kryptograficznego drzewa haszy Merkle Tree. Student symuluje magazyn blokowy z sumami kontrolnymi dla każdego liścia, oblicza korzeń drzewa (Merkle Root), symuluje przypadkową zmianę pojedynczego bitu w losowym bloku danych oraz demonstruje procedurę lokalizacji uszkodzenia w czasie logarytmicznym O(log n).

Scenariusz – opis

Wielkoskalowe badania nad nośnikami pamięci masowej dowodzą istnienia zjawiska cichej degradacji danych (Silent Data Corruption / Bit Rot). Polega ono na samoistnym przekłamaniu bitów na magnetycznym talerzu HDD lub w komórkach flash SSD pod wpływem promieniowania kosmicznego lub błędów firmware. Tradycyjne systemy plików (takie jak ext4 czy NTFS) ufają, że nośnik zwróci błąd I/O, jeśli dane są uszkodzone.

Tymczasem przy cichej korupcji kontroler dysku bez ostrzeżenia zwraca przekłamane dane, co prowadzi do trwałego uszkodzenia baz danych i archiwów. Nowoczesne systemy pamięci masowej nowej generacji, w tym ZFS oraz Btrfs, rozwiązują ten problem za pomocą hierarchicznych sum kontrolnych. Kryptograficzną strukturą idealnie modelującą ten mechanizm jest drzewo skrótów Merkle Tree zaproponowane przez Ralpha Merkle.

W drzewie Merkle każdy blok danych na najniższym poziomie reprezentowany jest przez kryptograficzny skrót (liść drzewa). Węzły wyższego poziomu powstają poprzez haszowanie konkatenacji skrótów swoich węzłów potomnych, aż do pojedynczego korzenia Merkle Root. Jakakolwiek modyfikacja nawet pojedynczego bitu w dowolnym bloku danych powoduje kaskadową zmianę korzenia drzewa. Dzięki strukturze drzewiastej zlokalizowanie uszkodzonego bloku w zbiorze milionów elementów wymaga zaledwie logarytmicznej liczby porównań.

W tym zadaniu zaimplementujesz pełne drzewo Merkle w języku Python, zasymulujesz bit rot i zademonstrujesz automatyczną naprawę uszkodzonego bloku.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/merkle_lab && cd ~/merkle_lab.
2. Utwórz plik skryptu: nano merkle_engine.py.
3. Zaimportuj moduły standardowe: hashlib, math, os.
4. Zdefiniuj funkcję sha256( data) zwracającą heksadecymalny skrót ciągu bajtów.
5. Zaimplementuj klasę MerkleNode przechowującą hash, referencje do lewego i prawego dziecka oraz indeks bloku.
6. Zaimplementuj metodę budowania drzewa build_tree( blocks) tworzącą poziomy od liści do korzenia.
7. Wygeneruj 16 bloków danych testowych (D0 do D15) po 128 bajtów każdy.
8. Zbuduj drzewo Merkle i wyświetl referencyjny Merkle Root: print('Poczatkowy Merkle Root:', tree.root_hash).
9. Zaimplementuj funkcję get_proof(block_index) generującą ścieżkę uwierzytelniającą (ścieżkę Merkle'a) dla wybranego bloku.
10. Zaimplementuj weryfikację poprawności pojedynczego bloku względem korzenia przy użyciu ścieżki O(log n).
11. Zasymuluj zjawisko cichej korupcji Bit Rot: blocks[7] = bytearray( blocks[7]); blocks[7][10] ^= 0x01 (odwrócenie bitu w bloku 7).
12. Uruchom procedurę scrub(): wykryj natychmiastową niezgodność nowego Merkle Root z wartością referencyjną.
13. Zaimplementuj algorytm lokalizacji błędu: schodź w dół drzewa, sprawdzając, który podwęzeł zmienił skrót, wskazując uszkodzony indeks 7.
14. Zasymuluj samonaprawę (Self-Healing Storage): pobierz zdrowy blok D7 z kopii lustrzanej (mirror) i zastąp nim uszkodzony blok.
15. Przebuduj drzewo Merkle po naprawie i upewnij się, że Merkle Root powrócił do wartości początkowej.
16. Przetestuj skalowalność algorytmu dla 1024 bloków danych i porównaj liczbę operacji weryfikacji ze skanowaniem liniowym O(n).
17. Wykonaj zrzuty ekranu kodu drzewa Merkle, struktury węzłów oraz logów wykrycia i usunięcia błędu bit rot.
18. Sformułuj wnioski wyjaśniające, dlaczego architektury ZFS i Btrfs opierają się na drzewach haszy w walce z degradacją nośników.

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 natury zjawiska cichej degradacji danych (Bit Rot) niewykrywalnej przez tradycyjne systemy plików.
• Praktyczna umiejętność implementacji kryptograficznego drzewa haszy Merkle Tree w języku Python.
• Znajomość logarytmicznej złożoności O(log n) lokalizacji uszkodzeń i generowania ścieżek uwierzytelniających.
• Świadomość roli mechanizmu scrubbing i samonaprawy w nowoczesnych systemach składowania klasy enterprise (ZFS).

Cel

Celem ćwiczenia jest programowa rekonstrukcja działania migawek bazujących na technice Copy-on-Write (CoW) znanej z systemów plików ZFS i Btrfs. Student pisze w języku Python symulator przestrzeni adresowej bloków, implementuje tablicę translacji wskaźników, tworzy migawki w czasie rzeczywistym, modyfikuje wybrane bloki danych w wolumenie roboczym i dowodzi, że stan w migawce pozostaje nienaruszony przy minimalnym alokowaniu nowej przestrzeni.

Scenariusz – opis

Tradycyjne tworzenie kopii zapasowych poprzez fizyczne powielanie całych dysków jest operacją czasochłonną i drastycznie marnuje przestrzeń. Rewolucją w zarządzaniu danymi stały się migawki (snapshots) wykonywane w ułamku sekundy bez przerywania pracy systemu. Fundamentem nowoczesnych migawek jest architektura Copy-on-Write (kopiowanie przy zapisie) oraz Redirect-on-Write.

W systemie typu CoW bloki danych raz zapisane na dysku są niemutowalne - żadna operacja modyfikacji nie nadpisuje oryginalnego sektora w miejscu. Zamiast tego zmieniony blok zapisywany jest w nowo zaalokowanym wolnym obszarze pamięci masowej, po czym aktualizowany jest jedynie wskaźnik w metadanych. Wykonanie migawki polega wyłącznie na skopiowaniu wskaźnika do korzenia drzewa metadanych i zamrożeniu stanu logicznego wolumenu.

Dopóki wolumen roboczy nie podlega zmianom, migawka nie zajmuje żadnej dodatkowej przestrzeni fizycznej na nośnikach. Dopiero gdy użytkownik zmodyfikuje określony plik, technika CoW alokuje nowe bloki dla nowej wersji, podczas gdy migawka nadal wskazuje na bloki pierwotne. Zapewnia to całkowitą izolację wersji historycznych oraz błyskawiczny powrót do poprzedniego stanu (rollback) w przypadku awarii lub ataku ransomware. Zrozumienie wskaźnikowej natury migawek pozwala optymalizować retencję danych i planować pojemność magazynów pamięci masowej.

W tym zadaniu zaimplementujesz wirtualny menedżer bloków CoW w Pythonie, wykonasz serię migawek i zmierzysz przyrost zużycia pamięci.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/cow_lab && cd ~/cow_lab.
2. Utwórz plik skryptu w języku Python: nano cow_simulator.py.
3. Zdefiniuj klasę PhysicalPool przechowującą słownik blocks = {} oraz ref_counts = {}.
4. Zdefiniuj klasę VirtualVolume zawierającą mapowanie logical_to_physical = {} oraz referencję do puli fizycznej.
5. Zaimplementuj metodę write_block(lba, data): jeśli ref_counts[pba] >1, zaalokuj nowy fizyczny blok i zaktualizuj wskaźnik (zasada CoW).
6. Zaimplementuj metodę read_block(lba) zwracającą zawartość wskazywanego bloku fizycznego.
7. Zaimplementuj menedżer migawek SnapshotManager przechowujący kopie mapowań logicznych z unikalnymi nazwami.
8. Zainicjalizuj wolumen z 8 blokami logicznymi: wpisz do każdego bloku treść 'Wersja_1_Blok_X'.
9. Sprawdź zużycie fizyczne puli: 8 bloków w pamięci, każdy o liczniku referencji równym 1.
10. Wykonaj migawkę snap_poczatkowa: skopiuj mapowanie wskaźników i zwiększ ref_counts wszystkich 8 bloków do 2.
11. Zmierz narzut pamięciowy migawki: potwierdź, że liczba fizycznych bloków nie wzrosła (wciąż wynosi 8).
12. Zmodyfikuj bloki logiczne 1 i 3 w wolumenie roboczym: wpisz 'Wersja_2_Zmieniona'.
13. Zaobserwuj działanie CoW: pula alokuje bloki fizyczne 8 i 9 dla wolumenu roboczego; bloki 1 i 3 w snap_poczatkowa pozostają nienaruszone.
14. Wyświetl zawartość logiczną bloku 1 z wolumenu roboczego oraz z migawki snap_poczatkowa i porównaj różnice.
15. Wykonaj drugą migawkę snap_druga i wprowadź kolejną modyfikację w bloku 1.
16. Zaimplementuj funkcję rollback('snap_poczatkowa') i potwierdź natychmiastowe przywrócenie pierwotnego stanu całego wolumenu.
17. Zaimplementuj usuwanie migawki i zweryfikuj zwalnianie bloków o ref_count == 0 (garbage collection).
18. Wykonaj zrzuty ekranu kodu, mapowania wskaźników bloków oraz logów demonstracyjnych mechanizmu CoW.

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 fundamentalnej zasady niemutowalności i kopiowania przy zapisie (Copy-on-Write).
• Praktyczna znajomość mechanizmu tworzenia natychmiastowych migawek poprzez kopiowanie wskaźników metadanych.
• Opanowanie techniki śledzenia referencji bloków fizycznych (reference counting) gwarantującej brak wycieków pamięci.
• Świadomość roli migawek CoW w strategii ochrony przed atakami ransomware i błyskawicznym odzyskiwaniu spójności.

Cel

Celem laboratorium jest stworzenie w języku Python pełnej symulacji protokołu uwierzytelniania wyzwanie-odpowiedź CHAP (Challenge Handshake Authentication Protocol) stosowanego w sieciach iSCSI SAN. Student implementuje węzły Inicjatora i Celu, modeluje bezpieczną wymianę pakietów uwierzytelniających, symuluje próbę podsłuchania transmisji oraz atak powtórzenia (replay attack), wykazując matematyczne podstawy odporności protokołu CHAP.

Scenariusz – opis

W sieciach pamięci masowej iSCSI SAN dane blokowe przesyłane są przez ogólnodostępną infrastrukturę protokołu TCP/IP. Brak mechanizmów weryfikacji tożsamości pozwoliłby dowolnemu nieautoryzowanemu hostowi w sieci podłączyć się do jednostki LUN i odczytać poufne bazy danych. Podstawowym standardem uwierzytelniania węzłów iSCSI zdefiniowanym w RFC 3720 jest protokół CHAP (Challenge Handshake Authentication Protocol).

Protokół ten eliminuje konieczność przesyłania hasła jawnym tekstem przez sieć, opierając się na schemacie kryptograficznym wyzwanie-odpowiedź. W trakcie fazy logowania (iSCSI Login Phase) cel (Target) generuje unikalny identyfikator wyzwania oraz losowy wektor bajtowy (Challenge). Inicjator (klient) łączy otrzymane wyzwanie ze wspólnym sekretem (hasłem) i oblicza kryptograficzny skrót odpowiedzi (Response) przy użyciu funkcji haszującej.

Po odebraniu odpowiedzi cel wykonuje niezależnie to samo obliczenie i porównuje uzyskany wynik ze skrótem nadesłanym przez klienta. Ponieważ wektor wyzwania jest unikalny dla każdej sesji, potencjalny podsłuchujący nie może ponownie użyć przechwyconej odpowiedzi (ochrona przed Replay Attack). W środowiskach wysokiego bezpieczeństwa stosuje się rozszerzenie Mutual-CHAP, w którym cel musi w analogiczny sposób dowieść swojej tożsamości przed inicjatorem. Zrozumienie szczegółów wymiany komunikatów CHAP pozwala administratorom diagnozować błędy negocjacji sesji i wykrywać anomalie sieciowe.

W tym zadaniu zaimplementujesz symulator protokołu CHAP i Mutual-CHAP w Pythonie oraz przetestujesz odporność na próby fałszerstwa poświadczeń.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/chap_lab && cd ~/chap_lab.
2. Utwórz plik skryptu w Pythonie: nano chap_simulator.py.
3. Zaimportuj moduły: os, hashlib, hmac, secrets.
4. Zdefiniuj tożsamości IQN: target_iqn = 'iqn.2026.pl.uafm:storage.target1', init_iqn = 'iqn.2026.pl.uafm:client.srv1'.
5. Zdefiniuj tajny sekret: shared_secret = b'BardzoTajneHasloSAN2026!'.
6. Zaimplementuj metodę Target.generate_challenge(): id_pkt = secrets.randbelow(256), challenge = os.urandom(16).
7. Zaimplementuj metodę Initiator.compute_response(id_pkt, secret, challenge): hash_obj = hashlib.md5(bytes([ id_pkt]) + secret + challenge); return hash_obj.digest().
8. Zaimplementuj weryfikację w Target.verify_response(id_pkt, secret, challenge, received_response).
9. Uruchom udany handshake CHAP i wyświetl logi: 'Handshake zakonczony sukcesem: Sesja iSCSI zestawiona'.
10. Zasymuluj próbę logowania z niepoprawnym hasłem: upewnij się, że Target zwraca błąd Authentication Failure.
11. Zasymuluj atak typu Replay: zarejestruj poprawny pakiet Response z sesji 1 i wyślij go w sesji 2 z nowym wyzwaniem.
12. Wykaż, że Target odrzuca podrobioną sesję, ponieważ nowe wyzwanie wymaga innego skrótu Response.
13. Zaimplementuj dwustronne uwierzytelnianie Mutual-CHAP: Inicjator generuje drugie wyzwanie, a Target odpowiada skrótem potwierdzającym tożsamość macierzy.
14. Porównaj bezpieczeństwo funkcji MD5 w tradycyjnym CHAP ze współczesnym wariantem CHAP opartym na SHA-256.
15. Zaimplementuj wersję CHAP wykorzystującą SHA-256 zgodnie z zaleceniami RFC 7143.
16. Wykonaj zrzuty ekranu kodu, symulacji handshake'u oraz wyników testów odporności na replay attack.
17. Sformułuj wnioski wyjaśniające, dlaczego sam protokół CHAP nie chroni danych przed podsłuchem po zestawieniu sesji (konieczność IPsec).

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 zasady działania kryptograficznego protokołu wyzwanie-odpowiedź CHAP w sieciach blokowych iSCSI.
• Praktyczna umiejętność modelowania i implementacji procedury obliczania i weryfikacji skrótów odpowiedzi w Pythonie.
• Empiryczne potwierdzenie odporności mechanizmu jednorazowych wyzwań nonce na ataki powtórzenia (Replay Attack).
• Świadomość ograniczeń protokołu CHAP (brak szyfrowania transmisji danych użytkownika) i konieczności stosowania tuneli IPsec.

Cel

Celem zadania jest stworzenie symulatora probabilistycznego w języku Python modelującego niezawodność macierzy wielodyskowych. Student implementuje wzory na roczną stopę awaryjności AFR, oblicza wskaźnik MTTDL dla RAID 0, 1, 5 i 6 oraz przeprowadza matematyczną symulację prawdopodobieństwa wystąpienia błędu URE podczas wielogodzinnej odbudowy dysków o pojemności powyżej 8 TB, uzasadniając konieczność migracji do RAID 6.

Scenariusz – opis

W projektowaniu systemów pamięci masowej intuicja inżynierska bywa zawodna, a decyzje architektoniczne muszą opierać się na rachunku prawdopodobieństwa. Podstawowymi wskaźnikami niezawodności pojedynczego dysku są średni czas bezawaryjnej pracy MTBF (Mean Time Between Failures) oraz roczna stopa awaryjności AFR. Pomiędzy tymi parametrami zachodzi ścisła relacja matematyczna: AFR jest w przybliżeniu równe liczbie godzin w roku podzielonej przez MTBF.

Dla całej macierzy dyskowej kluczową miarą odporności jest wskaźnik MTTDL (Mean Time to Data Loss) określający statystyczny czas do całkowitej utraty danych. O ile macierz RAID 5 skutecznie chroni przed całkowitą awarią pojedynczego dysku, o tyle jej słabym punktem jest proces odbudowy (rebuild). W trakcie resynchronizacji macierzy kontroler musi odczytać każdy sektor ze wszystkich pozostałych dysków, generując gigantyczne obciążenie wejścia-wyjścia.

W tym momencie krytycznym zagrożeniem staje się zjawisko błędu nieodwracalnego odczytu URE (Unrecoverable Read Error). Dla konsumenckich dysków SATA specyfikacja producenta określa prawdopodobieństwo URE na poziomie jednego błędu na 10^14 odczytanych bitów (około 12,5 TB danych). Oznacza to, że przy odbudowie macierzy złożonej z dysków 8 TB lub 16 TB prawdopodobieństwo napotkania błędu URE i katastrofalnej utraty całej macierzy przekracza 50%. Matematyczne modelowanie tego zjawiska pozwala administratorom udowodnić konieczność wdrożenia podwójnej parzystości RAID 6 w nowoczesnych magazynach.

W tym zadaniu napiszesz skrypt analityczny w Pythonie obliczający MTTDL oraz symulujący ryzyko błędu URE metodą Monte Carlo.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/reliability_lab && cd ~/reliability_lab.
2. Utwórz plik skryptu w języku Python: nano raid_reliability.py.
3. Zaimportuj moduły standardowe: math, random, sys.
4. Zaimplementuj funkcję mtbf_to_afr(mtbf_hours): afr = (8760 / mtbf_hours) * 100; return afr.
5. Zaimplementuj wzór na MTTDL dla RAID 0: MTTDL_0 = MTBF / N.
6. Zaimplementuj wzór na MTTDL dla RAID 1 (2 dyski): MTTDL_1 = (MTBF^2) / (2 * N * MTTR).
7. Zaimplementuj wzór na MTTDL dla RAID 5: MTTDL_5 = (MTBF^2) / (N * (N - 1) * MTTR).
8. Zaimplementuj wzór na MTTDL dla RAID 6: MTTDL_6 = (MTBF^3) / (N * (N - 1) * (N - 2) * MTTR^2).
9. Zaimplementuj funkcję prob_ure(num_disks, capacity_tb, ure_rate=1e-14): bits_read = (num_disks - 1) * capacity_tb * 8 * 10^12; return 1.0 - math.exp(-bits_read * ure_rate).
10. Oblicz ryzyko błędu URE dla macierzy 5 dysków SATA (10^-14) o pojemnościach: 2 TB, 4 TB, 8 TB, 12 TB, 16 TB.
11. Zanotuj drastyczny wzrost prawdopodobieństwa awarii: dla 8 TB ryzyko URE wynosi ponad 35%, dla 16 TB przekracza 60%.
12. Oblicz analogiczne prawdopodobieństwa dla dysków SAS Enterprise (ure_rate = 1e-15) i porównaj wyniki.
13. Napisz symulator Monte Carlo (10 000 prób) losujący momenty uszkodzeń sektorów i potwierdzający zgodność z modelem analitycznym.
14. Sformatuj wyniki do estetycznej tabeli konsolowej: Poziom RAID, Pojemnosc dysku, MTBF, MTTDL (lata), Ryzyko URE (%).
15. Wykaż, że dla dysków 16 TB wskaźnik MTTDL macierzy RAID 5 jest w praktyce zdominowany przez zjawisko URE, a nie drugą awarię fizyczną.
16. Wykonaj zrzuty ekranu kodu skryptu, tabeli wyników oraz analizy porównawczej.
17. Sformułuj oficjalną rekomendację architektoniczną dla dyrektora IT dotyczącą zakazu stosowania RAID 5 dla dysków o pojemności >4 TB.

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 matematycznych zależności pomiędzy wskaźnikami niezawodności MTBF, AFR oraz MTTDL.
• Świadomość zjawiska błędu nieodwracalnego odczytu URE jako głównego czynnika ryzyka w macierzach parzystościowych.
• Praktyczna umiejętność modelowania probabilistycznego awarii podsystemów dyskowych w języku Python.
• Krytyczna ocena przydatności RAID 5 i dowód konieczności wdrożenia RAID 6 w nowoczesnych środowiskach dyskowych.

Cel

Celem ćwiczenia jest programowa implementacja trybu szyfrowania dyskowego AES-XTS w języku Python oraz zbadanie jego właściwości kryptograficznych. Student implementuje wyprowadzanie wektora modyfikującego tweak dla kolejnych sektorów z mnożeniem wielomianowym przez alfa w ciele GF(2^128), szyfruje przykładowy 512-bajtowy sektor dyskowy, a następnie przeprowadza demonstrację ataku modyfikacji bitów w szyfrogramie (bit-flipping), dowodząc braku ochrony integralności w standardzie XTS.

Scenariusz – opis

Szyfrowanie pamięci masowych na poziomie sektorów blokowych narzuca specyficzne rygory niespotykane w szyfrowaniu transmisji sieciowej. Podstawowym ograniczeniem jest wymóg braku ekspansji danych: zaszyfrowany sektor 512-bajtowy lub 4096-bajtowy musi mieć dokładnie taki sam rozmiar fizyczny na dysku. Wyklucza to stosowanie tradycyjnych trybów uwierzytelnionych, takich jak AES-GCM, które dodają 16-bajtowy tag uwierzytelniający MAC do każdego bloku.

W odpowiedzi na te wyzwania instytut IEEE opracował standard IEEE 1619 definiujący tryb XTS-AES jako oficjalny standard szyfrowania dysków. Tryb XTS wykorzystuje dwa niezależne klucze AES-256 (łączny klucz 512-bitowy): klucz K1 do szyfrowania danych oraz klucz K2 do szyfrowania numeru sektora (tweak). Wewnątrz sektora wartość wektora tweak jest mnożona przez kolejne potęgi elementu pierwotnego alfa w ciele skończonym GF(2^128).

Mnożenie przez alfa w ciele GF(2^128) zdefiniowane jest operacją przesunięcia bitowego w lewo i warunkowej redukcji z wielomianem 0x87 (reprezentującym x^128 + x^7 + x^2 + x + 1). Taka konstrukcja zapobiega kopiowaniu bloków pomiędzy różnymi sektorami dysku oraz wewnątrz tego samego sektora. Jednak brak tagu integralności MAC oznacza, że tryb XTS jest podatny na manipulacje bitowe (malleability) - modyfikacja szyfrogramu niszczy jeden blok 16-bajtowy, ale nie unieważnia całego sektora.

W tym zadaniu zaimplementujesz procedurę XTS w Pythonie, zaszyfrujesz sektor dyskowy i zademonstrujesz podatność bit-flipping na strukturach systemu plików.

Co ma wykonać student / grupa

Przykładowe kroki do wykonania jako sugestia

1. W terminalu utwórz katalog roboczy: mkdir -p ~/xts_lab && cd ~/xts_lab.
2. Utwórz plik skryptu w języku Python: nano xts_engine.py.
3. Zaimportuj moduły: os, struct z cryptography.hazmat.primitives.ciphers (AES, ECB).
4. Zdefiniuj klucz 512-bitowy (64 bajty): key_512 = os.urandom(64); K1 = key_512[:32]; K2 = key_512[32:].
5. Zaimplementuj operację mnożenia przez alfa w ciele GF(2^128): gf128_mul_alpha( tweak).
6. W funkcji mnożenia zaimplementuj przesunięcie w lewo o 1 bit z uwzględnieniem bitu przeniesienia (carry) i redukcji xor z 0x87 na najmłodszym bajcie.
7. Zaimplementuj szyfrowanie sektora: xts_encrypt_sector(sector_data, sector_num, K1, K2).
8. Wylicz początkowy tweak T_0: zaszyfruj 16-bajtową reprezentację sector_num kluczem K2 w trybie ECB.
9. W pętli po 32 blokach (po 16 bajtów) oblicz: PP = XOR(P_i, T_i); CC = AES_Encrypt(K1, PP); C_i = XOR(CC, T_i); T_{i+1} = gf128_mul_alpha(T_i).
10. Zaimplementuj procedurę symetryczną deszyfrowania: xts_decrypt_sector( ciphertext, sector_num, K1, K2).
11. Przygotuj 512-bajtowy sektor testowy: pierwsze 16 bajtów to flaga 'STATUS=ADMIN_NO;', kolejne 496 bajtów to dane neutralne.
12. Zaszyfruj sektor numer 100 i upewnij się, że szyfrogram ma dokładnie 512 bajtów (brak narzutu).
13. Odszyfruj sektor i potwierdź poprawność odzyskania tekstu jawnego.
14. Zasymuluj atak manipulacji bitowej: zmień 2 bity w szyfrogramie bloku 0 (bajt 5 i bajt 6).
15. Odszyfruj zmodyfikowany szyfrogram: zaobserwuj, że blok 0 uległ zniszczeniu, lecz bloki 1-31 pozostały idealnie czytelne i nieuszkodzone.
16. Wyjaśnij zjawisko lokalności uszkodzenia w trybie XTS i brak mechanizmu odmowy autoryzacji.
17. Wykonaj zrzuty ekranu kodu algorytmu XTS, procedury mnożenia w GF(2^128) oraz demonstracji ataku bit-flipping.
18. Sformułuj wnioski oceniające kompromis pomiędzy brakiem narzutu przestrzennego a brakiem integralności w standardzie IEEE 1619.

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 założeń projektowych standardu IEEE 1619 dla szyfrowania pamięci masowych bez ekspansji danych.
• Praktyczna znajomość dwukluczowej architektury XTS-AES oraz roli wektora tweak w ciele GF(2^128).
• Umiejętność implementacji niskopoziomowego mnożenia wielomianowego przez alfa z redukcją modulo 0x87.
• Świadomość braku ochrony integralności (plastyczności) w trybie XTS i podatności na ukierunkowane ataki bit-flipping.