SELECT email, password FROM users;

import { hash } from 'bcrypt';

const password = 'MySecret123';

const hash1 = await hash(password, 10);
const hash2 = await hash(password, 10);

// ❌ Хеші будуть різними через випадкову сіль (див. наступну секцію)
// Але якщо використати той самий пароль для верифікації — результат завжди буде true

const password1 = 'MySecret123';
const password2 = 'MySecret124'; // Змінено лише останню цифру

const hash1 = await hash(password1, 10);
const hash2 = await hash(password2, 10);

console.log(hash1); 
// $2b$10$N9qo8uLOickgx2ZMRZoMye.IjefOxQZV.8c3ZxgO3k6GJ.9fV9OZm

console.log(hash2); 
// $2b$10$abcXYZ123differentHASHvalueDUEtoONEcharCHANGE
// Повністю інший результат!

const password = 'MySecret123';
const passwordHash = await hash(password, 10);

// ✅ Можливо: перевірити, чи відповідає введений пароль хешу
const isValid = await compare('MySecret123', passwordHash); // true

// ❌ НЕМОЖЛИВО: отримати оригінальний пароль з хешу
// Не існує функції unhash() або decrypt()
const recovered = unhash(passwordHash); // Такої функції не існує!

import { createHash } from 'crypto';

function weakHash(password: string): string {
  return createHash('sha256').update(password).digest('hex');
}

// Користувачі з однаковими паролями матимуть ідентичні хеші
const user1 = { email: 'ivan@example.com', password: 'password123' };
const user2 = { email: 'olena@example.com', password: 'password123' };

console.log(weakHash(user1.password)); 
// ef92b778bafe771e89245b89ecbc08a44a4e166c06659911881f383d4473e94f

console.log(weakHash(user2.password)); 
// ef92b778bafe771e89245b89ecbc08a44a4e166c06659911881f383d4473e94f
// ❌ Ідентичні хеші! Зловмисник бачить, що паролі співпадають

ef92b778... → password123
5e884898... → password

import { hash } from 'bcrypt';

const password = 'MySecret123';

// ✅ Сіль генерується автоматично
const hash1 = await hash(password, 10);
const hash2 = await hash(password, 10);

console.log(hash1);
// $2b$10$N9qo8uLOickgx2ZMRZoMye.IjefOxQZV.8c3ZxgO3k6GJ.9fV9OZm

console.log(hash2);
// $2b$10$abcXYZ123differentSALTgeneratedAUTOmaticallyEachTime
// Різні хеші через різні солі!

$2b$10$N9qo8uLOickgx2ZMRZoMye.IjefOxQZV.8c3ZxgO3k6GJ.9fV9OZm
│  │ │  │                        │
│  │ │  └─ Сіль (22 символи)     └─ Хеш (31 символ)
│  │ └─ Cost factor (2^10 = 1024 ітерацій)
│  └─ Версія алгоритму
└─ Ідентифікатор bcrypt

// Cost factor 10 → 2^10 = 1024 ітерацій → ~100 мс на CPU
await hash(password, 10);

// Cost factor 12 → 2^12 = 4096 ітерацій → ~400 мс на CPU
await hash(password, 12);

// Cost factor 14 → 2^14 = 16384 ітерацій → ~1600 мс на CPU
await hash(password, 14);

// src/auth/auth.service.ts
import { Injectable, ConflictException, BadRequestException } from '@nestjs/common';
import { hash } from 'bcrypt';
import { UsersService } from '../users/users.service';

@Injectable()
export class AuthService {
  // Cost factor для bcrypt
  private readonly BCRYPT_ROUNDS = 12;

  constructor(private readonly usersService: UsersService) {}

  /**
   * Реєстрація нового користувача з безпечним хешуванням паролю
   * 
   * @param email - Email користувача
   * @param password - Пароль у відкритому вигляді (plaintext)
   * @returns Об'єкт користувача без хешу паролю
   * @throws {ConflictException} Якщо користувач з таким email вже існує
   */
  async register(email: string, password: string) {
    // 1. Перевірка існування користувача
    const existingUser = await this.usersService.findByEmail(email);
    if (existingUser) {
      throw new ConflictException('User with this email already exists');
    }

    // 2. Валідація складності пароля (додаткова перевірка на сервері)
    if (password.length < 8) {
      throw new BadRequestException('Password must be at least 8 characters long');
    }

    // 3. Хешування пароля через bcrypt
    // Це асинхронна операція, що займає ~400мс для cost factor 12
    const passwordHash = await hash(password, this.BCRYPT_ROUNDS);

    console.log('Original password:', password);
    console.log('Bcrypt hash:', passwordHash);
    // Original password: MySecret123
    // Bcrypt hash: $2b$12$N9qo8uLOickgx2ZMRZoMye.IjefOxQZV.8c3ZxgO3k6GJ.9fV9OZm

    // 4. Створення користувача у базі даних
    const user = await this.usersService.create({
      email,
      passwordHash, // ✅ Зберігаємо хеш, а не пароль
      roles: ['user'],
    });

    // 5. Повертаємо користувача без хешу паролю
    const { passwordHash: _, ...userWithoutPassword } = user;
    return userWithoutPassword;
  }
}

