Maudite soit Spectre : pourquoi continue-t-il à hanter AMD et Intel ?

spectre laptop

Et si tous les processeurs du monde contenaient une vulnérabilité fondamentale, qui est exploitée de plus en plus souvent et pour laquelle il n’existe pas de correctif efficace ? Nous examinons Spectre, le diablotin d’Intel et d’AMD, et découvrons pourquoi la fuite existe toujours six mois après sa découverte.

Cet article a été initialement publié le 20 juillet 2018. Comme Spectre est toujours d’actualité, nous l’avons reformulé avec des exemples récents.

Intel et AMD semblent être traqués par le fantôme de Spectre. Les pirates peuvent briser les systèmes grâce à cette vulnérabilité, qui transforme les processeurs en un merveilleux vecteur. Bien que la fuite ait été découverte au début de 2018, nous continuons à souffrir des répercussions qui ont suivi. Ce n’est que récemment qu’Intel a découvert que les puces AMD restaient vulnérables à Spectre, malgré les mesures d’atténuation mises en place depuis des années. Intel a découvert cette faille elle-même par hasard, parce qu’elle est toujours à la recherche d’une bonne solution pour ses propres puces. Personne ne parais pouvoir éliminer définitivement cette brèche. En 2021, les chercheurs ont également découvert de nouveaux problèmes liés à Spectre chez Intel et AMD.

Dans cet article, nous allons plus loin. Pour comprendre pourquoi Spectre continue de hanter les fabricants de processeurs et qu’une simple mise à jour ne résout pas le problème, il faut savoir ce qui rend cette vulnérabilité si unique. Pour ce faire, nous devons nous plonger dans le fonctionnement de l’architecture d’un processeur moderne.

Personne ne semble pouvoir éliminer définitivement cette brèche.

Exécution spéculative : le talon d’Achille

Presque tous les processeurs modernes, qu’ils soient de marque Intel ou AMD, construits sur x86 ou ARM, utilisent des principes similaires. L’une d’entre elles est appelée exécution spéculative.

L’exécution spéculative est une réponse intelligente à un problème qui affectait les anciens processeurs. Au début de l’architecture des processeurs, un processeur avait un seul cœur de traitement avec une certaine fréquence d’horloge. Il a exécuté les instructions dans l’ordre dans lequel elles ont été proposées. La deuxième instruction n’a pas été lancée avant la fin de la première instruction.

C’est peu efficace. Par exemple, si la deuxième instruction a besoin de valeurs provenant de la mémoire, le CPU ne chargera pas ces valeurs avant la fin de la première instruction. Ce processus de chargement prend beaucoup de temps, ce qui entraîne la perte de précieux cycles d’horloge, pendant lesquels le cœur du processeur est inactif. Les architectures de processeurs évitaient ce problème en dotant les CPU d’un système intelligent qui permet aux puces de deviner quelle sera la prochaine instruction et quelles valeurs de mémoire y sont associées.

Jouer et gagner (performance)

Un exemple : immédiatement après l’instruction 1, l’instruction 2 est chargée de manière spéculative. Les données de la mémoire associée sont écrites dans le cache du processeur. Le cache est une petite réserve de mémoire ultra-rapide sur le processeur lui-même. Lorsqu’un CPU exécute des instructions, il fait appel au cache et non à la mémoire RAM car celle-ci est trop lente.

Une fois l’instruction 1 terminée, l’instruction 2 est déjà sur les talons de la première instruction, avec toutes les données nécessaires bien placées dans le cache. Si le processeur a correctement spéculé, il n’a pas besoin d’attendre de précieux cycles d’horloge jusqu’à ce que les données nécessaires aient été extraites de la RAM vers le cache, et le calcul peut se poursuivre normalement. Si la spéculation est fausse, alors tout le travail déjà effectué pour l’exécution de l’instruction 2 est annulé, et l’instruction suivante est chargée comme d’habitude.

La prédiction spéculative est devenue incontestable au fil des ans, avec un taux de réussite d’environ 95 %. Les processeurs modernes doivent une grande partie de leur vitesse à l’exécution spéculative.

Spectre exploite ingénieusement l’exécution spéculative.

