Crypton: una recopilación para aprender cripto(grafía) defensiva/ofensiva

Ampliamos nuestro material de estudio para estas vacaciones con una fantástica recopilación de explicaciones e implementaciones de todos los ataques existentes en varios sistemas de cifrado, firma digital y algoritmos de hashing junto con ejemplos de retos de CTFs. Esta joya, que te hará ser una auténtica máquina en la categoría "crypto", la tenemos en un repositorio de Github gracias a Ashutosh Ahelleya aka s0rc3r3r de @teambi0s que ha nombrado su proyecto como Crypton.

En definitiva podemos decir que Crypton es una auténtica biblioteca para aprender y practicar criptografía defensiva y ofensiva, estructurada de la siguiente manera:



1. Block Ciphers

S.No. Topic Explanation Impl./Exploit Challenge#
1 Block Cipher Basics- working of block ciphers, padding etc.
2 Modes of Encryption- different modes of operation on block ciphers: ECB, CBC, CTR
3 Block Size Detection- detect blocksize of a block cipher encrypting data on a remote service
4 Mode Detection- detect type of mode of encryption: independent or dependent encryption of blocks
5 ECB Byte at a Time- byte at a time decryption of a secret string running on a remote service encrypting input+secret in ECB mode
6 CBC IV Detection- detect the value of Initialisation Vector on a remote service that is encrypting our input using a block cipher in CBC mode
7 CBC Bit Flipping Attack- exploiting cookie generation mechanism to login as admin when cookie is generated using a block cipher in CBC mode
8 CBC Byte at a Time- byte at a time decryption of a secret string running on a remote service encrypting input+secret in ECB mode
9 CBC Padding Oracle Attack- decryption of data encrypted by a vulnerable service providing encryption/decryption
10 CTR Bit Flipping- exploiting cookie generation mechanism to login as admin when cookie is generated using a block cipher in CBC mode

microctfs: pequeños retos en contenedores docker para practicar

¿Estas de vacaciones y/o tienes tiempo libre y quieres practicar tu pericia con pequeños CTFs? El americano Gabe Marshall tiene un repo en Github con una serie de interesantes microretos en forma de contenedores Docker que pueden levantarse de inmediato para empezar a jugar. Te animo a probarlos y a compartir tu feedback e incluso writeups con nosotros:

MicroCTFs:

- geddy
- jenkins    
- logviewer    
- printf    
- sqli    
- tcmanager    
- xxe    

Instrucciones de uso

Clonar el repositorio:

$ git clone https://github.com/gabemarshall/microctfs.git

Levantar el microreto deseado:

$ cd <microctf>
$ docker build -t <microctf> .
$ docker run -d -p <puerto_host>:<puerto_contenedor> --name <nombre_reto> <microctf>

Ejemplo:

$ cd sqli
$ docker build -t sqli .
$ docker run -d -p 8883:80 --name sqli_chal sqli

http://localhost:8883


Forwards <puerto_host>:<puerto_contenedor>:

- geddy: 40000:4000
- jenkins    
- logviewer: 8000:80    
- printf: 1337:1337    
- sqli: 8883:80
- tcmanager: 8080:8080    
- xxe: 8080:8080    

Reiniciar el CTF:

$ docker rm -f <nombre_reto> && docker run -d -p <puerto_host>:<puerto_contenedorf> --name <nombre_reto> <microctf>

Ejemplo:

$ docker rm -f sqli_chal && docker run -d -p 8883:80 --name sqli_chal sqli

Parar el micro reto:

$ docker rm -f <nombre_reto>

Ejemplo:

$ docker rm -f sqli_chal

Repo: https://github.com/gabemarshall/microctfs

Publican el código fuente reverseado de Diablo (Devilution)

Un programador con el nick GalaxyHaxz ha subido una versión reverseada del código fuente de Diablo. La ingeniería inversa le llevó más de 1.200 horas durante 6-12 meses en un intento por garantizar "que todo se conserve". El proyecto lo ha bautizado como Devilution.


"Durante años, los creadores de mods tuvieron que depender de la tediosa edición de código y la inyección en memoria. Algunos incluso fueron más allá y reversearon una buena parte del juego (como Belzebub/The Hell)", explica GalaxyHaxz. "El problema es que nunca publicaron su código fuente. Por lo general, siendo un trabajo de una sola persona, siguen adelante con sus vidas inevitablemente debido a la cantidad de tiempo/trabajo requerido o falta de interés".
"Esto deja a la gente con un mod a medio terminar, uno que tuvo innumerables horas puestas en él, pero que quedó lleno de errores y sin acabar. Así que volvemos al punto de partida. Devilution tiene como objetivo solucionar esto, al hacer que el código fuente de Diablo quede disponible gratuitamente para todos".


GalaxyHaxz explica que el objetivo de Devilution es reproducir el código fuente del juego original del 96 con la mayor precisión posible. Pero, "como objetivo secundario, Devilution ayuda a documentar el contenido no utilizado y cortado del juego final. El desarrollo de Diablo se apresuró al final: muchas ideas se eliminaron y el multijugador se pirateó rápidamente. Al examinar la fuente, podemos ver varias peculiaridades del desarrollo planificado".

Con una nueva versión del Diablo 3 original, una comunidad de modding activa y un nuevo juego en desarrollo, Diablo sigue estando bien servido. Pero nunca me dejará asombrar por el cuidado y el esfuerzo que se dedica a proyectos de aficionados como Devilution. No os lo perdáis:

Proyecto: https://github.com/diasurgical/devilution

Aron: un sencillo script en GO para encontrar parámetros GET y POST mediante fuerza bruta

Lurkeando Internet encontré Aron, un pequeño pero útil script escrito en Go que nos ayudará a encontrar parámetros POST y GET ocultos mediante ataques de diccionario/fuerza bruta. Bastante útil para auditorías web...


Instalación
$ git clone https://github.com/m4ll0k/Aron.git aron
$ cd aron 
$ go get github.com/m4ll0k/printer
# now check if $GOPATH is set
$ go env | grep -i gopath
# if $GOPATH not set, try with:
$ export GOPATH=$HOME/go
$ go run aron.go
# OR 
$ go build aron.go
$ cp aron /usr/bin/
$ aron

