Radare2 dicas de uso, notícias, etc.

[gzn]

Como pesquisar por comandos e subcomandos?

?*~<expressão>

 ?*~current function
| $F            current function size
| x @@b               run 'x' on all basic blocks of current function (see afb)
| x @@i               run 'x' on all instructions of the current function (see pdr)
| x @@=`pdf~call[0]`  run 'x' at every call offset of the current function
| aeaf        Show regs used in current function
| afB 16                                set current function as thumb (change asm.bits)
| afc convention  Manually set calling convention for current function
| afcr[j]         Show register usage for the current function
| afns        list all strings associated with the current function
| axg [addr]      show xrefs graph to reach current function
| pxf               show hexdump of current function
| sf.               Seek to the beginning of current function

Obs.: ~ (til) chama o grep interno para você poder filtrar os dados.

[gzn]

Search For All referenced text strings? (recurso do Ollydbg)

Como fazer algo parecido no radare?

pd 2 @@=`axt @@ str.* ~[1]`'

14
|           0x56446be70768      488d3d790100.  lea rdi, str.Defuse_the_bomb_with_the_right_sequece_of_secret_numbers ; 0x56446be708e8 ; "[*] Defuse the bomb with the right sequece of secret numbers "
|           0x56446be7076f      e87cfeffff     call sym.imp.puts       ; int puts(const char *s)
|           0x56446be70774      488d3dab0100.  lea rdi, str.Enter_the_first_number: ; 0x56446be70926 ; "[+] Enter the first number: "
|           0x56446be7077b      b800000000     mov eax, 0
|           0x56446be707ab      488d3d940100.  lea rdi, str.Enter_the_second_number: ; 0x56446be70946 ; "[+] Enter the second number: "
|           0x56446be707b2      b800000000     mov eax, 0
|           0x56446be707dc      488d3d810100.  lea rdi, str.Enter_the_third_number: ; 0x56446be70964 ; "[+] Enter the third number: "
|           0x56446be707e3      b800000000     mov eax, 0
|           0x56446be7080f      488d3d6b0100.  lea rdi, str.Bomb_defused ; 0x56446be70981 ; "[+] Bomb defused"
|           0x56446be70816      e8d5fdffff     call sym.imp.puts       ; int puts(const char *s)
|           0x56446be70826      488d3d6b0100.  lea rdi, str.shellter_yeah_th3_s3qu3nc3_1s:__d__d__d ; 0x56446be70998 ; "[+] shellter{yeah_th3_s3qu3nc3_1s:(%d_%d_%d)} \n"
|           0x56446be7082d      b800000000     mov eax, 0
|           0x56446be7083e      488d3d830100.  lea rdi, str.BOOM__You_re_dead_x.x ; 0x56446be709c8 ; "[BOOM] You're dead x.x! "
|           0x56446be70845      e8a6fdffff     call sym.imp.puts       ; int puts(const char *s)
[*] Defuse the bomb with the right sequece of secret numbers 
[+] Enter the first number: [BOOM] You're dead x.x! 

Comandos usados:

pd N disassemble N instructions
axt [addr] find data/code references to this address

E o que é a expressão "@@=" ?

Com essa expressão dá pra gente montar uma lista de endereços e trabalhar em cima delas. Nesse caso usamos os endereços que referenciam strings (str).

Obs.: lembre-se que para você ter o resultado de um comando como argumento de outro você deve colocar o comando dentro de dois acentos graves (igual em shells como bash).

E o que é a expressão "~[1]"?

Você já usou o grep? Se já essa expressão é quase um grep! O til chama o "grep" interno e [1] seleciona a segunda coluna (começa do 0). Se você quisesse a primeira linha usaria a expressão ":0", sem as aspas.

 

 

[gzn]

Search for all Intermodular calls (recurso do OllyDbg)?

Você pode fazer algo parecido no radare com:

pd 2 @@=`axt @@@i~[1]`

 

