Une clé API en dur dans un fichier JavaScript, poussée sur un dépôt public. Je l'ai vue. Pas dans un projet d'étudiant : dans le front d'une petite boîte qui vendait un service à quelques centaines de clients. La clé donnait accès à leur base de données. Voilà le vrai visage de la sécurité des API côté développement web : pas des attaques sophistiquées de films, mais des oublis basiques, dans du code que personne ne relit.
Sécuriser une API quand on développe du web, ce n'est pas empiler des bibliothèques. C'est une discipline qui commence à la ligne de code et finit dans la configuration du serveur. Et la plupart des fuites que j'ai croisées venaient d'un seul point : on protège l'API, mais on oublie le navigateur qui l'appelle.
Points clés à retenir
- Le cœur du problème côté web : tout ce qui part dans le front est public, y compris vos clés et vos tokens.
- L'authentification (qui vous êtes) ne suffit pas : il faut aussi l'autorisation (ce que vous avez le droit de faire).
- Les quatre critères de sécurité à garder en tête : confidentialité, intégrité, disponibilité, traçabilité.
- Un token dans le localStorage est lisible par n'importe quel script injecté dans la page.
- Validez chaque entrée côté serveur, même si le formulaire la valide déjà côté client.
- Le RGPD et les recommandations de la CNIL imposent de minimiser et de journaliser, pas seulement de chiffrer.
Comment sécuriser une API en développement web : le vrai point de départ
La première fois que j'ai mis en place une authentification par token sur un projet, j'étais content de moi. JWT signé, mot de passe haché, tout ça. Trois semaines plus tard, un ami développeur ouvre les outils de développement de mon appli, regarde l'onglet Application, et me dit : « Ton token, il est dans le localStorage. Il est en clair. »
J'avais sécurisé le transport. J'avais oublié le stockage. C'est typique.
Ce qui change quand le client est un navigateur
Sur une API appelée par une autre machine, vous contrôlez les deux bouts. Sur le web, le bout « client » est un navigateur que vous ne contrôlez pas : une extension peut lire la page, un script tiers peut s'y glisser, un utilisateur peut tout inspecter avec deux clics. Toute valeur que l'API envoie au front est publique par définition.
Donc : aucune clé secrète dans le code JavaScript. Pas de clé d'API tierce embarquée dans le front, pas de secret de signature côté client. Si vous avez besoin d'appeler un service externe qui exige une clé, faites-le passer par votre propre backend, qui sert de relais et garde la clé chez lui.
Quels sont les 4 critères de sécurité ?
On me pose souvent la question, alors autant la traiter d'emblée. Les quatre critères classiques de la sécurité de l'information sont :
- Confidentialité : seules les personnes autorisées accèdent à la donnée. En pratique, chiffrement en transit (HTTPS obligatoire) et contrôle d'accès côté serveur.
- Intégrité : la donnée ne peut pas être modifiée en chemin sans qu'on le sache. D'où les signatures, les jetons vérifiables, la validation stricte des entrées.
- Disponibilité : le service répond même sous charge ou sous attaque. C'est là que le rate limiting entre en jeu.
- Traçabilité : on sait qui a fait quoi, quand. Journaux d'accès et d'erreurs, avec une durée de conservation raisonnée.
Ces quatre-là ne sont pas une liste à cocher une fois pour toutes. Ce sont des tensions permanentes. Plus vous tracez (traçabilité), plus vous stockez de données (confidentialité), et plus vous devez les protéger.
Protéger les accès : authentification et autorisation, deux chantiers distincts
Une erreur que je vois partout, y compris chez moi au début : confondre « l'utilisateur est connecté » avec « l'utilisateur a le droit ». Ce sont deux questions différentes, et la seconde est celle qu'on oublie de coder.
Jeton, cookie, session : que choisir côté web
Pour une application web classique, un cookie de session configuré correctement pose moins de risques qu'un jeton rangé dans le JavaScript. Le cookie peut être marqué HttpOnly (invisible pour les scripts) et Secure (envoyé uniquement en HTTPS), et il reste protégé du vol par script. Le jeton dans le localStorage, lui, est lisible par tout code qui tourne dans la page.
Si vous tenez absolument au jeton, alors le schéma propre est : jeton d'accès de courte durée, jeton de rafraîchissement stocké dans un cookie HttpOnly, et renouvellement côté serveur. Plus de code, plus de pièces mobiles, mais c'est le prix.
| Méthode | Exposé au vol par script | Complexité | Quand l'utiliser |
|---|---|---|---|
| Cookie de session HttpOnly | Non | Faible | App web classique, rendu serveur |
| Jeton en localStorage | Oui | Faible | À éviter pour de la donnée sensible |
| Jeton d'accès court + refresh en cookie | Non pour le refresh | Moyenne à élevée | API consommée par un front séparé |
| OAuth 2 / OIDC avec un fournisseur | Non | Élevée | Authentification déléguée, plusieurs clients |
Sur les scopes, un réflexe simple : donnez le minimum. Un jeton qui sert à lire un profil n'a pas besoin du droit d'écriture. Et vérifiez côté serveur, à chaque requête, que la ressource demandée appartient bien à l'utilisateur authentifié. C'est ce qu'on appelle le contrôle d'accès au niveau objet, et c'est l'oubli numéro un dans les API web.
CORS mal configuré et absence de limitation : le duo fatal
Le CORS, je l'ai découvert à mes dépens. J'avais mis un * dans l'en-tête Access-Control-Allow-Origin pour « faire marcher le front plus vite ». Sauf que ce réglage autorise n'importe quel site à appeler votre API depuis le navigateur d'un utilisateur connecté. Ce n'est pas une faille en soi, mais c'est une porte grande ouverte si votre authentification repose sur des cookies.
Même logique pour le rate limiting : sans limite de requêtes, une API d'authentification se laisse deviner au forceps. Quelques dizaines de tentatives par minute et par adresse, c'est déjà une barrière.
Valider les entrées et tracer sans stocker n'importe quoi
Le formulaire côté client vérifie déjà le format de l'email. Génial. Et alors ? N'importe qui peut envoyer une requête à votre API sans passer par votre formulaire, avec curl et un peu de patience. La validation côté serveur n'est pas une ceinture de sécurité en plus : c'est la seule qui compte.
Un exemple concret de validation
Prenons un endpoint qui attend un identifiant numérique. Si vous le passez directement dans une requête SQL, vous ouvrez la porte à l'injection. Deux gestes règlent l'essentiel :
- Vérifier le type et le format de chaque champ avant de l'utiliser (un entier reste un entier, une chaîne trop longue est rejetée).
- Passer par des requêtes paramétrées, jamais par une concaténation de chaînes.
Même chose pour les en-têtes et les fichiers envoyés : limitez la taille, vérifiez le type réel du contenu, refusez ce que vous n'attendez pas.
Conformité : ce que la CNIL attend vraiment
La sécurité d'une API n'est pas qu'une affaire technique. Si vous manipulez des données personnelles, le RGPD impose la minimisation (ne collecter que le nécessaire), une durée de conservation définie, et la capacité de tracer les accès. La CNIL publie un guide de la sécurité des données personnelles qui détaille ces principes ; je vous conseille de le lire avant de concevoir votre schéma de base, pas après. Parce que rajouter de la journalisation sur une API déjà en production coûte bien plus cher.
Un point que j'ai mis du temps à intégrer : ne pas journaliser ce qu'on n'a pas besoin de journaliser. Un log qui contient des mots de passe ou des numéros de carte en clair transforme votre outil de diagnostic en bombe à retardement.
Quelle est l'API la plus utilisée pour les services web ?
La question revient souvent. En pratique, REST reste le style d'architecture dominant pour exposer des services web : il repose sur HTTP, se comprend vite, et la quasi-totalité des outils et bibliothèques le prennent en charge. GraphQL gagne du terrain côté applications qui multiplient les écrans et les besoins de données, mais REST reste la base par défaut.
Le choix du style ne change pas grand-chose à la sécurité. Ce qui compte, c'est ce qu'on met autour : authentification, autorisation, validation, limites, journaux. Une API REST bâclée est aussi vulnérable qu'une API GraphQL bâclée.
Comment assurer la sécurité d'un site web ?
La sécurité du site et celle de l'API sont deux faces du même objet. Trois habitudes qui font la différence, et que j'essaie de tenir sur chaque projet :
- HTTPS partout, sans exception, et redirection automatique depuis HTTP.
- En-têtes de sécurité correctement renseignés (Content-Security-Policy, X-Content-Type-Options), et dépendances mises à jour régulièrement.
- Gestion des secrets hors du code : variables d'environnement, coffre-fort, rotation des clés. Jamais de fichier
.envpoussé sur un dépôt.
Et un principe qui vaut de l'or : ne faites jamais confiance au client. Le navigateur, c'est chez l'utilisateur. Votre serveur, c'est chez vous.
Le point de départ que je conseille à chaque nouveau projet
Avant d'écrire la première ligne d'un endpoint, posez trois questions. Qui peut appeler cette route ? Que peut-il faire une fois authentifié ? Que se passe-t-il si la requête est malveillante ? Si vous n'avez pas de réponse claire aux trois, ce n'est pas la peine de coder l'authentification : vous n'aurez sécurisé qu'une façade.
Une dernière chose. La sécurité d'une API ne se voit pas. Un site qui marche, c'est un site qui marche ; une API bien sécurisée, c'est une API à laquelle personne ne pense, parce que rien ne cloche. C'est frustrant, parce qu'on ne récolte jamais de compliments pour ça. Mais le jour où une clé traîne dans un dépôt public, on se souvient très bien de ce qu'on aurait dû faire.
Alors la prochaine fois que vous ouvrez les outils de développement de votre propre application, jetez un œil à l'onglet Application. Si un token s'y balade en clair, vous savez ce qu'il vous reste à faire.