Nesta secção, exploraremos os componentes envolvidos na construção de uma plataforma de inteligência contra ameaças bem-sucedida. Conforme mencionado anteriormente, este curso envolverá o teste de técnicas de extração de dados em sites fictícios que você pode configurar localmente usando o Docker. Aqui, você obterá informações sobre os tipos de sites com os quais trabalharemos.

Os tópicos abordados nesta secção incluem:

  1. Fórum Clearnet
  2. Fórum Tor
  3. Abordagem não LLM para análise de texto
  4. Lidando com tecnologias anti-scraping
  5. Listas de observação de inteligência

Fórum Clearnet

Embora a maioria dos sites de crimes cibernéticos não dependa muito de JavaScript, é importante entender como extrair dados de sites clearnet. A maioria dos sites Clearnet geralmente busca dados do backend usando JavaScript e, em seguida, atualiza o frontend dinamicamente. Ao visualizar a fonte da página, poderá não encontrar dados utilizáveis, pois o conteúdo é carregado após o carregamento inicial da página. Um bom exemplo é o nosso próprio scraper, onde quase todo o conteúdo é dinâmico e está em constante mudança.

Nesses casos, usamos navegadores headless como o Playwright para interagir com a página e extrair dados do DOM (Document Object Model) depois que ele for totalmente carregado e renderizado.

Para praticar isso, pode descarregar o fórum fictício sobre crimes cibernéticos criado para este curso no GitHub:

https://github.com/CyberMounties/clearnet_forum

O repositório contém instruções completas de configuração para executar o fórum localmente.

Fórum Tor

Grande parte da atividade de cibercrime ocorre no Tor devido à sua arquitetura centrada na privacidade. O nosso fórum Tor simulado foi projetado sem JavaScript para imitar cenários do mundo real, mantendo a simplicidade. Ao contrário do fórum clearnet, que inclui um recurso de shoutbox (chat geral), o fórum Tor não possui esse recurso.

Pode configurar o fórum Tor fictício para este curso descarregando-o do GitHub:

https://github.com/CyberMounties/tornet_forum

O repositório inclui instruções detalhadas para configurar e executar o fórum localmente.

Abordagem não LLM para análise de texto

Em vez de depender de modelos de linguagem grandes (LLMs) ou IA, pode usar bibliotecas tradicionais de processamento de linguagem natural (NLP), como spaCy, para analisar dados. Essas ferramentas podem ajudar em tarefas como classificação de texto, reconhecimento de entidades e correspondência de padrões. No entanto, elas têm limitações: normalmente exigem mais personalização manual, criação de regras e treinamento para alcançar resultados comparáveis aos LLMs. Embora possam ser eficazes para certos casos de uso, configurá-las para tarefas complexas, como identificar atividades de IAB, pode exigir muito mais tempo e esforço.

Exemplo com spaCy

Crie um diretório, configure um ambiente virtual e instale as dependências:

mkdir non_llm_cti && cd non_llm_cti
python3 -m venv venv
source venv/bin/activate
pip install spacy
python -m spacy download en_core_web_sm

Crie um ficheiro de script chamado «main.py» e cole o seguinte código dentro dele:

import spacy
import re
from typing import Tuple

# Load spaCy's English model
nlp = spacy.load("en_core_web_sm")

# Define keywords and patterns for initial access detection
ACCESS_KEYWORDS = {
    "access", "vpn", "rdp", "network", "server", "admin", "credentials", 
    "login", "remote", "domain", "shell", "backdoor"
}
SALE_KEYWORDS = {"sell", "selling", "offer", "offering", "sale", "available", "price", "btc", "escrow"}
NEGATIVE_KEYWORDS = {"hosting", "vps", "software", "malware", "loader", "botnet"}
OBFUSCATION_PATTERNS = [
    r"acc[e3]ss",  # Handles "acc3ss", "access"
    r"v[pP][nN]",  # Handles "VPN", "VpN", "vpn"
    r"rd[pP]",     # Handles "RDP", "rdp"
]

def preprocess_text(text: str) -> str:
    """Normalize text by converting to lowercase and handling basic obfuscation."""
    text = text.lower()
    for pattern in OBFUSCATION_PATTERNS:
        text = re.sub(pattern, re.search(pattern, text).group().replace("3", "e"), text) if re.search(pattern, text) else text
    return text

