Le chef ne déguste pas au hasard

Au passe, le chef ne déguste pas au hasard. Il sait que la sauce béarnaise tourne quand on la presse, que le poisson du jour sort d'un nouveau fournisseur, que le commis arrivé lundi n'a jamais fait ce dressage. Il regarde ces assiettes-là avec plus d'attention que les autres. Et la veille d'un changement de carte, il fait cuire chaque nouveau plat en entier, dans les conditions du service, pour voir ce qui se passe quand on en envoie quarante d'affilée.

Il y a aussi ce qu'il ne goûte jamais mais vérifie quand même. Ce qu'un cuisinier a ajouté « pour essayer » et oublié de retirer. Le bac de préparation qui n'appartient à aucun plat de la carte.

Une stratégie de test de sécurité fait la même chose pour un logiciel. Elle dit quoi tester, avec quelle technique, à quel moment et jusqu'où. Elle vérifie que la documentation dit vrai. Et elle cherche ce que le logiciel fait sans que personne ne l'ait décrit. Ce billet ouvre le domaine Tests, et son cas réel montre ce qui arrive quand une partie de ce qu'on livre n'est pas testée comme le reste.

En bref. Ce billet pose les cinq questions d'une stratégie de test de sécurité et compare les techniques par ce qu'elles ne voient pas. Il montre ensuite comment écrire les cas de test, vérifier la documentation et chercher les fonctions non documentées. Le cas réel est l'incident CrowdStrike du 19 juillet 2024, lu dans l'analyse des causes que l'éditeur a publiée le 6 août.

Une stratégie avant des outils

Une organisation qui achète trois outils de test de sécurité n'a pas une stratégie. Elle a trois outils. La stratégie répond d'abord à cinq questions, et c'est leurs réponses qui décident des outils.

Question Ce qu'elle décide D'où vient la réponse
Que doit-on prouver ? Les exigences et menaces à couvrir Les exigences du palier 1, le modèle de menaces du billet P12
Avec quelle profondeur ? L'effort par composant La classification des données et l'analyse de risque
Avec quelles techniques ? Le mélange d'outils et de tests manuels Ce que chaque technique sait trouver
À quel moment ? L'emplacement dans le cycle La méthode de développement, billet P4
Quand a-t-on fini ? Les critères de sortie L'appétit pour le risque, billet P6

La figure 1 reprend la colonne de droite : d'où vient chaque réponse, et ce que la stratégie en fait.

Classification etrisque Exigences etmenacespalier 1, billet P12 Stratégie detest Outils et testsmanuels Méthode dedéveloppementbillet P4 Appétit pourle risquebillet P6 ce qu'on doit prouver 1 effort par composant 2 emplacement 3 critères de sortie 4 techniques 5 1 2 3 4 5 1. Les exigences du palier 1 et le modèle de menaces donnent les exigences etmenaces à couvrir 2. La classification des données et l'analyse de risque fixent la profondeur 3. La méthode de développement décide du moment dans le cycle 4. L'appétit pour le risque dit quand on a fini 5. Le mélange d'outils et de tests manuels suit ce que chaque technique sait trouver
  1. Les exigences du palier 1 et le modèle de menaces donnent les exigences et menaces à couvrir
  2. La classification des données et l'analyse de risque fixent la profondeur
  3. La méthode de développement décide du moment dans le cycle
  4. L'appétit pour le risque dit quand on a fini
  5. Le mélange d'outils et de tests manuels suit ce que chaque technique sait trouver
Figure 1 : les réponses qui décident des outils

La première ligne est la plus négligée. Un plan de test de sécurité qui ne cite aucune exigence ne peut pas dire ce qu'il a prouvé. On reprend la matrice de traçabilité du billet P9 : chaque exigence de sécurité a au moins un test, et chaque menace retenue au billet P12 a un test qui vérifie sa parade.

