Secuma 2018 – DeathNode [500]

Buenas a todos!

Me presentaré brevemente: soy Secury, organizador y picateclas en Bitup Alicante.

A veces hago malware (pocas veces ya), pero, definitivamente, mi sitio esta los Red Team. Quiero dar las gracias a mi compañero Kalrong por dejarme un huequecito en su humilde morada y permitirme mostraros un caso muy interesante de un reto Web de un CTF.

Antes de nada, decir que este reto lo monté yo, y, curiosamente nadie consiguió resolverlo. A a mi parecer no es un reto muy difícil, pero si que tiene un final de estos de darle bastante al coco. Así que… Manos a la obra!

Lo primero que nos encontramos es una bonita vista donde se muestra una representación satírica, mezcla entre lenguajes de programación y algunos personajes de la serie de death note. Pero dejando atrás la comedia vamos a echar un vistazo al contenido de la página.

portada

Recordamos (de los anteriores writeups) que lo primero que debemos hacer en un pentesting web es hacernos un mapa de la plataforma web, obteniendo cada una de las referencias a otras vistas y así ampliar el rango de páginas donde pondremos en práctica nuestro análisis de vulnerabilidades.

Buceando por el código de la página vemos referencias a ficheros de estilos y scripts comunes de Boostrap, nada extraño, lo necesario para hacer funcionar la template cover de Bootstrap. Así que descartamos, en esta vista, la posibilidad de obtener cualquier tipo de información útil de estos ficheros.

Si le probamos a preguntarle al robots.txt como hacíamos en el anterior reto, no muestra lo siguiente:

robots.txt

Ese disallow sospechoso que vamos a seguir, y que nos llevará a la vista, posiblemente más cutre de la historia.

work-to-do

Podemos ver que es una especie de lista de tareas, de las cuales estan todas tachadas menos una que dice algo así: “Despedir al becario de Front-End”. Interesante…

Si observamos el código fuente descubrimos una tarea oculta que dice: “Esconder la intranet”. Es decir, podemos pensar que hay una intranet en el Servidor. No encontramos nada interesante, de nuevo, ni en los estilos ni en los scripts. Así que llegado a este punto, donde sólo tenemos 2 vistas y con las que no parece que podamos interactuar, toca ampliar el abanico de forma manual, y con manual me refiero a que toca fuzzear un poco.

Oigo voces en la lejanía maldiciendo por haber escuchado la palabra “fuzzear”, bueno para todos aquellos haters del descubrimiento de nuevas rutas aplicando la fuerza bruta, quiero transmitirles un mensaje de esperanza: con cualquier tool vas a dar con la solución.

Y esto es porque a mi también me parece que en un ctf, tirar de fuerza bruta es algo que no mola, a pesar de que en la vida real es otra cosa, pero… en la jungla todo vale ¿no?

Yo que soy un poco hipster, voy a utilizar el script de nmap http-enum, y sólo lo hago por llevar la contraria a todos esos fanboys de dirhunt, gobuster, photon, burp y otras hierbas. Pero que vamos… no hace falta que lloreis, es tan tan facil de sacar que podríais hasta hacerlo a manopla.

nmap

El nmap descubre 2 rutas nuevas: /l y /r (por dios! cuanta complejidad), entramos a la primera, por ejemplo, parece que se trata de un login, vamos a probamos a autenticarnos con datos por defecto completamente aleatorios = admin : patatas
Y después de intentarlo nos trae a la misma vista de nuevo, doy por hecho que ha fallado el intento de acceso.

Podemos suponer que puede que haya algún tipo de inyección sql, y con todo lo que hemos visto, sabiendo que estamos en una plataforma bajo Nodejs, todo apunta
a que, si hay una base de datos, lo más normal sería encontrarse un Mongodb (recordamos que es una base de datos NoSQL). Y por tanto vamos a probar a intentar
romper la “posible” query con medio de las inyecciones comunes a mongodb.

Y después de un rato intentando inyectar, y sin éxito y mucho dolor de cabeza, nos planteamos la posibilidad de que igual no es inyectable (bueno pero decirle al amigo sqlmapero que le tire a ver que saca).

Algún lumbreras, recordará del ToDo que salía la frase: “Plagarize of Tindermon“, y pensará: Pues igual se han plagiado de la prueba de Tindermon de Navaja Negra 2018, igual consiste en formar la inyección por medio de una corrupción de carácteres unicode
en la petición HTTP fruto de enviar determinados emojis (revisar el post de Ryan Kelly).

Y si alguien intenta esto y lo veo en los logs me pondré muy feliz, porque significa que los chicos de Ka0labs llegaron a romper muchas cabezas, además de la mía, aquel precioso día. Pero no, la respuesta no va por ahí, ni tampoco se haya en ningún javascript de la vista. Por tanto, pasemos a echar un vistazo a la otra ruta.

register

Y vaya… tanto rato peleandonos y todo por no haber mirado antes en el /r o /r(egister). Pues vamos a probar a registrarnos, como no, con un usuario y password completamente aleatorios = admin : patatas , y al darle a enviar nos sucede lo siguiente:

err-register

Nos lanza un curioso error “Error! Invalid password Format”. Pero si nos hemos fijado habremos notado 2 cosas muy graves:

No ha llegado a enviar la petición, eso significa que el error es fruto de alguna validación por parte del Javascript de la página.
Venga seamos serios… ¿nadie esta flipando porque ese error da a presuponer que hay un formato base de las contraseñas?

En el código nos encontramos un único script con un curioso nombre “__.js” que tiene todas las papeletas de contener la función que esta evaluando el formato de la contraseña. Cuando lo abrimos nos encontramos con el contenido en formato mono linea, y al parecer ofuscado.

js_code

Se abre un frente claro, y es desofuscarlo e interpretar el código, pero estoy seguro que algún erudito ha visto la vía fácil, y es que en las primeras palabras del script, nos sale un bonito base64 y una palabra clave: “test”. Si decodeamos ese base64, obtenemos una cadena como la siguiente.

decode_regex

Que tras evaluarla rápidamente, podemos asegurar que se trata del pattern por el formato típico de una expresión regular. Y si hemos descubierto esto, no será difícil entender que ese “test” corresponde a la función test() de javascript para para comparar una cadena de entrada con la expresión regular.

Podríamos desofuscar el código (es más, yo lo haré en una sección de este writeup que estará publicado en gitlab también), pero kalrong me va a matar como me pase con la extensión. Así que nos dirigimos al registro a tratar de poner en uso lo que hemos averiguado.

Probamos la siguiente combinación= patatas:d4rkS0ul1234567

dont-allowed

Y al intentar registrarnos nos saca el siguiente error: “You are not allowed to register. Maybe you want try to login”, que nos arroja que no podemos registrarnos, que probemos a iniciar sesión. Y eso haremos, pues sabiendo el formato de las contraseñas, podemos probar todas las combinaciones posibles hasta llegar a dar con la contraseña de un usuario, nada, son sólo 1 millon de combinaciones distintas, eso es pan comido. Pero.. ¿y qué usuario? Probemos con admin, porque tiene toda la pinta. (Y de ahí lo de despedir al de FrontEnd)

Y después de un ratillo obtnemos como resultado el paso con la contraseña “d4rkS0ul7777777”.
La insistencia nos ha llevado a un panel, al estilo del anterior reto (writeup-fbi). A priori nos atreveríamos a decir que viene a cumplir la misma función, es decir, hacer una petición HTTP, pero con la clara diferencia de que esto no es PHP, sino que es nodejs, y en node no vamos a contar con nuestros amigos los wrappers y otras fumadas, al igual que no habrá ningún escapeshellcmd que bypassear, pues la url va directamente a la función que realiza la petición. Si no me crees, adelante, puedes probarlo, y comprobarás que no hay posibilidad a un command injection, puesto que no ejecuta ningún comando.

death-note

Entonces, si descartamos un LFI, y el Command Injection, así como un Inyección NoSQL…

¿Qué nos queda?

Pues si no te había venido antes a la cabeza, es un caso típico de Server Side Request Forgery (SSRF) y Cross Site Port Attack (XSPA, de este no tenía ni idea que se llamaba así), la primera es una vulnerabilidad que nos permite forzar al servidor web a realizar peticiones a la destinación que se le precise, esto da paso al ataque XSPA que se utiliza para mapear los puertos y/o servicios que están corriendo en la máquina que realiza las peticiones, en base a las respuestas obtenidas con las diferentes solicitudes. Y no lo digo yo, lo dice Chema.

¿Y cómo realizamos este ataque?

Pues, por definición, si queremos hacer peticiones desde una máquina así misma, procederemos a utilizar el nombre reservado conocido como “localhost” o para los más posturetas “127.0.0.1” (pero seguro que todo desarrollador web lo sabía de antemano), que básicamente se apunta a sí misma. Y ahí la gracia del asunto; si el Servidor Web hace una petición a la dirección localhost estaría haciendo una petición HTTP a su propia máquina, y más concretamente, a su servidor Web local (por defecto en el puerto 80), dicho esto, una petición a localhost:22 le estaría haciendo una petición HTTP al puerto 22 (o por defecto al puerto donde suele correr el servicio SSH) y, en caso de interpretar el protocolo HTTP (con el que hacemos la petición), es posible que nos devuelva una respuesta.

Vale, pues vamos a ponerlo en acción!

Y de primeras nos encontramos que no nos esta devolviendo ninguna respuesta HTTP sino que nos muestra un peculiar error de: “bad format”.

Y no, aquí no hay javascript que valga, esto ya es cosa del backend. Pero entonces…

¿Cómo querrá que hagamos la petición?

Pues aquí lo que vamos haciendo es ir probando de diferentes formas, y después de un largo rato tenemos los siguientes casos que permiten que se haga la petición.

http://php.com
https://php.com
http://www.php.com
http://php.org
http://php.com/abcdef
http://bitupalicante.es
http://b1tuP4liCaNte.es

Y nos damos cuenta con todos estos casos, que satisfacen a un mismo patron que podemos determinar (con esta plataforma):

  • La cadena debe comenzar por el protocolo http o https obligatoriamente

