jovanbulck/sgx-stepUn pratico framework di attacco per un controllo preciso dell'esecuzione dell'enclave
SGX-Step è un framework open-source per facilitare la ricerca sugli attacchi a canale laterale su processori Intel x86 in generale e su piattaforme Intel SGX in particolare. SGX-Step consiste in un driver del kernel Linux avversario e una piccola libreria del sistema operativo in spazio utente che permette di configurare voci di tabella delle pagine non fidate e/o interrupt del timer APIC x86 completamente dallo spazio utente. SGX-Step è stato sfruttato nella nostra ricerca, così come da ricercatori indipendenti, per abilitare diversi nuovi e migliorati attacchi all'esecuzione nelle enclave che raccolgono osservazioni a canale laterale con una risoluzione temporale massima (cioè, interrompendo l'enclave vittima dopo ogni singola istruzione).
Licenza. SGX-Step è software libero, concesso in licenza sotto GPLv3. Il logo di SGX-Step è derivato dall'iconica serie di foto di pubblico dominio "Sallie Gardner at a Gallop" di Eadweard Muybridge, che, come il nostro obiettivo di single-stepping delle enclave, scompone le dinamiche del cavallo al galoppo in una serie di singoli fotogrammi per rivelare le proprietà generali dell'andatura del cavallo.
| Rilascio SGX-Step | Caratteristiche del changelog |
|---|---|
| v1.5.0 | Correzioni di stabilizzazione (KPTI, mapping ISR del kernel); (sperimentale) porting Gramine; supporto IPI. |
| v1.4.0 | Gate di interrupt/chiamata privilegiati (Plundervolt). |
| v1.3.0 | Supporto per esecuzione transiente (Foreshadow). |
| v1.2.0 | Gestione degli interrupt in spazio utente e filtraggio deterministico zero-step (Nemesis). |
| v1.1.0 | Supporto IA32. |
| v1.0.0 | Manipolazione delle tabelle delle pagine in spazio utente e single-stepping del timer APIC. |
Pubblicazioni. SGX-Step è stato utilizzato da diversi gruppi di ricerca indipendenti e ha abilitato una nuova linea di attacchi SGX ad alta risoluzione. Un elenco completo e aggiornato dei progetti noti che utilizzano SGX-Step è incluso in fondo a questo README. Una copia del documento originale è disponibile qui.``` @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, }
**Demo.** La directory [app/memcmp](https://github.com/jovanbulck/sgx-step/blob/master/app/memcmp) contiene una piccola applicazione demo che illustra la potenza degli attacchi SGX-Step eseguendo passo-passo un enclave di esempio che contiene una logica di confronto password `memcmp` non a tempo costante, sottile. A differenza dei tradizionali attacchi a tempo, notoriamente rumorosi, SGX-Step può forzare deterministicamente la password carattere per carattere in tempo _lineare_:
## Panoramica
Cruciale per la progettazione di SGX-Step, a differenza delle precedenti proposte di prelazione degli enclave, è la creazione di mapping di memoria virtuale nello spazio utente per le locazioni di memoria fisica che contengono le voci delle tabelle delle pagine, così come per i registri di configurazione I/O memory-mapped dell'APIC locale e per la tabella dei descrittori di interrupt (IDT) x86. Ciò consente a un processo host non fidato, controllato dall'attaccante, di (i) tracciare o modificare facilmente le voci delle tabelle delle pagine dell'enclave, (ii) configurare la sorgente di interrupt one-shot/periodica del timer APIC, (iii) attivare interrupt inter-processore e (iv) registrare gestori di interrupt personalizzati completamente _all'interno_ dello spazio utente.
La figura sopra riassume la sequenza di passi hardware e software nell'interrompere e riprendere un enclave SGX tramite il nostro framework.
1. L'interrupt del timer APIC locale arriva durante un'istruzione enclave.
2. Il processore esegue la procedura AEX che memorizza in modo sicuro il contesto di esecuzione nel frame SSA dell'enclave, inizializza i registri della CPU e vettorizza al gestore di interrupt (nello spazio utente) registrato nell'IDT.
3. A questo punto, qualsiasi codice spia specifico per l'attacco può essere facilmente inserito.
4. La libreria ritorna al trampolino AEP nello spazio utente. Abbiamo modificato il runtime non fidato dell'SDK SGX ufficiale per consentire la facile registrazione di uno stub AEP personalizzato. Inoltre, per consentire una valutazione precisa del nostro approccio su enclave di debug benchmark controllati dall'attaccante, SGX-Step può _opzionalmente_ essere strumentato per recuperare il puntatore all'istruzione memorizzato dal frame SSA dell'enclave interrotta (utilizzando l'interfaccia `/proc/self/mem` di Linux e l'istruzione `EDBGRD`).
5. Successivamente, configuriamo il timer APIC locale per il prossimo interrupt scrivendo nel registro I/O memory-mapped del conteggio iniziale, appena prima di eseguire (6) `ERESUME`.
## Panoramica del codice sorgente
Questo repository è organizzato come segue:```
.
├── 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 è un framework universale di controllo dell'esecuzione che consente l'interleaving preciso delle istruzioni dell'enclave vittima con codice attaccante arbitrario. Alcuni dei principali casi d'uso del framework SGX-Step sono riassunti nella figura seguente (vedere anche il fondo di questo README per un elenco aggiornato delle pubblicazioni che utilizzano SGX-Step).
SGX-Step richiede un processore Intel SGX-capable e un kernel Linux standard. La nostra valutazione originale è stata eseguita su CPU i7-6500U/6700, con Ubuntu 18.04 e un kernel Linux 4.15.0 standard. Sono supportati anche kernel e distribuzioni Linux più recenti. Di seguito riassumiamo i parametri del kernel Linux.
| Parametro del kernel Linux | Motivazione |
|---|---|
nox2apic | Configura opzionalmente il dispositivo APIC locale in modalità I/O mappata in memoria (per utilizzare le funzionalità di single-stepping preciso di SGX-Step). Se impostato, assicurati di impostare X2APIC a 0 in libsgxstep/config.h. In alternativa, puoi lasciare la CPU in modalità x2APIC e le distribuzioni recenti di SGX-Step dovrebbero essere compatibili. |
iomem=relaxed no_timer_check | Sopprime i messaggi di avviso non necessari nei log del kernel. |
nmi_watchdog=0 | Sopprime il watchdog NMI del kernel. |
isolcpus=1 | Affinizza il processo vittima a un core CPU isolato. |
clearcpuid=308,295,514 | Disabilita le funzionalità di prevenzione dell'accesso in modalità supervisore (SMAP, bit 295), prevenzione dell'esecuzione in modalità supervisore (SMEP, bit 308) e prevenzione delle istruzioni in modalità utente (UMIP, bit 514). |
pti=off | Disabilita l'isolamento delle tabelle delle pagine del kernel (per evitare panico del kernel con gestori IRQ utente). |
rcupdate.rcu_cpu_stall_suppress=1 | Disabilita il rilevatore di stallo CPU read-copy update (RCU) del kernel (per evitare avvisi durante il single-stepping prolungato senza chiamare il gestore di interrupt del timer del kernel). |
msr.allow_writes=on | Sopprime i messaggi di avviso del kernel per le scritture nei registri modello-specifici (MSR) da parte di SGX-Step. |
vdso=0 | Solo su kernel Linux recenti: disabilita la libreria vdso_sgx_enter_enclave (non compatibile con le patch di intercettazione AEP). |
dis_ucode_ldr | Disabilita opzionalmente gli aggiornamenti del microcodice della CPU (le recenti mitigazioni degli attacchi di esecuzione transitoria potrebbero richiedere la ricalibrazione dell'intervallo di single-stepping). |
Passare al kernel i parametri di avvio desiderati come segue:```bash
$ sudo vim /etc/default/grub
$ sudo update-grub && reboot
Per verificare che il kernel attualmente in esecuzione sia configurato correttamente, esegui:```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]
Infine, per migliorare la stabilità complessiva del tempo di esecuzione, puoi optare per disabilitare ulteriormente gli C-States e la tecnologia SpeedStep nella configurazione del BIOS.
/dev/sgx-stepSGX-Step viene fornito con un modulo del kernel caricabile che esporta un'interfaccia IOCTL verso la libreria user-space libsgxstep. Il driver è principalmente responsabile di (i) hooking del gestore dell'interrupt del timer APIC, (ii) raccolta dei mapping della tabella delle pagine non attendibili, e opzionalmente (iii) recupero del puntatore all'istruzione interrotta per enclave di benchmark.
Per compilare e caricare il driver /dev/sgx-step, esegui:```bash
$ cd kernel/
$ ./install_SGX_driver.sh # tested on Ubuntu 20.04/22.04
$ make clean load
**Nota (/dev/sgx_enclave).** SGX-Step supporta sia il driver legacy Intel `/dev/isgx` out-of-tree, che dovrebbe funzionare su tutte le piattaforme, sia il driver upstream `/dev/sgx_enclave` per piattaforme con kernel Linux recenti >5.11 e supporto hardware per il controllo di avvio flessibile. Lo script `install_SGX_driver.sh` dovrebbe rilevare automaticamente se un driver in-tree `/dev/sgx_enclave` è disponibile e, in caso contrario, costruire e caricare il driver out-of-tree `/dev/isgx` tramite il sottomodulo git che punta a una versione v2.14 non modificata di [linux-sgx-driver](https://github.com/intel/linux-sgx-driver).
**Nota (/dev/mem).** Facciamo affidamento sul dispositivo virtuale `/dev/mem` di Linux per costruire mappature di memoria virtuale a livello utente per i registri APIC di I/O mappati in memoria fisica e le voci della tabella delle pagine di interesse. Le distribuzioni Linux recenti abilitano solitamente l'opzione `CONFIG_STRICT_DEVMEM` che impedisce tale uso, tuttavia. Il nostro driver `/dev/sgx-step` include quindi un [approccio](https://www.libcrack.so/index.php/2012/09/02/bypassing-devmem_is_allowed-with-kprobes/) per bypassare i controlli `devmem_is_allowed`, senza dover ricompilare il kernel.
### 2. Applicare patch e installare SGX SDK
Per abilitare la registrazione semplice di uno stub personalizzato del Puntatore di Uscita Asincrona (AEP), abbiamo modificato il runtime non attendibile dell'SDK Intel SGX ufficiale. Procedere come segue per effettuare il checkout di [linux-sgx](https://github.com/01org/linux-sgx) v2.29 e applicare le nostre patch.```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
Gli script di installazione sopra indicati sono testati su Ubuntu 22.04 LTS. Per altre distribuzioni GNU/Linux, segui le istruzioni nel progetto linux-sgx per compilare e installare i pacchetti Intel SGX SDK e PSW. Dovrai anche compilare e caricare un modulo kernel SGX linux-sgx-driver (non modificato) per utilizzare SGX-Step.
Nota (installazione locale). I pacchetti SGX SDK e PSW modificati possono essere
installati localmente, senza influenzare un'installazione compatibile a livello di sistema di 'linux-sgx'.
A questo scopo, i Makefile di esempio supportano una variabile d'ambiente SGX_SDK
che punta alla directory di installazione locale dell'SDK. Quando
viene rilevato un percorso SDK non predefinito (cioè diverso da /opt/intel/sgxsdk), i target "run"
del Makefile inoltre si collegano dinamicamente al runtime non fidato
libsgx_urts.so modificato, compilato nella directory locale linux-sgx
(usando la variabile d'ambiente LD_LIBRARY_PATH).
Nota (supporto 32 bit). Le istruzioni (obsolete e non mantenute!) per compilare versioni a 32 bit dell'SDK SGX e di SGX-Step si trovano in README-m32.md.
Le applicazioni nello spazio utente possono collegarsi alla libreria libsgxstep per utilizzare
le funzionalità di esecuzione passo-passo e manipolazione delle tabelle delle pagine di SGX-Step. Dai un'occhiata
alle applicazioni di esempio nella directory "app".
Prima, controlla la configurazione dell'APIC e della tabella dei descrittori di interrupt:```bash $ cd app/selftest/idt $ make run # fires interrupts in an infinite loop to stress-test stability; exit with CTRL-C
Ad esempio, per compilare ed eseguire un'applicazione di esempio elementare per testare le funzionalità di manipolazione della tabella delle pagine e le patch dell'SDK:```bash
$ cd app/aep-redirect
$ make run
Per testare la funzionalità di single-stepping del timer, prova ad esempio a compilare ed eseguire un enclave di benchmark per eseguire il single-step di una sequenza di 100 istruzioni nop successive:```bash
$ cd app/bench
$ NUM=100 make parse # alternatively vary NUM and use STRLEN=1 or ZIGZAG=1
Il comando sopra costruisce `libsgxstep`, l'enclave vittima di benchmark e il processo host dell'attaccante non fidato, dove lo scenario di attacco e la dimensione dell'istanza sono configurati tramite le corrispondenti variabili d'ambiente. Lo stesso comando esegue anche il binario risultante in modo non interattivo (per garantire intervalli di timer deterministici) e infine chiama uno script Python di post-elaborazione specifico per l'attacco per analizzare i risultati del benchmark del puntatore alle istruzioni dell'enclave.
**Nota (prestazioni).** L'esecuzione a passo singolo (single-stepping) dell'esecuzione in enclave comporta un notevole rallentamento. Abbiamo misurato tempi di esecuzione fino a 15 minuti per gli esperimenti descritti nell'articolo. Le funzionalità di manipolazione delle tabelle delle pagine di SGX-Step consentono di avviare il single-stepping solo per funzioni selezionate, ad esempio revocando i diritti di accesso su specifiche pagine di codice o dati di interesse.
**Nota (intervallo del timer).** Il valore esatto dell'intervallo del timer dipende dalla frequenza della CPU e quindi rimane intrinsecamente specifico della piattaforma (vedere anche [app/selftest/apic](https://github.com/jovanbulck/sgx-step/blob/master/app/selftest/apic) per microbenchmark dettagliati che valutano l'accuratezza delle varie modalità del timer APIC). Configurare un valore adatto in `/app/bench/main.c`. Abbiamo stabilito intervalli di timer precisi per le nostre piattaforme di valutazione (vedere la tabella sotto) modificando e osservando i risultati della traccia del puntatore alle istruzioni dell'enclave del microbenchmark NOP, come descritto più avanti.
**Nota (stabilità).** Per evitare che il kernel Linux si blocchi o vada in panico, SGX-Step dovrebbe ripristinare automaticamente la tabella dei descrittori di interrupt e il timer APIC locale dopo l'uscita dal processo `libsgxstep`. È possibile verificare se il timer APIC sta ancora scattando su tutti i core come segue:```bash
$ watch -n0.1 "cat /proc/interrupts | grep 'Local timer interrupts'"
La tabella sottostante elenca le CPU Intel attualmente supportate, insieme al loro intervallo del timer APIC per il single-stepping (libsgxstep/config.h).
Si noti che l'intervallo esatto di single-stepping può dipendere dalla versione del microcodice del processore quando sono in atto mitigazioni recenti per attacchi a esecuzione transitoria per svuotare i buffer microarchitetturali all'ingresso/uscita dell'enclave.
Nella tabella sottostante sono forniti alcuni diversi versioni di microcodice come riferimento.
| Nome modello | CPU | Frequenza base | microcodice (data) | Intervallo 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+ |
Nota (calibrazione).
Attualmente, il modo più semplice per configurare un intervallo di timer affidabile è utilizzare lo strumento di benchmark app/bench con un lungo NOP slide e aumentare/diminuire gradualmente SGX_STEP_TIMER_INTERVAL. Probabilmente si può iniziare da circa 20 e poi eseguire NUM=100 make parse per ottenere un riepilogo di single-step, zero-step e multi-step per un NOP slide di 100 istruzioni (una volta che si ha un intervallo più o meno stabile si può passare a slide più lunghi). Troppi zero-step indicano che è necessario aumentare l'intervallo del timer, mentre multi-step richiedono di abbassare l'intervallo del timer.
Nota (filtraggio degli zero-step). Importante: non preoccuparsi se rimangono alcuni zero-step, purché si facciano progressi, è sempre possibile filtrare deterministicamente gli zero-step guardando il bit 'accessed' del PTE del codice dell'enclave (che viene impostato solo quando l'istruzione viene effettivamente completata e si è verificato un single-step). Pertanto, dopo aver configurato un intervallo di timer conservativo che esclude sempre i multi-step, SGX-Step può ottenere un single-stepping silenzioso con una granularità perfetta a livello di istruzione.
Nota (estensione della 'finestra di atterraggio' dell'interrupt).
Come chiarito nell'analisi delle cause principali qui sotto, più lento è il page table walk per risolvere l'indirizzo (del codice) della prima istruzione dell'enclave dopo ERESUME, più lunga sarà la 'finestra di atterraggio' dell'interrupt e, quindi, più affidabile sarà il tasso di single-stepping di SGX-Step. Ad esempio, abbiamo scoperto che, oltre a cancellare il bit 'accessed' del PMD dell'enclave, la finestra di atterraggio può essere ulteriormente estesa svuotando (flushing) una o più voci della tabella delle pagine non protette dalla cache della CPU prima di ERESUME, costringendo effettivamente la CPU ad attendere la memoria lenta durante la page table walk. Pertanto, quando non si riesce a trovare una configurazione affidabile dell'intervallo del timer, assicurarsi di (i) cancellare il bit 'accessed' del PTE/PMD del codice dell'enclave e (ii) svuotare (CLFLUSH) una o più voci della tabella delle pagine dell'enclave nel gestore AEP.
Nota (microcodice). Un'altra parola di cautela riguarda le recenti mitigazioni del microcodice per Foreshadow/ZombieLoad/RIDL/etc che svuotano i buffer microarchitetturali 'leaky' all'ingresso/uscita dell'enclave. Essere consapevoli che quando queste mitigazioni sono abilitate, l'intervallo del timer dovrà essere aumentato poiché l'ingresso nell'enclave richiede più tempo (ad esempio, sulla mia CPU i7-8650U ho scoperto che l'intervallo del timer per il single-step sale a 54 con microcodice recente, da solo 34 con microcodice pre-Foreshadow). Le operazioni di flushing aggiuntive possono inoltre aumentare leggermente la varianza del tempo di ingresso nell'enclave, il che implica che potrebbe essere necessario configurare il timer in modo più conservativo con più zero-step (che possono essere filtrati deterministicamente come spiegato sopra).
Un'analisi dettagliata delle cause principali di come esattamente SGX-Step riesce a interrompere in modo affidabile la prima (possibilmente molto breve!) istruzione dell'enclave dopo la notoriamente complessa istruzione ERESUME è descritta nell'articolo AEX-Notify.
Abbiamo scoperto che la chiave del successo di SGX-Step risiede nell'uso del bit 'accessed' (A). Nello specifico, SGX-Step cancella sempre il bit A nella page-middle directory (PMD) dell'enclave vittima prima di armare l'APIC per emettere un interrupt one-shot. Il bit A viene impostato dal processore solo quando almeno un'istruzione viene eseguita dall'enclave e può quindi essere utilizzato per distinguere deterministicamente tra zero-step e single-step.
Fondamentalmente, poiché il page-miss handler del processore è ottimizzato per il percorso rapido comune e utilizza un 'microcode assist' molto più lento per gestire il caso meno frequente e più complesso in cui è necessario modificare un PMD o un PTE, questo assist ha l'effetto di prolungare l'esecuzione della prima istruzione dell'enclave dopo ERESUME di diverse centinaia di cicli. Questa 'finestra di assist' apre quindi efficacemente uno spazio di atterraggio ampio per l'interrupt del timer APIC a grana grossa e normalmente distribuito, che arriva con alta precisione.
Il modo più semplice per iniziare a utilizzare il framework SGX-Step nei propri progetti è attraverso i git submodules:```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
Dai un'occhiata ai Makefile nella directory `app` per vedere come un'applicazione client può collegarsi a `libsgxstep` più eventuali pacchetti SGX SDK/PSW locali.
<a name="bottom"></a>
Di seguito è riportato un elenco di progetti noti che utilizzano SGX-Step. Sentiti libero di aprire una pull request se il tuo progetto utilizza SGX-Step ma non è incluso nella lista.
| Titolo | Dettagli della pubblicazione | Codice sorgente | Funzionalità SGX-Step utilizzate |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
| AEX-NStep: Probabilistic Interrupt Counting Attacks on Intel SGX | [S&P'26](https://arxiv.org/pdf/2510.14675) | [Zenodo](https://zenodo.org/records/17338383) | Page faults, IPIs, WRMSR Interrupt Gate |
| MDPeek: Breaking Balanced Branches in SGX with Memory Disambiguation Unit Side Channels | [ASPLOS'25](https://www.comp.nus.edu.sg/~tcarlson/pdfs/liu2025mbbbiswmdusc.pdf) | [GitHub (Artifact Evaluated & Functional)](https://github.com/CPU-THU/MDPeek) | Page faults |
| Activation Functions Considered Harmful: Recovering Neural Network Weights through Controlled Channels | [RAID'25](https://ieeexplore.ieee.org/document/11352487) | [Github Artifact](https://github.com/heavyimage/afch_paper) | Single-stepping, PTE A/D |
| TLBlur: Compiler-Assisted Automated Hardening against Controlled Channels on Off-the-Shelf Intel SGX Platforms | [USEC'25](https://vanbulck.net/files/usenix25-tlblur.pdf) | [GitHub (full)](https://github.com/TLBlur-SGX) | Single-stepping, PTE A/D, page faults |
| POSTER: On the Feasibility of Inferring SGX Execution through PMU | [AsiaCCS'24](https://dl.acm.org/doi/pdf/10.1145/3634737.3659434) | - | Single-stepping, zero-stepping|
| SIGY: Breaking Intel SGX Enclaves with Malicious Exceptions & Signals | [ArXiv'24](https://arxiv.org/abs/2404.13998) | - | Timer interrupts, page faults |
| On (the Lack of) Code Confidentiality in Trusted Execution Environments | [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: Sub-Cache-Line Leakages Strike Back | [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: Thwarting Precise Single-Stepping Attacks through Interrupt Awareness for Intel SGX Enclaves | [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
| Controlled Data Races in Enclaves: Attacks and Detection | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-chen-sanchuan.pdf) | [GitHub (non-attack)](https://github.com/OSUSecLab/SGXRacer) | Single-stepping, APIC |
| BunnyHop: Exploiting the Instruction Prefetcher | [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: Exploiting Speculative Data Gathering | [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 |
| All Your PC Are Belong to Us: Exploiting Non-control-Transfer Instruction BTB Updates for Dynamic PC Extraction | [ISCA23](https://dl.acm.org/doi/pdf/10.1145/3579371.3589100?casa_token=Q5jf5nOgiLIAAAAA:cT0ltJh7vk943buODuR4oMFKmuhg2Tp-djFm2kUu6DzlxtBhNhEw2WteRggn0k99D7ft-P6pluVrFA) | - | Single-stepping |
| Cache-timing attack against HQC | [CHES23](https://eprint.iacr.org/2023/102.pdf) | - | Single-stepping, PTE A/D |
| FaultMorse: An automated controlled-channel attack via longest recurring sequence | [ComSec23](https://www.sciencedirect.com/science/article/pii/S0167404822003959) | [GitHub (post processing)](https://github.com/Ezekiel-1998/FaultMorse) | Page fault |
| AEPIC Leak: Architecturally Leaking Uninitialized Data from the Microarchitecture | [USEC22](https://www.usenix.org/system/files/sec22-borrello.pdf) | [GitHub (full)](https://github.com/IAIK/AEPIC) | Single-Stepping, PTE A/D |
| MoLE: Mitigation of Side-channel Attacks against SGX via Dynamic Data Location Escape | [ACSAC22](https://dl.acm.org/doi/fullHtml/10.1145/3564625.3568002) | - | Single-Stepping, page fault, transient execution |
| WIP: Interrupt Attack on TEE-Protected Robotic Vehicles | [AutoSec22](https://www.ndss-symposium.org/wp-content/uploads/autosec2022_23001_paper.pdf) | - | Single-stepping, multi-stepping |
| Towards Self-monitoring Enclaves: Side-Channel Detection Using Performance Counters | [NordSec22](https://link.springer.com/chapter/10.1007/978-3-031-22295-5_7) | - | Page fault, LVI. |
| ENCLYZER: Automated Analysis of Transient Data Leaks on Intel SGX | [SEED22](https://ieeexplore.ieee.org/document/9935016) | [GitHub (full)](https://github.com/bloaryth/enclyser) | Page-table manipulation |
| Side-Channeling the Kalyna Key Expansion | [CT-RSA22](https://cs.adelaide.edu.au/~yval/pdfs/ChuengsatiansupGYZ22.pdf) | - | Single-Stepping, PTE A/D |
| Rapid Prototyping for Microarchitectural Attacks | [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: Exploiting Key Decoding in Cryptographic Libraries | [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: Smashing SGX Enclaves Using Exceptions | [CCS21](https://dl.acm.org/doi/pdf/10.1145/3460120.3484821) | - | Single-Stepping |
| Online Template Attacks: Revisited | [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 |
| Aion Attacks: Manipulating Software Timers in Trusted Execution Environment | [DIMVA21](http://individual.utoronto.ca/shengjiexu/publication/whuang-dimva2021-aion_v2.pdf) | - | Single-stepping, interrupts(?) |
| Platypus: Software-based Power Side-Channel Attacks on x86 | [S&P21](https://platypusattack.com/platypus.pdf) | [GitHub (simulated PoC)](https://github.com/0xhilbert/Platypus) | Single-stepping, zero-stepping |
| CrossTalk: Speculative Data Leaks Across Cores Are Real | [S&P21](https://download.vusec.net/papers/crosstalk_sp21.pdf) | - | Single-stepping, page fault |
| Frontal Attack: Leaking Control-Flow in SGX via the CPU Frontend | [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: Cross-User-Kernel-Boundary Rowhammer through Implicit Accesses | - | [MICRO20](https://arxiv.org/pdf/2007.08707v2.pdf) | Page table walk |
| SpeechMiner: A Framework for Investigating andMeasuring Speculative Execution Vulnerabilities | [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: Side-Channel Analysis of Mozilla's NSS | [CCS20](https://dl.acm.org/doi/pdf/10.1145/3372297.3421761) | - | Page fault |
| From A to Z: Projective coordinates leakage in the wild | [CHES20](https://eprint.iacr.org/2020/432.pdf) | - | Page fault |
| LVI: Hijacking Transient Execution through Microarchitectural Load Value Injection | [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: Controlled Instruction-Level Attacks on Enclaves | [USEC20](https://arxiv.org/pdf/2002.08437.pdf) | - | Single-stepping, page fault, PTE A/D |
| When one vulnerable primitive turns viral: Novel single-trace attacks on ECDSA and RSA | [CHES20](https://eprint.iacr.org/2020/055.pdf) | - | Single-stepping, page fault, PTE A/D |
| Big Numbers - Big Troubles: Systematically Analyzing Nonce Leakage in (EC)DSA Implementations | [USEC20](https://www.usenix.org/system/files/sec20summer_weiser_prepub_0.pdf) | - | Page fault |
| Plundervolt: Software-based Fault Injection Attacks against Intel SGX | [S&P20](https://plundervolt.com/doc/plundervolt.pdf) | [GitHub (full)](https://github.com/KitMurdock/plundervolt) | Privileged interrupt/call gates, MSR |
| Bluethunder: A 2-level Directional Predictor Based Side-Channel Attack against SGX | [CHES20](https://heartever.github.io/files/bluethunder_sgx_ches.pdf) | - | Single-stepping |
| Fallout: Leaking Data on Meltdown-resistant CPUs | [CCS19](https://mdsattacks.com/files/fallout.pdf) | - | PTE A/D |
| A Tale of Two Worlds: Assessing the Vulnerability of Enclave Shielding Runtimes | [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: Cross-Privilege-Boundary Data Sampling | [CCS19](https://zombieloadattack.com/zombieload.pdf) | [GitHub (PoC)](https://github.com/IAIK/ZombieLoad/) | Single-stepping, zero-stepping, page-table manipulation |
| SPOILER: Speculative Load Hazards Boost Rowhammer and Cache Attacks | [USEC19](https://arxiv.org/pdf/1903.00446.pdf) | - | Single-stepping interrupt latency |
| Nemesis: Studying Microarchitectural Timing Leaks in Rudimentary CPU Interrupt Logic | [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: Extracting the Keys to the Intel SGX Kingdom with Transient Out-of-Order Execution | [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 |
| Single Trace Attack Against RSA Key Generation in Intel SGX SSL | [AsiaCCS18](https://rspreitzer.github.io/publications/proc/asiaccs-2018-paper-1.pdf) | - | Page fault |
| Off-Limits: Abusing Legacy x86 Memory Segmentation to Spy on Enclaved Execution | [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: A Practical Attack Framework for Precise Enclave Execution Control | [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 |