jovanbulck/sgx-stepUn framework d'attaque pratique pour un contrôle précis de l'exécution dans les enclaves
SGX-Step est un cadre open-source conçu pour faciliter la recherche sur les attaques par canaux auxiliaires sur les processeurs Intel x86 en général et les plates-formes Intel SGX en particulier. SGX-Step se compose d'un pilote noyau Linux adverse et d'une petite bibliothèque système en espace utilisateur qui permet de configurer des entrées de table de pages non fiables et/ou des interruptions de minuterie APIC x86 entièrement depuis l'espace utilisateur. SGX-Step a été utilisé dans nos propres recherches, ainsi que par des chercheurs indépendants, pour permettre plusieurs nouvelles attaques d'exécution d'enclaves améliorées qui recueillent des observations de canaux auxiliaires à une résolution temporelle maximale (c'est-à-dire en interrompant l'enclave victime après chaque instruction individuelle).
Licence. SGX-Step est un logiciel libre, sous licence GPLv3. Le logo de SGX-Step est dérivé de la célèbre série de photos domaine public "Sallie Gardner at a Gallop" d'Eadweard Muybridge, qui, comme notre objectif de pas à pas d'enclave, décompose la dynamique du cheval au galop en une série de photogrammes individuels pour révéler les propriétés globales de l'allure du cheval.
| Version SGX-Step | Fonctionnalités du journal des modifications |
|---|---|
| v1.5.0 | Correctifs de stabilisation (KPTI, mappage ISR noyau) ; port Gramine (expérimental) ; support IPI. |
| v1.4.0 | Portes d'interruption/appel privilégiées (Plundervolt). |
| v1.3.0 | Support d'exécution transitoire (Foreshadow). |
| v1.2.0 | Gestion des interruptions en espace utilisateur et filtrage déterministe zéro-pas (Nemesis). |
| v1.1.0 | Support IA32. |
| v1.0.0 | Manipulation des tables de pages en espace utilisateur et pas à pas par minuterie APIC. |
Publications. SGX-Step a été employé par plusieurs groupes de recherche indépendants et a permis une nouvelle lignée d'attaques SGX à haute résolution. Une liste complète et à jour des projets connus utilisant SGX-Step est incluse en bas de ce README. Une copie de l'article original est disponible ici.``` @inproceedings{vanbulck2017sgxstep, title = {{SGX-Step}: A Practical Attack Framework for Precise Enclave Execution Control}, author = {Van Bulck, Jo and Piessens, Frank and Strackx, Raoul}, booktitle = {2nd Workshop on System Software for Trusted Execution {(SysTEX)}}, publisher = {{ACM}}, pages = {4:1--4:6}, month = Oct, year = 2017, }
**Démo.** Le répertoire [app/memcmp](https://github.com/jovanbulck/sgx-step/blob/master/app/memcmp) contient une petite application de démonstration qui illustre la puissance des attaques SGX-Step en exécutant pas à pas une enclave exemple contenant une logique de comparaison de mot de passe `memcmp` subtile et non à temps constant. Contrairement aux attaques temporelles traditionnelles, notoirement bruyantes, SGX-Step peut forcer de manière déterministe le mot de passe caractère par caractère en temps _linéaire_ :
## Aperçu
Crucial pour la conception de SGX-Step, par opposition aux propositions précédentes de préemption d’enclave, est la création de mappages de mémoire virtuelle en espace utilisateur pour les emplacements de mémoire physique contenant les entrées de la table de pages, ainsi que pour les registres de configuration d’entrée-sortie mappée en mémoire du contrôleur d’interruptions APIC local et la table des descripteurs d’interruption (IDT) x86. Cela permet à un processus hôte non fiable contrôlé par un attaquant de (i) suivre ou modifier facilement les entrées de la table de pages de l’enclave, (ii) configurer la source d’interruption unique/périodique du minuteur APIC, (iii) déclencher des interruptions inter-processeurs et (iv) enregistrer des gestionnaires d’interruptions personnalisés complètement _dans_ l’espace utilisateur.
La figure ci-dessus résume la séquence d’étapes matérielles et logicielles lors de l’interruption et de la reprise d’une enclave SGX via notre infrastructure.
1. L’interruption du minuteur APIC local arrive à l’intérieur d’une instruction enclavée.
2. Le processeur exécute la procédure AEX qui stocke de manière sécurisée le contexte d’exécution dans la trame SSA de l’enclave, initialise les registres du CPU et vecteur vers le gestionnaire d’interruptions (en espace utilisateur) enregistré dans l’IDT.
3. À ce stade, tout code espion spécifique à l’attaque peut facilement être intégré.
4. La bibliothèque retourne à la trampoline AEP en espace utilisateur. Nous avons modifié l’environnement d’exécution non fiable du SDK SGX officiel pour permettre l’enregistrement facile d’un stub AEP personnalisé. De plus, pour permettre une évaluation précise de notre approche sur des enclaves de débogage de benchmark contrôlées par l’attaquant, SGX-Step peut _optionnellement_ être instrumenté pour récupérer le pointeur d’instruction stocké dans la trame SSA de l’enclave interrompue (en utilisant l’interface `/proc/self/mem` de Linux et l’instruction `EDBGRD`).
5. Ensuite, nous configurons le minuteur APIC local pour la prochaine interruption en écrivant dans le registre d’entrée-sortie mappé en mémoire de comptage initial, juste avant d’exécuter (6) `ERESUME`.
## Aperçu du code source
Ce dépôt est organisé comme suit :```
.
├── app -- Collection of sample client applications using SGX-Step to
│ attack different victim enclave scenarios.
├── doc -- Papers and reference material.
├── kernel -- Minimal dynamically loadable Linux kernel driver to export
│ physical memory to user space and bootstrap `libsgxstep`.
├── libsgxstep -- Small user-space operating system library that implements the
│ actual SGX-Step functionality, including x86 page-table and
│ APIC timer manipulations.
└── sdk -- Bindings to use SGX-Step with different SGX SDKs and libOSs.
SGX-Step est un framework de contrôle d'exécution universel qui permet l'entrelacement précis des instructions de l'enclave victime avec du code attaquant arbitraire. Quelques-uns des principaux cas d'utilisation du framework SGX-Step sont résumés dans la figure ci-dessous (voir également le bas de ce README pour une liste à jour des publications utilisant SGX-Step).
SGX-Step nécessite un processeur Intel compatible SGX et un noyau Linux standard. Notre évaluation originale a été réalisée sur des CPU i7-6500U/6700, exécutant Ubuntu 18.04 avec un noyau Linux 4.15.0 standard. Les noyaux Linux et distributions plus récents sont également pris en charge. Nous résumons ci-dessous les paramètres du noyau Linux.
| Paramètre du noyau Linux | Motivation |
|---|---|
nox2apic | Configurez éventuellement le périphérique APIC local en mode d'E/S mappée en mémoire (pour utiliser les fonctionnalités précises de pas à pas de SGX-Step). Si défini, assurez-vous de définir X2APIC à 0 dans libsgxstep/config.h. Sinon, vous pouvez laisser le CPU en mode x2APIC et les distributions SGX-Step récentes devraient également être compatibles. |
iomem=relaxed no_timer_check | Supprimez les messages d'avertissement inutiles dans les journaux du noyau. |
nmi_watchdog=0 | Supprimez le chien de garde NMI du noyau. |
isolcpus=1 | Affinitiez le processus victime à un cœur CPU isolé. |
clearcpuid=308,295,514 | Désactivez les fonctionnalités de prévention d'accès en mode superviseur (SMAP, bits 295), de prévention d'exécution en mode superviseur (SMEP, bits 308) et de prévention d'instructions en mode utilisateur (UMIP, bits 514). |
pti=off | Désactivez l'isolation de la table des pages du noyau (pour éviter les paniques du noyau avec les gestionnaires d'IRQ utilisateur). |
rcupdate.rcu_cpu_stall_suppress=1 | Désactivez le détecteur de blocage du CPU de mise à jour par lecture-copie (RCU) du noyau (pour éviter les avertissements lors de l'exécution pas à pas pendant une longue période sans appeler le gestionnaire d'interruption du timer du noyau). |
msr.allow_writes=on | Supprimez les messages d'avertissement du noyau pour les écritures de registres spécifiques au modèle (MSR) par SGX-Step. |
vdso=0 | Uniquement sur les noyaux Linux récents : désactivez la bibliothèque vdso_sgx_enter_enclave (non compatible avec les correctifs d'interception AEP). |
dis_ucode_ldr | Désactivez éventuellement les mises à jour du microcode du CPU (les correctifs récents contre les attaques par exécution transitoire peuvent nécessiter un réétalonnage de l'intervalle de pas à pas). |
Transmettez les paramètres de démarrage souhaités au noyau comme suit :```bash
$ sudo vim /etc/default/grub
$ sudo update-grub && reboot
Pour vérifier que le noyau actuellement en cours d'exécution est correctement configuré, exécutez :```bash
$ sudo ./check_sys.sh
.. Checking recommended SGX-Step parameters [OK]
.. Checking unknown kernel parameters [OK]
.. Checking CPU features [OK]
.. Checking kernel page-table isolation [OK]
Enfin, pour améliorer la stabilité globale du temps d'exécution, vous pouvez également désactiver les C-States et la technologie SpeedStep dans la configuration du BIOS.
/dev/sgx-stepSGX-Step inclut un module kernel chargeable qui exporte une interface IOCTL vers la bibliothèque espace utilisateur libsgxstep. Le pilote est principalement responsable de (i) l'interception du gestionnaire d'interruption du timer APIC, (ii) la collecte des mappages de tables de pages non fiables, et optionnellement (iii) la récupération du pointeur d'instruction interrompu pour les enclaves de benchmark.
Pour construire et charger le pilote /dev/sgx-step, exécutez :```bash
$ cd kernel/
$ ./install_SGX_driver.sh # tested on Ubuntu 20.04/22.04
$ make clean load
**Note (/dev/sgx_enclave).** SGX-Step prend en charge à la fois le pilote externe `/dev/isgx` hérité d'Intel, qui devrait fonctionner sur toutes les plateformes, ainsi que le pilote intégré `/dev/sgx_enclave` pour les plateformes équipées de noyaux Linux récents >5.11 avec prise en charge matérielle du contrôle de lancement flexible. Le script `install_SGX_driver.sh` détecte automatiquement si un pilote intégré `/dev/sgx_enclave` est disponible ; dans le cas contraire, il compile et charge le pilote externe `/dev/isgx` via le sous-module git pointant vers la version v2.14 non modifiée du [linux-sgx-driver](https://github.com/intel/linux-sgx-driver).
**Note (/dev/mem).** Nous utilisons le périphérique virtuel `/dev/mem` de Linux pour construire des mappages mémoire virtuels au niveau utilisateur pour les registres d'E/S mappés en mémoire physique de l'APIC et les entrées de tables de pages d'intérêt. Cependant, les distributions Linux récentes activent généralement l'option `CONFIG_STRICT_DEVMEM`, ce qui empêche une telle utilisation. Notre pilote `/dev/sgx-step` inclut donc une [approche](https://www.libcrack.so/index.php/2012/09/02/bypassing-devmem_is_allowed-with-kprobes/) pour contourner les vérifications de `devmem_is_allowed`, sans avoir à recompiler le noyau.
### 2. Appliquer les correctifs et installer le SDK SGX
Pour faciliter l'enregistrement d'un stub personnalisé de pointeur de sortie asynchrone (AEP), nous avons modifié l'environnement d'exécution non fiable du SDK SGX officiel d'Intel. Procédez comme suit pour extraire [linux-sgx](https://github.com/01org/linux-sgx) v2.29 et appliquer nos correctifs.```bash
$ cd sdk/intel-sdk/
$ ./install_SGX_SDK.sh # tested on Ubuntu 20.04/22.04
$ source /opt/intel/sgxsdk/environment # add to ~/.bashrc to preserve across terminal sessions
$ sudo service aesmd status # stop/start aesmd service if needed
Les scripts d'installation ci-dessus sont testés sur Ubuntu 22.04 LTS. Pour les autres distributions GNU/Linux, veuillez suivre les instructions dans le projet linux-sgx pour construire et installer les paquets Intel SGX SDK et PSW. Vous devrez également construire et charger un module noyau SGX (non modifié) linux-sgx-driver afin d'utiliser SGX-Step.
Note (installation locale). Les paquets SDK et PSW Intel SGX patchés peuvent être
installés localement, sans affecter une installation 'linux-sgx' compatible à l'échelle du système.
Pour cela, les Makefiles d'exemple prennent en charge une variable d'environnement SGX_SDK
qui pointe vers le répertoire d'installation local du SDK. Lorsqu'un
chemin SDK non par défaut est détecté (c'est-à-dire pas /opt/intel/sgxsdk), les cibles Makefile "run"
lient en outre dynamiquement contre l'environnement d'exécution non fiable patché
libsgx_urts.so construit dans le répertoire local linux-sgx
(en utilisant la variable d'environnement LD_LIBRARY_PATH).
Note (support 32 bits). Les instructions (obsolètes et non maintenues !) pour construire des versions 32 bits du SDK SGX et de SGX-Step peuvent être trouvées dans README-m32.md.
Les applications espace utilisateur peuvent se lier à la bibliothèque libsgxstep pour utiliser
les fonctionnalités de pas à pas et de manipulation de tables de pages de SGX-Step. Jetez un œil aux
applications d'exemple dans le répertoire "app".
Tout d'abord, vérifiez la configuration de l'APIC et de la table des descripteurs d'interruption :```bash $ cd app/selftest/idt $ make run # fires interrupts in an infinite loop to stress-test stability; exit with CTRL-C
Par exemple, pour construire et exécuter une application d'exemple élémentaire afin de tester les fonctionnalités de manipulation de tables de pages et les correctifs du SDK :```bash
$ cd app/aep-redirect
$ make run
Pour tester la fonctionnalité de pas à pas du minuteur, essayez par exemple de construire et d'exécuter une enclave de benchmark pour exécuter pas à pas une séquence de 100 instructions nop successives :```bash
$ cd app/bench
$ NUM=100 make parse # alternatively vary NUM and use STRLEN=1 or ZIGZAG=1
La commande ci-dessus construit `libsgxstep`, l'enclave victime de référence et le
processus hôte attaquant non fiable, où le scénario d'attaque et la taille de
l'instance sont configurés via les variables d'environnement correspondantes.
La même commande exécute également le binaire résultant de manière non
interactive (pour garantir des intervalles de temporisation déterministes), et
appelle finalement un script Python de post-traitement spécifique à l'attaque
pour analyser les résultats du benchmark du pointeur d'instruction de l'enclave.
**Remarque (performance).** L'exécution pas à pas d'une enclave entraîne un
ralentissement substantiel. Nous avons mesuré des temps d'exécution allant
jusqu'à 15 minutes pour les expériences décrites dans l'article. Les
fonctionnalités de manipulation des tables de pages de SGX-Step permettent
d'initier le pas à pas uniquement pour certaines fonctions, par exemple en
révoquant les droits d'accès sur des pages de code ou de données spécifiques.
**Remarque (intervalle de temporisation).** La valeur exacte de l'intervalle de
temporisation dépend de la fréquence du CPU, et reste donc intrinsèquement
spécifique à la plateforme (voir aussi
[app/selftest/apic](https://github.com/jovanbulck/sgx-step/blob/master/app/selftest/apic) pour des microbenchmarks détaillés
évaluant la précision des différents modes de temporisation APIC). Configurez
une valeur appropriée dans `/app/bench/main.c`. Nous avons établi des
intervalles de temporisation précis pour nos plateformes d'évaluation (voir
tableau ci-dessous) en ajustant et en observant les résultats de trace du
pointeur d'instruction de l'enclave NOP microbenchmark, comme décrit plus loin.
**Remarque (stabilité).** Afin d'éviter que le noyau Linux ne se bloque ou ne
panique, SGX-Step doit automatiquement restaurer la table des descripteurs
d'interruption et le temporisateur APIC local après la sortie du processus
`libsgxstep`. Vous pouvez vérifier si le temporisateur APIC est toujours actif
sur tous les cœurs comme suit :```bash
$ watch -n0.1 "cat /proc/interrupts | grep 'Local timer interrupts'"
Le tableau ci-dessous liste les processeurs Intel actuellement pris en charge, avec leur intervalle de temporisation APIC pour le pas à pas (libsgxstep/config.h).
Notez que l'intervalle exact de pas à pas peut dépendre de la version du microcode du processeur lorsque les récentes atténuations des attaques par exécution transitoire sont en place pour vider les tampons microarchitecturaux à l'entrée/sortie de l'enclave.
Plusieurs versions de microcode différentes sont fournies à titre de référence dans le tableau ci-dessous.
| Nom du modèle | Processeur | Fréquence de base | ucode (date) | Intervalle du timer APIC |
|---|---|---|---|---|
| Skylake | i7-6700 | 3.4 GHz | ? | 19 |
| Skylake | i7-6500U | 2.5 GHz | ? | 25 |
| Skylake | i5-6200U | 2.3 GHz | ? | 28 |
| Kaby Lake R | i7-8650U | 1.9 GHz | ? | 34 |
| Kaby Lake R | i7-8650U | 1.9 GHz | 0xca (2019-10-03) | 54 |
| Coffee Lake R | i7-9700 | 3 GHz | 0xf4 (2022-07-31) | 26 |
| Coffee Lake R | i9-9900K | 3.6 GHz | ? | 21 |
| Coffee Lake HR | i7-9750H | 2.6 GHz | 0xf4 (2023-02-23) | 37 |
| Ice Lake | i5-1035G1 | 1.00 GHz | 0x32 (2019-07-05) | 135 |
| Ice Lake | i5-1035G1 | 1.00 GHz | 0xb0 (2022-03-09) | 255 |
| Comet Lake | i9-10900K | 3.70 GHz | 0xfc (2024-02-01) | 24 |
| Emerald Rapids | Xeon Gold 5515+ |
Remarque (calibrage).
Actuellement, la façon la plus simple de configurer un intervalle de temporisation fiable est d'utiliser l'outil de benchmarking app/bench avec un long NOP slide et d'augmenter/diminuer progressivement SGX_STEP_TIMER_INTERVAL. Vous pouvez probablement commencer autour de 20, puis exécuter NUM=100 make parse pour obtenir un résumé des single-steps, zero-steps et multi-steps pour un NOP slide de 100 instructions (une fois que vous avez un intervalle plus ou moins stable, vous pouvez passer à des slides plus longs). Un trop grand nombre de zero-steps indique que vous devez augmenter l'intervalle du timer, tandis que des multi-steps nécessitent de diminuer l'intervalle du timer.
Remarque (filtrage des zero-steps). Important : ne vous inquiétez pas s'il reste quelques zero-steps, tant que vous progressez, vous pouvez toujours filtrer de manière déterministe les zero-steps en examinant le bit d'accès PTE du code de l'enclave (qui n'est activé que lorsque l'instruction se retire effectivement et qu'un single-step a eu lieu). Ainsi, après avoir configuré un intervalle de temporisation conservateur qui exclut toujours les multi-steps, SGX-Step peut réaliser un pas à pas sans bruit à une granularité parfaite, au niveau de l'instruction.
Remarque (extension de la « fenêtre d'atterrissage » de l'interruption).
Comme il est expliqué dans l'analyse de cause racine ci-dessous, plus la promenade de la table des pages (page table walk) pour résoudre l'adresse (du code) de la première instruction de l'enclave après ERESUME est lente, plus la « fenêtre d'atterrissage » de l'interruption est longue et, par conséquent, plus le taux de pas à pas de SGX-Step sera fiable. Par exemple, nous avons constaté qu'en plus d'effacer le bit d'accès PMD de l'enclave, la fenêtre d'atterrissage peut être encore étendue en vidant une ou plusieurs entrées de table des pages non protégées du cache CPU avant ERESUME, forçant ainsi le CPU à attendre la mémoire lente lors de la promenade de la table des pages. Ainsi, lorsque vous ne trouvez pas de configuration d'intervalle de temporisation fiable, assurez-vous de (i) effacer le bit « accessed » PTE/PMD du code de l'enclave et (ii) vider (CLFLUSH) une ou plusieurs entrées de la table des pages de l'enclave dans le gestionnaire AEP.
Remarque (microcode). Un autre mot de prudence concerne les récentes atténuations via microcode pour Foreshadow/ZombieLoad/RIDL/etc. qui vident les tampons microarchitecturaux divulguant des informations à l'entrée/sortie de l'enclave. Soyez conscient que lorsque ces atténuations sont activées, l'intervalle du timer devra être augmenté car l'entrée dans l'enclave prend plus de temps (par exemple, sur mon CPU i7-8650U, j'ai constaté que l'intervalle du timer pour le pas à pas passe à 54 avec le microcode récent, contre seulement 34 avec le microcode d'avant Foreshadow). Les opérations de vidage supplémentaires peuvent en outre augmenter quelque peu la variance du temps d'entrée dans l'enclave, ce qui implique que vous devrez peut-être configurer le timer de manière plus conservatrice avec plus de zero-steps (qui peuvent être filtrés de manière déterministe comme expliqué ci-dessus).
Une analyse de cause racine détaillée de la façon exacte dont SGX-Step parvient à interrompre de manière fiable la première (voire très courte !) instruction de l'enclave après la célèbre instruction complexe ERESUME est décrite dans l'article AEX-Notify. Nous avons découvert que la clé du succès de SGX-Step réside dans son utilisation du bit « accessed » (A). Plus précisément, SGX-Step efface toujours le bit A dans le répertoire de pages intermédiaires (PMD) de l'enclave victime avant d'armer l'APIC pour déclencher une interruption à un seul coup. Le bit A n'est activé par le processeur que lorsqu'au moins une instruction est exécutée par l'enclave et peut donc être utilisé pour distinguer de manière déterministe les zero-steps des single-steps.
Crucialement, comme le gestionnaire d'absence de page (page-miss handler) du processeur est optimisé pour le chemin rapide courant et utilise un « assist microcode » beaucoup plus lent pour gérer le cas moins fréquent et plus complexe où une PMD ou une PTE doit être modifiée, cet assist a pour effet de prolonger l'exécution de la première instruction de l'enclave après ERSUME de plusieurs centaines de cycles. Cette « fenêtre d'assistance » ouvre ainsi effectivement un espace d'atterrissage spacieux pour que l'interruption du timer APIC, grossièrement granulée et normalement distribuée, arrive avec une grande précision.
La façon la plus simple de commencer à utiliser le framework SGX-Step dans vos propres projets est via les sous-modules Git :```bash
$ cd my/git/project
$ git submodule add https://github.com/jovanbulck/sgx-step.git
$ cd sgx-step # Now build /dev/sgx-step and libsgxstep as described above
Consultez les Makefiles dans le répertoire `app` pour voir comment une application cliente peut se lier à `libsgxstep` ainsi qu'à tout paquet SGX SDK/PSW local.
<a name="bottom"></a>
Voici une liste de projets connus utilisant SGX-Step. N'hésitez pas à ouvrir une pull request si votre projet utilise SGX-Step mais n'est pas inclus ci-dessous.
| Titre | Détails de publication | Code source | Fonctionnalités SGX-Step utilisées |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
| AEX-NStep : Attaques probabilistes par comptage d'interruptions sur Intel SGX | [S&P'26](https://arxiv.org/pdf/2510.14675) | [Zenodo](https://zenodo.org/records/17338383) | Page faults, IPIs, WRMSR Interrupt Gate |
| MDPeek : Briser les branches équilibrées dans SGX avec les canaux auxiliaires de l'unité de désambiguïsation mémoire | [ASPLOS'25](https://www.comp.nus.edu.sg/~tcarlson/pdfs/liu2025mbbbiswmdusc.pdf) | [GitHub (Artifact Evaluated & Functional)](https://github.com/CPU-THU/MDPeek) | Page faults |
| Les fonctions d'activation considérées nuisibles : récupération des poids de réseaux de neurones via des canaux contrôlés | [RAID'25](https://ieeexplore.ieee.org/document/11352487) | [Github Artifact](https://github.com/heavyimage/afch_paper) | Single-stepping, PTE A/D |
| TLBlur : Durcissement automatisé assisté par compilateur contre les canaux contrôlés sur les plateformes Intel SGX standard | [USEC'25](https://vanbulck.net/files/usenix25-tlblur.pdf) | [GitHub (full)](https://github.com/TLBlur-SGX) | Single-stepping, PTE A/D, page faults |
| POSTER : Sur la faisabilité d'inférer l'exécution SGX via le PMU | [AsiaCCS'24](https://dl.acm.org/doi/pdf/10.1145/3634737.3659434) | - | Single-stepping, zero-stepping|
| SIGY : Briser les enclaves Intel SGX avec des exceptions et signaux malveillants | [ArXiv'24](https://arxiv.org/abs/2404.13998) | - | Timer interrupts, page faults |
| Sur l'absence de confidentialité du code dans les environnements d'exécution de confiance | [S&P24](https://ivanpuddu.com/files/papers/TEE_WASM_code_Leakage.pdf) | [GitHub (empty)](https://github.com/dn0sar/TEE-WASM-Code-Extraction) | Single-stepping |
| TeeJam : Les fuites sous la ligne de cache frappent à nouveau | [CHES24](https://doi.org/10.46586/tches.v2024.i1.457-500) | [Github (full)](https://github.com/UzL-ITS/teejam) | Single-stepping interrupt latency, PTE A/D |
| AEX-Notify : Contrer les attaques précises à pas-à-pas via la conscience des interruptions pour les enclaves Intel SGX | [USEC23](https://jovanbulck.github.io/files/usenix23-aexnotify.pdf) | [GitHub (SGX SDK mitigation)](https://github.com/intel/linux-sgx/blob/master/sdk/trts/linux/trts_mitigation.S) | Single-Stepping, PTE A/D
| Courses de données contrôlées dans les enclaves : attaques et détection | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-chen-sanchuan.pdf) | [GitHub (non-attack)](https://github.com/OSUSecLab/SGXRacer) | Single-stepping, APIC |
| BunnyHop : Exploitation du préfetcheur d'instructions | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-zhang-zhiyuan-bunnyhop.pdf) | [GitHub (non-SGX PoC)](https://github.com/0xADE1A1DE/BunnyHop) | Single-stepping, PTE A/D |
| Downfall : Exploitation de la collecte spéculative de données | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-moghimi.pdf) | [GitHub (non-SGX PoC)](https://github.com/flowyroll/downfall/tree/main/POC) | Single-stepping, zero-stepping |
| Tous vos PC nous appartiennent : Exploitation des mises à jour BTB d'instructions non-transfert pour l'extraction dynamique de PC | [ISCA23](https://dl.acm.org/doi/pdf/10.1145/3579371.3589100?casa_token=Q5jf5nOgiLIAAAAA:cT0ltJh7vk943buODuR4oMFKmuhg2Tp-djFm2kUu6DzlxtBhNhEw2WteRggn0k99D7ft-P6pluVrFA) | - | Single-stepping |
| Attaque par temporisation de cache contre HQC | [CHES23](https://eprint.iacr.org/2023/102.pdf) | - | Single-stepping, PTE A/D |
| FaultMorse : Une attaque automatisée par canal contrôlé via la plus longue séquence récurrente | [ComSec23](https://www.sciencedirect.com/science/article/pii/S0167404822003959) | [GitHub (post processing)](https://github.com/Ezekiel-1998/FaultMorse) | Page fault |
| AEPIC Leak : Fuite architecturale de données non initialisées depuis la microarchitecture | [USEC22](https://www.usenix.org/system/files/sec22-borrello.pdf) | [GitHub (full)](https://github.com/IAIK/AEPIC) | Single-Stepping, PTE A/D |
| MoLE : Atténuation des attaques par canaux auxiliaires contre SGX via l'échappement dynamique de localisation des données | [ACSAC22](https://dl.acm.org/doi/fullHtml/10.1145/3564625.3568002) | - | Single-Stepping, page fault, transient execution |
| WIP : Attaque par interruption sur les véhicules robotiques protégés par TEE | [AutoSec22](https://www.ndss-symposium.org/wp-content/uploads/autosec2022_23001_paper.pdf) | - | Single-stepping, multi-stepping |
| Vers des enclaves auto-surveillées : Détection de canaux auxiliaires à l'aide de compteurs de performances | [NordSec22](https://link.springer.com/chapter/10.1007/978-3-031-22295-5_7) | - | Page fault, LVI. |
| ENCLYZER : Analyse automatisée des fuites de données transitoires sur Intel SGX | [SEED22](https://ieeexplore.ieee.org/document/9935016) | [GitHub (full)](https://github.com/bloaryth/enclyser) | Page-table manipulation |
| Canal auxiliaire sur l'expansion de clé Kalyna | [CT-RSA22](https://cs.adelaide.edu.au/~yval/pdfs/ChuengsatiansupGYZ22.pdf) | - | Single-Stepping, PTE A/D |
| Prototypage rapide pour attaques microarchitecturales | [USENIX22](https://www.usenix.org/system/files/sec22summer_easdon.pdf) | [GitHub (full)](https://github.com/libtea/frameworks) | Single-stepping, page fault, PTE A/D, etc. |
| Util::Lookup : Exploitation du décodage de clés dans les bibliothèques cryptographiques | [CCS21](https://dl.acm.org/doi/abs/10.1145/3460120.3484783) | [GitHub (full)](https://github.com/UzL-ITS/util-lookup) | Single-Stepping, PTE A/D |
| SmashEx : Briser les enclaves SGX à l'aide d'exceptions | [CCS21](https://dl.acm.org/doi/pdf/10.1145/3460120.3484821) | - | Single-Stepping |
| Attaques par templates en ligne : revisitées | [CHES21](https://tches.iacr.org/index.php/TCHES/article/view/8967/8545) | [Zenodo (simulation)](https://zenodo.org/record/4680071) | Single-stepping, page fault, PTE A/D |
| Attaques Aion : Manipulation des temporisateurs logiciels dans un environnement d'exécution de confiance | [DIMVA21](http://individual.utoronto.ca/shengjiexu/publication/whuang-dimva2021-aion_v2.pdf) | - | Single-stepping, interrupts(?) |
| Platypus : Attaques par canal auxiliaire de puissance basées sur logiciel sur x86 | [S&P21](https://platypusattack.com/platypus.pdf) | [GitHub (simulated PoC)](https://github.com/0xhilbert/Platypus) | Single-stepping, zero-stepping |
| CrossTalk : Les fuites de données spéculatives entre cœurs sont réelles | [S&P21](https://download.vusec.net/papers/crosstalk_sp21.pdf) | - | Single-stepping, page fault |
| Frontal Attack : Fuite du flot de contrôle dans SGX via le frontal du CPU | [USEC21](https://www.usenix.org/system/files/sec21-puddu.pdf) | [GitHub (full, artifact evaluated)](https://github.com/dn0sar/frontal_poc) | Single-stepping interrupt latency, PTE A/D |
| PThammer : Rowhammer trans-frontière utilisateur-noyau via accès implicites | - | [MICRO20](https://arxiv.org/pdf/2007.08707v2.pdf) | Page table walk |
| SpeechMiner : Un framework pour investiguer et mesurer les vulnérabilités d'exécution spéculative | [NDSS20](https://www.ndss-symposium.org/wp-content/uploads/2020/02/23105-paper.pdf) | [GitHub (full)](https://github.com/teecert/SpeechMiner) | Page-table manipulation |
| Déjà Vu : Analyse par canal auxiliaire de NSS de Mozilla | [CCS20](https://dl.acm.org/doi/pdf/10.1145/3372297.3421761) | - | Page fault |
| De A à Z : Fuite de coordonnées projectives dans la nature | [CHES20](https://eprint.iacr.org/2020/432.pdf) | - | Page fault |
| LVI : Détournement d'exécution transitoire via l'injection de valeur de charge microarchitecturale | [S&P20](https://lviattack.eu/lvi.pdf) | [GitHub (PoC)](https://github.com/jovanbulck/sgx-step-lvi/tree/master/app/lvi) | Single-stepping, page-table manipulation |
| CopyCat : Attaques contrôlées au niveau instruction sur les enclaves | [USEC20](https://arxiv.org/pdf/2002.08437.pdf) | - | Single-stepping, page fault, PTE A/D |
| Quand une primitive vulnérable devient virale : Nouvelles attaques à trace unique sur ECDSA et RSA | [CHES20](https://eprint.iacr.org/2020/055.pdf) | - | Single-stepping, page fault, PTE A/D |
| Grands nombres - Grands problèmes : Analyse systématique des fuites de nonce dans les implémentations (EC)DSA | [USEC20](https://www.usenix.org/system/files/sec20summer_weiser_prepub_0.pdf) | - | Page fault |
| Plundervolt : Attaques par injection de fautes basées logiciel contre Intel SGX | [S&P20](https://plundervolt.com/doc/plundervolt.pdf) | [GitHub (full)](https://github.com/KitMurdock/plundervolt) | Privileged interrupt/call gates, MSR |
| Bluethunder : Attaque par canal auxiliaire basée sur un prédicteur directionnel à 2 niveaux contre SGX | [CHES20](https://heartever.github.io/files/bluethunder_sgx_ches.pdf) | - | Single-stepping |
| Fallout : Fuite de données sur les CPU résistants à Meltdown | [CCS19](https://mdsattacks.com/files/fallout.pdf) | - | PTE A/D |
| Une histoire de deux mondes : Évaluation de la vulnérabilité des runtimes de protection d'enclave | [CCS19](https://people.cs.kuleuven.be/~jo.vanbulck/ccs19-tale.pdf) | [GitHub (full)](https://github.com/jovanbulck/0xbadc0de) | Single-stepping, page fault, PTE A/D |
| ZombieLoad : Échantillonnage de données trans-frontière de privilège | [CCS19](https://zombieloadattack.com/zombieload.pdf) | [GitHub (PoC)](https://github.com/IAIK/ZombieLoad/) | Single-stepping, zero-stepping, page-table manipulation |
| SPOILER : Les aléas de charge spéculative amplifient Rowhammer et les attaques par cache | [USEC19](https://arxiv.org/pdf/1903.00446.pdf) | - | Single-stepping interrupt latency |
| Nemesis : Étude des fuites temporelles microarchitecturales dans la logique d'interruption rudimentaire du CPU | [CCS18](https://people.cs.kuleuven.be/~jo.vanbulck/ccs18.pdf) | [GitHub (full)](https://github.com/jovanbulck/nemesis) | Single-stepping interrupt latency, page fault, PTE A/D |
| Foreshadow : Extraction des clés du royaume Intel SGX avec exécution transitoire hors-ordre | [USEC18](https://foreshadowattack.eu/foreshadow.pdf) | [GitHub (PoC)](https://github.com/jovanbulck/sgx-step/tree/master/app/foreshadow) | Single-stepping, zero-stepping, page-table manipulation |
| Attaque à trace unique contre la génération de clés RSA dans Intel SGX SSL | [AsiaCCS18](https://rspreitzer.github.io/publications/proc/asiaccs-2018-paper-1.pdf) | - | Page fault |
| Off-Limits : Abus de la segmentation mémoire x86 héritée pour espionner l'exécution d'enclave | [ESSoS18](https://people.cs.kuleuven.be/~jo.vanbulck/essos18.pdf) | [link (full, artifact evaluated)](https://distrinet.cs.kuleuven.be/software/off-limits/) | Single-stepping, IA32 segmentation, page fault |
| SGX-Step : Un framework d'attaque pratique pour le contrôle précis de l'exécution d'enclave | [SysTEX17](https://people.cs.kuleuven.be/~jo.vanbulck/systex17.pdf) | [GitHub (full)](https://github.com/jovanbulck/sgx-step/tree/master/app/bench) | Single-stepping, page fault, PTE A/D |
| 3.2 GHz |
| 0x21000230 (2024-02-05) |
| 32 |