regex1

  • Puede contener o no el subdominio www permite ningún otro, por tanto sólo apunta a dominios principales.
  • El dominio o nombre, sólo puede estar compuesto por letras y números.

regex2

  • Se requiere una extensión obligatoriamente, y sólo hemos dado con 3 válidas: [es,com,org]
  • Permite añadir cualquier subcarpeta o directorio, siempre y cuando se cumplan las condiciones anteriores.

regex3

Y como hemos podido comprobar, hemos reconstruido a partir de casos que nos pasaban el control, el patron que posiblemente se acabe pareciendo a lo que hay detrás (y curiosamente si, se parece bastante). Aunque, permitirme hacer un apunte, y es que esto tiene toda la pinta de haber un WAF por en medio que nos esta aplicando ese filtrado
y nos esta jodiendo. (y de ahí que en el ToDo saliera lo del WaxFFFF).

Aunque cabe decir que conocer este patron de la regex no nos ha aportado mucho más que conocimiento de lo que esta pasando, pues si nosotros queremos que se haga un loopback en la petición tendríamos que conseguir mandar localhost o 127.0.0.1 y parece que el WAF esta haciendo bien su trabajo. Entonces…

¿Qué nos queda?

Bueno, la clave del reto o dificultad (por llamarlo de alguna forma) reside en este paso, en el cual es crucial tener una mente abierta y ser creativo. Atendiendo al propio funcionamiento de HTTP y fijandonos en las propias respuestas que nos daba a ejemplos de webs como: http://bitupalicante.es, nos daremos cuenta que no accede realmente a esa página, sino que finalmente acaba rehaciendo la petición al puerto 443. ¿Y por qué sucede esto? Pues porque lo que nos esta devolviendo el Servidor Web es un código de redirección, en cristiano, un HTTP 302.

Y aquí podríamos utilizar el comodín del administrador, y leer atentamente la pista que se nos dan:

“Kira, be carefull who you point… Remember that a 30x could cause you to shoot yourself.”

Que viene a decirnos que tengamos cuidado dónde apuntamos, pues un 30x puede hacer que nos disparemos a nosotros mismos. Y de eso se trata, tenemos que marcarnos un Froilán.

¿Y cómo nos disparamos en el pie?

Pues si controlamos el servidor al que se hace la petición, podemos devolver, ante una HTTP Request, una Respuesta HTTP con un Código de Redirección hacia una nueva dirección, ¿Y que metemos en esa nueva dirección?

Pues podríamos poner: localhost (a secas, a pelo, tal cual)

¿Y cómo puede ser que el WAF se lo coma?

Pues porque ese “Waf” no es más que un maldito middleware cutre en el router del nodejs, es decir, que valida sólo la entrada a la función que irá en la propia petición, y no los saltos que esta de lo que esta responda. Y de ahí que en la pista se diga: 30x y no 302, pues recordamos que los códigos 3XX son los de redirección (era más facil verlo con un 30X que con un 3XX).

Y de igual forma que se utiliza localhost, se puede acceder directamente a un puerto = localhost:22, o a la URL que nosotros queramos.

Entonces, manos a la obra, conociendo esto, que es la propia definición de XSPA, vamos a automatizarlo con un pequeño servidor en nodejs (puesto a hacerlo en node, lo hacemos todo en node), que dado un numero de puerto mande un codigo de redirección a localhost con ese puerto. Y con ello empezaremos a mapear todos los servicios que nos respondan a peticiones HTTP simples.

Recordad, que tenemos un rango de puertos del 1 al 65536 (máximo con esos 16 bits o 2 bytes que podemos especificar en el campo de puerto destino de las cabeceras TCP). Así que nada, un bonito bucle for con curl desde el 1 hasta el 65536 que enviará peticiones al recurso /death-note, pasandole por post la URL de nuestro dominio (.es, .org o .com) en el que estará escuchando nuestro server en nodejs que será el que reciba ese contador del bucle for, y devolverá la redirección hacia dicho puerto, mostrando tanto el contenido de la respuesta como el tamaño.

flag

Y bueno, como podemos ver, nos encontramos el puerto 1999 con una pequeña vista levantada, donde en la respuesta HTTP a dicha página, nos encontramos con la FLAG del reto! Bang! en todo el pie.

Espero que os haya gustado el reto, que hayais aprendido a utilizar la nueva tecnica del Froilán y que os de la motivación necesaria para seguir haciendo CTFs y disfrutando mucho.

Feliz hacking!

Publicado en ctf, docker, web, writeups | Etiquetado | Deja un comentario

Os presento a Bob, nuestro nuevo amigo en I2P

Felices fiestas y prosperas resacas!

Ya sé que os tengo abandonaditos pero es que en los últimos dos meses apenas he tenido tiempo para escribir nada ni para trastear con demasiadas cosas (bueno si, pero no sé hasta que punto os interesaran jeje) pero este día decidí levantar mis nodos de RetroShare otra vez y esto me llevo a levantar mis routers de I2P después de unas buenas vacaciones, cual fue mi sorpresa cuando al ir a la configuración de red de RS para el nodo oculto me encontré una nueva pestaña sobre un tal BOB de I2P.

Y es que resulta que la gente de I2P ha añadido a BOB (Basic Open Bridge) al router de I2P y nos da una manera sencilla de levantar y gestionar túneles.

NOTA: Adastra me ha bajado de mi hype comentandome que BOB lleva ya tiempo pero que funciona genial y que efectivamente es un método sencillo para montar túneles.

Una de las principales ventajas que BOB tiene sobre el viejo SAM de I2p es que mientras que en este último todo iba por el mismo canal y tenías que parsear los paquetes en BOB tiene canales de datos  y comandos por separado. Estas conexiones corren en paralelo así que podemos estar haciendo cambios en la configuración de un túnel en un canal mientras por otro va el tráfico de datos.

Lo que más me ha gustado es la simpleza con que podemos configurar los túneles para nuestros servidores, como nota decir que RS sigue siendo limitante a localhost, a pesar de que en BOB se pueda configurar de forma remota RS sigue resistiéndose a escuchar en otra cosa que no sea localhost.

Para que veáis lo simple que es de utilizarlo en nuestras aplicaciones voy a reutilizar el ejemplo que viene en la documentación de I2P pero explicando paso a paso los distintos comandos.

Lo primero es que para conectarnos a BOB llega con que hagamos un telnet o nc en nuestro router I2P al puerto 2827.

Comencemos por un help:

BOB 00.00.10
OK
help
OK COMMANDS: help clear getdest getkeys getnick inhost inport list lookup newkeys option outhost outport quiet quit setkeys setnick show showprops start status stop verify visit zap

Fijémonos en un par de cosas, la primera es que la versión es la 00.00.10; las versiones 00.00.00 a 00.00.0F son versiones de testing. Lo segundo es que BOB siempre responderá con una línea terminando en \n o \r\n dependiendo del sistema.

Comencemos por darle un nombre, o nick, a nuestro túnel servidor:

setnick boca
OK Nickname set to boca

Con setnick lo que estamos haciendo realmente es indicarle a BOB que toda configuración que hagamos a partir de ahora pertenece al túnel boca.

Generemos unas llaves nuevas (cambian de cada vez así que no hagáis copy paste de estas):

newkeys
OK EONsUe8~6z09YvAArlJ5BCBMPi0akug7m~HvK2fnUcyZV4XbHumpB49HL5So8eSORTDmKK62xDiGJg8o5tS9MPUSqsAYCww4~SzS0rqq~0FbXT9DQg3l0PvA4SCWWymhWM2k-LpqWy0vLkKhBb1DqJQwt97cs1-FRyOlUA2h6D2K-WblY9uAeb2vqCiEsJ3z9OqloMKwpdS9nVVme8jHlyMB~SvsvrtYWCh4AaiBv0wMXWIk~e7GFSloQDgDwcG2CU87xgrMXnCjJIZ9NsOyo384xk12-09T6abrZvEs8G-BcDHPx7sQfXsB~5a2nV~Tl2dHHX234PatXPRZ8qeZDSK7ViVU9OojMI8pAONjKAJyWFapC-AWt9D2llbudfPgiy2TZJj3v2Uyx4Q4MO9bRksg3E7TSlWzPZYpN810hJoSd~ZYQYZ101bhMF0vrXwZ3yyMk8M0xux-E-EoiEQzBAkySLNwjlSFW0kCsR69sM2Ifr7vtqRs3CUkPyiAKeugAAAA

Ahora vamos a configurar a donde tiene que apuntar este túnel, es este caso será un netcat escuchando en el puerto 1337 de localhost:

outhost 127.0.0.1
OK outhost set
outport 1337
OK outbound port set

Y finalmente arrancamos el túnel con start:

start
OK tunnel starting

Podemos ver la configuración y estado del túnel utilizando el comando status:

status boca
OK DATA NICKNAME: boca STARTING: false RUNNING: true STOPPING: false KEYS: true QUIET: false INPORT: not_set INHOST: localhost OUTPORT: 1337 OUTHOST: 127.0.0.1

Ahora vamos a crear un túnel de cliente, la única diferencia será que utilizaremos las opciones inhost e inport para indicar donde escuchará el túnel:

setnick oreja
OK Nickname set to oreja
newkeys
OK b6cXR~oiErbaKfOpKF~QxXpuR2cLBfjYDk~l4PejRUdcOInb3Ncx~yiSjd-XcIGkDd3WPvXJPcL1sU8Vugj6REv4B17bYi9mQ1W5D~WIEuoSFXVF-Xs8Byd4C4APqjAZvg6mtwzKlk5WT4ElJr5YDf-Z9VCXcn02rmXDVHtpsS-0shfgSGZTvJwpqeOw0dLGY4WjCtiEUcdBsEDmpppoqI5Lhb8TG2O7NqDt3tGsbUtum57gbZ~GigAM7s1p6xDFPqzUpcm~wwEy497gaxp09vYSZTm6QOEyy2DDufVt4Ov1bm3zk2g9f~LdzP0JKn0Rx0cGC9Bl0NqN4mKvlq4ogZe7wO-83YAweWy8XwEKJ6cc8TQX5eUuBIKtylHpqqgFseaeaX-9m8MenjF-bxZGuDkLOt5Qp5OJ1ao6najkkpPq9~WbhonsTIiKhpP4dmTnrNY2Qd3jTaMh1wL4JPd-VasPaVgVyRWchBy08OPCmXxtbtDp8camA8BWDfgUVModAAAA
inhost 127.0.0.1
OK inhost set
inport 37337
OK inbound port set
start
OK tunnel starting