Uso
   ___                         
   /   |  _________  ___       
  / /| | / ___/ __ \/ __\   
 / ___ |/ /  / /_/ / / / /   
/_/  |_/_/   \____/_/ /_/ (v0.1.0 beta)
----------------------------
  Momo (M4ll0k) Outaadi 

Usage of aron:
  -data="":             Set post data
  -get=false:           Set get method
  -post=false:          Set post method
  -url="":              Set target URL
  -wordlist="dict.txt": Set your wordlist

FUERZA BRUTA EN GET
$ go run aron.go -url http://www.test.com/index.php -get 
$ go run aron.go -url http://www.test.com/index.php<[?|id=1|id=1&]> -get
$ go run aron.go -url http://www.test.com/index.php<[?|id=1|id=1&]> -get -wordlist my_wordlist.txt

<[?|id=1|id=1&]> => posible final de URL

 OR Note: en este caso aron necesita el wordlist path

$ aron -url http://www.test.com/index.php -get -wordlist path/wordlist.txt
$ aron -url http://www.test.com/index.php<[?|id=1|id=1&]> -get -wordlist path/wordlist.txt

FUERZA BRUTA EN POST
$ go run aron.go -url http://www.test.com/index.php -post 
$ go run aron.go -url http://www.test.com/index.php<[?id=1]> -post
$ go run aron.go -url http://www.test.com/index.php<[?id=1]> -post -data "user=1"
$ go run aron.go -url http://www.test.com/index.php<[?id=1]> -post -data "user=1" -wordlist my_wordlist

 OR Note: en este caso aron necesita el wordlist path

$ aron -url http://www.test.com/index.php -post -wordlist path/wordlist.txt
$ aron -url http://www.test.com/index.php<[?id=1]> -post -data "user=1" -wordlist path/wordlist.txt

Repositorio: https://github.com/m4ll0k/Aron

[HTB write-up] Valentine

El siguiente writeup muestra el proceso que utilicé para capturar las flags de usuario y de root en la máquina Valentine en @10.10.10.79.
Este documento contiene mis notas que tomé cuando estaba trabajando en la misma.

Mi forma de pensar

El primer paso consiste en la fase de reconocimiento como escaneo de puertos, banner grabbing, configuraciones erróneas, etc. El segundo en encontrar las vulnerabilidades, es decir, el ataque en sí mismo, y finalmente la escalada de privilegios llamada "fase de post-explotación".


Aviso personal: la post-explotación fue bastante compleja, haré todo lo posible para explicar cómo rooteé la máquina de Valentine.

Subíndice: Algo estaba oculto en la imagen de bienvenida y ayuda mucho ...


Escaneo de puertos

Durante este paso vamos a identificar el objetivo para ver que hay detrás de la dirección IP. Estos son los resultados:


El sistema remoto es Linux. Tenemos abierto un servidor web y un acceso remoto mediante ssh.

Con ésto, vamos a chequear ambos servicios. Para hacer esto, primero lo veremos en el navegador y, segundo, abriremos un terminal con las credenciales básicas.

Top 10 de herramientas free para threat hunting

La búsqueda de amenazas o threat hunting es un enfoque alternativo a los sistemas de seguridad tradicionales como firewalls o NIDS que monitorizan el tráfico de red. Si bien estos últimos investigan las amenazas después de que ocurrieron, la estrategia de threat hunting implica buscar a través de redes, detectar y aislar amenazas, y erradicarlas incluso antes de que los sistemas de alerta tradicionales hayan generado una alerta.

Esto se puede lograr manualmente por un analista que intenta identificar fallos potenciales en la red y crear escenarios de "qué pasaría si" que se utilizan para contrarrestar esas debilidades de forma proactiva. Hoy, sin embargo, la caza de amenazas se está volviendo más automatizada, y el proceso aprovecha el análisis del comportamiento de las entidades y los usuarios para informar al analista de seguridad de cualquier riesgo potencial.

Hoy en día podemos decir que hay tres tipos de hipótesis que los analistas usan mientras buscan amenazas:

- Basada en análisis: Considera el análisis de comportamiento de las entidades y los usuarios (UEBA) y el aprendizaje automático para desarrollar puntuaciones de riesgo acumuladas y otras hipótesis
- Basada en inteligencia: Impulsado por informes de amenazas de inteligencia, feeds, análisis de malware y escaneos de vulnerabilidades
- Conciencia Situacional: Usa evaluaciones de riesgo de la empresa o análisis Crown Jewel, evaluando las tendencias de una empresa o individuo

En base a estas hipótesis podemos clasificar una serie de herramientas gratuitas que los analistas o en general aquellos que buscan amenazas pueden usar para mantenerse protegidos.

Basadas en análisis

Maltego CE

Esta es una herramienta de minería de datos que genera gráficos interactivos para el análisis las relaciones entre datos de varias fuentes de Internet. Maltego CE automatiza los procesos de diferentes recursos de consulta y muestra gráficos comprensibles. La personalización de esta aplicación es sencilla y puede adaptarse a requisitos específicos.

ROPeando para bypassear NX y ASLR con libc

Después de un tiempo desconectado del mundo de los posts, tiempo en el que me he dedicado a investigar y a aprender cosillas bastante interesantes prioritariamente del mundo del exploiting, hoy vengo a hablar sobre una técnica fundamental para el desarrollo de exploits, la técnica se hace llamar "Return Oriented Programming", abreviando, ROP.

La técnica ROP se basa en el control del flujo del programa ejecutando fragmentos de código que encontramos en memoria, estos fragmentos de código se llaman "gadgets", los gadgets tienen la peculiaridad de acabar habitualmente en la instrucción RET, aunque en algunas situaciones también serán de utilidad los gadgets que acabes en un JMP o un CALL. Resumiendo, el ROP es una técnica en la cual se reutiliza código ensamblador del propio programa para poder controlar al gusto de la persona el flujo del programa.

