Le palais du chef et le thermomètre à sonde

Pendant le service, le chef goûte. Pas tout, pas tout le temps : il n'en aurait pas le temps. Il goûte la sauce qu'un commis vient de monter pour la première fois, le plat du jour avant le premier envoi, la préparation qui a déjà posé problème la semaine dernière. Il sait où les erreurs se cachent, et il regarde là d'abord.

Il a aussi des instruments. Le thermomètre à sonde ne remplace pas son palais, mais il ne se fatigue jamais et il ne se laisse pas distraire. L'un trouve ce qui est trop salé, l'autre ce qui n'est pas assez cuit à cœur. Une cuisine sérieuse a besoin des deux.

Lire le code en attaquant, c'est la même chose. Une revue humaine, guidée par ce qu'on sait des failles, et des outils d'analyse qui passent partout sans se lasser. Ce billet traite des deux, du vocabulaire qui permet de nommer ce qu'on trouve, et de ce qu'on en fait une fois trouvé. Le cas réel tient en une ligne de code, en double.

Le classement des outils d'analyse par famille a déjà son billet sur le blog. Celui-ci se concentre sur la manière de s'en servir.

En bref. Un relecteur et un analyseur statique ne trouvent pas les mêmes défauts. Ce billet dit où regarder pendant une revue, comment régler un analyseur, ce que désignent CWE, CVE et CVSS, puis comment trier et corriger un constat. Le cas réel est « goto fail », corrigé par Apple en février 2014 : une ligne en double qui empêchait la vérification d'une signature.

Ce que la revue trouve, et ce que les outils trouvent

La première question n'est pas « faut-il relire ou outiller ? ». C'est « qui trouve quoi ? ». Les deux approches ne voient pas les mêmes choses.

Ce qu'on cherche Revue humaine Analyse statique Analyse des dépendances
Injection, donnée non validée qui atteint un interpréteur Parfois Bien Non
Secret dans le code Parfois Bien, avec un outil dédié Non
Fonction dangereuse ou obsolète Parfois Bien Non
Composant tiers vulnérable Rarement Non Bien
Contrôle d'autorisation absent sur un objet Bien Mal Non
Logique métier contournable Bien Non Non
Erreur de conception, hypothèse fausse Bien Non Non
Code mort, branche inatteignable Mal Bien Non

La colonne de gauche couvre les lignes du bas, la colonne du milieu couvre celles du haut. Aucune ne couvre tout. Le billet P9 l'avait annoncé pour les cas d'abus : les fautes de logique métier échappent aux outils. Le cas réel de ce billet montre l'inverse, une faute qu'un outil aurait vue et que des yeux humains ont laissé passer.

La répartition du travail en découle. Les outils prennent tout ce qui est répétitif et détectable par motif. La revue humaine se concentre sur ce qu'aucun outil ne voit : l'autorisation, la logique, la conception. Un relecteur qui passe son temps à chercher des requêtes SQL concaténées fait le travail d'une machine, et ne fait pas le sien.

La figure 1 résume ce partage.

  • Ce qu'aucun outil ne voit
Figure 1 : la répartition du travail entre les outils et la revue humaine
À retenir. L'outil trouve ce qui ressemble à une faille connue. Le relecteur trouve ce qui ne ressemble à rien mais ne tient pas.

La revue de code sécurité : savoir où regarder

Une revue de code ordinaire demande si le code est correct, lisible et testable. Une revue de sécurité pose une autre question : comment quelqu'un pourrait-il s'en servir contre nous ? Elle ne se fait pas ligne par ligne sur tout le dépôt. Elle se concentre là où le risque se concentre.

Cinq zones méritent d'être relues en priorité :

  1. Les frontières. Le code qui reçoit une entrée depuis l'extérieur : contrôleurs, consommateurs de messages, imports de fichiers.
  2. Les contrôles. Authentification, autorisation, gestion des sessions, cryptographie.
  3. Les données sensibles. Tout ce qui lit, écrit, journalise ou transmet une donnée classée restreinte au billet P8.
  4. Les interpréteurs. Tout ce qui construit une requête, une commande, un gabarit.
  5. Les changements récents dans ces zones. Une demande de fusion qui touche l'une des quatre premières mérite un second relecteur formé.