L’ensemble du système est mis en œuvre au niveau de la micro-architecture. Le microprogramme du CPU, qui contrôle le fonctionnement des circuits logiques construits par les milliards d’interconnexions et de transistors, contrôle également l’exécution spéculative. Les programmes n’en tiennent pas compte : ils supposent simplement que leurs instructions sont exécutées en séquence. La partie spéculative se déroule en arrière-plan et accélère l’exécution. Spectre abuse brillamment de l’exécution spéculative.

Les problèmes sont initialement apparus dans les processeurs Intel antérieurs à 2018, mais il existe encore des variantes de l’abus de la version spéculative. Nous détaillons ci-dessous le fonctionnement de la variante originale de Spectre.

Abus spéculatif

Le problème réside dans un autre élément de la technologie. Dans la mémoire des PC et des serveurs, il existe une distinction importante entre l’espace utilisateur et l’espace noyau. L’espace utilisateur contient des données qui ne sont pas trop sensibles, tandis que l’espace noyau, qui est normalement très bien protégé, contient les données les plus essentielles.

Une instruction normale sans accès à l’espace noyau ne passera jamais par le processeur en ayant accès aux données qui s’y trouvent. Si une instruction normale en espace utilisateur demande l’accès à des données en espace noyau, le processeur arrête l’instruction.

Il en va autrement s’il s’agit d’une instruction spéculative. La vérification a toujours lieu, mais seulement à la toute fin, lorsqu’il s’avère que l’instruction doit effectivement être exécutée. Le raisonnement est simple : si le processeur se trompe de spéculation, toutes les modifications sont annulées. Si l’instruction spéculative est exécutée correctement, elle est soumise à une dernière vérification de privilège avant de terminer son exécution.

« Pipeline » défectueux

Ce qui cloche, c’est le pipeline. Imaginez simplement qu’un processeur fictif possède un pipeline à quatre étapes. Dans la première étape, les données sont écrites de la mémoire RAM vers le cache du processeur. Dans les étapes suivantes, des opérations sont effectuées, et dans la toute dernière étape, dans le cas de l’instruction spéculative, le processeur vérifie si elle était censée être exécutée et s’il dispose des privilèges nécessaires.

Même si la réponse à l’une de ces questions est négative, une instruction spéculative malveillante aurait pu apporter des modifications au cache du processeur. Dans ce cache, les données sont moins protégées que dans l’espace du noyau.

La première fuite de Spectre utilise cette vulnérabilité dans les processeurs pour lire des données sensibles. Une instruction spéculative malveillante transmet des données telles qu’un mot de passe de l’espace du noyau au cache, après quoi elle est arrêtée légitimement, mais le cache a été modifié entre-temps. Sur la base de cette modification, les logiciels malveillants peuvent alors s’emparer de votre mot de passe.

Un seul tour, plusieurs variations

Les variations récemment découvertes de Spectre vont encore plus loin. Ils ne demandent pas à lire des données protégées. Cependant, ils tentent d’écrire du code malveillant dans des positions de la mémoire auxquelles ils n’ont pas accès. Un dépassement de tampon est à l’origine de ce problème. Là encore, un contrôle de privilège tardivement mis en œuvre sur les exécutions spéculatives est responsable.

Alors que la première variante de Spectre tente de lire des données sensibles en écrivant secrètement des données de l’espace noyau vers le cache, Spectre 1.1 et Spectre 1.2 tentent d’écrire des données à une adresse mémoire qui n’existe pas. Disons qu’une instruction spéculative accède à cinq adresses consécutives différentes dans la mémoire. Pendant l’exécution spéculative, l’instruction demande qu’un bloc de code malveillant soit écrit à l’adresse six. Normalement, le processeur arrête le code parce que l’adresse six n’existe pas dans le contexte de l’instruction. En mode spéculatif, cette vérification n’a pas lieu et, en pratique, le code est écrit à une adresse mémoire qui appartient à un autre ensemble d’instructions.