Esta técnica es bastante importante porque dichos gadgets son "inmunes" a la aleatoriedad del ASLR, la protección Address Space Layout Randomization fue implementada para evitar (o dificultar) la explotación del software, resumiendo, esta protección se encarga de aleatorizar las direcciones de varias secciones y librerías compartidas de los programas en ejecución, en este caso, la sección .text, que es donde se encuentran dichos gadgets junto al resto de código ensamblador del programa no se aleatoriza, por ello está técnica es utilizada continuamente en los exploits de hoy en día.

A día de hoy, por defecto desde hace tiempo la protección ASLR está activada en todos los sistemas GNU/Linux, por ello, en un caso real siempre deberemos lidiar con ello. También debo hablar de otra protección que podremos combatir con el ROP, la protección NX, es una protección que viene también implementada por defecto, en este caso en los compiladores, para impedir la ejecución de código en la pila, imposibilitando el uso de la técnica ret2ESP que se basaba en la ejecución del shellcode en el propio stack.

ASLR activado
NX activado
Stack no ejecutable
No hay nada mejor para aprender este tipo de técnicas que practicando, para ello realizaré un reto que se usó en el CTF clasificatorio de la DEFCON 2015, el reto se llama r0pbaby y lo podréis descargar en este LINK. Para replicar este reto ejecutaré dicho programa en otra máquina virtual con un Ubuntu que contendrá la flag, por lo tanto primero deberé explotarlo localmente en mi máquina y luego explotarlo remotamente en la máquina Ubuntu.

Una vez descargado podemos ver ante qué clase de archivo estamos con el comando file:


Podemos observar que estamos ante un ELF de 64 bits dynamically linked, vamos a ver como funciona el programa en ejecución.

Construye tu propia botnet con BYOB

BYOB (Build Your Own Botnet) es un proyecto de código abierto que proporciona un framework para que los investigadores y profesionales de seguridad construyan y operen una botnet básica. Gracias a ésta herramienta se podrá:
- profundizar en la comprensión del malware cada vez más sofisticado que infecta millones de dispositivos cada año
- generar botnets modernas con el fin de mejorar su capacidad para desarrollar contramedidas contra este tipo de amenazas

La herramienta contiene 4 partes principales:

Servidor

uso: server.py [-h] [-v] [--host HOST] [--port PORT] [--database DATABASE]

Servidor de comando y control con base de datos persistente y consola

- Interfaz de usuario basado en consola: interfaz por consola para controlar las máquinas clientes de forma remota a través de shells reversas
- Base de datos persistente de SQLite: base de datos liviana que almacena información de identificación de las máquinas clientes, lo que permite que las sesiones de reversas persistan
- Arquitectura Cliente-Servidor: todos los paquetes/módulos python instalados localmente están disponibles automáticamente para que los clientes los importen de forma remota sin tocar el disco, permitiendo a los clientes utilizar módulos que requieren paquetes no instalados en las máquinas de destino

Cliente

uso: client.py [-h] [-v] [--name NAME] [--icon ICON] [--pastebin API] [--encrypt] [--obfuscate] [--compress] [--compile] host port [module [module ...]]

Genera clientes completamente indetectables con payloads staged, imports remotos y módulos ilimitados


- Imports remotos: importa remotamente paquetes de terceros desde el servidor sin escribirlos en el disco o descargarlos/instalarlos
- No escribe nada en el disco: los clientes nunca escriben nada en el disco, ni siquiera archivos temporales (se realizan llamadas al sistema IO zero) porque las importaciones remotas permiten que el código arbitrario se cargue dinámicamente en la memoria y se importe directamente en el proceso en ejecución
- Cero dependencias (ni siquiera el propio Python): el cliente ejecuta solo la biblioteca estándar de Python, importa de forma remota cualquier paquete/módulo no estándar del servidor y puede compilarse con un intérprete de Python independiente en un ejecutable binario portátil formateado para cualquier plataforma/arquitectura, lo que le permite ejecutarse en cualquier cosa, incluso cuando Python mismo falta en el host de destino

Taller de exploiting: BOF básico en Linux - análisis dinámico (2/2)

En la entrada anterior fuimos capaces de generar nuestro payload para explotar un desbordamiento de buffer básico sólo analizando el código asm generado con objdump. Ahora en esta entrada lo que haremos será realizar un análisis dinámico del mismo binario mediante el debugger de facto en Linux: gdb (The GNU Project Debugger) al que añadiremos PEDA (Python Exploit Development Assistance for GDB) para ampliar sus funcionalidades.

Pero antes de empezar con gdb os recomiendo echar un vistazo a algún cheatsheet como los siguientes:
- https://darkdust.net/files/GDB%20Cheat%20Sheet.pdf
- https://github.com/stmerry/gdb-peda-cheatsheet/blob/master/gdb-peda%20cheatsheet.pdf

Continuando con el ejercicio, lo primero que haremos será cargar el debugger simplemente llamando a nuestro programa vulnerable como parámetro:
$ gdb bof2
GNU gdb (Ubuntu 8.0.1-0ubuntu1) 8.0.1
Copyright (C) 2017 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
Para las instrucciones de informe de errores, vea:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Leyendo símbolos desde bof2...hecho.

Lo que se suele hacer en primer lugar es comprobar las protecciones del binario con el comando checksec:
gdb-peda$ checksec bof2
CANARY    : disabled
FORTIFY   : disabled
NX        : ENABLED
PIE       : disabled
RELRO     : FULL

Como se puede observar en el resultado sólo está activado lo siguiente:

- NX (non executable): hace que ningún segmento de la aplicación sea escribible o ejecutable una vez cargado en memoria. Esto significa que aunque logremos alterar el flujo de un programa hacia un shellcode que hayamos cargado en memoria este no se va a ejecutar.
- RELRO (Relocation Read-Only) completo o FULL: mapea toda la GOT (Global Offset Table) a sólo lectura.

Afortunadamente ninguna de estas dos protecciones nos van a impedir desbordar la pila (smash the stack) así que ¡vamos a ello!