La figure 2 place ces cinq zones.

  • Changement qui mérite un second relecteur formé
Figure 2 : les cinq zones à relire en priorité

Une liste de questions évite de compter sur l'inspiration du jour.

Zone Question à poser
Frontière Chaque entrée est-elle validée côté serveur, sur la forme puis sur le sens ?
Autorisation Pour chaque objet lu ou modifié, où vérifie-t-on qu'il appartient au demandeur ?
Autorisation Que se passe-t-il si l'on appelle cette route sans passer par l'écran prévu ?
Erreurs Que fait le code si cet appel lève une exception ? Échoue-t-il fermé ?
Erreurs Une valeur de retour est-elle ignorée alors qu'elle signale un échec ?
Données Ce champ sensible finit-il dans un journal, un message d'erreur, un export ?
Interpréteurs Une donnée est-elle concaténée dans une commande ?
Secrets Une clé, un mot de passe, une adresse interne apparaissent-ils en clair ?
Désactivations Une ligne désactive-t-elle un mécanisme de sécurité du socle ? Pourquoi ?
Concurrence La vérification et l'action sont-elles une seule opération ?

Trois habitudes rendent la revue efficace.

Lire le changement avec son contexte. Une demande de fusion de dix lignes peut supprimer un contrôle situé ailleurs, ou rendre une branche inatteignable. On ouvre le fichier entier, pas seulement le diff.

Suivre une donnée de bout en bout. Partir d'une entrée et la suivre jusqu'à l'endroit où elle est utilisée. C'est le travail que fait un analyseur, en plus lent et en plus intelligent.

Garder les relectures courtes. L'attention baisse vite. Mieux vaut quatre demandes de fusion de cent lignes qu'une de quatre cents. C'est une raison de sécurité pour découper les changements.

Il reste une forme de lecture à part : la rétro-ingénierie. Le plan d'examen l'évoque, et le programme du cours y consacre une leçon. On lit alors un binaire dont on n'a pas le source, souvent un composant tiers ou un livrable à vérifier. Elle soulève des questions juridiques, liées aux licences et au droit d'auteur, qu'il faut trancher avant de commencer.


L'analyse statique : un relecteur qui ne dort jamais

Un outil d'analyse statique lit le code sans l'exécuter. Il cherche des motifs connus de défauts et, pour les meilleurs, suit le chemin des données depuis une source non fiable jusqu'à un point d'usage dangereux.

Sa force est la constance. Il relit tout, à chaque changement, sans fatigue ni complaisance. Sa faiblesse est le bruit.

Le bruit. Un outil mal réglé produit des centaines de constats dont la plupart ne sont pas des failles, et l'équipe apprend vite à ne plus les lire.

La figure 3 place l'analyse à trois moments, puis le tri et le suivi.

  • Constats envoyés au tri, puis au suivi
Figure 3 : l'analyse statique à trois moments, suivie du tri et du suivi. Sans les deux derniers, les trois premiers ne servent à rien.

Quatre réglages font la différence entre un outil utile et un outil ignoré.

Réglage Ce qu'il change
Ne bloquer que sur le nouveau code L'équipe n'hérite pas de mille constats anciens d'un coup ; le stock se traite à part
Commencer par peu de règles, à forte confiance Les premiers constats sont justes, l'équipe fait confiance à l'outil
Pouvoir écarter un faux positif avec une raison Le constat ne revient pas à chaque analyse, et la raison reste tracée
Ajouter des règles propres au projet L'outil apprend les erreurs que cette équipe fait vraiment

Le quatrième réglage est le plus rentable à terme.

En pratique. Chaque fois qu'une revue ou un incident révèle une erreur, on se demande si une règle aurait pu la trouver. Si oui, on l'écrit. L'erreur ne revient plus, nulle part dans le dépôt.

