Access та Refresh Tokens

npm install @nestjs/jwt cookie-parser
npm install -D @types/cookie-parser

import { NestFactory } from '@nestjs/core';
import cookieParser from 'cookie-parser';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.use(cookieParser());

  await app.listen(3000);
}

bootstrap();

import {
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';

type StoredRefreshToken = {
  userId: string;
  tokenHash: string;
  expiresAt: number;
};

@Injectable()
export class AuthService {
  private readonly accessSecret =
    process.env.JWT_ACCESS_SECRET ?? 'development-access-secret';

  private readonly refreshSecret =
    process.env.JWT_REFRESH_SECRET ?? 'development-refresh-secret';

  /*
   * Це демонстраційне сховище.
   * У production його потрібно замінити на базу даних або Redis.
   */
  private readonly refreshTokens = new Map<string, StoredRefreshToken>();

  constructor(private readonly jwtService: JwtService) {}

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

    if (!user) {
      throw new UnauthorizedException('Неправильний email або пароль');
    }

    return this.issueTokenPair(user.id, user.email);
  }

  async refresh(refreshToken: string) {
    let payload: {
      sub: string;
      email: string;
      type: string;
      jti: string;
    };

    try {
      payload = await this.jwtService.verifyAsync(refreshToken, {
        secret: this.refreshSecret,
      });
    } catch {
      throw new UnauthorizedException('Недійсний refresh token');
    }

    if (payload.type !== 'refresh' || !payload.jti) {
      throw new UnauthorizedException('Некоректний refresh token');
    }

    const storedToken = this.refreshTokens.get(payload.jti);

    if (
      !storedToken ||
      storedToken.userId !== payload.sub ||
      storedToken.expiresAt <= Date.now() ||
      !this.isSameHash(storedToken.tokenHash, this.hash(refreshToken))
    ) {
      throw new UnauthorizedException(
        'Refresh token відкликаний або недійсний',
      );
    }

    /*
     * Rotation: старий refresh token стає недійсним
     * ще до створення нового.
     */
    this.refreshTokens.delete(payload.jti);

    return this.issueTokenPair(payload.sub, payload.email);
  }

  logout(refreshToken?: string) {
    if (!refreshToken) {
      return;
    }

    try {
      const payload = this.jwtService.verify<{
        jti?: string;
      }>(refreshToken, {
        secret: this.refreshSecret,
        ignoreExpiration: true,
      });

      if (payload.jti) {
        this.refreshTokens.delete(payload.jti);
      }
    } catch {
      /*
       * Logout має бути ідемпотентним:
       * навіть недійсний токен не повинен спричиняти помилку.
       */
    }
  }

  revokeAllUserTokens(userId: string) {
    for (const [jti, storedToken] of this.refreshTokens) {
      if (storedToken.userId === userId) {
        this.refreshTokens.delete(jti);
      }
    }
  }

  private async issueTokenPair(userId: string, email: string) {
    const refreshJti = randomUUID();

    const accessToken = await this.jwtService.signAsync(
      {
        sub: userId,
        email,
        type: 'access',
      },
      {
        secret: this.accessSecret,
        expiresIn: '15m',
      },
    );

    const refreshToken = await this.jwtService.signAsync(
      {
        sub: userId,
        email,
        type: 'refresh',
        jti: refreshJti,
      },
      {
        secret: this.refreshSecret,
        expiresIn: '7d',
      },
    );

    this.refreshTokens.set(refreshJti, {
      userId,
      tokenHash: this.hash(refreshToken),
      expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000,
    });

    return {
      accessToken,
      user: {
        id: userId,
        email,
      },
    };
  }

  private hash(token: string) {
    return createHash('sha256').update(token).digest('hex');
  }

  private isSameHash(first: string, second: string) {
    const firstBuffer = Buffer.from(first);
    const secondBuffer = Buffer.from(second);

    return (
      firstBuffer.length === secondBuffer.length &&
      timingSafeEqual(firstBuffer, secondBuffer)
    );
  }

  private async validateUser(email: string, password: string) {
    /*
     * Для прикладу використано умовного користувача.
     * У реальному застосунку тут буде пошук у базі
     * та перевірка хешу пароля.
     */
    if (email === 'user@example.com' && password === 'correct-password') {
      return {
        id: 'user-1',
        email,
      };
    }

    return null;
  }
}

import {
  Body,
  Controller,
  Post,
  Req,
  Res,
} from '@nestjs/common';
import type { Request, Response } from 'express';
import { AuthService } from './auth.service';