Una vez levantados ambos túneles para llegar a nuestro netcat primero tendremos que especificar la key del mismo que obtuvimos cuando lo seteamos y esto será lo primero que enviemos, por ejemplo:

nc 127.0.0.1 37337
xLv5x6OvpQoTf40HJYnK0DnT0XpFlmEc2-J28EHdBADFHOinsThQPrV-isFYNXb~Lsm5ZnjTb4sVVYbKwfqLMNHZjGja~kObhjGleR5GqSbj76LI~OOjw6C5iyVsAzYp2lu-WQcTom0mdEAeHmtlWlEVhbWfL24ULZ6V703QqJAAXwdUP11Vf9muvkL388IF6s2Ovj8oaR4WyyELxFvxQoZtfEoLOfG~Jn3IxVMjZpKvAI5MZIOvuINU7QLLgnI0llj4715Pfsok65vNtA7tGGdbZtSQMXJcwMNlRfSjLU1kaQf1FkE~XDmYjMmN8rY5nxU~1K4akZQTFmLa6VDyrHW6zsIwlajqJhdXx-f~P6cYvQ7qoLJFzrGPF-935IuJxVDCc-BCOc5YbHW4qpVCQYLLDJmuGz5KtX4dkcFgtn1JVuwuKwHEV4P0thN4NDMKOTuxXNNHtLWOA4iC~ltVs5wk9vX89PpN8S36NKc-8iJHlEjCisRyUhFgPgcXJVUIAAAA
hola

La primera linea le indicará a BOB a donde tiene que dirigirse y nosotros enviamos un hola, el cual podremos ver en nuestros netcat:

nc -l -s 127.0.0.1 -p 1337 -vvvv
listening on [127.0.0.1] 1337 ...
DNS fwd/rev mismatch: kserv != localhost.localdomain
connect to [127.0.0.1] from kserv [127.0.0.1] 46504
b6cXR~oiErbaKfOpKF~QxXpuR2cLBfjYDk~l4PejRUdcOInb3Ncx~yiSjd-XcIGkDd3WPvXJPcL1sU8Vugj6REv4B17bYi9mQ1W5D~WIEuoSFXVF-Xs8Byd4C4APqjAZvg6mtwzKlk5WT4ElJr5YDf-Z9VCXcn02rmXDVHtpsS-0shfgSGZTvJwpqeOw0dLGY4WjCtiEUcdBsEDmpppoqI5Lhb8TG2O7NqDt3tGsbUtum57gbZ~GigAM7s1p6xDFPqzUpcm~wwEy497gaxp09vYSZTm6QOEyy2DDufVt4Ov1bm3zk2g9f~LdzP0JKn0Rx0cGC9Bl0NqN4mKvlq4ogZe7wO-83YAweWy8XwEKJ6cc8TQX5eUuBIKtylHpqqgFseaeaX-9m8MenjF-bxZGuDkLOt5Qp5OJ1ao6najkkpPq9~WbhonsTIiKhpP4dmTnrNY2Qd3jTaMh1wL4JPd-VasPaVgVyRWchBy08OPCmXxtbtDp8camA8BWDfgUVModAAAA
hola

Si os fijáis en nuestro netcat también hemos recibido la llave de nuestro túnel cliente.

Ahora que ya sabemos cómo levantar túneles, pararlos y borrarlos es muy sencillo:

BOB 00.00.10
OK
getnick oreja
OK Nickname set to oreja
stop
OK tunnel stopping
clear
OK cleared
getnick boca
OK Nickname set to boca
stop
OK tunnel stopping
clear
OK cleared
list
OK Listing done

Como veis es tan simple como parar el túnel y lanzar un clear.

Pues con esto ya tenéis una forma sencilla de montar a través de I2P, de una manera muy sencilla, prácticamente cualquier aplicación TCP que se os ocurra jeje ahora no tenéis excusa de que es complicado.

Espero os haya gustado, un saludo, y como siempre; muchas gracias por vuestra visita!

Publicado en i2p, tools, tutorial | 1 comentario

HackerOne 212 CTF Writeup

Ya se que había prometido otros writeups antes que este pero es que si no me paran de poner ctf’s así no hay quien pueda, aprovecho que para este no hubo manera más que escribir un writeup para compartirlo con vosotros a ver que os parece.

Enunciado:
An engineer of acme.org launched a new server for a new admin panel at
http://104.236.20.43/. He is completely confident that the server can’t be hacked. He added a
tripwire that notifies him when the flag file is read. He also noticed that the default Apache
page is still there, but according to him that’s intentional and doesn’t hurt anyone. Your goal?
Read the flag!

Writeup:

En la url que nos dan podemos ver la página por defecto de Apache (versión de Ubuntu) que nos mencionan en el enunciado, después de buscar un poco me encontré con algo interesante en la uri /flag con el siguiente resultado:

El hecho de que nos den el dominio y la referencia a un panel de administrador me llevo a probar poniendo distintos dominios en mi archivo de hosts apuntando a esa ip resultando en un 200 y una cookie:

 Probamos a poner la cookie a yes:

GET no está permitido, así que la siguiente opción a probar es POST:

Parece que falta algo. Mientras tanto dirbuster encontró un par de uris interesantes, /read.php y /reset.php, el segundo solo me devolvía ok pero el primero parecía mucho más prometedor:

Después de varios intentos pasando el parámetro row como json (por el tipo de respuesta que recibí), url e incluso en una cookie me decidí por volver al index y probar el post allí:

Ok, espera un dominio, vamos a añadirlo:

Tiene que ser un .com:

Extraño, probamos añadiendo otro .com:

Parece que el dominio tiene que seguir el formato 212.domain.com:

Volvemos a read.php a ver que hay esta vez ahí:

Decodificando el base64 nos muestra el contenido del website, así que parece que estamos ante una vulnerabilidad SSRF así que apuntamos nuestro dominio a 127.0.0.1 y repetimos la llamada:

Esta vez obtenemos la página de default de Apache nuevamente, pero ahora podemos intentar encontrar otros servicios añadiendo un puerto a la llamada, luego de un rato encontré algo interesante en el puerto 1337:

Esta vez obtenemos el mensaje “Hmm, where would it be?”  La página de flag parece el sitio obvio pero el problema es que las llamadas terminan siendo del estilo /flag.com así que necesitaba escapar el .com pero los caracteres habituales no estaban permitidos. Así que vamos a intentar mover el .com a otro header:

Pero la respuesta esta vacía, espera, no subían los ID de uno en uno? Acabamos de saltar del ID 10 al 12, vamos a ver que hay en el ID 11:

Bingo! Decodificamos el base64 y encontramos la flag:

La verdad es que la prueba ha sido muy interesante así como un gran quebradero de cabeza, aquí queda todo muy bonito pero la verdad es que fueron varios días de pegarse contra un muro en cada nuevo avance, pero ha sido una gran experiencia.

Espero os haya gustado y, como siempre, gracias por vuestra visita!

Publicado en ctf, hackerone, web, writeups | 3 comentarios

Cybercamp 2017 Online – 09. Cryptic messages [400]

Por un momento dejamos forense a un lado para volver con cripto, nos dan el siguiente enunciado y links:

Encrypted messages have been shared in a multi-user network. The goal is to get the sent message in plain text. Examine the contents of the file associated with this challenge to get the sent message.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective9_a.txt

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective9_b.txt

Ambos ficheros son idénticos salvo que uno aparecen los datos en español y en el otro en inglés, por pereza me quede con el de inglés y al abrirlo me encontré con esto:

Ahí podemos ver los siguientes datos:

  • Un número primo
  • Un generator
  • Mensajes cifrados
  • Intercambio de claves

El enunciado no nos da ninguna pista sobre el tipo de cifrado pero los datos anteriormente mencionados nos dan  una base para empezar a buscar.

Para empezar parece ser una clave de cifrado asimétrica del estilo de RSA, aunque esta utiliza dos números primos en lugar de un primo y un generator, así que centrémonos en esas características para nuestra búsqueda.

Después de andar rebuscando, viendo listados de cifrados, etc, etc finalmente volví a terminar en la wikipedia donde leí esto:

the ElGamal encryption system is an asymmetric key encryption algorithm for public-key cryptography which is based on the Diffie–Hellman key exchange.

Parece que cumple con el primer criterio y revisando el algoritmo efectivamente utilizan un número primo y un generator, parece que tenemos vencedor. No os penséis que esto fue tan fácil, realmente me tiré un buen rato buscando, leyendo, y probando jeje Diffie-Hellman precisamente me tuvo entretenido un rato pero fue la pista final para llegar a ElGamal.

Buscando sobre como poder atacar elGamal me encontré el siguiente artículo, muy interesante, donde explica todo el proceso: http://jceipek.com/Cracking-ElGamal/

Así que tenemos la siguiente información:

K = g^{a} (mod p)

p = 668086880889731962133523431807175727
g = 5
a = (desconocido)

Siendo K las claves públicas podemos intentar crackear “a” de forma relativamente sencilla:

p = 668086880889731962133523431807175727L
g = 5

ks = [
	13676350792300656720415722840537517L,
	203945637215597518230545505171659679L,
	580366026388626537671567427495532104L,
	44183384276523077372058753373688245L,
	285030156272853013220480705095447260L,
	357012145447722165249748761535461006L,
	390029735669441452196274751955684179L,
	601989706928792605813992011832479199L,
	360961284583613898695965394387421236L,
	139941716626953418230482445280581903L,
	105881177968778568798759564195833907L,
	390526685498939106176110574061595602L,
	563639529202234758731368531968832147L,
	324245072881445330437040962443118945L,
	405610708257034412823729058735169540L,
	650262519644970696024389370642695650L,
	213432877935741336033450896689174194L,
	353552678930580044120885303672148957L,
	243663467386438261103795683502533121L,
	60054856901287017831260389123964788L,
	47619151582173839369440869144212671L
]

