Newsletter
Firmware sécurisé : réduire le code, pas la confiance15 min de lecture2 950 mots

Firmware sécurisé : réduire le code, pas la confiance

Découvrez comment un firmware de 300 lignes remplace un million de lignes en déplaçant la complexité vers des artefacts mesurés et vérifiables.

firmware sécuriséenclave confidentiellesurface d’attaqueattestation matériellecalcul confidentiel
Firmware sécurisé : réduire le code, pas la confiance

Sécuriser une enclave en remplaçant un million de lignes par 300

Un firmware utilisé au démarrage d'une machine virtuelle confidentielle peut-il vraiment être plus sûr si on lui enlève presque tout ? C'est l'idée de Tinfoil : remplacer OVMF, un firmware généraliste d'un million de lignes de code C, par environ 300 lignes d'assembleur, sans dépendances. L'objectif n'est pas seulement de « faire plus petit ». Il s'agit surtout de déplacer la responsabilité : ce qui était construit ou vérifié au démarrage est préparé et mesuré à la compilation.

Cette distinction compte, parce que l'hôte qui lance une enclave est considéré comme non fiable. Une erreur côté firmware peut alors permettre à l'hôte de pousser un état inattendu et de casser soit la confidentialité, soit la vérifiabilité de la machine. Réduire le code exécuté au démarrage diminue le nombre de chemins qu'un attaquant peut essayer de provoquer, mais déplacer du code vers la compilation change aussi le type d'efforts d'audit.

Voici comment fonctionne l'approche, ce qu'elle change dans la chaîne de confiance, et dans quels cas elle a du sens. Le principe dépasse le firmware : quand une configuration peut être préparée à l'avance, un artefact mesuré est souvent plus facile à examiner qu'un programme qui interprète des entrées fournies par un acteur potentiellement hostile.

Pourquoi le firmware est un point critique

Une frontière de sécurité au démarrage

Une machine virtuelle confidentielle, ou enclave, protège la mémoire d'une charge de travail grâce aux mécanismes matériels des processeurs. Selon la plateforme, des technologies comme Intel TDX ou AMD SEV-SNP permettent aussi d'attester certains éléments de son état initial. En clair : l'attestation donne à un tiers un moyen de vérifier ce qui a été lancé, sans devoir faire entièrement confiance à l'opérateur du serveur.

Cette vérification est cruciale dans un service où l'opérateur ne doit pas pouvoir lire les données des clients, même si son infrastructure est compromise. Et le risque ne vient pas que de « la machine vers l'hôte ». Un hôte malveillant peut aussi chercher à influencer l'invité, notamment pendant son démarrage.

Le matériel mesure un état initial. Mais dans un démarrage plus classique, le firmware chargé à cet instant doit ensuite lire des éléments fournis par l'hôte, charger le noyau Linux et d'autres composants, puis mesurer ou vérifier ce qui sera exécuté. La confiance dépend alors de la capacité du firmware à manipuler correctement ces données et à faire les mesures au bon moment.

Le coût de la polyvalence

Tinfoil s'appuie sur OVMF, un firmware largement utilisé. Sa généralité rend le système pratique : il gère beaucoup de matériels, de configurations et de modes de démarrage. On y trouve notamment des fonctions liées au réseau, à la gestion des périphériques et à la compatibilité.

Mais plus une cible est « prête à tout », plus elle embarque de code, de dépendances et de chemins d'exécution. Le projet source souligne qu'OVMF dépasse largement le million de lignes de C, et que des vulnérabilités critiques ont été découvertes, y compris dans des composants dont Tinfoil n'a pas besoin. Un pilote de démarrage réseau, par exemple, n'a aucune utilité si votre environnement ne démarre jamais par le réseau.

Le problème n'est donc pas « OVMF serait mauvais parce qu'il est populaire ». C'est plutôt que sa richesse fonctionnelle répond à des usages que chaque déploiement n'a pas. Dans une flotte suffisamment homogène, garder tout ce bagage peut coûter plus cher en surface d'attaque qu'en souplesse.

La taille ne suffit pas à prouver la sécurité