8
|           0x5629e1b6c76f      e87cfeffff     call sym.imp.puts       ; int puts(const char *s)
|           0x5629e1b6c774      488d3dab0100.  lea rdi, str.Enter_the_first_number: ; 0x5629e1b6c926 ; "[+] Enter the first number: "
|           0x5629e1b6c845      e8a6fdffff     call sym.imp.puts       ; int puts(const char *s)
|           0x5629e1b6c84a      b800000000     mov eax, 0
|           0x5629e1b6c816      e8d5fdffff     call sym.imp.puts       ; int puts(const char *s)
|           0x5629e1b6c81b      8b4df4         mov ecx, dword [local_ch]
|           0x5629e1b6c780      e87bfeffff     call sym.imp.printf     ; int printf(const char *format)
|           0x5629e1b6c785      488d45fc       lea rax, [local_4h]
|           0x5629e1b6c7b7      e844feffff     call sym.imp.printf     ; int printf(const char *format)
|           0x5629e1b6c7bc      488d45f8       lea rax, [local_8h]
|           0x5629e1b6c7e8      e813feffff     call sym.imp.printf     ; int printf(const char *format)
|           0x5629e1b6c7ed      488d45f4       lea rax, [local_ch]
|           0x5629e1b6c832      e8c9fdffff     call sym.imp.printf     ; int printf(const char *format)
|           0x5629e1b6c837      b801000000     mov eax, 1
|           0x5629e1b6c798      e873feffff     call sym.imp.__isoc99_scanf
|           0x5629e1b6c79d      8b45fc         mov eax, dword [local_4h]
|           0x5629e1b6c7cf      e83cfeffff     call sym.imp.__isoc99_scanf
|           0x5629e1b6c7d4      8b45f8         mov eax, dword [local_8h]
|           0x5629e1b6c800      e80bfeffff     call sym.imp.__isoc99_scanf
|           0x5629e1b6c805      8b45f4         mov eax, dword [local_ch]
[*] Defuse the bomb with the right sequece of secret numbers 
[+] Enter the first number: [BOOM] You're dead x.x! 

Note que eu decidi imprimir duas instruções depois da referência (veja, é inclusivo, incluindo a própria referência), eu até acharia melhor imprimir duas antes.
Como fazer isso? Simples, ao invés de pd 2 você digita pd -2!

[gzn]

Visualizando variáveis locais (que estão na pilha) de uma forma mais inteligível

r2 -c 'db sym.main;dc;v!' -AAd binario

O comando "v!" entra no modo visual com paineis, com ele você pode criar novos paineis com o comando que quiser. Eu particularmente acho útil criar um comando para visualização do "afvd":

afv?
...
afvd name                   output r2 command for displaying the value of args/locals in the debugger
...

Basicamente você deve digitar M, coloca um nome, por exemplo "Variáveis locais", depois o comando (que nesse caso é o afvd). Note que você pode rearranjar os painéis navegando por eles pelo TAB e apertando ENTER no que você quer dar maior foco.

 

[gzn]