for k in ks:
	print "Testing key: %s" % k
	for i in xrange(0, 10000):
		if k == pow(g,i,p):
			print "FOUND:	%s " % i
			break
		elif i==9999:
			print "Password not found"

Como vemos en el script se itera por todas las claves públicas y por cada una se prueban 10000 posibles valores de “a”, ejecutamos el script y obtenemos lo siguiente:

Hemos tenido suerte y hemos conseguido encontrar un valor valido: 5713

Ahora tenemos:

  • Los mensajes cifrados utilizando las claves públicas y privadas.
  • Las 21 claves públicas utilizadas.
  • Una clave privada, 5713, utilizada para cifrar alguno de los mensajes.

El siguiente paso sera iterar por todos los mensajes utilizando la información que conocemos para encontrar aquellos cifrados con nuestra clave privada y ver que contienen:

import binascii, string

ks = [
	13676350792300656720415722840537517L,
	203945637215597518230545505171659679L,
	580366026388626537671567427495532104L,
	44183384276523077372058753373688245L,
	285030156272853013220480705095447260L,
	357012145447722165249748761535461006L,
	390029735669441452196274751955684179L,
	601989706928792605813992011832479199L,
	360961284583613898695965394387421236L,
	139941716626953418230482445280581903L,
	105881177968778568798759564195833907L,
	390526685498939106176110574061595602L,
	563639529202234758731368531968832147L,
	324245072881445330437040962443118945L,
	405610708257034412823729058735169540L,
	650262519644970696024389370642695650L,
	213432877935741336033450896689174194L,
	353552678930580044120885303672148957L,
	243663467386438261103795683502533121L,
	60054856901287017831260389123964788L,
	47619151582173839369440869144212671L
]

ms = [
	275023513241996465145375277081798608L,
	447218054680404751018822774460718704L,
	51995582795200573676963225532291674L,
	193223721789665268065712251555969216L,
	220335814464633181853626310867800188L,
	656425673616840602129167597679995093L,
	281892485332165528077148251112629012L,
	620557294483014348860918835366093395L,
	156345492853024516725256648981773406L,
	132200864409682167694544306450049620L,
	382432406296505241913643555684753752L,
	172521731908572948160105617230206656L,
	658413611309329150536039577629832733L,
	470009248009045054893716168409231672L,
	23596506422783336435053882014037130L,
	383558469957245595047304146183172589L,
	347874231426543687257153625634545539L,
	67459688204264591154317629916556269L,
	191215507340327093723036088461066387L,
	115117630595934113621417863594045891L,
	664015760731773907898900144736007853L,
	595217394235485536046669899798176478L,
	112023097890488836143086615204661790L,
	608874679440735925600052610265281796L,
	627004193985581843968567471204709309L,
	400371059170563645226682976240507021L,
	275561561380430753130008463891051319L,
	200330734437451947551782935576820286L,
	4050142404262389618647986897000959L,
	23146488724874171376119071203201823L,
	301084425566731188968143030280327612L,
	661999379372886369576256038659921506L,
	538840376896108158028033793328837055L,
	628613307485444872721287063540568485L,
	268637255868335003688434687411074993L,
	381198387780204467302612163348706704L,
	400162560639994092221980422692908055L,
	399884623550765435890595082239306353L,
	95290873877305597733967646180307586L,
	641264950193834896903186128424472068L,
	43114514832635661215282858829006066L,
	68848632281350060105250861040771224L,
	139026874478930635813093749231601370L,
	655054596740951208790111828671407650L,
	651375195158994899657890599658048856L,
	285442090376771814189050634199458623L,
	982626333322476170131864630408090L,
	469354413955364991082951491284192153L,
	103793433289712076190450408975699625L,
	4766500844846659360508423238089711L,
	377669527108872822305052284949357020L,
	95920750238990748132617870809588151L,
	127278808060571896803384740938668807L,
	189601784199791219483320087267882549L,
	344196550998639525901987791134561537L,
	263650727383674608586010904392328918L,
	459739916775104719487159379591490295L,
	439037356963229048061191227105627374L,
	186379926031613967999671113768565225L,
	84951650617004032168830381676866149L,
	656944761086661565220056094921318296L,
	502980701175656560313734064531551071L,
	107271094854895401072269844571403805L,
	516400490889683786305851199913815487L,
	606808728818715487827728440626551855L,
	27411826797353775333603907921745463L,
	524397563941504625880910396018932380L,
	24021136517611978297227685711419170L,
	219047882901615601296318017152053796L,
	42988869817116390289497212345458978L,
	356011675196335642115022112592576960L,
	223494308152020204522016556367321846L,
	346356309073576552673987939313043383L,
	599172108441353432011552211209759120L,
	286703909778039270880661258004633674L,
	660051626702153873713990679214106770L,
	141402079720691873145676175151050276L,
	242429047870131231642110013163376117L,
	193213311272454674555953883981535401L,
	350431438249475996960516854823204070L,
	406755029946632926255211620049600144L,
	298956115564633149551111642911769177L,
	624983588666681197516867067080227343L,
	322865886478608435617642618336886528L,
	484310864483152708576021119100590468L,
	323317770963134415387616019546124150L,
	664611512535013863159898484781401394L,
	564091952146454446893647704186484295L,
	612037128288224063949207003244931903L,
	143546506514694697702580740506451057L,
	474806893256685165420572727361313727L,
	239612759211713177457242520864545373L,
	74787785262221388851642570545110090L,
	274719943084337263336901857643803025L,
	502725889933552791883959493172359564L,
	575862093313626652925425410032589465L,
	505698177665487415454788766346780242L,
	581461780713181428956776682676939535L,
	530397494115930081791582949104886302L,
	285801387076390876754579887639733109L,
	510921457560136739170187973639958611L,
	663500891194754312048932854322793679L,
	463343466711415614750405955546091366L,
	221203346954627052668479687662911260L,
	189469132893167348761976530592996989L,
	188603058226806753069769225787858738L,
	616194194941484971188276658095704275L,
	113202092462663629728701607894834865L,
	309886466150813197844325706680318621L,
	639471373224136177331540772282298710L,
	192932334651310913857988456012323837L,
	114816913019746305825440313210515565L,
	74828199087438656125488068396634735L,
	522732653872542903229762834179641882L,
	191584423265039561925713828567071717L,
	227787869970564063041296346104679887L,
	306891653972344582241361176850584407L,
	392274172021885022443850587414407011L,
	125559738428408720475644102324838556L,
	615364216773625903334625795559421169L,
	500057421841703584877403678260138799L,
	260070084421235847074282002455457252L,
	187600596342100486089171096561896931L,
	339635057512093364991610116021953342L,
	339110300499989182998368511866157833L,
	660779395639316212241686437332003362L,
	329095027993074595919695551410540583L,
	140605789490440930875187497544296460L,
	257176879402866603529816355782375986L,
	324120980584346851162216090452979977L,
	194387168439381116078942591916009397L,
	175995255161919702861081374240179288L,
	259572006909692576380172420589925452L,
	509638935328899883642651178414675943L,
	298090377811497995789786927516761223L,
	55053603143546713705199061614172199L,
	211194736508204713045164972691471559L,
	322643858284619135628948880605163328L,
	439668266247815895970171643710455379L,
	587820837884352136815268545013060251L,
	95753039954214631842487951960885318L,
	491620200566522347901236852867785307L,
	301780054420658208572651245649627539L,
	351451218715182319868764656094037520L,
	89539648924955438094086602983260782L,
	166704048535849478418519555410161074L,
	389820252475886726351349233054499366L,
	85845598060256819271577218812087780L,
	118024352385516021924162367848038300L,
	134454254807443906815016665983042484L,
	635605035001932628742852236741891992L,
	285472755901244094520983263238312924L,
	242112294852247232052558862110026552L,
	555253203134618755614672537833547733L,
	255188187487970487505231795251002256L,
	362408360464855976002489117110507504L,
	497798205064839028989840950145093903L,
	664598263130956335111813563348353854L,
	176248945524152414626381741808780582L,
	459320289109161198395771953215785644L,
	352241435713696262643915518276547395L,
	299109270475944905422148853708209824L,
	605389275264832802088211224918956056L,
	270428096336061713906253329149472894L,
	118236816750358362845164515718656153L,
	413485833771564678539647748788319049L,
	523462356290280371241112889147181889L,
	70447181971292666325002616079110879L,
	94208126463978995542294456139862677L,
	175200039423318692241081357349657280L,
	33148743030138295425863598894494680L,
	21237242841043549932136698852470846L,
	71957619258305017989437299179723715L,
	563661543710991717276574237793420753L,
	639429223748100829821152259664648759L,
	111682601189739995895306397620637428L,
	86069271466041748677971387575107561L,
	32781001024753003354920591047220459L,
	304680222370252324708846074103480953L,
	412468073256502561255069087528766427L,
	281036079681016522949370175392467269L,
	52602357085365575792478273909939590L,
	521705544428555254953998581032264483L,
	523357143576414494615671730610365650L,
	49383328153585943265768459507402214L,
	325319666760700489505055717374892372L,
	571546298787029679777929059902713655L,
	487909322255400265409025779925892990L,
	393785198212849758008912370728252216L,
	566956552334637565880432440938357002L,
	34318900912105668553839995901038535L
]

p = 668086880889731962133523431807175727L
g = 5
a = 5713

def is_printable(input_str):
	return all(ord(c) < 127 and c in string.printable for c in input_str)

def decrypt(r, c, a, p):
    return (pow(r,p-1-a,p)*c) % p

for m in ms:
  for k in ks:
    dec = decrypt(k , m , a , p)
    hexnum = hex(dec)

    if len(hexnum)%2 == 0:
      hexnum = "0x0" + hexnum[2:]

    message = binascii.unhexlify(hexnum[2:-1])

    if is_printable(message):
      print "c1: %s \nc2: %s \nmessage: %s"  % (k, m , message)

Ejecutamos el script y obtenemos el siguiente resultado:

Como solo hay un resultado está claro que nuestra flag es: crypt0_w0rld=)

Espero os haya gustado, un saludo!

Publicado en cripto, ctf, cybercamp, writeups | Deja un comentario

