Duvida!!!

[Edinho Sousa]

Boa tarde!

nos meus estudos  descobrir algo interessante, um programa em assembly como:

global _main:

_main:
    mov eax, 10
    
    add ecx, 10
    add ebx, 20

compilando:

nasm -f win32 tes.asm -o tes.o

e usando o objdump do gcc temos o seguite resutado

tes.o:     file format pe-i386


Disassembly of section .text:

00000000 <.text>:
   0:   b8 0a 00 00 00          mov    $0xa,%eax
   5:   83 c1 0a                add    $0xa,%ecx
   8:   83 c3 14                add    $0x14,%ebx

concluimos que 83 é o opcode de add, c1 e c3 são os registradores ecx, ebx e 0a e 14 sao os valores 10 e 20 em hexadecimal.

minha duvida é tem como atrves do codigo em C, colocar esses opcodes para o precessador execultar?

[Fernando Mercês]

Oi @Edinho Sousa. É exatamente como se costuma testar um shellcode em C. Tudo que você precisa é:

 

1. Colocar os opcodes que você quer num buffer.

2. Criar um ponteiro de função que aponte para este buffer.

3. Chamar esta função através do ponteiro criado no passo anterior.

 

Tutoriais sobre shellcode / exploração de binários vão te mostrar isso. Achei um gist aqui: https://gist.github.com/securitytube/5318838

 

Abraço!

[Edinho Sousa]

@Fernando Mercês obrigado denovo ?

[fredericopissarra]

Infelizmente a conclusão sobre os opcodes está errada. O formato de opcodes de processadores Intel (x86) é mais complicada:

Um opcode pode ter até 3 btyes de tamanho, e pode ser precedido de um ou mais prefixos. Seguido de mais 1 byte contendo a lista de argumentos (ModR/M - registro ou memória), seguido do byte SIB - ainda temos o displacement (offset) e um possível valor imediato.

Consulte o volume 2 do Manual de desenvolvimento de software da Intel para ver os opcodes de todas as instruções (https://software.intel.com/content/www/us/en/develop/articles/intel-sdm.html).

[fredericopissarra]

Outro problema a ser enfrentado... Um "shellcode" que funcione no modo i386 (32 bits) geralmente não funciona no modo x86-64 (64 bits)... Por exemplo, os registradores seletores de segmentos não são usados no modo x86-64.... O modo de endereçamento relativo a RIP não está disponível no modo i386 (32 bits), etc...

[fredericopissarra]

OUTRO problema... Simplesmente colocar os bytes dos opcodes num buffer é problemático. Sistemas modernos usam paginação para gerenciar memória e páginas podem ter o flag NX (not executable) habilitado. É o caso do segmento de dados. O programa abaixo simplesmnte causará um "segmentation fault" porque o segmento de dados não permite execução de código (mesmo que o "shellcode" esteja correto e respeite a convenção de chamada):
 

#include <stdio.h>

char *shellcode = "\x8d\x04\x7f"    // lea eax,[rdi+rdi*2]
                  "\xc3";           // ret

int main( void )
{
  int (*f)(int) = (int (*)(int))shellcode;
  int y;

  y = f(3);
  printf( "%d\n", y );
}

Compilando e executando:
 

$ cc -o test test.c
$ ./test
Segmentation fault (code dumped)

 

[Fernando Mercês]

@fredericopissarra,

O problema é a stack não executável, mas este esquema é só para testes. Normalmente é compilado com as opções -fno-stack-protector e -z execstack do gcc para testar o shellcode. ;-)

Abraço.

[fredericopissarra]

20 minutos atrás, Fernando Mercês disse:

@fredericopissarra,

O problema é a stack não executável, mas este esquema é só para testes. Normalmente é compilado com as opções -fno-stack-protector e -z execstack do gcc para testar o shellcode. ?

Abraço.

Fernando, o "shellcode" ai não está na pilha.