Kurs NestJS · Moduł 9: Deployment i infrastruktura

Security Best Practices - ochrona przed barbarzyńcami

5 min czytania ·
W tej lekcji6

Strażniku tributów! Na rubieżach Imperium barbarzyńcy rzadko szturmują mury. Próbują kluczy: haseł wykradzionych z innych serwisów, podrobionych tokenów, sekretów, które ktoś zostawił w repozytorium. Konsul Caesar.js chce, żebyś znał najlepsze metody obrony przed takimi atakami.

Authentication & Authorization

Uwierzytelnianie sprawdza, kim jest legionista, a autoryzacja - co mu wolno. Token JWT weryfikuje strategia Passport:

// JWT Strategy
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(config: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: config.getOrThrow<string>('JWT_SECRET'),
      algorithms: ['HS256'], // przyjmuj tylko algorytm, którym podpisujesz
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

ExtractJwt.fromAuthHeaderAsBearerToken() czyta token z nagłówka Authorization, a ignoreExpiration: false odrzuca wygasłe. getOrThrow() zatrzymuje start aplikacji, gdy sekretu brakuje, zamiast pracować z pustym kluczem. Lista algorithms zamyka drogę podmianie algorytmu: w teście token podpisany HS512 dostał 401. To, co zwróci validate(), trafia do req.user.

Hasła przechowujemy wyłącznie jako skróty:

// Password hashing
import { BadRequestException, Injectable } from '@nestjs/common';
import * as bcrypt from 'bcrypt';

@Injectable()
export class CryptoService {
  async hashPassword(password: string): Promise<string> {
    // bcrypt czyta tylko 72 bajty - dłuższe hasło odrzuć, zamiast po cichu je przyciąć
    if (Buffer.byteLength(password, 'utf8') > 72) {
      throw new BadRequestException('Hasło przekracza 72 bajty');
    }
    const saltRounds = 12;
    return bcrypt.hash(password, saltRounds);
  }

  async validatePassword(password: string, hash: string): Promise<boolean> {
    return bcrypt.compare(password, hash);
  }
}

bcrypt z kosztem 12 jest celowo wolny, co utrudnia łamanie skrótów. Czyta jednak tylko pierwsze 72 bajty UTF-8: w teście hasło różniące się dopiero po 72. bajcie przeszło weryfikację, stąd strażnik długości. Przy nowym projekcie polecam Argon2id (pakiet argon2), który OWASP stawia na pierwszym miejscu i który tego limitu nie ma.

Input Validation

Dane wejściowe waliduje DTO z dekoratorami class-validator:

// DTO with validation
import { IsEmail, IsString, Length, Matches, MaxLength, MinLength } from 'class-validator';

export class CreateLegionaryDto {
  @IsString()
  @Length(2, 50)
  @Matches(/^[\p{L}\s'-]+$/u, { message: 'Name can only contain letters' })
  name: string;

  @IsEmail()
  email: string;

  @IsString()
  @MinLength(15) // NIST SP 800-63B-4: długość zamiast reguł składu
  @MaxLength(64)
  password: string;
}

Klasa \p{L} z flagą u akceptuje litery każdego alfabetu, więc „Łukasz Żółtowski” przechodzi - pierwsza wersja z [a-zA-Z] odrzucała polskie imiona. Reguły hasła pochodzą z NIST SP 800-63B-4: co najmniej 15 znaków, gdy hasło jest jedynym składnikiem logowania (8 przy MFA), dopuszczenie co najmniej 64 znaków i sprawdzenie z listą haseł, które wyciekły. Przy bcrypt pamiętaj, że 64 polskie znaki mogą przekroczyć 72 bajty.

Poprzednia wersja lekcji wymuszała skład hasła:

// Dawna reguła składu hasła - dziś odradzana
@Matches(/(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]/, {
  message: 'Password must contain uppercase, lowercase, number and special character'
})

NIST wprost zabrania dziś takich reguł. Ludzie odpowiadają na nie przewidywalnym „Haslo123!”, a długie, zwykłe zdanie jest trudniejsze do złamania.

Sekrety - klucze do skarbca

Zarządzanie sekretami w produkcji opiera się na trzech zasadach: sekrety są szyfrowane, regularnie rotowane, a dostęp do nich - audytowany. Trzymaj je w menedżerze sekretów, np. HashiCorp Vault albo usłudze chmury; zmienne środowiskowe to tylko sposób dostarczenia do procesu. Sekret nigdy nie trafia do kodu, repozytorium ani obrazu Dockera.

Brak sekretu najlepiej wykryć przy starcie. ConfigModule.forRoot() przyjmuje validationSchema, np. z biblioteki Joi, i sprawdza zmienne, zanim aplikacja wstanie:

// app.module.ts - walidacja konfiguracji przy starcie
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import Joi from 'joi';

@Module({
  imports: [
    ConfigModule.forRoot({
      validationSchema: Joi.object({
        NODE_ENV: Joi.string()
          .valid('development', 'production', 'test')
          .default('development'),
        PORT: Joi.number().port().default(3000),
        DATABASE_URL: Joi.string().uri().required(),
        JWT_SECRET: Joi.string().min(32).required(),
      }),
    }),
  ],
})
export class AppModule {}

Brak DATABASE_URL i za krótki JWT_SECRET kończą start błędem Config validation error z listą wszystkich problemów naraz, a PORT przychodzi już jako liczba. W projekcie ES używaj import Joi from 'joi': forma import * as Joi kompiluje się, ale w teście padła z błędem Joi.string is not a function. Dokumentacja NestJS poleca dziś w nowych projektach bibliotekę Zod, a Joi obsługuje od wersji 18.

Mury wokół aplikacji

Kontenery hartujesz jak w lekcji o Dockerze: użytkownik inny niż root, minimalny obraz bazowy i skanowanie podatności. Przypinaj też wersje obrazów zamiast tagu :latest, który zmienia się bez ostrzeżenia i nie pozwala odtworzyć, co dokładnie działa na produkcji. Przed zbyt dużą liczbą żądań od jednego klienta chroni rate limiting z lekcji o TLS.

Kronika straży

Bez logów nie wykryjesz włamania. Produkcyjne logi zapisuje Winston przez moduł nest-winston:

// app.module.ts - kronika straży w produkcji
import { Module } from '@nestjs/common';
import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';
import DailyRotateFile from 'winston-daily-rotate-file';

@Module({
  imports: [
    WinstonModule.forRoot({
      format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.json(),
      ),
      transports: [
        new DailyRotateFile({
          filename: 'logs/app-%DATE%.log',
          datePattern: 'YYYY-MM-DD',
          maxFiles: '30d',
        }),
        new DailyRotateFile({
          filename: 'logs/error-%DATE%.log',
          datePattern: 'YYYY-MM-DD',
          level: 'error',
          maxFiles: '90d',
        }),
      ],
    }),
  ],
})
export class AppModule {}

WinstonModule.forRoot() przyjmuje te same opcje co winston.createLogger(). Logi są w JSON-ie, pliki rotują codziennie, a błędy mają osobny plik z dłuższą retencją. Żeby logował przez niego także NestJS, w main.ts wywołaj app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER)). Nigdy nie zapisuj haseł ani tokenów.

