Archivo de la categoría: Tips

CTF OverTheWire: Natas6

Continuamos con la serie de tutoriales del CTF Natas, ahora toca el turno de natas6.

Natas Level 5 → Level 6
Username: natas6
URL:      http://natas6.natas.labs.overthewire.org

Utilizamos la bandera obtenida en el reto anterior y accedemos a la URL indicada en las instrucciones del reto, veremos una pantalla como la siguiente.

Es solo un formulario donde nos piden ingresar una contraseña o secreto, al introducir cualquier cosa obtenemos un mensaje de error.

En la misma pagina hay un enlace que dice view sourcecode (ver código fuente), damos clic y veremos lo siguiente.

La parte importa es:

<?

include "includes/secret.inc";

    if(array_key_exists("submit", $_POST)) {
        if($secret == $_POST['secret']) {
        print "Access granted. The password for natas7 is <censored>";
    } else {
        print "Wrong secret";
    }
    }
?>

Es un código php muy sencillo, podemos ver que obtiene un parámetro via POST (el que enviamos mediante el formulario) y lo compara con la variable $secret, ademas hace include de un archivo interesante includes/secret.inc

Accedemos a ese archivo usando el navegador.

Y utilizamos el secret que acabamos de descubrir en el formulario inicial.

La bandera para acceder a natas7 es 7z3hEENjQtflzgnT29q7wAvMNfZdh0i9

En este reto aprovechamos un fallo de seguridad llamado Source code disclosure, en donde tenemos acceso a código que solo debería ser consumido del lado del servidor.

Happy hacking 🙂

Security Fest #CTF – Zion write up

Para este reto nos daban un archivo comprimido zion.tar.gz, procedemos a descomprimirlo y obtenemos otro archivo llamado YouKnow.

El archivo no tiene extension pero utilizamos el comando file para ver que tipo de archivo es.

Parece un archivo de Microsoft Word Office y sabemos que los archivos docx en realidad son archivos en formato zip.

Procedemos a descomprimir YouKnow

Obtenemos varios archivos y carpetas, comenzamos a analizarlos de uno por uno, sin embargo no encontramos nada que haga referencia a la bandera del reto. (analice la imagen del conejo con un par de herramientas de esteganografía pero no había nada)

Damos un paso atrás y abrimos el archivo YouKnow en un editor hexadecimal de su elección, you utilice Sublime

Observamos la cabecera estándar PK del formato ZIP

Al ir analizando el archivo, hacia el final, algo salta inmediatamente a la vista.

Parece que hay otro archivo Zip concatenado al primero pero los bytes están en orden inverso (observen como el archivo termina en KP, y vemos algunos strings como lmx que seria xml).

Podemos utilizar python para invertir los bytes del archivo fácilmente.

open('YouKnow_reversed','wb').write(open('YouKnow','rb').read()[::-1])

Obtenemos el archivo con los bytes invertidos y procedemos a descomprimirlo.

Obtenemos nuevamente varios archivos y carpetas.

Y en donde estaba la imagen anterior del conejo rojo ahora encontramos otra imagen, esta vez de un conejo azul que nos muestra la bandera del reto 🙂

La bandera del reto es sctf{m41nfr4m3_4cc3ss_c0d3_1337_4lw4s}

Bonus

Programe una pequeña herramienta en python llamada reverse bytes para invertir los bytes de un archivo utilizando una cli mas amigable.

usage: rbytes.py [-h] [-o OUTFILE] infile

A simple python script for reverse the bytes of a file.

Author: Lenin Alevski Huerta Arias
Year: 2018

positional arguments:
  infile                Input file

optional arguments:
  -h, --help            show this help message and exit
  -o OUTFILE, --outfile OUTFILE
                        Output file

Happy hacking 🙂

CTF OverTheWire: Natas1

