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.

1. Authentification de base

Qu'est-ce que c'est?

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).

Comment le mettre en œuvre

Pour ajouter l'authentification de base à votre API à l'aide d'Express, voici ce dont vous aurez besoin :

1. Installez le package basic-auth :

   npm install basic-auth

1. Ajouter le middleware d'authentification :

   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}`);
   });

Le tester

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.

2. JWT (jetons Web JSON)

Qu'est-ce que c'est?

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.

Comment le mettre en œuvre

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}`);
});

Le tester

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 les informations d'identification n'ont pas besoin d'être envoyées à chaque demande.

3. Authentification par clé API

Qu'est-ce que c'est?

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.

Comment le mettre en œuvre

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}`);
});

Le tester

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/

Résumé des méthodes d'authentification

• Authentification de base :

  • Avantages : Facile à configurer.
  • Inconvénients : Les informations d'identification sont envoyées avec chaque demande, elles doivent donc être utilisées via HTTPS.
  • Cas d'utilisation : API simples avec un petit nombre d'utilisateurs.

• Authentification JWT :

  • Avantages : Sécurisé, sans état et bien évolutif.
  • Inconvénients : Plus complexe que l'authentification de base.
  • Cas d'utilisation : API évolutives nécessitant une sécurité robuste.

• Authentification par clé API :

  • Avantages : Simple et largement utilisé.
  • Inconvénients : les clés API sont moins sécurisées que JWT et plus difficiles à gérer.
  • Cas d'utilisation : API simples où vous souhaitez authentifier les clients sans gestion des utilisateurs.

Conclusion

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!