Cursos Empresas Blog Live Conf Eventos Precios

0:008:11

Recursos

Resumen

¿Cómo se implementa el hashing de contraseñas en endpoints de usuario y cliente?

Cuando trabajamos con datos sensibles como contraseñas, es imperativo asegurarse de que sean almacenados de manera segura. En este contenido, exploraremos cómo se puede integrar el hashing de contraseñas en una API para mejorar la seguridad tanto al crear usuarios como clientes.

¿Qué pasos se deben seguir para hash las contraseñas al crear un usuario?

En primer lugar, es vital que las contraseñas no se almacenen en texto plano dentro de nuestra base de datos. Utilizando una librería como Bcrypt para encriptar contraseñas es una práctica común. La implementación requiere los siguientes pasos:

Importar la librería Bcrypt: Esto se logra añadiendo la línea de importación correspondiente en el archivo del servicio de usuarios.
Generar el hash: Antes de almacenar la contraseña en la base de datos, se genera un hash de la contraseña original utilizando un método provisto por Bcrypt. Aquí un ejemplo en JavaScript:
```
const bcrypt = require('bcrypt');
const saltRounds = 10;

function hashPassword(password) {
  return bcrypt.hash(password, saltRounds);
}
```
Reemplazar la contraseña por el hash en el objeto usuario: Una vez generado el hash, se sustituye la contraseña original por el hash antes de almacenar el usuario en la base de datos:
```
const newUser = {
  ...userData,
  password: hashedPassword,
};
```
Verificar que el password no se retorne: Asegúrate de no devolver la contraseña (ni siquiera el hash) al cliente una vez creado el usuario. Utiliza delete para eliminar el campo password:
```
delete newUser.password;
```

¿Cómo se aplica el hash en el endpoint de creación de clientes?

La lógica de encriptación también se aplica cuando se están creando clientes. Estos pasos aseguran que las contraseñas relacionadas continúan utilizando hashing, manteniendo los datos seguros:

Clonar y modificar el objeto de datos: Al crear un cliente, clonar el objeto contenido y aplicar el hash al sub-objeto correspondiente:
```
const cloneData = { ...data };
cloneData.user.password = await hashPassword(cloneData.user.password);
```
Eliminar el campo de password en la respuesta: Aplicar la misma estrategia de eliminación para que la contraseña no sea parte de la respuesta devuelta al cliente:
```
delete cloneData.user.password;
```

¿Qué beneficios ofrece este enfoque?

Implementar el hashing de contraseñas ofrece varios beneficios de seguridad:

Reducción de riesgo: Minimiza el riesgo de exposición en caso de filtraciones de datos.
Cumplimiento de normativas: Ayuda a cumplir regulaciones de protección de datos que exigen la protección de información sensible.
Confianza del usuario: Mejora la confianza del usuario en el manejo seguro de sus datos personales.

Al finalizar la configuración del hashing para la implementación detallada, se está listo para proceder a desarrollar funcionalidades avanzadas como endpoints de login y autenticación basados en tokens seguros. Siempre es fundamental estar un paso adelante en temas de seguridad dentro de tu API.

Implementación de Hashing en Endpoints de Usuario y Cliente

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 6 / 20

Ver clases

Implementación de Hashing en Endpoints de Usuario y Cliente

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 6 de 20

Clase 6 / 20

Implementación de Hashing en Endpoints de Usuario y Cliente

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 6 / 20

Ver clases

Maria Gabriela Rodriguez Cuevas#4647168

➕# Clase #6: Implementando hashing para usuarios 6/20 ➕

Continuando con el Proyecto: 📝

Se va a realizar el hashing tanto para los usuarios (users) y clientes (customers), para ello vamos a VSC, buscamos la carpeta services, luego abrimos el archivo user.service.js, se modificará la función de crear usuario, se necesitará importar en la cabecera el bcrypt para la encriptación:

const bcrypt = require('bcrypt');

La función create(data) queda:

async create(data) {
    //El password viene de data.password
    const hash = await bcrypt.hash(data.password, 10);
    const newUser = await models.User.create({
      //Se clona todo el objeto con data
      ...data,
      //Se asigna el password
      password: hash
    });
    //Con el delete se elimina el password de la respuesta para no mostrar el password en pantalla
    //Lo elimina de dataValues
    delete newUser.dataValues.password;
    return newUser;
  }

Guardamos, vamos a la terminal y en caso de que no se haya levantado docker ni pgAdmin, hacerlo con:

docker-compose up -d postgres

docker-compose up -d pgadmin

Luego correr con dev:

npm run dev

Abrir Insomnia, e ir a la carpeta users, con la opción dev para la dirección de la API, vamos al POST de users y colocamos en el JSON:

{
	"email": "admin @ mail. com",
	"password": "12356 .2019",
	"role": "admin"
}

Al enviar (Send) en la salida debe estar el código 201 Created con:

{
	"createdAt": "2023-03-16T23:16:53.124Z",
	"id": 1,
	"email": "admin @ mail. com",
	"role": "admin"
}

Nota: No sale el password impreso ya que se agregó el código el método delete para borrar en la respuesta el hash del password. En cuanto a customer, dentro de la carpeta services la función create(data) queda:

async create(data) {
    //Se crea el hash
    const hash = await bcrypt.hash(data.user.password, 10);
    //Se hace un clonación de data
    const newData = {
      ...data,
      //Se sobreescribe el sujeto user
      user: {
        ...data.user,
        //Se modifica el password
        password: hash
      }
    }
    const newCustomer = await models.Customer.create(newData, {
      include: ['user']
    });
    delete newCustomer.dataValues.user.dataValues.password;
    return newCustomer;
  }

Nota: Tomar en cuenta que en éste caso tenemos anidado la creación de un customer.

Guardamos, con la terminal corriendo: npm run dev
Vamos a Insomnia, ir a la carpeta customers, con la opción dev para la dirección de la API, vamos al POST de customers y colocamos en el JSON:

{
	"name": "Santiago",
	"lastName": "Molina",
	"phone": "9898",
	"user": {
		"email": "santi @ mail.
com",
		"password": "23 23 23"
	}
}

Al enviar (Send) en la salida debe estar el código 201 Created con:

{
	"createdAt": "2023-03-16T23:37:01.327Z",
	"id": 1,
	"name": "Santiago",
	"lastName": "Molina",
	"phone": "9898",
	"user": {
		"role": "customer",
		"createdAt": "2023-03-16T23:37:01.328Z",
		"id": 2,
		"email": "santi @ mail. com"
	},
	"userId": 2
}

Nota: No sale el password impreso ya que se agregó el código el método delete para borrar en la respuesta el hash del password.

Comentarios (38)38 comentarios

Carlos Alberto Angel Angel

Hace 5 años

Pueden utlizar los hooks con sequelize para que realice el hash de la contraseña antes de guardar los datos. Solo tienes que agregar la opción hooks en el método config de la clase User que se encuentra en user.model.js

static config(sequelize) {
    return {
      sequelize,
      tableName: USER_TABLE,
      modelName: 'User',
      timestamps: false,
      hooks: {
        beforeCreate: async (user, options) => {
          const password = await bcrypt.hash(user.password, 10);
          user.password = password;
        },
      }
    };
  }

De esta forma puedes evitar realizar el hash en los servicios user y customer y dejarlos como estaban anteriormente.

Niller David Yanes Diaz

Excelente aporte !!

Ricardo Rito Anguiano

Tu aporte fue genial, me encato esta forma de hacerlo :D

Fredy Reyes

Resolviendo Reto

Para poder resolver este reto lo que debemos de hacer entrar al objeto de dataValues luego al objeto de usuario y por ultimo al objeto de usuario. Y ya podemos acceder a la propiedad de contraseña para proceder a borrarla.

Codigo

delete newCustomer.dataValues.user.dataValues.password;
return newCustomer;

Felipe Mireles Cruz

jajja, así mismo lo hice, excelente!

Sebastian Pacheco Lopez

Hace 4 años

yo lo hice solo poniendo un dataValue despues de user y tambien me sirvio:

delete newCustomer.user.dataValues.password;

Hi! I'm practicing my english. So I will post my notes:

There are too many ways to encrypt passwords, but we are going to do it through models hooks.

To encrypt a password before being send to the database, just add a hook in model.config

static config(sequelize) {
        return {
            sequelize,
            tableName: USER_TABLE,
            modelName: 'User',
            timestamps: false,
            **hooks: {
                beforeCreate: async(user) => {
                    const password = await bcrypt.hash(user.password, 10);
                    user.password = password;
                },
            }**
        }
    }

(This part of the code was made by @Carlos Alberto Angel Angel, some comments above this)

This is good! But when we create a password, user will receive the hash too, so we need to delete it from the info that will be sent.

In user.service: We delete password from dataValues when object is created

async create(data) {

        const newUser = await models.User.create(data);
        //Delete password to don't send it when created
        **delete newUser.dataValues.password;**
        return newUser;
    }

Juan Jiménez

Se debe hacer hashing por el lado de users y customers para guardar la contraseña hasheada en la base de datos, para ello modificamos la parte del servicio en ambos lados.

user.service.js, en esta parte se usa delete newUser.dataValues.password para que la respuesta no devuelva la password al crear un usuario:

async create(data) {
    const hash = await bcrypt.hash(data.password, 10);
    const newUser = await models.User.create({
      ...data,
      password: hash,
    });
    delete newUser.dataValues.password;
    return newUser;
  }

customer.service.js, lo que se hace es clonar la información (data) y al subobjeto le pasamos la información y específicamente el password (hash). Se usa delete newCustomer.user.dataValues.password para que la respuesta no devuelva la password al crear un cliente (ligado a usuario):

async create(data) {
    const hash = await bcrypt.hash(data.user.password, 10);
    const newData = {
      ...data,
      user: {
        ...data.user,
        password: hash,
      },
    };
    const newCustomer = await models.Customer.create(newData, {
      include: ['user'],
    });
    delete newCustomer.user.dataValues.password;
    return newCustomer;
  }

Ian Vassallo

Si usas sequelize, mejor usa la serialización que viene por defecto para excluir atributos, y el scope para poder usar todos:

{
    sequelize,
    modelName: 'User',
    tableName: 'users',
    defaultScope: {
      attributes: {
        exclude: ['password']
      }
    },
    scopes: {
      allProperties: {
        attributes: ['id', 'email', 'name','password',]
      }
    }
  }

Andrés Muñoz

Si haces esto a nivel de modelo, que haces cuando necesites el password guardado en la base para compararlo con el del usuario ?

Eber Edrey Alejo Berrones

Por si no entendieron el scope por defecto no muestra el password para poder acceder al password utilizamos

User.scope('allProperties').findByPk(1)

David Fernando Basto Martinez

Podemos excluir el password de las consultas que incluyan el User cambiando el defaultScope, y si necesitamos hacer una consulta con el password podemos crear otro scope

static config(sequelize){
    return {
      sequelize,
      tableName: USER_TABLE,
      modelName: 'User',
      timestamps: false,
      hooks: {
        beforeCreate: async (user) => {
          const password = await bcrypt.hash(user.password, 10);
          user.password = password;
        },
      },
      defaultScope: {
        attributes: { exclude: ['password'] },
      },
      scopes: {
        withPassword:{ attributes: {}, }
      },
    }
  }

Para realizar las consulta con el scope withPassword:

const user = await models.User.scope("withPassword").findByPk(id);

David Esteban Giraldo Duque

Hace 3 años

Excelente aporte

Miguel Ángel Baquero Tello

Para eliminar el password de la respuesta, simplemente colocar esto antes del return:

  delete newCustomer.user.dataValues.password;
  return newCustomer;
}

Jose Ever Muñoz Muñoz

Hace 2 años

tambien debes poner newCustomer.dataValues.user...

Maria Gabriela Rodriguez Cuevas

Alfonso Ricaurte Riveros

Muchisimas gracias por estros aportes.

Rafael Ricardo Pinto Díaz