En el articulo anterior, OWASP – Riviera Maya e introducción a Overthewire CTF, comenzamos con una breve introducción a los CTFs y resolvimos Natas0, con la bandera que obtuvimos ahora toca el turno de Natas1, el nivel es muy similar pero tiene algo que lo hace diferente.

Natas1

Natas Level 0 → Level 1
Username: natas1
URL:      http://natas1.natas.labs.overthewire.org

Vamos a la URL del reto, http://natas1.natas.labs.overthewire.org, ingresamos natas1 como username, la bandera obtenida en el reto anterior como contraseña y veremos la siguiente pantalla.

si intentamos hacer lo mismo que en el reto anterior, click derecho > ver código fuente, nos aparece un alert de Javascript indicando que el clic derecho esta deshabilitado.

Ok, hay código javascript que bloquea la acción de click derecho, sin embargo conocemos otras formas de acceder al código fuente de un sitio web, por ejemplo usando shortcuts (alt + command + U en mac, etc.) o con CURL

CURL es un cliente para linea de comandos que nos permite enviar o recibir datos utilizando distintos protocolos, entre ellos HTTP, abrimos una consola y escribimos el siguiente comando (en Windows CURL no esta instalado por default, pero podemos utilizar esta solución https://curl.haxx.se/download.html)

$ curl -u natas1:gtVrDuiDfck831PqWsLEZy5gyDz1clto http://natas1.natas.labs.overthewire.org

El parámetro -u nos permite definir credenciales para autenticarnos ante el servidor.

CURL nos muestra el código fuente de la URL que le indicamos, también podemos ver el código javascript que bloquea el clic derecho y la solución de este reto.

<body oncontextmenu="javascript:alert('right clicking has been blocked!');return false;">

La bandera para acceder a natas2 es ZluruAthQk7Q2MqmDeTiUij2ZvWy2mBi

* Aprendimos que hay otras formas de consumir una pagina web ademas de los navegadores que normalmente usamos (firefox, chrome, ie, safari, etc)

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/?include=asset.name,comment.author,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 {
  GraphQLObjectType,
  GraphQLInt,
  GraphQLString,
  GraphQLList,
  GraphQLBoolean,
  GraphQLNonNull,
  GraphQLFloat,
} 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) {
          return movie.name;
        }
      },
      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 {
  GraphQLObjectType,
  GraphQLList,
  GraphQLString,
  GraphQLInt,
  GraphQLBoolean
} 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 {
  GraphQLObjectType,
  GraphQLInt,
  GraphQLString,
  GraphQLNonNull,
  GraphQLList,
  GraphQLInputObjectType,
  GraphQLBoolean,
  GraphQLFloat,
} 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

#Docker para #hackers y pentesters, ejecutando #metasploit desde un container

Se acabó el 2016 y como ultima publicación del año les traigo un tutorial exprés que involucra docker y seguridad informática. En publicaciones anteriores explicaba que durante estos últimos meses he estado trabajando bastante con docker, orchestration e infraestructura de cloud en general (parte habitual en un trabajo de full stack engineer).

Docker es una herramienta muy poderosa para desarrolladores pues nos ayuda a construir imágenes con todas sus dependencias y nos deja el paso libre para enfocarnos en lo que realmente importa: deployar rápidamente una aplicación (o varias) que sabemos que va a funcionar.

Bajo esa premisa no es de extrañarse que la comunidad de seguridad haya adoptado docker tan rápidamente, docker es una herramienta fantástica 🙂 y así como nos permite dockerizar una aplicación también podemos dockerizar herramientas de seguridad y en general cualquier cosa que tengamos en nuestro arsenal para pentest.

La gente que trabaja o ha trabajado en seguridad, específicamente en el área de penetration testing, estará de acuerdo en que uno de los recursos más importantes que tenemos son las ventanas de tiempo, por lo general cuando se realiza una prueba de penetración a alguna aplicación o sistema se hace durante un periodo de tiempo bien definido, el tiempo es valioso y no podemos desperdiciarlo en instalar y configurar herramientas, o peor aun ¿que pasa si la infraestructura que estamos auditando nos bloquea? ¿cuánto tiempo vamos a invertir en preparar un nuevo nodo desde donde podamos lanzar ataques y recibir shells?, para todo lo anterior llega docker al rescate 🙂