Cybercamp 2017 Online – 08. Elephant memory [200]

Y seguimos con forense, que me encanta, esta vez tenemos el siguiente enunciado y link:

During the investigation of a case of money laundering, it was possible to acquire the ram (.vmem) file of the virtual machine, but no the disk image. It is known that the organization that was doing money laundering was using a means of payment through a web service to receive the commissions. It is needed to get the password in order to access to the account that used the online payment and see the list of transactions received.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective8.raw

Esta vez parece que no tenemos una imágen de disco sino de memoria, tocará sacarle el polvo a volatility, primero veamos que tipo de imagen es:

volatility imageinfo -f objective8.raw

Nos da tres posibles perfiles, decidí quedarme con el primero, vamos a ver que procesos están corriendo:

Los procesos más interesantes son KeePass, Chrome, wordpad y notepad ya que son los que más probabilidades tienen de contener una contraseña.

Vamos a comenzar con Keepass, creamos un directorio para dumpear el proceso y lanzamos el siguiente comando:

mkdir o8
volatility memdump -p 1336 --profile Win7SP1x86_23418 -f objective8.raw --dump-dir=o8/

Como veis le he especificado el PID del proceso, en este caso 1336 y nos ha guardado el dump en la carpeta que hemos creado.

¿Que suele ser lo más facil para buscar cadenas de texto en un binario? Nuestro viejo amigo strings, le pasamos un less para poder hacer busquedas y ver poco a poco la información de la siguiente manera:

 strings o8/1336.dmp | less

Por si no lo sabéis en less podéis buscar texto utilizando la / y a continuación el texto a buscar, por ejemplo:

Precisamente esa es la primera búsqueda que se me ocurrió, pulsamos enter para que encuentre la primera coincidencia y para las siguientes simplemente escribimos / de nuevo y pulsamos enter para ver las siguientes coincidencias.

A la cuarta coincidencia parece que hemos tenido suerte:

Probamos y efectivamente la flag es: Birds_fly_cats_not

Gracias por vuestra visita, un saludo!

Publicado en ctf, cybercamp, forense, writeups | Deja un comentario

Cybercamp 2017 Online – 07. Holidays [200]

Esta prueba me pareció un tanto curiosa y la verdad es que tuve suerte de que sea un tema en el que he estado trabajando en los últimos meses ya que me permitió sacarla bastante rápido, pero vamos al lío, nos dan el siguiente enunciado y link:

A well-known sportsman has requested for a vacation from a travel agency. He asked for the required discretion in the destiny to avoid being persecuted by paparazzi. The president of the travel company devised a document to keep it secret.

Due to a leak of information through an agency employee, a magazine got the file called FLAG.zip. Could you review its content and thus determine if the filtered information is reliable?

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective7.zip

Lo primero que intente fue descomprimir el archivo zip, pero extrañamente me salto un error de descompresión, raro, le tiramos un file y vemos lo siguiente:

Mmm, parece que no se reconoce la cabecera, vamos a echarle un vistazo con hexdump:

Eso no es una cabecera de un ZIP o yo no he visto una en mi vida. Preguntemosle a San Google…. Más fácil dicho que hecho, después de mucho buscar termine en el articulo sobre archivos STL de la wikipedia donde decía lo siguiente:

The Materialise Magics software uses the 80-byte header at the top of the file to represent the overall color of the entire part. If color is used, then somewhere in the header should be the ASCII string “COLOR=” followed by four bytes representing red, green, blue and alpha channel (transparency) in the range 0–255. This is the color of the entire object, unless overridden at each facet. Magics also recognizes a material description; a more detailed surface characteristic. Just after “COLOR=RGBA” specification should be another ASCII string “,MATERIAL=” followed by three colors (3×4 bytes): first is a color of diffuse reflection, second is a color of specular highlight, and third is an ambient light. Material settings are preferred over color.

Parece que tenemos un ganador, vamos a probar a abrir el archivo con un software de impresión 3D, en mi caso utilizo Repetier-Host para mi impresora así que ya lo abrí en el, et voila:

Como bien podéis leer la flag final es Habana.

Espero os haya gustado, un saludo y gracias por vuestra visita!

Publicado en ctf, cybercamp, forense, writeups | 2 comentarios

Cybercamp 2017 Online – 06. Pretty flowers [300]

Superando el tercio de pruebas vamos a por la sexta que nos deja el siguiente enunciado y link:

This exercise consists of three files: an executable, an image and an encrypted 7z. Somehow the three files are related. Find out how and validate the flag.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective6.zip

