jovanbulck/sgx-stepEin praktisches Angriffsframework für präzise Steuerung der Enklavenausführung
SGX-Step ist ein Open-Source-Framework, das die Forschung zu Seitenkanalangriffen auf Intel x86-Prozessoren im Allgemeinen und Intel SGX-Plattformen im Besonderen erleichtert. SGX-Step besteht aus einem adversarialen Linux-Kernel-Treiber und einer kleinen User-Space-Betriebssystembibliothek, die es ermöglicht, nicht vertrauenswürdige Seitentabelleneinträge und/oder x86-APIC-Timer-Interrupts vollständig aus dem Benutzerraum zu konfigurieren. SGX-Step wurde sowohl in unserer eigenen Forschung als auch von unabhängigen Forschern genutzt, um mehrere neue und verbesserte Enclave-Ausführungsangriffe zu ermöglichen, die Seitenkanalbeobachtungen mit maximaler zeitlicher Auflösung sammeln (d.h. durch Unterbrechung der Opfer-Enclave nach jeder einzelnen Anweisung).
Lizenz. SGX-Step ist freie Software, lizenziert unter GPLv3. Das SGX-Step-Logo ist abgeleitet von Eadweard Muybridges ikonischer Public-Domain Fotoserie "Sallie Gardner at a Gallop", die, ähnlich wie unser Ziel des Enclave Single-Steppings, die Dynamik eines galoppierenden Pferdes in eine Reihe einzelner Frames zerlegt, um die Gesamtbewegungsabläufe des Pferdes sichtbar zu machen.
| SGX-Step release | Changelog features |
|---|---|
| v1.5.0 | Stabilisierungs-Fixes (KPTI, Kernel-ISR-Mapping); (experimenteller) Gramine-Port; IPI-Unterstützung. |
| v1.4.0 | Privilegierte Interrupt-/Call-Gates (Plundervolt). |
| v1.3.0 | Unterstützung für transiente Ausführung (Foreshadow). |
| v1.2.0 | User-Space-Interrupt-Handling und deterministisches Zero-Step-Filtering (Nemesis). |
| v1.1.0 | IA32-Unterstützung. |
| v1.0.0 | User-Space-Seitentabellenmanipulation und APIC-Timer-Single-Stepping. |
Publikationen. SGX-Step wurde von mehreren unabhängigen Forschergruppen eingesetzt und hat eine neue Reihe hochauflösender SGX-Angriffe ermöglicht. Eine vollständige aktuelle Liste bekannter Projekte, die SGX-Step verwenden, befindet sich am Ende dieser README. Eine Kopie des Originalpapiers ist hier verfügbar.``` @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.** Das Verzeichnis [app/memcmp](https://github.com/jovanbulck/sgx-step/blob/master/app/memcmp) enthält eine kleine Demo-Anwendung, die die Leistungsfähigkeit von SGX-Step-Angriffen demonstriert, indem sie eine Beispiel-Enclave schrittweise ausführt, die eine subtile, nicht-konstantzeitliche `memcmp`-Passwortvergleichslogik enthält. Im Gegensatz zu traditionellen, bekanntermaßen verrauschten Timing-Angriffen kann SGX-Step das Passwort deterministisch Zeichen für Zeichen in _linearer_ Zeit erraten:
## Übersicht
Entscheidend für das Design von SGX-Step, im Gegensatz zu früheren Vorschlägen zur Enclave-Präemption, ist die Erstellung von Userspace-Virtual-Memory-Mappings für physische Speicherorte, die Seitentabelleneinträge enthalten, sowie für die lokalen APIC-Memory-Mapped-I/O-Konfigurationsregister und die x86 Interrupt Descriptor Table (IDT). Dies erlaubt einem nicht vertrauenswürdigen, angreiferkontrollierten Host-Prozess, einfach (i) Enclave-Seitentabelleneinträge zu verfolgen oder zu modifizieren, (ii) die APIC-Timer-Interruptquelle (Einmal-/Periodisch) zu konfigurieren, (iii) Inter-Processor-Interrupts auszulösen und (iv) benutzerdefinierte Interrupt-Handler vollständig _innerhalb_ des Userspace zu registrieren.
Die obige Abbildung fasst die Abfolge der Hardware- und Softwareschritte beim Interrupt und der Wiederaufnahme einer SGX-Enclave durch unser Framework zusammen.
1. Der lokale APIC-Timer-Interrupt trifft innerhalb einer Enclaved-Instruktion ein.
2. Der Prozessor führt die AEX-Prozedur aus, die den Ausführungskontext sicher im SSA-Frame der Enclave speichert, CPU-Register initialisiert und zum (Userspace-)Interrupt-Handler im IDT vektorisiert.
3. An diesem Punkt kann jeder angriffsspezifische Spy-Code einfach eingefügt werden.
4. Die Bibliothek kehrt zum Userspace-AEP-Trampolin zurück. Wir haben die nicht vertrauenswürdige Runtime des offiziellen SGX SDK modifiziert, um eine einfache Registrierung eines benutzerdefinierten AEP-Stubs zu ermöglichen. Darüber hinaus kann SGX-Step _optional_ instrumentiert werden, um den gespeicherten Befehlszeiger aus dem SSA-Frame der unterbrochenen Enclave abzurufen (unter Verwendung des Linux-`/proc/self/mem`-Interfaces und der `EDBGRD`-Instruktion), um eine präzise Evaluierung unseres Ansatzes auf angreiferkontrollierten Benchmark-Debug-Enclaves zu ermöglichen.
5. Danach konfigurieren wir den lokalen APIC-Timer für den nächsten Interrupt, indem wir in das Initial-Count-Memory-Mapped-I/O-Register schreiben, direkt bevor wir (6) `ERESUME` ausführen.
## Quellcode-Übersicht
Dieses Repository ist wie folgt organisiert:```
.
├── 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 ist ein universelles Ausführungskontroll-Framework, das die präzise Verschachtelung von Enklaven-Befehlen des Opfers mit beliebigem Angreifercode ermöglicht. Einige der Hauptanwendungsfälle des SGX-Step-Frameworks sind in der folgenden Abbildung zusammengefasst (siehe auch das Ende dieser README für eine aktuelle Liste der Publikationen, die SGX-Step verwenden).
SGX-Step benötigt einen SGX-fähigen Intel-Prozessor und einen handelsüblichen Linux-Kernel. Unsere ursprüngliche Bewertung wurde auf i7-6500U/6700 CPUs unter Ubuntu 18.04 mit einem Standard-Linux-4.15.0-Kernel durchgeführt. Neuere Linux-Kernel und Distributionen werden ebenfalls unterstützt. Wir fassen die Kernelparameter von Linux unten zusammen.
| Linux-Kernelparameter | Motivation |
|---|---|
nox2apic | Optional: Lokales APIC-Gerät im memory-mapped I/O-Modus konfigurieren (um die präzisen Single-Stepping-Funktionen von SGX-Step zu nutzen). Falls gesetzt, stellen Sie sicher, dass X2APIC in libsgxstep/config.h auf 0 gesetzt ist. Alternativ können Sie die CPU im x2APIC-Modus belassen, und neuere SGX-Step-Distributionen sollten ebenfalls kompatibel sein. |
iomem=relaxed no_timer_check | Unnötige Warnmeldungen in den Kernel-Logs unterdrücken. |
nmi_watchdog=0 | Den NMI-Watchdog des Kernels unterdrücken. |
isolcpus=1 | Den Opferprozess auf einen isolierten CPU-Kern festlegen. |
clearcpuid=308,295,514 | Supervisor-Mode Access Prevention (SMAP, Bit 295), Supervisor-Mode Execution Prevention (SMEP, Bit 308) und User-Mode Instruction Prevention (UMIP, Bit 514) deaktivieren. |
pti=off | Kernel Page-Table Isolation deaktivieren (um Kernel-Paniken mit Benutzer-IRQ-Handlern zu vermeiden). |
rcupdate.rcu_cpu_stall_suppress=1 | Den Read-Copy-Update (RCU) CPU-Stall-Detektor des Kernels deaktivieren (um Warnungen zu vermeiden, wenn längere Zeit ohne Aufruf des Timer-Interrupt-Handlers des Kernels ein Einzelschritt ausgeführt wird.) |
msr.allow_writes=on | Kernel-Warnmeldungen für Schreibvorgänge in modellspezifische Register (MSR) durch SGX-Step unterdrücken. |
vdso=0 | Nur bei neueren Linux-Kernels: vdso_sgx_enter_enclave-Bibliothek deaktivieren (nicht kompatibel mit AEP-Interception-Patches). |
dis_ucode_ldr | Optional: CPU-Mikrocode-Updates deaktivieren (aktuelle Schutzmaßnahmen gegen transiente Ausführungsangriffe können eine Neukalibrierung des Single-Stepping-Intervalls erforderlich machen). |
Übergeben Sie die gewünschten Boot-Parameter wie folgt an den Kernel:```bash
$ sudo vim /etc/default/grub
$ sudo update-grub && reboot
Um zu überprüfen, ob der aktuell laufende Kernel korrekt konfiguriert ist, führen Sie Folgendes aus:```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]
Schließlich können Sie optional C-States und SpeedStep-Technologie im BIOS deaktivieren, um die Stabilität der Ausführungszeit insgesamt zu verbessern.
/dev/sgx-stepSGX-Step enthält ein ladbares Kernelmodul, das eine IOCTL-Schnittstelle für die libsgxstep-Bibliothek im Userspace bereitstellt. Der Treiber ist hauptsächlich für (i) das Hooking des APIC-Timer-Interrupt-Handlers, (ii) das Sammeln nicht vertrauenswürdiger Seitentabellen-Abbildungen und optional (iii) das Abrufen des unterbrochenen Befehlszeigers für Benchmark-Enklaven verantwortlich.
Um den Treiber /dev/sgx-step zu bauen und zu laden, führen Sie Folgendes aus:```bash
$ cd kernel/
$ ./install_SGX_driver.sh # tested on Ubuntu 20.04/22.04
$ make clean load
**Note (/dev/sgx_enclave).** SGX-Step unterstützt sowohl den alten Intel `/dev/isgx` Out-of-Tree-Treiber, der auf allen Plattformen funktionieren sollte, als auch den Upstream-`/dev/sgx_enclave`-Treiber für Plattformen mit neueren Linux-Kerneln >5.11 sowie Hardwareunterstützung für Flexible-Launch-Control. Das Skript `install_SGX_driver.sh` erkennt automatisch, ob ein im Baum befindlicher `/dev/sgx_enclave`-Treiber verfügbar ist, und falls nicht, baut und lädt den Out-of-Tree-`/dev/isgx`-Treiber über das Git-Submodul, das auf einen unmodifizierten v2.14 [linux-sgx-driver](https://github.com/intel/linux-sgx-driver) verweist.
**Note (/dev/mem).** Wir verlassen uns auf das virtuelle Gerät `/dev/mem` von Linux, um benutzerebene virtuelle Speicherabbildungen für APIC-physikalische Speicher-abgebildete I/O-Register und relevante Seitentabelleneinträge zu erstellen. Aktuelle Linux-Distributionen aktivieren jedoch typischerweise die Option `CONFIG_STRICT_DEVMEM`, die eine solche Nutzung verhindert. Unser Treiber `/dev/sgx-step` enthält daher einen [Ansatz](https://www.libcrack.so/index.php/2012/09/02/bypassing-devmem_is_allowed-with-kprobes/), um die `devmem_is_allowed`-Prüfungen zu umgehen, ohne den Kernel neu kompilieren zu müssen.
### 2. Patchen und Installieren des SGX SDK
Um eine einfache Registrierung eines benutzerdefinierten Asynchronous Exit Pointer (AEP)-Stubs zu ermöglichen, haben wir die Laufzeitumgebung (untrusted runtime) des offiziellen Intel SGX SDK modifiziert. Gehen Sie wie folgt vor, um [linux-sgx](https://github.com/01org/linux-sgx) v2.29 auszuchecken und unsere Patches anzuwenden.```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
Die obigen Installationsskripte wurden unter Ubuntu 22.04 LTS getestet. Für andere GNU/Linux-Distributionen folgen Sie bitte den Anweisungen im linux-sgx-Projekt, um die Intel SGX SDK und PSW-Pakete zu erstellen und zu installieren. Sie müssen außerdem ein (unverändertes) linux-sgx-driver SGX-Kernelmodul erstellen und laden, um SGX-Step nutzen zu können.
Hinweis (lokale Installation). Die gepatchten SGX SDK und PSW-Pakete können
lokal installiert werden, ohne eine kompatible systemweite 'linux-sgx'-Installation zu beeinträchtigen.
Hierfür unterstützen die Beispiel-Makefiles eine Umgebungsvariable SGX_SDK,
die auf das lokale SDK-Installationsverzeichnis verweist. Wenn
ein nicht-standardmäßiger SDK-Pfad erkannt wird (d. h. nicht /opt/intel/sgxsdk), verlinken die "run"-Makefile-Ziele darüber hinaus dynamisch gegen die gepatchte, nicht vertrauenswürdige Laufzeitbibliothek libsgx_urts.so, die im lokalen linux-sgx-Verzeichnis erstellt wurde (unter Verwendung der Umgebungsvariablen LD_LIBRARY_PATH).
Hinweis (32-Bit-Unterstützung). Anleitungen (veraltet und nicht gewartet!) zur Erstellung von 32-Bit-Versionen des SGX SDK und von SGX-Step finden Sie in README-m32.md.
Anwendungen im Benutzerbereich können eine Verbindung zur libsgxstep-Bibliothek herstellen, um die Single-Stepping- und Seitentabellenmanipulationsfunktionen von SGX-Step zu nutzen. Werfen Sie einen Blick auf die Beispielanwendungen im Verzeichnis "app".
Überprüfen Sie zunächst die APIC- und Interrupt-Deskriptor-Tabelleneinrichtung:```bash $ cd app/selftest/idt $ make run # fires interrupts in an infinite loop to stress-test stability; exit with CTRL-C
Zum Beispiel, um eine elementare Beispielanwendung zu erstellen und auszuführen, um Funktionen zur Seitentabellenmanipulation und SDK patches zu testen:```bash
$ cd app/aep-redirect
$ make run
Um die Timer-Einzelschritt-Funktionalität zu testen, versuchen Sie beispielsweise, eine Benchmark-Enklave zu erstellen und auszuführen, um einen Durchlauf von 100 aufeinanderfolgenden nop-Anweisungen im Einzelschritt zu durchlaufen:```bash
$ cd app/bench
$ NUM=100 make parse # alternatively vary NUM and use STRLEN=1 or ZIGZAG=1
Der obige Befehl erstellt `libsgxstep`, die Benchmark-Opfer-Enklave und den nicht vertrauenswürdigen Angreifer-Hostprozess, wobei das Angriffsszenario und die Instanzgröße über die entsprechenden Umgebungsvariablen konfiguriert werden. Der gleiche Befehl führt auch das resultierende Binärprogramm nicht-interaktiv aus (um deterministische Timer-Intervalle sicherzustellen) und ruft schließlich ein angriffsspezifisches Python-Skript zur Nachbearbeitung auf, um die resultierenden Enklaven-Befehlszeiger-Benchmark-Ergebnisse zu analysieren.
**Hinweis (Leistung).** Das Single-Stepping der Enklavenausführung verursacht eine erhebliche Verlangsamung. Wir haben für die im Papier beschriebenen Experimente Ausführungszeiten von bis zu 15 Minuten gemessen. Die Seitentabellen-Manipulationsfunktionen von SGX-Step ermöglichen es, Single-Stepping nur für ausgewählte Funktionen zu initiieren, beispielsweise durch Widerruf der Zugriffsrechte auf bestimmte Code- oder Datenseiten von Interesse.
**Hinweis (Timer-Intervall).** Der genaue Timer-Intervallwert hängt von der CPU-Frequenz ab und bleibt daher inhärent plattformspezifisch (siehe auch [app/selftest/apic](https://github.com/jovanbulck/sgx-step/blob/master/app/selftest/apic) für detaillierte Mikrobenchmarks zur Bewertung der Genauigkeit verschiedener APIC-Timer-Modi). Konfigurieren Sie einen geeigneten Wert in `/app/bench/main.c`. Wir haben für unsere Evaluierungsplattformen (siehe Tabelle unten) präzise Timer-Intervalle ermittelt, indem wir die NOP-Mikrobenchmark-Enklaven-Befehlszeiger-Trace-Ergebnisse angepasst und beobachtet haben, wie weiter unten beschrieben.
**Hinweis (Stabilität).** Um zu vermeiden, dass der Linux-Kernel hängt oder abstürzt, sollte SGX-Step nach dem Beenden des `libsgxstep`-Prozesses automatisch die Interrupt-Deskriptor-Tabelle und den lokalen APIC-Timer wiederherstellen. Sie können überprüfen, ob der APIC-Timer auf allen Kernen noch feuert, wie folgt:
```bash
$ watch -n1 'cat /proc/interrupts | grep -e APIC -e LOC -e ERR -e NMI'
``````bash
$ watch -n0.1 "cat /proc/interrupts | grep 'Local timer interrupts'"
Die folgende Tabelle listet aktuell unterstützte Intel-CPUs zusammen mit ihrem Single-Stepping-APIC-Timer-Intervall (libsgxstep/config.h) auf. Beachten Sie, dass das genaue Single-Stepping-Intervall von der Mikrocode-Version des Prozessors abhängen kann, wenn aktuelle Transient-Execution-Angriffs-Minderungsmaßnahmen vorhanden sind, die mikroarchitektonische Puffer beim Enclave-Eintritt/-Austritt leeren. Einige verschiedene Mikrocode-Versionen werden in der folgenden Tabelle als Referenz angegeben.
| Modellname | CPU | Basisfrequenz | µcode (Datum) | APIC-Timer-Intervall |
|---|---|---|---|---|
| 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+ |
Hinweis (Kalibrierung).
Derzeit besteht der einfachste Weg, ein zuverlässiges Timer-Intervall zu konfigurieren, darin, das Benchmarking-Tool app/bench mit einer langen NOP-Rutsche zu verwenden und SGX_STEP_TIMER_INTERVAL schrittweise zu erhöhen/verringern. Sie können wahrscheinlich bei etwa 20 starten und dann NUM=100 make parse ausführen, um eine Zusammenfassung der Einzelschritte, Nullschritte und Mehrfachschritte für eine NOP-Rutsche von 100 Anweisungen zu erhalten (sobald Sie ein mehr oder weniger stabiles Intervall haben, können Sie zu längeren Rutschen wechseln). Zu viele Nullschritte deuten darauf hin, dass Sie das Timer-Intervall erhöhen müssen, während Mehrfachschritte ein Verringern des Timer-Intervalls erfordern.
Hinweis (Herausfiltern von Null-Schritten). Wichtig: Machen Sie sich keine Sorgen, wenn noch einige Nullschritte übrig sind. Solange Sie Fortschritte erzielen, können Sie Nullschritte immer deterministisch herausfiltern, indem Sie das PTE-Zugriffs-Bit des Enclave-Codes betrachten (das nur gesetzt wird, wenn die Anweisung tatsächlich ausgeführt wird und ein Einzelschritt erfolgt ist). Nachdem Sie also ein konservatives Timer-Intervall konfiguriert haben, das Mehrfachschritte immer ausschließt, kann SGX-Step ein rauschfreies Single-Stepping mit perfekter Granularität auf Befehlsebene erreichen.
Hinweis (Erweiterung des Interrupt-„Landefensters“).
Wie in der folgenden Grundursachenanalyse klargestellt wird, gilt: Je langsamer der Page-Table-Walk zur Auflösung der (Code-)Adresse des ersten Enclave-Befehls nach ERESUME ist, desto länger ist das Interrupt-„Landefenster“ und desto zuverlässiger ist die Single-Stepping-Rate von SGX-Step. Wir haben zum Beispiel festgestellt, dass das Landefenster zusätzlich zum Löschen des PMD-Zugriffs-Bits der Enclave noch weiter verlängert werden kann, indem ein oder mehrere ungeschützte Page-Table-Einträge vor ERESUME aus dem CPU-Cache geflusht werden, wodurch die CPU gezwungen wird, während des Page-Table-Walks auf langsamen Speicher zu warten. Wenn Sie also keine zuverlässige Timer-Intervall-Konfiguration finden, stellen Sie sicher, dass Sie (i) das „accessed“-Bit des Enclave-Code-PTE/PMD löschen und (ii) einen oder mehrere Enclave-Page-Table-Einträge im AEP-Handler flushen (CLFLUSH).
Hinweis (Mikrocode). Eine weitere Vorsichtsmaßnahme betrifft aktuelle Foreshadow/ZombieLoad/RIDL/etc.-Mikrocode-Minderungen, die undichte µarch-Puffer beim Enclave-Eintritt/-Austritt leeren. Beachten Sie, dass das Timer-Intervall erhöht werden muss, wenn diese Minderungen aktiviert sind, da der Enclave-Eintritt länger dauert (z. B. habe ich auf meiner i7-8650U-CPU festgestellt, dass das Single-Step-Timer-Intervall bei neuem Mikrocode auf 54 ansteigt, gegenüber nur 34 mit Pre-Foreshadow-Mikrocode). Die zusätzlichen Flush-Operationen können außerdem die Varianz der Enclave-Eintrittszeit etwas erhöhen, was bedeutet, dass Sie den Timer möglicherweise konservativer konfigurieren müssen, mit mehr Nullschritten (die deterministisch herausgefiltert werden können, wie oben erläutert).
Eine detaillierte Grundursachenanalyse, wie genau SGX-Step es schafft, die erste (möglicherweise sehr kurze!) Enclave-Anweisung nach dem bekanntermaßen komplexen ERESUME-Befehl zuverlässig zu unterbrechen, wird im Paper AEX-Notify beschrieben. Wir haben festgestellt, dass der Schlüssel zum Erfolg von SGX-Step in der Verwendung des „accessed“-Bits (A-Bit) liegt. Insbesondere löscht SGX-Step immer das A-Bit im Page-Middle-Directory (PMD) der Opfer-Enclave, bevor der APIC scharfgeschaltet wird, um einen One-Shot-Interrupt auszulösen. Das A-Bit wird nur dann vom Prozessor gesetzt, wenn mindestens eine Anweisung von der Enclave ausgeführt wird, und kann daher verwendet werden, um deterministisch zwischen Nullschritten und Einzelschritten zu unterscheiden.
Entscheidend ist, dass der Page-Miss-Handler des Prozessors auf den gemeinsamen schnellen Pfad optimiert ist und einen viel langsameren „Mikrocode-Assist“ verwendet, um den selteneren und komplexeren Fall zu behandeln, bei dem ein PMD oder PTE geändert werden muss. Dieser Assist hat die Wirkung, die Ausführung der ersten Enclave-Anweisung nach ERESUME um mehrere hundert Zyklen zu verlängern. Dieses „Assist-Fenster“ eröffnet somit effektiv einen großzügigen Landeplatz für den grobkörnigen, normalverteilten APIC-Timer-Interrupt, der mit hoher Genauigkeit eintrifft.
Der einfachste Einstieg in die Nutzung des SGX-Step-Frameworks in eigenen Projekten erfolgt über 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
Schauen Sie sich die Makefiles im `app`-Verzeichnis an, um zu sehen, wie eine Client-Anwendung eine Verknüpfung zu `libsgxstep` plus beliebigen lokalen SGX SDK/PSW-Paketen herstellen kann.
<a name="bottom"></a>
Im Folgenden finden Sie eine Liste bekannter Projekte, die SGX-Step verwenden. Erstellen Sie gerne einen Pull-Request, wenn Ihr Projekt SGX-Step verwendet, aber nicht unten aufgeführt ist.
| Titel | Publikationsdetails | Quellcode | Verwendete SGX-Step-Features |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
| 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 |