Snyk peut-il détecter les problèmes de sécurité liés aux JWT ?

Les développeurs utilisent souvent les JWT pour mettre en place une authentification plutôt que des sessions traditionnelles basées sur des cookies. Mais que se passe-t-il lorsqu’ils comprennent mal la sécurité des JWT et s’exposent à une grave vulnérabilité liée à une authentification défaillante ?

Qu’est-ce qu’un JWT ?

Les JSON Web Tokens (JWT) constituent un moyen compact et autonome de transmettre des informations de manière sécurisée entre différentes parties sous la forme d’un objet JSON. Comme ces informations sont signées numériquement, souvent à l’aide de certificats, elles peuvent être vérifiées et considérées comme fiables. Les JWT sont couramment utilisés par les développeurs web qui souhaitent ajouter une authentification à leurs applications et éviter la gestion traditionnelle de la sécurité des cookies et des sessions dans le navigateur.

Structure d’un JWT

Comme indiqué plus haut, un JWT est un objet JSON standard qui stocke des données. Il se compose d’un Header, d’un Payload et d’une Signature. Ces éléments sont encodés en Base64 et séparés par des points (.) pour former la chaîne JWT.

1. Header : l’en-tête comprend généralement deux éléments : le type de jeton, JWT, et l’algorithme de signature utilisé, comme HMAC SHA256 ou RSA.

 {
     "alg": "HS256",
     "typ": "JWT"
   }

2. Payload : la charge utile contient les claims. Les claims sont des déclarations concernant une entité (généralement l’utilisateur) ainsi que des données supplémentaires. Veillez toutefois à ne pas y stocker de données sensibles ou confidentielles, car les JWT ne sont souvent pas chiffrés et n’importe qui peut les décoder pour accéder aux données. Il existe trois types de claims : les claims enregistrés, publics et privés.

{
     "sub": "1234567890",
     "name": "John Doe",
     "admin": true
   }

3. Signature : pour créer la signature, vous devez signer l’en-tête encodé, la charge utile encodée, un secret et l’algorithme indiqué dans l’en-tête.

 HMACSHA256(
     base64UrlEncode(header) + "." +
     base64UrlEncode(payload),
     secret)

Le JWT obtenu peut ressembler à ceci :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Le rôle des JWT dans les API et les microservices

Les JWT jouent un rôle important pour les développeurs front-end et back-end qui mettent en place l’authentification et développent des API et des microservices. Contrairement à l’authentification traditionnelle par session côté serveur, qui exige que le serveur conserve l’état de session dans une base de données, les JWT offrent une approche plus évolutive et efficace grâce à leur nature sans état. Lorsqu’un utilisateur se connecte, le serveur génère un jeton qui encode ses informations et le signe à l’aide d’une clé secrète. Ce jeton est ensuite envoyé au client, qui l’ajoute à l’en-tête des requêtes suivantes.

Le serveur peut vérifier la signature du jeton pour authentifier l’utilisateur sans stocker de données de session. La nature sans état des JWT les rend particulièrement adaptés aux systèmes distribués et aux architectures de microservices, où la gestion d’un référentiel de sessions centralisé pourrait devenir un goulot d’étranglement ou un point de défaillance unique.

Packages npm JWT open source populaires pour Node.js

Pour travailler avec les JWT dans Node.js, les développeurs disposent de nombreuses bibliothèques open source, mais ils choisissent souvent le package npm populaire jsonwebtoken. Ces bibliothèques simplifient la génération, la signature et la vérification des jetons. Il est toutefois essentiel de comprendre leurs différences fonctionnelles et leurs implications en matière de sécurité afin d’éviter toute utilisation inappropriée susceptible d’introduire un risque de sécurité.

Parmi les autres packages npm JSON figurent node-jose et des intégrations pour les frameworks web, comme passport-jwt et @fastify/jwt.

Risques de sécurité liés au décodage d’un JWT

Pour illustrer une erreur classique dans l’utilisation non sécurisée des JWT pour gérer l’authentification, nous allons choisir les options populaires vers lesquelles la plupart des développeurs se tourneront : le framework web Express et la bibliothèque JWT jsonwebtoken.

Saurez-vous repérer la vulnérabilité de sécurité dans le code Node.js suivant ? :

const express = require('express');
const jsonWebToken = require('jsonwebtoken');
require('dotenv').config();

const webApp = express();

const securityKey = process.env.JWT_SECRET;