La dernière ligne est la plus difficile. Les tests de sécurité ne finissent jamais d'eux-mêmes : on peut toujours chercher plus longtemps. Les critères de sortie se décident à l'avance. Aucun défaut critique ouvert, toutes les exigences du premier rang couvertes, les défauts élevés acceptés par écrit par celui qui porte le risque. Sans ces critères, la fin des tests arrive le jour où le calendrier l'impose.

À retenir. Un plan de test qui ne cite aucune exigence ne peut dire ni ce qu'il a prouvé, ni ce qui lui a échappé.

Les techniques, et ce que chacune voit

Le blog a déjà un billet qui classe les outils par famille. Ce tableau-ci les regarde sous l'angle de la stratégie : ce que chaque technique trouve, et ce qu'elle ne trouvera jamais.

Technique Ce qu'elle fait Ce qu'elle trouve bien Ce qu'elle ne voit pas Moment
Analyse statique Lit le code sans l'exécuter Injections, fonctions dangereuses, code mort Logique métier, configuration d'exploitation À chaque changement
Analyse des dépendances Compare l'inventaire aux failles publiques Composants vulnérables Tout ce qui est dans ton code À chaque build et en continu
Analyse dynamique Attaque l'application en fonctionnement, de l'extérieur Configuration, en-têtes, injections atteignables Le code qu'elle n'atteint pas Sur un environnement déployé
Analyse interactive Observe l'application de l'intérieur pendant les tests Le chemin exact d'une donnée jusqu'à son usage Ce que les tests n'exécutent pas Pendant les tests fonctionnels
Fuzzing Envoie des entrées aléatoires ou malformées par millions Plantages, lectures hors limites, cas limites Les failles qui ne plantent rien En continu sur les analyseurs et formats
Tests d'abus Vérifient qu'un scénario d'attaque échoue Autorisation, contournement de parcours Ce qu'on n'a pas pensé à écrire À chaque build
Test d'intrusion Un humain attaque comme un adversaire Enchaînements, logique, conception Ce qui est hors du périmètre ou du temps imparti Avant une mise en service majeure, puis périodiquement
Revue de configuration Compare le déploiement à la configuration de référence Réglages dangereux, ports ouverts, droits trop larges Le code À chaque déploiement

Trois remarques sur ce tableau.

La colonne « ce qu'elle ne voit pas » est la plus utile. Une stratégie se construit en couvrant chaque angle mort par une autre technique. Le test d'intrusion couvre la logique que les outils ignorent. Les outils couvrent l'étendue que le test d'intrusion n'a pas le temps de parcourir.

Le fuzzing mérite plus de place qu'on ne lui en donne. C'est la technique qui trouve le mieux les failles de type Heartbleed, vues au billet P14 : une entrée malformée que personne n'aurait écrite à la main. En Java, un outil comme Jazzer s'intègre aux tests unitaires.

@FuzzTest
void parserNeverCrashes(FuzzedDataProvider data) {
    String input = data.consumeRemainingAsString();
    try {
        ReservationParser.parse(input);
    } catch (InvalidReservationException expected) {
        // Un refus propre est le comportement attendu.
        // Toute autre exception fait échouer le test.
    }
}

Le test ne dit pas ce que l'analyseur doit produire. Il dit seulement qu'aucune entrée, quelle qu'elle soit, ne doit le faire tomber autrement que par un refus prévu.

La figure 2 montre les deux issues de ce test.

Test de fuzzingJazzer AnalyseurReservationParser Test en échec entrée malformée 1 refus prévu 2 autre exception 3 1 2 3 1. Le test envoie une entrée aléatoire ou malformée, que personne n'aurait écrite à lamain 2. L'analyseur refuse proprement : c'est le comportement attendu 3. Toute autre exception fait échouer le test
  1. Le test envoie une entrée aléatoire ou malformée, que personne n'aurait écrite à la main
  2. L'analyseur refuse proprement : c'est le comportement attendu
  3. Toute autre exception fait échouer le test
Figure 2 : ce que le test de fuzzing accepte, et ce qui le fait échouer

Le test d'intrusion, enfin, n'est pas une stratégie à lui seul. C'est une photographie, prise par quelques personnes pendant quelques jours, sur un périmètre donné. Il trouve ce que les outils ne trouvent pas, et il ne remplace aucun d'eux.

