Módulo de Metasploit para PoC Stack Buffer Overflow

Ha llovido desde el artículo anterior donde vimos de qué manera nos podía afectar la ruta de ejecución de un binario a la hora de identificar la dirección de memoria en la que explotar un código vulnerable a stack based buffer overflow, pero esto sólo era un preámbulo antes de ponernos manos a la obra con la escritura de un módulo para Metasploit que ejecute esa explotación por nosotros, así que dejemos de dar rodeos y empecemos con ello.

Preparando el entorno

Para darle vidilla a esta prueba de concepto he creado el siguiente entorno:

• Un usuario atacante desde el que he iniciado la consola de Metasploit y preparado el exploit java_signed_applet para tomar el control de la máquina del cliente.
• Un usuario cliente con nombre nodoraiz. Desde este usuario se visitará el enlace que ha preparado el atacante.
• El usuario cliente dispone de la aplicación con el código vulnerable y que además se ha configurado con setuid simulando un proceso que nos pueda permitir realizar una escalada de privilegios.

Creando el script en Ruby

Lo primero que haremos antes de ponernos manos a la obra con el módulo de Metasploit, es crear un exploit que aproveche la vulnerabilidad detectada en nuestra aplicación:

El resultado de ejecutar el script:

De exploit a módulo Metasploit

Para cualquier duda que nos surja agradeceremos el Redmine dedicado a la guía de desarrollo, que aunque se corresponde con versiones previas del framework, sin duda nos servirá de ayuda.

También podemos ver en la Web de Offensive-security el esqueleto esperado por un módulo de Metasploit, sin embargo en ese mismo enlace veréis como el módulo está orientado a una explotación en remoto (MSF::Exploit::Remote) mientras que en nuestro escenario vamos a tomar el control de la máquina del cliente y realizar una explotación en local (MSF::Exploit::Local), quedándonos un código como el del siguiente enlace a Pastebin. Vamos a verlo más en detalle.

En la definición de la clase del módulo tenemos lo siguiente:

Incluimos las librerías iniciales y especificamos que estamos creando un exploit local. Además a través del ranking podemos especificar qué tal responde el exploit respecto a su comportamiento en el sistema sobre el que será ejecutado, los distintos valores los podéis consultar aquí.

A continuación tenemos en el constructor de la clase la asignación de los atributos que definirán las posibilidades de nuestro exploit:

En la imagen anterior, además de campos descriptivos del módulo, vemos como se definen otros parámetros más influyentes del exploit:

• El framework nos propondrá los payloads según el conjunto de valores que definamos en Platform, Arch, SessionTypes y Payload:

• El campo Target nos permite indicar los posibles objetivos que el usuario podrá seleccionar al configurar el exploit
• Usaremos la estructura register_options para crear un diccionario de valores que el usuario pueda sobreescribir a través de la consola de MSF y que el exploit utilice durante la ejecución:

Podéis ver en esta última captura como aparece un campo SESSION que no ha sido definido, esto es porque al tratarse de un módulo de explotación local habrá que definir la sesión establecida a través de Metasploit con un cliente y sobre la cual se quiere ejecutar el exploit.

Finalmente tenemos el método en el que escribiremos nuestro código para explotar la vulnerabilidad y que será ejecutado sobre la sesión que se le indique a MSF cuando se ejecute el comando "exploit" o "run":

Vemos dos detalles relevantes en este bloque:

• El uso de la variable datastore["exec_file"], que nos permite acceder a las opciones que ha configurado el usuario
• En mi caso he dejado el código de la shellcode que he usado desde el principio ya que el código no tenía prácticamente nada de espacio para inyectar los payloads de MSF, pero lo interesante es hacer referencia a la variable payload.encoded, permitiendo utilizar al usuario el payload que haya seleccionado

Por último indicar que en nuestro módulo podemos segmentar el código a través de todos los métodos que consideremos necesarios, además de poder incluir un método check para comprobar si el sistema configurado es vulnerable y que pueda ser invocado desde la consola MSF con el comando check.

Ejecutando el exploit

Un último detalle que nos puede ahorrar mucho tiempo cuando estamos trabajando con Metasploit y el desarrollo de nuevos módulos es el uso de Resource Scripts, en mi caso yo he utilizado el siguiente:

Y ya sin dar más vueltas, desde la sesión del atacante iniciamos Metasploit con "msfconsole" y cargamos el resource script:

Invitamos al cliente a visitar el enlace indicado por el exploit java_signed_applet, y veremos en nuestra consola de MSF como se recibe una una nueva sesión a la que nos podemos conectar:

En este caso vemos como tenemos acceso a una sesión con la cuenta del usuario, así que vamos a ejecutar el exploit que hemos preparado y que en nuestro escenario supondrá una elevación de privilegios:

Conclusiones finales

No abunda la documentación sobre desarrollo de módulos de Metasploit, pero algunos de los enlaces que encontraréis más interesantes son los comentados durante el artículo:

• Wiki del proyecto
• Documentación en la Web de Offensive-Security
• Googlear ejemplos con consultas del tipo:
• site:exploit-db.com "MSF::Exploit::Local"
• site:exploit-db.com "MSF::Exploit::Remote"

Artículo cortesía de Miguel Ángel García

@nodoraiz

Etiquetas: contribuciones , metasploit