Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/jonathansalwan/triton
Análise Dinâmica (Sandboxing)Engenharia ReversaFuzzingAnálise de Binários
GitHubjonathansalwan/triton

Triton

Triton é uma biblioteca de análise binária dinâmica. Construa suas próprias ferramentas de análise de programas, automatize sua engenharia reversa, realize verificação de software ou apenas emule código.

Ver RepositórioSite
4.3k590há 3 mesesRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Triton é uma biblioteca de análise binária dinâmica. Ela fornece componentes internos que permitem criar ferramentas de análise de programas, automatizar engenharia reversa, realizar verificação de software ou apenas emular código.

  • Dynamic symbolic execution
  • Dynamic taint analysis
  • AST representation of the x86, x86-64, ARM32, AArch64 e RISC-V 32/64 ISA semantic
  • Expressions synthesis
  • SMT simplification passes
  • Lifting para LLVM bem como para Z3 e vice-versa
  • Interface SMT solver para Z3 e Bitwuzla
  • API C++ e Python


Como o Triton é uma espécie de projeto de meio período, por favor, não nos culpe se não for totalmente confiável. Abra issues ou pull requests são sempre melhores do que trollar =). No entanto, você pode acompanhar o desenvolvimento no twitter @qb_triton.

      Codecov      

Início rápido

  • Instalação
  • Python API
  • C++ API
  • Exemplos Python
  • Eles já usaram o Triton

Começando```python

from triton import *

Create the Triton context with a defined architecture

ctx = TritonContext(ARCH.X86_64)

Define concrete values (optional)

ctx.setConcreteRegisterValue(ctx.registers.rip, 0x40000)

Symbolize data (optional)

ctx.symbolizeRegister(ctx.registers.rax, 'my_rax')

Execute instructions

ctx.processing(Instruction(b"\x48\x35\x34\x12\x00\x00")) # xor rax, 0x1234 ctx.processing(Instruction(b"\x48\x89\xc1")) # mov rcx, rax

Get the symbolic expression

rcx_expr = ctx.getSymbolicRegister(ctx.registers.rcx) print(rcx_expr) (define-fun ref!8 () (_ BitVec 64) ref!1) ; MOV operation - 0x40006: mov rcx, rax

Solve constraint

ctx.getModel(rcx_expr.getAst() == 0xdead) {0: my_rax:64 = 0xcc99}

0xcc99 XOR 0x1234 is indeed equal to 0xdead

hex(0xcc99 ^ 0x1234) '0xdead'

root@kitploit:~
## Instalar usando pip

O Triton pode ser instalado usando `pip`:```console
pip install triton-library

Instalar a partir do código fonte

Triton depende das seguintes dependências:```

  • libcapstone >= 5.0.x https://github.com/capstone-engine/capstone
  • libboost (optional) >= 1.68
  • libpython (optional) >= 3.6
  • libz3 (optional) >= 4.6.0 https://github.com/Z3Prover/z3
  • libbitwuzla (optional) >= 0.4.x https://github.com/bitwuzla/bitwuzla
  • llvm (optional) >= 12
root@kitploit:~
### Linux e MacOS```console
$ git clone https://github.com/JonathanSalwan/Triton
$ cd Triton
$ mkdir build ; cd build
$ cmake ..
$ make -j3
$ sudo make install

Por padrão, LLVM e Bitwuzla não são compilados. Se você deseja aproveitar todo o poder do Triton, a compilação cmake é:```console $ cmake -DLLVM_INTERFACE=ON -DCMAKE_PREFIX_PATH=$(llvm-config --prefix) -DBITWUZLA_INTERFACE=ON ..

root@kitploit:~
#### MacOS M1 Nota:

Caso você obtenha erros de compilação como:```
Could NOT find PythonLibs (missing: PYTHON_LIBRARIES PYTHON_INCLUDE_DIRS)