Le périmètre du test d'intrusion. Son rapport ne vaut que par la précision de son périmètre : ce qui en était exclu n'a pas été testé, quel que soit le ton rassurant de la conclusion.

Placer les tests dans le cycle

Les techniques se répartissent le long du cycle de livraison du billet P4. Les plus rapides tournent à chaque changement, les plus lourdes plus rarement. La figure 3 les place sur la chaîne.

Figure 3 : chaque technique à son rythme. Le fuzzing long tourne en parallèle et alimente la chaîne quand il trouve

Une règle simple décide de l'emplacement : un test se place au plus tôt là où il peut être exécuté sans ralentir le travail au point qu'on le contourne. Un test d'abus qui dure trois secondes va dans le build. Une analyse dynamique complète qui dure trois heures tourne la nuit sur l'environnement de test.

La colonne de droite rappelle que tester ne s'arrête pas à la mise en service. Un composant sans faille connue le jour de la livraison en aura une le mois suivant. Les tests de production sont le sujet du palier 3.


Écrire les cas de test

Un cas de test de sécurité a la même forme qu'un autre : des conditions initiales, une action, un résultat attendu. Ce qui change, c'est l'origine du cas et la nature de l'attente.

Les cas viennent de trois sources, toutes produites au palier 1 et au début du palier 2.

Source Exemple Le cas de test
Exigence de sécurité Une session inactive est fermée après quinze minutes Ouvrir une session, attendre seize minutes, appeler une route protégée : refus attendu
Cas d'abus Un client lit la commande d'un autre en changeant l'identifiant Deux comptes, une commande de B, une requête de A : « introuvable » attendu
Menace du modèle M5 : les allergies sont recopiées dans les journaux Créer une réservation avec une allergie, lire les journaux : aucune occurrence attendue

La troisième ligne montre un test qu'on oublie souvent : celui qui vérifie qu'une chose n'a pas eu lieu. Personne ne verra jamais l'absence d'un champ dans un journal. Seul un test peut la prouver, et la prouver à chaque build.

Trois familles de cas reviennent dans presque toutes les applications et méritent un gabarit commun.

  • Les cas négatifs. Toute fonction de sécurité se teste en lui demandant de dire non. C'est la leçon de « goto fail » au billet P15.
  • Les cas limites. La valeur juste au-dessus et juste en dessous de chaque borne. Douze couverts acceptés, treize refusés. Le champ de 80 caractères accepté, celui de 81 refusé.
  • Les cas de rôle. Chaque route appelée avec chaque rôle, y compris aucun. Le tableau des réponses attendues se génère à partir des règles d'autorisation, et tout écart est un défaut.

La figure 4 rassemble les trois sources et les trois familles.

  • Ce que chaque source apporte au cas de test
Figure 4 : trois sources de cas de test, trois familles à gabarit commun

En cuisine, ce sont les essais de la veille d'une nouvelle carte. On ne vérifie pas seulement que le plat est bon. On vérifie ce qui se passe s'il attend cinq minutes sous la lampe, s'il part sans sa garniture, si on en envoie quarante de suite.


Vérifier que la documentation dit vrai

Le plan d'examen consacre un objectif à la vérification de la documentation, et il a raison. Un exploitant ne lit pas le code. Il lit le guide d'installation, le manuel d'administration, la description de l'API. Si ces documents mentent, il déploiera un système qui ne se comporte pas comme il le croit.

Document Ce qu'on vérifie L'écart typique
Guide d'installation Les réglages par défaut décrits sont ceux qui s'appliquent Le guide dit « désactivé par défaut », le paramètre est actif
Manuel d'administration Chaque réglage de sécurité a l'effet décrit Un paramètre renommé, l'ancien nom ignoré sans avertissement
Description de l'API Toutes les routes exposées y figurent, avec leur authentification Une route exposée et absente de la description
Matrice des rôles Chaque rôle a exactement les droits décrits Un rôle « lecture seule » qui peut exporter
Procédure de restauration La procédure fonctionne, dans le délai annoncé Une étape manquante, découverte le jour de l'incident
En pratique. La méthode est toujours la même : on lit le document comme un exploitant, on fait ce qu'il dit, et on observe.

