Kurs NestJS · Moduł 4: Uwierzytelnianie

Password Hashing - haszowanie kodów skarbca

4 min czytania ·
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.1rc20s7WQMF0UJoC58nf5eHWniFUUrm

Fragment $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. 1. Dlaczego hasła należy hashować zamiast szyfrować?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Uszereguj kroki hashowania hasła z bcrypt:

  1. PytanieDlaczego hashowanie a nie szyfrowanie haseł
  2. Kliknij w kolejnościProces hashowania hasła z bcrypt

Przydatne artykuły