Kurs NestJS · Moduł 4: Uwierzytelnianie
Password Hashing - haszowanie kodów skarbca
W tej lekcji4
Wyobraź sobie, że ktoś wynosi z fortu kopię rejestru legionistów. Jeśli hasła leżą tam zwykłym tekstem, wróg zna je wszystkie od ręki - a ponieważ ludzie używają tych samych haseł w wielu miejscach, otwiera też ich skrzynki i konta w innych serwisach. Architekt Vitruvius ma na to prostą zasadę: skarbiec nie przechowuje kluczy, tylko ich odciski. Tym właśnie jest password hashing.
Czym jest Password Hashing?
Hashowanie przekształca hasło w ciąg znaków (hash) za pomocą funkcji jednokierunkowej. To jak odcisk palca: to samo hasło daje zawsze pasujący odcisk, ale z odcisku nie da się odtworzyć palca. Przy logowaniu nie odzyskujesz więc hasła z bazy, tylko liczysz hash z tego, co wpisał użytkownik, i porównujesz wyniki.
Dlaczego nie zwykłe szyfrowanie?
Szyfrowanie jest odwracalne - kto ma klucz, odczyta wszystko. Porównaj oba podejścia (funkcje encrypt i decrypt są tu umowne, służą tylko do zilustrowania różnicy):
// ZŁE PODEJŚCIE - zwykłe szyfrowanie
const encryptedPassword = encrypt('my-secret-password', 'encryption-key');
// Można odszyfrować: decrypt(encryptedPassword, 'encryption-key')
// DOBRE PODEJŚCIE - hashowanie
const hashedPassword = await bcrypt.hash('my-secret-password', 12);
// Nie można odwrócić procesu!Wyciek klucza szyfrującego oznacza wyciek wszystkich haseł naraz. Hash nie ma klucza, który można ukraść. Dlaczego zatem nie zwykłe SHA-256? Bo jest za szybkie: karta graficzna sprawdza miliardy kandydatów na sekundę. bcrypt jest powolny celowo i dodaje do każdego hasła sól.
Sól i koszt
Sól to losowa wartość generowana osobno dla każdego hasła. Dzięki niej dwóch legionistów z hasłem „Roma123" dostaje zupełnie różne hashe, a gotowe tablice odgadniętych haseł stają się bezużyteczne. Koszt (saltRounds) mówi, ile pracy trzeba wykonać: bcrypt wykonuje 2^koszt iteracji, więc każdy kolejny stopień podwaja czas. Tak wygląda gotowy hash o długości 60 znaków:
$2b$12$FSazelkmW3GJ/HK7ig5K9.1rc20s7WQMF0UJoC58nf5eHWniFUUrmFragment $2b$ to wersja algorytmu, 12 to koszt, następne 22 znaki to sól, a ostatnie 31 to właściwy hash. Sól jest zapisana w samym wyniku, więc nie potrzebujesz na nią osobnej kolumny w bazie.
Implementacja z bcrypt
Instalujesz pakiet bcrypt oraz typy @types/bcrypt i tworzysz serwis, który będzie jedynym miejscem pracy z hasłami:
// npm install bcrypt
// npm install -D @types/bcrypt
import { Injectable } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
@Injectable()
export class PasswordService {
private readonly saltRounds = 12; // Koszt hashowania: 2^12 iteracji
async hashPassword(plainPassword: string): Promise<string> {
console.log('Tworzenie bezpiecznego hasha hasła...');
// bcrypt sam generuje sól i zapisuje ją w wyniku
const hashedPassword = await bcrypt.hash(plainPassword, this.saltRounds);
console.log(`Hasło zahashowane: ${hashedPassword.substring(0, 20)}...`);
return hashedPassword;
}Jedno wywołanie bcrypt.hash() wykonuje cały proces: podajesz koszt, biblioteka generuje losową sól, łączy ją z hasłem i przepuszcza przez 2^12 rund, a Ty zapisujesz w bazie gotowy ciąg. Samo hasło nigdzie nie zostaje. Wersja asynchroniczna liczy w wątkach puli libuv, więc nie blokuje pętli zdarzeń serwera.
Weryfikacja przy logowaniu wygląda tak:
async verifyPassword(
plainPassword: string,
hashedPassword: string
): Promise<boolean> {
console.log('Sprawdzanie hasła...');
const isValid = await bcrypt.compare(plainPassword, hashedPassword);
console.log(`Wynik weryfikacji: ${isValid ? 'hasło poprawne' : 'hasło błędne'}`);
return isValid;
}bcrypt.compare() odczytuje z zapisanego hasha sól i koszt, liczy hash z wpisanego hasła i porównuje oba wyniki. Nic tu nie jest odszyfrowywane - tego nie da się zrobić.
Gdy za kilka lat podniesiesz koszt do 13, stare hashe nadal będą miały 12. Pomaga w tym metoda sprawdzająca:
// Sprawdzenie czy hasło wymaga re-hashowania (zmiana saltRounds)
async needsRehash(hashedPassword: string): Promise<boolean> {
try {
// Koszt (saltRounds) jest zapisany w samym hashu
const currentRounds = this.extractSaltRounds(hashedPassword);
return currentRounds < this.saltRounds;
} catch (error) {
return true; // Jeśli nie można określić, lepiej re-hashować
}
}
private extractSaltRounds(hash: string): number {
// Format bcrypt: $2b$12$...
const parts = hash.split('$');
return parseInt(parts[2], 10);
}
}Ręczne cięcie napisu po znaku $ działa, ale biblioteka ma gotowe bcrypt.getRounds(hash) - i to polecam. Nowy hash wygenerujesz przy najbliższym udanym logowaniu, bo tylko wtedy masz w ręku prawdziwe hasło.
Granice bcrypt
bcrypt czyta tylko pierwsze 72 bajty wejścia - bajty UTF-8, nie znaki - a resztę po cichu pomija. Dla haseł to rzadko problem, ale zapamiętaj ten limit: przy refresh tokenach okaże się kluczowy. Koszt 12 to rozsądny punkt wyjścia; dokumentacja NestJS pokazuje także alternatywę argon2.
W następnej lekcji poznasz tokeny JWT, czyli przepustki, które legionista dostaje po udanym logowaniu.
Pamiętaj: hasła się nie szyfruje, tylko hashuje - skarbiec przechowuje odcisk klucza, nigdy sam klucz.
Kod do tej lekcji: src/auth/password.service.ts
// Password Hashing - Szyfrowanie kodow skarbca
import { Injectable } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
@Injectable()
export class PasswordService {
private readonly saltRounds = 12;
// TODO: Zaimplementuj hashowanie hasla
// Uzyj bcrypt.hash() z this.saltRounds
async hashPassword(plainPassword: string): Promise<string> {
// TODO: Wygeneruj hash hasla
return '';
}
// TODO: Zaimplementuj weryfikacje hasla
// Uzyj bcrypt.compare() do porownania
async verifyPassword(
plainPassword: string,
hashedPassword: string,
): Promise<boolean> {
// TODO: Porownaj haslo z hashem
return false;
}
// Sprawdz czy haslo wymaga re-hashowania
async needsRehash(hashedPassword: string): Promise<boolean> {
try {
const parts = hashedPassword.split('$');
const currentRounds = parseInt(parts[2], 10);
return currentRounds < this.saltRounds;
} catch {
return true;
}
}
}
// Demonstracja
async function demo() {
const service = new PasswordService();
const password = 'GloriaRomae2024';
console.log('Haslo:', password);
const hashed = await service.hashPassword(password);
console.log('Hash:', hashed);
const isValid = await service.verifyPassword(password, hashed);
console.log('Poprawne:', isValid);
const isWrong = await service.verifyPassword('ZleHaslo', hashed);
console.log('Bledne:', isWrong);
}
demo();
console.log('bcrypt - jednokierunkowe hashowanie hasel');
console.log('Salt rounds = sila hashowania (wiecej = bezpieczniej ale wolniej)');
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Dlaczego hasła należy hashować zamiast szyfrować?
Zadania praktyczne w grze
- Klikanie w kolejności
Uszereguj kroki hashowania hasła z bcrypt: