jovanbulck/sgx-stepUn marco de ataque práctico para el control preciso de la ejecución en enclave.
SGX-Step es un marco de trabajo de código abierto para facilitar la investigación de ataques de canal lateral en procesadores Intel x86 en general y en plataformas Intel SGX en particular. SGX-Step consiste en un controlador del kernel de Linux adversarial y una pequeña biblioteca de sistema operativo en espacio de usuario que permite configurar entradas de tabla de páginas no confiables y/o interrupciones del temporizador APIC x86 completamente desde el espacio de usuario. SGX-Step se ha utilizado en nuestra propia investigación, así como por investigadores independientes, para habilitar varios ataques de ejecución de enclave nuevos y mejorados que recopilan observaciones de canal lateral con una resolución temporal máxima (es decir, interrumpiendo el enclave víctima después de cada instrucción individual).
Licencia. SGX-Step es software libre, licenciado bajo GPLv3. El logotipo de SGX-Step se deriva de la icónica serie de fotografías de dominio público "Sallie Gardner at a Gallop" de Eadweard Muybridge, la cual, al igual que nuestro objetivo de ejecución paso a paso del enclave, descompone la dinámica del galope del caballo en una serie de fotogramas individuales para revelar las propiedades generales de la marcha equina.
| Versión de SGX-Step | Características del changelog |
|---|---|
| v1.5.0 | Correcciones de estabilización (KPTI, mapeo ISR del kernel); puerto Gramine (experimental); soporte IPI. |
| v1.4.0 | Puertas de interrupción/llamada privilegiadas (Plundervolt). |
| v1.3.0 | Soporte de ejecución transitoria (Foreshadow). |
| v1.2.0 | Manejo de interrupciones en espacio de usuario y filtrado determinista de paso cero (Nemesis). |
| v1.1.0 | Soporte IA32. |
| v1.0.0 | Manipulación de tabla de páginas en espacio de usuario y ejecución paso a paso del temporizador APIC. |
Publicaciones. SGX-Step ha sido empleado por varios grupos de investigación independientes y ha permitido una nueva línea de ataques SGX de alta resolución. Se incluye una lista completa actualizada de proyectos conocidos que utilizan SGX-Step al final de este README. Una copia del artículo original está disponible aquí.``` @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.** El directorio [app/memcmp](https://github.com/jovanbulck/sgx-step/blob/master/app/memcmp) contiene una pequeña aplicación demo que
ilustra el poder de los ataques con SGX-Step al ejecutar paso a paso un enclave de ejemplo
que contiene una lógica de comparación de contraseñas `memcmp` sutil y no constante en tiempo.
A diferencia de los ataques de temporización tradicionales, notoriamente ruidosos, SGX-Step puede
determinísticamente forzar la contraseña carácter por carácter en tiempo _lineal_:
## Visión general
Crucial para el diseño de SGX-Step, a diferencia de propuestas anteriores de desalojo de enclaves,
es la creación de mapas de memoria virtual en espacio de usuario para ubicaciones de memoria física que
contienen entradas de tabla de páginas, así como para los registros de configuración de E/S mapeada en
memoria del APIC local y la Tabla de Descriptores de Interrupciones (IDT) de x86. Esto permite que un
proceso anfitrión no confiable y controlado por el atacante pueda fácilmente (i) rastrear o modificar
las entradas de tabla de páginas del enclave, (ii) configurar la fuente de interrupción del temporizador
del APIC local en modo de un solo disparo/periódico, (iii) disparar interrupciones entre procesadores,
y (iv) registrar manejadores de interrupción personalizados completamente _dentro_ del espacio de usuario.
La figura anterior resume la secuencia de pasos hardware y software al interrumpir y reanudar un enclave
SGX a través de nuestro marco de trabajo.
1. La interrupción del temporizador del APIC local llega dentro de una instrucción enclavada.
2. El procesador ejecuta el procedimiento AEX que almacena de forma segura el contexto de ejecución
en el marco SSA del enclave, inicializa los registros de la CPU y redirige al manejador de interrupción
(en espacio de usuario) registrado en la IDT.
3. En este punto, cualquier código espía específico del ataque puede conectarse fácilmente.
4. La biblioteca regresa al trampolín AEP en espacio de usuario. Modificamos el entorno de ejecución
no confiable del SDK SGX oficial para permitir el registro sencillo de un stub AEP personalizado.
Además, para permitir una evaluación precisa de nuestro enfoque en enclaves de depuración de referencia
controlados por el atacante, SGX-Step puede _opcionalmente_ ser instrumentado para recuperar el puntero
de instrucción almacenado del marco SSA del enclave interrumpido (usando la interfaz `/proc/self/mem`
de Linux y la instrucción `EDBGRD`).
5. A continuación, configuramos el temporizador del APIC local para la siguiente interrupción escribiendo
en el registro de E/S mapeado en memoria de conteo inicial, justo antes de ejecutar (6) `ERESUME`.
## Resumen del código fuente
Este repositorio está organizado de la siguiente manera:```
.
├── 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 es un marco de control de ejecución universal que permite la intercalación precisa de instrucciones del enclave víctima con código atacante arbitrario. Algunos de los principales casos de uso del framework SGX-Step se resumen en la siguiente figura (consulte también la parte inferior de este README para obtener una lista actualizada de publicaciones que utilizan SGX-Step).
SGX-Step requiere un procesador Intel compatible con SGX y un kernel Linux estándar. Nuestra evaluación original se realizó en CPU i7-6500U/6700, ejecutando Ubuntu 18.04 con un kernel Linux 4.15.0 estándar. También se admiten kernels y distribuciones de Linux más recientes. A continuación resumimos los parámetros del kernel de Linux.
| Parámetro del kernel de Linux | Motivación |
|---|---|
nox2apic | Opcionalmente, configure el dispositivo APIC local en modo de E/S mapeado en memoria (para aprovechar las características de ejecución paso a paso precisa de SGX-Step). Si se establece, asegúrese de configurar X2APIC en 0 en libsgxstep/config.h. Alternativamente, puede dejar la CPU en modo x2APIC y las distribuciones recientes de SGX-Step también deberían ser compatibles. |
iomem=relaxed no_timer_check | Eliminar mensajes de advertencia innecesarios en los registros del kernel. |
nmi_watchdog=0 | Desactivar el watchdog NMI del kernel. |
isolcpus=1 | Afianzar el proceso víctima a un núcleo de CPU aislado. |
clearcpuid=308,295,514 | Deshabilitar las funciones de prevención de acceso en modo supervisor (SMAP, bits 295), prevención de ejecución en modo supervisor (SMEP, bits 308) y prevención de instrucciones en modo usuario (UMIP, bits 514). |
pti=off | Deshabilitar el aislamiento de la tabla de páginas del kernel (para evitar pánicos del kernel con los controladores de IRQ de usuario). |
rcupdate.rcu_cpu_stall_suppress=1 | Deshabilitar el detector de estancamiento de CPU de actualización de lectura-copia (RCU) del kernel (para evitar advertencias al ejecutar paso a paso durante mucho tiempo sin llamar al controlador de interrupción del temporizador del kernel). |
msr.allow_writes=on | Eliminar mensajes de advertencia del kernel por escrituras de registros específicos del modelo (MSR) realizadas por SGX-Step. |
vdso=0 | Solo en kernels de Linux recientes: deshabilitar la biblioteca vdso_sgx_enter_enclave (no compatible con parches de interceptación AEP). |
dis_ucode_ldr | Opcionalmente, deshabilitar las actualizaciones de microcódigo de la CPU (las mitigaciones recientes de ataques de ejecución transitoria pueden requerir recalibrar el intervalo de ejecución paso a paso). |
Pase los parámetros de arranque deseados al kernel de la siguiente manera:```bash
$ sudo vim /etc/default/grub
$ sudo update-grub && reboot
Para verificar que el kernel en ejecución actual está configurado correctamente, ejecute:```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]
Finalmente, para mejorar la estabilidad general del tiempo de ejecución, puede optar por deshabilitar adicionalmente los C-States y la tecnología SpeedStep en la configuración de la BIOS.
/dev/sgx-stepSGX-Step viene con un módulo de kernel cargable que exporta una interfaz IOCTL a la biblioteca de espacio de usuario libsgxstep. El controlador es principalmente responsable de (i) enganchar el manejador de interrupciones del temporizador APIC, (ii) recopilar asignaciones de tabla de páginas no confiables, y opcionalmente (iii) obtener el puntero de instrucción interrumpida para enclaves de referencia.
Para construir y cargar el controlador /dev/sgx-step, ejecute:```bash
$ cd kernel/
$ ./install_SGX_driver.sh # tested on Ubuntu 20.04/22.04
$ make clean load
**Nota (/dev/sgx_enclave).** SGX-Step soporta tanto el controlador legacy `/dev/isgx` fuera del árbol que debería funcionar en todas las plataformas, así como el controlador principal `/dev/sgx_enclave` para plataformas con kernels Linux recientes >5.11 y soporte de hardware para control de lanzamiento flexible. El script `install_SGX_driver.sh` debería detectar automáticamente si un controlador en el árbol `/dev/sgx_enclave` está disponible, y, si no, construir y cargar el controlador fuera del árbol `/dev/isgx` mediante el submódulo git que apunta a una versión sin modificar v2.14 [linux-sgx-driver](https://github.com/intel/linux-sgx-driver).
**Nota (/dev/mem).** Confiamos en el dispositivo virtual `/dev/mem` de Linux para construir mapeos de memoria virtual a nivel de usuario para los registros de E/S mapeados en memoria física de APIC y las entradas de tabla de páginas de interés. Sin embargo, las distribuciones recientes de Linux suelen habilitar la opción `CONFIG_STRICT_DEVMEM` que impide dicho uso. Por lo tanto, nuestro controlador `/dev/sgx-step` incluye un [enfoque](https://www.libcrack.so/index.php/2012/09/02/bypassing-devmem_is_allowed-with-kprobes/) para evitar las comprobaciones de `devmem_is_allowed`, sin tener que recompilar el kernel.
### 2. Parchear e instalar el SDK de SGX
Para permitir el registro sencillo de un stub personalizado de Puntero de Salida Asíncrona (AEP), modificamos el runtime no confiable del SDK oficial de Intel SGX. Proceda de la siguiente manera para hacer checkout de [linux-sgx](https://github.com/01org/linux-sgx) v2.29 y aplicar nuestros parches.```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
Los scripts de instalación anteriores están probados en Ubuntu 22.04 LTS. Para otras distribuciones de GNU/Linux, siga las instrucciones en el proyecto linux-sgx para compilar e instalar los paquetes Intel SGX SDK y PSW. También necesitará compilar y cargar un módulo del kernel SGX linux-sgx-driver (sin modificar) para poder usar SGX-Step.
Nota (instalación local). Los paquetes parcheados del SGX SDK y PSW se pueden
instalar localmente, sin afectar una instalación compatible de 'linux-sgx' a nivel de sistema.
Para ello, los Makefiles de ejemplo admiten una variable de entorno SGX_SDK
que apunta al directorio de instalación local del SDK. Cuando
se detecta una ruta del SDK no predeterminada (es decir, no /opt/intel/sgxsdk), los objetivos del Makefile "run"
además enlazan dinámicamente con la biblioteca de ejecución no confiable parcheada
libsgx_urts.so construida en el directorio local linux-sgx
(usando la variable de entorno LD_LIBRARY_PATH).
Nota (soporte de 32 bits). Instrucciones (¡desactualizadas y no mantenidas!) para compilar versiones de 32 bits del SGX SDK y SGX-Step se pueden encontrar en README-m32.md.
Las aplicaciones de espacio de usuario pueden enlazar con la biblioteca libsgxstep para usar
las funciones de ejecución paso a paso y manipulación de tablas de páginas de SGX-Step. Eche un vistazo a
las aplicaciones de ejemplo en el directorio "app".
Primero, verifique la configuración del APIC y la tabla de descriptores de interrupción:```bash $ cd app/selftest/idt $ make run # fires interrupts in an infinite loop to stress-test stability; exit with CTRL-C
Por ejemplo, para construir y ejecutar una aplicación de ejemplo elemental para probar las características de manipulación de tablas de páginas y parches del SDK:```bash
$ cd app/aep-redirect
$ make run
Para probar la funcionalidad de ejecución paso a paso con temporizador, intente, por ejemplo, compilar y ejecutar un enclave de referencia para ejecutar paso a paso una serie de 100 instrucciones nop consecutivas:```bash
$ cd app/bench
$ NUM=100 make parse # alternatively vary NUM and use STRLEN=1 or ZIGZAG=1
El comando anterior compila `libsgxstep`, el enclave víctima de referencia, y el proceso anfitrión atacante no confiable, donde el escenario de ataque y el tamaño de la instancia se configuran mediante las variables de entorno correspondientes. El mismo comando también ejecuta el binario resultante de forma no interactiva (para garantizar intervalos de temporizador deterministas), y finalmente ejecuta un script de Python de postprocesamiento específico del ataque para analizar los resultados de referencia del puntero de instrucción del enclave resultante.
**Nota (rendimiento).** La ejecución paso a paso de un enclave provoca una ralentización considerable. Medimos tiempos de ejecución de hasta 15 minutos para los experimentos descritos en el artículo. Las funciones de manipulación de la tabla de páginas de SGX-Step permiten iniciar el paso a paso solo para funciones seleccionadas, por ejemplo, revocando los derechos de acceso en páginas de código o datos específicas de interés.
**Nota (intervalo del temporizador).** El valor exacto del intervalo del temporizador depende de la frecuencia de la CPU y, por lo tanto, sigue siendo inherentemente específico de la plataforma (consulte también [app/selftest/apic](https://github.com/jovanbulck/sgx-step/blob/master/app/selftest/apic) para microbenchmarks detallados que evalúan la precisión de varios modos de temporizador APIC). Configure un valor adecuado en `/app/bench/main.c`. Establecimos intervalos de temporizador precisos para nuestras plataformas de evaluación (consulte la tabla a continuación) ajustando y observando los resultados del seguimiento del puntero de instrucción del enclave de microbenchmark NOP, como se detalla más adelante.
**Nota (estabilidad).** Para evitar que el kernel de Linux se bloquee o entre en pánico, SGX-Step debe restaurar automáticamente la tabla de descriptores de interrupción y el temporizador APIC local después de salir del proceso `libsgxstep`. Puede verificar si el temporizador APIC aún se está disparando en todos los núcleos de la siguiente manera:
``````bash
$ watch -n0.1 "cat /proc/interrupts | grep 'Local timer interrupts'"
La tabla a continuación enumera las CPU Intel actualmente compatibles, junto con su
intervalo del temporizador APIC de paso a paso (libsgxstep/config.h).
Tenga en cuenta que el intervalo exacto de paso a paso puede depender de la versión del microcódigo
del procesador cuando mitigaciones recientes de ataque de ejecución transitoria estén
vigentes para vaciar los búferes microarquitectónicos al entrar/salir del enclave.
En la tabla siguiente se proporcionan algunas versiones diferentes de microcódigo como referencia.
| Nombre del modelo | CPU | Frecuencia base | microcódigo (fecha) | Intervalo del temporizador 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 (calibración).
Actualmente, la forma más sencilla de configurar un intervalo de temporizador fiable es
utilizar la herramienta de evaluación comparativa app/bench con un slide NOP largo e
ir aumentando/disminuyendo gradualmente SGX_STEP_TIMER_INTERVAL. Puede probablemente
comenzar alrededor de 20 y luego ejecutar NUM=100 make parse para obtener un resumen
de single-steps, zero-steps y multi-steps para un slide NOP de 100
instrucciones (una vez que tenga un intervalo más o menos estable puede
cambiar a slides más largos). Demasiados zero-steps indican que debe
aumentar el intervalo del temporizador, mientras que multi-steps requieren
disminuir el intervalo del temporizador.
Nota (filtrado de zero-steps). Importante: no se preocupe si quedan algunos zero-steps, siempre que avance, puede filtrar deterministamente los zero-steps observando el bit de acceso (PTE) del código del enclave (que solo se establece cuando la instrucción realmente se retira y se produce un single-step). Por lo tanto, después de configurar un intervalo de temporizador conservador que siempre evite multi-steps, SGX-Step puede lograr una ejecución paso a paso sin ruido a una granularidad perfecta a nivel de instrucción.
Nota (extensión de la "ventana de aterrizaje" de la interrupción).
Como se aclara en el análisis de causa raíz a continuación, cuanto más lento sea el recorrido de la tabla de páginas
para resolver la dirección (del código) de la primera instrucción del enclave después de
ERESUME, más larga será la "ventana de aterrizaje" de la interrupción y, por lo tanto, más
fiable será la tasa de paso a paso de SGX-Step. Por ejemplo, descubrimos que,
además de borrar el bit de acceso del PMD del enclave, la ventana de aterrizaje puede
extenderse aún más vaciando una o más de las entradas de la tabla de páginas no protegidas
de la caché de la CPU antes de ERESUME, forzando efectivamente a la CPU a
esperar a la memoria lenta durante el recorrido de la tabla de páginas. Por lo tanto, cuando no pueda encontrar una
configuración de intervalo de temporizador fiable, asegúrese de (i) borrar el bit
"accessed" del PTE/PMD del código del enclave y (ii) vaciar (CLFLUSH) una o más entradas
de la tabla de páginas del enclave en el manejador AEP.
Nota (microcódigo). Otra advertencia se relaciona con las mitigaciones recientes de microcódigo de Foreshadow/ZombieLoad/RIDL/etc. que vacían búferes uarch con fugas en la entrada/salida del enclave. Tenga en cuenta que cuando estas mitigaciones están habilitadas, el intervalo del temporizador deberá aumentarse ya que la entrada al enclave tarda más (por ejemplo, en mi CPU i7-8650U encontré que el intervalo del temporizador de paso a paso sube a 54 con microcódigo reciente, desde solo 34 con microcódigo anterior a Foreshadow). Las operaciones de vaciado adicionales pueden además aumentar algo la varianza del tiempo de entrada al enclave, lo que implica que es posible que deba configurar el temporizador de forma más conservadora con más zero-steps (que se pueden filtrar deterministamente como se explicó anteriormente).
En el artículo
AEX-Notify se describe un análisis detallado
de la causa raíz de cómo exactamente SGX-Step
logra interrumpir de forma fiable la primera instrucción (¡posiblemente muy corta!) del enclave
después de la notoriamente compleja instrucción ERESUME.
Descubrimos que la clave del éxito de SGX-Step reside en su uso del bit
"accessed" (A). Específicamente, SGX-Step siempre borra el bit A en el directorio medio de página
(PMD) del enclave víctima antes de armar el APIC para disparar una interrupción
de un solo disparo. El bit A solo se establece por el procesador cuando al menos una
instrucción es ejecutada por el enclave y, por lo tanto, se puede utilizar para
distinguir deterministamente entre zero-steps y single-steps.
Crucialmente, como el manejador de fallos de página del procesador está optimizado para el camino rápido común
y utiliza una "asistencia de microcódigo" mucho más lenta para manejar el caso menos frecuente
y más complejo donde se necesita modificar un PMD o PTE, esta asistencia tiene
el efecto de prolongar la ejecución de la primera instrucción del enclave
después de ERSUME en varios cientos de ciclos. Esta "ventana de asistencia" abre así
efectivamente un espacio de aterrizaje amplio para que la interrupción del temporizador APIC de grano grueso
y normalmente distribuida llegue con alta precisión.
La forma más sencilla de empezar a utilizar el framework SGX-Step en sus propios
proyectos es a través de
submódulos de 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
Echa un vistazo a los Makefiles en el directorio `app` para ver cómo una aplicación cliente puede enlazar con `libsgxstep` además de cualquier paquete local de SGX SDK/PSW.
<a name="bottom"></a>
La siguiente es una lista de proyectos conocidos que utilizan SGX-Step. Si tu proyecto usa SGX-Step y no aparece en la lista, no dudes en abrir un pull request.
| Título | Detalles de publicación | Código fuente | Funcionalidades de SGX-Step utilizadas |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
| 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 and Measuring 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 |