const validateAccess = (request, response, next) => {
  const authorizationHeader = request.headers.authorization;

  if (!authorizationHeader) {
    return response.status(401).json({ error: 'Missing authentication credentials' });
  }

  try {
    const decodedToken = jsonWebToken.decode(authorizationHeader,{complete: true});
    request.userContext = decodedToken;
    next();
  } catch (authError) {
    return response.status(403).json({ error: 'Invalid or expired token' });
  }
};

webApp.get('/privileged-area', validateAccess, (request, response) => {
  const { username } = request.userContext;
  if (username === 'admin') {
    // Access to sensitive data is now available.
    return response.status(200).json({ status: 'Access permitted to admin' });
  }
  response.status(403).json({ status: 'Insufficient permissions' });
});

webApp.get('/issue-token', (request, response) => {
  const userClaims = { username: 'user' };
  const authenticationToken = jsonWebToken.sign(userClaims, securityKey, { expiresIn: '1h' });
  response.status(200).json({ authenticationToken });
});

webApp.listen(3001, () => {
  console.log('Application listening on port 3001');
});

Ce code Node.js utilise jsonWebToken.decode() pour décoder le JWT. Cette méthode décode le jeton sans en vérifier la signature. Ainsi, même si le code fonctionne parce que decodedToken renvoie des données, rien ne garantit que celles-ci correspondent à celles définies par le serveur ni qu’elles n’ont pas été altérées par un tiers. N’importe qui peut donc modifier le jeton, et l’application continuera de l’accepter comme valide. Utilisez plutôt jsonWebToken.verify() pour décoder le jeton et vérifier son authenticité à l’aide de la clé secrète.

Snyk détecte les problèmes de sécurité liés aux JWT

Analysez avec Snyk le code Node.js vulnérable ci-dessus. Snyk détectera le problème de sécurité JWT lié à l’utilisation de la méthode non sécurisée de gestion des jetons JSON jwt.decode() dans la bibliothèque jsonwebtoken :

Snyk détectera ce problème, quel que soit le point d’intégration choisi. Dans la capture d’écran ci-dessus, j’ai importé le dépôt de code GitHub via l’application web Snyk. Une fois le dépôt importé, Snyk analyse les fichiers manifestes, comme requirements.txt pour Python ou package.json pour npm, afin de détecter les dépendances vulnérables. Snyk détecte également les fichiers IaC, comme ceux de Terraform, et effectue une analyse statique du code.

Comme le montre la capture d’écran ci-dessus, Snyk a détecté l’utilisation incorrecte de la bibliothèque jsonwebtoken, qui recourt à la fonction non sécurisée jwt.decode et peut entraîner une authentification défaillante.

Voici une méthode recommandée pour décoder un JWT de manière sécurisée :

   try {
     const decodedToken = jsonWebToken.verify(authorizationHeader, securityKey);
     request.userContext = decodedToken;
     next();
   } catch (authError) {
     return response.status(403).json({ error: 'Invalid or expired token' });
   }

Le code Node.js présenté plus haut comporte également les problèmes de sécurité JWT suivants :

• Données sensibles codées en dur : l’extrait de code stocke la clé secrète dans des variables d’environnement. Veillez à gérer ces variables de manière sécurisée, à ne pas les exposer dans les systèmes de gestion de versions et à pouvoir les renouveler et les gérer en toute sécurité.

• Journalisation insuffisante : consignez les tentatives d’authentification et les erreurs. Vous pourrez ainsi surveiller les incidents de sécurité potentiels et y répondre.

• Limitation du débit : comment limiter les tentatives de connexion par force brute et les autres abus des API d’authentification ? Mettez en place une limitation du débit pour éviter la saturation des ressources et les tentatives d’authentification sans contrôle.

• Expiration des jetons : le code définit une durée d’expiration pour les jetons, mais il est essentiel de vérifier cette expiration à chaque requête.

Bonnes pratiques recommandées pour sécuriser les JWT

Sécuriser une API REST avec des JWT ne consiste pas seulement à émettre et à vérifier des jetons. Cela nécessite de prendre en compte plusieurs pratiques de sécurité afin de limiter les vulnérabilités potentielles. Utilisez, par exemple, une clé secrète robuste pour signer les jetons, de préférence des clés asymétriques, et veillez à les transmettre via HTTPS pour éviter leur interception.

Il est également essentiel de mettre en place des stratégies adaptées d’expiration et de révocation des jetons. Leur durée de vie doit être courte afin de limiter les risques d’utilisation abusive en cas de compromission. Les jetons d’actualisation peuvent servir à émettre de nouveaux jetons d’accès sans obliger l’utilisateur à se reconnecter, mais ils doivent eux aussi être gérés en toute sécurité.

Consultez notre guide détaillé sur la sécurisation des API REST.