---
title: "Laboratorium: przechowywanie haseł i budowanie kodów TOTP"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "bezpłatnie"
environment: "własny komputer (Linux, macOS lub Windows z WSL2) z Pythonem 3.9 lub nowszym; aplikacja uwierzytelniająca na telefonie jest opcjonalna"
lang: pl
source_hash: c069a4b1d609
---

# Laboratorium: przechowywanie haseł i budowanie kodów TOTP

## 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
![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ą, do której wpisujesz ręcznie sekret laboratoryjny. Strzałka łączy krok 4 z aplikacją, a Ty porównujesz, czy obie pokazują te same sześć cyfr. Notatka informuje, że sekret trzeba usunąć z telefonu przy sprzątaniu.](../../../assets/diagrams/auth-lab-architecture.pl.svg)

*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ć.