Deux autres techniques complètent l'analyse statique et sont traitées au palier des tests : l'analyse dynamique, qui attaque l'application en fonctionnement, et le fuzzing, qui lui envoie des entrées aléatoires ou malformées par millions. Le fuzzing est d'ailleurs la technique qui trouve le mieux les failles de type Heartbleed vues au billet P14.


Nommer ce qu'on trouve : CWE, CVE, CVSS

Trois sigles reviennent dans tout rapport d'analyse. On les confond souvent, alors qu'ils ne désignent pas la même chose.

Sigle Ce qu'il désigne Exemple En cuisine
CWE Un type de faiblesse, indépendant de tout produit La lecture hors des limites d'un tampon « Rupture de la chaîne du froid », comme catégorie
CVE Une vulnérabilité précise, dans un produit précis Heartbleed, dans OpenSSL 1.0.1 à 1.0.1f « Le lot 2417 de saumon, livré mardi »
CVSS Un score de gravité technique, de 0 à 10 7,5 pour Heartbleed, selon la notation actuelle Le niveau de danger de ce lot

La CWE est l'outil du développeur et de l'architecte. C'est un catalogue tenu par l'organisme MITRE, qui décrit plusieurs centaines de faiblesses, leurs conséquences et leurs parades. Une liste annuelle extrait les vingt-cinq plus dangereuses.

Son intérêt pratique est de parler de classes d'erreurs plutôt que de cas isolés. Une équipe qui voit revenir trois fois la même CWE sait où mettre sa formation et ses règles d'analyse.

La CVE est l'outil de l'exploitation et du suivi des dépendances. C'est un identifiant unique attribué à une vulnérabilité publique, qui permet à tout le monde de parler de la même chose.

Le score CVSS est utile et trompeur à la fois. Le billet P6 le disait : il mesure la gravité technique d'une faille en elle-même, pas le risque qu'elle fait courir chez toi. Une faille notée 9,8 sur un composant que tu n'appelles jamais pèse moins qu'une faille notée 6,5 sur ton service de paiement exposé.

La figure 4 pose ces deux failles côte à côte.

  • La faille qui pèse le plus chez toi
Figure 4 : deux failles, deux scores, et le contexte qui décide laquelle pèse le plus

D'autres indicateurs aident à corriger ce biais. Certains estiment la probabilité qu'une faille soit exploitée dans les prochains jours. Des catalogues publics listent les failles dont l'exploitation a déjà été constatée. Heartbleed figure dans l'un d'eux.

À retenir. Un score dit à quel point une faille est grave. Ton contexte dit à quel point elle est urgente.

Trier : un constat n'est pas une faille

Un outil produit des constats. Une partie seulement sont des failles réelles, et une partie seulement de celles-ci sont exploitables chez toi. Le tri transforme une liste en décisions. Il répond à quatre questions, dans cet ordre.

Question Si la réponse est non
Le constat est-il juste ? Le défaut existe-t-il vraiment dans le code ? Faux positif : on l'écarte avec une raison écrite
Le code concerné est-il atteignable ? On le note, et l'on se demande pourquoi ce code existe
Une entrée contrôlée par un attaquant peut-elle l'atteindre ? Priorité faible, mais on corrige : les chemins changent
Que se passerait-il si on l'exploitait, ici ? On évalue avec la grille du billet P6

La figure 5 suit un constat d'une question à la suivante.

  • Constat qui passe à la question suivante
Figure 5 : les quatre questions du tri, dans l'ordre

La deuxième ligne mérite un mot. Du code inatteignable n'est pas dangereux aujourd'hui. Il le devient le jour où quelqu'un le rebranche, et il cache souvent une erreur de logique. Le cas réel de ce billet est exactement cela.

Deux règles protègent le tri contre ses propres dérives. La première : celui qui écarte un constat n'est pas celui qui a écrit le code concerné. C'est la séparation des tâches du billet P2. La seconde : un constat écarté garde sa raison, et on peut la relire. Un faux positif d'hier peut être une vraie faille demain, après un changement ailleurs.


Corriger : la cause, les variantes, la preuve

Corriger une faille ne se résume pas à changer la ligne signalée. Une correction complète passe par quatre étapes. La figure 6 les met dans l'ordre.