En este caso nos dan una imagen, un archivo 7z y un binario, como animal de costumbres que soy lo primero que hice fue investigar la imagen a ver si encontraba algo pero después de darle mil vueltas y perder un tiempo valioso decidí irme a por el binario a ver si tenía más suerte, lo cargue en gdb con peda e hice un disas main:

   0x56555700 <+0>:     lea    ecx,[esp+0x4]
   0x56555704 <+4>:     and    esp,0xfffffff0
   0x56555707 <+7>:     push   DWORD PTR [ecx-0x4]
   0x5655570a <+10>:    push   ebp
   0x5655570b <+11>:    mov    ebp,esp
   0x5655570d <+13>:    push   edi
   0x5655570e <+14>:    push   esi
   0x5655570f <+15>:    push   ebx
   0x56555710 <+16>:    push   ecx
   0x56555711 <+17>:    sub    esp,0x878
   0x56555717 <+23>:    call   0x565555d0 <__x86.get_pc_thunk.bx>
   0x5655571c <+28>:    add    ebx,0x18e4
   0x56555722 <+34>:    mov    esi,ecx
   0x56555724 <+36>:    mov    BYTE PTR [ebp-0x6d],0x41
   0x56555728 <+40>:    mov    BYTE PTR [ebp-0x6c],0x42
   0x5655572c <+44>:    mov    BYTE PTR [ebp-0x6b],0x43
   0x56555730 <+48>:    mov    BYTE PTR [ebp-0x6a],0x44
   0x56555734 <+52>:    mov    BYTE PTR [ebp-0x69],0x45
   0x56555738 <+56>:    mov    BYTE PTR [ebp-0x68],0x46
   0x5655573c <+60>:    mov    BYTE PTR [ebp-0x67],0x47
   0x56555740 <+64>:    mov    BYTE PTR [ebp-0x66],0x48
   0x56555744 <+68>:    mov    BYTE PTR [ebp-0x65],0x49
   0x56555748 <+72>:    mov    BYTE PTR [ebp-0x64],0x4a
   0x5655574c <+76>:    mov    BYTE PTR [ebp-0x63],0x4b
   0x56555750 <+80>:    mov    BYTE PTR [ebp-0x62],0x4c
   0x56555754 <+84>:    mov    BYTE PTR [ebp-0x61],0x4d
   0x56555758 <+88>:    mov    BYTE PTR [ebp-0x60],0x4e
   0x5655575c <+92>:    mov    BYTE PTR [ebp-0x5f],0x4f
   0x56555760 <+96>:    mov    BYTE PTR [ebp-0x5e],0x50
   0x56555764 <+100>:   mov    BYTE PTR [ebp-0x5d],0x51
   0x56555768 <+104>:   mov    BYTE PTR [ebp-0x5c],0x52
   0x5655576c <+108>:   mov    BYTE PTR [ebp-0x5b],0x53
   0x56555770 <+112>:   mov    BYTE PTR [ebp-0x5a],0x54
   0x56555774 <+116>:   mov    BYTE PTR [ebp-0x59],0x55
   0x56555778 <+120>:   mov    BYTE PTR [ebp-0x58],0x56
   0x5655577c <+124>:   mov    BYTE PTR [ebp-0x57],0x57
   0x56555780 <+128>:   mov    BYTE PTR [ebp-0x56],0x58
   0x56555784 <+132>:   mov    BYTE PTR [ebp-0x55],0x59
   0x56555788 <+136>:   mov    BYTE PTR [ebp-0x54],0x5a
   0x5655578c <+140>:   mov    BYTE PTR [ebp-0x53],0x5f
   0x56555790 <+144>:   mov    BYTE PTR [ebp-0x52],0x61
   0x56555794 <+148>:   mov    BYTE PTR [ebp-0x51],0x62
   0x56555798 <+152>:   mov    BYTE PTR [ebp-0x50],0x63
   0x5655579c <+156>:   mov    BYTE PTR [ebp-0x4f],0x64
   0x565557a0 <+160>:   mov    BYTE PTR [ebp-0x4e],0x65
   0x565557a4 <+164>:   mov    BYTE PTR [ebp-0x4d],0x66
   0x565557a8 <+168>:   mov    BYTE PTR [ebp-0x4c],0x67
   0x565557ac <+172>:   mov    BYTE PTR [ebp-0x4b],0x68
   0x565557b0 <+176>:   mov    BYTE PTR [ebp-0x4a],0x69
   0x565557b4 <+180>:   mov    BYTE PTR [ebp-0x49],0x6a
   0x565557b8 <+184>:   mov    BYTE PTR [ebp-0x48],0x6b
   0x565557bc <+188>:   mov    BYTE PTR [ebp-0x47],0x6c
   0x565557c0 <+192>:   mov    BYTE PTR [ebp-0x46],0x6d
   0x565557c4 <+196>:   mov    BYTE PTR [ebp-0x45],0x6e
   0x565557c8 <+200>:   mov    BYTE PTR [ebp-0x44],0x6f
   0x565557cc <+204>:   mov    BYTE PTR [ebp-0x43],0x70
   0x565557d0 <+208>:   mov    BYTE PTR [ebp-0x42],0x71
   0x565557d4 <+212>:   mov    BYTE PTR [ebp-0x41],0x72
   0x565557d8 <+216>:   mov    BYTE PTR [ebp-0x40],0x73
   0x565557dc <+220>:   mov    BYTE PTR [ebp-0x3f],0x74
   0x565557e0 <+224>:   mov    BYTE PTR [ebp-0x3e],0x75
   0x565557e4 <+228>:   mov    BYTE PTR [ebp-0x3d],0x76
   0x565557e8 <+232>:   mov    BYTE PTR [ebp-0x3c],0x77
   0x565557ec <+236>:   mov    BYTE PTR [ebp-0x3b],0x78
   0x565557f0 <+240>:   mov    BYTE PTR [ebp-0x3a],0x79
   0x565557f4 <+244>:   mov    BYTE PTR [ebp-0x39],0x7a
   0x565557f8 <+248>:   cmp    DWORD PTR [esi],0x1
   0x565557fb <+251>:   je     0x56555807 <main+263>
   0x565557fd <+253>:   mov    eax,0x1
   0x56555802 <+258>:   jmp    0x56555c55 <main+1365>
   0x56555807 <+263>:   sub    esp,0xc
   0x5655580a <+266>:   lea    eax,[ebx-0x1310]
   0x56555810 <+272>:   push   eax
   0x56555811 <+273>:   call   0x56555570 <exif_data_new_from_file@plt>
   0x56555816 <+278>:   add    esp,0x10
   0x56555819 <+281>:   mov    DWORD PTR [ebp-0x2c],eax
   0x5655581c <+284>:   cmp    DWORD PTR [ebp-0x2c],0x0
   0x56555820 <+288>:   jne    0x56555847 <main+327>
   0x56555822 <+290>:   mov    eax,DWORD PTR [esi+0x4]
   0x56555825 <+293>:   add    eax,0x4
   0x56555828 <+296>:   mov    eax,DWORD PTR [eax]
   0x5655582a <+298>:   sub    esp,0x8
   0x5655582d <+301>:   push   eax
   0x5655582e <+302>:   lea    eax,[ebx-0x1304]
   0x56555834 <+308>:   push   eax
   0x56555835 <+309>:   call   0x56555500 <printf@plt>
   0x5655583a <+314>:   add    esp,0x10
   0x5655583d <+317>:   mov    eax,0x2
   0x56555842 <+322>:   jmp    0x56555c55 <main+1365>
   0x56555847 <+327>:   mov    DWORD PTR [ebp-0x28],0x0
   0x5655584e <+334>:   jmp    0x56555b04 <main+1028>
   0x56555853 <+339>:   cmp    DWORD PTR [ebp-0x28],0x0
   0x56555857 <+343>:   jne    0x5655590a <main+522>
   0x5655585d <+349>:   lea    eax,[ebp-0x881]
   0x56555863 <+355>:   mov    ecx,0x64
   0x56555868 <+360>:   mov    esi,0x0
   0x5655586d <+365>:   mov    DWORD PTR [eax],esi
   0x5655586f <+367>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x56555873 <+371>:   lea    edx,[eax+0x4]
   0x56555876 <+374>:   and    edx,0xfffffffc
   0x56555879 <+377>:   sub    eax,edx
   0x5655587b <+379>:   add    ecx,eax
   0x5655587d <+381>:   and    ecx,0xfffffffc
   0x56555880 <+384>:   shr    ecx,0x2
   0x56555883 <+387>:   mov    edi,edx
   0x56555885 <+389>:   mov    eax,esi
   0x56555887 <+391>:   rep stos DWORD PTR es:[edi],eax
   0x56555889 <+393>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x5655588d <+397>:   mov    BYTE PTR [ebp-0x881],al
   0x56555893 <+403>:   movzx  eax,BYTE PTR [ebp-0x44]
   0x56555897 <+407>:   mov    BYTE PTR [ebp-0x880],al
   0x5655589d <+413>:   movzx  eax,BYTE PTR [ebp-0x4d]
   0x565558a1 <+417>:   mov    BYTE PTR [ebp-0x87f],al
   0x565558a7 <+423>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x565558ab <+427>:   mov    BYTE PTR [ebp-0x87e],al
   0x565558b1 <+433>:   movzx  eax,BYTE PTR [ebp-0x3c]
   0x565558b5 <+437>:   mov    BYTE PTR [ebp-0x87d],al
   0x565558bb <+443>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x565558bf <+447>:   mov    BYTE PTR [ebp-0x87c],al
   0x565558c5 <+453>:   movzx  eax,BYTE PTR [ebp-0x41]
   0x565558c9 <+457>:   mov    BYTE PTR [ebp-0x87b],al
   0x565558cf <+463>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x565558d3 <+467>:   mov    BYTE PTR [ebp-0x87a],al
   0x565558d9 <+473>:   sub    esp,0xc
   0x565558dc <+476>:   lea    eax,[ebp-0x881]
   0x565558e2 <+482>:   push   eax
   0x565558e3 <+483>:   call   0x56555560 <exif_tag_from_name@plt>
   0x565558e8 <+488>:   add    esp,0x10
   0x565558eb <+491>:   mov    DWORD PTR [ebp-0x30],eax
   0x565558ee <+494>:   mov    eax,DWORD PTR [ebp-0x2c]
   0x565558f1 <+497>:   mov    eax,DWORD PTR [eax]
   0x565558f3 <+499>:   sub    esp,0x8
   0x565558f6 <+502>:   push   DWORD PTR [ebp-0x30]
   0x565558f9 <+505>:   push   eax
   0x565558fa <+506>:   call   0x56555550 <exif_content_get_entry@plt>
   0x565558ff <+511>:   add    esp,0x10
   0x56555902 <+514>:   mov    DWORD PTR [ebp-0x24],eax
   0x56555905 <+517>:   jmp    0x56555b00 <main+1024>
   0x5655590a <+522>:   cmp    DWORD PTR [ebp-0x28],0x1
   0x5655590e <+526>:   jne    0x56555a11 <main+785>
   0x56555914 <+532>:   lea    eax,[ebp-0x881]
   0x5655591a <+538>:   mov    ecx,0x64
   0x5655591f <+543>:   mov    esi,0x0
   0x56555924 <+548>:   mov    DWORD PTR [eax],esi
   0x56555926 <+550>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x5655592a <+554>:   lea    edx,[eax+0x4]
   0x5655592d <+557>:   and    edx,0xfffffffc
   0x56555930 <+560>:   sub    eax,edx
   0x56555932 <+562>:   add    ecx,eax
   0x56555934 <+564>:   and    ecx,0xfffffffc
   0x56555937 <+567>:   shr    ecx,0x2
   0x5655593a <+570>:   mov    edi,edx
   0x5655593c <+572>:   mov    eax,esi
   0x5655593e <+574>:   rep stos DWORD PTR es:[edi],eax
   0x56555940 <+576>:   movzx  eax,BYTE PTR [ebp-0x65]
   0x56555944 <+580>:   mov    BYTE PTR [ebp-0x881],al
   0x5655594a <+586>:   movzx  eax,BYTE PTR [ebp-0x46]
   0x5655594e <+590>:   mov    BYTE PTR [ebp-0x880],al
   0x56555954 <+596>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x56555958 <+600>:   mov    BYTE PTR [ebp-0x87f],al
   0x5655595e <+606>:   movzx  eax,BYTE PTR [ebp-0x4c]
   0x56555962 <+610>:   mov    BYTE PTR [ebp-0x87e],al
   0x56555968 <+616>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x5655596c <+620>:   mov    BYTE PTR [ebp-0x87d],al
   0x56555972 <+626>:   movzx  eax,BYTE PTR [ebp-0x6a]
   0x56555976 <+630>:   mov    BYTE PTR [ebp-0x87c],al
   0x5655597c <+636>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555980 <+640>:   mov    BYTE PTR [ebp-0x87b],al
   0x56555986 <+646>:   movzx  eax,BYTE PTR [ebp-0x40]
   0x5655598a <+650>:   mov    BYTE PTR [ebp-0x87a],al
   0x56555990 <+656>:   movzx  eax,BYTE PTR [ebp-0x50]
   0x56555994 <+660>:   mov    BYTE PTR [ebp-0x879],al
   0x5655599a <+666>:   movzx  eax,BYTE PTR [ebp-0x41]
   0x5655599e <+670>:   mov    BYTE PTR [ebp-0x878],al
   0x565559a4 <+676>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x565559a8 <+680>:   mov    BYTE PTR [ebp-0x877],al
   0x565559ae <+686>:   movzx  eax,BYTE PTR [ebp-0x43]
   0x565559b2 <+690>:   mov    BYTE PTR [ebp-0x876],al
   0x565559b8 <+696>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x565559bc <+700>:   mov    BYTE PTR [ebp-0x875],al
   0x565559c2 <+706>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x565559c6 <+710>:   mov    BYTE PTR [ebp-0x874],al
   0x565559cc <+716>:   movzx  eax,BYTE PTR [ebp-0x44]
   0x565559d0 <+720>:   mov    BYTE PTR [ebp-0x873],al
   0x565559d6 <+726>:   movzx  eax,BYTE PTR [ebp-0x45]
   0x565559da <+730>:   mov    BYTE PTR [ebp-0x872],al
   0x565559e0 <+736>:   sub    esp,0xc
   0x565559e3 <+739>:   lea    eax,[ebp-0x881]
   0x565559e9 <+745>:   push   eax
   0x565559ea <+746>:   call   0x56555560 <exif_tag_from_name@plt>
   0x565559ef <+751>:   add    esp,0x10
   0x565559f2 <+754>:   mov    DWORD PTR [ebp-0x34],eax
   0x565559f5 <+757>:   mov    eax,DWORD PTR [ebp-0x2c]
   0x565559f8 <+760>:   mov    eax,DWORD PTR [eax]
   0x565559fa <+762>:   sub    esp,0x8
   0x565559fd <+765>:   push   DWORD PTR [ebp-0x34]
   0x56555a00 <+768>:   push   eax
   0x56555a01 <+769>:   call   0x56555550 <exif_content_get_entry@plt>
   0x56555a06 <+774>:   add    esp,0x10
   0x56555a09 <+777>:   mov    DWORD PTR [ebp-0x20],eax
   0x56555a0c <+780>:   jmp    0x56555b00 <main+1024>
   0x56555a11 <+785>:   lea    eax,[ebp-0x881]
   0x56555a17 <+791>:   mov    ecx,0x64
   0x56555a1c <+796>:   mov    esi,0x0
   0x56555a21 <+801>:   mov    DWORD PTR [eax],esi
   0x56555a23 <+803>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x56555a27 <+807>:   lea    edx,[eax+0x4]
   0x56555a2a <+810>:   and    edx,0xfffffffc
   0x56555a2d <+813>:   sub    eax,edx
   0x56555a2f <+815>:   add    ecx,eax
   0x56555a31 <+817>:   and    ecx,0xfffffffc
   0x56555a34 <+820>:   shr    ecx,0x2
   0x56555a37 <+823>:   mov    edi,edx
   0x56555a39 <+825>:   mov    eax,esi
   0x56555a3b <+827>:   rep stos DWORD PTR es:[edi],eax
   0x56555a3d <+829>:   movzx  eax,BYTE PTR [ebp-0x65]
   0x56555a41 <+833>:   mov    BYTE PTR [ebp-0x881],al
   0x56555a47 <+839>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x56555a4b <+843>:   mov    BYTE PTR [ebp-0x880],al
   0x56555a51 <+849>:   movzx  eax,BYTE PTR [ebp-0x5f]
   0x56555a55 <+853>:   mov    BYTE PTR [ebp-0x87f],al
   0x56555a5b <+859>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x56555a5f <+863>:   mov    BYTE PTR [ebp-0x87e],al
   0x56555a65 <+869>:   movzx  eax,BYTE PTR [ebp-0x43]
   0x56555a69 <+873>:   mov    BYTE PTR [ebp-0x87d],al
   0x56555a6f <+879>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555a73 <+883>:   mov    BYTE PTR [ebp-0x87c],al
   0x56555a79 <+889>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555a7d <+893>:   mov    BYTE PTR [ebp-0x87b],al
   0x56555a83 <+899>:   movzx  eax,BYTE PTR [ebp-0x4f]
   0x56555a87 <+903>:   mov    BYTE PTR [ebp-0x87a],al
   0x56555a8d <+909>:   movzx  eax,BYTE PTR [ebp-0x5c]
   0x56555a91 <+913>:   mov    BYTE PTR [ebp-0x879],al
   0x56555a97 <+919>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x56555a9b <+923>:   mov    BYTE PTR [ebp-0x878],al
   0x56555aa1 <+929>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x56555aa5 <+933>:   mov    BYTE PTR [ebp-0x877],al
   0x56555aab <+939>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x56555aaf <+943>:   mov    BYTE PTR [ebp-0x876],al
   0x56555ab5 <+949>:   movzx  eax,BYTE PTR [ebp-0x45]
   0x56555ab9 <+953>:   mov    BYTE PTR [ebp-0x875],al
   0x56555abf <+959>:   movzx  eax,BYTE PTR [ebp-0x4c]
   0x56555ac3 <+963>:   mov    BYTE PTR [ebp-0x874],al
   0x56555ac9 <+969>:   movzx  eax,BYTE PTR [ebp-0x40]
   0x56555acd <+973>:   mov    BYTE PTR [ebp-0x873],al
   0x56555ad3 <+979>:   sub    esp,0xc
   0x56555ad6 <+982>:   lea    eax,[ebp-0x881]
   0x56555adc <+988>:   push   eax
   0x56555add <+989>:   call   0x56555560 <exif_tag_from_name@plt>
   0x56555ae2 <+994>:   add    esp,0x10
   0x56555ae5 <+997>:   mov    DWORD PTR [ebp-0x38],eax
   0x56555ae8 <+1000>:  mov    eax,DWORD PTR [ebp-0x2c]
   0x56555aeb <+1003>:  mov    eax,DWORD PTR [eax+0x8]
   0x56555aee <+1006>:  sub    esp,0x8
   0x56555af1 <+1009>:  push   DWORD PTR [ebp-0x38]
   0x56555af4 <+1012>:  push   eax
   0x56555af5 <+1013>:  call   0x56555550 <exif_content_get_entry@plt>
   0x56555afa <+1018>:  add    esp,0x10
   0x56555afd <+1021>:  mov    DWORD PTR [ebp-0x1c],eax
   0x56555b00 <+1024>:  add    DWORD PTR [ebp-0x28],0x1
   0x56555b04 <+1028>:  cmp    DWORD PTR [ebp-0x28],0x2
   0x56555b08 <+1032>:  jle    0x56555853 <main+339>
   0x56555b0e <+1038>:  cmp    DWORD PTR [ebp-0x1c],0x0
   0x56555b12 <+1042>:  je     0x56555bd0 <main+1232>
   0x56555b18 <+1048>:  cmp    DWORD PTR [ebp-0x20],0x0
   0x56555b1c <+1052>:  je     0x56555bd0 <main+1232>
   0x56555b22 <+1058>:  cmp    DWORD PTR [ebp-0x24],0x0
   0x56555b26 <+1062>:  je     0x56555bd0 <main+1232>
   0x56555b2c <+1068>:  sub    esp,0x4
   0x56555b2f <+1071>:  push   0x400
   0x56555b34 <+1076>:  lea    eax,[ebp-0x881]
   0x56555b3a <+1082>:  push   eax
   0x56555b3b <+1083>:  push   DWORD PTR [ebp-0x20]
   0x56555b3e <+1086>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555b43 <+1091>:  add    esp,0x10
   0x56555b46 <+1094>:  movzx  eax,BYTE PTR [ebp-0x881]
   0x56555b4d <+1101>:  test   al,al
   0x56555b4f <+1103>:  je     0x56555bd0 <main+1232>
   0x56555b51 <+1105>:  sub    esp,0x8
   0x56555b54 <+1108>:  lea    eax,[ebp-0x881]
   0x56555b5a <+1114>:  push   eax
   0x56555b5b <+1115>:  lea    eax,[ebp-0x46d]
   0x56555b61 <+1121>:  push   eax
   0x56555b62 <+1122>:  call   0x56555530 <strcpy@plt>
   0x56555b67 <+1127>:  add    esp,0x10
   0x56555b6a <+1130>:  sub    esp,0x4
   0x56555b6d <+1133>:  push   0x400
   0x56555b72 <+1138>:  lea    eax,[ebp-0x881]
   0x56555b78 <+1144>:  push   eax
   0x56555b79 <+1145>:  push   DWORD PTR [ebp-0x24]
   0x56555b7c <+1148>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555b81 <+1153>:  add    esp,0x10
   0x56555b84 <+1156>:  sub    esp,0x8
   0x56555b87 <+1159>:  lea    eax,[ebp-0x881]
   0x56555b8d <+1165>:  push   eax
   0x56555b8e <+1166>:  lea    eax,[ebp-0x46d]
   0x56555b94 <+1172>:  push   eax
   0x56555b95 <+1173>:  call   0x56555520 <strcat@plt>
   0x56555b9a <+1178>:  add    esp,0x10
   0x56555b9d <+1181>:  sub    esp,0x4
   0x56555ba0 <+1184>:  push   0x400
   0x56555ba5 <+1189>:  lea    eax,[ebp-0x881]
   0x56555bab <+1195>:  push   eax
   0x56555bac <+1196>:  push   DWORD PTR [ebp-0x1c]
   0x56555baf <+1199>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555bb4 <+1204>:  add    esp,0x10
   0x56555bb7 <+1207>:  sub    esp,0x8
   0x56555bba <+1210>:  lea    eax,[ebp-0x881]
   0x56555bc0 <+1216>:  push   eax
   0x56555bc1 <+1217>:  lea    eax,[ebp-0x46d]
   0x56555bc7 <+1223>:  push   eax
   0x56555bc8 <+1224>:  call   0x56555520 <strcat@plt>
   0x56555bcd <+1229>:  add    esp,0x10
   0x56555bd0 <+1232>:  mov    DWORD PTR [ebp-0x481],0x0
   0x56555bda <+1242>:  mov    DWORD PTR [ebp-0x47d],0x0
   0x56555be4 <+1252>:  mov    DWORD PTR [ebp-0x479],0x0
   0x56555bee <+1262>:  mov    DWORD PTR [ebp-0x475],0x0
   0x56555bf8 <+1272>:  mov    DWORD PTR [ebp-0x471],0x0
   0x56555c02 <+1282>:  movzx  eax,BYTE PTR [ebp-0x468]
   0x56555c09 <+1289>:  mov    BYTE PTR [ebp-0x481],al
   0x56555c0f <+1295>:  movzx  eax,BYTE PTR [ebp-0x465]
   0x56555c16 <+1302>:  mov    BYTE PTR [ebp-0x480],al
   0x56555c1c <+1308>:  movzx  eax,BYTE PTR [ebp-0x467]
   0x56555c23 <+1315>:  mov    BYTE PTR [ebp-0x47f],al
   0x56555c29 <+1321>:  movzx  eax,BYTE PTR [ebp-0x46d]
   0x56555c30 <+1328>:  mov    BYTE PTR [ebp-0x47e],al
   0x56555c36 <+1334>:  movzx  eax,BYTE PTR [ebp-0x462]
   0x56555c3d <+1341>:  mov    BYTE PTR [ebp-0x47d],al
   0x56555c43 <+1347>:  movzx  eax,BYTE PTR [ebp-0x46c]
   0x56555c4a <+1354>:  mov    BYTE PTR [ebp-0x47c],al
   0x56555c50 <+1360>:  mov    eax,0x0
   0x56555c55 <+1365>:  lea    esp,[ebp-0x10]
   0x56555c58 <+1368>:  pop    ecx
   0x56555c59 <+1369>:  pop    ebx
   0x56555c5a <+1370>:  pop    esi
   0x56555c5b <+1371>:  pop    edi
   0x56555c5c <+1372>:  pop    ebp
   0x56555c5d <+1373>:  lea    esp,[ecx-0x4]
   0x56555c60 <+1376>:  ret

