Maison > Article > interface Web > Sécuriser une API Node.js : un guide simple d'authentification
J'ai construit une API Node.js et je souhaite la sécuriser, j'ai donc coché les quelques options parmi lesquelles je dois choisir. Je vais donc vous présenter trois méthodes d'authentification courantes : Authentification de base, JWT (JSON Web Tokens) et Clés API.
L'authentification de base est aussi simple que possible. Le client envoie un nom d'utilisateur et un mot de passe à chaque demande dans l'en-tête Autorisation. Bien qu'il soit facile à mettre en œuvre, ce n'est pas le plus sécurisé, sauf si vous utilisez HTTPS, car les informations d'identification sont uniquement codées en base64 (non cryptées).
Pour ajouter l'authentification de base à votre API à l'aide d'Express, voici ce dont vous aurez besoin :
npm install basic-auth
const express = require('express'); const basicAuth = require('basic-auth'); const app = express(); function auth(req, res, next) { const user = basicAuth(req); const validUser = user && user.name === 'your-username' && user.pass === 'your-password'; if (!validUser) { res.set('WWW-Authenticate', 'Basic realm="example"'); return res.status(401).send('Authentication required.'); } next(); } app.use(auth); app.get('/', (req, res) => { res.send('Hello, authenticated user!'); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); });
Utilisez curl pour tester votre authentification de base :
curl -u your-username:your-password http://localhost:3000/
Conseil : Utilisez toujours l'authentification de base via HTTPS pour garantir la protection des informations d'identification.
JWT est un moyen plus sécurisé et évolutif d'authentifier les utilisateurs. Au lieu d'envoyer des informations d'identification à chaque demande, le serveur génère un jeton lors de la connexion. Le client inclut ce jeton dans l'en-tête Authorization pour les demandes ultérieures.
Tout d'abord, installez les packages requis :
npm install jsonwebtoken express-jwt
Voici un exemple de la façon dont vous pouvez configurer l'authentification JWT :
const express = require('express'); const jwt = require('jsonwebtoken'); const expressJwt = require('express-jwt'); const app = express(); const secret = 'your-secret-key'; // Middleware to protect routes const jwtMiddleware = expressJwt({ secret, algorithms: ['HS256'] }); app.use(express.json()); // Parse JSON bodies // Login route to generate JWT token app.post('/login', (req, res) => { const { username, password } = req.body; if (username === 'user' && password === 'password') { const token = jwt.sign({ username }, secret, { expiresIn: '1h' }); return res.json({ token }); } return res.status(401).json({ message: 'Invalid credentials' }); }); // Protected route app.get('/protected', jwtMiddleware, (req, res) => { res.send('This is a protected route. You are authenticated!'); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); });
Tout d'abord, connectez-vous pour obtenir un jeton :
curl -X POST http://localhost:3000/login -d '{"username":"user","password":"password"}' -H "Content-Type: application/json"
Ensuite, utilisez le token pour accéder à un itinéraire protégé :
curl -H "Authorization: Bearer <your-token>" http://localhost:3000/protected
JWT est génial car le jeton a un délai d'expiration et il n'est pas nécessaire d'envoyer des informations d'identification à chaque demande.
L'authentification par clé API est simple : vous donnez à chaque client une clé unique, et il l'inclut dans ses requêtes. C’est facile à mettre en œuvre mais pas aussi sécurisé ou flexible que JWT, car la même clé est réutilisée encore et encore. En fin de compte, c'est une solution robuste, qui peut facilement être utilisée pour limiter le nombre d'appels API et de nombreux sites Web l'utilisent. Comme mesure de sécurité supplémentaire, les demandes peuvent être limitées à une adresse IP spécifique.
Vous n'avez pas besoin de packages spéciaux pour cela, mais utiliser dotenv pour gérer vos clés API est une bonne idée. Tout d’abord, installez dotenv :
npm install dotenv
Ensuite, créez votre API avec l'authentification par clé API :
require('dotenv').config(); const express = require('express'); const app = express(); const API_KEY = process.env.API_KEY || 'your-api-key'; function checkApiKey(req, res, next) { const apiKey = req.query.api_key || req.headers['x-api-key']; if (apiKey === API_KEY) { next(); } else { res.status(403).send('Forbidden: Invalid API Key'); } } app.use(checkApiKey); app.get('/', (req, res) => { res.send('Hello, authenticated user with a valid API key!'); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); });
Vous pouvez tester votre authentification par clé API avec :
curl http://localhost:3000/?api_key=your-api-key
Ou en utilisant un en-tête personnalisé :
curl -H "x-api-key: your-api-key" http://localhost:3000/
Authentification de base :
Authentification JWT :
Authentification par clé API :
Si vous recherchez quelque chose de rapide et facile, l'Authentification de base pourrait fonctionner, mais n'oubliez pas d'utiliser HTTPS. Si vous souhaitez une sécurité plus robuste et évolutive, optez pour JWT. Pour les API légères ou internes, l'authentification par clé API peut suffire.
Quelle méthode d'authentification comptez-vous utiliser ou avez-vous d'autres solutions ? Faites-le moi savoir dans les commentaires !
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!