Là encore, l’instruction sera arrêtée par le CPU dès qu’elle passera de spéculative à concrète, mais là encore, le cache a déjà été compromis à ce stade. Une bonne attaque incitera un processus disposant des autorisations nécessaires à charger les données du cache qui ont été écrasées précédemment, ce qui permettra au processus normal de se mettre soudainement à faire des choses malveillantes.

La réponse ?

« Mais Intel, vérifie alors les privilèges d’une instruction avant l’exécution spéculative, au lieu d’après ! » Cela semble être la solution, mais c’est là que réside le problème. La micro-architecture est construite pour effectuer le contrôle après coup. Tous les transistors et les interconnexions qui les transforment en circuits logiques sont conçus par les ingénieurs lors de la phase de conception, de sorte qu’ils ne peuvent être contrôlés qu’après coup. Il est possible de modifier le microprogramme et de résoudre (partiellement) le problème de sécurité, mais cela a un impact énorme sur les performances.

Dans le cas de la première variante de Spectre, la version 1.0, Intel a déployé des correctifs de micrologiciels qui faisaient basculer le processeur entre un mode utilisateur et un mode noyau. Après le correctif, une vérification est effectuée pour chaque instruction, après quoi le processeur passe au mode correct. Cela corrige le problème, mais dans la pratique, cela ralentit le processeur jusqu’à dix pour cent. La lenteur réelle dépend du type de processeur et du type de charge de travail. Les puces Haswell et plus anciennes sont particulièrement touchées. Dans les programmes de consommation traditionnels, le calcul s’effectue principalement dans l’espace utilisateur, et l’impact est minime. Au niveau des serveurs, il y a beaucoup plus de changements entre l’espace utilisateur et l’espace noyau, et le correctif réduit considérablement les performances.

Il est possible de résoudre (partiellement) le problème de sécurité, mais cela aura un impact énorme sur les performances.

Les puces AMD et les CPU sur architecture ARM sont également très vulnérables. Cependant, ils rencontrent moins de problèmes. À l’exception d’Intel, tout le monde a intégré un espace pour programmer à l’avance les instructions spéculatives. Un correctif de micrologiciel a donc un impact beaucoup plus faible, voire imperceptible, sur les performances. Cependant, AMD doit également éliminer la vulnérabilité et, quatre ans plus tard, elle n’y est toujours pas parvenue.

Un avenir sombre

Ce n’est plus un secret. Spectre est devenu un terme générique pour les fuites qui abusent de l’exécution spéculative. Maintenant qu’il est clair que les processeurs sont vulnérables via ce vecteur, les pirates et les spécialistes de la sécurité recherchent diligemment de nouveaux moyens d’abuser des instructions spéculatives. Spectre 1.1 et 1.2 en sont des exemples. Il n’y a aucune raison de penser qu’il n’y aura pas de versions 1.3 et 1.4, qui trouvent d’autres moyens de faire des choses non autorisées une réalité spéculative.

Entre-temps, Intel a amélioré Les principaux problèmes ont donc été résolus, mais l’exécution spéculative reste un phénomène dangereux. De temps en temps, de nouvelles variantes de Spectre apparaissent, qui fonctionnent également sur les puces modernes. La conception de processeurs totalement exempts de Spectre s’avère être un défi majeur pour Intel et AMD.

En attendant, Spectre reste une fuite extrêmement vicieuse, qui peut en partie être corrigée dans le microprogramme, mais qui doit également être limitée par tous les créateurs de logiciels. Malheureusement, cela a toujours un prix en termes de performances. Si vous entendez parler d’une nouvelle variante dangereuse dans les mois qui suivent, vous savez au moins maintenant pourquoi Spectre continue de vous hanter.

Petit point positif : dans les environnements professionnels, des solutions de sécurité avancées peuvent apporter un peu de calme. Ils ne le font pas en appliquant un correctif à la fuite, mais en vérifiant le code pour y déceler les caractéristiques d’une attaque Spectre, par exemple dans un environnement « sandbox ». Le processeur reste vulnérable, mais le logiciel malveillant est arrêté avant que l’attaque ne puisse être lancée.

newsletter

Abonnez-vous gratuitement à ITdaily !
Category(Required)
Consent(Required)
This field is for validation purposes and should be left unchanged.
retour à la maison