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

Clase 8 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 implementar la técnica de hashing en un proyecto Mongo?

El hashing es una técnica esencial para la seguridad de las contraseñas en las bases de datos. La implementación correcta asegura que las contraseñas almacenadas estén protegidas, incluso si la base de datos es comprometida. Aquí se explica paso a paso cómo aplicar el hashing en un proyecto basado en MongoDB usando la librería bcrypt.

¿Cómo instalar la librería bcrypt?

Para comenzar, es necesario instalar la librería bcrypt. Esta librería permite realizar el hashing de contraseñas de manera eficiente y segura. Sigue estos pasos:

Instala bcrypt junto con su tipado (para TypeScript), utilizando el siguiente comando:
```
npm install bcrypt
npm install @types/bcrypt --save-dev
```
Asegúrate de que la instalación del tipado es solo para el entorno de desarrollo.

¿Cómo modificar el servicio de usuarios?

La lógica para manejar contraseñas debe ser incorporada en el servicio de usuarios de tu aplicación. Aquí es donde se recibe la contraseña y se realiza el hashing antes de guardarla en la base de datos.

Importa la librería en el archivo del servicio.
```
import * as bcrypt from 'bcrypt';
```

Implementa el hashing en el método de creación de usuarios antes de guardar los datos.

const hashPassword = await bcrypt.hash(newModel.password, 10);
newModel.password = hashPassword;

Es fundamental hacer que el método sea asíncrono debido al uso de promesas con await.

¿Cómo excluir la contraseña de las respuestas?

Aunque las contraseñas ya estén hashadas, aún es una buena práctica no incluirlas en las respuestas del API.

Usa desestructuración para quitar el password del objeto antes de devolver la respuesta.
```
const { password, ...rta } = userModel.toJSON();
```
Devuelve únicamente la información necesaria al cliente.

¿Cómo probar el funcionamiento?

Usa herramientas como Insomnia para realizar peticiones al API y asegúrate de que las contraseñas no se incluyen en las respuestas. Comprueba que:

Al crear un nuevo usuario, la contraseña se almacena en la base de datos en formato hash.
La respuesta del API no debe incluir la contraseña, ni siquiera en forma hash.

¿Cómo buscar un usuario por email de forma segura?

Para futuras implementaciones, como la autenticación, necesitarás métodos que busquen usuarios sin comprometer la seguridad:

Implementa un método que busque usuarios usando su email:

async findByEmail(email) {
  return this.userModel.findOne({ email }).exec();
}

Asegúrate de usar findOne para evitar que se devuelvan múltiples resultados, dado que los emails deben ser únicos en la base de datos.

¿Cómo exportar el servicio para su uso en otros módulos?

El servicio debe ser accesible desde otros módulos, como el de autenticación, para funciones como verificar usuarios:

Exporta el servicio de usuarios desde su módulo:

export class UserService {
  // Métodos aquí
}

Asegúrate de que otros módulos pueden importar y utilizar el servicio sin problemas.

Este proceso de implementación garantiza que las contraseñas de los usuarios estén protegidas y el sistema sea seguro. ¡Continúa practicando y mejorando tus habilidades! Recuerda que la seguridad es esencial en cualquier aplicación.

Comentarios

Carlos Delgado

student•

Otra forma para 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')

Daniel Muñoz Martín

student•

Gran aporte! En lo personal me gusta más tu solución.

James Diaz Lopez

student•

Confirmo, funciona muy bien.

Rony Porraz Vargas

student•

Si quieres loguear a sus usuarios y no quieres devolver el password a la respuesta podrian hacer la busqueda asi

 const userToFind = await this.userModel.findOne({ email : user.email }).select("-password")

Eso les devolvera todo el objeto del usuario menos el password

Juan David Merchán Torres

student•

Hola 👋 Yo implementaria algo mas reutilizable y que no toca al users.services. Estando en el user.entity agregaria una funcion al metodo con el metodo pre de UserSchema y sobreescribiria el metodo toJSON del UserScham.

