Hack’n Roll Blog

Olá galera.! Como meu primeiro post no blog irei falar sobre um método que irá dificultar o disassembly de um binário.

O método cria um Falso Disassembly, que irá confundir os disassemblers gerando outras instruções diferente da que irá executar colocando outros bytes juntos com o opcode correto. O código abaixo é um exemplo de um simples exit sem esse método.

1
2
3
4
5
6
7
8

.section .text
.globl _start
_start:
          xor %eax,%eax
          push %eax
          mov $0x1,%al
          push %eax
          int $0x80

c0d3labs# objdump -d normal_exit

normal_exit:     file format elf32-i386-freebsd

Disassembly of section .text:

08048074 :
 8048074:       31 c0                   xor    %eax,%eax
 8048076:       50                      push   %eax
 8048077:       b0 01                   mov    $0x1,%al
 8048079:       50                      push   %eax
 804807a:       cd 80                   int    $0x80
c0d3labs#

Agora, no exemplo abaixo, quando o disassembler for mostrar o código, irá juntar os opcodes “\xc0\xc9″ com “\x31″, que é o começo do “xor %eax,%eax”, que faz a instrução “ror $0×31,%cl”(opcode “\xc0\xc9\x31″). Isso aconteçe porque a instrução “ror”(opcode “\xc0″) recebe dois argumentos. Com isso o “\xc0″, que é o final do “xor %eax,%eax”, é ignorado e passa a ser a proxima instrução.

A chave principal dessa idéia é alterar o entry point. No caso iremos aumentar em dois para cair diretamente no “\x31\xc0″, no caso executar o “xor %eax,%eax” e, assim, ignorar o “\xc0\xc9″ que foi inserido só para confundir o disassembly.

E, em seguida, executar o “jmp . + 4″ (opcode “\xeb\x02″), que é para pular do endereço atual mais quatro. Isso para ignorar o “\xc9\xc0″ que foi inserido junto com “\xb0\x01″ para o mesmo propósito, e cair diretamente no “mov $0×1,%al”(opcode “\xb0\x01″) e assim seguir adiante.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

.section .text
.globl _start
_start:
         .byte 0xc0
         .byte 0xc9
         xor %eax,%eax
         push %eax
         jmp . + 4
         .byte 0xc0
         .byte 0xc9
         mov $0x1,%al
         jmp . + 4
         .byte 0xc9
         .byte 0xc0
         push %eax
         jmp . + 4
         .byte 0xc0
         .byte 0xc9
         int $0x80

c0d3labs# objdump -d false_disassembly

false_disassembly:     file format elf32-i386-freebsd

Disassembly of section .text:

08048074 <_start>:
8048074:       c0 c9 31                ror    $0x31,%cl
8048077:       c0 50 eb 02             rclb   $0x2,0xffffffeb(%eax)
804807b:       c0 c9 b0                ror    $0xb0,%cl
804807e:       01 eb                   add    %ebp,%ebx
8048080:       02 c9                   add    %cl,%cl
8048082:       c0 50 eb 02             rclb   $0x2,0xffffffeb(%eax)
8048086:       c0 c9 cd                ror    $0xcd,%cl
8048089:       80                      .byte 0x80
c0d3labs#

Para alterar o entry point, você pode mudar manualmente via qualquer editor hexadecimal no offset 0×18 ou usar esse code.

Todos os testes foram feito em um FreeBSD versão 6.2.

Até mais!

`hacknroll`