Remplacer un gros composant par un petit ne garantit pas la sécurité. Le code réduit doit être compris, testé, et intégré correctement dans la chaîne de démarrage. La réduction est utile quand elle enlève de vraies fonctions inutiles et rend le comportement plus simple à vérifier. Elle ne remplace pas une analyse de sécurité.

Et l'approche s'inscrit aussi dans une logique d'audit plus outillée : tests continus, fuzzing, analyses, parfois aidées par des modèles d'IA. Mais les campagnes automatisées de recherche de failles coûtent cher. La décision la plus durable, au final, ressemble souvent à un principe plus simple : limiter ce qui est possible, plutôt que d'essayer de débusquer après coup chaque défaut d'un logiciel généraliste.

Comment déplacer la confiance vers le démarrage mesuré

Mesurer l'image avant que l'enclave ne démarre

Dans l'ancien modèle, le matériel mesure le firmware au lancement. Ensuite, ce firmware charge des éléments (comme le noyau, l'initramfs et la ligne de commande Linux) et contribue à établir ce qui sera exécuté. La mesure « finale » dépend donc à la fois du matériel et du comportement du firmware après son propre lancement.

Tinfoil change la chaîne. Le noyau, l'initramfs, la ligne de commande, les tables nécessaires et des éléments de configuration sont placés dans la mémoire initiale de l'enclave. Cette image est décrite via IGVM, un format conçu pour représenter l'état de lancement d'une machine virtuelle confidentielle. La compilation produit l'image, puis le matériel mesure cet état au démarrage.

La différence tient à une idée simple : le firmware ne décide plus quels fichiers charger ni comment mesurer quoi que ce soit à partir d'entrées fournies par l'hôte. La mesure porte sur un ensemble défini à l'avance. Le firmware restant sert surtout à préparer le processeur et à transférer l'exécution à Linux.

Séparer le code « d'audit » du code « exposé »

Déplacer la génération des tables et de l'image vers la compilation ne supprime pas le code qui produit ces données. Il faut faire confiance au générateur et vérifier qu'il produit bien un état conforme aux règles attendues. La vraie différence, c'est son exposition : au démarrage, le générateur ne reçoit pas des données arbitraires venues d'un hôte potentiellement malveillant.

Un artefact construit à l'avance peut aussi être conservé, comparé d'une version à l'autre et inclus dans une mesure matérielle. Si le générateur contient un défaut, le résultat peut être faux, mais il est produit de manière déterministe pour les images concernées et peut être inspecté avant déploiement. À l'inverse, un constructeur de tables exécuté au démarrage doit être analysé pour toutes les entrées qu'un hôte peut lui envoyer et pour tous les chemins d'exécution déclenchés.

On peut résumer le déplacement comme suit :

Fonction Approche généraliste Approche décrite par Tinfoil
Noyau et initramfs Chargés au démarrage Inclus dans l'image initiale mesurée
Tables et structures fixes Construites ou complétées à l'exécution Produites à la compilation et mesurées
Vérification du contenu En partie confiée au firmware Portée par la mesure matérielle de l'image
Configuration variable de l'hôte Interprétée par plusieurs composants Limitée à des valeurs contrôlées par bornes
Services après le transfert à Linux Conservés par le firmware Supprimés après le transfert

Le but n'est pas de supprimer toute confiance dans le logiciel. C'est plutôt de réduire le nombre de composants qui doivent traiter des entrées contrôlées par l'hôte pendant une phase critique.

Une attestation plus claire, pas une magie

Une image initiale mesurée rend plus simple la question « quel état a été lancé ? ». Mais ça ne prouve pas à elle seule que chaque composant est exempt de vulnérabilités, ni que la machine restera sûre contre tous les problèmes possibles (matériels, logiciels, opérationnels). Ce que ça donne, c'est une base de vérification plus nette : un état attendu, un artefact reproductible, et une mesure qu'on peut comparer.

Dans une infrastructure liée aux actifs numériques ou aux services financiers, cette distinction a un effet concret. L'attestation peut améliorer la vérifiabilité d'un environnement, mais elle ne remplace ni l'analyse du code réellement exécuté, ni la gestion des clés, ni les contrôles de déploiement. En pratique, la confiance se répartit entre plusieurs couches : rendre le démarrage plus petit facilite l'examen, sans faire disparaître les autres risques.