def analyze_post(text: str) -> Tuple[str, float]:
    """
    Analyze a post to determine if it offers initial access.
    Returns: (classification, confidence_score)
    Classifications: 'positive' (initial access sale), 'neutral' (general ad), 'negative' (unrelated)
    """
    # Preprocess text
    text = preprocess_text(text)
    doc = nlp(text)

    # Initialize scores
    access_score = 0.0
    sale_score = 0.0
    negative_score = 0.0

    # Rule 1: Check for access-related keywords
    for token in doc:
        if token.lemma_ in ACCESS_KEYWORDS:
            access_score += 0.4
        if token.lemma_ in SALE_KEYWORDS:
            sale_score += 0.3
        if token.lemma_ in NEGATIVE_KEYWORDS:
            negative_score += 0.5

    # Rule 2: Dependency parsing for sales intent (e.g., "selling access")
    for token in doc:
        if token.lemma_ in SALE_KEYWORDS and token.head.lemma_ in ACCESS_KEYWORDS:
            access_score += 0.3
            sale_score += 0.3
        elif token.lemma_ in ACCESS_KEYWORDS and token.head.lemma_ in SALE_KEYWORDS:
            access_score += 0.3
            sale_score += 0.3

    # Rule 3: Named entities (e.g., "RBC Bank", "EU telecom") for context
    for ent in doc.ents:
        if ent.label_ in ["ORG", "GPE"]:
            access_score += 0.2

    # Rule 4: Regex for specific patterns (e.g., "access to [entity]")
    access_pattern = r"\b(access|vpn|rdp)\b.*\b(to|for|at)\b.*\b(bank|telecom|network|company|org)\b"
    if re.search(access_pattern, text, re.IGNORECASE):
        access_score += 0.3

    # Rule 5: Cryptocurrency or escrow mentions
    if any(word in text for word in ["btc", "bitcoin", "escrow", "monero"]):
        sale_score += 0.2

    # Calculate total score and determine classification
    total_score = access_score + sale_score - negative_score
    if access_score >= 0.4 and sale_score >= 0.3 and total_score > 0.5:
        classification = "positive"
        confidence = min(total_score, 1.0)
    elif negative_score > access_score and negative_score > sale_score:
        classification = "negative"
        confidence = min(negative_score, 1.0)
    else:
        classification = "neutral"
        confidence = min(max(access_score, sale_score, negative_score), 1.0)

    return classification, confidence

def main():
    # Test cases
    test_posts = [
        # Positive: Initial access sale with details
        """Back again, mods nuked my last thread. Selling VPN access to a big EU telecom, one of them household names in Germany (you figure it out). Full internal access, you can pivot to servers, grab call logs, or mess with billing systems. Been stable for a month, no kicks. Asking $4,000 BTC, negotiable for bulk buyers (got 2 more telecoms). I'll throw in logs or a test connection for proof, but only if you're serious. Escrow or MM accepted, I'm vouched here. Hit me up in PM, let's make this quick. No skids, please.""",
        # Positive: Direct initial access sale
        "Initial access to RBC Bank available, full admin creds, $5k BTC, DM for details.",
        # Neutral: General ad, not access-related
        "Selling malware loader, high quality, $200, contact me for demo.",
        # Negative: Unrelated service
        "Offering VPS hosting, 16GB RAM, $50/month, legit service."
    ]

    for i, post in enumerate(test_posts, 1):
        classification, confidence = analyze_post(post)
        print(f"\nPost {i}:")
        print(f"Text: {post[:100]}..." if len(post) > 100 else f"Text: {post}")
        print(f"Classification: {classification.capitalize()}")
        print(f"Confidence: {confidence:.2f}")

if __name__ == "__main__":
    main()

Execute e veja os resultados por si mesmo:

$ python3 main.py

Post 1:
Text: Back again, mods nuked my last thread. Selling VPN access to a big EU telecom, one of them household...
Classification: Positive
Confidence: 1.00

Post 2:
Text: Initial access to RBC Bank available, full admin creds, $5k BTC, DM for details.
Classification: Positive
Confidence: 1.00

Post 3:
Text: Selling malware loader, high quality, $200, contact me for demo.
Classification: Negative
Confidence: 1.00

Post 4:
Text: Offering VPS hosting, 16GB RAM, $50/month, legit service.
Classification: Negative
Confidence: 1.00

Essa abordagem, conforme demonstrado, é menos confiável, especialmente na classificação precisa da terceira publicação como «neutra». Ela exige ampla personalização e ajustes, o que, neste caso, supera os benefícios, dada a disponibilidade de soluções mais simples e adaptáveis, como as APIs de IA existentes.

Tecnologias anti-scraping

