Aller au contenu

Clé API

Une clé d'api est une chaîne de caractères aléatoire unique qui est utilisée pour identifier et authentifier un utilisateur qui effectue une requête à l'api. Ce n'est pas de l'information encrypté ou hashé. Par exemple on pourrait un UUID comme clé api.

On ajoute la clé dans l'entête de chaque requête envoyée à l'API. Ensuite le serveur détermine si la clé est valide, identifie l'utilisateur associé à la clé (identification) et détermine si celui-ci peut effectuer la requête (authentification).

Fonctionnement

Voici le mode de fonctionnement que nous allons utiliser pour ajouter une protection par clé api à notre projet:

  • L'utilisateur doit se créer un compte à l'aide d'une route de l'api en fournissant un email et un mot de passe.
  • On va générer une clé d'api, enregistrer les informations dans la base de données (hashez le mot de passe) et ensuite retourner la clé à l'utilisateur
  • L'utilisateur devra ensuite ajouter la clé dans l'entête de chaque requête qui est envoyée au serveur.
  • Un Intergiciel se chargera de valider si la clé est bonne en faisant une recherche dans la base de données.
  • On va ajouter le Intergiciel aux routes qu'on veut protéger.

Ajouter la clé à l'entête de la requête

Dans la section entête de la requête il y a une clé qui est utilisée justement pour envoyer des données comme un clé api. Dans Postman vous pouvez ajouter l'information dans l'onglet Headers. Le nom de la clé est Authorization et comme valeur nous allons avoir cle_api suivi d'une espace et de la clé. (Vous pouvez utiliser autre chose comme nom que cle_api, souvent dans les documentation on va voir Bearer).

apikey_01.png

Intergiciel de confirmation de la clé

Dans votre projet, créer un répertoire middlewares dans le répertoire src. Créez un fichier dans ce répertoire avec le code suivant

authentification.middleware.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const Utilisateur = require("../models/utilisateur.model");

module.exports = (req, res, next) => {

    // Vérifier si la clé API est présente dans l'entête
    if(!req.headers.authorization) {
        return res.status(401).json({ message: "Vous devez fournir une clé api" });
    }

    // Récupérer la clé API
    const cleApi = req.headers.authorization.split(' ')[1];
    // Vérifier si la clé API est valide
    Utilisateur.validationCle(cleApi)
    .then(resultat => {
        if(!resultat) {
            return res.status(401).json({ message: "Clé API invalide" });
        } else {
            // La clé API est valide, on continue le traitement
            next();
        }
    })
    .catch(erreur => {
        return res.status(500).json({ message: "Erreur lors de la validation de la clé api" })
    });    
}

Note

Explication de la ligne 11 req.headers.authorization me retourne la valeur complète de la clé authorization, par exemple "cle_api 123456". En utilisant split avec un espace comme caractère de séparation je me retrouve avec un tableau avec "cle_api" à l'index 0 et "123456" à l'index 1. C'est ne récupérer que la valeur de la clé que j'utilise split et ensuite je demande l'index 1.

Voici maintenant un exemple de fonction qui valide que la clé api existe dans la bd et retourne une valeur vrai ou faux.

utilisateur.model.js
// ...
exports.validationCle = (cleApi) => {
    return new Promise((resolve, reject) => {
        const requete = 'SELECT COUNT(*) AS nbUsager FROM usager u WHERE cle_api = ?; ';
        const parametres = [cleApi];

        sql.query(requete, parametres, (erreur, resultat) => {
            if (erreur) {
                console.log(`Erreur sqlState ${erreur.sqlState} : ${erreur.sqlMessage}`);
                reject(erreur);
            }
            resolve(resultat[0].nbUsager > 0);   
        });
    });
}
// ...

Protection des routes

On peut appliquer la protection à toutes les routes de l'API. Par contre si on a une route qui permet de créer un utilisateur sans clé d'api ou une route pour la documentation, elles seront bloquées. Ce n'est donc pas la meilleure méthode. Dans le fichier index.js on va simplement utiliser app.use().

index.js
const authentification = require('./src/middlewares/authentification.middleware');
// ...
app.use(authentification);

Étant donnée qu'on utilise le routage, on peut aussi ajouter la protection à un groupe de route.

index.js
const authentification = require('./src/middlewares/authentification.middleware');
// ...
app.use('/api/pokemons', authentification, pokemonsRoutes);

On peut aussi y aller route par route

pokemons.route.js
1
2
3
4
5
const authentification = require('../middlewares/authentification.middleware');

// Ici seulement la route /liste est protégée
router.get('/liste', authentification, pokemonsController.afficherTousLesPokemons);
router.get('/:id', pokemonsController.trouverUnPokemon);

Mediagraphie