Figure 6 : une correction complète, en quatre étapes

Trouver la cause. La ligne signalée est le symptôme. La cause est souvent ailleurs : une validation absente en amont, une abstraction qui encourage l'erreur, une bibliothèque mal comprise. Corriger le symptôme laisse la cause produire la prochaine faille.

Chercher les variantes. Si cette erreur a été faite ici, où d'autre l'a-t-elle été ? C'est la question que le cas Optus du billet P11 a posée trop tard. Une recherche dans le dépôt, ou une règle d'analyse écrite pour l'occasion, répond en quelques minutes.

Prouver la correction. Un test qui reproduit la faille, échoue avant la correction et passe après. Il reste dans la suite de tests, et la faille ne revient pas sans que quelqu'un le voie. C'est le test négatif du billet P9.

Fixer un délai selon la gravité. Toutes les failles ne se corrigent pas dans l'heure. Une politique écrite dit combien de temps on se donne par niveau, et ce qui se passe quand le délai est dépassé.

Niveau, après tri Délai indicatif Si le délai est dépassé
Critique, exploitable Jours Escalade immédiate ; mesure compensatoire en attendant
Élevé Semaines Dérogation signée, comme au billet P5
Moyen Prochaines itérations Revue mensuelle du stock
Faible Selon l'occasion Aucune action particulière

Les chiffres précis sont à décider par ton organisation. Ce qui compte est qu'ils soient écrits, mesurés, et que leur dépassement déclenche quelque chose. La métrique du délai médian de correction, vue au billet P5, sort de ce tableau.

Quand la correction prend du temps, une mesure compensatoire couvre l'intervalle : une règle de pare-feu applicatif qui bloque le motif d'attaque, la désactivation de la fonction, une surveillance renforcée. Elle n'est pas une correction. Elle a une date de fin.


Scénario : « goto fail », ou la ligne en double

Le vendredi 21 février 2014, Apple publie une mise à jour de sécurité pour iOS. La note est brève : le composant qui gère les connexions sécurisées ne vérifiait pas l'authenticité de la connexion, et le problème a été résolu en rétablissant des étapes de validation manquantes.

iOS 7.0.6 et iOS 6.1.6 corrigent la faille. Le correctif pour OS X 10.9 suit quelques jours plus tard, avec la version 10.9.2. Les versions plus anciennes, iOS 5 et OS X 10.8, n'avaient jamais eu le défaut.

Le code concerné étant publié en source ouverte, des chercheurs en publient la cause dès le lendemain. Elle se trouve dans la fonction qui vérifie la signature du serveur pendant l'échange de clés. Voici le passage, simplifié.

if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
    goto fail;
    goto fail;
if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
    goto fail;
/* ... vérification de la signature ... */
fail:
    /* libération des ressources */
    return err;

La deuxième ligne goto fail; n'est soumise à aucune condition. L'indentation suggère qu'elle dépend du if qui précède. Elle n'en dépend pas. Le programme saute donc toujours à la fin de la fonction, à cet endroit, et ne vérifie jamais la signature.

Le pire tient à la valeur renvoyée. Au moment du saut, la variable err vaut zéro, puisque l'opération précédente a réussi. Zéro signifie « tout va bien ». La fonction de vérification renvoie donc un succès sans avoir rien vérifié. Quelqu'un placé sur le réseau, dans un café par exemple, pouvait se faire passer pour un site légitime sans que l'appareil s'en aperçoive.

La figure 7 suit cette vérification, de l'appel au faux succès.

Quelqu'un surle réseaudans un café, parexemple Appareil Fonction devérificationsignature duserveur identité usurpée 1 signature du serveur 2 3 err vaut zéro 4 5 1 2 3 4 5 1. Quelqu'un placé sur le réseau se fait passer pour un site légitime 2. Pendant l'échange de clés, l'appareil fait vérifier la signature du serveur 3. Le second goto fail saute à la fin de la fonction : la signature n'est jamais vérifiée 4. La variable err vaut zéro : la fonction renvoie un succès sans avoir rien vérifié 5. L'appareil ne s'aperçoit de rien
  1. Quelqu'un placé sur le réseau se fait passer pour un site légitime
  2. Pendant l'échange de clés, l'appareil fait vérifier la signature du serveur
  3. Le second goto fail saute à la fin de la fonction : la signature n'est jamais vérifiée
  4. La variable err vaut zéro : la fonction renvoie un succès sans avoir rien vérifié
  5. L'appareil ne s'aperçoit de rien