// src/auth/auth.controller.ts
import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
import { AuthService } from './auth.service';
import { RegisterDto } from './dto/register.dto';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('register')
  async register(@Body() dto: RegisterDto) {
    const user = await this.authService.register(dto.email, dto.password);

    return {
      statusCode: HttpStatus.CREATED,
      message: 'User registered successfully',
      data: {
        id: user.id,
        email: user.email,
        createdAt: user.createdAt,
      },
    };
  }
}

// src/auth/dto/register.dto.ts
import {
  IsEmail,
  IsNotEmpty,
  MinLength,
  MaxLength,
  Matches,
} from 'class-validator';

export class RegisterDto {
  @IsEmail({}, { message: 'Invalid email format' })
  @IsNotEmpty()
  email: string;

  @IsNotEmpty()
  @MinLength(8, { message: 'Password must be at least 8 characters long' })
  @MaxLength(64, { message: 'Password must not exceed 64 characters' })
  @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&#])[A-Za-z\d@$!%*?&#]+$/, {
    message: 'Password must contain uppercase, lowercase, number and special character',
  })
  password: string;
}

POST /auth/register HTTP/1.1
Host: localhost:3000
Content-Type: application/json

{
  "email": "ivan@example.com",
  "password": "SecureP@ss123"
}

{
  "statusCode": 201,
  "message": "User registered successfully",
  "data": {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "email": "ivan@example.com",
    "createdAt": "2026-09-06T12:30:00.000Z"
  }
}

SELECT id, email, password_hash, created_at FROM users 
WHERE email = 'ivan@example.com';

// src/auth/auth.service.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { compare } from 'bcrypt';
import { UsersService } from '../users/users.service';

@Injectable()
export class AuthService {
  constructor(private readonly usersService: UsersService) {}

  /**
   * Валідація облікових даних користувача при вході
   * 
   * @param email - Email користувача
   * @param password - Пароль у відкритому вигляді
   * @returns Об'єкт користувача або null
   * @throws {UnauthorizedException} Якщо credentials невалідні
   */
  async validateUser(email: string, password: string) {
    // 1. Завантаження користувача з бази даних за email
    const user = await this.usersService.findByEmail(email);

    if (!user) {
      // ❌ НЕ розкриваємо, що користувач не існує
      throw new UnauthorizedException('Invalid credentials');
    }

    // 2. Порівняння введеного пароля з хешем
    // bcrypt автоматично витягує сіль з хешу та відтворює обчислення
    const isPasswordValid = await compare(password, user.passwordHash);

    if (!isPasswordValid) {
      // ❌ Той самий загальний текст помилки
      throw new UnauthorizedException('Invalid credentials');
    }

    // 3. Перевірка додаткових умов (опціонально)
    if (!user.isActive) {
      throw new UnauthorizedException('Account is disabled');
    }

    if (!user.emailVerified) {
      throw new UnauthorizedException('Email not verified. Check your inbox.');
    }

    // ✅ Всі перевірки пройдено — повертаємо користувача
    return user;
  }
}

async validateUser(email: string, password: string) {
  const user = await this.usersService.findByEmail(email);

  if (!user) {
    // ❌ Миттєве повернення — зловмисник розуміє, що email не існує
    throw new UnauthorizedException('User not found');
  }

  const isPasswordValid = await compare(password, user.passwordHash);
  // ❌ bcrypt.compare займає ~400мс — різниця у часі відповіді очевидна

  if (!isPasswordValid) {
    throw new UnauthorizedException('Invalid password');
  }

  return user;
}

async validateUser(email: string, password: string) {
  const user = await this.usersService.findByEmail(email);

  // Завжди виконуємо bcrypt.compare, навіть якщо користувач не існує
  const passwordToCompare = user ? user.passwordHash : 
    '$2b$12$dummyHashToPreventTimingAttacksXXXXXXXXXXXXXXXXXXXXXXXX';

  const isPasswordValid = await compare(password, passwordToCompare);

  if (!user || !isPasswordValid) {
    // ✅ Загальне повідомлення без деталей
    throw new UnauthorizedException('Invalid credentials');
  }

  return user;
}

