jovanbulck/sgx-stepUm framework de ataque prático para controle preciso de execução em enclave
SGX-Step é um framework de código aberto para facilitar a pesquisa de ataques de canal lateral em processadores Intel x86 em geral e em plataformas Intel SGX em particular. SGX-Step consiste em um driver adversarial do kernel Linux e uma pequena biblioteca de sistema operacional em espaço de usuário que permite configurar entradas de tabela de páginas não confiáveis e/ou interrupções de temporizador APIC x86 completamente a partir do espaço de usuário. SGX-Step tem sido utilizado em nossa própria pesquisa, bem como por pesquisadores independentes, para possibilitar vários ataques de execução em enclave novos e melhorados que coletam observações de canal lateral com resolução temporal máxima (isto é, interrompendo o enclave vítima após cada instrução individual).
Licença. SGX-Step é um software livre, licenciado sob GPLv3. O logotipo do SGX-Step é derivado da icônica série de fotos domínio público "Sallie Gardner at a Gallop" de Eadweard Muybridge, que, assim como nosso objetivo de execução passo a passo em enclave, decompõe a dinâmica do cavalo galopando em uma série de quadros fotográficos individuais para revelar propriedades gerais da marcha do cavalo.
| Lançamento do SGX-Step | Recursos do changelog |
|---|---|
| v1.5.0 | Correções de estabilização (KPTI, mapeamento ISR do kernel); porta (experimental) Gramine; suporte a IPI. |
| v1.4.0 | Portas privilegiadas de interrupção/chamada (Plundervolt). |
| v1.3.0 | Suporte a execução transiente (Foreshadow). |
| v1.2.0 | Tratamento de interrupção em espaço de usuário e filtragem determinística de passo zero (Nemesis). |
| v1.1.0 | Suporte a IA32. |
| v1.0.0 | Manipulação de tabela de páginas em espaço de usuário e execução passo a passo com temporizador APIC. |
Publicações. O SGX-Step tem sido empregado por vários grupos de pesquisa independentes e possibilitou uma nova linha de ataques SGX de alta resolução. Uma lista completa e atualizada de projetos conhecidos que usam SGX-Step está incluída no final deste README. Uma cópia do artigo original está disponível aqui.``` @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, }
**Demonstração.** O diretório [app/memcmp](https://github.com/jovanbulck/sgx-step/blob/master/app/memcmp) contém uma pequena aplicação de demonstração que
ilustra o poder dos ataques SGX-Step ao executar passo a passo um enclave de exemplo
que contém lógica de comparação de senhas `memcmp` sutil e não constante em tempo.
Ao contrário dos tradicionais e notoriamente ruidosos ataques de temporização, o SGX-Step pode
realizar força bruta determinística da senha caractere por caractere em tempo _linear_:
## Visão Geral
Crucial para o design do SGX-Step, ao contrário de propostas anteriores de preempção de enclave,
é a criação de mapeamentos de memória virtual em espaço de usuário para locais de memória física
que contêm entradas de tabela de páginas, bem como para os registros de configuração de I/O
mapeados em memória do APIC local e para a Tabela de Descritores de Interrupção (IDT) do x86.
Isso permite que um processo host não confiável e controlado por atacante possa facilmente
(i) rastrear ou modificar entradas de tabela de páginas do enclave, (ii) configurar a fonte de
interrupção temporizadora one-shot/periódica do APIC, (iii) disparar interrupções entre
processadores e (iv) registrar manipuladores de interrupção personalizados completamente _dentro_
do espaço de usuário.
A figura acima resume a sequência de etapas de hardware e software ao
interromper e retomar um enclave SGX através do nosso framework.
1. A interrupção do temporizador do APIC local chega dentro de uma instrução enclavada.
2. O processador executa o procedimento AEX que armazena seguramente o contexto de execução
no frame SSA do enclave, inicializa os registradores da CPU e redireciona para o
manipulador de interrupção (em espaço de usuário) registrado na IDT.
3. Neste ponto, qualquer código espião específico de ataque pode ser facilmente inserido.
4. A biblioteca retorna ao trampolim AEP em espaço de usuário. Modificamos o runtime não
confiável do SDK oficial do SGX para permitir o fácil registro de um stub AEP personalizado.
Além disso, para permitir uma avaliação precisa da nossa abordagem em enclaves de depuração
de benchmark controlados pelo atacante, o SGX-Step pode _opcionalmente_ ser instrumentado para
recuperar o ponteiro de instrução armazenado do frame SSA do enclave interrompido
(usando a interface `/proc/self/mem` do Linux e a instrução `EDBGRD`).
5. Em seguida, configuramos o temporizador do APIC local para a próxima interrupção
escrevendo no registro de I/O mapeado em memória de contagem inicial, logo antes de
executar (6) `ERESUME`.
## Visão geral do código-fonte
Este repositório está organizado da seguinte forma:```
.
├── 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.
O SGX-Step é um framework universal de controle de execução que permite o intercalamento preciso de instruções de enclave da vítima com código arbitrário do atacante. Alguns dos principais casos de uso do framework SGX-Step estão resumidos na figura abaixo (veja também o final deste README para uma lista atualizada de publicações que utilizam o SGX-Step).
O SGX-Step requer um processador Intel compatível com SGX e um kernel Linux padrão. Nossa avaliação original foi realizada em CPUs i7-6500U/6700, rodando Ubuntu 18.04 com um kernel Linux 4.15.0 padrão. Kernels Linux e distribuições mais recentes também são suportados. Resumimos abaixo os parâmetros do kernel do Linux.
| Parâmetro do kernel Linux | Motivação |
|---|---|
nox2apic | Opcionalmente configurar o dispositivo APIC local em modo de E/S mapeada em memória (para usar os recursos precisos de execução passo a passo do SGX-Step). Se definido, certifique-se de configurar X2APIC como 0 em libsgxstep/config.h. Alternativamente, você pode deixar a CPU em modo x2APIC e as distribuições recentes do SGX-Step também devem ser compatíveis. |
iomem=relaxed no_timer_check | Suprimir mensagens de aviso desnecessárias nos logs do kernel. |
nmi_watchdog=0 | Suprimir o watchdog NMI do kernel. |
isolcpus=1 | Afinizar o processo vítima a um núcleo de CPU isolado. |
clearcpuid=308,295,514 | Desabilitar a prevenção de acesso em modo supervisor (SMAP, bits 295), prevenção de execução em modo supervisor (SMEP, bits 308) e prevenção de instruções em modo usuário (UMIP, bits 514). |
pti=off | Desabilitar o Isolamento de Tabela de Páginas do Kernel (para evitar panics do kernel com manipuladores de IRQ do usuário). |
rcupdate.rcu_cpu_stall_suppress=1 | Desabilitar o detector de parada de CPU de read-copy update (RCU) do kernel (para evitar avisos ao executar passo a passo por um longo tempo sem chamar o manipulador de interrupção de timer do kernel.) |
msr.allow_writes=on | Suprimir mensagens de aviso do kernel para gravações de registros específicos do modelo (MSR) pelo SGX-Step. |
vdso=0 | Apenas em kernels Linux recentes: desabilitar a biblioteca vdso_sgx_enter_enclave (não compatível com patches de interceptação AEP). |
dis_ucode_ldr | Opcionalmente desabilitar atualizações de microcódigo da CPU (mitigações recentes de ataques de execução transitória podem necessitar recalibrar o intervalo de execução passo a passo). |
Passe os parâmetros de inicialização desejados para o kernel da seguinte forma:```bash
$ sudo vim /etc/default/grub
$ sudo update-grub && reboot
Para verificar se o kernel atualmente em execução está configurado corretamente, execute:```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 melhorar a estabilidade geral do tempo de execução, você pode optar por desabilitar adicionalmente as tecnologias C-States e SpeedStep na configuração da BIOS.
/dev/sgx-stepO SGX-Step vem com um módulo de kernel carregável que exporta uma interface IOCTL para a biblioteca de espaço de usuário libsgxstep. O driver é principalmente responsável por (i) interceptar o manipulador de interrupção do temporizador APIC, (ii) coletar mapeamentos de tabela de páginas não confiáveis e, opcionalmente, (iii) buscar o ponteiro de instrução interrompido para enclaves de benchmark.
Para construir e carregar o driver /dev/sgx-step, execute:```bash
$ cd kernel/
$ ./install_SGX_driver.sh # tested on Ubuntu 20.04/22.04
$ make clean load
**Nota (/dev/sgx_enclave).** O SGX-Step suporta tanto o driver legado Intel `/dev/isgx` fora da árvore (out-of-tree) que deve funcionar em todas as plataformas, como também bem como o driver upstream `/dev/sgx_enclave` para plataformas com kernels Linux recentes >5.11 e suporte de hardware para controle de inicialização flexível. O script `install_SGX_driver.sh` deve detectar automaticamente se um driver `/dev/sgx_enclave` na árvore (in-tree) está disponível e, se não estiver, construir e carregar o driver `/dev/isgx` fora da árvore através do submódulo git que aponta para uma versão não modificada v2.14 [linux-sgx-driver](https://github.com/intel/linux-sgx-driver).
**Nota (/dev/mem).** Nós dependemos do dispositivo virtual `/dev/mem` do Linux para construir mapeamentos de memória virtual em nível de usuário para registros de E/S mapeados em memória física APIC e entradas de tabela de páginas de interesse. No entanto, distribuições Linux recentes geralmente habilitam a opção `CONFIG_STRICT_DEVMEM` que impede tal uso. Nosso driver `/dev/sgx-step` portanto inclui uma [abordagem](https://www.libcrack.so/index.php/2012/09/02/bypassing-devmem_is_allowed-with-kprobes/) para contornar as verificações de `devmem_is_allowed`, sem precisar recompilar o kernel.
### 2. Aplicar patch e instalar o SGX SDK
Para permitir o registro fácil de um stub de Ponteiro de Saída Assíncrona (AEP) personalizado, modificamos o runtime não confiável do SGX SDK oficial da Intel. Proceda da seguinte forma para fazer checkout do [linux-sgx](https://github.com/01org/linux-sgx) v2.29 e aplicar nossos patches.```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
Os scripts de instalação acima são testados no Ubuntu 22.04 LTS. Para outras distribuições GNU/Linux, siga as instruções no projeto linux-sgx para compilar e instalar os pacotes Intel SGX SDK e PSW. Você também precisará compilar e carregar um (não modificado) linux-sgx-driver kernel módulo do kernel SGX para usar o SGX-Step.
Nota (instalação local). Os pacotes corrigidos do SGX SDK e PSW podem ser
instalados localmente, sem afetar uma instalação compatível do 'linux-sgx' em todo o sistema.
Para isso, os Makefiles de exemplo suportam uma variável de ambiente SGX_SDK
que aponta para o diretório de instalação local do SDK. Quando
ao detectar um caminho de SDK não padrão (ou seja, diferente de /opt/intel/sgxsdk), os alvos do Makefile "run"
além disso, fazem a ligação dinâmica contra a
biblioteca de tempo de execução não confiável libsgx_urts.so construída no diretório local linux-sgx
(usando a variável de ambiente LD_LIBRARY_PATH).
Nota (suporte a 32 bits). Instruções (desatualizadas e não mantidas!) para compilar versões de 32 bits do SGX SDK e do SGX-Step podem ser encontradas em README-m32.md.
Aplicações do espaço do usuário podem se ligar à biblioteca libsgxstep para usar
os recursos de single-stepping e manipulação de tabela de páginas do SGX-Step. Dê uma olhada
nas aplicações de exemplo no diretório "app".
Primeiro, verifique a configuração do APIC e da tabela de descritores de interrupção:```bash $ cd app/selftest/idt $ make run # fires interrupts in an infinite loop to stress-test stability; exit with CTRL-C
Por exemplo, para construir e executar um aplicativo de exemplo elementar para testar recursos de manipulação de tabela de páginas e patches do SDK:```bash
$ cd app/aep-redirect
$ make run
Para testar a funcionalidade de single-stepping do timer, tente, por exemplo, construir e executar um enclave de benchmark para executar single-step em uma sequência de 100 instruções nop sucessivas:```bash
$ cd app/bench
$ NUM=100 make parse # alternatively vary NUM and use STRLEN=1 or ZIGZAG=1
O comando acima constrói `libsgxstep`, o enclave vítima de benchmark, e o
processo host atacante não confiável, onde o cenário de ataque e o tamanho da instância
são configurados através das variáveis de ambiente correspondentes. O mesmo comando
também executa o binário resultante de forma não interativa (para garantir intervalos de timer
determinísticos) e, finalmente, chama um script Python de pós-processamento específico do ataque
para analisar os resultados de benchmark do ponteiro de instrução do enclave.
**Nota (desempenho).** A execução passo a passo (single-stepping) de código enclavado incorre em uma
desaceleração substancial. Medimos tempos de execução de até 15 minutos para os experimentos
descritos no artigo. Os recursos de manipulação de tabela de páginas do SGX-Step permitem
iniciar a execução passo a passo apenas para funções selecionadas, por exemplo, revogando
direitos de acesso em páginas específicas de código ou dados de interesse.
**Nota (intervalo do timer).** O valor exato do intervalo do timer depende da frequência
da CPU e, portanto, permanece inerentemente específico da plataforma (veja também
[app/selftest/apic](https://github.com/jovanbulck/sgx-step/blob/master/app/selftest/apic) para microbenchmarks detalhados que avaliam a precisão de
vários modos de timer APIC). Configure um valor adequado em `/app/bench/main.c`.
Estabelecemos intervalos de timer precisos para nossas plataformas de avaliação (veja tabela
abaixo) ajustando e observando os resultados do rastreamento do ponteiro de instrução do enclave
no microbenchmark NOP, conforme detalhado abaixo.
**Nota (estabilidade).** Para evitar que o kernel Linux trave ou entre em pânico,
o SGX-Step deve restaurar automaticamente a tabela de descritores de interrupção
e o timer APIC local após sair do processo `libsgxstep`. Você pode verificar se
o timer APIC ainda está disparando em todos os núcleos da seguinte forma:```bash
$ watch -n0.1 "cat /proc/interrupts | grep 'Local timer interrupts'"
A tabela abaixo lista as CPUs Intel atualmente suportadas, juntamente com seu
intervalo do temporizador APIC de single-stepping (libsgxstep/config.h).
Observe que o intervalo exato de single-stepping pode depender da versão do microcódigo
do processador quando mitigações recentes de ataques de execução transitória estão
em vigor para limpar buffers microarquiteturais na entrada/saída do enclave.
Algumas versões diferentes de microcódigo são fornecidas como referência na tabela abaixo.
| Nome do modelo | CPU | Frequência base | Microcódigo (data) | Intervalo do 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 (calibração).
Atualmente, a maneira mais fácil de configurar um intervalo de temporizador confiável é
usar a ferramenta de benchmarking app/bench com um longo slide de NOP e
gradualmente aumentar/diminuir SGX_STEP_TIMER_INTERVAL. Você pode provavelmente
começar em torno de 20 e depois executar NUM=100 make parse para obter um resumo
de single-steps, zero-steps e multi-steps para um slide de NOP de 100
instruções (uma vez que você tenha um intervalo mais ou menos estável, pode
mudar para slides mais longos). Muitos zero-steps indicam que você precisa
aumentar o intervalo do temporizador, enquanto multi-steps exigem diminuir
o intervalo do temporizador.
Nota (filtrando zero-steps). Importante: não se preocupe quando alguns zero-steps permanecerem, desde que você progrida, você sempre pode filtrar deterministicamente os zero-steps olhando para o bit de acesso (PTE accessed) do código do enclave (que é definido apenas quando a instrução realmente é executada e um single-step ocorre). Assim, após configurar um intervalo de temporizador conservador que sempre evita multi-steps, o SGX-Step pode alcançar single-stepping sem ruído com uma granularidade perfeita, no nível da instrução.
Nota (estendendo a "janela de aterrissagem" da interrupção).
Conforme esclarecido na análise de causa raiz abaixo, quanto mais lenta for a caminhada pela tabela de páginas
para resolver o endereço (do código) da primeira instrução do enclave após
ERESUME, maior a "janela de aterrissagem" da interrupção e, portanto, mais
confiável será a taxa de single-stepping do SGX-Step. Por exemplo, descobrimos que,
além de limpar o bit de acesso do PMD do enclave, a janela de aterrissagem pode ser
ainda mais estendida ao esvaziar uma ou mais entradas da tabela de páginas não protegidas
do cache da CPU antes de ERESUME, forçando efetivamente a CPU a
esperar por memória lenta durante a caminhada pela tabela de páginas. Assim, quando você não conseguir encontrar uma
configuração confiável de intervalo do temporizador, certifique-se de (i) limpar o bit de "acesso"
do PTE/PMD do código do enclave e (ii) esvaziar (CLFLUSH) uma ou mais entradas da tabela de páginas
do enclave no manipulador AEP.
Nota (microcódigo). Outra palavra de cautela diz respeito às mitigações recentes de microcódigo para Foreshadow/ZombieLoad/RIDL/etc que esvaziam buffers microarquiteturais vazados na entrada/saída do enclave. Esteja ciente de que, quando essas mitigações estão ativadas, o intervalo do temporizador terá que ser aumentado, pois a entrada do enclave leva mais tempo (por exemplo, na minha CPU i7-8650U descobri que o intervalo do temporizador de single-step sobe para 54 com microcódigo recente, contra apenas 34 com microcódigo anterior ao Foreshadow). As operações de esvaziamento adicionais podem também aumentar um pouco a variância do tempo de entrada do enclave, o que implica que você pode precisar configurar o temporizador de forma mais conservadora com mais zero-steps (que podem ser deterministicamente filtrados conforme explicado acima).
Uma análise detalhada de causa raiz de como exatamente o SGX-Step
consegue interromper de forma confiável a primeira (possivelmente muito curta!) instrução
do enclave após a notoriamente complexa instrução ERESUME é descrita no artigo
AEX-Notify.
Descobrimos que a chave para o sucesso do SGX-Step está no uso do bit de "acesso"
(A). Especificamente, o SGX-Step sempre limpa o bit A no diretório de página intermediário (PMD)
do enclave vítima antes de armar o APIC para disparar uma interrupção de disparo único.
O bit A só é definido pelo processador quando pelo menos uma instrução
é executada pelo enclave e, portanto, pode ser usado para
distinguir deterministicamente entre zero-steps e single-steps.
Crucialmente, como o manipulador de falta de página do processador é otimizado para o caminho rápido comum
e usa um "assist" de microcódigo muito mais lento para lidar com o caso menos frequente
e mais complexo onde um PMD ou PTE precisa ser modificado, este assist tem
o efeito de prolongar a execução da primeira instrução do enclave
após ERSUME em várias centenas de ciclos. Esta "janela de assist" efetivamente
abre um espaço de aterrissagem espaçoso para a interrupção do temporizador APIC, de granularidade grossa e normalmente distribuída,
chegar com alta precisão.
A maneira mais fácil de começar a usar o framework SGX-Step em seus próprios
projetos é através de
submódulos 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
Dê uma olhada nos Makefiles no diretório `app` para ver como uma aplicação cliente pode se ligar ao `libsgxstep` mais quaisquer pacotes locais do SGX SDK/PSW.
<a name="bottom"></a>
A seguir está uma lista de projetos conhecidos que usam SGX-Step. Sinta-se à vontade para abrir um pull request se o seu projeto usa SGX-Step mas não está incluído abaixo.
| Título | Detalhes da publicação | Código fonte | Funcionalidades SGX-Step usadas |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
| AEX-NStep: Ataques Probabilísticos de Contagem de Interrupções no Intel SGX | [S&P'26](https://arxiv.org/pdf/2510.14675) | [Zenodo](https://zenodo.org/records/17338383) | Page faults, IPIs, WRMSR Interrupt Gate |
| MDPeek: Quebrando Ramos Balanceados no SGX com Canais Laterais da Unidade de Desambiguação de Memória | [ASPLOS'25](https://www.comp.nus.edu.sg/~tcarlson/pdfs/liu2025mbbbiswmdusc.pdf) | [GitHub (Artifact Evaluated & Functional)](https://github.com/CPU-THU/MDPeek) | Page faults |
| Funções de Ativação Consideradas Prejudiciais: Recuperando Pesos de Redes Neurais Através de Canais Controlados | [RAID'25](https://ieeexplore.ieee.org/document/11352487) | [Github Artifact](https://github.com/heavyimage/afch_paper) | Single-stepping, PTE A/D |
| TLBlur: Endurecimento Automatizado Assistido por Compilador contra Canais Controlados em Plataformas Intel SGX Comerciais | [USEC'25](https://vanbulck.net/files/usenix25-tlblur.pdf) | [GitHub (full)](https://github.com/TLBlur-SGX) | Single-stepping, PTE A/D, page faults |
| POSTER: Sobre a Viabilidade de Inferir Execução SGX através do PMU | [AsiaCCS'24](https://dl.acm.org/doi/pdf/10.1145/3634737.3659434) | - | Single-stepping, zero-stepping|
| SIGY: Quebrando Enclaves Intel SGX com Exceções e Sinais Maliciosos | [ArXiv'24](https://arxiv.org/abs/2404.13998) | - | Timer interrupts, page faults |
| Sobre a (Falta de) Confidencialidade de Código em Ambientes de Execução Confiáveis | [S&P24](https://ivanpuddu.com/files/papers/TEE_WASM_code_Leakage.pdf) | [GitHub (vazio)](https://github.com/dn0sar/TEE-WASM-Code-Extraction) | Single-stepping |
| TeeJam: Vazamentos Sub-Cache-Line Contra-Atacam | [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: Frustrando Ataques Precisos de Single-Stepping através de Consciência de Interrupção para Enclaves Intel SGX | [USEC23](https://jovanbulck.github.io/files/usenix23-aexnotify.pdf) | [GitHub (mitigação SGX SDK)](https://github.com/intel/linux-sgx/blob/master/sdk/trts/linux/trts_mitigation.S) | Single-Stepping, PTE A/D
| Corridas de Dados Controladas em Enclaves: Ataques e Detecção | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-chen-sanchuan.pdf) | [GitHub (não ataque)](https://github.com/OSUSecLab/SGXRacer) | Single-stepping, APIC |
| BunnyHop: Explorando o Prefetcher de Instruções | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-zhang-zhiyuan-bunnyhop.pdf) | [GitHub (PoC não SGX)](https://github.com/0xADE1A1DE/BunnyHop) | Single-stepping, PTE A/D |
| Downfall: Explorando Coleta Especulativa de Dados | [USEC23](https://www.usenix.org/system/files/usenixsecurity23-moghimi.pdf) | [GitHub (PoC não SGX)](https://github.com/flowyroll/downfall/tree/main/POC) | Single-stepping, zero-stepping |
| Todos os Seus PCs Nos Pertencem: Explorando Atualizações de BTB de Instruções Não-Transferência de Controle para Extração Dinâmica de PC | [ISCA23](https://dl.acm.org/doi/pdf/10.1145/3579371.3589100?casa_token=Q5jf5nOgiLIAAAAA:cT0ltJh7vk943buODuR4oMFKmuhg2Tp-djFm2kUu6DzlxtBhNhEw2WteRggn0k99D7ft-P6pluVrFA) | - | Single-stepping |
| Ataque de cache-timing contra HQC | [CHES23](https://eprint.iacr.org/2023/102.pdf) | - | Single-stepping, PTE A/D |
| FaultMorse: Um ataque automatizado de canal controlado via sequência recorrente mais longa | [ComSec23](https://www.sciencedirect.com/science/article/pii/S0167404822003959) | [GitHub (pós-processamento)](https://github.com/Ezekiel-1998/FaultMorse) | Page fault |
| AEPIC Leak: Vazamento Arquitetural de Dados Não Inicializados da Microarquitetura | [USEC22](https://www.usenix.org/system/files/sec22-borrello.pdf) | [GitHub (completo)](https://github.com/IAIK/AEPIC) | Single-Stepping, PTE A/D |
| MoLE: Mitigação de Ataques de Canal Lateral contra SGX via Escape Dinâmico de Localização de Dados | [ACSAC22](https://dl.acm.org/doi/fullHtml/10.1145/3564625.3568002) | - | Single-Stepping, page fault, transient execution |
| WIP: Ataque de Interrupção em Veículos Robóticos Protegidos por TEE | [AutoSec22](https://www.ndss-symposium.org/wp-content/uploads/autosec2022_23001_paper.pdf) | - | Single-stepping, multi-stepping |
| Rumo a Enclaves Automonitorados: Detecção de Canal Lateral Usando Contadores de Desempenho | [NordSec22](https://link.springer.com/chapter/10.1007/978-3-031-22295-5_7) | - | Page fault, LVI. |
| ENCLYZER: Análise Automatizada de Vazamentos de Dados Transientes no Intel SGX | [SEED22](https://ieeexplore.ieee.org/document/9935016) | [GitHub (completo)](https://github.com/bloaryth/enclyser) | Page-table manipulation |
| Canal Lateral na Expansão de Chave Kalyna | [CT-RSA22](https://cs.adelaide.edu.au/~yval/pdfs/ChuengsatiansupGYZ22.pdf) | - | Single-Stepping, PTE A/D |
| Prototipagem Rápida para Ataques Microarquiteturais | [USENIX22](https://www.usenix.org/system/files/sec22summer_easdon.pdf) | [GitHub (completo)](https://github.com/libtea/frameworks) | Single-stepping, page fault, PTE A/D, etc. |
| Util::Lookup: Explorando Decodificação de Chaves em Bibliotecas Criptográficas | [CCS21](https://dl.acm.org/doi/abs/10.1145/3460120.3484783) | [GitHub (completo)](https://github.com/UzL-ITS/util-lookup) | Single-Stepping, PTE A/D |
| SmashEx: Esmagando Enclaves SGX Usando Exceções | [CCS21](https://dl.acm.org/doi/pdf/10.1145/3460120.3484821) | - | Single-Stepping |
| Ataques de Template Online: Revisitados | [CHES21](https://tches.iacr.org/index.php/TCHES/article/view/8967/8545) | [Zenodo (simulação)](https://zenodo.org/record/4680071) | Single-stepping, page fault, PTE A/D |
| Ataques Aion: Manipulando Temporizadores de Software em Ambientes de Execução Confiáveis | [DIMVA21](http://individual.utoronto.ca/shengjiexu/publication/whuang-dimva2021-aion_v2.pdf) | - | Single-stepping, interrupts(?) |
| Platypus: Ataques de Canal Lateral Baseados em Software no x86 | [S&P21](https://platypusattack.com/platypus.pdf) | [GitHub (PoC simulado)](https://github.com/0xhilbert/Platypus) | Single-stepping, zero-stepping |
| CrossTalk: Vazamentos Especulativos de Dados Entre Núcleos São Reais | [S&P21](https://download.vusec.net/papers/crosstalk_sp21.pdf) | - | Single-stepping, page fault |
| Ataque Frontal: Vazamento de Fluxo de Controle no SGX via Frontend da CPU | [USEC21](https://www.usenix.org/system/files/sec21-puddu.pdf) | [GitHub (completo, artifact evaluated)](https://github.com/dn0sar/frontal_poc) | Single-stepping interrupt latency, PTE A/D |
| PThammer: Rowhammer Através de Fronteiras Usuário-Kernel por Meio de Acessos Implícitos | - | [MICRO20](https://arxiv.org/pdf/2007.08707v2.pdf) | Page table walk |
| SpeechMiner: Um Framework para Investigar e Medir Vulnerabilidades de Execução Especulativa | [NDSS20](https://www.ndss-symposium.org/wp-content/uploads/2020/02/23105-paper.pdf) | [GitHub (completo)](https://github.com/teecert/SpeechMiner) | Page-table manipulation |
| Déjà Vu: Análise de Canal Lateral do NSS da Mozilla | [CCS20](https://dl.acm.org/doi/pdf/10.1145/3372297.3421761) | - | Page fault |
| De A a Z: Vazamento de coordenadas projetivas na prática | [CHES20](https://eprint.iacr.org/2020/432.pdf) | - | Page fault |
| LVI: Sequestrando Execução Transiente através de Injeção de Valor de Carga Microarquitetural | [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: Ataques Controlados em Nível de Instrução em Enclaves | [USEC20](https://arxiv.org/pdf/2002.08437.pdf) | - | Single-stepping, page fault, PTE A/D |
| Quando um primitivo vulnerável se torna viral: Novos ataques de traço único em ECDSA e RSA | [CHES20](https://eprint.iacr.org/2020/055.pdf) | - | Single-stepping, page fault, PTE A/D |
| Números Grandes - Grandes Problemas: Analisando Sistematicamente Vazamento de Nonce em Implementações (EC)DSA | [USEC20](https://www.usenix.org/system/files/sec20summer_weiser_prepub_0.pdf) | - | Page fault |
| Plundervolt: Ataques de Injeção de Falha Baseados em Software contra Intel SGX | [S&P20](https://plundervolt.com/doc/plundervolt.pdf) | [GitHub (completo)](https://github.com/KitMurdock/plundervolt) | Privileged interrupt/call gates, MSR |
| Bluethunder: Um Ataque de Canal Lateral Baseado em Preditor Direcional de 2 Níveis contra SGX | [CHES20](https://heartever.github.io/files/bluethunder_sgx_ches.pdf) | - | Single-stepping |
| Fallout: Vazamento de Dados em CPUs Resistentes a Meltdown | [CCS19](https://mdsattacks.com/files/fallout.pdf) | - | PTE A/D |
| Um Conto de Dois Mundos: Avaliando a Vulnerabilidade de Runtimes de Proteção de Enclave | [CCS19](https://people.cs.kuleuven.be/~jo.vanbulck/ccs19-tale.pdf) | [GitHub (completo)](https://github.com/jovanbulck/0xbadc0de) | Single-stepping, page fault, PTE A/D |
| ZombieLoad: Amostragem de Dados Através de Fronteiras de Privilégio | [CCS19](https://zombieloadattack.com/zombieload.pdf) | [GitHub (PoC)](https://github.com/IAIK/ZombieLoad/) | Single-stepping, zero-stepping, page-table manipulation |
| SPOILER: Riscos de Carga Especulativa Impulsionam Ataques Rowhammer e Cache | [USEC19](https://arxiv.org/pdf/1903.00446.pdf) | - | Single-stepping interrupt latency |
| Nemesis: Estudando Vazamentos de Temporização Microarquiteturais em Lógica de Interrupção de CPU Rudimentar | [CCS18](https://people.cs.kuleuven.be/~jo.vanbulck/ccs18.pdf) | [GitHub (completo)](https://github.com/jovanbulck/nemesis) | Single-stepping interrupt latency, page fault, PTE A/D |
| Foreshadow: Extraindo as Chaves do Reino Intel SGX com Execução Transiente Fora de Ordem | [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 |
| Ataque de Traço Único Contra Geração de Chave RSA no Intel SGX SSL | [AsiaCCS18](https://rspreitzer.github.io/publications/proc/asiaccs-2018-paper-1.pdf) | - | Page fault |
| Off-Limits: Abusando da Segmentação de Memória x86 Legada para Espionar Execução em Enclave | [ESSoS18](https://people.cs.kuleuven.be/~jo.vanbulck/essos18.pdf) | [link (completo, artifact evaluated)](https://distrinet.cs.kuleuven.be/software/off-limits/) | Single-stepping, IA32 segmentation, page fault |
| SGX-Step: Um Framework Prático de Ataque para Controle Preciso de Execução de Enclaves | [SysTEX17](https://people.cs.kuleuven.be/~jo.vanbulck/systex17.pdf) | [GitHub (completo)](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 |