WOW! Como sabéis lo mio no es reversing precisamente así que me impresiono bastante ver todas estas lineas, de buenas a primeras lo que más me llamo la atención fue la llamada a strcat en la dirección 0x56555bc8 así que puse un breakpoint ahí:

¡Bien he encontrado algo, seguro que es la contraseña del 7z!… Ah pues no… jo

Y es que en mis ansías no me fijé en que a continuación se seguían realizando operaciones, así que una docena de breakpoints después (insisto, reversing no es lo mio probablemente haya mil maneras más faciles de sacarlo jeje) para ir viendo la última parte de la ejecución fui viendo que iba pasando en cada paso. Luego de un par de ejecuciones me fije en que en el registro EAX iban apareciendo una serie de caracteres antes de finalizar la ejecución:

Después de anotarlos me quede con el string w2aC7y, esta vez si que hubo suerte y esta era la contraseña que buscabamos para el 7z, descomprimimos y obtenemos un txt con la flag:

FLAG: ReversingIsCool

Seguramente alguien más ducho en reversing os podría explicar con más detalle que se va haciendo en cada paso y probablemente lo hubiese visto en el primer vistazo, por desgracia reversing es un tema que tengo muy verde y contento me quedo con haberlo conseguido sacar jeje

Un saludo y gracias por vuestra visita!

