Transformar Saída do objdump Em Shellcode

Introdução

Quem já precisou transformar a saída do objdump em uma shellcode, sabe do trabalho que dá. É muito chato pegar byte por byte para montar a shellcode, e em alguns casos, acontece de esquecermos alguns bytes, fazendo a shellcode não funcionar.

Hoje irei apresentar um método usando somente comandos padrões do linux para transformar a saída do objdump em uma shellcode.

Shellcode?

Shellcode é um pequeno pedaço de código usado para explorar uma aplicação vulnerável e na maioria das vezes seu objetivo é rodar uma shell (daí o nome shellcode). Como as shellcodes realizam funções específicas, é muito fácil encontrá-las prontas na Internet. Sites como [2], mantém muitas shellcodes em seus bancos de dados.

Em geral, um programa em C ou em assembly é escrito e em seguida compilado, e à partir dos códigos de máquina desse programa, a shellcode é gerada. Esse processo, feito de forma manual é muito cansativo, principalmente quando a shellcode é grande, e também muito passível de erros.

objdump

objdump, como o nome já sugere, mostra (“dump“) informações de arquivos binários. Essas informações são as mais diversas possíveis, e para esse post a mais importante é a capacidade de mostrar o código de máquina do binário assim como as instruções em assembly correspondentes.

Obtendo a shellcode através do objdump

Esse post é baseado totalmente na ideia apresenta por gunslinger_ em [1]. O que irei fazer aqui é um passo a passo de como a sequência de comandos funciona.

Bem, como exemplo irei usar o seguinte programa em assembly para obter uma shellcode:

.text

.globl _start
_start:

push $0xb
pop %eax
cltd
push %edx
push $0x68732f2f
push $0x6e69622f
movl %esp, %ebx
xorl %ecx, %ecx
int $0x80

O que esse programa faz é executar a syscall execve para executar uma shell (/bin/sh). Vamos compilá-lo:

$ as -gstabs -o prog.o prog.s
$ ld -o prog prog.o

O executável prog foi criado. Agora vamos ver a saída do objdump em cima desse arquivo:

$ objdump -d prog
prog:     file format elf32-i386

Disassembly of section .text:

08048054 <_start>:
 8048054:	6a 0b                	push   $0xb
 8048056:	58                   	pop    %eax
 8048057:	99                   	cltd
 8048058:	52                   	push   %edx
 8048059:	68 2f 2f 73 68       	push   $0x68732f2f
 804805e:	68 2f 62 69 6e       	push   $0x6e69622f
 8048063:	89 e3                	mov    %esp,%ebx
 8048065:	31 c9                	xor    %ecx,%ecx
 8048067:	cd 80                	int    $0x80

A sequência de bytes “6a 0b 58 … cd 80” é a nossa shellcode. Vamos usar o grep para selecionar somente as linhas da shellcode:

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file
 8048054:	6a 0b                	push   $0xb
 8048056:	58                   	pop    %eax
 8048057:	99                   	cltd
 8048058:	52                   	push   %edx
 8048059:	68 2f 2f 73 68       	push   $0x68732f2f
 804805e:	68 2f 62 69 6e       	push   $0x6e69622f
 8048063:	89 e3                	mov    %esp,%ebx
 8048065:	31 c9                	xor    %ecx,%ecx
 8048067:	cd 80                	int    $0x80

Agora vamos deletar os endereços que estão antes do ‘:’:

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file | cut -f2 -d ':'
	6a 0b                	push   $0xb
	58                   	pop    %eax
	99                   	cltd
	52                   	push   %edx
	68 2f 2f 73 68       	push   $0x68732f2f
	68 2f 62 69 6e       	push   $0x6e69622f
	89 e3                	mov    %esp,%ebx
	31 c9                	xor    %ecx,%ecx
	cd 80                	int    $0x80

O que sobrou foram os códigos de máquina e as instruções em assembly correspondentes. Para extrair somente o código de máquina, podemos considerar somente os 6 primeiros campos da linha tendo o espaço como separador.

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file | cut -f2 -d ':' | cut -f1-6 -d' '
	6a 0b
	58
	99
	52
	68 2f 2f 73 68
	68 2f 62 69 6e
	89 e3
	31 c9
	cd 80

Por fim só falta formatarmos essa saída. Primeiro retiramos os espaços desnecessários:

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file | cut -f2 -d ':' | cut -f1-6 -d' ' | tr -s ' ' | tr '\t' ' '
 6a 0b
 58
 99
 52
 68 2f 2f 73 68
 68 2f 62 69 6e
 89 e3
 31 c9
 cd 80

e usamos o sed para adicionar o \x no início de cada byte e as aspas no início e no fim da string. O paste unirá todas as linhas em uma só, usando o delimitador nulo:

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file | cut -f2 -d ':' | cut -f1-6 -d' ' | tr -s ' ' | tr '\t' ' ' | sed 's/ $//' | sed 's/ /\\x/g' | paste -d '' -s | sed 's/^/"/' | sed 's/$/"/'
"\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\xcd\x80"

Obviamente esses comandos podem ser melhorados para evitar a chamada de processos desnecessários (ex: um sed atrás do outro), mas preferi usar a forma original, como visto em [1].

Obtendo a shellcode e o assembly como comentário

Sempre é bom incluir as instruções em assembly junto a shellcode para facilitar a leitura da mesma. Pensando nisso, modifiquei os comandos apresentados anteriormente para gerar uma shellcode incluindo as instruções assembly como comentários em C.

$ objdump -d prog | grep '[0-9a-f]:' | grep -v file | cut -f2 -d ':' | tr '\t' ' ' | sed ':a;s/ \([0-9a-f][0-9a-f]\)/\\x\1/;ta;s,^\([^ ]*\) *\(.*\),"\1" /* \2 */,' | column -t

"\x6a\x0b"              /*  push  $0xb         */
"\x58"                  /*  pop   %eax         */
"\x99"                  /*  cltd  */
"\x52"                  /*  push  %edx         */
"\x68\x2f\x2f\x73\x68"  /*  push  $0x68732f2f  */
"\x68\x2f\x62\x69\x6e"  /*  push  $0x6e69622f  */
"\x89\xe3"              /*  mov   %esp,%ebx    */
"\x31\xc9"              /*  xor   %ecx,%ecx    */
"\xcd\x80"              /*  int   $0x80        */

Os comandos até o sed são os mesmos que os anteriores. O sed substituirá cada ocorrência de “<espaco>XX”, sendo XX dígitos hexas, por “\xXX”. Esse processo de substituição é feito usando um loop já que o uso do ‘g’ poderia pegar dígitos hexas nas instruções em assembly, o que não estaria correto. Quando a condição do loop falhar, a segunda substituição será realizada. Basicamente o que ela faz é pegar tudo antes do espaço (a shellcode em si) e adicionar aspas duplas, e o restante da string,  incluir entre os indicadores de comentários em C, /* */. Por fim, o comando column embeleza a saída, criando uma tabela com espaçamentos iguais em todas as linhas.

Conclusão

Esse post foi para mostrar mais uma vez a eficiência das ferramentas padrões do linux e como o tratamento de texto merece também um pouco de atenção por parte dos usuários, por facilitar algumas tarefas entediantes, como obter uma shellcode à partir da saída do objdump.

Referências

[1] Get all shellcode on binary file from objdump, by gunslinger_ (Acessado em: Março/2012)http://www.commandlinefu.com/commands/view/6051/get-all-shellcode-on-binary-file-from-objdump

[2] exploit-db (Acessado em: Março/2012)
http://www.exploit-db.com/shellcode/

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s