Extrair dados de sites é simples em pequena escala, mas torna-se complexo quando os sites implementam tecnologias anti-scraping para bloquear o acesso automatizado. Muitos sites impõem termos de serviço que proíbem o scraping, e os programadores implementam medidas de proteção para fazer cumprir essas restrições.

As técnicas anti-scraping comuns incluem:

  • CAPTCHAs: exigem que os utilizadores resolvam puzzles ou desafios baseados em imagens para verificar que não são bots.
  • Limitação de taxa: limita o número de solicitações de um único endereço IP ou conta dentro de um período específico.
  • Bloqueio de contas: suspende temporária ou permanentemente as contas após detectar atividades suspeitas ou tentativas excessivas de login com falha.
  • Proibições de IP: bloqueia o tráfego de endereços IP que exibem padrões automatizados ou comportamento abusivo.
  • Verificações de cabeçalho e comportamento: Detecta pedidos que se desviam do comportamento típico do navegador, como cabeçalhos em falta ou padrões de interação irrealistas.

Ferramentas como o Playwright podem ajudar a contornar algumas das defesas anti-bot, simulando um navegador real, mas ainda não é suficiente. Pode querer usar o undetected chrome driver.

Embora este curso não aborde como contornar todas as técnicas avançadas anti-scraping, o exemplo abaixo ilustra como usar o Playwright para simular velocidades de digitação semelhantes às humanas.

Para começar, configure um ambiente e instale as dependências:

mkdir play && cd play
touch play.py
python3 -m venv venv
source venv/bin/activate
sudo apt install libavif16
pip3 install playwright
playwright install

Abra play.py e insira este código:

from playwright.sync_api import sync_playwright
import time
import os

def fill_input_slowly():
    text_to_type = "This is a test string"
    local_html = """
    <!DOCTYPE html>
    <html>
    <body>
        <form>
            <input type="text" id="fname" name="fname" value="Hamy">
        </form>
    </body>
    </html>
    """
    
    # Write the HTML to a temporary file
    html_file_path = "temp.html"
    with open(html_file_path, "w") as f:
        f.write(local_html)
    
    with sync_playwright() as p:
        # Set headless to True if you don't want to see the browser
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        
        try:
            page.goto(f"file://{os.path.abspath(html_file_path)}", timeout=60000)
            input_field = page.locator("input#fname[name='fname']")
            input_field.wait_for(timeout=10000) 
            input_field.clear()

            for char in text_to_type:
                input_field.type(char, delay=750)
            time.sleep(2)
            
        except Exception as e:
            print(f"Error occurred: {e}")
        
        finally:
            browser.close()
            if os.path.exists(html_file_path):
                os.remove(html_file_path)

if __name__ == "__main__":
    fill_input_slowly()

Listas de vigilância de inteligência

Uma das principais características que diferencia este curso da maioria dos treinamentos em CTI é que você aprenderá a criar listas de vigilância de inteligência realistas. Essas listas funcionam como um sistema de vigilância automatizado, monitorando continuamente a atividade de um utilizador ao longo do tempo. Em vez de apenas coletar instantâneos de dados, você criará ferramentas que podem rastrear mudanças e ações à medida que elas acontecem.

O principal objetivo destas listas de vigilância é demonstrar como cruzar as atividades de um agente de ameaças em várias plataformas, ajudando-o a construir uma imagem completa do seu comportamento. Isto é essencial para rastrear agentes de ameaças prolíficos, correlacionar dados de diferentes fontes e compreender padrões que podem sinalizar intenções maliciosas.

Para criar um perfil de lista de vigilância, irá definir:

  • Link: O identificador do indivíduo ou entidade que pretende monitorizar.
  • Frequência: com que frequência o sistema verifica se há novas atividades. As opções incluem:
    • Baixa: a cada 24 horas
    • Média: a cada 12 horas
    • Alta: a cada 6 horas
    • Muito alta: a cada 1 hora
    • Crítica: a cada 5 minutos
  • Prioridade: a profundidade das informações recolhidas. As opções incluem:
    • Tudo: Todos os dados disponíveis (publicações e comentários)
    • Apenas publicações: Apenas o conteúdo publicado pelo utilizador
    • Apenas comentários: Apenas os comentários feitos pelo utilizador

Por exemplo, uma lista de observação de baixa prioridade verifica a atividade a cada 24 horas e recolhe os dados relevantes. Os resultados podem ser exportados em formato JSON para facilitar o download e a referência cruzada com outras plataformas.