Publicado en ctf, cybercamp, reversing, writeups | Deja un comentario

Cybercamp 2017 Online – 05. Without Collaboration [300]

Esta prueba en concreto me gusto bastante ya que yo mismo he estado trasteando con un método parecido, pero vamos al grano, tenemos este enunciado y el link:

Something unusual was happening on a coworker’s computer. We already identified the culprit but he does not collaborate and he does not explain how he got the information from the computer. However, a traffic capture was found that might be useful. Identify how the computer was compromised and whether he accessed some sensitive file.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective5.pcap

Esta vez nos encontramos con un pcap con una captura de tráfico bastante grande, por acotar me límite a las direcciones locales y descarté el trafico de internet para más tarde.

Las ip’s que se localizaron fueron la 192.168.47.191 y la 192. Filtrando primero por una y luego por otra vemos que la 192 básicamente solo se comunica con la 191:

Vemos que basicamente se utilizan dos protocolos, el UDP y el ICMP, después de revisar los paquetes por encima de UDP me decante por echarles un vistazo a los ICMP (como os digo, esto fue un poco de casualidad porque justo había estado trabajando con dichos paquetes) así que filtro y me encuentro con esto:

Mmm ¿Un ping sin response en la misma red local y donde hemos visto que el tráfico es bastante fluido? Algo no me cuadra, sigo mirando los otros paquetes y en uno me llevo una grata sorpresa:

Parece que están utilizando los paquetes ICMP para exfiltrar información, vamos a utilizar scapy en python para extraer la información de dichos paquetes con el siguiente scripts:

from scapy.all import *

packets = rdpcap('objective5.pcap')

for pkt in packets:
	if pkt.haslayer(ICMP):
		if hasattr(pkt[ICMP], 'load'):
			print pkt[ICMP].load

Como veis es muy sencillo y no me he complicado mucho la vida, recorro todo el pcap en busca de ICMP’s e imprimo por pantalla el contenido del load, el resultado es este:



Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

C:\>



C:\>













dir

dir
 Volume in drive C has no label.
 Volume Serial Number is EC3F-A500

 Directory of C:\

27/07/2017  10:40              
  15 Adpass.txt
17/05/2013  17:26            19.033 icmpsh.exe
14/07/2009  05:20    <DIR>          PerfLogs
06/07/2017  14:04
    <DIR>          Program Files
14/07/2009  06:57    <DIR>          Program Files (x86)
06/07/2017  14:02    <DIR>          U
sers
21/07/2017  12:13    <DIR>          Windows
               2 File(s)         19.048 bytes
               5 Dir(s)  53.22
7.302.912 bytes free

C:\>














more Adpass.txt

more Adpass.txt
GhostInThePings

C:\>




















Y ahí podemos ver la flag: GhostInThePings

Espero os haya gustado, saludos y gracias por la visita!

Publicado en ctf, cybercamp, forense, writeups | Deja un comentario

Cybercamp 2017 Online – 04. Transfer with terrible consequences [400]

Y vamos a por el cuarto, si, ya no se me ocurren mejores introducciones jajaja Vamos con el enunciado:

We are in a complicated situation. The control of a critical infrastructure was impossible due to the loss of the access password. During the transfer of a worker’s position, a mishap occurred and some of the information has disappeared.

The worker, who wants to remain anonymous, kept each character of a hash in some sheets arranged in a filing cabinet. One character per sheet. During the transfer of his workplace, the sheets have been disordered and some information has disappeared.

Not everything, but some information characters from the hash could be retrieved: ‘50afXXXXXX6351475e54bf6eb2c96f2b’. Characters identified by “X” are hexadecimal values that have been lost.

The password was not complicated but we have minimum information. The worker barely remembers that the password was composed of eight alphanumeric characters. “In q, it ends in q!“ – He excitedly exclaimed. Finally, he remembered that of the eight characters, the first was a “q” and the last two were “oq”. He was asked about the type of used hash, but he shook his head. After holding his breath for a few seconds, he recognised that he was unable to remember the type of hash.

We need help in order to obtain the password and get control of the infrastructure. The solution must have the following format: password-hash

Esta vez no tenemos archivo ya que el enunciado nos da toda la información que necesitamos, en este caso debemos encontrar un hash, del cual no sabemos que tipo es y del cual conocemos parte; de una palabra de 8 caracteres de longitud que comienza por oq y termina por q.

Primero probamos rellenando los caracteres que faltan en el hash con ceros y se lo pasamos a hashid para ver que nos dice:

50af0000006351475e54bf6eb2c96f2b
Analyzing '50af0000006351475e54bf6eb2c96f2b'
[+] MD2 
[+] MD5 
[+] MD4 
[+] Double MD5 
[+] LM 
[+] RIPEMD-128 
[+] Haval-128 
[+] Tiger-128 
[+] Skein-256(128) 
[+] Skein-512(128) 
[+] Lotus Notes/Domino 5 
[+] Skype 
[+] Snefru-128 
[+] NTLM 
[+] Domain Cached Credentials 
[+] Domain Cached Credentials 2 
[+] DNSSEC(NSEC3) 
[+] RAdmin v2.x 

Parece que no hemos tenido mucha suerte con esto, tendremos que ir probando distintos hashes, en lugar de escribir un script que permutara por todos debido al gran número de posibilidades me decante por utilizar john, pero primero necesitamos una lista de todos los posibles hashes y las posibles palabras, para ello utilizamos el siguiente script:

import itertools
import string

def gen_hash_dict():
    alphabet='0123456789abcdef'
    d=[]
    for x in itertools.product(alphabet, repeat=6):
        h='50af'+''.join(x)+'6351475e54bf6eb2c96f2b'
        d.append(h+'\n')
    with open('hash_dict.txt', 'w') as f:
        f.writelines(d)

def gen_passwd_dict():
    alphabet=string.ascii_lowercase + string.digits
    d=[]
    for x in itertools.product(alphabet, repeat=5):
        p='q'+''.join(x)+'oq'
        d.append(p+'\n')
    with open('passwd_dict.txt', 'w') as f:
        f.writelines(d)

print('generating hash dict...')
gen_hash_dict()
print('generating passwd dict...')
gen_passwd_dict()
print('done!')

Como veis en la primera función limitamos los carácteres a los utilizados en hexadecimal ya que en el enunciado nos indican que estos son los utilizados en el hash; para las contraseñas utilizamos todos los caracteres alfanuméricos.

Una vez tenemos los dos archivos, vamos probando cada uno de los hashes que hashid nos ha dado, finalmente en la tercera tenemos suerte:

Este es el comando de john que finalmente nos dio la solución:

john --fork=4 --format=raw-md4 --wordlist=passwd_dict.txt hash_dict.txt

Ahora que ya tenemos la palabra veamos cual es su hash correspondiente utilizando una de las multiples tools online y obtenemos 50affc9dcf6351475e54bf6eb2c96f2b.

La flag finalmente es:

q5ib44oq-50affc9dcf6351475e54bf6eb2c96f2b

Espero os haya gustado, un saludo y gracias por la visita!

 

Publicado en cripto, ctf, cybercamp, writeups | Deja un comentario

Cybercamp 2017 Online – 03. Messenger Service [300]

Vamos con la tercera prueba de la fase online de la Cybercamp con el siguiente enunciado y link:

The Spanish law enforcement agencies have made a seizure in an operation against the embezzlement of public funds. They acquired evidences from different computers and mobile devices. They have made a physical acquisition on one of the android mobile devices. They need to identify the communications of the device through one of the most used messenger programs of the moment. Allegedly, this information could help them to obtain information and a profile of the investigated.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective3.raw

Esta vez nos dan una imágen raw de un dispositivo android en ext4 lo cual nos permite montarla facilmente con un simple comando (vamos a realizarlo como root para así evitar problema también de permisos en la imágen que montamos):

mount objective3.raw mount/

La primera carpeta que vamos a revisar es la de data ya que ahí también podremos ver las distintas aplicaciones que han sido instaladas en el dispositivo:

Ahí podemos ver varias cosas, como por ejemplo que parece tener cyanogenmod instalado jeje y entre lo más interesante dos aplicaciones de facebook, katana y orca; katana corresponde a la aplicación oficial de facebook mientras que orca es la de su messenger ¿Recordais el enunciado? Una aplicación de mensajería de las más usadas así que orca tiene toda la pinta de ser lo que estabamos buscando, vamos a ver que hay dentro:

Primero pense que la carpeta flags podía ser algo relacionado pero no contenía ningún archivo así que me fuí a la segunda opción, la carpeta databases:

Vemos que tenemos una gran cantidad de bases de datos sqlite (muy utilizadas en android) con sus correspondientes journals y uids.

Después de un buen rato revisando las bases de datos no encontré nada realmente interesante, entonces se me vino a la cabeza, si hay archivos journal, ¿puede que aún no se haya escrito a la db y esté ahí esperandonos?

La db que parecía contener los mensajes se llamaba threads_db2 así que decidí empezar por su journal, estos son archivos en texto plano así que podemos verlos con un simple cat o si preferís evitar susto por culpa de alguna codificación podéis utilizar strings:

La última linea parece prometedora, sobre todo el ME_GUSTAN_LOS_GATITOS, probamos a meter la flag y ¡Bingo!

Como veis en este caso la solución ha consistido en ir tirando poco a poco del hilo hasta llegar a la información deseada, no siempre son todo scripts super complejos ni cosas por el estilo jeje

Espero que os haya gustado, saludos!

Publicado en ctf, cybercamp, forense, Sin categoría, writeups | Deja un comentario