Analisando Inteligência de Sites de Vazamento de Ransomware
Visão Geral
Grupos de ransomware que operam sob modelos de dupla extorsão mantêm sites de vazamento de dados (DLS) em serviços ocultos do Tor, onde publicam nomes de vítimas, amostras de dados roubados e temporizadores regressivos para pressionar o pagamento. No primeiro semestre de 2025, 96 grupos de ransomware únicos estavam ativos, listando aproximadamente 535 vítimas por mês. Monitorar esses sites fornece inteligência sobre grupos de ameaças ativos, setores visados, padrões geográficos e famílias de ransomware emergentes. Esta habilidade abrange a coleta segura de inteligência de DLS, extração de dados estruturados, rastreamento de tendências de atividade do grupo e produção de avaliações de risco específicas por setor.
Quando Usar
- Ao investigar incidentes de segurança que exigem análise de inteligência de sites de vazamento de ransomware
- Ao construir regras de detecção ou consultas de caça a ameaças para este domínio
- Quando analistas de SOC precisam de procedimentos estruturados para este tipo de análise
- Ao validar a cobertura de monitoramento de segurança para técnicas de ataque relacionadas
Pré-requisitos
- Python 3.9+ com as bibliotecas
requests,beautifulsoup4,pandas,matplotlib - Proxy Tor (SOCKS5) para acessar sites .onion ou feeds comerciais de monitoramento de DLS
- Compreensão do modelo de negócios de dupla extorsão de ransomware
- Familiaridade com as principais famílias de ransomware (Qilin, Akira, LockBit, BlackCat, Clop)
- Acesso a feeds de rastreamento de ransomware (Ransomwatch, RansomLook, DarkFeed)
Conceitos-chave
Modelo de Dupla Extorsão
Grupos modernos de ransomware criptografam os dados da vítima E os exfiltram antes da criptografia. Os sites de vazamento servem como pressão pública: as vítimas são listadas com um temporizador regressivo, amostras de dados parciais e árvores de arquivos. Se o resgate não for pago, os dados completos são publicados. Alguns grupos evoluíram para a tripla extorsão, adicionando ameaças de DDoS ou contatando diretamente os clientes das vítimas.
Valor da Inteligência de DLS
Os sites de vazamento fornecem: identificação da vítima (nome da empresa, setor, país), linha do tempo do ataque (quando listado, prazo, dados publicados), estimativas de volume de dados, avaliação de capacidade do grupo (setores visados, frequência de ataque, ritmo operacional) e análise de tendências (novos grupos emergindo, grupos mudando de nome, desmantelamentos por forças policiais).
Práticas de Coleta Segura
Nunca acesse sites DLS diretamente em um ambiente de produção. Use serviços de monitoramento criados para esse fim (Ransomwatch, DarkFeed, KELA, Flashpoint), VMs de pesquisa isoladas por Tor, plataformas comerciais de inteligência de ameaças ou conjuntos de dados mantidos pela comunidade. Toda a análise deve ser conduzida em ambientes isolados com a devida autorização.
Fluxo de Trabalho
Etapa 1: Ingerir Dados de Sites de Vazamento de Ransomware de Feeds Públicos
import requests
import json
import pandas as pd
from datetime import datetime, timedelta
from collections import Counter
class RansomwareIntelCollector:
"""Coleta inteligência de DLS de ransomware de fontes de rastreamento públicas."""
RANSOMWATCH_API = "https://raw.githubusercontent.com/joshhighet/ransomwatch/main/posts.json"
RANSOMWATCH_GROUPS = "https://raw.githubusercontent.com/joshhighet/ransomwatch/main/groups.json"
def __init__(self):
self.posts = []
self.groups = []
def fetch_ransomwatch_data(self):
"""Busca postagens de vítimas de ransomware do ransomwatch."""
resp = requests.get(self.RANSOMWATCH_API, timeout=30)
if resp.status_code == 200:
self.posts = resp.json()
print(f"[+] Carregadas {len(self.posts)} postagens de vítimas do ransomwatch")
else:
print(f"[-] Falha ao buscar postagens: {resp.status_code}")
resp = requests.get(self.RANSOMWATCH_GROUPS, timeout=30)
if resp.status_code == 200:
self.groups = resp.json()
print(f"[+] Carregados {len(self.groups)} perfis de grupos de ransomware")
return self.posts
def get_recent_victims(self, days=30):
"""Obtém vítimas publicadas nos últimos N dias."""
cutoff = datetime.now() - timedelta(days=days)
recent = []
for post in self.posts:
try:
discovered = datetime.fromisoformat(
post.get("discovered", "").replace("Z", "+00:00")
)
if discovered.replace(tzinfo=None) >= cutoff:
recent.append(post)
except (ValueError, TypeError):
continue
print(f"[+] {len(recent)} vítimas nos últimos {days} dias")
return recent
def get_group_activity(self, group_name):
"""Obtém todas as postagens de um grupo de ransomware específico."""
group_posts = [
p for p in self.posts
if p.get("group_name", "").lower() == group_name.lower()
]
print(f"[+] {group_name}: {len(group_posts)} vítimas no total")
return group_posts
collector = RansomwareIntelCollector()
collector.fetch_ransomwatch_data()
recent = collector.get_recent_victims(days=30)
Etapa 2: Analisar Atividade e Tendências do Grupo
def analyze_group_trends(posts, top_n=15):
"""Analisa tendências de atividade de grupos de ransomware."""
group_counts = Counter(p.get("group_name", "desconhecido") for p in posts)
monthly_activity = {}
for post in posts:
try:
date = datetime.fromisoformat(
post.get("discovered", "").replace("Z", "+00:00")
)
month_key = date.strftime("%Y-%m")
group = post.get("group_name", "desconhecido")
if month_key not in monthly_activity:
monthly_activity[month_key] = Counter()
monthly_activity[month_key][group] += 1
except (ValueError, TypeError):
continue
analysis = {
"total_posts": len(posts),
"unique_groups": len(group_counts),
"top_groups": group_counts.most_common(top_n),
"monthly_totals": {
month: sum(counts.values())
for month, counts in sorted(monthly_activity.items())
},
"monthly_top_groups": {
month: counts.most_common(5)
for month, counts in sorted(monthly_activity.items())
},
}
print(f"\n=== Atividade de Grupos de Ransomware ===")
print(f"Total de vítimas rastreadas: {analysis['total_posts']}")
print(f"Grupos ativos: {analysis['unique_groups']}")
print(f"\nTop {top_n} Grupos:")
for group, count in analysis["top_groups"]:
print(f" {group}: {count} vítimas")
return analysis
trends = analyze_group_trends(collector.posts)
Etapa 3: Avaliação de Risco Setorial e Geográfica
def assess_sector_risk(posts, target_sector=None, target_country=None):
"""Avalia o risco de ransomware para setor ou geografia específica."""
sector_data = {}
country_data = {}
for post in posts:
# Extrai setor se disponível (nem todos os feeds incluem isso)
sector = post.get("sector", post.get("industry", "desconhecido"))
country = post.get("country", "desconhecido")
if sector not in sector_data:
sector_data[sector] = {"count": 0, "groups": Counter(), "recent": []}
sector_data[sector]["count"] += 1
sector_data[sector]["groups"][post.get("group_name", "")] += 1
if country not in country_data:
country_data[country] = {"count": 0, "groups": Counter()}
country_data[country]["count"] += 1
country_data[country]["groups"][post.get("group_name", "")] += 1
# Pontuação de risco setorial
total = len(posts)
risk_assessment = {
"total_victims": total,
"sectors": {},
"countries": {},
}
for sector, data in sorted(sector_data.items(), key=lambda x: -x[1]["count"]):
pct = (data["count"] / total * 100) if total > 0 else 0
risk_assessment["sectors"][sector] = {
"victim_count": data["count"],
"percentage": round(pct, 1),
"top_groups": data["groups"].most_common(5),
"risk_level": (
"crítico" if pct > 15
else "alto" if pct > 8
else "médio" if pct > 3
else "baixo"
),
}
for country, data in sorted(country_data.items(), key=lambda x: -x[1]["count"]):
pct = (data["count"] / total * 100) if total > 0 else 0
risk_assessment["countries"][country] = {
"victim_count": data["count"],
"percentage": round(pct, 1),
"top_groups": data["groups"].most_common(5),
}
return risk_assessment
risk = assess_sector_risk(collector.posts)
Etapa 4: Rastrear Grupos Emergentes e com Mudança de Nome
def track_new_groups(posts, lookback_days=90):
"""Identifica grupos de ransomware recém-emergidos."""
group_first_seen = {}
for post in posts:
group = post.get("group_name", "")
try:
date = datetime.fromisoformat(
post.get("discovered", "").replace("Z", "+00:00")
)
if group not in group_first_seen or date < group_first_seen[group]["first_seen"]:
group_first_seen[group] = {
"first_seen": date,
"first_victim": post.get("post_title", ""),
}
except (ValueError, TypeError):
continue
cutoff = datetime.now() - timedelta(days=lookback_days)
new_groups = {
group: info for group, info in group_first_seen.items()
if info["first_seen"].replace(tzinfo=None) >= cutoff
}
# Conta total de vítimas por novo grupo
for group in new_groups:
victims = [p for p in posts if p.get("group_name") == group]
new_groups[group]["total_victims"] = len(victims)
new_groups[group]["avg_per_month"] = round(
len(victims) / max(1, lookback_days / 30), 1
)
print(f"\n=== Novos Grupos (últimos {lookback_days} dias) ===")
for group, info in sorted(new_groups.items(), key=lambda x: -x[1]["total_victims"]):
print(f" {group}: {info['total_victims']} vítimas, "
f"primeira aparição em {info['first_seen'].strftime('%Y-%m-%d')}")
return new_groups
new_groups = track_new_groups(collector.posts, lookback_days=90)
Etapa 5: Gerar Relatório de Inteligência
def generate_ransomware_intel_report(trends, risk, new_groups):
"""Gera relatório de inteligência de ameaças de ransomware."""
report = f"""# Relatório de Inteligência de Ameaças de Ransomware
Gerado em: {datetime.now().isoformat()}
## Sumário Executivo
- **Total de vítimas rastreadas**: {trends['total_posts']}
- **Grupos de ransomware ativos**: {trends['unique_groups']}
- **Novos grupos (últimos 90 dias)**: {len(new_groups)}
## Principais Grupos Ativos
| Classificação | Grupo | Vítimas |
|------|-------|---------|
"""
for i, (group, count) in enumerate(trends["top_groups"][:10], 1):
report += f"| {i} | {group} | {count} |\n"
report += "\n## Novos Grupos Emergentes\n"
for group, info in sorted(new_groups.items(), key=lambda x: -x[1]["total_victims"])[:10]:
report += f"- **{group}**: {info['total_victims']} vítimas desde {info['first_seen'].strftime('%Y-%m-%d')}\n"
report += "\n## Avaliação de Risco Setorial\n"
report += "| Setor | Vítimas | % | Nível de Risco |\n|--------|---------|---|------------|\n"
for sector, data in list(risk["sectors"].items())[:10]:
report += f"| {sector} | {data['victim_count']} | {data['percentage']}% | {data['risk_level'].upper()} |\n"
report += """
## Recomendações
1. Monitore feeds DLS diariamente para sua organização e parceiros da cadeia de suprimentos
2. Priorize a correção de vulnerabilidades exploradas pelos principais grupos ativos
3. Implemente estratégia de backup offline para reduzir alavancagem de extorsão
4. Conduza exercícios de mesa para resposta a cenários de ransomware
5. Compartilhe indicadores com ISACs setoriais e comunidades de compartilhamento de ameaças
"""
with open("ransomware_intel_report.md", "w") as f:
f.write(report)
print("[+] Relatório salvo: ransomware_intel_report.md")
return report
generate_ransomware_intel_report(trends, risk, new_groups)
Critérios de Validação
- Dados de vítimas de ransomware ingeridos de feeds de rastreamento públicos
- Tendências de atividade do grupo analisadas com detalhamento mensal
- Avaliação de risco setorial e geográfica produzida
- Grupos novos e emergentes identificados com métricas de atividade
- Relatório de inteligência gerado com recomendações acionáveis
- Toda coleta conduzida através de fontes públicas autorizadas