À l'ère des API RESTful et des microservices, la sécurisation de vos points de terminaison est absolument essentielle. Une méthode populaire et efficace pour garantir que seuls les utilisateurs autorisés peuvent accéder à des ressources spécifiques est l'authentification par jeton Bearer. Dans ce blog, nous allons explorer comment implémenter l'authentification par Bearer Token dans une application Node.js en utilisant Express. Nous aborderons les bases des Bearer Tokens, comment les configurer dans votre application et les meilleures pratiques pour garantir une architecture de sécurité robuste.
Qu'est-ce que l'authentification par Bearer Token ?
L'authentification par Bearer Token implique l'émission d'un jeton lors de l'authentification de l'utilisateur, que le client doit inclure dans l'en-tête Authorization des requêtes suivantes. Ce jeton agit comme un "porteur" d'informations d'identification, ce qui signifie que toute personne possédant le jeton peut accéder aux ressources associées. Les JSON Web Tokens (JWT) sont une forme couramment utilisée de Bearer Tokens en raison de leur nature sans état et de leur flexibilité.
Étape 1 : Configuration de votre application Node.js et Express
Avant de nous plonger dans l'implémentation des Bearer Tokens, configurons une application Node.js et Express de base. Nous commencerons par initialiser un nouveau projet et installer les dépendances nécessaires.
1. Initialiser un nouveau projet :
mkdir express-bearer-token && cd express-bearer-token
npm init -y
2. Installer les packages requis :
npm install express body-parser jsonwebtoken
express: Le framework web pour Node.js.jsonwebtoken: Une bibliothèque pour signer, vérifier et décoder les JWT.body-parser: Un middleware pour analyser les corps des requêtes entrantes.
3. Configurer le serveur de base :
Créez un fichier index.js et configurez un serveur Express :
const express = require('express');
const bodyParser = require('body-parser');
const jwt = require('jsonwebtoken');
const app = express();
const PORT = 3000;
const SECRET_KEY = 'your_secret_key';
app.use(bodyParser.json());
app.get('/', (req, res) => {
res.send('Welcome to the Bearer Token Authentication Tutorial!');
});
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
Étape 2 : Génération d'un JWT
Tout d'abord, vous devez créer un point de terminaison pour la connexion de l'utilisateur afin de générer et de renvoyer un jeton JWT. Pour simplifier, nous utiliserons un utilisateur factice.
1. Ajouter une route de connexion :
const users = {
user1: { username: 'user1', password: 'password1' } // Dummy user
};
app.post('/login', (req, res) => {
const { username, password } = req.body;
const user = users[username];
if (user && user.password === password) {
const token = jwt.sign({ username }, SECRET_KEY, { expiresIn: '1h' });
res.json({ token });
} else {
res.status(401).send('Invalid credentials');
}
});
Étape 3 : Protection des routes avec Bearer Token
Pour protéger certaines routes, vous aurez besoin d'un middleware qui valide le Bearer Token des requêtes entrantes.
1. Créer un middleware d'authentification :
Créez une fonction middleware pour vérifier le jeton Bearer. Ce middleware vérifiera l'en-tête Authorization dans les requêtes entrantes et vérifiera le jeton à l'aide d'une clé secrète.
const authenticateToken = (req, res, next) => {
const authHeader = req.headers['authorization'];
const token = authHeader && authHeader.split(' ')[1]; // Bearer <token>
if (token == null) return res.sendStatus(401); // No token present
jwt.verify(token, SECRET_KEY, (err, user) => {
if (err) return res.sendStatus(403); // Invalid token
req.user = user;
next();
});
};
2. Création de routes :
Créez des routes pour la connexion et une route protégée qui nécessite une authentification.
const users = [
{ id: 1, username: 'user1', password: 'password1' },
{ id: 2, username: 'user2', password: 'password2' }
];
app.post('/login', (req, res) => {
const { username, password } = req.body;
const user = users.find(u => u.username === username && u.password === password);
if (!user) {
return res.status(400).send('Username or password is incorrect');
}
const token = jwt.sign({ username: user.username }, 'your_jwt_secret_key', { expiresIn: '1h' });
res.json({ token });
});
app.get('/protected', authenticateToken, (req, res) => {
res.send('This is a protected route');
});
Étape 4 : Test de l'implémentation
Exécutez votre serveur :
node app.js
Pour tester l'implémentation :
- Connexion : Envoyez une requête POST à
/loginavec un corps JSON contenant unusernameet unpasswordvalides. Si les informations d'identification sont correctes, vous recevrez un JWT. - Accès à la route protégée : Envoyez une requête GET à
/protectedavec l'en-têteAuthorizationdéfini surBearer <your_token>. Si le jeton est valide, vous pourrez accéder à la route protégée.
Test de l'authentification API Bearer Token avec Apidog
L'authentification par jeton Bearer est une méthode courante utilisée dans les applications web pour sécuriser les requêtes API. Apidog, un outil API polyvalent, simplifie ce processus, permettant aux développeurs d'authentifier les requêtes API sans effort. Voici un guide étape par étape sur la façon dont vous pouvez tester l'authentification API Bearer token en utilisant Apidog.
Étape 1 : Configuration d'Apidog
- Télécharger et installer Apidog : Téléchargez Apidog et suivez les instructions d'installation pour votre système d'exploitation.
- Créer un nouveau projet : Ouvrez Apidog et créez un nouveau projet où vous pourrez gérer vos requêtes et tests API.
Étape 2 : Ajout d'un Bearer Token à la requête API
1. Sélectionnez l'authentification par Bearer Token : Dans le tableau de bord du projet, créez une nouvelle requête API. Accédez à "Auth" et sélectionnez "Bearer Token" dans le menu déroulant.
2. Entrez le jeton : Entrez directement la valeur de votre jeton. Apidog le préfixe automatiquement avec "Bearer" pour la requête réelle.
3. Envoyer la requête : Avec le jeton Bearer défini, envoyez la requête. Apidog inclura le jeton dans l'en-tête d'autorisation, vous permettant d'accéder aux ressources protégées.
Étape 3 : Vérification de la réponse
Après avoir envoyé la requête, vérifiez la réponse pour vous assurer que l'appel API a réussi. Un statut 200 OK indique généralement une authentification réussie.
Pourquoi choisir Bearer Token pour l'authentification API ?
L'authentification par jeton Bearer est largement choisie pour l'authentification API en raison de plusieurs avantages :
- Sans état : Les jetons Bearer permettent au serveur d'authentifier les requêtes sans maintenir l'état de la session, ce qui facilite la mise à l'échelle des applications.
- Simplicité : Les jetons sont faciles à implémenter et à utiliser, généralement inclus dans l'en-tête HTTP Authorization.
- Sécurité : Les jetons peuvent être chiffrés et avoir des délais d'expiration, ce qui améliore la sécurité.
- Interopérabilité : Les jetons Bearer sont standardisés et peuvent être utilisés sur différentes plateformes et services, favorisant l'interopérabilité.
Ces avantages font des jetons Bearer une option robuste et flexible pour sécuriser les API.
Meilleures pratiques pour la sécurité des Bearer Tokens
1. Utiliser des clés secrètes fortes :
Assurez-vous que votre clé secrète utilisée pour signer les JWT est complexe et stockée en toute sécurité. Évitez de la coder en dur dans votre base de code - envisagez d'utiliser des variables d'environnement.
2. Expiration du jeton :
Définissez toujours un délai d'expiration pour les jetons afin de minimiser le risque d'utilisation abusive s'ils sont volés. Faites régulièrement pivoter et invalidez les jetons.
3. HTTPS :
Utilisez HTTPS pour protéger les données en transit, y compris les Bearer Tokens, en assurant le chiffrement entre le client et le serveur.
4. Stockage sécurisé :
Côté client, stockez les jetons en toute sécurité. Les cookies HTTP-only et Secure sont souvent le meilleur choix par rapport au stockage local ou au stockage de session.
5. Limitation du débit et surveillance :
Implémentez une limitation du débit pour empêcher les attaques par force brute. De plus, surveillez vos API pour toute tentative d'accès non autorisée.
6. Liste noire des jetons compromis :
Maintenez un mécanisme pour invalider les jetons, tel qu'une liste noire, en cas de besoin de révoquer l'accès immédiatement.
Conclusion
L'authentification par Bearer Token utilisant JWT dans une application Node.js et Express offre une approche robuste et évolutive pour sécuriser vos API. En suivant les étapes décrites dans ce blog, vous pouvez implémenter une authentification sécurisée basée sur des jetons et protéger efficacement vos ressources.
La sécurité est un processus continu, et bien que les Bearer Tokens offrent de nombreux avantages, restez toujours informé des dernières meilleures pratiques et menaces en matière de sécurité. Avec cette base, vous êtes en bonne voie pour créer des API sécurisées, évolutives et efficaces dans Node.js en utilisant Express.
