Implementación de JWT en Módulo de Autenticación con Variables de Entorno

Clase 12 de 22 • Curso de NestJS: Autenticación con Passport y JWT

Contenido del curso

Introducción

Protección con guardianes

Autenticación con Passport

Autenticación con JSON Web Tokens

Deployment

Próximos pasos

22
Implementación de Autenticación y Autorización en NestJS
00:41 min

Tomar examen

Resumen

Firmar tokens de forma segura y controlar su expiración es una pieza fundamental en cualquier API que maneje autenticación. Aquí se aborda paso a paso cómo registrar el JWT Module dentro del módulo de autenticación en NestJS, proteger el secret con variables de entorno y, finalmente, generar un access token funcional desde el flujo de login.

¿Por qué es necesario registrar el JWT Module en el auth module?

En la clase anterior se instalaron las dependencias @nestjs/jwt y se creó el método generateJWT dentro del AuthService. Sin embargo, el JwtService que ese método utiliza no puede resolverse si el módulo correspondiente no está importado. Al correr la aplicación sin esta configuración, NestJS lanza un error de dependencia.

Para solucionarlo hay que agregar JwtModule en el array de imports del AuthModule [01:07]. Con la programación modular de NestJS, al importar un módulo se exponen sus servicios internos —en este caso JwtService— para que puedan inyectarse donde se necesiten.

¿Qué representa el secret y por qué debe estar protegido?

El secret funciona como la llave de una caja fuerte [00:40]. Solo quien posea esa llave puede descifrar la información contenida en el token. Si alguien con acceso al repositorio encuentra el secret escrito de forma explícita en el código, podría desencriptar cualquier token y suplantar usuarios.

El secret es una cadena (palabra, frase o valor aleatorio) con la que se firman todos los JWT.
Debe almacenarse en una variable de entorno, nunca hard-coded.
Solo el responsable de la infraestructura o del deployment a producción debería conocer la llave real.

¿Cómo se configura la expiración del token?

Al registrar el módulo se pasa un objeto con signOptions que incluye expiresIn [03:00]. En el ejemplo se utiliza 10d (diez días), lo que significa que pasado ese tiempo el token deja de ser válido y el usuario debe autenticarse de nuevo.

Existen estrategias más robustas como manejar la expiración en segundos y combinarla con un refresh token.
Con un refresh token se puede renovar el access token de forma transparente para el usuario.
Para profundizar en estas prácticas de seguridad se recomienda el curso de Passport de Node en Platzi.

¿Cómo leer el secret desde variables de entorno con registerAsync?

En lugar de JwtModule.register(), se utiliza JwtModule.registerAsync() [04:28]. Este método permite inyectar dependencias —como el ConfigService— mediante un useFactory.

typescript JwtModule.registerAsync({ inject: [config.KEY], useFactory: (configService: ConfigType<typeof config>) => { return { secret: configService.jwtSecret, signOptions: { expiresIn: '10d', }, }; }, })

Pasos clave en esta configuración:

Se agrega JWT_SECRET al archivo .env y se declara en el esquema de configuración [03:47].
Se marca como requerida en la validación del AppModule para que el proyecto no arranque sin ella [04:15].
Se inyecta config con ConfigType y typeof config para obtener tipado seguro.

¿Dónde se invoca el método generateJWT?

El método generateJWT del AuthService recibe el usuario validado, selecciona los datos que viajarán dentro del payload (como el rol y el id), firma el token con JwtService.sign() y devuelve un objeto con el access token y la información del usuario [06:40].

Este método se llama en el AuthController, justo después de que el guard de Passport confirma que el email y password son correctos [07:05].

typescript @UseGuards(AuthGuard('local')) @Post('login') login(@Req() req: Request) { const user = req.user as User; return this.authService.generateJWT(user); }

¿Por qué se necesita el casteo as User?

Express tipifica req.user de forma genérica. Al hacer un casteo hacia la entidad User propia del proyecto, se garantiza que TypeScript reconozca las propiedades disponibles (rol, id, email) y evite errores en tiempo de compilación [08:10]. Usar any resolvería el error, pero se perdería la seguridad de tipos.

¿Cómo verificar que el token se genera correctamente?

Al enviar una petición POST a /login con credenciales válidas desde Insomnia, la respuesta incluye el objeto del usuario junto con el access token [09:22]. Un JWT válido se compone de tres partes separadas por puntos: el header, el payload y la signature.

Con el token generado, el siguiente paso será proteger los demás endpoints para que validen este token en cada petición, comprueben que no haya expirado y concedan o nieguen el acceso según corresponda.

