Shellcode de Linux "¡Hola, mundo!"

assembly nasm

Question

Tengo el siguiente código NASM funcional:

global _start

section .text

_start:
    mov eax, 0x4
    mov ebx, 0x1
    mov ecx, message
    mov edx, 0xF
    int 0x80

    mov eax, 0x1
    mov ebx, 0x0
    int 0x80

section .data
    message: db "Hello, World!", 0dh, 0ah

que imprime "Hello, World! / n" en la pantalla. También tengo el siguiente contenedor C que contiene el código de objeto NASM anterior:

char code[] =
"/xb8/x04/x00/x00/x00"
"/xbb/x01/x00/x00/x00"
"/xb9/x00/x00/x00/x00"
"/xba/x0f/x00/x00/x00"
"/xcd/x80/xb8/x01/x00"
"/x00/x00/xbb/x00/x00"
"/x00/x00/xcd/x80";

int main(void)
{
    (*(void(*)())code)();
}

Sin embargo, cuando ejecuto el código, parece que el código del ensamblador no se ejecuta, pero el programa sale bien. ¿Algunas ideas?

Gracias

Answer 1

Como mencionó BSH , su shellcode no contiene los bytes del mensaje. Saltar a la etiqueta MESSAGE y llamar a la rutina GOBACK justo antes de definir el byte msg fue una buena jugada ya que la dirección de msg estaría en la parte superior de la pila como dirección de retorno que podría aparecer en ecx , donde se almacena la dirección de msg .

Pero tanto el suyo como el código de BSH tienen una pequeña limitación. Contiene NULL bytes ( /x00 ) que se considerarían como fin de cadena cuando el puntero de función desreferencia.

Hay una manera inteligente de evitar esto. Los valores que almacena en eax, ebx and edx son lo suficientemente pequeños para escribirse directamente en los nibbles inferiores de los registros respectivos de una vez accediendo a al, bl and dl respectivamente. El nibble superior puede contener valor no deseado por lo que puede ser definido.

b8 04 00 00 00 ------ mov $0x4,%eax

se convierte

b0 04          ------ mov $0x4,%al
31 c0          ------ xor    %eax,%eax

A diferencia del conjunto de instrucciones anterior, el nuevo conjunto de instrucciones no contiene ningún byte NULL.

Entonces, el programa final se ve así:

global _start

section .text

_start:
jmp message

proc:
    xor eax, eax
    mov al, 0x04
    xor ebx, ebx
    mov bl, 0x01
    pop ecx
    xor edx, edx
    mov dl, 0x16
    int 0x80

    xor eax, eax
    mov al, 0x01
    xor ebx, ebx
    mov bl, 0x01   ; return 1
    int 0x80

message:
    call proc
    msg db " y0u sp34k 1337 ? "

section .data

Ensamblaje y enlace:

$ nasm -f elf hello.asm -o hello.o
$ ld -s -m elf_i386 hello.o -o hello
$ ./hello
 y0u sp34k 1337 ? $ 

Ahora extrae el código de shell del hola binario:

$ for i in `objdump -d hello | tr ''/t'' '' '' | tr '' '' ''/n'' | egrep ''^[0-9a-f]{2}$'' ` ; do echo -n "//x$i" ; done

salida:

/xeb/x19/x31/xc0/xb0/x04/x31/xdb/xb3/x01/x59/x31/xd2/xb2/x12/xcd/x80/x31/xc0/xb0/x01/x31/xdb/xb3/x01/xcd/x80/xe8/xe2/xff/xff/xff/x20/x79/x30/x75/x20/x73/x70/x33/x34/x6b/x20/x31/x33/x33/x37/x20/x3f/x20

Ahora podemos tener nuestro programa de controlador para iniciar Shellcode.

#include <stdio.h>

char shellcode[] = "/xeb/x19/x31/xc0/xb0/x04/x31/xdb"
                   "/xb3/x01/x59/x31/xd2/xb2/x12/xcd"
                   "/x80/x31/xc0/xb0/x01/x31/xdb/xb3"
                   "/x01/xcd/x80/xe8/xe2/xff/xff/xff"
                   "/x20/x79/x30/x75/x20/x73/x70/x33"
                   "/x34/x6b/x20/x31/x33/x33/x37/x20"
                   "/x3f/x20";


int main(int argc, char **argv) {
    (*(void(*)())shellcode)();
    return 0;
}

Existen ciertas características de seguridad en compiladores modernos como la protección NX que evita la ejecución de código en el segmento de datos o la pila. Por lo tanto, debemos especificar explícitamente el compilador para deshabilitar estos.

$ gcc -g -Wall -fno-stack-protector -z execstack launcher.c -o launcher

Ahora el launcher se puede invocar para iniciar el shellcode.

$ ./launcher
 y0u sp34k 1337 ? $ 

Para shellcodes más complejos, habría otro obstáculo. Los núcleos Linux modernos tienen ASLR o Address Space Layout Randomization Es posible que deba deshabilitar esto antes de inyectar el código de shell, especialmente cuando se trata de desbordamientos de búfer.

