Was macht Analyse von Ransomware-Leak-Site-Intelligence?
Überblick
Ransomware-Gruppen, die nach dem Double-Extortion-Modell operieren, betreiben Datenleak-Seiten (DLS) auf Tor-Hidden-Services, auf denen sie Opfernamen, gestohlene Datenproben und Countdown-Timer veröffentlichen, um Zahlungsdruck auszuüben. Im H1 2025 waren 96 einzigartige Ransomware-Gruppen aktiv, die monatlich etwa 535 Opfer auflisteten. Die Überwachung dieser Seiten liefert Intelligence über aktive Bedrohungsgruppen, gezielte Sektoren, geografische Muster und aufkommende Ransomware-Familien. Diese Fähigkeit umfasst die sichere Erfassung von DLS-Intelligence, die Extraktion strukturierter Daten, die Verfolgung von Gruppenaktivitätstrends und die Erstellung sektorspezifischer Risikobewertungen.
Wann verwenden
- Bei der Untersuchung von Sicherheitsvorfällen, die die Analyse von Ransomware-Leak-Site-Intelligence erfordern
- Bei der Erstellung von Erkennungsregeln oder Threat-Hunting-Abfragen für diese Domäne
- Wenn SOC-Analysten strukturierte Verfahren für diesen Analysetyp benötigen
- Bei der Validierung der Sicherheitsüberwachungsabdeckung für verwandte Angriffstechniken
Voraussetzungen
- Python 3.9+ mit den Bibliotheken
requests,beautifulsoup4,pandas,matplotlib - Tor-Proxy (SOCKS5) für den Zugriff auf .onion-Seiten oder kommerzielle DLS-Überwachungsfeeds
- Verständnis des Ransomware-Double-Extortion-Geschäftsmodells
- Vertrautheit mit großen Ransomware-Familien (Qilin, Akira, LockBit, BlackCat, Clop)
- Zugang zu Ransomware-Tracking-Feeds (Ransomwatch, RansomLook, DarkFeed)
Schlüsselkonzepte
Double-Extortion-Modell
Moderne Ransomware-Gruppen verschlüsseln Opferdaten UND exfiltrieren sie vor der Verschlüsselung. Leak-Seiten dienen als öffentlicher Druck: Opfer werden mit einem Countdown-Timer, teilweisen Datenproben und Dateibäumen aufgelistet. Wird das Lösegeld nicht gezahlt, werden die vollständigen Daten veröffentlicht. Einige Gruppen sind zur Triple Extortion übergegangen und fügen DDoS-Drohungen hinzu oder kontaktieren direkt die Kunden der Opfer.
DLS-Intelligence-Wert
Leak-Seiten bieten: Opferidentifikation (Unternehmensname, Sektor, Land), Angriffszeitachse (wann gelistet, Frist, Daten veröffentlicht), Datengrößenschätzungen, Gruppenfähigkeitsbewertung (angezielte Sektoren, Angriffshäufigkeit, operationelles Tempo) und Trendanalyse (neue Gruppen, Gruppen-Umbranding, Strafverfolgungsmaßnahmen).
Sichere Erfassungspraktiken
Greifen Sie niemals direkt auf DLS-Seiten in einer Produktionsumgebung zu. Verwenden Sie zweckgebundene Überwachungsdienste (Ransomwatch, DarkFeed, KELA, Flashpoint), Tor-isolierte Forschungs-VMs, kommerzielle Threat-Intelligence-Plattformen oder von der Gemeinschaft gepflegte Datensätze. Alle Analysen sollten in isolierten Umgebungen mit entsprechender Autorisierung durchgeführt werden.
Workflow
Schritt 1: Ransomware-Leak-Site-Daten aus öffentlichen Feeds erfassen
import requests
import json
import pandas as pd
from datetime import datetime, timedelta
from collections import Counter
class RansomwareIntelCollector:
"""Sammelt Ransomware-DLS-Intelligence aus öffentlichen Tracking-Quellen."""
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):
"""Ruft Ransomware-Opferbeiträge von Ransomwatch ab."""
resp = requests.get(self.RANSOMWATCH_API, timeout=30)
if resp.status_code == 200:
self.posts = resp.json()
print(f"[+] {len(self.posts)} Opferbeiträge von Ransomwatch geladen")
else:
print(f"[-] Fehler beim Abrufen der Beiträge: {resp.status_code}")
resp = requests.get(self.RANSOMWATCH_GROUPS, timeout=30)
if resp.status_code == 200:
self.groups = resp.json()
print(f"[+] {len(self.groups)} Ransomware-Gruppenprofile geladen")
return self.posts
def get_recent_victims(self, days=30):
"""Ermittelt Opfer, die in den letzten N Tagen veröffentlicht wurden."""
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)} Opfer in den letzten {days} Tagen")
return recent
def get_group_activity(self, group_name):
"""Ermittelt alle Beiträge einer bestimmten Ransomware-Gruppe."""
group_posts = [
p for p in self.posts
if p.get("group_name", "").lower() == group_name.lower()
]
print(f"[+] {group_name}: {len(group_posts)} Opfer insgesamt")
return group_posts
collector = RansomwareIntelCollector()
collector.fetch_ransomwatch_data()
recent = collector.get_recent_victims(days=30)
Schritt 2: Gruppenaktivität und -trends analysieren
def analyze_group_trends(posts, top_n=15):
"""Analysiert Aktivitätstrends von Ransomware-Gruppen."""
group_counts = Counter(p.get("group_name", "unknown") 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", "unknown")
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=== Ransomware-Gruppenaktivität ===")
print(f"Verfolgte Opfer insgesamt: {analysis['total_posts']}")
print(f"Aktive Gruppen: {analysis['unique_groups']}")
print(f"\nTop {top_n} Gruppen:")
for group, count in analysis["top_groups"]:
print(f" {group}: {count} Opfer")
return analysis
trends = analyze_group_trends(collector.posts)
Schritt 3: Sektor- und geografische Risikobewertung
def assess_sector_risk(posts, target_sector=None, target_country=None):
"""Bewertet das Ransomware-Risiko für einen bestimmten Sektor oder eine bestimmte Geografie."""
sector_data = {}
country_data = {}
for post in posts:
# Sektor extrahieren, falls verfügbar (nicht alle Feeds enthalten dies)
sector = post.get("sector", post.get("industry", "unknown"))
country = post.get("country", "unknown")
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
# Sektor-Risikobewertung
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": (
"critical" if pct > 15
else "high" if pct > 8
else "medium" if pct > 3
else "low"
),
}
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)
Schritt 4: Neue und umbenennende Gruppen verfolgen
def track_new_groups(posts, lookback_days=90):
"""Identifiziert neu aufgetauchte Ransomware-Gruppen."""
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
}
# Opferanzahl pro neuer Gruppe zählen
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=== Neue Gruppen (letzte {lookback_days} Tage) ===")
for group, info in sorted(new_groups.items(), key=lambda x: -x[1]["total_victims"]):
print(f" {group}: {info['total_victims']} Opfer, "
f"erster Fund {info['first_seen'].strftime('%Y-%m-%d')}")
return new_groups
new_groups = track_new_groups(collector.posts, lookback_days=90)
Schritt 5: Intelligence-Bericht erstellen
def generate_ransomware_intel_report(trends, risk, new_groups):
"""Erstellt einen Ransomware-Bedrohungs-Intelligence-Bericht."""
report = f"""# Ransomware Threat Intelligence Report
Erstellt: {datetime.now().isoformat()}
## Executive Summary
- **Verfolgte Opfer insgesamt**: {trends['total_posts']}
- **Aktive Ransomware-Gruppen**: {trends['unique_groups']}
- **Neue Gruppen (letzte 90 Tage)**: {len(new_groups)}
## Top-aktive Gruppen
| Rang | Gruppe | Opfer |
|------|--------|-------|
"""
for i, (group, count) in enumerate(trends["top_groups"][:10], 1):
report += f"| {i} | {group} | {count} |\n"
report += "\n## Neue aufkommende Gruppen\n"
for group, info in sorted(new_groups.items(), key=lambda x: -x[1]["total_victims"])[:10]:
report += f"- **{group}**: {info['total_victims']} Opfer seit {info['first_seen'].strftime('%Y-%m-%d')}\n"
report += "\n## Sektor-Risikobewertung\n"
report += "| Sektor | Opfer | % | Risikostufe |\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 += """
## Empfehlungen
1. DLS-Feeds täglich für Ihre Organisation und Supply-Chain-Partner überwachen
2. Priorisierung der Patch-Behebung von Schwachstellen, die von den aktivsten Gruppen ausgenutzt werden
3. Offline-Backup-Strategie implementieren, um den Erpressungshebel zu verringern
4. Tabletop-Übungen für die Reaktion auf Ransomware-Szenarien durchführen
5. Indikatoren mit sektoralen ISACs und Threat-Sharing-Communities teilen
"""
with open("ransomware_intel_report.md", "w") as f:
f.write(report)
print("[+] Bericht gespeichert: ransomware_intel_report.md")
return report
generate_ransomware_intel_report(trends, risk, new_groups)
Validierungskriterien
- Ransomware-Opferdaten aus öffentlichen Tracking-Feeds eingelesen
- Gruppenaktivitätstrends mit monatlichen Aufschlüsselungen analysiert
- Sektor- und geografische Risikobewertung erstellt
- Neue und aufkommende Gruppen mit Aktivitätsmetriken identifiziert
- Intelligence-Bericht mit handlungsrelevanten Empfehlungen generiert
- Alle Erfassungen über autorisierte öffentliche Quellen durchgeführt