Tente especificar PYTHON_EXECUTABLE, PYTHON_LIBRARIES e PYTHON_INCLUDE_DIRS para a sua versão específica do Python:```console cmake -DCMAKE_INSTALL_PREFIX=/opt/homebrew/
-DPYTHON_EXECUTABLE=/opt/homebrew/bin/python3
-DPYTHON_LIBRARIES=/opt/homebrew/Cellar/[email protected]/3.10.8/Frameworks/Python.framework/Versions/3.10/lib/libpython3.10.dylib
-DPYTHON_INCLUDE_DIRS=/opt/homebrew/opt/[email protected]/Frameworks/Python.framework/Versions/3.10/include/python3.10/
..

root@kitploit:~
Você pode obter esta informação deste trecho:```python
from sysconfig import get_paths
info = get_paths()
print(info)

Autocompletar Python

Se o autocompletar do Python não estiver funcionando, siga estas etapas:

  1. Execute o script
  2. Coloque o arquivo triton.pyi gerado no mesmo diretório do objeto compartilhado do Triton para o qual você deseja fornecer dicas (por exemplo, /usr/lib/python3.13/).

Sua IDE deve suportar a análise de arquivos .pyi.

Windows

Você pode usar o cmake para gerar o arquivo .sln do libTriton.```console

git clone https://github.com/JonathanSalwan/Triton.git cd Triton mkdir build cd build cmake -G "Visual Studio 14 2015 Win64"
-DBOOST_ROOT="C:/Users/jonathan/Works/Tools/boost_1_61_0"
-DPYTHON_INCLUDE_DIRS="C:/Python36/include"
-DPYTHON_LIBRARIES="C:/Python36/libs/python36.lib"
-DZ3_INCLUDE_DIRS="C:/Users/jonathan/Works/Tools/z3-4.6.0-x64-win/include"
-DZ3_LIBRARIES="C:/Users/jonathan/Works/Tools/z3-4.6.0-x64-win/bin/libz3.lib"
-DCAPSTONE_INCLUDE_DIRS="C:/Users/jonathan/Works/Tools/capstone-5.0.1-win64/include"
-DCAPSTONE_LIBRARIES="C:/Users/jonathan/Works/Tools/capstone-5.0.1-win64/capstone.lib" ..

root@kitploit:~
Você pode usar setup.py para gerar a versão de depuração do triton.pyd no Windows.```console
> git clone https://github.com/JonathanSalwan/Triton.git
> cd Triton
> $env:COMPILER_DIR="C:/deps/llvm/llvm2116r/bin"
> $env:CMAKE_PREFIX_PATH="C:/deps/llvm/llvm-project-21.1.6.src/install/lib/cmake/llvm;C:/code/cxx-common-cmake/build/install"
> python_d -m build --wheel
> python_d -m pip install (Get-ChildItem .\dist\triton_library*)

No entanto, se preferir descarregar diretamente a biblioteca pré-compilada, consulte os artefactos do nosso AppVeyor. Note que se utilizar os artefactos do AppVeyor, provavelmente terá de instalar os pacotes Visual C++ Redistributable para o Visual Studio 2012.

Instalação a partir do vcpkg

A porta do Triton no vcpkg é mantida atualizada por membros da Microsoft e colaboradores da comunidade. O url do vcpkg é: https://github.com/Microsoft/vcpkg. Pode descarregar e instalar o Triton utilizando o gestor de dependências vcpkg:```console $ git clone https://github.com/Microsoft/vcpkg.git $ cd vcpkg $ ./bootstrap-vcpkg.sh # ./bootstrap-vcpkg.bat for Windows $ ./vcpkg integrate install $ ./vcpkg install triton