En este tutorial mostraré como ejecutar una de las herramientas de seguridad más populares utilizando docker: metasploit, específicamente utilizaremos el módulo exploit/multi/handler para recibir sesiones de meterpreter.

ojo: no voy a mostrar como dockerizar metasploit, eso lo dejamos para un siguiente tutorial donde veamos como dockerizar aplicaciones

Ejecutando metasploit desde un contenedor de docker

Para evitarte el problema de abrir los puertos en tu router y hacer un mapeo de puertos para exponer tu maquina a internet, puedes contratar un vps con algún proveedor de tu elección, hoy en día es muy sencillo contratar un vps y puedes tener uno en línea prácticamente en minutos, yo recomiendo digitalocean por qué sus vps son baratos y el soporte es muy bueno, con un nodo de 10 USD al mes es suficiente para correr una imagen de metasploit, puedes contratar el de 5 USD pero tendrás que habilitar el swap o si no quieres gastar dinero siempre puedes aprovechar la promoción que te ofrece Amazon Webservices (más o menos 1 año de uso gratuito de una instancia micro)

Sea cual sea el proveedor que hayas elegido el siguiente paso es instalar docker en tu instancia, para este tutorial lo haré sobre ubuntu / debian pero podrías instalarlo en el sistema operativo de tu elección, acá tienes una lista de sistemas operativos soportados

Desde la terminal de tu instancia y como root vamos a ejecutar algunos comandos para instalar herramientas necesarias como compiladores de gcc/g++, algunas librerías, utilidades, etc. al final vamos a instalar docker

apt-get install build-essential
apt-get install libxslt-dev libxml2-dev zlib1g-dev --yes
apt-get install docker
apt-get install docker.io

Lo siguiente que vamos a hacer es crear un directorio en nuestra instancia, este directorio lo vamos a utilizar como un volumen persistente cuando ejecutemos metasploit desde el contenedor para poder almacenar ahí todo el loot, scripts y en general archivos que nos genere la herramienta.

mkdir /root/.msf4

Llego el momento, en el docker registry oficial existe una imagen llamada remnux/metasploit que contiene todo lo necesario para ejecutar la herramienta, ejecutamos el siguiente comando y docker comenzara a descargar la imagen y posteriormente procederá a correr el contenedor.

docker run --rm -it -p 443:443 -v ~/.msf4:/root/.msf4 -v /tmp/msf:/tmp/data remnux/metasploit

En el tutorial de docker anterior explicaba para que era cada parametro, en resumen -p nos permite mapear puertos y -v definir volúmenes persistentes (mapear una carpeta de nuestro sistema de archivos a una del sistema de archivos virtual del contenedor).

Una vez la imagen haya sido descargada el contenedor será creado y todas las dependencias necesarias comenzaran a ser instaladas, nos olvidamos de instalar todas las gemas y resolver conflictos y nos podemos ir por un café ya que es un proceso bastante automatizo 🙂

Después de unos minutos tenemos un nodo listo para recibir conexiones.

En el caso de necesitar más listeners no hay problema pues podemos ejecutar múltiples contenedores de metasploit en diferentes puertos y así tener nuestras shells organizadas, y si nuestro servidor es baneado rápidamente podemos desplegar otro ejecutando esos 6 comandos.

Como lo he comentado en varios artículos, docker es una herramienta muy poderosa que puede ser utilizada en varias situaciones además del desarrollo de software, como lo vimos en este tutorial. Puedes dockerizar casi cualquier cosa, yo en lo personal tengo una imagen con un set de herramientas que utilizo en mi día a día (fierce, dirb, sqlmap, nmap, enum4linux, hashcat, Responder, etc.)

Saludos y Happy Hacking.