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

Clase 7 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

¿Cómo se protege una contraseña mediante hashing?

El hashing de contraseñas es esencial para mantener la seguridad de los datos en una base de datos. Este proceso transforma una contraseña en una secuencia irreconocible mediante algoritmos de cifrado. Esto no solo protege la información si alguien accede a la base de datos, sino que también garantiza que ni siquiera los administradores puedan ver las contraseñas reales de los usuarios.

¿Por qué es importante el hashing?

Protección de datos: Impide que atacantes obtengan contraseñas directamente de la base de datos.
Privacidad del usuario: Asegura que ni el administrador ni otras personas vean las contraseñas.
Seguridad adicional: Evita que contraseñas débiles, como '123456', sean fácilmente explotadas.

¿Cómo implementar hashing en NodeJS?

Para implementar correctamente el hashing de contraseñas en un proyecto en NodeJS, es necesario seguir ciertos pasos y utilizar las herramientas adecuadas.

Paso 1: Instalación de la librería de hashing

Utiliza una librería de confianza específicamente diseñada para NodeJS. Asegúrate de instalar también el tipado, ya que muchas librerías no lo incluyen por defecto.

npm install bcrypt
npm install @types/bcrypt --save-dev

Paso 2: Implementación del hashing en el servicio

Una vez instalada la librería, debes integrarla en el servicio donde se gestionan las credenciales del usuario.

import * as bcrypt from 'bcrypt';

async function createUser({ email, password }) {
  // Obtener y generar un hash de la contraseña
  const hashedPassword = await bcrypt.hash(password, 10);
  
  // Guardar el usuario con la contraseña hasheada
  saveUserToDatabase({ email, password: hashedPassword });
}

El proceso de hashing es asíncrono y por eso es importante manejarlo dentro de una función async. Normalmente se utilizan 10 saltos (rondas) para incrementar la complejidad del hashing.

Paso 3: Excluir contraseñas del retorno de consultas

Es importante que las contraseñas no se devuelvan en las respuestas de las API. Usa serialización y otras técnicas para asegurarte de que las contraseñas estén escondidas.

class UserTransformer {
  // Decorador para excluir el campo 'password'
  @Exclude()
  password: string;
}

¿Cómo verificar un usuario con autenticación?

Además del hashing, es vital contar con un mecanismo de búsqueda eficiente para autenticar a los usuarios. Crear un método para buscar por email es crucial.

async function findByEmail(email: string) {
  return userRepo.findOne({ email });
}

Preparación del servicio para la autentificación

Una vez ajustados los métodos, es vital habilitar el servicio para ser consumido desde otros módulos.

@Module({
  exports: [UserService],
})
export class UserModule {}

¿Cómo manejar el hashing en MongoDB?

El proceso de hashing en MongoDB se mantiene similar al de otros sistemas de gestión de bases de datos. La implementación varía dependiendo del ORM o la herramienta que estés utilizando, pero el concepto sigue siendo el mismo: proteger la información de usuario mediante métodos de cifrado robustos.

Siempre mantén tus conocimientos al día y recuerda que la seguridad es un aspecto crucial del desarrollo de software. Con dotarte de estas herramientas y prácticas, brindas a tus usuarios la protección que merecen.

Comentarios

Juan David Merchán Torres

student•

Hola 👋 También podemos hashear la contraseña en la creación y en la actualización automáticamente con este método en su entidad. 🧐

@BeforeInsert()
@BeforeUpdate()
async hashPassword() {
  if (!this.password) return;

  const salt = await bcrypt.genSaltSync(10);

  this.password = await bcrypt.hashSync(this.password, salt);
}

Espero haberles ayudado 🚀

Robert Jarod Meza Garcia

student•

Buen aporte! Gracias

Omar Blanco

student•

Excelente aporte, lo implementare

yerson lasso

student•

En caso de que alguien tenga preocupaciones de seguridad a la hora de traer el usuario con contraseña del DB ( en ocasiones es necesario), con typeORM se puede añadir el atributo “select” en la petición findOne y traer solo los atributos necesarios

const user = await this.userRepo.findOne(
            {
                where: { id },
                select: ["username", "email", "role"] }
            );

Renato Renzo Luna Herrera

student•

esto de aquí me parece mas útil que usar Exclude, muchas gracias.

Miguel Eduardo Pérez Salcedo

student•

Pienso que usar un Exclude es mejor porque indiferentemente de donde mandas a llamar los usuarios ya te vienen sin la contraseña, en cambio de este modo siempre tendrás que indicar que te traía los campos y no la contraseña

También que este ejemplo son solo 3 campos, pero supongamos que tu entidad de usuario tiene 10 campos, vas a tener que escribir 9 solo para sacar 1

Carlos Delgado

student•

Para los que están usando Mongoose y quieren eliminar el password de la respuesta pueden instalar el paquete: npm i nestjs-mongoose-exclude luego en su Entity utilizar el decorador @ExcludeProperty() y por último utilizar un Interceptor a nivel de ruta o del controlador completo quedaría así:

@Prop({ required: true })
  @ExcludeProperty()
  password: string;

@UseInterceptors(
  new SanitizeMongooseModelInterceptor({
    excludeMongooseId: false,
    excludeMongooseV: true,
  }),
)
@Controller('users')

Yonathan Gutierrez

student•

Es probable que el decorador exclude no funcione, para esto se hace necesario añadir el interceptor global de nest...

' app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector))); '