Gdy barbarzyńcy przejdą przez mur

Obsługa incydentu produkcyjnego ma stałe etapy:

  1. detekcja i alert o problemie,
  2. triage i wstępna reakcja,
  3. mitygacja i rozwiązanie problemu,
  4. analiza post-mortem i usprawnienia.

Post-mortem szuka przyczyn w procesie, a nie winnych, bo tylko wtedy ludzie mówią prawdę. Polecam Ci spisać te etapy w runbooku, zanim zdarzy się pierwszy incydent. W następnej lekcji przygotujemy kopie zapasowe na dzień, w którym mur jednak padnie.

Pamiętaj: najlepszy strażnik nie ufa bramie, tylko sprawdza każdy klucz i zapisuje każdą próbę.

Kod do tej lekcji: src/security.ts
// Security Best Practices - Ochrona Przed Barbarzyńcami
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

// 1. JWT Authentication
// @Injectable()
// class JwtAuthGuard extends AuthGuard('jwt') {
//   canActivate(context: ExecutionContext) {
//     return super.canActivate(context);
//   }
// }

// 2. Role-based Authorization
@Injectable()
class RolesGuard implements CanActivate {
  constructor(private requiredRoles: string[]) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const user = request.user;

    if (!user || !user.roles) return false;

    return this.requiredRoles.some(role =>
      user.roles.includes(role)
    );
  }
}

// 3. Input Validation (class-validator)
// class CreateLegionDto {
//   @IsString()
//   @MinLength(3)
//   @MaxLength(50)
//   name: string;
//
//   @IsNumber()
//   @Min(100)
//   @Max(10000)
//   soldiers: number;
//
//   @IsEnum(Province)
//   province: Province;
// }

// 4. Security Headers (Helmet)
const securityHeaders = {
  'X-Content-Type-Options': 'nosniff',
  'X-Frame-Options': 'DENY',
  'X-XSS-Protection': '1; mode=block',
  'Strict-Transport-Security': 'max-age=31536000',
  'Content-Security-Policy': "default-src 'self'",
};

// 5. Password Hashing (bcrypt)
// import * as bcrypt from 'bcrypt';
// const hash = await bcrypt.hash(password, 10);
// const isMatch = await bcrypt.compare(password, hash);

// 6. Rate Limiting - ochrona przed DDoS
// @UseGuards(ThrottlerGuard)
// @Throttle(100, 60)  // 100 requestow / 60 sekund

// 7. CORS Configuration
const corsConfig = {
  origin: ['https://roman-empire.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,
};

// 8. Environment Secrets
// NIGDY nie hardcoduj:
// - Hasla do bazy danych
// - Klucze API
// - JWT Secret
// - Klucze szyfrowania
// Uzyj: .env, Docker secrets, Vault, AWS Secrets Manager

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. Secrets management w produkcji powinno:

  2. 2. Security best practices dla Docker containers:

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj WinstonModule z transportami: file, error-file i format JSON

  • Klikanie w kolejności

    Ułóż etapy obsługi incydentu produkcyjnego:

  1. PytanieSecrets management w infrastrukturze
  2. PytanieHardening kontenerów produkcyjnych
  3. Zadanie z kodemPraktyka: Agregacja logów produkcyjnych z Winston
  4. PytanieChecklist hardening infrastruktury
  5. Kliknij w kolejnościEtapy obsługi incydentu produkcyjnego

Przydatne artykuły