Figure 7 : « goto fail », une vérification qui renvoie un succès sans avoir rien vérifié

Relisons l'erreur avec les outils de ce billet.

Outil Ce qu'il aurait vu Pourquoi il ne l'a pas vu
Revue humaine Une ligne en double, sous une indentation trompeuse L'œil lit l'indentation, pas la syntaxe ; une ligne répétée passe pour une répétition sans conséquence
Analyse statique Tout le code après le second saut est inatteignable Une analyse de code inatteignable aurait signé l'erreur ; elle n'était pas active, ou ses résultats pas lus
Règle de style Un if sans accolades, une indentation qui ment Une règle qui impose les accolades rend la ligne fautive visible
Test négatif Une signature invalide doit être refusée Il fallait un test qui présente une fausse signature et attend un refus
Échec sûr Une fonction de vérification qui renvoie succès par défaut La variable de résultat aurait dû partir d'une valeur d'échec

La deuxième ligne est le cœur du cas. Toute la fin de la vérification était devenue inatteignable. C'est exactement le type de défaut qu'un analyseur trouve sans effort, et qu'un humain a du mal à voir. On retrouve le premier tableau de ce billet, colonne du milieu, dernière ligne.

La quatrième ligne est la plus importante pour l'avenir. Une fonction de sécurité qui dit « oui » se teste en lui présentant des cas où elle doit dire « non ». Les tests ordinaires, qui vérifient qu'une connexion légitime fonctionne, passaient parfaitement : une connexion légitime fonctionnait. Ce qui ne fonctionnait plus, c'était le refus.

La dernière ligne rejoint le billet P2. Si la variable avait été initialisée à une valeur d'échec, la même erreur aurait cassé toutes les connexions. Quelqu'un l'aurait remarqué le jour même.

On ne sait pas publiquement comment la ligne est arrivée là. Une fusion de branches mal résolue est l'hypothèse la plus souvent avancée. La question compte moins que la suivante : quels outils auraient dû l'arrêter, et pourquoi aucun ne l'a fait ?

À retenir. Une fonction de sécurité se teste en lui demandant de dire non.

Testez-vous

Sur quoi la revue humaine se concentre-t-elle, une fois le répétitif laissé aux outils ?

Sur ce qu'aucun outil ne voit : l'autorisation, la logique, la conception.

Quelle différence y a-t-il entre une CWE et une CVE ?

La CWE désigne un type de faiblesse, indépendant de tout produit. La CVE désigne une vulnérabilité précise, dans un produit précis.

Dans « goto fail », pourquoi la fonction de vérification renvoie-t-elle un succès ?

Au moment du saut, la variable err vaut zéro, puisque l'opération précédente a réussi. La fonction renvoie donc un succès sans avoir rien vérifié.


Points clés

  • La revue humaine et l'analyse automatique ne trouvent pas les mêmes choses. Les outils prennent le répétitif, les humains l'autorisation, la logique et la conception.
  • Une revue de sécurité se concentre sur les frontières, les contrôles, les données sensibles, les interpréteurs, et suit une liste de questions.
  • Un analyseur statique utile bloque sur le nouveau code, commence par peu de règles fiables, et apprend les erreurs de l'équipe.
  • CWE nomme un type de faiblesse, CVE une faille précise, CVSS une gravité technique. Le contexte décide de l'urgence.
  • Le tri répond à quatre questions : juste, atteignable, exploitable, grave ici. Un constat écarté garde sa raison.
  • Corriger, c'est trouver la cause, chercher les variantes, prouver par un test, et respecter un délai écrit.

Dans la série

Palier 2 : Tenir les fourneaux. Domaine : Implémentation.


Pour aller plus loin