Ce que font réellement les 300 lignes de code

Préparer le processeur, puis passer la main

Pour démarrer Linux sur x86, il faut mettre en place quelques briques de base : la pagination et le mode 64 bits, par exemple. Le protocole de démarrage Linux donne aussi les informations nécessaires pour retrouver le noyau, l'initramfs et la ligne de commande. Dans la conception de Tinfoil, ces éléments sont déjà en mémoire au lancement.

Le firmware n'a donc plus à chercher les fichiers, charger des pilotes, ou construire une chaîne de vérification. Il configure l'état minimal du processeur, effectue quelques contrôles sur la configuration, puis transfère l'exécution au noyau. Une fois Linux démarré, le firmware s'arrête : il ne continue pas à fournir des services d'exécution.

Le « chiffre » d'environ 300 lignes ne veut pas dire qu'il n'existe que 300 lignes dans toute la chaîne. Le noyau, les outils de compilation et les composants qui préparent l'image restent indispensables. Le nombre décrit ici correspond au firmware minimal présenté : pas de dépendances, et pas de rôle « généraliste » à la manière d'OVMF.

Une configuration variable, mais bornée

Le point dur côté pratique est d'accepter des machines avec des quantités différentes de mémoire ou de processeurs, sans devoir reconstruire une image complète pour chaque combinaison.

L'idée est de fixer à la compilation la forme attendue, puis de laisser au démarrage une petite marge sur certaines valeurs, dans des limites contrôlées. Pour la mémoire, le firmware connaît une disposition physique prédéfinie. La taille totale de RAM peut varier, mais la configuration reçue de l'hôte doit respecter la structure attendue. Le firmware vérifie cette compatibilité : si l'hôte fournit une disposition hors bornes, le démarrage échoue. Pas de « fallback » vers un plan mémoire imprévu.

Pour les processeurs, les tables ACPI sont aussi préparées en amont. Le firmware vérifie le nombre de processeurs déclaré, et ajuste l'entrée nécessaire dans la table de description, au lieu de reconstruire tout l'environnement depuis des données libres. Si la configuration ne correspond pas, les cœurs non prévus ne devraient pas offrir à l'hôte un moyen de lire la mémoire de l'enclave : concrètement, le comportement visé est l'absence de démarrage effectif sur ces cœurs.

Supprimer ce qui ne sert pas le produit

La réduction vient de plusieurs endroits : certaines tâches sont transférées à Linux, d'autres sont préparées à la compilation, et le reste est retiré. Le vrai critère n'est pas la ligne de code, mais la destination de chaque fonction.

  • Les tables de pages et certaines structures processeur sont générées avant le lancement et mesurées.
  • Le noyau, l'initramfs et la ligne de commande sont intégrés à l'image.
  • Linux prend en charge des tâches comme l'énumération des périphériques et le démarrage des autres processeurs.
  • Le gestionnaire de démarrage, les pilotes de disque et de réseau, les ROM d'option et les services d'exécution du firmware sont supprimés.
  • Les entrées restantes de l'hôte (principalement mémoire et nombre de processeurs) sont vérifiées contre une configuration bornée.

Transférer une fonction à Linux ne veut pas forcément dire « ajouter un risque ailleurs ». Dans l'analyse de Tinfoil, Linux effectuait déjà une partie de ces tâches dans les environnements concernés. OVMF en faisait parfois une partie en plus. L'objectif est d'éviter de maintenir deux mécanismes pour une même fonction.

Quels compromis cette architecture impose

Une spécialisation qui dépend de la flotte

La simplicité se paye en compatibilité. Un firmware généraliste peut s'adapter à des configurations variées. Un firmware minimal basé sur des dispositions mesurées ne démarre que les configurations prévues par le processus de compilation et les contrôles associés.

Si l'hyperviseur modifie la disposition mémoire ou les tables de la machine virtuelle, l'image doit être mise à jour et testée avant de fonctionner avec cette nouvelle configuration. Dans une flotte homogène, ce coût reste gérable. Dans un produit qui doit supporter de nombreux hyperviseurs, matériels et scénarios de démarrage, ça devient vite un frein.