Robert Jarod Meza Garcia

student•

Para poder entender de una manera mas simple el hash, la particularidad de este método de seguridad es que el Hash en si no se desencripta una vez ha sido encriptado. Simplemente se compara el código (o password) ingresado al momento de iniciar sesión con el hash almacenado en la base de datos.

Maximiliano Delgado

student•

npm i bcrypt

npm i -D @types/bcrypt

Daniel Martínez López

student•

Hola!, Estoy teniendo problemas al aplicar el exclude(), lo agrego a mi entidad pero no se está excluyendo. Esta es mi entidad.

@Entity({name: 'users'})
export class User {
    @PrimaryGeneratedColumn()    
    iduser: number;
    
    @Column()    
    username: string;
        
    @Column()
    @Exclude()
    password: string;

    @Column()    
    name: string;

    @Column()    
    avatar: string;

    @Column()    
    createAt: Date;
}

Este es mi controlador

@Get(':id')    
    getOne(
        @Res() res: Response,
        @Param('id', ParseIntPipe) userId: number,
    ) {        
        this.userService.getOne(userId).then((response: User) => {
            return res.status(HttpStatus.OK).json({
                "statusCode": HttpStatus.OK,
                "message": "Usuarios recuperados con éxito",
                "user": response,
            });
        }).catch(response => {
            return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
                "statusCode": HttpStatus.INTERNAL_SERVER_ERROR,
                "message": "Error en el servidor",
                "error": "Error en el servidor"
            });
        });
    }

@Get()
    getMany(
        @Res() res: Response
    ) {        
        this.userService.getMany().then( (response: User[]) => {            
            return res.status(HttpStatus.OK).json({
                "statusCode": HttpStatus.OK,
                "message": "Usuarios recuperados con éxito",
                "users": response
            });
        }).catch(response => {
            return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
                "statusCode": HttpStatus.INTERNAL_SERVER_ERROR,
                "message": "Error en el servidor",
                "error": "Error en el servidor"
            });
        });
        
    }

y este es el servicio

async getOne(idUser: number): Promise<UserDto> {        
        const user = await this.userService.findOne({
            where: {
               iduser: idUser
            }
        });
        user.apps = await this.appUserService.find({
            select: ['idapp_user'],
            relations: ['application', 'role'],
            where: {
                iduser: user.iduser
            }
        });

        return user;
    }

    getMany(): Promise<UserDto[]> {        
        return this.userService.find();
    }

Que podría estar haciendo mal?, gracias por su ayuda.

Allan Jair Escamilla Hernández

student•

Hola Daniel, ya agregaste en tu archivo main.ts la siguiente linea?

app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)));

Esto debe de ir antes del app.listen.

Saludos!!

Daniel Antonio

student•

Creo que una forma mas limpia seria hacer un pipe que realice un hashing de la contraseña.

Miguel Eduardo Pérez Salcedo

student•

Los pipe son clases que se ejecutan en los argumentos de nuestros controladores y el hashing de contraseña tiene que ser algo que se haga justo antes de la creación del usuarios ya que si en nuestro servicio tenemos otros tipos de validaciones y alguna no pasa pues de nada nos sirve consumir recursos en el hashing si igual no lo usaramos

por eso pienso que sería algo que se haría justo antes del guardado, que ya todo lo que se este validando haya pasado correctamente

Lluis Pitarch Ripolles

student•

En el caso de Mongo para hacer el findOne

  async findByMail(email: string) {
    return await this.UserModel.findOne({ where: { email: email } });
  }

Naldo Duran

student•

👏

Claudio Anibal Morales Pérez

student•

npm i bcrypt

@Entity({name: 'users'})
export class User {
    @PrimaryGeneratedColumn()    
    iduser: number;
    
    @Column()    
    username: string;
        
    @Column()
    @Exclude()
    password: string;

    @Column()    
    name: string;

    @Column()    
    avatar: string;

    @Column()    
    createAt: Date;
}

@Get(':id')    
    getOne(
        @Res() res: Response,
        @Param('id', ParseIntPipe) userId: number,
    ) {        
        this.userService.getOne(userId).then((response: User) => {
            return res.status(HttpStatus.OK).json({
                "statusCode": HttpStatus.OK,
                "message": "Usuarios recuperados con éxito",
                "user": response,
            });
        }).catch(response => {
            return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
                "statusCode": HttpStatus.INTERNAL_SERVER_ERROR,
                "message": "Error en el servidor",
                "error": "Error en el servidor"
            });
        });
    }

@Get()
    getMany(
        @Res() res: Response
    ) {        
        this.userService.getMany().then( (response: User[]) => {            
            return res.status(HttpStatus.OK).json({
                "statusCode": HttpStatus.OK,
                "message": "Usuarios recuperados con éxito",
                "users": response
            });
        }).catch(response => {
            return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
                "statusCode": HttpStatus.INTERNAL_SERVER_ERROR,
                "message": "Error en el servidor",
                "error": "Error en el servidor"
            });
        });
        
    }

async getOne(idUser: number): Promise<UserDto> {        
        const user = await this.userService.findOne({
            where: {
               iduser: idUser
            }
        });
        user.apps = await this.appUserService.find({
            select: ['idapp_user'],
            relations: ['application', 'role'],
            where: {
                iduser: user.iduser
            }
        });

        return user;
    }

    getMany(): Promise<UserDto[]> {        
        return this.userService.find();
    }

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

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