Regarder le poisson avant de le parer
Un bon cuisinier ne fait pas confiance à ce qui arrive sur son plan de travail. Il regarde le poisson avant de le parer : l'œil, les ouïes, l'odeur. Il vérifie l'étiquette du bac avant de s'en servir. Il ne prend pas une sauce dans le pot d'un collègue sans savoir ce qu'elle contient. Et quand il envoie une assiette, il essuie le bord : rien ne sort de son poste qui ne soit pas destiné au client.
Ce ne sont pas des gestes de méfiance envers les fournisseurs ou les collègues. Ce sont des gestes de métier, faits mille fois par service, qui évitent qu'un seul produit douteux ne gagne la salle.
Le code a les mêmes gestes. Ce billet ouvre le domaine Implémentation avec cinq d'entre eux : valider ce qui entre, encoder ce qui sort, échouer proprement, tenir la mémoire et les ressources, garder les secrets hors du code. Il se termine sur les contrôles de sécurité qu'on ne réécrit pas, et sur une faille célèbre où tout tient à une longueur qu'on n'a pas vérifiée.
Le classement des failles applicatives courantes, l'OWASP Top 10, a déjà son billet sur le blog. Celui-ci part du geste plutôt que de la liste.
Valider ce qui entre
Toute donnée qui traverse une frontière de confiance est suspecte jusqu'à preuve du contraire. Le billet P10 a défini ces frontières. Le code est l'endroit où l'on tient la promesse : à chaque frontière, on vérifie.
Quatre règles font une bonne validation.
Valider côté serveur. Une vérification dans le navigateur ou l'application mobile améliore le confort de l'utilisateur. Elle ne protège rien, puisque l'appelant peut l'ignorer. C'est la règle du billet P11 sur le client.
Décrire ce qui est permis, pas ce qui est interdit. Une liste de caractères dangereux sera toujours incomplète. Une description de ce qu'on attend, un nombre entre 1 et 12, une heure au format HH:MM, un identifiant de 36 caractères, rejette tout le reste sans avoir à l'imaginer.
Valider tôt, à l'entrée, et une fois mise en forme. On ramène d'abord la donnée à sa forme canonique : encodage, majuscules, chemins relatifs résolus. Puis on la valide. L'inverse laisse passer ce qui ne devient dangereux qu'après transformation.
Valider le sens, pas seulement la forme. Une date bien formée peut être dans le passé. Un identifiant bien formé peut désigner l'objet d'un autre. La validation syntaxique ne remplace ni la règle métier ni l'autorisation.
Avec Spring, la validation déclarative couvre la forme à peu de frais.
public record ReservationRequest(
@NotBlank @Size(max = 80) String name,
@Min(1) @Max(12) int guests,
@Pattern(regexp = "^[0-9]{2}:[0-9]{2}$") String time) {
}
@PostMapping("/reservations")
ResponseEntity<Void> create(@Valid @RequestBody ReservationRequest request) {
// Le contrôleur ne reçoit que des requêtes de forme valide.
// Les règles métier (créneau ouvert, capacité) restent à vérifier dans le service.
return reservations.book(request);
}
Une requête qui ne respecte pas ces contraintes est rejetée avant d'atteindre le service. Le commentaire compte autant que le code : la forme est vérifiée, le sens ne l'est pas encore.
La figure 1 suit une requête de réservation jusqu'au service.
- L'appelant envoie sa requête de réservation au serveur
- La validation déclarative vérifie la forme : nom, nombre de convives, heure
- Une requête qui ne respecte pas ces contraintes est rejetée avant d'atteindre le service
- Le service vérifie les règles métier : créneau ouvert, capacité
Trois catégories d'entrées demandent une attention particulière.
| Entrée | Le danger | Le geste |
|---|---|---|
| Fichiers téléversés | Un nom qui remonte l'arborescence, un contenu qui ne correspond pas à l'extension, une archive qui se décompresse en plusieurs gigaoctets | Renommer à l'arrivée, vérifier le type réel, limiter la taille, stocker hors du répertoire servi |
| Formats structurés | Un document XML qui appelle une ressource externe, un objet sérialisé qui exécute du code à la lecture | Désactiver les entités externes, ne jamais désérialiser un format natif venu de l'extérieur |
| Adresses fournies par l'appelant | Le serveur va chercher une ressource interne pour le compte de l'attaquant | Liste fixe de destinations permises, résolution contrôlée |
La dernière ligne rappelle le cas Capital One du billet P2 : un serveur qu'on peut amener à faire des requêtes à sa place devient un relais vers l'intérieur.
En cuisine, c'est la réception des marchandises. On ne range rien en chambre froide sans avoir vérifié la température du camion, l'état de l'emballage et l'étiquette. Un colis douteux se refuse à la porte, pas à la cuisson.
Séparer le code des données
La plupart des injections ont la même cause : une donnée est collée dans une commande, et l'interpréteur ne sait plus où s'arrête l'une et où commence l'autre. La parade n'est pas de nettoyer la donnée. Elle est de ne jamais la mélanger au code.
// À éviter : la donnée devient du code SQL
jdbc.queryForList("SELECT * FROM reservations WHERE name = '" + name + "'");
// À préférer : la requête et la donnée voyagent séparément
jdbc.queryForList("SELECT * FROM reservations WHERE name = ?", name);
Dans la seconde forme, la base reçoit la structure de la requête d'un côté et la valeur de l'autre. Aucune valeur, quelle qu'elle soit, ne peut changer la structure.
La figure 2 met les deux formes côte à côte.
- La donnée devient du code SQL
- Aucune valeur ne change la structure
- Ce que la base reçoit
Le principe vaut pour tous les interpréteurs, pas seulement SQL.
| Interpréteur | L'injection | La forme sûre |
|---|---|---|
| Base de données | Une valeur qui ferme la chaîne et ajoute une clause | Requêtes paramétrées, ou un outil de persistance qui les génère |
| Système d'exploitation | Une valeur qui ajoute une seconde commande | Appeler le programme avec une liste d'arguments, jamais par un interpréteur de commandes |
| Annuaire | Un filtre qui élargit la recherche | Encoder les caractères spéciaux du filtre |
| Moteur de gabarits | Une valeur interprétée comme une expression | Ne jamais construire un gabarit à partir d'une entrée |
| Modèle de langage | Un texte qui contient des instructions | Voir le billet P11 : il n'existe pas de forme paramétrée fiable |
La dernière ligne n'est pas une plaisanterie. C'est le seul interpréteur courant pour lequel la séparation du code et des données n'existe pas, et c'est pourquoi sa sécurité se joue à l'architecture plutôt qu'au code.
Encoder ce qui sort
Valider à l'entrée ne suffit pas, parce qu'une même donnée peut être inoffensive dans un contexte et dangereuse dans un autre. Une apostrophe est un caractère normal dans un nom de famille. Elle devient un délimiteur dans du HTML, du JavaScript ou du SQL. On ne peut pas l'interdire à l'entrée. On doit l'encoder à la sortie, selon l'endroit où elle va.
La figure 3 pose les cinq contextes de sortie, le tableau dit qui encode à ta place.
les caractères qui ouvrent une balise"] D --> A["Attribut HTML
les guillemets, en plus"] D --> J["Code JavaScript
presque tout"] D --> U["Adresse web
les caractères réservés"] D --> L["Journal
les retours à la ligne"] class J risque
- Personne n'encode de façon fiable : ne pas y injecter de données
| Contexte de sortie | Ce qu'on encode | Ce qui le fait pour toi |
|---|---|---|
| Corps d'une page HTML | Les caractères qui ouvrent une balise | Le moteur de gabarits, s'il échappe par défaut |
| Attribut HTML | Les guillemets, en plus | Le même, à condition de mettre l'attribut entre guillemets |
| Code JavaScript | Presque tout | Personne de façon fiable : ne pas y injecter de données, passer par un attribut |
| Adresse web | Les caractères réservés | Les fonctions d'encodage d'URL de la plateforme |
| Journal | Les retours à la ligne | Un format structuré, qui sépare les champs |
La ligne du journal surprend souvent. Un utilisateur qui glisse un retour à la ligne dans son nom peut fabriquer une fausse ligne de journal, avec une fausse date et un faux événement. Un journal au format structuré, où chaque champ est séparé, ferme la porte.
Une politique de sécurité du contenu, envoyée par le serveur, ajoute une seconde barrière : elle dit au navigateur quels scripts il a le droit d'exécuter.
C'est le bord de l'assiette qu'on essuie. Ce qui sort du poste est fait pour le client, et seulement pour lui.
Échouer proprement
Le billet P2 a posé la règle de l'échec sûr. Le code est l'endroit où elle se tient, ou pas. Trois règles suffisent.
L'utilisateur reçoit un message, le journal reçoit les détails. Une trace d'exécution, un nom de table ou une version de composant dans une réponse d'erreur aident l'attaquant à cartographier le système. Le détail va dans le journal, avec une référence qu'on donne à l'utilisateur pour le retrouver.
Une exception ne laisse pas de porte ouverte. Le billet P2 montrait une variable initialisée à true avant un contrôle. La même famille d'erreurs se cache dans les blocs qui attrapent une exception et continuent comme si de rien n'était.
Une opération interrompue laisse un état cohérent. Un paiement débité sans réservation enregistrée, ou l'inverse, est une erreur d'intégrité. Les transactions et les opérations rejouables sans effet double existent pour cela.
Un gestionnaire d'erreurs central applique les deux premières règles partout à la fois.
@RestControllerAdvice
class ApiErrors {
private static final Logger log = LoggerFactory.getLogger(ApiErrors.class);
@ExceptionHandler(Exception.class)
ProblemDetail unexpected(Exception e) {
String incidentId = UUID.randomUUID().toString();
log.error("Unexpected error, incident {}", incidentId, e);
ProblemDetail problem = ProblemDetail.forStatus(HttpStatus.INTERNAL_SERVER_ERROR);
problem.setDetail("Erreur interne. Référence : " + incidentId);
return problem;
}
}
L'utilisateur voit une référence. L'exploitation retrouve la trace complète grâce à elle. L'attaquant n'apprend rien.
La figure 4 suit cette référence.
- Une requête provoque une erreur inattendue
- Le gestionnaire central génère une référence d'incident
- Le journal reçoit les détails : la trace complète, avec la référence
- L'utilisateur reçoit « Erreur interne » et la référence, sans aucun détail
- L'exploitation retrouve la trace complète grâce à la référence
Une nuance à garder en tête : uniformiser les erreurs a aussi un rôle de confidentialité. Le billet P7 recommandait de répondre « introuvable » à qui demande l'objet d'un autre, comme si l'objet n'existait pas. Le même raisonnement vaut pour la connexion : « identifiant ou mot de passe incorrect » ne dit pas lequel des deux est faux.
Il faut aussi surveiller les temps de réponse, qui peuvent trahir ce que le message cache. Le billet P3 en donnait un exemple avec la comparaison de secrets.
Tenir la mémoire et les ressources
Dans les langages qui laissent le programmeur gérer la mémoire, comme C et C++, une famille entière de failles vient de lectures et d'écritures hors des limites prévues. On lit au-delà de la fin d'un tampon, on écrit après avoir libéré, on libère deux fois. Le cas réel de ce billet en est un exemple.
Les langages à mémoire gérée, comme Java, rendent ces erreurs impossibles dans le code ordinaire : chaque accès à un tableau est vérifié. C'est une raison de sécurité à part entière pour choisir un langage, et plusieurs agences de sécurité encouragent désormais ce choix pour le code nouveau.
La mémoire gérée ne règle pourtant pas tout. Quatre sujets restent à la charge du développeur Java.
| Sujet | Ce qui peut arriver | Le geste |
|---|---|---|
| Code natif | Une bibliothèque qui appelle du C sous le capot hérite de ses failles | Savoir quelles dépendances embarquent du natif, les tenir à jour |
| Épuisement des ressources | Une requête qui alloue sans limite, un fichier lu en entier, une expression régulière qui s'emballe | Bornes sur les tailles, délais d'attente, lecture en flux |
| Fuites de ressources | Des connexions ou des fichiers jamais fermés, jusqu'à l'arrêt du service | Fermeture automatique, pools bornés |
| Concurrence | Deux requêtes qui modifient le même état, une vérification et un usage séparés dans le temps | Opérations atomiques, verrous en base, contrôle de version optimiste |
La dernière ligne cache une faille classique : on vérifie qu'il reste une place, puis on réserve. Entre les deux, une autre requête a pris la place. Deux clients ont réservé la même table. La vérification et l'action doivent être une seule opération, typiquement en base.
La figure 5 déroule cette course entre deux requêtes.
Les données sensibles en mémoire posent une dernière question. Un mot de passe stocké dans une chaîne de caractères reste en mémoire jusqu'à ce que le ramasse-miettes la récupère, et il peut se retrouver dans un vidage mémoire. C'est l'hypothèse qu'avançait Microsoft pour la clé du billet P3. On limite la durée de vie des secrets en mémoire, et on traite les vidages mémoire comme des données restreintes.
Garder les secrets hors du code
Un secret dans le code source est publié à tous ceux qui lisent le dépôt, aujourd'hui et pour toujours, puisque l'historique le garde. Un secret dans une image de conteneur est publié à tous ceux qui la téléchargent. Un secret dans un fichier de configuration versionné l'est aussi.
La règle est simple : le code ne contient pas les secrets, il sait où les demander.
# application.yml : le code nomme le secret, il ne le contient pas
payment:
api-key: ${PAYMENT_API_KEY}
La valeur arrive à l'exécution, depuis un coffre à secrets ou l'environnement fourni par la plateforme. Le billet P10 classait le coffre parmi les briques qu'on ne fabrique pas.
La figure 6 sépare ce que contient le dépôt de ce qui arrive à l'exécution.
application.yml nomme PAYMENT_API_KEY"] -->|"nom du secret"| APP["Application à l'exécution"] COF["Coffre à secrets"] e1@-->|"valeur du secret"| APP ENV["Environnement fourni par la plateforme"] e2@-->|"valeur du secret"| APP e1@{ animate: true } e2@{ animate: true } class DEP sain
- Le dépôt ne contient pas le secret
- La valeur du secret, à l'exécution
Quatre pratiques complètent la règle.
- Détecter avant le commit. Un outil sur le poste du développeur et dans la chaîne de fabrication repère les formes connues de clés et de mots de passe. C'était la première ligne de la feuille de route du billet P4.
- Considérer un secret publié comme compromis. Le retirer du dépôt ne suffit pas : il est dans l'historique, et peut-être déjà copié. On le révoque et on le remplace.
- Préférer les secrets de courte durée. Un jeton qui expire dans une heure vaut beaucoup moins, volé, qu'une clé permanente. Quand la plateforme sait fournir une identité au service, on n'a même plus de secret à gérer.
- Ne pas journaliser les secrets. Un journal qui recopie les en-têtes d'une requête recopie les jetons qui s'y trouvent.
C'est la clé de la cave. Elle n'est pas gravée sur la porte. Elle est dans le coffre du chef, qui la confie pour un service et la reprend après.
Les contrôles qu'on ne réécrit pas
Le plan d'examen consacre un objectif à la mise en œuvre des contrôles de sécurité : authentification, sessions, autorisation, cryptographie, journalisation. Le message du billet P10 vaut ici à la ligne de code près : on les prend dans le socle du cadre applicatif, et on les configure bien.
| Contrôle | Ce que fournit le socle | Ce qui reste à ta charge |
|---|---|---|
| Authentification | Les protocoles standard, la vérification des jetons | Le choix du fournisseur, la configuration des audiences et des émetteurs |
| Sessions | Identifiant aléatoire, renouvellement à la connexion, cookies protégés | La durée d'inactivité, la déconnexion réelle côté serveur |
| Requêtes intersites forgées | Un jeton de protection, actif par défaut pour les sessions | Ne pas le désactiver « pour que ça marche » |
| En-têtes de sécurité | Un jeu d'en-têtes par défaut | La politique de sécurité du contenu, propre à ton application |
| Autorisation | Le mécanisme de règles par route et par méthode | Les règles elles-mêmes, et le contrôle d'appartenance par objet |
| Mots de passe | Les encodeurs adaptés, vus au billet P3 | Le choix de l'encodeur et sa migration |
La colonne de droite montre que « utiliser le socle » n'est pas « ne rien faire ». Le socle donne de bons réglages par défaut. Les failles apparaissent là où quelqu'un les a changés, souvent pour débloquer un test un vendredi soir.
Scénario : Heartbleed, ou la longueur qu'on a crue sur parole
Le 7 avril 2014, le projet OpenSSL publie un avis de sécurité. OpenSSL est la bibliothèque qui chiffre une grande partie des connexions sécurisées sur Internet. La faille avait été trouvée indépendamment par des chercheurs de Google et de la société Codenomicon. On l'appelle Heartbleed.
Elle se trouve dans le code d'une extension du protocole, le battement de cœur. Le principe est simple : un côté envoie un petit message accompagné de sa longueur, l'autre côté le renvoie tel quel pour prouver que la connexion est vivante. Cette extension avait été ajoutée dans la version 1.0.1, publiée en 2012.
Le code du serveur ne vérifiait pas que la longueur annoncée correspondait à la longueur réelle du message. Un attaquant envoyait quatre octets en annonçant soixante-quatre kilo-octets. Le serveur copiait alors soixante-quatre kilo-octets à partir de l'adresse du message, et les renvoyait. Avec ses quatre octets, il renvoyait tout ce qui se trouvait à côté en mémoire.
La figure 7 déroule un battement falsifié.
- L'attaquant envoie quatre octets en annonçant soixante-quatre kilo-octets
- Le serveur ne vérifie pas que la longueur annoncée correspond à la longueur réelle
- Il copie soixante-quatre kilo-octets à partir de l'adresse du message
- Avec ses quatre octets, il renvoie tout ce qui se trouvait à côté en mémoire
- L'attaque se répète autant de fois que voulu, chaque requête ramène un nouveau morceau
Ce qui se trouvait à côté pouvait être n'importe quoi : des mots de passe, des cookies de session, des jetons, des données d'autres utilisateurs, et parfois la clé privée du serveur. L'attaque ne demandait ni authentification ni compétence particulière. Elle pouvait être répétée autant de fois que voulu, chaque requête ramenant un nouveau morceau. La limite de soixante-quatre kilo-octets s'appliquait à chaque battement, pas à l'attaque.
La faille touchait les versions 1.0.1 à 1.0.1f. La version 1.0.1g la corrigeait. Elle est classée dans la famille des lectures hors limites. Aucun algorithme cryptographique n'était cassé : la connexion restait chiffrée, et c'est par le chiffrement lui-même qu'on faisait sortir les secrets.
Relisons-la avec les gestes de ce billet.
| Geste | Ce que montre Heartbleed | Ce qu'il aurait fallu |
|---|---|---|
| Valider ce qui entre | Une longueur fournie par l'appelant, utilisée sans contrôle | Comparer la longueur annoncée à la longueur reçue, et rejeter l'écart |
| Valider le sens | La longueur était bien formée ; elle mentait | Une valeur cohérente avec les autres données de la requête |
| Tenir la mémoire | Une copie qui lit au-delà du tampon | Un langage ou une bibliothèque qui vérifie les limites |
| Garder les secrets | La clé privée du serveur en mémoire du même processus | Une clé dans un module séparé, comme au billet P3 |
| Réduire la surface | Une extension active par défaut, que peu de services utilisaient | Activer ce dont on a besoin, pas plus |
La première ligne résume l'affaire. Le correctif tient en quelques lignes : vérifier que le message est au moins aussi long qu'il le prétend, et l'ignorer sinon. Aucune nouveauté technique, aucun mécanisme savant. Le geste du cuisinier qui ouvre le colis avant de le ranger.
La deuxième ligne explique pourquoi cette erreur est si courante. La longueur était un nombre valide. Une validation de forme l'aurait laissée passer. Seule une validation de sens, qui la confronte à ce qu'on a réellement reçu, l'arrête.
La quatrième rappelle que le code parfait n'existe pas. Même avec la faille, un serveur dont la clé privée vivait ailleurs aurait perdu des sessions, pas son identité. C'est la défense en profondeur appliquée aux secrets.
La dernière, enfin, prépare les billets suivants. Un très grand nombre de serveurs ont dû être corrigés, et beaucoup de leurs exploitants ont d'abord dû découvrir qu'ils utilisaient OpenSSL. Savoir ce que contient son logiciel est le sujet du billet P16.
Testez-vous
Pourquoi décrire ce qui est permis plutôt que ce qui est interdit ?
Une liste de caractères dangereux sera toujours incomplète. Une description de ce qu'on attend rejette tout le reste sans avoir à l'imaginer.
Quand une erreur inattendue survient, que reçoit l'utilisateur et où vont les détails ?
L'utilisateur reçoit un message et une référence. Le détail va dans le journal, où l'exploitation retrouve la trace complète grâce à cette référence.
Pourquoi une validation de forme n'aurait-elle pas arrêté Heartbleed ?
La longueur annoncée était un nombre valide. Seule une validation de sens, qui la confronte à ce qu'on a réellement reçu, l'arrête.
Points clés
- Toute donnée qui traverse une frontière se valide côté serveur, en décrivant ce qui est permis, après mise en forme canonique, sur la forme puis sur le sens.
- Les injections disparaissent quand le code et les données voyagent séparément : requêtes paramétrées, arguments séparés, gabarits fixes.
- Ce qui sort s'encode selon son contexte. Le danger se trouve là où l'on désactive l'échappement par défaut.
- Une erreur donne une référence à l'utilisateur et les détails au journal. Elle ne laisse ni porte ouverte ni état incohérent.
- La mémoire gérée supprime une famille de failles. Restent le code natif, l'épuisement, les fuites et la concurrence.
- Le code nomme ses secrets, il ne les contient pas. Un secret publié est un secret compromis.
- Les contrôles de sécurité viennent du socle. Toute ligne qui en désactive un se justifie et se date.
Dans la série
Palier 2 : Tenir les fourneaux. Domaine : Implémentation.
- Précédent : Revue d'architecture : non-fonctionnel et architecture d'exploitation
- Suivant : Revue de code sécurité : analyse statique, CWE, CVSS, remédiation
- Vue d'ensemble : Sécurité du cycle de vie logiciel : par où commencer dans La Brigade
Pour aller plus loin
- CSSLP Certification Exam Outline, ISC2 : objectifs 5.1 et 5.3.
- Heartbleed Bug, OWASP.
- Heartbleed bug exposes OpenSSL installations, LWN, 9 avril 2014.
- Sécuriser le code et les API : OWASP Top 10, SAST, DAST, SCA, sur ce blog.