Generar JWT en el servicio

Generating tokes from backend

• First of all, configure .env to provide a secret and it won’t be accessible from code.

  jwtSecret="A SECRET REALLY SECRET"

  Page to generate greats passwords:

• In our auth.routes configure secret such as we did in the last lesson

  router.post('/login',
      //We are using the local strategy and not using sessions
      passport.authenticate('local', { session: false }),
      async(req, res, next) => {
          try {
              const user = req.user;
              **const payload = {
                  sub: user.id,
                  role: user.role
              }**
  
              **const token = jwt.sign(payload, config.auth.jwtSecret);**
  
              res.json({ user, token });
  
          } catch (err) {
              next(err);
          }
      }
  );
  

• Finally,

  try it in insomnia/postman!

Al implementar JWT ya no es necesario enviar los datos del usuario en la petición, ya que por medio del payload del token podemos enviarla, ademas recordar que por ningún motivo se debe enviar informacion sensible del usuario.

En el archivo auth.route.js se hace la implementación del JWT, primero se hace la autenticación con la estrategia local y con ello se tiene al usuario (req.user), por lo tanto, se crea el payload con los datos del usuario, posteriormente se firma el token con la función .sign() y como respuesta se envía un JSON con el user y el token.

const express = require('express');
const passport = require('passport');
const jwt = require('jsonwebtoken');

const { config } = require('../../config/config');

const router = express.Router();

router.post(
  '/login',
  passport.authenticate('local', { session: false }),
  async (req, res, next) => {
    try {
      const user = req.user;
      const payload = {
        sub: user.id,
        role: user.role,
      };

      const token = jwt.sign(payload, config.jwtSecret);
      res.json({ user, token });
    } catch (error) {
      next(error);
    }
  }
);

module.exports = router;

El secret es necesario para firmar el token, por ello se asigna en el archivo .env, una página para generar passwords con diferentes algoritmos es https://keygen.io/.

PORT=3000
DATABASE_URL='postgres://john:admin123@localhost:5432/my_store'
API_KEY=321456
JWT_SECRET='D8T1LkIMVTA8yYSuNgbadlFJ9yGU7cjD'

La nueva variable de entorno se agrega a la configuración config/config.js:

require('dotenv').config();

const config = {
  env: process.env.NODE_ENV || 'dev',
  isProd: process.env.NODE_ENV === 'production',
  port: process.env.PORT || 3000,
  dbUser: process.env.DB_USER,
  dbPassword: process.env.DB_PASSWORD,
  dbHost: process.env.DB_HOST,
  dbName: process.env.DB_NAME,
  dbPort: process.env.DB_PORT,
  dbUrl: process.env.DATABASE_URL,
  apiKey: process.env.API_KEY,
  jwtSecret: process.env.JWT_SECRET,
};

module.exports = { config };

Otra forma de generar secrets desde la terminal es:

$ openssl rand -hex 45

🗝 Clase #10: Generar JWT en el servicio 10/20 🗝

Pasos: 📝

• Vamos a implementar la lógica para que cuando se haga login, tengamos el token. Para ello en VSC, en la carpeta routes, abrimos el archivo auth.router.js, el código queda:
   

const express = require('express');
const passport = require('passport');
const jwt = require('jsonwebtoken');

//Traemos el config para el jwtSecret
const { config } = require('./../config/config');

const router = express.Router();

router.post('/login',
  passport.authenticate('local', {session: false}),
  //Al pasar la capa de autenticación después de verificar que el usuario y password son correctos
  //al devolver el login, se le brinda un token
  async (req, res, next) => {
    try {
      const user = req.user;
      const payload = {
        sub: user.id,
        role: user.role
      }
      //Se hace la firma
      const token = jwt.sign(payload, config.jwtSecret);
      res.json({
        user,
        token
      });
    } catch (error) {
      next(error);
    }
  }
);

module.exports = router;

 
Guardamos, vamos a la carpeta config y abrimos el archivo config.js y después de apiKey colocamos:
 

jwtSecret: process.env.JWT_SECRET,

 
Guardamos, abrimos la página para generar claves (enlace: aquí), para ésta clase se buscó: WEP 256-bit Key, se generó en la pestaña NEW y luego al dar en la pestaña COPY, aparece un cuadro donde indica que al presionar las teclas Ctrl + C se copia la clave generada.
 
Esa clave se copia y se pega en el archivo de variables de entorno .env después de API_KEY se coloca el JWT_SECRET, para mi ejemplo:

JWT_SECRET=csvV9KYB4QeqhaEgoJdIzwunROb1XDZU

 
Guardamos, como se modificó el archivo .env con las variables de entorno, en la terminal se corre de nuevo:
 

npm run dev

 
Vamos a Insomia y en la carpeta de Auth en Login, la solicitud del POST con la dirección: _.API_URL/api/v1/auth/login

 
En el body JSON:
 

{
	"email": "[email protected]",
	"password": "12356 .2020",
	"role": "admin"
}

 
Al enviar la petición debe salir el código 200 OK:
 

{
	"user": {
		"id": 3,
		"email": "[email protected]",
		"role": "admin",
		"createdAt": "2023-03-17T02:47:32.524Z"
	},
	"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjMsInJvbGUiOiJhZG1pbiIsImlhdCI6MTY3OTUzNjc4MH0.ivIhrTTJreKyEFvFWJbRBJ_eLEItoIgH5HlWSVLOESw"
}

Otra cosa que es recomendable agregarle al token es un tiempo de expiración (también definido desde envs o alguna configuración por usuario/cliente)

const token = jwt.sign(payload, "secret", {
  // Ejemplo: token expira en 10 horas
  expiresIn: "10h" 
})

#hola

Hola

¡Excelente clase! 🌟

Otra opcion para generar los secrets es directamente con el mismo node creando caracteres aleatorios, en este caso lo hago con un oneliner desde la terminal

echo 'key=require("crypto").randomBytes(128).toString("base64");console.log(key)' | node