La Autenticación y Autorización JWT (JSON Web Token) es un estándar de la industria que se utiliza para garantizar la seguridad en la comunicación entre dos sistemas. Este protocolo permite que los sistemas compartan recursos seguros al garantizar la autenticación y autorización de los usuarios.
Aquí hay una implementación básica basada en Node.js y Express.
1. Instalar los paquetes necesarios:
```bash
npm install express jsonwebtoken
```
2. Crear un modelo de usuario para representar un usuario en su sistema:
```javascript
// User.js
class User {
constructor(name, password) {
this.name = name;
this.password = password;
}
}
module.exports = User;
```
3. Crear una estrategia para autenticar usuarios:
```javascript
// auth.js
const jwt = require(‘jsonwebtoken’);
const User = require(‘./User’);
const SECRET_KEY = ‘somesupersecretkey’ // Recuerda siempre mantener esto seguro y nunca exponerlo al Cliente
function authenticate(name, password) { // Aquí puedes hacer una llamada a tu base de datos para buscar al usuario const user = new User(‘john’, ‘password123’) // usuario de prueba
if (name !== user.name || password !== user.password) { throw new Error(‘Invalid user credentials’); } const payload = { name: user.name, iat: Date.now(), exp: Date.now() + 2 * 60 * 60 * 1000 // expiration time }; const token = jwt.sign(payload, SECRET_KEY); return token; }module.exports = authenticate;
```
4. Crear un middleware para verificar la autorización:
```javascript
// verifyToken.js
const jwt = require(‘jsonwebtoken’);
const SECRET_KEY = ‘somesupersecretkey’
function verifyToken(req, res, next) { const token = req.headers[‘authorization’];
if (!token) { res.status(403).send(‘A token is required for authentication’); } try { const decoded = jwt.verify(token, SECRET_KEY); req.user = decoded; } catch (err) { return res.status(401).json(“Invalid Token”); } return next(); }module.exports = verifyToken;
```
5. Crear endpoints para iniciar sesión y proteger recursos:
```javascript
// server.js
const express = require(‘express’);
const app = express();
const authenticate = require(‘./auth’);
const verifyToken = require(‘./verifyToken’);
app.use(express.json());
app.post(‘/login’, (req, res) => {
try {
const token = authenticate(req.body.name, req.body.password);
res.json({
success: true,
token: token
});
} catch(err) {
res.status(401).send(err.message)
}
});
app.get(‘/protected’, verifyToken, (req, res) => {
res.json({
success: true,
message: ‘This is a protected resource’,
user: req.user
});
});
app.listen(3000, () => console.log(‘Server started on port 3000’));
```
Eso es muy básico y, por supuesto, debes adaptarlo a tus necesidades. Podrías querer hacer cosas como almacenar usuarios en tu base de datos, utilizar sistemas de almacenamiento de contraseñas seguras, manejar tokens de refresco y mucho más. Debes investigar y entender completamente JWT antes de utilizarlo en una aplicación en producción. Además, existen otros métodos alternativos para la autenticación, como las sesiones basadas en cookies, que podrías considerar.