root@localhost:~# echo 0 > /proc/sys/kernel/randomize_va_space 

Answer 2

Cuando inyectas este Shellcode, no sabes qué hay en el message :

mov ecx, message

en el proceso inyectado, puede ser cualquier cosa, pero no será "Hello world!/r/n" ya que está en la sección de datos mientras está descargando solo la sección de texto. Puedes ver que tu shellcode no tiene "Hello world!/r/n" :

"/xb8/x04/x00/x00/x00"
"/xbb/x01/x00/x00/x00"
"/xb9/x00/x00/x00/x00"
"/xba/x0f/x00/x00/x00"
"/xcd/x80/xb8/x01/x00"
"/x00/x00/xbb/x00/x00"
"/x00/x00/xcd/x80";

Este es un problema común en el desarrollo de shellcode, la forma de evitarlo es de esta manera:

global _start

section .text

_start:
    jmp MESSAGE      ; 1) lets jump to MESSAGE

GOBACK:
    mov eax, 0x4
    mov ebx, 0x1
    pop ecx          ; 3) we are poping into `ecx`, now we have the
                     ; address of "Hello, World!/r/n" 
    mov edx, 0xF
    int 0x80

    mov eax, 0x1
    mov ebx, 0x0
    int 0x80

MESSAGE:
    call GOBACK       ; 2) we are going back, since we used `call`, that means
                      ; the return address, which is in this case the address 
                      ; of "Hello, World!/r/n", is pushed into the stack.
    db "Hello, World!", 0dh, 0ah

section .data

Ahora descargue la sección de texto:

$ nasm -f elf shellcode.asm
$ ld shellcode.o -o shellcode
$ ./shellcode 
Hello, World!
$ objdump -d shellcode

shellcode:     file format elf32-i386


Disassembly of section .text:

08048060 <_start>:
 8048060:   e9 1e 00 00 00   jmp    8048083 <MESSAGE>

08048065 <GOBACK>:
 8048065:   b8 04 00 00 00   mov    $0x4,%eax
 804806a:   bb 01 00 00 00   mov    $0x1,%ebx
 804806f:   59               pop    %ecx
 8048070:   ba 0f 00 00 00   mov    $0xf,%edx
 8048075:   cd 80            int    $0x80
 8048077:   b8 01 00 00 00   mov    $0x1,%eax
 804807c:   bb 00 00 00 00   mov    $0x0,%ebx
 8048081:   cd 80            int    $0x80

08048083 <MESSAGE>:
 8048083:   e8 dd ff ff ff   call   8048065 <GOBACK>
 8048088:   48               dec    %eax                    <-+
 8048089:   65               gs                               |
 804808a:   6c               insb   (%dx),%es:(%edi)          |
 804808b:   6c               insb   (%dx),%es:(%edi)          |
 804808c:   6f               outsl  %ds:(%esi),(%dx)          |
 804808d:   2c 20            sub    $0x20,%al                 |
 804808f:   57               push   %edi                      |
 8048090:   6f               outsl  %ds:(%esi),(%dx)          |
 8048091:   72 6c            jb     80480ff <MESSAGE+0x7c>    |
 8048093:   64               fs                               |
 8048094:   21               .byte 0x21                       |
 8048095:   0d               .byte 0xd                        |
 8048096:   0a               .byte 0xa                      <-+

$

Las líneas que marqué son nuestra cadena "Hello, World!/r/n" :

$ printf "/x48/x65/x6c/x6c/x6f/x2c/x20/x57/x6f/x72/x6c/x64/x21/x0d/x0a"
Hello, World!

$ 

Entonces nuestro envoltorio de C será:

char code[] = 

    "/xe9/x1e/x00/x00/x00"  //          jmp    8048083 <MESSAGE>
    "/xb8/x04/x00/x00/x00"  //          mov    $0x4,%eax
    "/xbb/x01/x00/x00/x00"  //          mov    $0x1,%ebx
    "/x59"                  //          pop    %ecx
    "/xba/x0f/x00/x00/x00"  //          mov    $0xf,%edx
    "/xcd/x80"              //          int    $0x80
    "/xb8/x01/x00/x00/x00"  //          mov    $0x1,%eax
    "/xbb/x00/x00/x00/x00"  //          mov    $0x0,%ebx
    "/xcd/x80"              //          int    $0x80
    "/xe8/xdd/xff/xff/xff"  //          call   8048065 <GOBACK>
    "Hello wolrd!/r/n";     // OR       "/x48/x65/x6c/x6c/x6f/x2c/x20/x57"
                            //          "/x6f/x72/x6c/x64/x21/x0d/x0a"


int main(int argc, char **argv)
{
    (*(void(*)())code)();

    return 0;
}

Vamos a probarlo:

$ gcc test.c -o test
$ ./test 
Hello wolrd!
$ 

funciona.