// user.entity.ts

...
UserSchema.pre('save', async function (next: HookNextFunction) {
  const user = this as User;

  // only hash the password if it has been modified (or is new)
  if (!user.isModified('password')) return next();

  // Random additional data
  const salt = await bcrypt.genSalt(10);

  const hash = await bcrypt.hash(user.password, salt);

  // Replace the password with the hash
  user.password = hash;

  return next();
});

Hasheara el password en la creacion y en la modificacion de la misma.

// usersentity.ts
....

UserSchema.methods.toJSON = function () {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const { __v, password, ...user } = this.toObject();

  return user;
};

Sobreescribira un poco el metodo toJSON para que ignore el password y en este caso el __v al imprimir el usuario en cualquier tipo de retorno del mismo, esto lo hace super reutilizable y no tendremos que tocar nunca mas la config.

Y nuestro users.service esta intacto

 async create(payload: CreateUserDto) {
    const newUser = new this.userModel(payload);

    return await newUser.save();
  }

Espero haberles aportado algo 🚀

Samuel R.

student•

No podría llamarle reutilizable a los pre middlewares de mongoose, dado que se esta acoplando lógica a la entidad (por lo tanto a la base de datos) y hay casos puntuales en los que los pre middlewares no son accionados o llamados, ejemplo: un update many o un updateOne con set directo, esto es algo para tener en cuenta y evaluar con el equipo de desarrollo. (Como una nota: se puede hacer genérica la función para todos los pre middlewares disponibles, pero no creo que lo valga, igual es cosa que se evalué con el equipo de desarrollo).

El caso del toJSON, lo encuentro útil (salvo que en queries de tipo lean, este no funciona).

El caso genérico que se me ocurre es:

Marcar la propiedad del schema como {select: false} de acuerdo a la documentación de mongoose.
Posterior es forzar la selección del password, que para la autenticación es un caso especial (por lo general siempre no es seleccionado en las consultas tipo find({})).
Y finalmente eliminar en el servicio o un repositorio como se ve en la clase para mantener desacoplado lo relacionado a la BD.

Igual espero aportarles algo 👨🏾‍💻

Diego Miguel Gonzalez Calero

student•

Otra forma para esconder el password es agregando la siguiente configuración en el user.entity:

@Prop({ type: String, required: true, select: false })
  password: string;

Con select: false indicamos que todas las peticiones de los usuarios vendrán sin el password :)

Juan Camilo Noreña López

student•

Muy buena solución, ya que como si lo haciamos como el profe solo nos funciona al crear y no en todas las consultas. alguna forma de no retornar el '_v':0 ?

Maximiliano Delgado

student•

npm i bcrypt

npm i -D @types/bcrypt

Ernán Alexander Velásquez Ramírez

student•

La mejor forma de excluir los password lo encontré en la documentación de NestJs:

Lorenzo Gómez

student•

Una alternativa para devolver el objeto sin la contraseña podría ser usar la Keyword Delete de JS

delete model.password

Efrén Ruíz Rubio

student•

Con el decorador @Schema se puede modificar el método toJSON que mongoose usa en la entidad / Modelo de mongoose:

//user.entity.ts

import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { Document, Types } from "mongoose";

@Schema({
  toJSON: {
    transform: (_document, returnedObject) => {
      returnedObject.id = returnedObject._id;
      delete returnedObject._id;
      delete returnedObject.__v;
      delete returnedObject.password;
    },
  },
})

De esta manera también se pueden borrar los elementos de la consulta que regresa mongoose.

José Porfirio Carrillo Echenique

student•

Yo lo hice así en ambos, TypeORM y Mongoose:

  @Exclude()
  @Prop({ required: true, minlength: 6 })
  password: string;

Y solucionando el asunto. Recuerden que class-transformer funciona dentro del controlador. Que es lo que realmente interactuá con cliente.

Tulio Junior Rangel Nuñez

student•

