rellic
Version 0.2.3
O Rellic é uma implementação do algoritmo de estruturação independente de padrões para produzir uma saída C sem goto a partir do LLVM Bitcode.
A filosofia de design por trás do projeto é fornecer uma base de código relativamente pequena e facilmente hackeável, com grande interoperabilidade com outros projetos LLVM e REMILL.
| Programa original | Compilado com -emit-llvm -O0 e descompilado |
int main () {
for ( int i = 0 ; i < 30 ; ++ i ) {
if ( i % 3 == 0 && i % 5 == 0 ) {
printf ( "fizzbuzzn" );
} else if ( i % 3 == 0 ) {
printf ( "fizzn" );
} else if ( i % 5 == 0 ) {
printf ( "buzzn" );
} else {
printf ( "%dn" , i );
}
}
} | int main () {
unsigned int var0 ;
unsigned int i ;
var0 = 0U ;
i = 0U ;
while (( int ) i < 30 ) {
if (( int ) i % 3 != 0U || !(( int ) i % 5 == 0U || ( int ) i % 3 != 0U )) {
if (( int ) i % 3 != 0U ) {
if (( int ) i % 5 != 0U ) {
printf ( "%dn" , i );
} else {
printf ( "buzzn" );
}
} else {
printf ( "fizzn" );
}
} else {
printf ( "fizzbuzzn" );
}
i = i + 1U ;
}
return var0 ;
} |
int main () {
int i = 0 ;
start:
i ++ ;
switch ( i ) {
case 1 : printf ( "%dn" , i ); goto start; break ;
case 2 : printf ( "%dn" , i ); goto start; break ;
case 3 : printf ( "%dn" , i ); break ;
}
} | int main () {
unsigned int var0 ;
unsigned int i ;
var0 = 0U ;
i = 0U ;
do {
i = i + 1U ;
if (!( i != 3U && i != 2U && i != 1U ))
if ( i == 3U ) {
printf ( "%dn" , i );
break ;
} else if ( i == 2U ) {
printf ( "%dn" , i );
} else {
printf ( "%dn" , i );
}
} while (!( i != 3U && i != 2U && i != 1U ));
return var0 ;
} |
int main () {
int x = atoi ( "5" );
if ( x > 10 ) {
while ( x < 20 ) {
x = x + 1 ;
printf ( "loop1 x: %dn" , x );
}
}
while ( x < 20 ) {
x = x + 1 ;
printf ( "loop2 x: %dn" , x );
}
} | int main () {
unsigned int var0 ;
unsigned int x ;
unsigned int call2 ;
var0 = 0U ;
call2 = atoi ( "5" );
x = call2 ;
if (( int ) x > 10 ) {
while (( int ) x < 20 ) {
x = x + 1U ;
printf ( "loop1 x: %dn" , x );
}
}
if (( int ) x <= 10 || ( int ) x >= 20 ) {
while (( int ) x < 20 ) {
x = x + 1U ;
printf ( "loop2 x: %dn" , x );
}
}
if (( int ) x >= 20 && (( int ) x <= 10 || ( int ) x >= 20 )) {
return var0 ;
}
} |
C suas estruturas de dados com rellic-headergen
Decompilação interativa com rellic-xref
Linente: um experimento com decompilação interativa
| mestre | |
|---|---|
| Linux |
Se você está enfrentando problemas sem documentos com a Rellic, peça ajuda no canal #binary-lifting da Flack de hackers do Empire.
O Rellic é suportado em plataformas Linux e foi testado no Ubuntu 22.04.
A maioria das dependências da Rellic pode ser fornecida pelo repositório commaz-common. Trilhas de bits hosts versões para download e pré-criadas do CXX-Common, o que facilita substancialmente a corrida com o Rellic. No entanto, a tabela a seguir representa a maioria das dependências da Rellic.
| Nome | Versão |
|---|---|
| Git | Mais recente |
| Cmake | 3.21+ |
| Bandeiras do Google | Mais recente |
| Google log | Mais recente |
| Llvm | 16 |
| Clang | 16 |
| Z3 | 4.7.1+ |
As imagens do Docker pré-criadas estão disponíveis no Docker Hub e no Registro do Pacote do Github.
Primeiro, atualize a aptidão e instale as dependências da linha de base.
sudo apt update
sudo apt upgrade
sudo apt install
git
python3
wget
unzip
pixz
xz-utils
cmake
curl
build-essential
lsb-release
zlib1g-dev
libomp-dev
doctest-devSe a distribuição em que você está não incluir um lançamento recente do CMake (3.21 ou posterior), você precisará instalá -lo. Para o Ubuntu, veja aqui https://apt.kitware.com/.
O próximo passo é clonar o repositório Rellic.
git clone --recurse-submodules https://github.com/lifting-bits/rellic.git Finalmente, construímos e embalamos o Rellic. Este script criará outro diretório, rellic-build , no diretório de trabalho atual. Todas as dependências restantes necessárias para o Rellic serão baixadas e colocadas no diretório pai ao lado do check-out de repo no lifting-bits-downloads (consulte a opção -h do script para obter mais detalhes). Este script também cria pacotes installáveis de DeB, RPM e TGZ.
cd rellic
./scripts/build.sh --llvm-version 16
# to install the deb package, then do:
sudo dpkg -i rellic-build/ * .debPara experimentar o Rellic, você pode fazer o seguinte, dado um arquivo de bitcode LLVM de sua escolha.
# Create some sample bitcode or your own
clang-16 -emit-llvm -c ./tests/tools/decomp/issue_4.c -o ./tests/tools/decomp/issue_4.bc
./rellic-build/tools/rellic-decomp --input ./tests/tools/decomp/issue_4.bc --output /dev/stdoutCertifique-se de ter o último lançamento do CXX-Common para LLVM 16. Então, construa com
cmake
-DCMAKE_BUILD_TYPE=RelWithDebInfo
-DCMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake
-DVCPKG_TARGET_TRIPLET=x64-osx-rel
-DRELLIC_ENABLE_TESTING=OFF
-DCMAKE_C_COMPILER= ` which clang `
-DCMAKE_CXX_COMPILER= ` which clang++ `
/path/to/rellic
make -j8A imagem do Docker deve fornecer um ambiente que possa configurar, construir e executar o Rellic. As imagens do Docker são parametrizadas pela versão Ubuntu Verison, LLVM e arquitetura.
Para construir a imagem do docker usando o LLVM 16 para o Ubuntu 22.04, você pode executar o seguinte comando:
UBUNTU=22.04 ; LLVM=16 ; docker build .
-t rellic:llvm ${LLVM} -ubuntu ${UBUNTU}
-f Dockerfile
--build-arg UBUNTU_VERSION= ${UBUNTU}
--build-arg LLVM_VERSION= ${LLVM}Para executar o decompilador, o ponto de entrada já foi definido, mas verifique se o código de bits que você está descompidando é a mesma versão LLVM que o decompilador e execute:
# Get the bc file
clang-16 -emit-llvm -c ./tests/tools/decomp/issue_4.c -o ./tests/tools/decomp/issue_4.bc
# Decompile
docker run --rm -t -i
-v $( pwd ) :/test -w /test
-u $( id -u ) : $( id -g )
rellic:llvm16-ubuntu22.04 --input ./tests/tools/decomp/issue_4.bc --output /dev/stdoutPara explicar mais o comando acima:
# Mount current directory and change working directory
-v $( pwd ) :/test -w /teste
# Set the user to current user to ensure correct permissions
-u $( id -u ) : $( id -g ) Utilizamos vários testes de integração e unidade para testar o Rellic.
Os testes de ida e volta levarão o código C, a criarão para o LLVM IR e depois traduzirão que o IR de volta para C. O teste vê se o C resultante poderá ser construído e se o código traduzido (aproximadamente) a mesma coisa que o original. Para executá -los, use:
cd rellic-build # or your rellic build directory
CTEST_OUTPUT_ON_FAILURE=1 cmake --build . --verbose --target test Anghabench 1000 é uma amostra de 1000 arquivos (arquiteturas x 4, portanto, um total de 4000 testes) a partir dos programas completos de milhões que acompanham o Anghabench. Este teste verifica apenas se o Bitcode para esses programas se traduz em C, não a beleza ou funcionalidade da tradução resultante. Para executar este teste, primeiro instale as dependências Python necessárias encontradas nos scripts/requirements.txt e depois execute:
scripts/test-angha-1k.sh --rellic-cmd < path_to_rellic_decompiler_exe > Por favor, use o seguinte snippet bibtex para citar o Rellic:
@online{rellic,
title={Rellic},
author={Surovič, Marek and Bertolaccini, Francesco},
organization={Trail of Bits},
url={https://github.com/lifting-bits/rellic}
}