Une partie s'automatise. Comparer la liste des routes réellement exposées à la description de l'API, par exemple, se fait à chaque build, et tout écart arrête la chaîne. La figure 5 dessine cette comparaison.

  • Les deux listes comparées à chaque build
Figure 5 : les routes exposées comparées à la description de l'API, à chaque build

La dernière ligne rejoint le billet P13. Une procédure de restauration qu'on n'a jamais déroulée est une hypothèse, pas une procédure.


Chercher ce que personne n'a décrit

Une fonction non documentée est un comportement du logiciel qui ne figure dans aucune exigence, aucune spécification, aucun manuel. Elle n'est pas forcément malveillante. Elle est presque toujours dangereuse, parce que personne ne la surveille et que personne n'a pensé à la protéger.

Ce qu'on trouve D'où ça vient Pourquoi c'est dangereux
Route de diagnostic ou de débogage Ajoutée pour dépanner, jamais retirée Elle expose l'état interne, parfois sans authentification
Compte de test Créé pour la recette, livré avec le produit Un mot de passe connu de tous ceux qui ont lu le code
Paramètre caché Un drapeau qui change le comportement, connu des développeurs Il contourne un contrôle si on le découvre
Interface d'administration oubliée Une ancienne console, remplacée mais toujours déployée Les contrôles de l'époque, comme l'API d'Optus au billet P11
Fonction cachée volontaire Un clin d'œil de développeur, un « œuf de Pâques » Du code jamais relu ni testé, dans le produit livré
Porte dérobée Un accès ajouté volontairement, par un initié ou un composant piégé Le pire cas : le sujet du billet P23

La cinquième ligne a une histoire. Les œufs de Pâques, ces fonctions cachées que les développeurs glissaient dans les logiciels, ont largement disparu des produits Microsoft avec l'initiative de 2002 vue au billet P4. La raison n'était pas le sérieux : c'était que du code que personne n'avait demandé n'avait été ni relu ni testé.

Trois techniques permettent de chercher.

Comparer ce qui est exposé à ce qui est décrit. Lister toutes les routes, tous les ports, tous les paramètres de configuration reconnus, et rapprocher la liste de la documentation. Ce qui n'apparaît que d'un côté est un défaut. Avec Spring Boot, les points de supervision sont un exemple classique : n'expose que ce dont l'exploitation a besoin.

# Seul le point de santé est exposé sur le web.
# Tout autre point de supervision doit être ajouté explicitement, et documenté.
management.endpoints.web.exposure.include=health

Lire la matrice de traçabilité à l'envers. Le billet P9 le suggérait : du code qui ne se rattache à aucune exigence est soit du confort, soit une fonction que personne n'a demandée.

Comparer le livrable au code relu. Ce qui part en production est-il ce qu'on a relu ? C'est la question du billet P16, et le cas SolarWinds y répondait par la négative.

La figure 6 met ces trois comparaisons côte à côte.

  • Ce que personne n'a décrit, personne ne l'a protégé
Figure 6 : trois comparaisons pour trouver ce que personne n'a décrit

En cuisine, c'est le bac au fond de la chambre froide qui n'appartient à aucun plat de la carte. Personne ne sait qui l'a préparé ni quand. On ne le goûte pas pour savoir s'il est bon. On le jette, et on cherche pourquoi il est là.

À retenir. Ce que le logiciel fait sans que personne l'ait décrit, personne ne l'a protégé.

Scénario : CrowdStrike, le 19 juillet 2024, ou le contenu qu'on ne testait pas comme du code

Le 19 juillet 2024, des millions d'ordinateurs Windows s'arrêtent sur un écran d'erreur et ne redémarrent plus. Des aéroports, des hôpitaux, des banques et des médias sont touchés. La cause est une mise à jour du capteur Falcon, le logiciel de sécurité de l'éditeur CrowdStrike, installé sur ces machines. Il n'y a pas d'attaque. L'éditeur publie son analyse des causes le 6 août 2024.

