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.

En bref. Ce billet passe en revue les gestes du code sécurisé : valider ce qui entre, séparer le code des données, encoder ce qui sort, échouer proprement, tenir la mémoire, garder les secrets hors du code. Le cas réel est Heartbleed, publié le 7 avril 2014 : le serveur OpenSSL croyait sur parole la longueur annoncée par l'appelant.

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.

Appelant Contrôleurvalidation de forme Servicerègles métier requête 1 2 forme invalide 3 forme valide 4 1 2 3 4 1. L'appelant envoie sa requête de réservation au serveur 2. La validation déclarative vérifie la forme : nom, nombre de convives, heure 3. Une requête qui ne respecte pas ces contraintes est rejetée avant d'atteindre leservice 4. Le service vérifie les règles métier : créneau ouvert, capacité
  1. L'appelant envoie sa requête de réservation au serveur
  2. La validation déclarative vérifie la forme : nom, nombre de convives, heure
  3. Une requête qui ne respecte pas ces contraintes est rejetée avant d'atteindre le service
  4. Le service vérifie les règles métier : créneau ouvert, capacité
Figure 1 : la forme se vérifie au contrôleur, le sens dans le service

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.

À retenir. La validation dit ce qu'on attend. Tout le reste est refusé sans qu'on ait eu à l'imaginer.

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
Figure 2 : la donnée collée dans la commande, ou la requête et la donnée séparées

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.

  • Personne n'encode de façon fiable : ne pas y injecter de données
Figure 3 : une même donnée, cinq contextes de sortie, cinq encodages
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.

Piège. Les moteurs de gabarits modernes échappent par défaut. Le danger vient des endroits où l'on désactive ce comportement « pour afficher du gras ». Une revue de code doit chercher ces endroits en premier.

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.

Utilisateur Gestionnaired'erreurs Journal Exploitation requête 1 2 trace et référence 3 message etréférence 4 référence 5 1 2 3 4 5 1. Une requête provoque une erreur inattendue 2. Le gestionnaire central génère une référence d'incident 3. Le journal reçoit les détails : la trace complète, avec la référence 4. L'utilisateur reçoit « Erreur interne » et la référence, sans aucun détail 5. L'exploitation retrouve la trace complète grâce à la référence
  1. Une requête provoque une erreur inattendue
  2. Le gestionnaire central génère une référence d'incident
  3. Le journal reçoit les détails : la trace complète, avec la référence
  4. L'utilisateur reçoit « Erreur interne » et la référence, sans aucun détail
  5. L'exploitation retrouve la trace complète grâce à la référence
Figure 4 : une référence pour l'utilisateur, les détails pour le journal

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.

À retenir. Une erreur bien gérée ne dit rien à l'attaquant et tout à l'exploitation.

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.

Figure 5 : une vérification et une réservation séparées dans le temps

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.

  • Le dépôt ne contient pas le secret
  • La valeur du secret, à l'exécution
Figure 6 : le dépôt nomme le secret, la valeur arrive à 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.

En pratique. Une règle de revue utile tient en une phrase : toute ligne qui désactive un mécanisme de sécurité porte un commentaire qui dit pourquoi, et un ticket qui dit quand on la retire.
À retenir. Le socle fournit de bons réglages. La faille commence à la ligne qui les désactive.

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

Même processus Attaquant Serveur OpenSSL Mémoire voisinejetons, clé privée 4 octets, 64 ko annoncés 1 2 mémoire voisine 3 64 ko renvoyés 4 5 1 2 3 4 5 1. L'attaquant envoie quatre octets en annonçant soixante-quatre kilo-octets 2. Le serveur ne vérifie pas que la longueur annoncée correspond à la longueur réelle 3. Il copie soixante-quatre kilo-octets à partir de l'adresse du message 4. Avec ses quatre octets, il renvoie tout ce qui se trouvait à côté en mémoire 5. L'attaque se répète autant de fois que voulu, chaque requête ramène un nouveaumorceau
  1. L'attaquant envoie quatre octets en annonçant soixante-quatre kilo-octets
  2. Le serveur ne vérifie pas que la longueur annoncée correspond à la longueur réelle
  3. Il copie soixante-quatre kilo-octets à partir de l'adresse du message
  4. Avec ses quatre octets, il renvoie tout ce qui se trouvait à côté en mémoire
  5. L'attaque se répète autant de fois que voulu, chaque requête ramène un nouveau morceau
Figure 7 : Heartbleed, quatre octets envoyés, soixante-quatre kilo-octets renvoyés

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.

À retenir. Une longueur fournie par l'appelant est une affirmation. Le code doit la vérifier comme n'importe quelle autre.

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.


Pour aller plus loin