Sigo las instrucciones y me sale este error:

src/users/services/users.service.ts:42:13 - error TS2339: Property 'password' does not exist on type '{ (options: ToObjectOptions & { flattenMaps: false; }): LeanDocument<User & { _id: any; }>; (options?: ToObjectOptions): FlattenMaps<...>; <T = FlattenMaps<...>>(options?: ToObjectOptions): T; }'.

42     const { password, ...rta } = staging.toJSON;
               ~~~~~~~~

[12:35:01 p. m.] Found 1 error. Watching for file changes.

Y si en realidad password no existiera no debería hacer el hash, cosa que sí hace.

Carlos Enrique Ramírez Flores

student•

Una opción rapida para excluir propiedades es:

findAll() { ``return this.userModel.find({}, { __v: 0, password: 0 }); }

Carlos Enrique Ramírez Flores

student•

findAll() {

return this.userModel.find({}, { __v: 0, password: 0 });

}

Diego Ivan Nacimiento

student•

Para eliminar password en el método create del servicio:

users.service.ts:

async create(payload: CreateUserDto) {
    const newUser = new this.userModel(payload);

    // Hasheamos la contraseña y la guardamos en una variable
    const hashedPassword = await bcrypt.hash(newUser.password, 10);

    // Actualizamos la propiedad password de newUser por hashedPassword
    newUser.password = hashedPassword;

    // Guardamos
    const userSaved = await newUser.save();

    // Creamos una variable que guarde el usuario en formato JSON
    const user = userSaved.toJSON();

    // Eliminamos la contraseña
    delete user.password;

    // Retornamos el user
    return user;
  }

Y luego para que en las demás peticiones http (Get, Put y Delete) no aparezca la propiedad password

Debemos ir al archivo user.entity.ts y agregar:

user.entity.ts:

@Schema()
export class User extends Document {

  @Prop()
  email: string;

  // Ponemos select en false
  @Prop({ select: false })
  password: string;

  @Prop()
  role: string;
}

// user.entity.ts

...
UserSchema.pre('save', async function (next: HookNextFunction) {
  const user = this as User;

  // only hash the password if it has been modified (or is new)
  if (!user.isModified('password')) return next();

  // Random additional data
  const salt = await bcrypt.genSalt(10);

  const hash = await bcrypt.hash(user.password, salt);

  // Replace the password with the hash
  user.password = hash;

  return next();
});

// usersentity.ts
....

UserSchema.methods.toJSON = function () {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const { __v, password, ...user } = this.toObject();

  return user;
};

//user.entity.ts

import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { Document, Types } from "mongoose";

@Schema({
  toJSON: {
    transform: (_document, returnedObject) => {
      returnedObject.id = returnedObject._id;
      delete returnedObject._id;
      delete returnedObject.__v;
      delete returnedObject.password;
    },
  },
})

src/users/services/users.service.ts:42:13 - error TS2339: Property 'password' does not exist on type '{ (options: ToObjectOptions & { flattenMaps: false; }): LeanDocument<User & { _id: any; }>; (options?: ToObjectOptions): FlattenMaps<...>; <T = FlattenMaps<...>>(options?: ToObjectOptions): T; }'.

42     const { password, ...rta } = staging.toJSON;
               ~~~~~~~~

[12:35:01 p. m.] Found 1 error. Watching for file changes.

async create(payload: CreateUserDto) {
    const newUser = new this.userModel(payload);

    // Hasheamos la contraseña y la guardamos en una variable
    const hashedPassword = await bcrypt.hash(newUser.password, 10);

    // Actualizamos la propiedad password de newUser por hashedPassword
    newUser.password = hashedPassword;

    // Guardamos
    const userSaved = await newUser.save();

    // Creamos una variable que guarde el usuario en formato JSON
    const user = userSaved.toJSON();

    // Eliminamos la contraseña
    delete user.password;

    // Retornamos el user
    return user;
  }

Implementación de Hashing en Proyecto Mongo 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

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