Pour comprendre l'incident, il faut distinguer deux choses que livre l'éditeur. D'un côté, le code du capteur, mis à jour de temps en temps. De l'autre, du contenu de détection, livré beaucoup plus souvent pour suivre les nouvelles menaces sans toucher au code. Ce contenu se compose de règles, écrites selon des modèles compilés dans le capteur. Un composant du capteur, l'interpréteur de contenu, applique ces règles. Un outil de l'éditeur, le validateur de contenu, vérifie les règles avant leur envoi.

En février 2024, une nouvelle version du capteur introduit un modèle de détection destiné aux communications entre processus. Sa définition prévoit vingt et un champs d'entrée. Le code du capteur, lui, n'en fournit que vingt. L'écart passe inaperçu. Les règles livrées dans les mois suivants utilisent toutes un joker sur le vingt et unième champ : elles ne le lisent jamais.

Le 19 juillet, deux nouvelles règles sont envoyées. L'une d'elles compare le vingt et unième champ à une valeur précise. L'interpréteur essaie de lire une entrée qui n'existe pas, lit en dehors de son tableau, et la machine tombe. Comme le capteur s'exécute au cœur du système, la machine tombe à chaque redémarrage.

L'analyse explique pourquoi les tests n'ont rien vu. La suite automatique utilisait douze cas de test, tous avec un joker sur le vingt et unième champ. Le test de charge utilisait un seul exemple, qui ne déclenchait pas non plus le problème. Le validateur, enfin, vérifiait les règles contre la définition erronée à vingt et un champs : il les jugeait correctes. Et le contenu était envoyé à toutes les machines à la fois, sans déploiement progressif.

La figure 7 reprend le déroulé, de février au 19 juillet.

CrowdStrikel'éditeur MachinesWindowscapteur Falcon Validateur decontenu version du capteur 1 2 deux nouvelles règles 3 règles jugées correctes 4 5 6 1 2 3 4 5 6 1. Février 2024 : le nouveau modèle prévoit 21 champs d'entrée, le code du capteurn'en fournit que 20 2. Dans les mois suivants, les règles utilisent un joker sur le 21e champ : elles ne lelisent jamais 3. Le 19 juillet, l'une des deux règles compare le vingt et unième champ à une valeurprécise 4. Vérifiées contre la définition à 21 champs, elles partent vers toutes les machines à lafois 5. L'interpréteur lit une entrée qui n'existe pas, en dehors de son tableau, et lamachine tombe 6. Le capteur s'exécute au cœur du système : la machine tombe à chaqueredémarrage
  1. Février 2024 : le nouveau modèle prévoit 21 champs d'entrée, le code du capteur n'en fournit que 20
  2. Dans les mois suivants, les règles utilisent un joker sur le 21e champ : elles ne le lisent jamais
  3. Le 19 juillet, l'une des deux règles compare le vingt et unième champ à une valeur précise
  4. Vérifiées contre la définition à 21 champs, elles partent vers toutes les machines à la fois
  5. L'interpréteur lit une entrée qui n'existe pas, en dehors de son tableau, et la machine tombe
  6. Le capteur s'exécute au cœur du système : la machine tombe à chaque redémarrage
Figure 7 : CrowdStrike, de la version de février 2024 à l'arrêt des machines le 19 juillet

L'éditeur liste six constats et autant de mesures : vérifier le nombre de champs à la compilation, ajouter des contrôles de limites dans l'interpréteur, tester chaque champ de chaque modèle avec des valeurs précises, corriger le validateur, tester chaque nouvelle règle avant envoi, déployer par vagues avec un temps d'observation et la possibilité de revenir en arrière. Il annonce aussi du fuzzing sur ces composants, et des revues indépendantes de son code et de son processus qualité.

Relisons l'incident avec la stratégie de ce billet.