// scripts/benchmark-bcrypt.ts
import { hash } from 'bcrypt';

async function benchmarkBcrypt() {
  const password = 'TestPassword123!';
  const costFactors = [10, 11, 12, 13, 14];

  console.log('Bcrypt cost factor benchmark:\n');
  console.log('| Cost Factor | Iterations | Time (ms) | Hashes/sec |');
  console.log('|-------------|------------|-----------|------------|');

  for (const cost of costFactors) {
    const iterations = Math.pow(2, cost);
    const startTime = Date.now();

    await hash(password, cost);

    const endTime = Date.now();
    const timeMs = endTime - startTime;
    const hashesPerSec = (1000 / timeMs).toFixed(2);

    console.log(`| ${cost}          | ${iterations.toLocaleString().padStart(7)} | ${timeMs.toString().padStart(9)} | ${hashesPerSec.padStart(10)} |`);
  }
}

benchmarkBcrypt();

$ ts-node scripts/benchmark-bcrypt.ts

Bcrypt cost factor benchmark:

| Cost Factor | Iterations | Time (ms) | Hashes/sec |
|-------------|------------|-----------|------------|
| 10          |   1,024    |       103 |       9.71 |
| 11          |   2,048    |       207 |       4.83 |
| 12          |   4,096    |       415 |       2.41 |
| 13          |   8,192    |       831 |       1.20 |
| 14          |  16,384    |     1,663 |       0.60 |

// src/auth/auth.service.ts
import { hash, compare, getRounds } from 'bcrypt';

@Injectable()
export class AuthService {
  private readonly TARGET_BCRYPT_ROUNDS = 12;

  async validateUser(email: string, password: string) {
    const user = await this.usersService.findByEmail(email);

    if (!user) {
      throw new UnauthorizedException('Invalid credentials');
    }

    const isPasswordValid = await compare(password, user.passwordHash);

    if (!isPasswordValid) {
      throw new UnauthorizedException('Invalid credentials');
    }

    // Перевірка cost factor існуючого хешу
    const currentRounds = getRounds(user.passwordHash);

    if (currentRounds < this.TARGET_BCRYPT_ROUNDS) {
      // Опортуністична міграція: пере-хешуємо пароль з новим cost factor
      const newHash = await hash(password, this.TARGET_BCRYPT_ROUNDS);
      await this.usersService.updatePasswordHash(user.id, newHash);

      console.log(`Migrated user ${user.email} from cost ${currentRounds} to ${this.TARGET_BCRYPT_ROUNDS}`);
    }

    return user;
  }
}

import argon2 from 'argon2';

const passwordHash = await argon2.hash(password, {
  type: argon2.argon2id,    // Гібридний режим (рекомендовано)
  timeCost: 3,              // Кількість ітерацій
  memoryCost: 65536,        // 64 MiB оперативної пам'яті
  parallelism: 4,           // 4 паралельні потоки
});

// src/auth/argon2-auth.service.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import * as argon2 from 'argon2';
import { UsersService } from '../users/users.service';

@Injectable()
export class Argon2AuthService {
  constructor(private readonly usersService: UsersService) {}

  /**
   * Хешування пароля через Argon2id
   */
  async hashPassword(password: string): Promise<string> {
    return argon2.hash(password, {
      type: argon2.argon2id,     // Гібридний режим: захист від tradeoff attacks
      timeCost: 3,               // Кількість ітерацій
      memoryCost: 65536,         // 64 MiB (рекомендовано OWASP)
      parallelism: 4,            // 4 потоки (підганяйте під CPU)
    });
  }

  /**
   * Верифікація пароля
   */
  async verifyPassword(hash: string, password: string): Promise<boolean> {
    try {
      // Argon2 автоматично витягує параметри з хешу
      return await argon2.verify(hash, password);
    } catch (error) {
      // Помилка верифікації (пошкоджений хеш)
      return false;
    }
  }

  /**
   * Реєстрація користувача з Argon2
   */
  async register(email: string, password: string) {
    const existingUser = await this.usersService.findByEmail(email);
    if (existingUser) {
      throw new ConflictException('User already exists');
    }

    const passwordHash = await this.hashPassword(password);

    const user = await this.usersService.create({
      email,
      passwordHash,
      roles: ['user'],
    });

    const { passwordHash: _, ...userWithoutPassword } = user;
    return userWithoutPassword;
  }