La question se résume donc à votre besoin : combien de configurations devez-vous vraiment couvrir ? Chaque cas ajouté augmente le volume d'artefacts, de tests et de règles de validation. La simplicité côté runtime ne tombe pas du ciel : elle suppose une discipline de configuration et de déploiement.

La compilation devient une partie du périmètre de confiance

Le générateur d'image, les scripts de compilation et les contrôles qui vont avec doivent être audités. Un défaut peut produire un artefact incorrect ou vulnérable, même si le firmware « runtime » est minuscule. La mesure matérielle atteste l'image lancée ; elle ne dit pas si cette image a été conçue correctement.

En pratique, l'approche tient si l'équipe traite la construction comme une vraie composante de sécurité : versions maîtrisées, résultats vérifiables, tests des configurations, comparaison des artefacts, revue des changements. Le déplacement vers la compilation est particulièrement intéressant quand le résultat est stable et inspectable. Si le générateur devient une boîte noire trop complexe, on perd une partie du bénéfice.

Pourquoi ne pas reprendre un autre firmware minimal ?

Tinfoil indique avoir évalué Stage0, un firmware conçu pour des machines virtuelles confidentielles et plus réduit qu'OVMF. Le désaccord ne se limite pas à la taille. Selon cette analyse, Stage0 conserve des fonctions de chargement et de mesure après le lancement, ainsi que des mécanismes qui traitent des entrées fournies par l'hôte.

Ce choix peut être pertinent si un logiciel doit démarrer des machines variées et s'adapter à des descriptions différentes. Mais si l'hôte est traité comme un attaquant, chaque analyseur d'entrée devient un chemin exposé. Tinfoil a donc préféré construire l'essentiel à l'avance et limiter le firmware restant à des contrôles.

Ce n'est pas une loi universelle. Un logiciel réutilisable pour beaucoup d'environnements a parfois de bonnes raisons de garder plus de mécanismes d'adaptation. La bonne question n'est pas « quel firmware est le plus petit ? ». C'est « quelles entrées accepte-t-on à l'exécution, et a-t-on vraiment besoin de cette flexibilité ? »

Conclusion

Le message principal de cette refonte n'est pas « il faut absolument un firmware de 300 lignes ». C'est plutôt : un composant critique ne devrait pas garder des fonctions généralistes dont le produit n'a pas besoin, surtout quand ces fonctions obligent à traiter des entrées fournies par un hôte non fiable.

En plaçant l'image de démarrage et les structures fixes dans un artefact préparé puis mesuré, Tinfoil réduit le rôle du firmware à quelques contrôles et au transfert vers Linux. Cette décision rend la chaîne d'attestation plus simple à comprendre, mais elle impose une flotte plus prévisible et un processus de construction plus rigoureux.

Si vous évaluez une architecture similaire, commencez par lister ce qui est vraiment nécessaire à l'exécution, identifiez les entrées contrôlées par un tiers, puis demandez quelles décisions peuvent être prises avant le lancement et vérifiées dans un artefact concret. Le but n'est pas de minimiser le code « à tout prix ». C'est de minimiser les comportements exposés, tout en restant raisonnablement capables de faire confiance au reste.

Questions frequentes

Il intervient au démarrage, lorsque l’état initial de la machine est établi et mesuré. S’il traite mal une entrée contrôlée par l’hôte, celui-ci pourrait influencer le code chargé ensuite et affaiblir la confidentialité ou l’attestation de l’enclave.
Non. Une faible taille ne prouve pas la sécurité. Elle facilite l’examen si les fonctions inutiles ont été supprimées et si le code restant est testé. Le générateur d’image, Linux et le processus de déploiement doivent aussi être pris en compte.
Le matériel calcule une mesure de l’état initial de la machine virtuelle, qui peut être liée à un rapport d’attestation. Ici, le noyau et les éléments de démarrage sont présents dès cet état, plutôt que chargés et mesurés plus tard par le firmware.
Non. Elle convient surtout à une flotte dont les configurations sont connues et contrôlées. Une plateforme qui doit prendre en charge de nombreux types de machines peut avoir besoin d’un firmware plus adaptable, au prix d’une surface d’exécution potentiellement plus large.

Articles similaires