¿Ya lograste generar tu primer token? Comparte en los comentarios qué estrategia de expiración planeas usar en tu proyecto.

Comentarios

Nicolás Potier Anzola

student•

Seria bueno ver la estrategia de refresh token con Nest!!!

Ingenea SRL

student•

si si por favor Nico explicanos :):)

Juan Manuel

student•

Aquí un ejemplo me sirvio de mucho: https://wanago.io/2020/09/21/api-nestjs-refresh-tokens-jwt/

Carlos Vallejo

student•

Hola profe! Una duda, con TypeORM me vuelve a regresar el password en los datos del usuario, a pesar de ya estar puesto el Exclude, y veo que lo mismo le pasa a usted. A qué se debe esto? Gracias!

Nicolas Molina

teacher•

Esa es una gran pregunta, lo que ocurre es que los serializadores solo actúan cuando el modelo es exactamente el retorno del controlador es decir cuando queremos productos y el controlador retorna esa entidad entonces el serializador entra en acción.

Nuestro controlador de login no retorna una entidad retorna:

return {
      access_token:,
      user,
    };

Por lo cual no es procesado por el serializador.

Guillermo Rodas Gómez

student•

Encontré la solución a este problema en este link

Creamos un interceptor que transfome explicitamente la clase a texto plano pasando por el serializador:

// src/config/transform.interceptor.ts
import {
  CallHandler,
  ExecutionContext,
  Injectable,
  NestInterceptor,
} from '@nestjs/common';
import { classToPlain } from 'class-transformer';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(
    context: ExecutionContext,
    call$: CallHandler<any>,
  ): Observable<any> {
    return call$.handle().pipe(map((data) => classToPlain(data)));
  }
}

Y luego le decimos a NestJs que utilice el interceptor

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TransformInterceptor } from './config/transform.interceptor';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalInterceptors(new TransformInterceptor());
  ....
}
bootstrap();

Y voilá, la respuesta ya no contendrá el password!

Andrés Esteban Rodríguez Jiménez

student•

Secret desde variables de entorno

Ya tenemos el método para generar los Jwt, pero para que este método funcione, primero tenemos que firmar los Jwt con un secreto antes de enviarlos, esto lo vamos a hacer con una variable de entorno de nuestra aplicación.

En la configuración de variables de entorno, vamos a añadir el secreto:

**src/config.ts**:

import { registerAs } from '@nestjs/config';

export default registerAs('config', () => {
  return {
    //
    jwtSecret: process.env.JWT_SECRET,
  };
});

Luego vamos a nuestro **.env** y escribimos un secreto que consideremos seguro.

Luego vamos a configurar el módulo de autenticación:

**src/auth/auth.module.ts**:

// importmoa el módulo de Jwt
import { JwtModule } from '@nestjs/jwt';
// importamos la configuración d variables de ambiente
import config from '../config';
// importamos el typo de config
import { ConfigType } from '@nestjs/config';

@Module({
  // importamos "JwtModule" en el módulo
  imports: [
    // ...
    // usamos un registro asíncrono para poder enviar un useFactory
    JwtModule.registerAsync({
      // inyectamos la configuracíon
      inject: [config.KEY],
      // inyectamos el tipo de config en el use factory
      useFactory: (configiService: ConfigType<typeof config>) => {
        return {
          // le debemos enviar un secreto que será una variable de ambiente
          secret: configiService.jwtSecret,
          signOptions: {
            // especificamos en cuanto tiempo expirará el token, por ende, la sesión
            // se vence en 10 días
            expiresIn: '10d',
          },
        };
      },
    }),
  ],
  // ...
})
export class AuthModule {}

Con esto ya hemos configurado el JWT y su registro.

Ahora lo único que nos queda es implementar este generador en el controlador:

**src/auth/controllers/auth.controller.ts**:

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

  @UseGuards(AuthGuard('local'))
  @Post('login')
  async login(@Body() login: LoginDto) {
    const { email, password } = login;
    // validamos al usuario
    const user = await this.authService.validateUser(email, password);
    // enviamos al usuario
    const sesion = this.authService.generateJwt(user);
		// retornamos la sesión
    return sesion;
  }
}

Y listo, de esta forma hemos generado un JWT, y este token nos servirá para validar nuestros usuarios.

Nicolas Javier Espinoza Dias

student•

mi duda es cuando saber que algo tiene que ser inyectado y cuando no? por ejemplo en el minuto 12:49 usted dice que inyecta el authService pero no usa el decorador Inject() y en el authService al crearlo no uso el decorador @Injectable, espero pueda responder mi duda! muchas gracias profe