entiendo que el hash para un valor determinado es siempre el mismo, por lo tanto si dos usuarios tienen la misma contraseña el hash sería el mismo, esto hace vulnerable a la aplicación porque sería posible de cierta manera identificar los usuarios que tienen la misma contraseña. Sugiero que al construir el hash se concatene el nombre de usuario al hash y con esto se obtiene un hash único por usuario aunque tengan claves iguales.

Diego Andres Cabrera Rojas

Hola Rafael , Estuve intentando ejecutar la rutina para encriptar contraseñas con bcrypt y observe un comportamiento totalmente contrario a lo que expones , es decir con la misma contraseña ejecute varias veces la rutina y siempre arrojaba valores distintos , no obtuve ningun resultado idéntico , por lo tanto aunque la contraseña sea la misma bcrypt la esta encriptando de forma diferente.

tranky sas

El nombre tampoco sería un valor único, todos modos ese valor de hash cambia constantemente, no es el mismo

Nicolas Arbelaez

En lugar de eliminar manualmente el atributo password con:

delete newUser.dataValues.password
```puedes aprovechar la funcionalidad nativa que ofrecen tanto SQL como Sequelize.

**Con SQL**, por ejemplo, puedes insertar una fila y que se retornen solo los campos deseados:
```js
INSERT INTO productos (email, password, role)
VALUES ('email@mail.com', 'password123', 'admin')
RETURNING email, role;
```De esta forma, la base de datos se encarga de devolver únicamente los campos `email` y `role`, excluyendo `password`.

**Con Sequelize**, puedes lograr un comportamiento similar al crear un nuevo usuario. Al utilizar la opción `attributes` con `exclude`, indicas que deseas omitir el atributo `password` en el objeto resultante:
```js
const newUser = await models.User.create({
  ...data,
  password: hash
},{
  attributes: {
    exclude: ['password']
  }
})
```Este enfoque te permite evitar la manipulación manual del objeto devuelto, confiando en las funcionalidades nativas de Sequelize y de la base de datos para gestionar los campos que deseas incluir en la respuesta.

delete newUser.dataValues.password;

puedes aprovechar la funcionalidad nativa que ofrecen tanto SQL como Sequelize. **Con SQL**, por ejemplo, puedes insertar una fila y que se retornen solo los campos deseados:

INSERT INTO productos (email, password, role)VALUES ('email@mail.com', 'password123', 'admin')RETURNING email, role;

De esta forma, la base de datos se encarga de devolver únicamente los campos email y role, excluyendo password. **Con Sequelize**, puedes lograr un comportamiento similar al crear un nuevo usuario. Al utilizar la opción attributes con exclude, indicas que deseas omitir el atributo password en el objeto resultante:

*const* newUser = await models.User.create(  {    ...data,    password: hash,  },  {    attributes: {      exclude: \["password"],    },  });

Este enfoque te permite evitar la manipulación manual del objeto devuelto, confiando en las funcionalidades nativas de Sequelize y de la base de datos para gestionar los campos que deseas incluir en la respuesta.

Diego Fernando Enriquez Bernal

Hace un año

Bro, lo intente pero igual deja la contraseña, al parecer esto solo sirve en findAll() y findByPk() pero no en create().

Andrés Argote

Yo lo hice con MongoDB y para eliminar el campo de password en las solicitudes es tan sencillo como lo siguiente:

const userSchema = new Schema(
  {
    email: {
      type: String,
      required: true,
      unique: true,
    },
    password: {
      type: String,
      required: true,
    },
  },
  { timestamps: true }
);

userSchema.methods.toJSON = function () {
  const user = this.toObject();
  delete user.password;
  return user;
}

const User = mongoose.model('User', userSchema);

module.exports = User;

Algo así también se puede hacer con Sequelize y Postgres. Cuando se define la clase del modelo, se puede sobreescribir el método toJSON() de la clase Model para obtener el comportamiento deseado. Quedando la clase de la siguiente manera:

class User extends Model {
  static associate(models) {
    this.hasOne(models.Customer, { as: 'customer', foreignKey: 'userId' });
  }

  static config(sequelize) {
    return {
      sequelize,
      tableName: USER_TABLE,
      modelName: 'User',
      timestamps: false,
      hooks: {
        beforeCreate: async (user, _options) => {
          const password = await bcrypt.hash(user.password, 10)
          user.password = password
        },
      },
    };
  }

  toJSON() {
    const values = { ...this.get() };
    delete values.password;
    return values;
  }
}

Sin embargo, creo que es mejor utilizar scopes para poder tener varios comportamientos en diferentes contextos:

class User extends Model {
  static associate(models) {
    this.hasOne(models.Customer, { as: 'customer', foreignKey: 'userId' });
  }

  static config(sequelize) {
    return {
      sequelize,
      tableName: USER_TABLE,
      modelName: 'User',
      timestamps: false,
      hooks: {
        beforeCreate: async (user, _options) => {
          const password = await bcrypt.hash(user.password, 10)
          user.password = password
        },
      },
      defaultScope: {
          attributes: {
            exclude: ['password']
          }
      },
      scopes: {
          withPassword: { attributes: {} }
      }
    };
  }
}

Kevin Palma

El tema de eliminar el password es interesante pero yo vengo un poco de django y con rest_framework, y en los serializaers podemos definir que campos mostrar, y sequelize tiene esta opción, por lo que muestro mi código para que conozcan un poco mas..!

User Service

// Crea un nuevo usuario y lo retorna
  async create(body) {
    let password_hashed = await bcrypt.hash(body.password, 10)
    body.password = password_hashed
    const newUser = await models.User.create(body);
    if (body.profile) {
      const profile = await models.Profile.create({...body.profile, userId: newUser.id})
    }
    if (body.address) {
      const address = await models.Address.create({...body.address, userId: newUser.id})
    }
    return await this.getOne(newUser.id);
  }
// Retorna un usuario por su primaryKey
  async getOne(id) {
    const user = await models.User.findByPk(id, {
      attributes: ['id', 'email', 'role', 'isActive', 'isAdmin', 'isStaff'],
      include: [
        {
          association: 'profile',
          attributes: ['name', 'lastName', 'image', 'phone']
        },
        {
          association: 'address',
          attributes: ["postalCode", "country", "city", "description", "reference"]
        }
      ],
    })
    if (!user) {
      throw boom.notFound(`User with id:${id} not exits..!`)
    }
    return user
  }

En donde no se si esta mal realizar otra petición, sin embargo creo que era lo mejor para reducir código..!

Yo no use customer al contrario use Profile

Profile Service

 // Crea un nuevo perfil y lo retorna
  async create(body) {
    if (body.user) {
      let password_hashed = await bcrypt.hash(body.user.password, 10)
      body.user.password = password_hashed
    }
    const newProfile = await models.Profile.create(body, {
      attributes: ['id', 'name', 'lastName', 'image', 'phone', 'userId'],
      include: ['user']
    });
    return await this.getOne(newProfile.id);
  }

  // Retorna un perfil por su primaryKey
  async getOne(id) {
    const profile = await models.Profile.findByPk(id, {
      attributes: ['id', 'name', 'lastName', 'image', 'phone', 'userId'],
      include: {
        association: 'user',
        attributes: ['id', 'email', 'role', 'isActive', 'isAdmin', 'isStaff']
      }
    });
    if (!profile) {
      throw boom.notFound(`Profile with id:${id} not exits..!`);
    };
    return profile
  }

Como se observa le podemos decir que atributos o campos mostrar y de esta misma manera para los includes..! Espero a alguien le sirva..!

Edgar Alejandro España Amaya

Eliminar el password de la respuesta =>

Luis Fernando Morla Mora

de pronto al ejecutar docker-compose ps me deja de mostrar los contenedores! alguien sabe por que sucede esto?

Brandon Lee Aguero Fernandez

Debe ser porque no tienes ningún contenedor activo

usa solamente docker ps

John Alejandro Agudelo Holguín

Hola, me genera la duda es que si toda la encriptación se hace del lado del servidor significa que la información desde el cliente se envia "cruda"? esto no es un riesgo para un posible ataque Man In the Middle?

Tienes razón por eso es importante usar HTTPS(HyperText Transfer Protocol Secure) en lugar de HTTP

Carlos Luis Marin

hola tengo un problema con pgadmin, levanto con docker tanto postgres como pgadmin, sin embargo, cuando voy al puerto 5050, en la columna derecha donde dice server al desplegarlo no tiene contenido, aún así está funcionando la base de datos cuando voy a insomnia. Quién le ha pasado lo mismo que me pueda ayudar. Gracias

Nazareno

En ese mismo panel anda a Object->create->server dale el name que quieras y anda a la pestaña Connection y completa lo siguiente: Host: vas a ir a la terminal y vas a escribir 'docker ps' y vas a copiar el id del servicio de postgres y ahora vas a escribir 'docker inspect id' te va a salir mucha info, cerquita del final vas a encontrar algo el "IPAddress" en mi caso "172.18.0.2". Esta es la direccion que vas a poner en el campo Host Port: 5432 Maintenence database: (como esta) postgres Username: el username que tengas en tu .env (es el de la base de datos) Password: el password que tengas en tu .env (es la password de la base de datos)

Finalmente apretas el boton Save y listo

Ernán Alexander Velásquez Ramírez

En HOST sugiero utilizar "host.docker.internal" en vez de la IP, así no tienes que estar cambiando la ip cada vez que inicias sessión en wsl o linux.

MATEO FLOREZ ARROYO

delete newCustomer.dataValues.user.dataValues.password;

Esta fue la manera en que elimine yo la propiedad 'password', este código pertenece a mi servicio de 'customers'.

  async findAll() {
    const rta = await models.Customer.findAll({
      include: [
        {
          association: "user",
          attributes: { exclude: ["createdAt", "updatedAt", "password"] },
        },
      ],
      attributes: { exclude: ["createdAt", "updatedAt"] },
    });
    return rta;
  }

  async findOne(id) {
    const rta = await models.Customer.findByPk(id, {
      include: [{ association: "user", attributes: { exclude: "password" } }],
    });
    if (!rta) throw boom.notFound("Customer not Found");
    return rta;
  }

En mi caso yo creo a los 'customers' desde 'users'

Jose Valencia

sencillamente agregue el user antes del dataValues y funciono

este es el resultado

Existe algún problema si asigna el hash al user.password por referencia, o es menos propenso a bugs como se lo realiza en la clase ?

async create(data) {
    data.user.password = await bcrypt.hash(data.user.password, 10)
    const newCustomer = await models.Customer.create(
      data,
      {include: ['user']}
    );
    delete newCustomer.dataValues.user.dataValues.password;
    return newCustomer;
  }

Si el código funciona, no tendría que, pero no es recomendable por la legibilidad del código como tal

Recursos

Resumen

Implementación de Hashing en Endpoints de Usuario y Cliente

Implementación de Hashing en Endpoints de Usuario y Cliente

Implementación de Hashing en Endpoints de Usuario y Cliente

Progreso del curso

Introducción

Protección de contraseñas

Passport y JSON Web Tokens

Envío de emails con Node.js

Recuperación de contraseñas

Despliegue a producción

Próximos pasos

Implementación de Hashing en Endpoints de Usuario y Cliente

Implementación de Hashing en Endpoints de Usuario y Cliente

Recursos

Resumen

¿Cómo se implementa el hashing de contraseñas en endpoints de usuario y cliente?

¿Qué pasos se deben seguir para hash las contraseñas al crear un usuario?

¿Cómo se aplica el hash en el endpoint de creación de clientes?

¿Qué beneficios ofrece este enfoque?

Comentarios

Resolviendo Reto

Codigo

Recursos

Resumen

¿Cómo se implementa el hashing de contraseñas en endpoints de usuario y cliente?

¿Qué pasos se deben seguir para hash las contraseñas al crear un usuario?

¿Cómo se aplica el hash en el endpoint de creación de clientes?

¿Qué beneficios ofrece este enfoque?

Comentarios

Resolviendo Reto

Codigo

Continuando con el Proyecto: 📝