Taller de exploiting: BOF básico en Linux - análisis estático (1/2)

Voy a retomar el tema del exploiting con una serie de artículos "random", esta vez con uno en Linux de los más básicos y típicos que podemos encontrarnos. Me basaré en uno de un taller de kablaa en que tendremos que explotar un binario cuyo código fuente es el siguiente:
#include <stdio.h>
#include <stdlib.h> 

int main(int argc, const char *argv[])
{
    int correct = 0;
    char bof[64];

    scanf("%s",bof);

    if(correct != 0xdeadbeef)
    {
        puts("you suck!\n");
        exit(0);
    }
    puts("you win!\n");
    system("/bin/sh");

    return 0;
}

Evidentemente en un CTF no se nos facilitará nada más que el binario compilado, pero para este ejercicio lo usaremos primero para entender mejor el típico desbordamiento de buffer.

Como podéis ver en el código, se inicializa el entero 'correct' a 0 pero el programa admite como único parámetro la cadena 'bof' que será proporcionada como argumento directamente a la función main. Luego la función scanf con el especificador %s leerá los caracteres de la cadena hasta encontrar un espacio, un intro, un tabulador, un tabulador vertical o un retorno de carro, y añadirá automáticamente el carácter nulo al final (como sabréis, una cadena o string en C se define como un array de caracteres que termina siempre en un byte null (\0)).

Sin embargo, es muy peligroso usar scanf para leer cadenas, pues scanf no tiene en cuenta la longitud y admitirá que el usuario escriba más caracteres que lo que el array definido en el programa pueda admitir (64 en este caso). Como resultado, scanf escribirá los caracteres que ya no quepan en el array definido en otras porciones de memoria que pueden contener otros datos que está usando nuestro programa, y ahí es donde tenemos que sobre escribir el valor de la variable 'correct' y asignarle el valor 0xdeadbeef para que ejecute la función system.

Cr3dOv3r: herramienta para comprobar reutilización de contraseñas

Un estudio reciente de Panda arroja como resultado que el 52% de los usuarios reutiliza las contraseñas. Es decir, más de la mitad de los usuarios utiliza exactamente la misma password (o una muy parecida) en varios servicios web diferentes, lo que posibilita a un atacante comprometer varias cuentas de su víctima "de un plumazo". Y para hacerlo aún más fácil, el egipcio Karim Shoair aka D4Vinci ha creado una herramienta en python llamada Cr3dOv3r que facilita mucho el trabajo a la hora de realizar ataques de reutilización de contraseñas.

Básicamente, con una cuenta de correo Cr3dOv3r realiza dos simples pero útiles tareas:

- Busca en leaks públicos la cuenta indicada y devuelve el resultado con los detalles más útiles (utilizando la API de haveibeenpwned) e intenta obtener las contraseñas en texto claro que encuentre (utilizando @GhostProjectME).
- Si seteas la contraseña, prueba además esas credenciales contra algunos sitios web conocidos (por ejemplo, Facebook, Twitter, Google ...) e informa si el inicio de sesión fue exitoso.


Uso

usage: Cr3d0v3r.py [-h] [-p] [-np] [-q] email

positional arguments:
  email       Email/username to check

optional arguments:
  -h, --help  show this help message and exit
  -p          Don't check for leaks or plain text passwords.
  -np         Don't check for plain text passwords.
  -q          Quiet mode (no banner).

Installing and requirements
To make the tool work at its best you must have :

    Python 3.x or 2.x (preferred 3).
    Linux or Windows system.
    Worked on some machines with MacOS and python3.
    The requirements mentioned in the next few lines.

Instalación

+Para windows : (después de descargar el ZIP y descomprimirlo)

cd Cr3dOv3r-master
python -m pip install -r win_requirements.txt
python Cr3dOv3r.py -h

+Para Linux :

git clone https://github.com/D4Vinci/Cr3dOv3r.git
cd Cr3dOv3r
python3 -m pip install -r requirements.txt
python3 Cr3dOv3r.py -h

+Para docker :

git clone https://github.com/D4Vinci/Cr3dOv3r.git
docker build -t cr3dov3r Cr3dOv3r/
docker run -it cr3dov3r "example@gmail.com"

Github: https://github.com/D4Vinci/Cr3dOv3r

[HTB write-up] Sense

La máquina "SENSE" se retiró hace tiempo así que podemos hablar con total libertad sobre la forma de conseguir sus flags.

Como ya sabes, Hackthebox es un sitio donde hay todo tipo de máquinas virtuales vulnerables para practicar pentesting sin tener que hacer informes como lo haría un pentester en la vida real.

Estaba intrigado por el nombre de la máquina y por el sistema operativo. Me preguntaba si podría ser un firewall. Pensé que podía ser PFSENSE (OpenSource Firewall) y en realidad las letras "PF" fueron retiradas ;)

El LOGO de la máquina
La dirección de la máquina destino es la 10.10.10.60.

Enumeración

Escaneo de puertos

En esta parte vamos a encontrar los puertos y servicios de nuestro objetivo.