Imprimir desmontagem de referências `a chamadas intermodulares com contexto?

Não entendeu?

objdump -d binario | grep -C 2 call

É mais ou menos isso daí de cima...

Primeiro defina uma macro que:

• volta duas instruções a partir da referência atual (so -2)
• imprime 5 instruções (pd 5)
• imprimir um espaço para facilitar a leitura (echo '')

(grepc2, so -2, pd 5, echo '', echo '')

O nome que eu criei é grep + c (de contexto) + 2 (duas antes e duas depois).

Agora é só chamar a macro:

.(grepc2) @@=`axt @@@i~[1]`

 

[gzn]

Como ter a última versão do radare e ter um ambiente minimamente isolado para analisar binários?

Que tal usar o docker com uma imagem com o radare atualizado?

sudo apt install -y docker-compose
sudo docker pull radare/radare2
mkdir sandbox
cd sandbox

Agora um script para simplificar a sua vida (vou chamá-lo de r2docker):

#!/bin/sh

imagem='radare/radare2'
container='radare'
if sudo docker container ls -a|egrep Exited.+$container
then
    echo reiniciando
    sudo docker start $container
elif ! sudo docker container ls -a|egrep Up.+$container
then
    echo iniciando
    sudo docker run --name $container --cap-drop=ALL --cap-add=SYS_PTRACE -v $PWD:/home/r2/ -id $imagem
fi
sudo docker exec -it $container bash

Torne-o executável:

chmod +x r2docker

Agora é só entrar nesse ambiente e fazer os seus experimentos:

wget https://shellter-static.s3.amazonaws.com/media/files/7dd461ae-89bf-49c0-a7a3-4148bd788599.bomb -O bomb
./r2docker
r2@d0d325823847:~$ ls
bomb
r2@d0d325823847:~$ r2 -dAA bomb

Para atualizar a imagem do radare é bem simples, basta você parar o container e fazer o pull:

sudo docker container stop radare
sudo docker pull radare/radare2

Então, o que você acha disso?

Eu particularmente mesmo que os binários que eu vá analisar não sejam perigosos eu não gosto de bagunçar meu ambiente principal de trabalho (tudo que faço nele procuro instalar via gerenciador de pacotes para se quiser mais tarde desinstalar o que instalei com facilidade!). Como meu PC é muito lento pra rodar uma VM essa é uma boa alternativa.

 

[gzn]

Como encontrar a main de alguns arquivos executáveis?

No caso da instrução usada para especificar o primeiro argumento da __libc_start_main seja MOV:

Usando a fonte ola_mundo.c e as opções de compilação nesse Makefile:

r2@d0d325823847:~$ r2 -qc 's entry0+0x20;pxw 4~[1]' ola_mundo
0x00400430

Claro que se for fazer a análise dinamicamente fica mais fácil! 

Se estamos falando de um ELF de 64 bits vamos olhar para RDI onde está o endereço da main. Como olhar seu valor antes da call __libc_start_main?

1. Primeiro inicie o radare com -d (análise dinâmica requer modo de depuração)
2. Geralmente o radare já deixa você no ponto de entrada do binário se ele for um executável mesmo, mas se por algum motivo estranho ele não estiver lá, digite s entry0
3. Faça uma análise básica para descobrir as funções (use af)
4. Agora coloque um ponto de parada na primeira call (que provavelmente será para __libc_start_main) com comando db ` pdf~call:0[1]` 
5. Continue a execução com comando dc
6. Agora inspecione o registrador RDI com dr~rdi
7. Lembre-se que você pode fazer todos estes passos pela linha de comando de forma automática! (deixo para exercício)

Achou engraçado isso tudo só para pegar aquele enderecinho?! rsrs

Bom isso tudo é só pra você ir treinando um pouco e saber o que cada comando acima faz! Boa diversão e continue praticando! 

[gzn]

Integrando o snowman com radare2

r2pm init
sudo apt-get install libboost-dev libqt4-dev cmake build-essential
r2pm install r2snow

Se você usa o vagrant lembre-se de adicionar mais memória porque o padrão de 1 GiB não é suficiente para compilar o snowman, coloque uns 2 GiB e as chances serão maiores de você compilar esse negócio.

Depois de compilar ele você simplesmente carrega seu binário no radare e digita !r2snow. No diretório em que você executou esse script aparecerá alguns arquivos como: r2snow-addrof.txt,  r2snow-source.c e  r2snow-source.c.txt.

[gzn]

GSoC 2018 do radare

Esse ano o negócio promete mesmo!

Esse ano são seis participantes que vão trabalhar no radare2, no radeco também no cutter (a interface gráfica do radare ).

• Dois vão estar trabalhando na biblioteca de decompilação radeco-lib e integrando ela ao radare2
• Outros dois vão estar trabalhando no radare2 um na interface e o outro melhorando o suporte a estruturas
• E um vai estar trabalhando na GUI do radare (você que tem medo do radare porque ele opera principalmente pela CLI agora vai poder usar melhor a GUI dele!)

 

 

 

[Fernando Mercês]

UAU! Que notícia hein! E é impressionante ver o "r2 master" que você se tornou! ?

Abraço e obrigado por compartilhar. Esse tópico tá lindo!

[gzn]

kkkkkkk valeu meu amigo @Fernando Mercês! sou só um pequeno gafanhoto rsrs

vlw pelas palavras de motivação! 

 

[gzn]

Como visualizar as configurações em uso no radare?

É só digitar e*~padrão. Obs.: substitua padrão por qualquer texto que queira encontrar (é uma expressão regular).

[0x0804845c]> e*~symbol
"e asm.symbol = false"
"e asm.symbol.col = 40"
"e pdb.server = https://msdl.microsoft.com/download/symbols"

Para listar todas as configurações e usar o paginador interno apenas digite e*~..

"e anal.a2f = false"
"e anal.afterjmp = true"
"e anal.arch = x86"
"e anal.armthumb = false"
"e anal.autoname = true"
"e anal.bb.align = 0x10"
"e anal.bb.maxsize = 1024"
"e anal.bb.split = true"
"e anal.brokenrefs = false"
"e anal.calls = false"
"e anal.cjmpref = false"
"e anal.cpp.abi = itanium"
"e anal.cpu = x86"
"e anal.datarefs = false"
"e anal.depth = 64"
"e anal.eobjmp = false"
"e anal.esil = false"
"e anal.fcnprefix = fcn"
"e anal.from = 0xffffffffffffffff"
"e anal.gp = 0"
"e anal.gp2 = 0"
"e anal.hasnext = false"
"e anal.hpskip = false"
"e anal.ijmp = false"
"e anal.in = io.maps"
[...]

 

[gzn]

Assembly com descrição

Digite e asm.describe=true

[0x0804845c]> pdf
/ (fcn) main 94
|   main (int arg_ch);
|           ; var int local_8h @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_ch @ ebp+0xc
|           ; DATA XREF from 0x080483af (entry0)
|           0x0804845c b    55             push ebp                    ; push word, doubleword or quadword onto the stack
|           0x0804845d      89e5           mov ebp, esp                ; moves data from src to dst
|           0x0804845f      83ec18         sub esp, 0x18               ; substract src and dst, stores result on dst
|           0x08048462      83e4f0         and esp, 0xfffffff0         ; binary and operation between src and dst, stores result on dst
|           0x08048465      b800000000     mov eax, 0                  ; moves data from src to dst
|           0x0804846a      83c00f         add eax, 0xf                ; adds src and dst, stores result on dst
|           0x0804846d      83c00f         add eax, 0xf                ; adds src and dst, stores result on dst
|           0x08048470      c1e804         shr eax, 4                  ; logic right shift (0 padding)
|           0x08048473      c1e004         shl eax, 4                  ; logic left shift (0 padding)
|           0x08048476      29c4           sub esp, eax                ; substract src and dst, stores result on dst
|           0x08048478      c745f8000000.  mov dword [local_8h], 0     ; moves data from src to dst
|           0x0804847f      c745fcdec052.  mov dword [local_4h], 0x5e52c0de ; moves data from src to dst
|           0x08048486      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12 ; moves data from src to dst
|           0x08048489      83c004         add eax, 4                  ; adds src and dst, stores result on dst
|           0x0804848c      8b00           mov eax, dword [eax]        ; moves data from src to dst
[...]

Essa configuração é muito útil para quando a gente está começando a entender código assembly.

[gzn]

Como fazer um simples patch com radare?

Asciinema: https://asciinema.org/a/180843.

Como exemplo foi usado o seguinte desafio: https://shellterlabs.com/pt/questions/quals-2009/access-pass/.

Comandos novos utilizados:

wa[?] push ebp       write opcode, separated by ';' (use '"' around the command)

Comandos que poderiam ser utilizados:

Para saber quantos bytes o opcode jmp 0x62d e seu argumento ocuparia:

!rasm2 jmp 0x62d|egrep -o '.{2}'|wc -l

Para saber quantos bytes tem uma instrução faça um seek em algum endereço onde há a instrução que você quer e digite:

? $l

 

[gzn]

Gerando assinaturas de funções

Já teve casos em que você queria analisar um binário ligado estaticamente cujos símbolos foram removidos?

Vamos a um exemplo de caso:

// main.c
int main(int argc, char *argv[]){
    puts("Olá");
    return 0;
}

Vamos gerar um executável dele com os símbolos e um sem.

$ gcc -static -o main main.c
$ cp main{,2}
$ strip -s main2

Vamos abrir o main (que tem os símbolos) e gerar assinaturas com base nas funções encontradas nele:

$ r2 -qc 'aaf;zg;z* > main.r2' main
$ head main.r2
zs *
za fcn.0047f498 b e8........4883c4084889c34889df5b5de9........
za fcn.0047f498 g cc=2 nbbs=1 edges=1 ebbs=0
za fcn.0047f498 o 0x0047f498
za fcn.0047f498 r sym._dl_allocate_tls_storage sym._dl_allocate_tls_storage sym._dl_allocate_tls_init
zs *
za fcn.0041f650 b 4883c41831d24889d05b5dc3
za fcn.0041f650 g cc=1 nbbs=1 edges=0 ebbs=1
za fcn.0041f650 o 0x0041f650
zs *

• aaf: tenta encontrar todas as funções
• zg: gera as assinaturas
• z*: mostra na tela (stdout) as assinaturas com a sintaxe do radare, redirecionamos para o arquivo main.r2

Agora vamos abrir o binário que está sem símbolos (main2) mas que sabemos usar a mesma bibliotecas que usamos no que está com símbolos (main):

r2 -qc '. main.r2;z/;aaa;pdf @ `axt @ sign.bytes.sym.puts_0 ~[1]`' main2
            ;-- main:
┌ (fcn) sign.bytes.sym.main_0 34
│   sign.bytes.sym.main_0 ();
│           ; var int local_10h @ rbp-0x10
│           ; var int local_4h @ rbp-0x4
│           ; DATA XREF from 0x00400a4d (entry0)
│           0x00400b4d      55             push rbp
│           0x00400b4e      4889e5         mov rbp, rsp
│           0x00400b51      4883ec10       sub rsp, 0x10
│           0x00400b55      897dfc         mov dword [local_4h], edi
│           0x00400b58      488975f0       mov qword [local_10h], rsi
│           0x00400b5c      488d3da11509.  lea rdi, [0x00492104]       ; "Ol\u00e1"
│           0x00400b63      e8a8f60000     call sign.bytes.sym.puts_0
│           0x00400b68      b800000000     mov eax, 0
│           0x00400b6d      c9             leave
└           0x00400b6e      c3             ret

• . main.r2: carrega as assinaturas
• z/: analisa a memória a procura das assinaturas
• aaa: encontra funções e nomeia elas automaticamente
• pdf @ `axt @ sign.bytes.sym.puts_0 ~[1]`': mostra o disassembly da função que tiver o endereço sign.bytes.sym.puts_0

Para ver as assinaturas e fazer um grep, faça o seguinte:

fs sign
f ~puts
0x00410210 407 sign.bytes.sym.puts_0
0x0046f6d0 311 sign.bytes.sym._IO_fputs_0

 

[gzn]

Como usar um decompilador com radare2?

Um dos melhores decompiladores que já testei até o momento foi o retdec, segue abaixo um simples script que pode ser adaptado para você instalar o retdec na sua máquina.

# retdec
[ -d retdec ] || git clone https://github.com/avast-tl/retdec.git
pushd retdec
sudo apt-get install build-essential cmake git perl python3 bash bison flex
autoconf automake libtool pkg-config m4 coreutils zlib1g-dev libtinfo-dev wget
bc upx doxygen graphviz nodejs npm 
cd retdec
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=/opt/retdec
make
sudo make install
for f in /opt/retdec/bin/*
do
    sudo ln -s $f /bin/$(basename $f)
done                                                                                                                                                  
echo /opt/retdec/bin/retdec-decompiler.sh | tee ~/.r2retdec
r2pm init
r2pm -i r2retdec
popd

https://asciinema.org/a/QbyBxxgTKy9oL6uw3aP0lDVhD

[gzn]

Como procurar por instruções?

vagrant@ubuntu-bionic:/vagrant$ r2 /bin/ls
 -- This is just an existentialist experiment.
[0x00005850]> /a push 0
Searching 2 bytes in [0x0-0x1e6e8]
hits: 10
Searching 2 bytes in [0x21eff0-0x221560]
hits: 2
0x000010b8 hit0_0 6a00
0x00001b79 hit0_1 6a00
0x00001cf9 hit0_2 6a00
0x0000365c hit0_3 6a00
0x00003e27 hit0_4 6a00
0x0000442b hit0_5 6a00
0x000082db hit0_6 6a00
0x00012d15 hit0_7 6a00
0x0001d0dc hit0_8 6a00
0x0001e2c4 hit0_9 6a00
0x0021f089 hit0_10 6a00
0x0021f129 hit0_11 6a00

Veja que foi gerado uma lista com algumas informações: o endereço onde foi encontrado a instrução, uma flag associada ao endereço, os bytes da instrução.

Com isso nós podemos por exemplo, imprimir o disassembly da instrução em cada um desses endereços:

[0x00005850]> pd 1 @@ hit0*
            ;-- hit0_0:
            0x000010b8      6a00           push 0
            ;-- hit0_1:
            0x00001b79      6a00           push 0
            ;-- hit0_2:
            0x00001cf9      6a00           push 0
            ;-- hit0_3:
            0x0000365c      6a00           push 0
            ;-- hit0_4:
            0x00003e27      6a00           push 0
            ;-- hit0_5:
            0x0000442b      6a00           push 0
            ;-- hit0_6:
            0x000082db      6a00           push 0
            ;-- hit0_7:
            0x00012d15      6a00           push 0
            ;-- hit0_8:
            0x0001d0dc      6a00           push 0
            ;-- hit0_9:
            0x0001e2c4      6a00           push 0
            ;-- hit0_10:
            0x0021f089      6a00           push 0
            ;-- hit0_11:
            0x0021f129      6a00           push 0
[0x00005850]> 

O padrão hit0* expande para todos as flags que começam com hit0. O comando pd 1 imprime o disassembly de uma instrução no endereço atual.

Veja, essa técnica é útil também para casos em que você quer aplicar um simples patch em vários endereços que tenham uma dada instrução (talvez uma chamada de função, um salto condicional, etc.).

Dá também para procurar pelo tipo de instrução:

[0x00005850]> /A push
0x000002b0 5 push 0xd0
0x00000f48 5 push 0x2202
0x000010b8 2 push 0
0x00001211 5 push 0x72747300
0x00001236 5 push 0x61657200
0x0000126e 5 push 0x6c6e755f
0x000014c6 5 push 0x6b6e75
0x0000174d 5 push 0x6569645f
0x00001b08 5 push 0x21f0
0x00001b79 2 push 0
0x00001c28 4 enter 0x21f0, 0
0x00001da8 5 push 0x21f1
0x00001ec8 4 enter 0x21f1, 0
0x000020f0 4 enter 0x21f2, 0
0x00002130 2 push 0xffffffffffffff80
0x00002990 5 push 0x2200
0x00002a98 5 push 0x2201
0x00003338 5 push 0x21fe
0x00003638 5 push 0x21ff
0x00003786 5 push 0
0x00003796 5 push 1
0x000037a6 5 push 2
0x000037b6 5 push 3
0x000037c6 5 push 4
0x000037d6 5 push 5
0x000037e6 5 push 6
0x000037f6 5 push 7
0x00003806 5 push 8
0x00003816 5 push 9
...

Se for a primeira vez que você faz esse tipo de pesquisa as flags começarão com hit0, se for a segunda, hit1, e assim por diante:

[0x00005850]> pd 1 @@ hit0*
            ;-- hit0_0:
            0x000002b0      68d0000000     push 0xd0
            ;-- hit0_1:
            0x00000f48      6802220000     push 0x2202
            ;-- hit0_2:
            0x000010b8      6a00           push 0
            ;-- hit0_3:
            0x00001211      6800737472     push 0x72747300
            ;-- hit0_4:
            0x00001236      6800726561     push 0x61657200
            ;-- hit0_5:
            0x0000126e      685f756e6c     push 0x6c6e755f
            ;-- hit0_6:
            0x000014c6      68756e6b00     push 0x6b6e75
            ;-- hit0_7:
            0x0000174d      685f646965     push 0x6569645f
            ;-- hit0_8:
            0x00001b08      68f0210000     push 0x21f0
            ;-- hit0_9:
            0x00001b79      6a00           push 0
            ;-- hit0_10:
            0x00001c28      c8f02100       enter 0x21f0, 0
...

Quais são os tipos suportados para passar para /A?

[0x00005850]> /A?|sort|column -c80
acmp	cmp	io	mod	not	ret	shl	switch	unk
add	cpl	jmp	mov	null	rol	shr	sync	upush
and	crypto	lea	mul	or	ror	store	trap	xchg
call	div	leave	new	pop	sal	sub	ucall	xor
case	ill	load	nop	push	sar	swi	ujmp