  /**
   * Валідація користувача при вході
   */
  async validateUser(email: string, password: string) {
    const user = await this.usersService.findByEmail(email);

    if (!user) {
      throw new UnauthorizedException('Invalid credentials');
    }

    const isPasswordValid = await this.verifyPassword(user.passwordHash, password);

    if (!isPasswordValid) {
      throw new UnauthorizedException('Invalid credentials');
    }

    return user;
  }
}

$argon2id$v=19$m=65536,t=3,p=4$5Z3MvZ8xJPaYnxK+8F5qRA$ZrIj0vOLhQfJ8KqZCgfCqA
│         │     │              │                        │
│         │     │              └─ Сіль (Base64)        └─ Хеш (Base64)
│         │     └─ Параметри: m=memory, t=time, p=parallelism
│         └─ Версія алгоритму (19 = v1.3)
└─ Тип: argon2id (гібридний)

// src/common/validators/password-strength.validator.ts
import { registerDecorator, ValidationOptions, ValidationArguments } from 'class-validator';
import * as zxcvbn from 'zxcvbn'; // Бібліотека Dropbox для оцінки стійкості паролів

export function IsStrongPassword(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      name: 'isStrongPassword',
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      validator: {
        validate(value: any, args: ValidationArguments) {
          if (typeof value !== 'string') {
            return false;
          }

          // Оцінка стійкості пароля (0 = дуже слабкий, 4 = дуже сильний)
          const result = zxcvbn(value);

          // Вимагаємо мінімум score 3 (сильний пароль)
          return result.score >= 3;
        },
        defaultMessage(args: ValidationArguments) {
          return 'Password is too weak. Use a mix of letters, numbers and symbols.';
        },
      },
    });
  };
}

// src/auth/dto/register.dto.ts
import { IsEmail, IsNotEmpty } from 'class-validator';
import { IsStrongPassword } from '../../common/validators/password-strength.validator';

export class RegisterDto {
  @IsEmail()
  email: string;

  @IsNotEmpty()
  @IsStrongPassword()
  password: string;
}

// src/auth/guards/login-rate-limit.guard.ts
import { Injectable, CanActivate, ExecutionContext, TooManyRequestsException } from '@nestjs/common';
import { Throttle, ThrottlerGuard } from '@nestjs/throttler';

@Injectable()
export class LoginRateLimitGuard extends ThrottlerGuard {
  /**
   * Обмеження: максимум 5 спроб входу за 15 хвилин для одного IP
   */
  protected async handleRequest(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const ip = request.ip;

    // Перевірка поточної кількості спроб
    const attempts = await this.getTracker(ip, context);

    if (attempts > 5) {
      throw new TooManyRequestsException(
        'Too many login attempts. Please try again in 15 minutes.'
      );
    }

    return super.handleRequest(context);
  }
}

// src/auth/auth.controller.ts
import { Controller, Post, UseGuards } from '@nestjs/common';
import { LoginRateLimitGuard } from './guards/login-rate-limit.guard';

@Controller('auth')
export class AuthController {
  @Post('login')
  @UseGuards(LoginRateLimitGuard)
  async login(@Body() dto: LoginDto) {
    return this.authService.login(dto.email, dto.password);
  }
}

// src/users/entities/password-history.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, ManyToOne, CreateDateColumn } from 'typeorm';
import { User } from './user.entity';

@Entity('password_history')
export class PasswordHistory {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @ManyToOne(() => User)
  user: User;

  @Column()
  passwordHash: string;

  @CreateDateColumn()
  createdAt: Date;
}

// src/users/users.service.ts
async changePassword(userId: string, newPassword: string) {
  const user = await this.findById(userId);

  // Завантажуємо останні 5 хешів паролів користувача
  const history = await this.passwordHistoryRepository.find({
    where: { user: { id: userId } },
    order: { createdAt: 'DESC' },
    take: 5,
  });

  // Перевіряємо, чи не використовувався новий пароль раніше
  for (const record of history) {
    const isReused = await compare(newPassword, record.passwordHash);
    if (isReused) {
      throw new BadRequestException(
        'You cannot reuse your last 5 passwords. Please choose a different password.'
      );
    }
  }

  // Хешуємо новий пароль
  const newHash = await hash(newPassword, 12);

  // Оновлюємо поточний хеш
  await this.userRepository.update(userId, { passwordHash: newHash });

  // Зберігаємо у історію
  await this.passwordHistoryRepository.save({
    user: { id: userId },
    passwordHash: newHash,
  });
}