Sujet de ce billet Ce que montre l'analyse Ce que la stratégie aurait dû prévoir
Que doit-on prouver ? Le contenu de détection n'était pas traité comme du code Tout ce qui change le comportement du logiciel se teste comme du code
Cas limites Douze cas, tous avec un joker sur le dernier champ Chaque champ testé avec une valeur précise, y compris le dernier
Fuzzing Une lecture hors limites, déclenchée par une entrée inhabituelle Le fuzzing de l'interpréteur, le type de faute qu'il trouve le mieux
Vérifier la documentation Une définition à 21 champs, un code qui en fournit 20 Un test qui confronte la définition au comportement réel
Validateur Un outil de contrôle qui partageait l'erreur qu'il devait trouver Un contrôle indépendant de la source qu'il vérifie
Critères de sortie et déploiement Un envoi à toutes les machines à la fois Un déploiement par vagues, avec une condition d'arrêt

La première ligne est le cœur du cas. Le code du capteur suivait un processus de test complet. Le contenu suivait un circuit plus court, parce qu'il devait partir vite et qu'il était vu comme de la donnée. Or cette donnée pilotait du code exécuté au cœur du système. C'est la leçon la plus large de l'incident : une configuration, un jeu de règles, un modèle, tout ce qui change ce que fait un programme est du code, et se teste comme tel.

La cinquième ligne mérite qu'on s'y arrête. Le validateur existait, et il a donné son accord. Il le donnait parce qu'il lisait la même définition fausse que tout le reste. Un contrôle qui partage les hypothèses de ce qu'il vérifie confirme ses erreurs au lieu de les trouver. On retrouve la défense en profondeur du billet P2 : des couches qui tombent ensemble ne sont pas des couches.

La dernière ligne rejoint le billet P13. Un envoi progressif aurait limité la casse au premier cercle de machines, et donné le temps de s'arrêter. Le critère de sortie d'un test ne s'arrête pas à la porte du laboratoire. Le premier cercle de production fait partie du plan de test.

Il faut saluer une chose. L'analyse publiée est précise, chiffrée, et elle nomme les défauts sans détour. C'est un document de référence pour quiconque écrit une stratégie de test.

À retenir. Ce qui change le comportement d'un programme est du code. Peu importe qu'on l'appelle donnée, règle ou configuration.

Testez-vous

Pourquoi les critères de sortie se décident-ils à l'avance ?

Les tests de sécurité ne finissent jamais d'eux-mêmes : on peut toujours chercher plus longtemps. Sans ces critères, la fin des tests arrive le jour où le calendrier l'impose.

Qu'est-ce qu'une fonction non documentée, et pourquoi est-elle dangereuse ?

Un comportement du logiciel qui ne figure dans aucune exigence, aucune spécification, aucun manuel. Elle est presque toujours dangereuse, parce que personne ne la surveille et que personne n'a pensé à la protéger.

Pourquoi le validateur de contenu a-t-il jugé correctes les règles du 19 juillet 2024 ?

Il vérifiait les règles contre la définition erronée à vingt et un champs. Il lisait la même définition fausse que tout le reste.


Points clés

  • Une stratégie de test répond à cinq questions avant de choisir des outils : quoi prouver, avec quelle profondeur, quelles techniques, quand, et quand s'arrêter. Chaque technique a un angle mort. La stratégie couvre chacun par une autre technique.
  • Le fuzzing trouve les lectures hors limites et les cas que personne n'écrirait à la main. Le test d'intrusion est une photographie, pas une stratégie.
  • Les cas de test viennent des exigences, des cas d'abus et du modèle de menaces. Les cas négatifs, limites et de rôle ont un gabarit commun.
  • La documentation se vérifie en faisant ce qu'elle dit. Une route exposée et non décrite est un défaut.
  • Les fonctions non documentées se cherchent en comparant ce qui est exposé à ce qui est décrit.
  • Tout ce qui change le comportement d'un logiciel se teste comme du code, y compris le contenu et la configuration.

Dans la série

Palier 2 : Tenir les fourneaux. Domaine : Tests.


Pour aller plus loin