Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Wypróbuj każde narzędzie z lekcji na maleńkim pliku tekstowym za pomocą polecenia `openssl`: policz jego skrót, zaszyfruj go hasłem, podpisz parą kluczy i zamień klucz w certyfikat. Potem odczytaj prawdziwy łańcuch certyfikatów `example.com`, tak jak robi to Twoja przeglądarka.
## Cele
- Obliczyć skrót SHA-256 i zobaczyć, że zmiana jednego znaku zmienia go całkowicie.
- Zaszyfrować i odszyfrować plik hasłem oraz zobaczyć, co się dzieje przy złym haśle i przy zmanipulowanym pliku.
- Utworzyć parę kluczy, podpisać plik, zweryfikować podpis i zobaczyć, że weryfikacja zawodzi po zmianie.
- Utworzyć certyfikat samopodpisany i odczytać jego pola.
- Wskazać podmiot (subject), wystawcę (issuer), daty ważności i SAN w prawdziwym łańcuchu certyfikatów.
## Wymagania wstępne
- OpenSSL 3.0 lub nowszy. Sprawdź go poleceniem `openssl version`. Musi pokazać `OpenSSL 3.x`, a nie `LibreSSL` ani `1.1.1`.
- Terminal. W Windows użyj WSL2.
- Dostęp do Internetu tylko w kroku 7.
- [Lekcja Podstawy kryptografii](lesson.pl.md) z tego modułu.
> [!WARNING]
> Wszystko w krokach od 1 do 6 dzieje się na Twoim własnym komputerze, na plikach tworzonych przez Ciebie. Krok 7 tylko **łączy się z portem 443 serwera `example.com` i odczytuje certyfikat, który on przedstawia**, dokładnie tak jak przeglądarka. Nie kieruj `openssl s_client` na systemy, które do Ciebie nie należą albo których nie wolno Ci testować, i nie wysyłaj do nich niczego więcej.
> [!NOTE]
> Klucze i hasła w tym laboratorium służą wyłącznie do ćwiczeń. Nigdy nie używaj klucza z laboratorium do niczego prawdziwego i nigdy nie wpisuj prawdziwego hasła w wierszu poleceń: jest widoczne na liście procesów i zapisywane w historii powłoki.
## Architektura
<figure class="diagram" style="--dg-w: 1020px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1020 330" width="1020" height="330" role="img" aria-labelledby="crypto-lab-architecture-pl-title crypto-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="crypto-lab-architecture-pl-title">Scenariusz laboratorium: pięć ćwiczeń z openssl w ~/crypto-lab</title>
<desc id="crypto-lab-architecture-pl-desc">Po lewej strefa Twojego komputera, folder ~/crypto-lab, z czterema kartami. Krok 2, skrót: message.txt, z sha256sum i openssl dgst. Kroki 3 i 4, szyfrowanie: message.enc, z openssl enc i AES-256-CBC. Krok 5, podpis: private.pem, public.pem i message.sig z Ed25519. Krok 6, certyfikat: server.crt i server.key, z openssl req i openssl x509. Po prawej strefa tylko do odczytu dla Internetu z krokiem 7, prawdziwym łańcuchem certyfikatów example.com na porcie 443, odczytanym tak, jak zrobiłaby to przeglądarka, za pomocą openssl s_client.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1019" height="329" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="640" height="290" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój komputer: ~/crypto-lab</text></g>
<rect class="dg-card" x="40" y="62" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(56 78) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><line x1="4" x2="20" y1="9" y2="9"/><line x1="4" x2="20" y1="15" y2="15"/><line x1="10" x2="8" y1="3" y2="21"/><line x1="16" x2="14" y1="3" y2="21"/></g></g>
<g class="dg-l2"><text x="98" y="99" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Krok 2: skrót</text></g>
<text x="58" y="130" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.txt</text>
<text x="58" y="150" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sha256sum, openssl dgst</text>
<rect class="dg-card" x="346" y="62" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(362 78) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g></g>
<g class="dg-l2"><text x="404" y="99" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Kroki 3-4: szyfrowanie</text></g>
<text x="364" y="130" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.enc</text>
<text x="364" y="150" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">openssl enc, AES-256-CBC</text>
<rect class="dg-card" x="40" y="182" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(56 198) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20h9"/><path d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"/></g></g>
<g class="dg-l2"><text x="98" y="219" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Krok 5: podpis</text></g>
<text x="58" y="250" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">private.pem public.pem</text>
<text x="58" y="270" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.sig (Ed25519)</text>
<rect class="dg-card" x="346" y="182" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(362 198) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g></g>
<g class="dg-l2"><text x="404" y="219" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Krok 6: certyfikat</text></g>
<text x="364" y="250" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">server.crt server.key</text>
<text x="364" y="270" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">openssl req, openssl x509</text>
<g class="dg-l1"><rect class="dg-tint" x="720" y="20" width="280" height="290" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(736 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="762" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet (tylko odczyt)</text></g>
<rect class="dg-card" x="736" y="100" width="248" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(752 116) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g></g>
<g class="dg-l1"><text x="794" y="137" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Krok 7: prawdziwy łańcuch</text></g>
<text x="754" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">example.com:443</text>
<text x="754" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">tak jak zrobiłaby przeglądarka</text>
<g class="dg-l1"><path class="dg-stroke" d="M662 153H718" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M713 147l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="836" y="232" font-size="12" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">openssl s_client</text>
</svg></figure>
*Rysunek 1. Kroki od 2 do 6 odbywają się na Twoim komputerze; krok 7 tylko odczytuje publiczny certyfikat.*
## Kroki
### Krok 1 — Utwórz folder roboczy i plik (3 min)
Pracujesz w jednym folderze, żeby sprzątanie na końcu było jednym poleceniem. Plik to maleńka „dyspozycja bankowa”, którą będziesz chronić na różne sposoby.
```bash
openssl version
mkdir ~/crypto-lab
cd ~/crypto-lab
printf 'Transfer 100 EUR to account ES00 1234\n' > message.txt
cat message.txt
```
Co robi każdy wiersz: `openssl version` sprawdza narzędzie; `mkdir` i `cd` tworzą folder i do niego wchodzą; `printf` zapisuje jeden wiersz do `message.txt`; `cat` go wyświetla.
Oczekiwany wynik (data kompilacji po wersji na Twoim komputerze będzie inna, byle zaczynał się od `OpenSSL 3`):
```text
OpenSSL 3.5.8 25 Aug 2026 (Library: OpenSSL 3.5.8 25 Aug 2026)
Transfer 100 EUR to account ES00 1234
```
### Krok 2 — Policz skrót pliku i zmień jeden znak (8 min)
Skrót to odcisk palca pliku. Policz go na dwa sposoby: `sha256sum` (Linux i WSL2; w macOS użyj `shasum -a 256`) oraz `openssl dgst`.
```bash
sha256sum message.txt
openssl dgst -sha256 message.txt
```
Oczekiwany wynik:
```text
190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f message.txt
SHA2-256(message.txt)= 190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f
```
Zwróć uwagę: oba narzędzia wypisują **te same 64 znaki szesnastkowe**. Uruchom któreś z poleceń ponownie, a za każdym razem dostaniesz ten sam skrót.
Teraz zrób kopię, w której `100` zmienia się w `900`, i policz jej skrót:
```bash
sed 's/100/900/' message.txt > message2.txt
cat message2.txt
sha256sum message2.txt
```
Oczekiwany wynik:
```text
Transfer 900 EUR to account ES00 1234
10bfa161dcd38705488563c4f86395ad2456430fe5b97d08fbbfc8c8322f96c5 message2.txt
```
Porównaj z pierwszym skrótem. W pliku zmienił się jeden znak, a skrót wygląda na zupełnie niepowiązany: to **efekt lawinowy**. Długość nadal wynosi 64 znaki.
Na koniec użyj skrótu tak, jak przy sprawdzaniu pobranego pliku. Zapisz skrót w pliku, a potem każ `sha256sum` sprawdzić plik względem niego, przed manipulacją i po niej:
```bash
sha256sum message.txt > SHA256SUMS
sha256sum -c SHA256SUMS
cp message.txt original.txt
cp message2.txt message.txt
sha256sum -c SHA256SUMS
cp original.txt message.txt
sha256sum -c SHA256SUMS
```
`-c` oznacza „sprawdź” (ang. check). Dwa polecenia `cp` najpierw zastępują `message.txt` zmienioną wersją (udając, że zrobił to atakujący), a potem ją przywracają.
Oczekiwany wynik (w innych językach systemu słowa są przetłumaczone):
```text
message.txt: OK
message.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
message.txt: OK
```
<details>
<summary>Pytanie: czy zgodny skrót dowodzi, że plik pochodzi od prawdziwego autora?</summary>
Nie. Dowodzi, że plik jest taki sam jak ten, którego skrót policzono. Jeśli atakujący może zmienić plik, może zmienić też `SHA256SUMS`. Aby udowodnić, **kto** stworzył plik, potrzebny jest klucz: to podpis, który utworzysz w kroku 5.
</details>
### Krok 3 — Zaszyfruj i odszyfruj hasłem (8 min)
Teraz poufność. `openssl enc` szyfruje plik algorytmem AES-256 i kluczem utworzonym z hasła. Opcja `-pbkdf2 -iter 600000` każe opensslowi zamienić hasło w klucz za pomocą PBKDF2, powoli, a `-salt` dodaje losową sól (to znowu idea haszowania haseł z lekcji).
```bash
openssl enc -aes-256-cbc -pbkdf2 -iter 600000 -salt -pass pass:correct-horse -in message.txt -out message.enc
wc -c message.enc
xxd message.enc
```
`-pass pass:correct-horse` podaje hasło w wierszu poleceń, co jest dopuszczalne tylko w laboratorium (patrz uwaga wyżej). `wc -c` liczy bajty. `xxd` pokazuje plik szesnastkowo, bo szyfrogram nie jest czytelnym tekstem.
Oczekiwany wynik (wszystko po `Salted__` zmienia się przy każdym uruchomieniu, bo sól jest losowa):
```text
64 message.enc
00000000: 5361 6c74 6564 5f5f 1865 220a 69f3 72b9 Salted__.e".i.r.
00000010: f14c 9111 b8a4 ce73 cd80 41b5 21c6 2ab0 .L.....s..A.!.*.
00000020: b186 557a af33 e545 2692 f807 cd4b 02ef ..Uz.3.E&....K..
00000030: 9582 5a70 821b b6e4 ff27 f526 190c 0762 ..Zp.....'.&...b
```
Zwróć uwagę: plik zaczyna się od słowa `Salted__` i 8 bajtów soli, a reszta wygląda losowo. Oryginalnego tekstu nie widać. Plik ma 64 bajty: 8 na `Salted__`, 8 na sól i 48 na zaszyfrowane dane (38-bajtowa wiadomość jest dopełniona do wielokrotności 16).
Odszyfruj go właściwym hasłem:
```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in message.enc
```
`-d` oznacza odszyfrowanie (ang. decrypt). Trzeba podać **ten sam** szyfr i tę samą wartość `-iter`.
Oczekiwany wynik:
```text
Transfer 100 EUR to account ES00 1234
```
Teraz spróbuj ze złym hasłem. Wyślij wynik do pliku, bo zły klucz daje śmieci:
```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:wrong-guess -in message.enc -out bad.txt
rm bad.txt
```
Oczekiwany wynik (kod szesnastkowy na początku drugiego wiersza się zmienia):
```text
bad decrypt
00332243777F0000:error:1C800064:Provider routines:ossl_cipher_unpadblock:bad decrypt:providers/implementations/ciphers/ciphercommon_block.c:107:
```
Zwróć uwagę: złe hasło niczego nie ujawnia; dostajesz błąd. `rm` usuwa plik ze śmieciami, który został.
> [!NOTE]
> Błąd nie jest gwarantowany. W tym trybie mniej więcej 1 złe hasło na 256 przypadkiem daje poprawne dopełnienie, więc `openssl` nie wypisuje błędu, a wynik to śmieci. Ten tryb nie ma jak powiedzieć „ten klucz jest zły”. Krok 4 pokazuje większą słabość tego samego rodzaju.
### Krok 4 — Dlaczego potrzebne jest szyfrowanie uwierzytelnione (6 min)
Lekcja mówi, że AES-CBC nie daje integralności. Sprawdź to. Poniższe polecenie zmienia **jeden bajt** w środku `message.enc`, tak jak mógłby to zrobić atakujący. `dd` nadpisuje bajt na pozycji 32 zerem.
```bash
cp message.enc tampered.enc
printf '\000' | dd of=tampered.enc bs=1 seek=32 conv=notrunc 2>/dev/null
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in tampered.enc -out tampered.txt
echo "exit code: $?"
xxd tampered.txt
```
Oczekiwany wynik (zniekształcone bajty w drugim wierszu i zmieniony bajt na początku trzeciego wiersza się zmieniają, bo sól jest losowa):
```text
exit code: 0
00000000: 5472 616e 7366 6572 2031 3030 2045 5552 Transfer 100 EUR
00000010: 63a6 2f97 15ae 6556 aa6a 448b 2a17 3791 c./...eV.jD.*.7.
00000020: 9131 3233 340a .1234.
```
Zwróć uwagę na trzy rzeczy. Polecenie kończy się **sukcesem** (kod wyjścia 0). Pierwsze 16 znaków jest w porządku. Następne 16 to śmieci, a spacja na początku ostatniego wiersza (przed `1234`) została zastąpiona innym bajtem. OpenSSL nie wykrył manipulacji: dlatego nowoczesne protokoły używają szyfrowania **uwierzytelnionego** (AEAD), takiego jak AES-GCM, które kończy się błędem, jeśli zmieni się choćby jeden bit.
Poproś `openssl enc` o użycie takiego szyfru:
```bash
openssl enc -aes-256-gcm -pbkdf2 -pass pass:x -in message.txt -out /dev/null
```
Oczekiwany wynik:
```text
enc: AEAD ciphers not supported
enc: Use -help for summary.
```
To uczciwe ograniczenie narzędzia: `openssl enc` nie potrafi AES-GCM. Nadaje się do nauki, nie do ochrony prawdziwych danych. Do prawdziwych plików użyj utrzymywanego narzędzia opartego na szyfrowaniu uwierzytelnionym, takiego jak `age` lub GnuPG, a we własnych programach biblioteki zapewniającej AES-GCM lub ChaCha20-Poly1305.
<details>
<summary>Pytanie: dlaczego odszyfrowanie „się udało” mimo uszkodzonego pliku?</summary>
CBC tylko zamienia bloki bajtów z powrotem w tekst jawny. Nie ma wartości kontrolnej (ani MAC, ani znacznika), więc nie może wiedzieć, że szyfrogram zmieniono. Uszkodzenie widać jako śmieci w bloku po zmienionym bajcie oraz odwrócony bajt w następnym bloku. Tryb AEAD dodaje znacznik uwierzytelniający i odmawia odszyfrowania, jeśli znacznik się nie zgadza.
</details>
### Krok 5 — Podpisz plik i zweryfikuj podpis (8 min)
Teraz autentyczność. Tworzysz **parę kluczy** algorytmem Ed25519, podpisujesz `message.txt` kluczem **prywatnym** i sprawdzasz go kluczem **publicznym**.
```bash
openssl genpkey -algorithm ED25519 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem
cat public.pem
```
`genpkey` generuje klucz prywatny. `pkey -pubout` wyprowadza z niego klucz publiczny. Do udostępniania przeznaczony jest tylko klucz publiczny.
Oczekiwany wynik (tekst Twojego klucza będzie inny):
```text
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAVPF2/34u81ANojBZJ/uT7OQ+7sX3ui2HiaKGVgG8t98=
-----END PUBLIC KEY-----
```
Spójrz na uprawnienia pliku z kluczem prywatnym. W Linuksie OpenSSL tworzy go tak, że może go czytać tylko Ty:
```bash
ls -l private.pem
```
Oczekiwany wynik (właściciel, data i dodatkowe znaki się różnią):
```text
-rw------- 1 user user 119 Nov 7 20:40 private.pem
```
`-rw-------` oznacza, że tylko Ty możesz go czytać i zapisywać. Klucz prywatny zawsze musi tak wyglądać.
Podpisz wiadomość:
```bash
openssl pkeyutl -sign -inkey private.pem -rawin -in message.txt -out message.sig
wc -c message.sig
```
`pkeyutl -sign` podpisuje kluczem prywatnym. `-rawin` każe wziąć jako dane wejściowe cały plik. Ed25519 haszuje plik wewnątrz algorytmu, więc nie liczysz skrótu wcześniej.
Oczekiwany wynik:
```text
64 message.sig
```
Podpis Ed25519 zawsze ma 64 bajty, niezależnie od rozmiaru pliku. Teraz zweryfikuj kluczem **publicznym**:
```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
```
`-pubin` mówi, że podawany klucz jest kluczem publicznym.
Oczekiwany wynik:
```text
Signature Verified Successfully
```
Teraz spróbuj zweryfikować ten sam podpis względem **zmienionego** pliku, `message2.txt` (tego z 900 EUR):
```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message2.txt -sigfile message.sig
```
Oczekiwany wynik (kod na początku pierwszego wiersza się zmienia):
```text
005364386B7F0000:error:030000EA:digital envelope routines:EVP_DigestVerify:provider signature failure:crypto/evp/m_sigver.c:795:ED25519 digest_verify:
Signature Verification Failure
```
Zwróć uwagę: jeden zmieniony znak i podpis już się nie zgadza. Nikt nie naprawi tego bez klucza prywatnego. W przeciwieństwie do skrótu z kroku 2 atakujący nie może podmienić podpisu tak, by pasował do zmanipulowanego pliku.
<details>
<summary>Pytanie: kto potrzebuje klucza prywatnego, a kto publicznego?</summary>
**Podpisujący** potrzebuje klucza prywatnego, by tworzyć podpisy. **Każdy, kto chce weryfikować**, potrzebuje klucza publicznego. Dlatego klucz publiczny można swobodnie publikować, a klucz prywatny trzeba chronić. Pozostałe pytanie, „czy to na pewno klucz publiczny autora?”, wyjaśniają certyfikaty, w następnym kroku.
</details>
### Krok 6 — Utwórz certyfikat samopodpisany i go odczytaj (7 min)
Certyfikat wiąże klucz publiczny z nazwą. Jedno polecenie tworzy nową parę kluczy i certyfikat **samopodpisany** (podpisany własnym kluczem, bez CA) dla zmyślonej nazwy w zarezerwowanej domenie `example.org`, ważny 30 dni.
```bash
openssl req -x509 -newkey ed25519 -nodes -keyout server.key -out server.crt -days 30 \
-subj "/CN=lab.example.org/O=CloudAcademia Lab" -addext "subjectAltName=DNS:lab.example.org"
```
Co znaczą opcje: `req -x509` tworzy certyfikat zamiast żądania; `-newkey ed25519` tworzy nowy klucz; `-nodes` zostawia klucz prywatny niezaszyfrowany (tylko laboratorium); `-keyout` i `-out` nazywają pliki; `-days 30` ustawia ważność; `-subj` ustawia pola nazwy; `-addext` dodaje SAN.
Oczekiwany wynik:
```text
-----
```
Odczytaj pola certyfikatu poznane w lekcji:
```bash
openssl x509 -in server.crt -noout -subject -issuer -dates -ext subjectAltName,basicConstraints
```
Oczekiwany wynik (daty dzieli 30 dni, od chwili uruchomienia polecenia):
```text
subject=CN=lab.example.org, O=CloudAcademia Lab
issuer=CN=lab.example.org, O=CloudAcademia Lab
notBefore=Nov 7 19:40:39 2026 GMT
notAfter=Dec 7 19:40:39 2026 GMT
X509v3 Basic Constraints: critical
CA:TRUE
X509v3 Subject Alternative Name:
DNS:lab.example.org
```
Zwróć uwagę: **podmiot i wystawca są identyczne**. To właśnie znaczy „samopodpisany”. Aby zobaczyć wszystko, w tym klucz publiczny i podpis, wypisz pełny tekst:
```bash
openssl x509 -in server.crt -noout -text
```
Oczekiwany wynik (skrócony; numer seryjny, klucz i bajty podpisu się różnią):
```text
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
7f:8f:86:e8:fe:a8:69:a8:09:be:68:86:59:17:31:37:61:10:f1:7d
Signature Algorithm: ED25519
Issuer: CN=lab.example.org, O=CloudAcademia Lab
Validity
Not Before: Nov 7 19:40:39 2026 GMT
Not After : Dec 7 19:40:39 2026 GMT
Subject: CN=lab.example.org, O=CloudAcademia Lab
Subject Public Key Info:
Public Key Algorithm: ED25519
ED25519 Public-Key:
pub:
a7:11:42:5a:60:88:0d:5f:6b:41:97:23:f1:ba:5d:
...
X509v3 extensions:
X509v3 Subject Key Identifier:
84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
X509v3 Authority Key Identifier:
84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
X509v3 Basic Constraints: critical
CA:TRUE
X509v3 Subject Alternative Name:
DNS:lab.example.org
Signature Algorithm: ED25519
Signature Value:
76:9f:98:3e:86:ac:f9:27:2b:f6:78:4d:56:2a:33:94:14:c3:
...
```
Znajdź każde pole: Serial Number, Issuer, Validity, Subject, Subject Public Key Info, rozszerzenia (SAN, Basic Constraints) i podpis wystawcy (Signature).
Teraz zobacz, dlaczego przeglądarki mu nie ufają. Każ OpenSSL zweryfikować go względem listy zaufanych certyfikatów głównych Twojego komputera, a potem względem niego samego:
```bash
openssl verify server.crt
openssl verify -CAfile server.crt server.crt
```
Oczekiwany wynik:
```text
CN=lab.example.org, O=CloudAcademia Lab
error 18 at 0 depth lookup: self-signed certificate
error server.crt: verification failed
server.crt: OK
```
Zwróć uwagę: pierwsze sprawdzenie kończy się niepowodzeniem, bo żadne CA w Twoim **magazynie zaufanych certyfikatów głównych** (root store) nie poręcza za ten certyfikat. Drugie przechodzi tylko dlatego, że OpenSSL dostał polecenie zaufania dokładnie temu certyfikatowi. Zaufanie przeglądarki to ta sama idea, z około stu zainstalowanymi już certyfikatami głównymi.
### Krok 7 — Odczytaj prawdziwy łańcuch certyfikatów example.com (5 min)
Ten krok wymaga Internetu. `openssl s_client` otwiera połączenie TLS jak przeglądarka. `-servername example.com` wysyła nazwę serwera, by wybrał właściwy certyfikat. `</dev/null` od razu kończy sesję, więc nic więcej nie jest wysyłane.
```bash
openssl s_client -connect example.com:443 -servername example.com </dev/null > chain.txt 2>&1
sed -n '/^Certificate chain/,/^---/p' chain.txt
```
Pierwsze polecenie zapisuje cały wynik w `chain.txt`; `sed` wypisuje tylko sekcję z łańcuchem.
> [!NOTE]
> To prawdziwa strona internetowa, więc **Twój wynik będzie się różnił od poniższego**: certyfikat jest odnawiany co kilka tygodni lub miesięcy, a urzędy certyfikacji, długość łańcucha i algorytmy mogą się zmienić. Szukaj tych samych rodzajów informacji, a nie tych samych wartości.
Oczekiwany wynik (skrócony do dwóch pierwszych certyfikatów; Twoja lista może być krótsza lub dłuższa):
```text
Certificate chain
0 s:CN=example.com
i:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA256
v:NotBefore: Sep 26 22:49:11 2026 GMT; NotAfter: Dec 25 22:56:35 2026 GMT
1 s:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
i:C=US, O=SSL Corporation, CN=SSL.com TLS Transit ECC CA R2
a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA384
v:NotBefore: May 29 19:49:45 2025 GMT; NotAfter: May 27 19:49:44 2035 GMT
...
---
```
Czytaj to tak: `s:` to **podmiot** (subject), a `i:` to **wystawca** (issuer). Certyfikat 0 to **certyfikat końcowy** (leaf) dla `example.com`, wystawiony przez pośrednie CA, którym jest certyfikat 1. Wystawca każdego certyfikatu jest podmiotem następnego: to jest łańcuch. `v:` podaje daty ważności. Ostatnie certyfikaty na liście to CA ponad pośrednim.
Teraz zobacz, czego użyło połączenie i czy Twój komputer mu zaufał:
```bash
grep -E "Protocol|Cipher is|Verification:" chain.txt
```
Oczekiwany wynik:
```text
Verification: OK
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
```
Zwróć uwagę: **TLS 1.3** z szyfrem **AES-GCM**, czyli hybryda z lekcji. `Verification: OK` oznacza, że łańcuch kończy się certyfikatem głównym, który jest w Twoim magazynie zaufanych certyfikatów. Twoje wartości mogą się różnić (na przykład `TLS_AES_128_GCM_SHA256`).
Na koniec odczytaj szczegóły certyfikatu końcowego poleceniem `x509`, którego użyto w kroku 6. `openssl x509` czyta pierwszy certyfikat w pliku, czyli końcowy:
```bash
openssl x509 -in chain.txt -noout -subject -issuer -dates -ext subjectAltName
```
Oczekiwany wynik:
```text
subject=CN=example.com
issuer=C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
notBefore=Sep 26 22:49:11 2026 GMT
notAfter=Dec 25 22:56:35 2026 GMT
X509v3 Subject Alternative Name:
DNS:example.com, DNS:*.example.com
```
Odpowiedz na te pytania, korzystając z **własnego** wyniku:
1. Kto jest podmiotem, a kto wystawcą certyfikatu końcowego?
2. Przez ile dni certyfikat jest ważny?
3. Jakie nazwy wymienia SAN? Czy certyfikat byłby ważny dla `www.example.com`? A dla `a.b.example.com`?
<details>
<summary>Pokaż odpowiedzi (dla powyższego wyniku)</summary>
1. Podmiotem jest `CN=example.com`; wystawcą jest pośrednie CA `Cloudflare TLS Issuing ECC CA 3`.
2. Od 26 września do 25 grudnia 2026: około 90 dni. Publiczne certyfikaty mają krótką żywotność, jak wyjaśnia lekcja.
3. `example.com` i `*.example.com`. `www.example.com` pasuje do wildcardu. `a.b.example.com` nie pasuje: wildcard obejmuje tylko jedną etykietę.
Twoje odpowiedzi będą inne, ale metoda jest ta sama: odczytaj podmiot, wystawcę, `NotBefore` i `NotAfter` oraz SAN.
</details>
## Weryfikacja
Sprawdź, czy masz kluczowe wyniki. Wszystkie poniższe muszą być prawdziwe:
```bash
sha256sum -c SHA256SUMS
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
openssl verify -CAfile server.crt server.crt
```
Oczekiwany wynik:
```text
message.txt: OK
Signature Verified Successfully
server.crt: OK
```
Zadanie jest zaliczone, jeśli:
- skrót oryginalnego pliku się zgadza (`OK`), a zmieniony plik dał w kroku 2 inny skrót;
- właściwe hasło odszyfrowało plik, a złe dało `bad decrypt`;
- podpis zweryfikował się dla `message.txt` i zawiódł dla `message2.txt`;
- w kroku 7 potrafisz wskazać podmiot, wystawcę, daty ważności i SAN certyfikatu `example.com`.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `openssl version` pokazuje `LibreSSL` albo `OpenSSL 1.1.1`, lub `pkeyutl` nie zna `-rawin` | Starszy lub inny OpenSSL (domyślny w macOS to LibreSSL) | Użyj OpenSSL 3.0 lub nowszego: zainstaluj go (na przykład przez Homebrew w macOS) albo użyj WSL2 w Windows |
| `Signature Verification Failure` w kroku 5 dla `message.txt` | `message.txt` edytowano po podpisaniu albo podpisano inny plik | Wykonaj ponownie `openssl pkeyutl -sign` na bieżącym `message.txt`. Niepowodzenie dla `message2.txt` jest oczekiwane |
| `bad decrypt` przy odszyfrowywaniu właściwym hasłem | Inny `-iter` lub szyfr niż przy szyfrowaniu albo literówka w haśle | Użyj dokładnie tych samych opcji i hasła co w poleceniu szyfrowania |
| `error 18 ... self-signed certificate` z `openssl verify server.crt` | Oczekiwane: żadne zaufane CA go nie podpisało | Użyj `-CAfile server.crt`, jak w kroku 6, aby zaufać mu jawnie |
| `connect: Connection refused`, `Connection timed out` lub błędy `getaddrinfo` w kroku 7 | Brak dostępu do Internetu albo zapora lub proxy blokuje port 443 | Sprawdź połączenie i spróbuj ponownie; proxy może zmienić widziany łańcuch. Pomiń krok 7, jeśli sieć jest ograniczona |
| `sha256sum: command not found` w macOS | macOS ma zamiast niego `shasum` | Użyj `shasum -a 256 message.txt` |
| Brakuje wiersza `Verification:` albo pokazuje błąd | Komputer nie ma pakietu certyfikatów CA albo ma złą datę | Sprawdź datę systemową i zainstaluj pakiet certyfikatów CA swojego systemu |
## Wyzwanie (opcjonalne)
1. Powtórz krok 3 **bez** opcji `-iter` oraz z `-iter 1000`. Odszyfruj każdy plik. Dlaczego liczba iteracji ma znaczenie dla hasła i o czym trzeba pamiętać przy odszyfrowywaniu?
2. Wygeneruj parę kluczy RSA poleceniem `openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out rsa-key.pem`, wyprowadź klucz publiczny jak w kroku 5 (nazwij go `rsa.pub`) i podpisz `message.txt` poleceniem `openssl pkeyutl -sign -inkey rsa-key.pem -rawin -digest sha256 -in message.txt -out rsa.sig`. Zweryfikuj go w ten sam sposób (dodaj `-digest sha256` także do polecenia weryfikacji). Porównaj rozmiar podpisu i rozmiar pliku klucza publicznego z wartościami dla Ed25519 (wskazówka: 384 bajty wobec 64).
3. W kroku 7 połącz się zamiast tego z `example.org` i porównaj łańcuch, wystawcę i SAN z `example.com`.
## Sprzątanie
Laboratorium utworzyło jeden folder w Twoim katalogu domowym i nic więcej. Usuń go razem z kluczami w środku:
```bash
cd ~
rm -r ~/crypto-lab
```
Sprawdź, że zniknął:
```bash
ls ~/crypto-lab
```
Oczekiwany wynik:
```text
ls: cannot access '/home/<you>/crypto-lab': No such file or directory
```
Nic nie zostało zainstalowane i żaden systemowy magazyn zaufania nie został zmieniony.
## Co już umiesz
- Skrót to powtarzalny odcisk o stałym rozmiarze: jeden zmieniony znak daje zupełnie inny skrót. Pokazuje integralność, ale każdy może go przeliczyć ponownie, więc nie dowodzi, kto napisał plik.
- Szyfrowanie hasłem za pomocą `openssl enc` ukrywa treść, ale tryb CBC nie wykrywa manipulacji. Preferuj szyfrowanie uwierzytelnione (AES-GCM, ChaCha20-Poly1305) przez właściwą bibliotekę lub narzędzie.
- Podpis wykonany kluczem prywatnym jest weryfikowany kluczem publicznym i przestaje być poprawny, gdy plik się zmieni. Klucz prywatny trzeba utrzymywać w tajemnicy (uprawnienia `600`).
- Certyfikat wiąże nazwę (SAN) z kluczem publicznym; samopodpisanemu nikt nie ufa, dopóki mu się na to nie pozwoli, a prawdziwy tworzy łańcuch do certyfikatu głównego w magazynie zaufanych certyfikatów.
- `openssl s_client` pokazuje to, co widzi Twoja przeglądarka: łańcuch, daty ważności, wersję TLS i szyfr.