type LoginDto = {
  email: string;
  password: string;
};

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

  @Post('login')
  async login(
    @Body() body: LoginDto,
    @Res({ passthrough: true }) response: Response,
  ) {
    const result = await this.authService.login(
      body.email,
      body.password,
    );

    /*
     * Refresh token не потрапляє до JavaScript-коду браузера
     * завдяки прапорцю HttpOnly.
     */
    const refreshToken = await this.createRefreshTokenForCookie(
      body.email,
      body.password,
    );

    response.cookie('refresh_token', refreshToken, {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'lax',
      path: '/auth',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });

    return {
      accessToken: result.accessToken,
      user: result.user,
    };
  }

  @Post('refresh')
  async refresh(
    @Req() request: Request,
    @Res({ passthrough: true }) response: Response,
  ) {
    const oldRefreshToken = request.cookies?.refresh_token as
      | string
      | undefined;

    if (!oldRefreshToken) {
      return response.status(401).json({
        message: 'Refresh token відсутній',
      });
    }

    const result = await this.authService.refresh(oldRefreshToken);

    /*
     * У прикладі сервіс повертає access token,
     * а новий refresh token потрібно також встановити в cookie.
     */
    const newRefreshToken = await this.createRefreshTokenForCookie(
      result.user.email,
      'correct-password',
    );

    response.cookie('refresh_token', newRefreshToken, {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'lax',
      path: '/auth',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });

    return {
      accessToken: result.accessToken,
      user: result.user,
    };
  }

  @Post('logout')
  logout(
    @Req() request: Request,
    @Res({ passthrough: true }) response: Response,
  ) {
    const refreshToken = request.cookies?.refresh_token as
      | string
      | undefined;

    this.authService.logout(refreshToken);

    response.clearCookie('refresh_token', {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'lax',
      path: '/auth',
    });

    return {
      message: 'Вихід виконано',
    };
  }

  private async createRefreshTokenForCookie(
    email: string,
    password: string,
  ) {
    /*
     * У production не потрібно повторно перевіряти пароль таким способом.
     * Метод показує ідею встановлення refresh cookie.
     *
     * Практична реалізація має повертати refresh token разом з access token
     * із сервісу, а не створювати його вдруге.
     */
    const user = await this.authService['validateUser'](email, password);

    if (!user) {
      throw new Error('Користувача не знайдено');
    }

    const result = await this.authService['issueTokenPair'](
      user.id,
      user.email,
    );

    return result.refreshToken;
  }
}

return {
  accessToken,
  refreshToken,
  user: {
    id: userId,
    email,
  },
};

const result = await this.issueTokenPair(payload.sub, payload.email);

return result;

import {
  CanActivate,
  ExecutionContext,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import type { Request } from 'express';

type AccessPayload = {
  sub: string;
  email: string;
  type: 'access';
};

@Injectable()
export class AccessTokenGuard implements CanActivate {
  private readonly accessSecret =
    process.env.JWT_ACCESS_SECRET ?? 'development-access-secret';

  constructor(private readonly jwtService: JwtService) {}

  async canActivate(context: ExecutionContext) {
    const request = context.switchToHttp().getRequest<Request>();
    const authorization = request.headers.authorization;

    if (!authorization?.startsWith('Bearer ')) {
      throw new UnauthorizedException('Access token відсутній');
    }

    const token = authorization.slice('Bearer '.length);

    try {
      const payload = await this.jwtService.verifyAsync<AccessPayload>(
        token,
        {
          secret: this.accessSecret,
        },
      );

      if (payload.type !== 'access') {
        throw new UnauthorizedException('Очікувався access token');
      }

      request.user = {
        id: payload.sub,
        email: payload.email,
      };

      return true;
    } catch {
      throw new UnauthorizedException('Недійсний access token');
    }
  }
}

import {
  Controller,
  Get,
  Req,
  UseGuards,
} from '@nestjs/common';
import type { Request } from 'express';
import { AccessTokenGuard } from './access-token.guard';

@Controller('profile')
export class ProfileController {
  @Get()
  @UseGuards(AccessTokenGuard)
  getProfile(@Req() request: Request) {
    return {
      userId: request.user.id,
      email: request.user.email,
    };
  }
}

declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        email: string;
      };
    }
  }
}

if (!storedToken) {
  this.revokeAllUserTokens(payload.sub);

  throw new UnauthorizedException(
    'Виявлено повторне використання refresh token',
  );
}

{
  httpOnly: true,
  secure: true,
  sameSite: 'lax',
  path: '/auth',
}