Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Zobaczysz na własne oczy, dlaczego zwykły skrót to zły sposób przechowywania haseł, zapiszesz hasła w bezpieczny sposób, z solą i wolną funkcją skrótu, a potem samodzielnie zbudujesz sześciocyfrowy kod aplikacji uwierzytelniającej w około 20 liniach Pythona. Następnie sprawdzisz swój kod według oficjalnych wartości testowych z RFC 6238.
## Cele
- Pokazać, że zwykły skrót SHA-256 daje tę samą wartość dla tego samego hasła i że popularne hasło można wyszukać.
- Zapisać hasła z losową solą i `hashlib.scrypt` oraz zweryfikować je porównaniem w stałym czasie.
- Wygenerować kody TOTP i sprawdzić je według wektorów testowych z RFC 6238, dodatek B.
- Wskazać, który drugi składnik powstrzymałby stronę phishingową przekazującą kody w czasie rzeczywistym.
## Wymagania wstępne
- Python 3.9 lub nowszy (`python3 --version`). Wklejasz krótkie skrypty i je uruchamiasz; nie musisz być programistą.
- Terminal i miejsce do wklejania tekstu (poniższe polecenia same tworzą pliki).
- Opcjonalnie (krok 4): aplikacja uwierzytelniająca na telefonie, która potrafi dodać konto przez wpisanie klucza (większość to potrafi).
- [Lekcja o uwierzytelnianiu i MFA](lesson.pl.md) z tego modułu.
- Bez kont, bez sieci i bez danych płatniczych.
> [!WARNING]
> Wszystko tutaj działa na Twoim własnym komputerze z wymyślonymi użytkownikami i hasłami. Nigdy nie używaj hasła, którego naprawdę używasz, i nigdy nie wklejaj do żadnego skryptu sekretu TOTP prawdziwego konta. Sekret utworzony w kroku 4 jest **tylko do tego laboratorium**: usuń go z aplikacji na telefonie w sekcji Sprzątanie.
## Architektura
<figure class="diagram" style="--dg-w: 1000px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1000 440" width="1000" height="440" role="img" aria-labelledby="auth-lab-architecture-pl-title auth-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="auth-lab-architecture-pl-title">Przegląd labu: cztery skrypty na komputerze i opcjonalna aplikacja na telefonie</title>
<desc id="auth-lab-architecture-pl-desc">Po lewej strefa Twojego komputera, folder ~/auth-lab, z czterema krokami: krok 1 plain_hash.py pokazuje, że to samo hasło daje ten sam SHA-256; krok 2 store.py zapisuje z solą i scrypt, więc wartości się różnią; krok 3 totp.py sprawdza wektory testowe RFC 6238; krok 4 show_code.py wypisuje losowy sekret i kod na żywo. Po prawej opcjonalna strefa telefonu z aplikacją uwierzytelniającą, w której ręcznie wpisujesz sekret z labu. Łącznik z podpisem ten sam sekret, ta sama godzina łączy krok 4 z aplikacją, a Ty porównujesz, czy oba pokazują te same sześć cyfr. Notatka mówi, by przy sprzątaniu usunąć sekret z telefonu.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="999" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="520" height="400" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" 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="#0369a1" font-weight="700">Twój komputer: ~/auth-lab</text></g>
<g class="dg-l2"><rect class="dg-tint" x="640" y="20" width="340" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(656 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="20" x="5" y="2" rx="2"/><path d="M12 18h.01"/></g>
<text x="682" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój telefon (opcjonalnie)</text></g>
<rect class="dg-card" x="40" y="56" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 72) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l1"><text x="98" y="93" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Krok 1: plain_hash.py</text></g>
<text x="58" y="124" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">to samo hasło, ten sam SHA-256</text>
<rect class="dg-card" x="40" y="146" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 162) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M5 22h14"/><path d="M5 2h14"/><path d="M17 22v-4.17a2 2 0 0 0-.59-1.42L12 12l-4.41 4.41A2 2 0 0 0 7 17.83V22"/><path d="M7 2v4.17a2 2 0 0 0 .59 1.42L12 12l4.41-4.41A2 2 0 0 0 17 6.17V2"/></g></g>
<g class="dg-l1"><text x="98" y="183" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Krok 2: store.py</text></g>
<text x="58" y="214" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sól + scrypt, różne wartości</text>
<rect class="dg-card" x="40" y="236" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 252) 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 6v6l4 2"/></g></g>
<g class="dg-l1"><text x="98" y="273" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Krok 3: totp.py</text></g>
<text x="58" y="304" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">wektory testowe RFC 6238</text>
<rect class="dg-card" x="40" y="326" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 342) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="7.5" cy="15.5" r="5.5"/><path d="m21 2-9.6 9.6"/><path d="m15.5 7.5 3 3L22 7l-3-3"/></g></g>
<g class="dg-l1"><text x="98" y="363" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Krok 4: show_code.py</text></g>
<text x="58" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sekret i kod na żywo</text>
<rect class="dg-card" x="660" y="326" width="300" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(676 342) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="20" x="5" y="2" rx="2"/><path d="M12 18h.01"/></g></g>
<g class="dg-l2"><text x="718" y="363" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Aplikacja uwierzytelniająca</text></g>
<text x="678" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">ręczne wpisanie sekretu z labu</text>
<g class="dg-l3"><path class="dg-stroke" d="M522 367H636" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M631 361l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="810" y="80" font-size="13" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Ten sam sekret, ta sama godzina</text>
<text x="810" y="102" font-size="13" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Czy oba pokazują te same 6 cyfr?</text>
<text x="810" y="134" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="500" text-anchor="middle">Wpisz sekret ręcznie; usuń go przy sprzątaniu.</text>
</svg></figure>
*Rysunek 1. Cztery małe skrypty w jednym folderze. Tylko krok 4 dotyka Twojego telefonu, i tylko jeśli tego chcesz.*
## Kroki
### Krok 1 — Zobacz, dlaczego zwykłe skróty są złe (8 min)
Skrót zamienia hasło w odcisk o stałej długości, którego nie da się odwrócić. Przechowywanie `SHA-256(hasło)` brzmi bezpiecznie. Zobaczmy, co może zrobić atakujący, który wykradnie taką tabelę. Utwórz folder i skrypt:
```bash
mkdir ~/auth-lab
cd ~/auth-lab
cat > plain_hash.py <<'EOF2'
import hashlib
def sha256(text):
return hashlib.sha256(text.encode()).hexdigest()
# A pretend user table where passwords are stored as a plain SHA-256 hash.
users = {"alice": sha256("sunshine1"), "bob": sha256("sunshine1"), "carol": sha256("c0rrect horse battery")}
for name, stored in users.items():
print(name, stored)
# An attacker who stole the table tries a short list of common passwords.
common = ["123456", "password", "qwerty", "letmein", "sunshine1"]
lookup = {sha256(word): word for word in common}
print()
for name, stored in users.items():
print(name, "->", lookup.get(stored, "not in my list"))
EOF2
python3 plain_hash.py
```
Oczekiwany wynik:
```text
alice 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
bob 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
carol af2de743ce77cb99a82cda058f8a04c158bf7f8109e06f302539ba2107320f8d
alice -> sunshine1
bob -> sunshine1
carol -> not in my list
```
Prostymi słowami:
- **alice i bob mają tę samą zapisaną wartość.** To samo hasło daje ten sam skrót. Każdy, kto czyta tabelę, widzi, że dwie osoby mają wspólne hasło, a złamanie jednego łamie oba.
- **Druga połowa to atakujący.** Raz oblicza skrót każdego popularnego hasła, buduje tabelę wyszukiwania i porównuje ją z wykradzioną tabelą. Alice i bob wpadają w jednym wyszukaniu. Prawdziwe listy mają miliardy wpisów, a szybkie skróty, takie jak SHA-256, pozwalają karcie graficznej sprawdzać miliardy na sekundę.
- **carol jest bezpieczna tylko dlatego, że jej fraza hasłowa nie jest na liście.** To szczęście, a nie projekt.
<details>
<summary>Dlaczego po prostu nie zastosować skrótu dwa razy?</summary>
Dwukrotne zastosowanie tej samej szybkiej funkcji nadal jest szybkie i nadal daje tę samą wartość dla tego samego hasła. Dwie naprawy to **sól** (inna wartość dla każdego użytkownika) i **wolna** funkcja skrótu (kosztowna przy każdej próbie). Krok 2 używa obu.
</details>
### Krok 2 — Zapisz hasła z solą i scrypt (10 min)
Teraz właściwy sposób. Dla każdego użytkownika utwórz losową **sól**, a potem zastosuj funkcję skrótu **scrypt** do hasła i soli razem; to celowo wolna funkcja, wymagająca dużo pamięci. Zapisz sól obok wyniku. Aby się zalogować, powtórz obliczenie z zapisaną solą i porównaj.
```bash
cat > store.py <<'EOF2'
import hashlib, hmac, os
def make_record(password):
salt = os.urandom(16) # random, different for every user
digest = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
return salt, digest
def check(password, salt, digest):
attempt = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
return hmac.compare_digest(attempt, digest)
alice = make_record("sunshine1")
bob = make_record("sunshine1")
print("alice salt: ", alice[0].hex())
print("alice stored:", alice[1].hex())
print("bob salt: ", bob[0].hex())
print("bob stored: ", bob[1].hex())
print("same stored value?", alice[1] == bob[1])
print("alice, right password:", check("sunshine1", *alice))
print("alice, wrong password:", check("sunshine2", *alice))
EOF2
python3 store.py
```
Oczekiwany wynik (wartości szesnastkowe są losowe i **zmieniają się przy każdym uruchomieniu**; ostatnie trzy linie nigdy się nie zmieniają):
```text
alice salt: 193e9e110d6fa0c36ea40a17ebd745be
alice stored: a58c567800dd4b22ff91e798bf0d25af061a5bbb06988decd854e812ea7d7729
bob salt: ecca3df25d21df01104b2ad8b5795727
bob stored: a7e5da3f8effd62fda91f6dabfeadafe9511c49457f9a28ef35761d10a5b750c
same stored value? False
alice, right password: True
alice, wrong password: False
```
Prostymi słowami:
- **alice i bob używają tego samego hasła, ale zapisane wartości się różnią.** Ich sole są różne, więc skróty są różne. Tabela wyszukiwania przygotowana wcześniej jest bezużyteczna, a atakujący musi atakować każde konto osobno.
- **Sól jest zapisana jawnie.** To w porządku: jej zadaniem jest być unikalną, a nie tajną.
- **Sprawdzanie** powtarza scrypt z zapisaną solą. `True` dla właściwego hasła, `False` dla błędnego.
- **`hmac.compare_digest`** porównuje dwie wartości w stałym czasie. Zwykłe `==` może zatrzymać się na pierwszym różnym bajcie, a ta drobna różnica czasu może ujawniać informacje.
- **Wolne celowo.** Jedno wywołanie scrypt trwa tu kilka setnych sekundy. Nikt tego nie zauważa przy logowaniu, ale dla atakującego mnoży koszt każdej pojedynczej próby.
> [!NOTE]
> `n=2**14` dobrano tak, aby laboratorium działało szybko na każdym komputerze. Prawdziwe systemy używają mocniejszych ustawień albo Argon2id. Aktualne zalecenia znajdziesz w OWASP Password Storage Cheat Sheet, zamiast kopiować liczby z laboratorium.
Uruchom skrypt drugi raz i spójrz na sole:
```bash
python3 store.py | head -2
```
Sól i zapisana wartość znów są inne, choć hasło się nie zmieniło.
### Krok 3 — Zbuduj TOTP i sprawdź go według RFC (12 min)
Kod TOTP to obliczenie na wspólnym sekrecie i czasie. Napiszesz je jako mały moduł, który wykorzystają kolejne kroki. Czytaj komentarze: każda linia odpowiada jednemu polu na rysunku z lekcji.
```bash
cat > totp.py <<'EOF2'
import hashlib, hmac, struct, time
def totp(secret_bytes, t=None, digits=6, step=30):
counter = int((time.time() if t is None else t) // step) # the time step T
mac = hmac.new(secret_bytes, struct.pack(">Q", counter), hashlib.sha1).digest()
offset = mac[-1] & 0x0F # dynamic truncation
number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
return str(number % 10**digits).zfill(digits)
if __name__ == "__main__":
secret = b"12345678901234567890" # RFC 6238 test secret
for t, expected in [(59, "94287082"), (1111111109, "07081804"), (1111111111, "14050471"),
(1234567890, "89005924"), (2000000000, "69279037")]:
code = totp(secret, t, digits=8)
print(t, code, expected, "OK" if code == expected else "WRONG")
EOF2
python3 totp.py
```
Oczekiwany wynik:
```text
59 94287082 94287082 OK
1111111109 07081804 07081804 OK
1111111111 14050471 14050471 OK
1234567890 89005924 89005924 OK
2000000000 69279037 69279037 OK
```
Prostymi słowami:
- **Każda linia** podaje czas Unix w sekundach, kod obliczony przez Twoją funkcję, kod, który według RFC jest poprawny, oraz OK lub WRONG.
- Pięć czasów testowych i oczekiwane 8-cyfrowe kody pochodzą z **RFC 6238, dodatek B** (kolumna SHA-1). Pięć linii OK oznacza, że Twój kod robi dokładnie to, co aplikacje uwierzytelniające.
- Linie funkcji odpowiadają lekcji: `// step` to krok czasu, `hmac.new(...)` to HMAC-SHA1, `& 0x0F` i wycinek to dynamiczne obcięcie, `% 10**digits` daje cyfry.
- Prawdziwe aplikacje używają 6 cyfr, czyli wartości domyślnej (`digits=6`); wektory z RFC używają 8.
Szybkie sprawdzenie: pierwsza linia to czas 59, czyli 59 sekund po 1 stycznia 1970. Krok czasu `59 // 30` to 1. Jaki 6-cyfrowy kod pokazałaby wtedy aplikacja?
<details>
<summary>Pokaż odpowiedź</summary>
Ostatnie sześć cyfr wartości 8-cyfrowej: `287082`. Możesz to sprawdzić:
```bash
python3 -c "from totp import totp; print(totp(b'12345678901234567890', 59))"
```
Wynik: `287082`. (Kod 6-cyfrowy to ta sama liczba modulo milion, więc to ostatnie sześć cyfr z `94287082`.)
</details>
### Krok 4 — Prawdziwy sekret i kod na żywo (10 min)
Aplikacje uwierzytelniające przechowują sekret jako tekst w **base32** (litery A-Z i cyfry 2-7). Utwórzmy losowy sekret i wypisujmy bieżący kod co pięć sekund.
```bash
cat > show_code.py <<'EOF2'
import base64, secrets, time
from totp import totp
secret_b32 = base64.b32encode(secrets.token_bytes(10)).decode() # 80 random bits -> 16 letters
print("Secret (lab only):", secret_b32)
key = base64.b32decode(secret_b32)
for _ in range(6):
left = 30 - int(time.time()) % 30
print(time.strftime("%H:%M:%S"), totp(key), f"(changes in {left}s)")
time.sleep(5)
EOF2
python3 show_code.py
```
Oczekiwany wynik (sekret, godziny i kody **będą u Ciebie inne**; kształt jest ten sam):
```text
Secret (lab only): EM35V2C6LLWLHA47
20:35:52 297598 (changes in 8s)
20:35:57 297598 (changes in 3s)
20:36:02 434430 (changes in 28s)
20:36:07 434430 (changes in 23s)
20:36:12 434430 (changes in 18s)
20:36:17 434430 (changes in 13s)
```
Prostymi słowami: kod pozostaje taki sam przez 30 sekund (ten sam krok czasu), a potem się zmienia. Licznik „changes in” dochodzi do zera, gdy zaczyna się następny krok. Serwer i telefon śledzą ten sam zegar, więc zgadzają się bez komunikowania się ze sobą.
**Opcjonalnie: porównaj z telefonem.** Uruchom skrypt ponownie, aby sekret został na ekranie, a w aplikacji uwierzytelniającej wybierz „dodaj konto”, a następnie „wpisz klucz konfiguracji” (nazwy różnią się zależnie od aplikacji):
1. Nazwa konta: `auth-lab`.
2. Klucz: 16 liter wypisanych po `Secret (lab only):`.
3. Typ klucza: **czasowy** (time-based). Zostaw wartości domyślne (6 cyfr, 30 sekund, SHA-1).
Porównaj sześć cyfr w aplikacji z tymi w terminalu. Powinny się zgadzać. Jeśli telefon pokazuje kod tuż przed zmianą, a terminal chwilę po niej, poczekaj na następny.
Właśnie zrobiono to, co robi skanowanie kodu QR: kod QR to tylko ten sekret plus nazwa, zapisane jako link `otpauth://` w postaci obrazka.
### Krok 5 — Ćwiczenie myślowe: kto powstrzyma przekazywanie? (5 min)
Strona phishingowa pokazuje kopię strony logowania Twojej firmy. Wpisujesz hasło i sześciocyfrowy kod z aplikacji. W tle strona wysyła oba do prawdziwej strony w ciągu sekund i zostaje zalogowana jako Ty.
Pytanie: czy każda z metod powstrzymałaby ten atak? Odpowiedz tak lub nie i uzasadnij: (a) samo hasło, (b) kod SMS, (c) kod TOTP, który właśnie zbudowano, (d) powiadomienie push z dopasowaniem liczby, (e) klucz bezpieczeństwa FIDO2 lub klucz dostępu.
<details>
<summary>Pokaż odpowiedź</summary>
| Metoda | Powstrzymuje przekazywanie w czasie rzeczywistym? | Dlaczego |
|---|---|---|
| (a) Samo hasło | Nie | Strona phishingowa zbiera je bezpośrednio. |
| (b) Kod SMS | Nie | Kod wpisuje się na fałszywej stronie, która go przekazuje. |
| (c) Kod TOTP | Nie | Kod jest ważny 30 sekund i nie jest związany ze stroną internetową. Dowodzi tego Twój skrypt: funkcja przyjmuje tylko sekret i czas, nigdy adres internetowy. |
| (d) Push z dopasowaniem liczby | Częściowo | Jest trudniej, bo użytkownik musi dopasować liczbę widoczną na prawdziwym logowaniu. Ale przekazywanie nadal może pokazać tę liczbę na fałszywej stronie, więc zmęczony lub spieszący się użytkownik może dać się oszukać. |
| (e) Klucz FIDO2 lub klucz dostępu | **Tak** | Klucz podpisuje wyzwanie razem z adresem internetowym, który widzi przeglądarka. Na fałszywej stronie nie ma pasującego poświadczenia, a podpis dla fałszywego adresu jest bezużyteczny na prawdziwej stronie. |
Dlatego obecne wytyczne preferują metody odporne na phishing dla administratorów i kont o wysokiej wartości.
</details>
## Weryfikacja
Sprawdź w tej kolejności:
```bash
cd ~/auth-lab
python3 totp.py
python3 store.py | tail -3
```
Zaliczasz, jeśli:
- `totp.py` wypisuje pięć linii, które wszystkie kończą się na `OK`.
- `store.py` wypisuje `same stored value? False`, potem `True` dla właściwego hasła i `False` dla błędnego.
- W kroku 1 alice i bob mieli ten sam SHA-256, a wyszukanie odzyskało `sunshine1`.
- (Opcjonalnie) Telefon i `show_code.py` pokazały te same sześć cyfr.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `AttributeError: module 'hashlib' has no attribute 'scrypt'` | Ten Python zbudowano bez obsługi scrypt z OpenSSL | Użyj standardowego Pythona 3.9 lub nowszego z systemu albo z python.org; w minimalnym kontenerze zainstaluj pełny pakiet `python3` |
| `ModuleNotFoundError: No module named 'totp'` | Nie jesteś w `~/auth-lab` albo brakuje `totp.py` lub zmieniono jego nazwę | Uruchom `cd ~/auth-lab`, sprawdź `ls` i uruchom ponownie blok z kroku 3 |
| `SyntaxError` lub `IndentationError` | Wklejanie zgubiło część linii lub spacji | Usuń ten plik i wklej cały blok ponownie, razem z ostatnią linią `EOF2` |
| `totp.py` wypisuje `WRONG` | Literówka w kodzie, w wartości z RFC lub w sekrecie | Porównaj plik z blokiem; sekret musi być dokładnie `12345678901234567890` |
| Telefon pokazuje inny kod | Literówka w sekrecie; aplikacja nie jest ustawiona na czasowy typ; zegar telefonu różni się o więcej niż kilka sekund | Wpisz klucz ponownie, sprawdź, czy typ to czasowy, włącz automatyczną datę i godzinę w telefonie |
| `mkdir: cannot create directory ... File exists` | Krok 1 został już wykonany | W porządku: uruchom `cd ~/auth-lab` i kontynuuj |
## Wyzwanie (opcjonalne)
1. Napisz `verify(secret, code)`, które akceptuje kod dla bieżącego kroku oraz kroków tuż przed i po (okno jednego kroku, jak w prawdziwym serwerze). Przetestuj je, przekazując kod sprzed 30 sekund i kod sprzed 90 sekund.
2. Zmierz czas `make_record` z `n=2**14` i z `n=2**17` (dla większej wartości dodaj `maxmem=2**28` do wywołania `hashlib.scrypt`, bo inaczej Python odmówi użycia tak dużej pamięci). O ile wolniejsze staje się jedno sprawdzenie hasła? Co to oznacza dla atakującego?
3. Przepuść długą frazę hasłową przez `check` z jednym zmienionym znakiem i bez niego. Czy zapisana wartość wygląda podobnie? Dlaczego nie?
## Sprzątanie
Usuń folder oraz sekret laboratoryjny z telefonu:
```bash
cd ~
rm -r ~/auth-lab
```
Na telefonie otwórz aplikację uwierzytelniającą i usuń konto `auth-lab`, jeśli zostało dodane. Nic więcej nie zostało zainstalowane ani zmienione.
## Co już umiesz
- Zwykły skrót daje tę samą wartość dla tego samego hasła i można go wyszukać, więc nie jest bezpiecznym sposobem przechowywania haseł.
- Losowa sól dla każdego użytkownika i wolna funkcja skrótu, taka jak scrypt, sprawiają, że identyczne hasła wyglądają inaczej, a każda próba jest kosztowna. Porównuj w stałym czasie.
- Kod TOTP to po prostu HMAC-SHA1 30-sekundowego kroku czasu ze wspólnym sekretem, obcięty do cyfr. Sprawdzono go według RFC 6238.
- Kod, który się wpisuje, nie jest związany ze stroną internetową, więc strona phishingowa może go przekazać. Klucz FIDO2 lub klucz dostępu podpisuje pochodzenie, więc nie da się go przekazać.