Nicolas Molina

teacher•

Realmente puedes inyectar varios valores en una clase, como un string, una number etc para inyectar valores usas el decorador @Inject, pero si lo que necesitas es inyectar una instancia de una clase como ProducutsService usas el decorador @Injectable y luego solo lo tienes que pasar al constructor.

Andres Trujillo

student•

Excelente aclaración profe

yerson lasso

student•

Debería guardar el tiempo de expiración en una variable de entorno? para hacer más fácil modificarlo

Carlos Alberto Angel Angel

student•

yo prefiero guardarlo como una variable de entorno, en caso de que quiera cambiar el tiempo de expiración solo necesito cambiar su valor y no hacer un cambio en el código.

Daniel Alejandro Barrientos Quispe

student•

Yo lo hice de esta manera:

-- auth.service.ts

import { Injectable } from '@nestjs/common';
import * as bcrypt from 'bcrypt';

import { UsersService } from './../../../users/services/users.service';
import { JwtService } from '@nestjs/jwt';
import { User } from './../../../users/entities/user.entity';
import { PayloadToken } from './../../models/token.model';

@Injectable()
export class AuthService {
  constructor(
    private userService: UsersService,
    private jwtService: JwtService,
  ) {}

  async validateUser(email: string, password: string) {
    const user = await this.userService.findByEmail(email);
    if (user) {
      const isMatch = await bcrypt.compare(password, user.password);
      if (isMatch) {
        const token = await this.generateJWT(user);
        return {
          user,
          token,
        };
      }
    }
    return null;
  }

  generateJWT(user: User) {
    const payload: PayloadToken = { role: user.role, sub: user.id };
    return this.jwtService.sign(payload);
  }
}

El controlador :

export class AuthController {
  @UseGuards(AuthGuard('local'))
  @Post('/login')
  @HttpCode(200)
  login(@Req() req: Request) {
    return req.user;
  }
}

Jhon Alexander Perez Ramirez

student•

Hola, estoy corriendolo y me sale el siguiente error.

[Nest] 22416 - 06/14/2023, 5:31:10 PM ERROR [ExceptionHandler] Nest can't resolve dependencies of the JWT_MODULE_OPTIONS (?). Please make sure that the argument CONFIGURATION(config) at index [0] is available in the JwtModule context.

Potential solutions:

If CONFIGURATION(config) is a provider, is it part of the current JwtModule?
If CONFIGURATION(config) is exported from a separate @Module, is that module imported within JwtModule? @Module({ imports: [ /* the Module containing CONFIGURATION(config) */ ] })

Luis David Arias Manjarrez

student•

¿Qué diferencia hay entre inyectar el config de esta forma y leer directamente de el JWT_SECRET desde process.env?

yerson lasso

student•

Entiendo que hace más flexible el cargado de configuraciones, así si quisieras cargar las variables con cualquier otro método solo cambias la lógica de cargue, aunque no se si halla otra razón

Carlos Alberto Angel Angel

student•

En la documentación de nestjs te explica las ventajas de manejar tu archivo de configuración de esta manera. archivos de configuración personalizados

Catalano Nicolas

student•

Como seria para implementar con el proyecto de MongoDB para que no te devuelva la password encriptada?. Vi que en Mongo no se lo devolvió, pero el proyecto de TypeORM si le devolvió el password.

José Bonilla

student•

Quizá no le colocó el decorador @Exclude() al password en la entidad user.

Andres Trujillo

student•

Esta manera de cargar las variables de entorno nos permite poder crear una instancia unica del llamado a las variables de entorno, con esto se minimiza el llamado o peticiones constantes, ah, otra cosa es que podemos diferentes variables de entorno sea: dev, staging o prod!

Implementación de JWT en Módulo de Autenticación con Variables de Entorno

Introducción

Autenticación de Usuarios en APIs con Nest.js y JWT

Configuración de Autenticación en Proyectos Mongo y TimeORM

Implementación de Autentificación y Autorización en API Node.js

Protección con guardianes

Creación y Uso de Guardianes en NestJS para Autorización de Endpoints

Decoradores para Control de Acceso en Controladores NETJS

Gestión de Variables de Entorno en Aplicaciones Node.js

Autenticación con Passport

Hashing de Contraseñas en Bases de Datos con Node.js

Implementación de Hashing en Proyecto Mongo con Node.js

Autenticación con Passport.js en Nest.js: Estrategias Locales

Implementación de Controlador de Login con NestJS y Estrategia Local

Autenticación con JSON Web Tokens

Implementación de JSON Web Tokens en APIs para Autenticación Segura