nmap 10.10.10.60
Starting Nmap 7.40 ( https://nmap.org ) at 2018–03–08 16:17 CET
Nmap scan report for 10.10.10.60
Host is up (0.079s latency).
Not shown: 998 filtered ports
PORT STATE SERVICE
80/tcp open http
443/tcp open https

Escaneo de versiones

nmap -sV 10.10.10.60
Starting Nmap 7.40 ( https://nmap.org ) at 2018–03–08 16:22 CET
Nmap scan report for 10.10.10.60
Host is up (0.053s latency).Not shown: 998 filtered ports
PORT STATE SERVICE VERSION
80/tcp open http lighttpd 1.4.35
443/tcp open ssl/http lighttpd 1.4.35

También comprobé la versión del servidor web con el comando curl:

curl -I 10.10.10.60
HTTP/1.1 301 Moved Permanently
Location: https://10.10.10.60/
Date: Thu, 08 Mar 2018 15:52:44 GMT
Server: lighttpd/1.4.35

Luego usé Metasploit para tener organizados mis escaneos. Es muy útil para manejar las máquinas, así que lo importé todo y trabajé con ello:

db_nmap -O 10.10.10.60
[*] Nmap: Starting Nmap 7.01 ( https://nmap.org ) at 2018–03–14 16:32 CET
[*] Nmap: Nmap scan report for 10.10.10.60
[*] Nmap: Host is up (0.031s latency).
[*] Nmap: Not shown: 998 filtered ports
[*] Nmap: PORT STATE SERVICE
[*] Nmap: 80/tcp open http
[*] Nmap: 443/tcp open https
[*] Nmap: Warning: OSScan results may be unreliable because we could not find at
least 1 open and 1 closed port
[*] Nmap: Device type: general purpose|specialized
[*] Nmap: Running (JUST GUESSING): OpenBSD 4.X (93%), Comau embedded
(92%), FreeBSD 6.X (89%), Linux 2.6.X (89%)
[*] Nmap: OS CPE: cpe:/o:openbsd:openbsd:4.0 cpe:/o:freebsd:freebsd:6.3
cpe:/o:linux:linux_kernel:2.6.29
[*] Nmap: Aggressive OS guesses: OpenBSD 4.0 (93%), Comau C4G robot control unit
(92%), FreeBSD 6.3-RELEASE (89%), Linux 2.6.29 (89%), OpenBSD 4.3 (85%)
[*] Nmap: No exact OS matches for host (test conditions non-ideal).
[*] Nmap: OS detection performed. Please report any incorrect results at
https://nmap.org/submit/ .
[*] Nmap: Nmap done: 1 IP address (1 host up) scanned in 14.27 seconds

Después, verifiqué mis hallazgos abriendo mi navegador para ver cómo era.

Captura del acceso a pfsense

Arsenal de herramientas de seguridad para AWS

Impresionante recopilatorio de Toni de la Fuente de Alfresco Software con un montón de recursos y herramientas para la seguridad de un entorno AWS (Amazon Web Service) en la nube. Os la pego también aquí pero si echas en falta algo no dudes en contactar con su autor para que actualice el repositorio:

https://github.com/toniblyx/my-arsenal-of-aws-security-tools

Defensivas (Fortificación, Auditoría de seguridad, Inventario)
Ofensivas:

Descubrimiento de rutas de una web mediante ficheros .DS_Store

Los archivos .DS_Store (Desktop Services Store) son archivos "ocultos" creados por Mac OS X que contienen preferencias para la visualización de cada carpeta del sistema. Básicamente le dicen a Finder como mostrar los iconos (su tamaño y posición), si una ventana de carpeta tiene algún color de fondo y otra información. El Finder crea un .DS_Store para cada carpeta que se abre en un Mac, incluidas carpetas o carpetas remotas en medios extraíbles.

Los archivos .DS_Store también pueden contener datos sobre otros archivos en sus carpetas. Por ejemplo, un archivo .DS_Store puede contener los nombres de los archivos que se encuentran en su carpeta y, por lo tanto, leer un archivo .DS_Store puede proporcionar información sobre el contenido de una carpeta.

Evidentemente esto no es un problema en Mac, pero podría ser un problema si estos ficheros están alojados y disponibles en un servidor web. De hecho, muchos archivos .DS_Store están indexados por Google, y al descargarlos y leer sus contenidos, es posible obtener una lista de algunos o todos los archivos contenidos en un directorio web. Otra forma de encontrarlos es mediante un fuzzing de directorios (diccionario) con alguna herramienta tipo wfuzz, dirb o similar. En cualquier caso, pueden resultarnos tremendamente útiles para descubrir la estructura de un sitio que estemos escaneando.

Así que si consigues descargarte uno, te recomiendo por ejemplo parsearlo con la herramienta ds_store_exp del chino lijiejie:

Uso: python ds_store_exp.py http://www.example.com/.DS_Store

$ git clone https://github.com/lijiejie/ds_store_exp.git && cd ds_store_exp

$ python ds_store_exp.py http://site_ejemplo/.DS_Store
[+] http://site_ejemplo/.DS_Store
[+] http://site_ejemplo/Widgets/.DS_Store
[Folder Found] http://site_ejemplo/Templates
[Folder Found] http://site_ejemplo/dev
[Folder Found] http://site_ejemplo/Widgets
[+] http://site_ejemplo/Themes/.DS_Store
[+] http://site_ejemplo/JS/.DS_Store
[+] http://site_ejemplo/Images/.DS_Store
[Folder Found] http://site_ejemplo/Themes
[Folder Found] http://site_ejemplo/JS
[Folder Found] http://site_ejemplo/Images
[+] http://site_ejemplo/Widgets/Framework/.DS_Store
[+] http://site_ejemplo/dev/.DS_Store
[Folder Found] http://site_ejemplo/Plugins
[Folder Found] http://site_ejemplo/Widgets/Menu
[Folder Found] http://site_ejemplo/Widgets/Framework
[Folder Found] http://site_ejemplo/Uploads
[+] http://site_ejemplo/iisstart.htm
[Folder Found] http://site_ejemplo/Themes/default
[Folder Found] http://site_ejemplo/JS/custom
[Folder Found] http://site_ejemplo/Images/buttons
[Folder Found] http://site_ejemplo/Images/icons
[+] http://site_ejemplo/Widgets/Framework/Layouts/.DS_Store
[Folder Found] http://site_ejemplo/Widgets/Framework/Layouts
[+] http://site_ejemplo/dev/oculto/.DS_Store
...


Fuentes:

- Possible Security Issue Involving .DS_Store Files on Web Servers
- Apache security "leak" noted with .DS_Store files
- Parsing the .DS_Store file format
- Removing DS_Store files on Linux Server

Inyecciones SQL como DIOS

El post de hoy no trata de inyecciones como si fueras del fuc**** master, si no que el acrónimo DIOS se refiere a Dump In One Shot, una técnica de inyección SQL que lleva existiendo ya desde hace años pero que sin embargo todavía hoy no es demasiado conocida. Como su nombre indica, DIOS es forma peculiar de construir inyecciones SQL que, con la ayuda del uso de ciertas sentencias, nos permite obtener el volcado completo para una consulta.

Con SQLis DIOS no necesitas herramientas como Sqlmap o Havij, sólo con el navegador puedes traerte todos los datos que necesitas y mediante una "única bala". Normalmente aplica en inyecciones de tipo union y también, aunque menos comunes y más difíciles de implementar, a las basadas en error. Para las inyecciones ciegas, esta técnica no se aplica.

Para entender como funciona vamos a ver la clásica inyección SQL 'Union Base' usando DIOS contra una base de datos MySQL. Para ello usaremos el laboratorio online SQLInjection Ninja de Security Idiots, que además son los mejores mesías de este tipo de inyecciones.

Primero identificaremos el recurso vulnerable a SQLi:

http://leettime.net/sqlninja.com/tasks/basic_ch1.php?id=.1%27%20union%20select%20111,222,333%20--%20-


La columna 222 es vulnerable: en ella insertaremos nuestra petición DIOS.

http://leettime.net/sqlninja.com/tasks/basic_ch1.php
?id=.1' union select 111,((select (@a) from (select(@a:=0x00),(select (@a) from (information_schema.schemata)where (@a)in (@a:=concat(@a,schema_name,'
'))))a)),333 -- -


Como podéis ver, con esa consulta devolvimos la lista de todas las bases de datos en ese sitio.

Solución al reto 26: Emma-ne-de-fur-fur?


Nuevo reto "especial verano" de la mano de @Hackers4Fun (#H4F) donde se ha interceptado un fragmento de código en un email remitido por Tim a Flint "Loco" (El prota de "Lluvia de albóndigas") y deberemos de encontrar lo que esconde.  

Manos a la obra

Descargamos y descomprimos con WinRAR el archivo "R3t0_12_H4f.gz" que contiene el siguiente enlace: https://drive.google.com/file/d/1iG_lNnMSU05-kjvbhk9Sk_GMCGnbO-Y1
Nos encontramos con lo que parece un archivo PDF, si lo ejecutamos nos encontraremos con el siguiente texto:
 
 
Observamos que es código HTML con una imagen codificada en base64, simplemente seleccionamos todo el código y lo colocamos en cualquier editor de texto (I love you sublime text) y guardamos en .html
Ejecutamos el archivo .html y vemos la siguiente imagen.bmp:
 
 
Nos la descargamos y la analizamos con diferentes herramientas (exiftool,binwalk y stegsolve) pero sin ninguna pista que me sirviera de ayuda.
Después de unos minutos de bloqueo, me cambié las gafas "3D" por las lentes graduadas (simplemente limpié los cristales xD) me tropecé con unos extraños pixels que no venían "a cuento" con la imagen. 
Hice zoom y encontré esto:
 

Es un mensaje en morse! Si tiramos de Photoshop (también sirve Gimp o Fireworks) y jugamos con los niveles podemos conseguir una imagen mas clara, mas o menos lo dejé así:
 

Dirhunt: encuentra directorios web sin fuerza bruta

 
Dirhunt es un web crawler optimizado para buscar y analizar directorios. Esta herramienta puede encontrar cosas interesantes si el servidor tiene habilitado el modo "index of", aunque también es útil si el listado de directorios no está habilitado. También detecta directorios con errores 404 "falsos", directorios donde se ha creado un archivo de índice vacío para ocultar cosas y mucho más.

$ dirhunt http://website.com/

Dirhunt no usa fuerza bruta. Pero tampoco es solo un crawler. Esta herramienta es más rápida que otras porque minimiza las solicitudes al servidor. En general, esta herramienta tarda entre 5-30 segundos, dependiendo del sitio web y del servidor.

Características

- Procesa uno o múltiples sitios a la vez.
- Procesa páginas de 'index of' y reporta archivos interesantes.
- Detecta redirecciones.
- Detecta index en blanco creados en directorios para ocultar cosas.
- Procesa algunos archivos html en busca de nuevos directorios.
- Páginas de error 404 y detectar errores 404 falsos.
- Filtrar resultados por flags.
- Analiza los resultados al final.

Instalación:

$ pip install dirhunt

o desde el repo:

$ git clone git://github.com/Nekmo/dirhunt
$ curl  -OL https://github.com/Nekmo/dirhunt/tarball/master
$ python setup.py install

Uso:
Usage: dirhunt [OPTIONS] [URLS]...

  :param int threads: :type exclude_flags: list

Options:
  -t, --threads INTEGER           Number of threads to use.
  -x, --exclude-flags TEXT        Exclude results with these flags. See
                                  documentation.
  -i, --include-flags TEXT        Only include results with these flags. See
                                  documentation.
  -e, --interesting-extensions TEXT
                                  The files found with these extensions are
                                  interesting
  -f, --interesting-files TEXT    The files with these names are interesting
  --stdout-flags TEXT             Return only in stdout the urls of these
                                  flags
  --progress-enabled / --progress-disabled
  --timeout INTEGER
  --version
  --help                          Show this message and exit.

Reto 26: Especial Verano: Emma-ne-de-fur-fur?

El grupo del IES Francico Umbral de Ciempozuelos (Madrid) Hackers4Fun CTF Team nos vuelve a traer otro entretenido reto para amenizar las calurosas jornadas de verano.

Categoria > Misc> Han interceptado un fragmento de código de un emaIl remitido por Tim a Flint "Loco". Puedes detectar el mensaje escondido en el archivo adjunto del email?> Download:

https://drive.google.com/file/d/1iG_lNnMSU05-kjvbhk9Sk_GMCGnbO-Y1/view


Una vez resuelto, mandar la flag por DM a la cuenta de Twitter https://www.twitter.com/Hackers4F. El formato es H4F{...}

Una vez que Hackers4F cierre el reto, publicaremos también el writeup y pondremos a los primeros acertantes en nuestra página. Así que animaros y a ver si sois capaces de descubrir el mensaje escondido.

Recopilatorio de formas de bypassear la Política de Ejecución (Execution Policy) en Powershell

PowerShell viene configurado por defecto para evitar la ejecución de scripts. Auqnue no debería, esto puede ser un obstáculo para los pentesters, administradores de sistemas y desarrolladores, ... y también para los atacantes. Sin embargo, se puede eludir esta política aún sin tener derechos de administrador local en el sistema. En un artículo en el blog de NetsPI de 2014 se mostraban numerosas formas de hacerlo que hoy en día siguen vigentes y por eso rescatamos.

¿Qué es la Política de Ejecución de Powershell o PowerShell Execution Policy?

La Política de Ejecución de Powershell es la configuración que determina qué tipo de scripts de PowerShell (si los hay) se pueden ejecutar en el sistema. Por defecto, está configurado como "Restringido" (en inglés "Restricted"), lo que básicamente significa ninguno. Sin embargo, es importante entender que esta política más que un control de seguridad estaba destinada a evitar que los administradores se peguen "un tiro en el pie". Es por eso que hay tantas opciones para cambiarla, incluyendo algunos que Microsoft ha proporcionado directamente.

Cómo ver la Política de Ejecución

Para ver la configuración actual se suele utilizar el comando de PowerShell "Get-ExectionPolicy". Si estás viendo la configuración por primera vez, es probable que esté configurada como "Restringida", como se muestra a continuación:

PS C:\> Get-ExecutionPolicy
Restricted


También vale la pena señalar que la política de ejecución se puede establecer en diferentes niveles en el sistema. Para ver una lista de ellos, usa el siguiente comando:

PS C:\> Get-ExecutionPolicy -List | Format-Table -AutoSize

        Scope ExecutionPolicy
        ----- ---------------
MachinePolicy       Undefined
   UserPolicy       Undefined
      Process       Undefined
  CurrentUser       Restricted
 LocalMachine       Restricted


Notas de configuración de laboratorio

En los ejemplos que se verán a continuación se usará un script llamado runme.ps1 que contiene el siguiente comando de PowerShell para escribir un mensaje a la consola:

Write-Host "Prueba"

Cuando se intente ejecutar en un sistema configurado con la política de ejecución predeterminada, aparecerá el siguiente error:


Si tu política actual es demasiado abierta y deseas hacerla más restrictiva para probar las técnicas que se mostrarán a continuación, ejecuta el comando "Set-ExecutionPolicy Restricted" desde una consola PowerShell con privilegios administrador. A continuación veremos 15 maneras de eludir las restricciones de la política de ejecución de PowerShell.

Cherry* - IA Busqueda A* && la Heuristica de Manhattan

Hoy les comparto algunas implementaciones sobre búsqueda no informada en JAVA, usando un nuevo enfoque funcional, comentado todo en español, espero que les sea de ayuda a quien lo necesite Funciona con el JDK 10...


Terminología

    Node -> Una estructura de datos que tiene lugar en el árbol;
    Actions -> Estados alcanzables desde algún estado cualquiera;
    Root -> Nodo top u origen del árbol;
    Origin -> Estado origen de algún estado cualquiera;
    Final -> Estado sin acciones posibles;
    Level -> Nivel del estado por defecto root = 0;
    Tree -> Estructura que modela los estados del problema;
    Cost -> Costo para llegar a ese estado desde el inicio;
    Source -> Representación matricial de algún estado;
    State -> Estado a priori;

Concepto

Los arboles son estructuras de datos complejas que nos permiten modelar el mundo, siguiendo ciertas restricciones adaptadas de la propia naturaleza del problema.

Una simple representación de un árbol puede ser la siguiente:

Los arboles con los que trabajaremos contienen una raíz destacada la cual es el origen del estado, por lo cual solo hay un camino origen asociado a un estado viniendo desde otro.

Investiga inicios de sesión maliciosos en el DA con LogonTracer

LogonTracer es una herramienta para investigar inicios de sesión maliciosos al visualizar y analizar los registros de eventos del directorio activo de Windows.

Esta herramienta utiliza PageRank y ChangeFinder para detectar hosts y cuentas maliciosas en los logs de eventos de Windows, y visualiza los siguientes identificadores de eventos relacionados con el inicio de sesión de Windows basados en nuestra investigación previa.

- 4624: inicio de sesión exitoso
-  4625: error de inicio de sesión
- 4768: Autenticación de Kerberos (solicitud de TGT)
- 4769: Ticket de servicio de Kerberos (Solicitud de ST)
- 4776: Autenticación NTLM
- 4672: asignar privilegios especiales

Tenéis más detalle en los siguientes enlaces:   


En mi caso voy a instalarlo y usarlo en Linux, pero lo tenéis también funcional en OSX e incluso en un contenedor Docker.

Descubriendo el camino para llegar a domain admin con BloodHound

Hoy en día prácticamente todas las empresas utilizan el Directorio Activo de Microsoft para administrar los recursos, usuarios y políticas de sus redes corporativas. Por eso uno de los objetivos finales de una intrusión siempre suele ser conseguir los máximos privilegios sobre el DA. Pero también suele ser bastante común que, cuando comprometemos un servidor y nos "asomamos" a las redes internas para comenzar con los movimientos laterales, nos encontremos con una auténtica maraña de servidores, relaciones de confianza, grupos anidados, etc, etc., es decir, literalmente es fácil que nos perdamos en el bosque, nunca mejor dicho.

Para facilitarnos el entendimiento de la topología a la que nos enfrentamos y visualizar las posibles vulnerabilidades y fallos existe una herramienta que se llama BloodHound que utiliza gráficos para revelar las relaciones ocultas y, a menudo no intencionadas, dentro de un entorno de DA.

Por un lado un atacante puede usarla para identificar fácilmente rutas de ataque altamente complejas que de otro modo serían imposibles de identificar rápidamente y, por otro, un administrador podría usarla también para identificar y eliminar esos mismos caminos de ataque. En definitiva, tanto los miembros del Red Team como los del Blue Team pueden usar BloodHound para obtener una comprensión más profunda de las relaciones de privilegios en un entorno de Active Directory.


Bloodhound está desarrollado por @_wald0, @CptJesus, y @harmj0y. y básicamente es una aplicación web de JavaScript de una sola página, construida sobre Linkurious, compilada con Electron, con una base de datos Neo4j alimentada por un ingestor PowerShell. Tenéis las instrucciones de instalación en la Wiki del proyecto. En este post haremos una pequeña demo desde la perspectiva de un atacante...

Primero, para funcionar BloodHound requiere tres conjuntos de información de un entorno de Active Directory:

- ¿Quién ha iniciado sesión en dónde?
- ¿Quién tiene los derechos de administrador?
- ¿Qué usuarios y grupos pertenecen a qué grupos?
- (Opcionalmente) ¿Qué directores tienen control sobre otros objetos de usuario y grupo?

En la mayoría de los casos, la recopilación de esta información no requiere privilegios de administrador ni la ejecución de código en sistemas remotos. El primer ingestor de Bloodhound -que así es como se conoce- estaba basado en PowerView y hacía que la recopilación de datos fuera rápida y simple, e incluso teníamos la ventaja de que podíamos llamarlo directamente desde Empire (módulo Powershell/situation_awareness/network/bloodhound) o incluso desde Meterpreter importando el cmdlet (powershell_import BloodHound.ps1). Sin embargo el uso de Powershell v2 penalizaba algo la velocidad de la enumeración en grandes entornos y, sobretodo, elevaba bastante el uso de la memoria, por lo que se reescribió un nuevo ingestor en C#: SharpHound.

noisy: un script en Python para generar "ruido" en forma de tráfico HTTP/DNS

noisy de 1tayH es un sencillo script en Python que genera ruido en forma de tráfico HTTP/DNS aleatorio mientras navegas por la red (en background), para que los datos de tráfico web sean menos valiosos a la hora de venderlos y para tener mayor "oscuridad".

El script ha sido probado en MacOS High Sierra, Ubuntu 16.04 y Raspbian Stretch, y es compatible tanto con Python 2.7 como con 3.6.

Instalación

pip install requests
git clone https://github.com/1tayH/noisy.git

Parámetros disponibles
$ python noisy.py --help
usage: noisy.py [-h] [--log -l] --config -c [--timeout -t]

optional arguments:
  -h, --help    show this help message and exit
  --log -l      logging level
  --config -c   config file
  --timeout -t  for how long the crawler should be running, in seconds

Uso

cd noisy
python noisy.py --config config.json

Ejemplo salida
$ docker run -it noisy --config config.json --log debug
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): 4chan.org:80
DEBUG:urllib3.connectionpool:http://4chan.org:80 "GET / HTTP/1.1" 301 None
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): www.4chan.org:80
DEBUG:urllib3.connectionpool:http://www.4chan.org:80 "GET / HTTP/1.1" 200 None
DEBUG:root:found 92 links
INFO:root:Visiting http://boards.4chan.org/s4s/
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): boards.4chan.org:80
DEBUG:urllib3.connectionpool:http://boards.4chan.org:80 "GET /s4s/ HTTP/1.1" 200 None
INFO:root:Visiting http://boards.4chan.org/s4s/thread/6850193#p6850345
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): boards.4chan.org:80
DEBUG:urllib3.connectionpool:http://boards.4chan.org:80 "GET /s4s/thread/6850193 HTTP/1.1" 200 None
INFO:root:Visiting http://boards.4chan.org/o/
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): boards.4chan.org:80
DEBUG:urllib3.connectionpool:http://boards.4chan.org:80 "GET /o/ HTTP/1.1" 200 None
DEBUG:root:Hit a dead end, moving to the next root URL
DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.reddit.com:443
DEBUG:urllib3.connectionpool:https://www.reddit.com:443 "GET / HTTP/1.1" 200 None
DEBUG:root:found 237 links
INFO:root:Visiting https://www.reddit.com/user/Saditon
DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.reddit.com:443
DEBUG:urllib3.connectionpool:https://www.reddit.com:443 "GET /user/Saditon HTTP/1.1" 200 None
...

