XDA

Introdução

XDA é uma ferramenta para desmontar instruções e recuperar limites de funções de binários removidos. É baseado na aprendizagem por transferência usando o codificador Transformer com objetivo de modelagem de linguagem mascarada [1, 2, 3]. Ele supera ferramentas de última geração (por exemplo, IDA Pro, Ghidra e RNN bidirecional [4]). Encontre os detalhes em nosso artigo: XDA: Desmontagem precisa e robusta com aprendizagem por transferência

 @inproceedings{pei2021xda,
    title={XDA: Accurate, Robust Disassembly with Transfer Learning},
    author={Pei, Kexin and Guan, Jonas and King, David Williams and Yang, Junfeng and Jana, Suman},
    year={2021},
    booktitle={Proceedings of the 2021 Network and Distributed System Security Symposium (NDSS)}
}

Instalação

Recomendamos usar conda para configurar o ambiente e instalar os pacotes necessários.

Primeiro, crie o ambiente conda,

conda create -n xda python=3.7 numpy scipy scikit-learn colorama

e ative o ambiente conda:

conda activate xda

Em seguida, instale o Pytorch mais recente (suponha que você tenha GPU):

conda install pytorch torchvision torchaudio cudatoolkit=11.0 -c pytorch

Finalmente, entre no diretório raiz do xda: por exemplo, path/to/xda e instale o XDA:

pip install --editable .

Preparação

Modelos pré-treinados:

Crie os checkpoints e o subdiretório checkpoints/pretrain_all em path/to/xda

mkdir -p checkpoints/pretrain_all

Baixe nossos parâmetros de peso pré-treinados e coloque checkpoints/pretrain_all

• 19/01/2022: Carregou um novo peso pré-treinado dedicado para binários Linux x64 compilados por GCC e Clang

Modelos ajustados:

Também fornecemos o modelo ajustado para você atuar diretamente na recuperação do limite da função. O modelo ajustado é treinado em binários compilados pelo MSVC x64. Crie o subdiretório checkpoints/finetune_msvs_funcbound_64 em path/to/xda

mkdir -p checkpoints/finetune_msvs_funcbound_64

Baixe nossos parâmetros de peso ajustados e coloque checkpoints/finetune_msvs_funcbound_64 .

• 04/11/2024: Carregados novos parâmetros de peso ajustados para previsão de limite de instrução elf (não testado, pode ser impreciso).

Brinque com o modelo ajustado

Colocamos alguns dados de amostra do corpus BAP compilado por MSVC x64 em data-raw/msvs_funcbound_64_bap_test . Existem duas colunas nos arquivos de dados. A primeira coluna contém todos os bytes brutos do binário e a segunda coluna é o rótulo que indica o início da função (F), o fim da função (R) ou nenhum dos dois.

Para prever o limite da função nesses arquivos, execute:

python scripts/play/play_func_bound.py

Esses scripts carregarão os pesos ajustados que você colocou em checkpoints/finetune_msvs_funcbound_64 e preverão os limites da função. Também será comparado com a verdade e os resultados da IDA.

Dados de amostra com limites de função

Fornecemos exemplos de arquivos de treinamento/teste de pré-treinamento e ajuste fino em data-src/

• data-src/pretrain_all contém os bytes brutos de amostra de binários removidos para pré-treinamento
• data-src/funcbound contém os bytes brutos de amostra com limites de função

Já fornecemos modelos pré-treinados em um grande número de binários. Mas se você quiser pré-treinar seus próprios dados coletados, você pode preparar os arquivos de amostra semelhantes ao formato em data-src/pretrain_all (concatenar todos os bytes de todos os binários e delimitar por uma nova linha n para garantir que cada linha não exceder o comprimento máximo que o modelo aceita). Da mesma forma, se você mesmo quiser preparar os dados de ajuste fino, certifique-se de seguir o formato mostrado em data-src/funcbound .

Temos que binarizar os dados para deixá-los prontos para serem treinados. Para binarizar os dados de treinamento para pré-treinamento, execute:

./scripts/pretrain/preprocess-pretrain-all.sh

Os dados de treinamento binarizados prontos para pré-treinamento serão armazenados em data-bin/pretrain_all

Para binarizar os dados de treinamento para ajuste fino, execute:

./scripts/finetune/preprocess.sh

Os dados de treinamento binarizados prontos para ajuste fino (para limite de função) serão armazenados em data-bin/funcbound

Treinamento

Se você estiver usando seus próprios binários analisados ​​para pré-treinamento e já os binarizou em data-bin/pretrain_all , execute:

./scripts/pretrain/pretrain-all.sh

Para ajustar o modelo, execute:

./scripts/finetune/finetune.sh

Os scripts carregam os parâmetros de peso pré-treinados de checkpoints/pretrain_all/ e ajustam o modelo.

Linha de base RNN

• A implementação do bi-RNN é lançada em ./bi-RNN/
• Para executar, baixe nosso exemplo de treinamento do conjunto de dados SPEC 2017 O1 processado, teste e coloque em birnn/

Avaliação de velocidade

Para avaliação de velocidade, coloquei um script em https://github.com/CUMLSec/XDA/blob/main/scripts/play/speed_eval.py

Referências

[1] Vaswani, Ashish, et al. "Atenção é tudo que você precisa." Avanços em sistemas de processamento de informações neurais. 2017.

[2] Devlin, Jacob, et al. "Bert: Pré-treinamento de transformadores bidirecionais profundos para compreensão da linguagem." Pré-impressão do arXiv arXiv:1810.04805 (2018).

[3] Liu, Yinhan, et al. "Roberta: Uma abordagem de pré-treinamento bert robustamente otimizada." pré-impressão arXiv arXiv:1907.11692 (2019).

[4] Shin, Eui Chul Richard, Dawn Song e Reza Moazzezi. "Reconhecendo funções em binários com redes neurais." 24º Simpósio de Segurança USENIX. 2015.