root@kitploit:~
Se a versão estiver desatualizada, por favor [crie uma issue ou pull request](https://github.com/Microsoft/vcpkg) no repositório do vcpkg.


# Contribuidores

* [**Alberto Garcia Illera**](https://twitter.com/algillera) - Cruise Automation
* [**Alexey Vishnyakov**](https://vishnya.xyz/) - ISP RAS
* [**Black Binary**](https://github.com/black-binary) - n/a
* [**Christian Heitman**](https://github.com/cnheitman) - Quarkslab
* [**Daniil Kuts**](https://github.com/apach301) - ISP RAS
* [**Jessy Campos**](https://github.com/ek0) - n/a
* [**Matteo F.**](https://twitter.com/fvrmatteo) - n/a
* [**Pierrick Brunet**](https://github.com/pbrunet) - Quarkslab
* [**PixelRick**](https://github.com/PixelRick) - n/a
* [**Romain Thomas**](https://twitter.com/rh0main) - Quarkslab
* [**E muitos outros**](https://github.com/JonathanSalwan/Triton/graphs/contributors)


## Eles já usaram o Triton

### Ferramentas

* [Exrop](https://github.com/d4em0n/exrop): Geração Automática de ROPChain.
* [Pimp](https://github.com/kamou/pimp): Plugin para R2 baseado no Triton para execução concolic e controle total.
* [Ponce](https://github.com/illera88/Ponce): Vencedor do concurso de plugins da IDA 2016! Execução simbólica a um clique de distância!
* [QSynthesis](https://github.com/quarkslab/qsynthesis): Sintetizador Greybox voltado para desofuscação de instruções de assembly.
* [TritonDSE](https://github.com/quarkslab/tritondse): Biblioteca DSE baseada no Triton com capacidades de carregamento e exploração.
* [Titan](https://github.com/archercreat/titan): Titan é um devirtualizador do VMProtect usando Triton.

### Artigos e conferências<ul dir="auto">
<li>
<b>Sydr-Fuzz: Fuzzing Híbrido Contínuo e Análise Dinâmica para o Ciclo de Vida de Desenvolvimento de Segurança</b><br />
 <b>Apresentado em</b>: Ivannikov ISP RAS Open Conference, Moscou, Rússia, 2022. [<a href="publications/ISPOPEN2022-sydr-fuzz.pdf">artigo</a>] [<a href="publications/ISPOPEN2022-slide-sydr-fuzz-vishnyakov.pdf">slide</a>]<br />
 <b>Autores</b>: Vishnyakov A., Kuts D., Logunova V., Parygina D., Kobrin E., Savidov G., Fedotov A.<br />
 <b>Resumo</b>: <em>Atualmente, frameworks de análise dinâmica automatizada para testes contínuos são muito procurados para garantir a segurança do software e atender aos requisitos do ciclo de vida de desenvolvimento de segurança (SDL). A eficiência na caça de bugs de segurança das técnicas de fuzzing híbrido de ponta supera o fuzzing guiado por cobertura amplamente utilizado. Propomos um pipeline de análise dinâmica aprimorado para alavancar a produtividade da detecção automatizada de bugs baseada em fuzzing híbrido. Implementamos o pipeline proposto no conjunto de ferramentas de fuzzing contínuo Sydr-Fuzz, que é alimentado por um orquestrador de fuzzing híbrido, integrando nossa ferramenta DSE Sydr com libFuzzer e AFL++. O Sydr-Fuzz também incorpora verificadores de predicados de segurança, a ferramenta de triagem de crashes Casr e utilitários para minimização de corpus e coleta de cobertura. A avaliação comparativa do nosso fuzzer híbrido em relação a soluções alternativas de ponta demonstra sua superioridade sobre os fuzzers guiados por cobertura, permanecendo no mesmo nível dos fuzzers híbridos avançados. Além disso, comprovamos a relevância da nossa abordagem ao descobrir 85 novas falhas reais de software no projeto OSS-Sydr-Fuzz. Finalmente, disponibilizamos o código-fonte do Casr para a comunidade para facilitar o exame dos crashes existentes.</em>
</li><br/>
<li>
<b>Strong Optimistic Solving for Dynamic Symbolic Execution</b><br />
 <b>Apresentado em</b>: Ivannikov Memorial Workshop, Kazan, Rússia, 2022. [<a href="publications/IVMEM2022-strong-optimistic-parygina.pdf">artigo</a>] [<a href="publications/IVMEM2022-slide-strong-optimistic-parygina.pdf">slide</a>]<br />
 <b>Autores</b>: Parygina D., Vishnyakov A., Fedotov A.<br />
 <b>Resumo</b>: <em>A execução simbólica dinâmica (DSE) é um método eficaz para teste automatizado de programas e detecção de bugs. Ela aumenta a cobertura de código através da exploração de ramos complexos durante o fuzzing híbrido. Ferramentas DSE invertem os ramos ao longo de algum caminho de execução e ajudam o fuzzer a examinar partes do programa anteriormente indisponíveis. A DSE frequentemente enfrenta problemas de super-restrição e sub-restrição. O primeiro leva a uma complicação significativa da análise, enquanto o segundo causa execução simbólica imprecisa. Propomos um método de resolução otimista forte que elimina restrições irrelevantes de predicado de caminho para a inversão de ramo alvo. Eliminamos tais restrições simbólicas das quais o ramo alvo não é dependente de controle. Além disso, tratamos separadamente ramos simbólicos que possuem instruções de transferência de controle aninhadas que passam o controle para além do escopo do ramo pai, por exemplo, return, goto, break, etc. Implementamos o método proposto em nossa ferramenta de execução simbólica dinâmica Sydr. Avaliamos a estratégia otimista forte, a estratégia otimista que contém apenas a negação da última restrição, e sua combinação. Os resultados mostram que a combinação de estratégias ajuda a aumentar a cobertura de código ou o número médio de ramos corretamente invertidos por minuto. É ideal aplicar ambas as estratégias juntas, em contraste com outras configurações.</em>
</li><br/>
<li>
<b>Greybox Program Synthesis: A New Approach to Attack Dataflow Obfuscation</b><br />
 <b>Apresentado em</b>: Blackhat USA, Las Vegas, Nevada, 2021. [<a href="publications/BHUSA2021-David-Greybox-Program-Synthesis.pdf">slide</a>]<br />
 <b>Autores</b>: Robin David<br />
 <b>Resumo</b>: <em>Esta palestra apresenta os mais recentes avanços em síntese de programas aplicada à desofuscação. Tem como objetivo desmistificar esta técnica de análise, mostrando como ela pode ser colocada em ação na ofuscação. Especialmente a implementação Qsynthesis lançada para esta palestra mostra um fluxo de trabalho completo de ponta a ponta para desofuscar instruções de assembly de volta em instruções otimizadas (desofuscadas) remontadas no binário.</em>
</li><br/>
<li>
<b>From source code to crash test-case through software testing automation</b><br />
 <b>Apresentado em</b>: C&ESAR, Rennes, França, 2021. [<a href="publications/CESAR2021_robin-david-paper.pdf">artigo</a>] [<a href="publications/CESAR2021_robin-david-slide.pdf">slide</a>]<br />
 <b>Autores</b>: Robin David, Jonathan Salwan, Justin Bourroux<br />
 <b>Resumo</b>: <em>Este artigo apresenta uma abordagem que automatiza o processo de teste de software, desde o código-fonte até o teste dinâmico do programa compilado. Mais especificamente, a partir de um relatório de análise estática indicando alertas em linhas de código-fonte, ela permite testar para cobrir essas linhas dinamicamente e verificar oportunisticamente se podem ou não desencadear um crash. O resultado é um corpus de teste que permite cobrir alertas e dispará-los se forem verdadeiros positivos. Este artigo discute a metodologia empregada para rastrear alertas no binário compilado, o processo de seleção dos mecanismos de teste e os resultados obtidos em uma implementação de pilha TCP/IP para sistemas embarcados e IoT.</em>
</li><br/>
<li>
<b>Symbolic Security Predicates: Hunt Program Weaknesses</b><br />
 <b>Apresentado em</b>: Ivannikov ISP RAS Open Conference, Moscou, Rússia, 2021. [<a href="publications/ISPOPEN2021-security-predicates-vishnyakov.pdf">artigo</a>] [<a href="publications/ISPOPEN2021-slide-security-predicates-vishnyakov.pdf">slide</a>]<br />
 <b>Autores</b>: A.Vishnyakov, V.Logunova, E.Kobrin, D.Kuts, D.Parygina, A.Fedotov<br />
 <b>Resumo</b>: <em>A execução simbólica dinâmica (DSE) é um método poderoso para exploração de caminhos durante o fuzzing híbrido e detecção automática de bugs. Propomos predicados de segurança para detectar efetivamente comportamento indefinido e erros de violação de acesso à memória. Inicialmente, executamos simbolicamente o programa em caminhos que não disparam nenhum erro (o fuzzing híbrido pode explorar esses caminhos). Em seguida, construímos um predicado de segurança simbólico para verificar alguma condição de erro. Assim, podemos alterar o fluxo de dados do programa para provocar fraquezas de desreferência de ponteiro nulo, divisão por zero, acesso fora dos limites ou estouro de inteiro. Diferentemente da análise estática, a execução simbólica dinâmica não apenas reporta erros, mas também gera novos dados de entrada para reproduzi-los. Além disso, introduzimos a modelagem de semântica de funções para funções comuns da biblioteca padrão C/C++. Nosso objetivo é modelar o fluxo de controle dentro de uma função com uma única fórmula simbólica. Isso auxilia na detecção de bugs, acelera a exploração de caminhos e supera as super-restrições no predicado de caminho. Implementamos as técnicas propostas em nossa ferramenta de execução simbólica dinâmica Sydr. Assim, utilizamos métodos poderosos do Sydr, como o slicing de predicado de caminho, que elimina restrições irrelevantes. Apresentamos o Juliet Dynamic para medir a precisão de ferramentas de detecção dinâmica de bugs. O sistema de teste também verifica se as entradas geradas disparam sanitizers. Avaliamos a precisão do Sydr para 11 CWEs do conjunto de testes Juliet. O Sydr mostra uma precisão geral de 95,59%. Disponibilizamos publicamente os artefatos de avaliação do Sydr para facilitar a reprodutibilidade dos resultados.</em>
</li><br/>
<li>
<b>Towards Symbolic Pointers Reasoning in Dynamic Symbolic Execution</b><br />
 <b>Apresentado em</b>: Ivannikov Memorial Workshop, Nizhny Novgorod, Rússia, 2021. [<a href="publications/IVMEM2021-symbolic-pointers-kuts.pdf">artigo</a>] [<a href="publications/IVMEM2021-slide-symbolic-pointers-kuts.pdf">slide</a>]<br />
 <b>Autores</b>: Daniil Kuts<br />
 <b>Resumo</b>: <em>A execução simbólica dinâmica é uma técnica amplamente utilizada para teste automatizado de software, projetada para exploração de caminhos de execução e detecção de erros em programas. Uma abordagem híbrida tornou-se recentemente difundida, onde o principal objetivo da execução simbólica é ajudar o fuzzer a aumentar a cobertura do programa. Quanto mais ramos o executor simbólico conseguir inverter, mais útil ele será para o fuzzer. O fluxo de controle de um programa geralmente depende de valores de memória, que são obtidos calculando índices de endereço a partir da entrada do usuário. No entanto, a maioria das ferramentas DSE não suporta tais dependências, então elas perdem alguns ramos desejados do programa. Implementamos o raciocínio sobre endereços simbólicos em leituras de memória em nossa ferramenta de execução simbólica dinâmica Sydr. As regiões de acesso à memória possíveis são determinadas analisando expressões simbólicas de endereços de memória ou pesquisa binária com SMT-solver. Propomos uma técnica de linearização aprimorada para modelar acessos à memória. Diferentes métodos de modelagem de memória são comparados em um conjunto de programas. Nossa avaliação mostra que o tratamento de endereços simbólicos permite descobrir novos ramos simbólicos e aumentar a cobertura do programa.</em>
</li><br/>
<li>
<b>QSynth: A Program Synthesis based Approach for Binary Code Deobfuscation</b><br />
 <b>Apresentado em</b>: BAR, San Diego, Califórnia, 2020. [<a href="publications/BAR2020-qsynth-robin-david.pdf">artigo</a>]<br />
 <b>Autores</b>: Robin David, Luigi Coniglio, Mariano Ceccato<br />
 <b>Resumo</b>: <em>Apresentamos uma abordagem genérica que utiliza tanto DSE quanto síntese de programas para sintetizar com sucesso programas ofuscados com Mixed-Boolean-Arithmetic, Data-Encoding ou Virtualização. O algoritmo de síntese proposto é um algoritmo de síntese enumerativa offline guiado por busca em largura de cima para baixo. Mostramos sua eficácia contra um ofuscador de ponta e sua escalabilidade, superando outras abordagens similares baseadas em síntese. Também mostramos sua eficácia na presença de ofuscação composta (combinação de várias técnicas). Este trabalho em andamento ilumina a eficácia da síntese para atingir certos tipos de ofuscação e abre caminho para algoritmos e estratégias de simplificação mais robustos.</em>
</li><br/>
<li>
<b>Sydr: Cutting Edge Dynamic Symbolic Execution</b><br />
 <b>Apresentado em</b>: Ivannikov ISP RAS Open Conference, Moscou, Rússia, 2020. [<a href="publications/ISPRAS2020-sydr.pdf">artigo</a>] [<a href="publications/ISPOPEN2020-slide-sydr-vishnyakov.pdf">slide</a>] [<a href="https://www.ispras.ru/conf/2020/video/compiler-technology-11-december.mp4#t=6021">vídeo</a>]<br />
 <b>Autores</b>: A.Vishnyakov, A.Fedotov, D.Kuts, A.Novikov, D.Parygina, E.Kobrin, V.Logunova, P.Belecky, S.Kurmangaleev<br />
 <b>Resumo</b>: <em>A execução simbólica dinâmica (DSE) tem uma enorme quantidade de aplicações em segurança de computadores (fuzzing, descoberta de vulnerabilidades, engenharia reversa, etc.). Propomos várias melhorias de desempenho e precisão para execução simbólica dinâmica. Pular instruções não simbólicas permite construir um predicado de caminho 1,2 a 3,5 vezes mais rápido. O motor simbólico simplifica fórmulas durante a execução simbólica. O slicing de predicado de caminho elimina conjuntos irrelevantes de consultas do solver. Tratamos cada tabela de jump (instrução switch) como múltiplos ramos e descrevemos o método para execução simbólica de programas multi-thread. As soluções propostas foram implementadas na ferramenta Sydr. O Sydr realiza a inversão de ramos no predicado de caminho. O Sydr combina a ferramenta de instrumentação binária dinâmica DynamoRIO com o motor simbólico Triton.</em>
</li><br/>
<li>
<b>Symbolic Deobfuscation: From Virtualized Code Back to the Original</b><br />
 <b>Apresentado em</b>: DIMVA, Paris-Saclay, França, 2018. [<a href="publications/DIMVA2018-deobfuscation-salwan-bardin-potet.pdf">artigo</a>] [<a href="publications/DIMVA2018-slide-deobfuscation-salwan-bardin-potet.pdf">slide</a>]<br />
 <b>Autores</b>: Jonathan Salwan, Sébastien Bardin, Marie-Laure Potet<br />
 <b>Resumo</b>: <em>A proteção de software ganhou um lugar importante na última década para proteger software legítimo contra engenharia reversa ou adulteração. A virtualização é considerada uma das melhores defesas contra tais ataques. Apresentamos uma abordagem genérica baseada em exploração simbólica de caminhos, taint e recompilação, permitindo recuperar, a partir de um código virtualizado, um código desvirtualizado semanticamente idêntico ao original e próximo em tamanho. Definimos critérios e métricas para avaliar a relevância dos resultados desofuscados em termos de correção e precisão. Finalmente, propomos uma configuração de código aberto que permite avaliar a abordagem proposta contra várias formas de virtualização.</em>
</li><br/>
<li>
<b>Deobfuscation of VM based software protection</b><br />
 <b>Apresentado em</b>: SSTIC, Rennes, França, 2017. [<a href="publications/SSTIC2017-French-Article-desobfuscation_binaire_reconstruction_de_fonctions_virtualisees-salwan_potet_bardin.pdf">artigo em francês</a>] [<a href="publications/SSTIC2017_Deobfuscation_of_VM_based_software_protection.pdf">slide em inglês</a>] [<a href="https://static.sstic.org/videos2017/SSTIC_2017-06-07_P08.mp4">vídeo em francês</a>]<br />
 <b>Autores</b>: Jonathan Salwan, Sébastien Bardin, Marie-Laure Potet<br />
 <b>Resumo</b>: <em>Nesta apresentação, descrevemos uma abordagem que consiste em analisar automaticamente proteções de software baseadas em máquina virtual e que recompila uma nova versão do binário sem tais proteções. Esta abordagem automatizada baseia-se em uma execução simbólica guiada por uma análise de taint e algumas políticas de concretização, e depois em uma reescrita binária usando a transição LLVM.</em>
</li><br/>
<li>
<b>How Triton can help to reverse virtual machine based software protections</b><br />
 <b>Apresentado em</b>: CSAW SOS, NYC, Nova York, 2016. [<a href="publications/CSAW2016-SOS-Virtual-Machine-Deobfuscation-RThomas_JSalwan.pdf">slide</a>]<br />
 <b>Autores</b>: Jonathan Salwan, Romain Thomas<br />
 <b>Resumo</b>: <em>A primeira parte da palestra será uma introdução ao framework Triton para expor seus componentes e explicar como eles funcionam juntos. Em seguida, a segunda parte incluirá demonstrações de como é possível reverter proteções baseadas em máquina virtual usando análise de taint, execução simbólica, simplificações SMT e otimizações LLVM-IR.</em>
</li><br/>
<li>
<b>Dynamic Binary Analysis and Obfuscated Codes</b><br  />
 <b>Apresentado em</b>: St'Hack, Bordeaux, França, 2016. [<a href="publications/StHack2016_Dynamic_Binary_Analysis_and_Obfuscated_Codes_RThomas_JSalwan.pdf">slide</a>]<br  />
 <b>Autores</b>: Jonathan Salwan, Romain Thomas<br />
 <b>Resumo</b>: <em>Nesta apresentação, falaremos sobre como uma DBA (Dynamic Binary Analysis) pode ajudar um engenheiro reverso a reverter código ofuscado. Primeiro, introduziremos algumas técnicas básicas de ofuscação e depois exporemos como é possível quebrar algumas coisas (usando nosso framework DBA de código aberto - Triton), como detectar predicados opacos, reconstruir CFG, encontrar o algoritmo original, isolar dados sensíveis e muito mais... Em seguida, concluiremos com uma demonstração e algumas palavras sobre nosso trabalho futuro.</em>
</li><br/>
<li>
<b>How Triton may help to analyse obfuscated binaries</b><br  />
 <b>Publicado em</b>: MISC magazine 82, 2015. [<a href="publications/MISC-82_French_Paper_How_Triton_may_help_to_analyse_obfuscated_binaries_RThomas_JSalwan.pdf">artigo em francês</a>]<br  />
 <b>Autores</b>: Jonathan Salwan, Romain Thomas<br />
 <b>Resumo</b>: <em>A ofuscação binária é usada para proteger a propriedade intelectual de software. Existem diferentes tipos de ofuscação, mas, grosso modo, ela transforma uma estrutura binária em outra estrutura binária preservando a mesma semântica. O objetivo da ofuscação é garantir que a informação original seja "afogada" em informações inúteis que tornarão a engenharia reversa mais difícil. Neste artigo, mostraremos como podemos analisar um programa ofuscado e quebrar algumas ofuscações usando o framework Triton.</em>
</li><br/>
<li>
<b>Triton: A Concolic Execution Framework</b><br  />
 <b>Apresentado em</b>: SSTIC, Rennes, França, 2015. [<a href="publications/SSTIC2015_French_Paper_Triton_Framework_dexecution_Concolique_FSaudel_JSalwan.pdf">artigo em francês</a>] [<a href="publications/SSTIC2015_English_slide_detailed_version_Triton_Concolic_Execution_FrameWork_FSaudel_JSalwan.pdf">slide detalhado em inglês</a>] <br />
 <b>Autores</b>: Jonathan Salwan, Florent Saudel<br />
 <b>Resumo</b>: <em>Esta palestra é sobre o lançamento do Triton, um framework de execução concólica baseado no Pin. Ele fornece componentes como um motor de taint, um motor de execução simbólica dinâmica, um motor de snapshot, tradução de instruções x64 para SMT2, uma interface Z3 para resolver restrições e bindings Python. Com base nesses componentes, o Triton oferece a possibilidade de construir ferramentas para pesquisa de vulnerabilidades ou assistência em engenharia reversa.</em>
</li><br/>
<li>
<b>Dynamic Behavior Analysis Using Binary Instrumentation</b><br  />
 <b>Apresentado em</b>: St'Hack, Bordeaux, França, 2015. [<a href="publications/StHack2015_Dynamic_Behavior_Analysis_using_Binary_Instrumentation_Jonathan_Salwan.pdf">slide</a>]<br  />
 <b>Autores</b>: Jonathan Salwan<br />
 <b>Resumo</b>: <em>Esta palestra pode ser considerada como a parte 2 da nossa palestra no SecurityDay. Na parte anterior, falamos sobre como era possível cobrir uma função alvo na memória usando a abordagem DSE (Dynamic Symbolic Execution). Cobrir uma função (ou seus estados) não significa encontrar todas as vulnerabilidades; algumas vulnerabilidades não causam crash no programa. É por isso que devemos implementar análises específicas para encontrar bugs específicos. Essas análises são baseadas na instrumentação binária e na análise de comportamento em tempo de execução do programa. Nesta palestra, veremos como é possível encontrar os seguintes tipos de bugs: off-by-one, stack/heap overflow, use-after-free, format string e {write, read}-what-where.</em>
</li><br/>
<li>
<b>Covering a function using a Dynamic Symbolic Execution approach</b><br  />
 <b>Apresentado em</b>: Security Day, Lille, França, 2015. [<a href="publications/SecurityDay2015_dynamic_symbolic_execution_Jonathan_Salwan.pdf">slide</a>]<br  />
 <b>Autores</b>: Jonathan Salwan<br />
 <b>Resumo</b>: <em>Esta palestra é sobre análise binária e instrumentação. Veremos como é possível alocar uma função específica, capturar o contexto de memória/registradores antes da função, traduzir a instrumentação em uma representação intermediária, aplicar uma análise de taint baseada nessa RI, construir/manter fórmulas para uma Execução Simbólica Dinâmica (DSE), gerar um valor concreto para percorrer um caminho específico, restaurar o contexto de memória/registrador e gerar outro valor concreto para percorrer outro caminho, depois repetir essa operação até que a função alvo seja coberta.</em>
</li>
</ul>

## Citar Triton```latex
@inproceedings{SSTIC2015-Saudel-Salwan,
  author    = {Saudel, Florent and Salwan, Jonathan},
  title     = {Triton: A Dynamic Symbolic Execution Framework},
  booktitle = {Symposium sur la s{\'{e}}curit{\'{e}} des technologies de l'information
               et des communications},
  series    = {SSTIC},
  pages     = {31--54},
  address   = {Rennes, France},
  month     = jun,
  year      = {2015},
}
Baixar ferramenta