Opción Docker

docker build -t noisy .
Raspberry Pi (corriendo Raspbian stretch): docker build -f Dockerfile.pi -t noisy .

docker run -it noisy --config config.json

Referencias

El proyecto se ha inspirado en:
 
Proyecto: https://github.com/1tayH/noisy

Herramienta para explotar bases de datos Firebase vulnerables/mal configuradas

Os escribo este post para compartir con vosotros una herramienta que he escrito. Se trata de un script en python que explota bases de datos Firebase vulnerables/mal configuradas. Me he inspirado en la investigación de appthority y el posterior artículo de thehackernews.

Mi script en python adopta un enfoque diferente al utilizado por los investigadores anteriormente citados: mediante la api (no oficial) de dnsdumpster y el escáner online disponible en pentest-tools se obtienen diversos subdominios de firebaseio.com asociados con sus correspondientes bases de datos. Algunas de estas bases de datos, quizás a propósito o quizás no, son accesibles sin requerir ningún tipo de autenticación, tal y como descubrieron en appthority.

Otra opción más interesante que he implementado es intentar escanear DBs de firebase mediante el recopilatorio del millón de sitios web más destacados de Alexa.
 
Requisitos (módulos python no-estándar):
Instalación:
git clone https://github.com/Turr0n/firebase.git
cd firebase
pip install -r requirements.txt
Uso:
 
python3 firebase.py [-h] [--dnsdumpster] [-d /path/to/file.htm] [-o results.json] [-l /path/to/file] [-c 100] [-p 4]

Argumentos:
    -h      Show the help message
    -d      Absolute path to the downloaded HTML file.
    -o      Output file name. Default: results.json
    -c      Crawl for domains in the top-1m by Alexa. Set how many domains to crawl, for example: 100. Up to 1000000
    -p      How many processes to execute. Default: 1
    -l      Path to a file containing the DBs to crawl. One DB name per line. This option can't be used with -d or -c
    --dnsdumpster       Use the DNSDumpster API to gather DBs
    --just-v    Ignore "non-vulnerable" DBs
    --amass Path of the output file of an amass scan ([-o] argument)