taptap/cve-2025-59489Automatisierter Scanner, der die Unity-Laufzeit-Injection-Schwachstelle CVE-2025-59489 in Android-APKs erkennt, indem er die Unity-Version extrahiert und gegen gepatchte Versionen prüft, mit Stapelverarbeitung und CI/CD-Integration.
Automatisiertes Erkennungstool für Unity-Runtime-Injection-Schwachstellen, speziell für Android-Spieleplattformen.
Kurz zusammengefasst: Angreifer können die vollständige Kontrolle über betroffene Unity-Spiele/-Apps übernehmen und alle Berechtigungen dieser App erhalten.
Kernpunkt: Unter Android kann eine bösartige App die bereits erteilten Berechtigungen einer Unity-App kapern
Kernpunkt: Unter Windows kann der Klick auf einen speziell präparierten Link die Schwachstelle auslösen, wenn das Spiel einen benutzerdefinierten URI-Handler registriert hat
Gute Nachricht: Angreifer können die Berechtigungsgrenzen der App selbst nicht überschreiten
Schlechte Nachricht: Viele Spiele verlangen umfangreiche Berechtigungen (Kamera, Mikrofon, Speicher, Standort usw.), die Angreifer vollständig ausnutzen können
Als Betreiber einer Android-Spieleplattform sind die schlimmsten Folgen:
[Quelle: Offizielle Unity-Sicherheitsankündigung, Technische Analyse von GMO Flatt Security]
# Nur Python 3.7+ Standardbibliothek erforderlich, keine zusätzlichen Abhängigkeiten
python3 --version # Python-Version bestätigen
# Schritt 1: Tests ausführen
python test_demo.py
# Schritt 2: Einzelne APK prüfen
python unity_vulnerability_checker.py your_game.apk
# Schritt 3: Stapelprüfung
python unity_vulnerability_checker.py --batch /path/to/apks
# Schritt 4: Verwendungsbeispiele ansehen
python usage_examples.py
from unity_vulnerability_checker import check_unity_vulnerability
# Einzelne APK-Datei prüfen
result = check_unity_vulnerability("your_game.apk")
# Methode 1: Komfort-Eigenschaften verwenden
if result.is_vulnerable:
print(f"⚠️ App ist betroffen! ({result.version})")
print(f"Empfehlung: {result.recommendation}")
elif result.is_safe:
print(f"✅ App ist sicher")
print(f"Grund: {result.message}")
else:
print(f"❓ Manuelle Überprüfung erforderlich")
print(f"Grund: {result.message}")
# Methode 2: status-Feld verwenden
if result.status == "positive":
print(f"Betroffen: {result.version}")
from unity_vulnerability_checker import batch_check
# Ein Verzeichnis stapelweise scannen
results = batch_check("/path/to/apk/folder")
# Betroffene Apps herausfiltern
vulnerable_apps = [
(name, result)
for name, result in results.items()
if result.is_vulnerable
]
print(f"{len(vulnerable_apps)} betroffene Apps gefunden")
for name, result in vulnerable_apps:
print(f" - {name}: {result.version}")
from unity_vulnerability_checker import UnityVulnerabilityChecker
class MyPlatform:
"""Dein Spielplattform-System"""
def __init__(self):
self.checker = UnityVulnerabilityChecker()
def check_new_upload(self, apk_path: str) -> bool:
"""Neue hochgeladene APK prüfen, zurückgeben ob sie veröffentlicht werden kann"""
result = self.checker.check_apk(apk_path)
if result.is_vulnerable:
# Betroffen - Veröffentlichung ablehnen
self.notify_developer(
f"Ihre App ist von der Unity-Schwachstelle betroffen\n"
f"Version: {result.version}\n"
f"Empfehlung: {result.recommendation}"
)
return False
elif result.is_safe:
# Sicher - Veröffentlichung genehmigen
return True
else:
# Nicht bestimmbar - manuelle Überprüfung
self.queue_manual_review(apk_path, result.message)
return False
def notify_developer(self, message: str):
"""Entwickler benachrichtigen (deine Benachrichtigungslogik implementieren)"""
pass
def queue_manual_review(self, apk_path: str):
"""Zur manuellen Überprüfung einreihen (deine Logik implementieren)"""
pass
Das Tool gibt drei Arten von Ergebnissen zurück:
Beispielausgabe (kompaktes einzeiliges Format):
# Betroffene App
⚠️ Diese App ist von CVE-2025-59489 betroffen (Unity 2019.2.6f1)
# Sichere App (3 Fälle)
✅ Diese App ist sicher - Keine Unity-App
✅ Diese App ist sicher - Bereits mit dem Unity-Patcher-Tool repariert
✅ Diese App ist sicher - Behobene Version (2019.4.41f1)
# Nicht bestimmbar
❓ Nicht bestimmbar - Unity-App, aber Version konnte nicht extrahiert werden, möglicherweise gepackt oder verschleiert, manuelle Überprüfung empfohlen
⚠️ Datei zu groß für Verarbeitung (1500.0MB, Limit 1024MB) - MAX_APK_SIZE_MB in Zeile 15 des Codes auf einen größeren Wert ändern
.
├── unity_vulnerability_checker.py # Kernmodul
│ ├─ UnityVulnerabilityChecker-Klasse - Kern-Engine zur Schwachstellenerkennung
│ ├─ check_unity_vulnerability() - Vereinfachte Erkennungsfunktion
│ ├─ batch_check() - Stapelprüfungsfunktion
│ └─ Vollständige Versionsanalyse- und Bewertungslogik
│
├── usage_examples.py # Verwendungsbeispiele
│ ├─ Grundlegende Verwendungsbeispiele
│ ├─ Stapelprüfungsbeispiele
│ ├─ Plattformintegrationsbeispiele
│ ├─ Automatisierte Antwortbeispiele
│ └─ Flask-API-Integrationsbeispiele
│
├── test_demo.py # Testdemonstration
│ ├─ Versionsnummer-Analysetests
│ ├─ Versionsextraktionstests
│ ├─ Behebungsbewertungstests
│ ├─ APK-Scanszenario-Simulationen
│ └─ Leistungs-Benchmark-Tests
│
├── test_version_detection.py # Unit-Tests (33 Testfälle)
│
├── README.md # Vollständige Dokumentation (enthält Schnellstart-Anleitung)
│
└── CLAUDE.md # Entwicklungsrichtlinien
# Einzeldateiprüfung
python unity_vulnerability_checker.py game.apk
# Detaillierter Logmodus
python unity_vulnerability_checker.py game.apk -v
# Stapelprüfung eines Verzeichnisses
python unity_vulnerability_checker.py --batch /path/to/apk/folder
# Stapelprüfung (detaillierter Modus)
python unity_vulnerability_checker.py --batch /path/to/apk/folder -v
from unity_vulnerability_checker import batch_check
results = batch_check("/path/to/apk/directory", verbose=True)
# Betroffene Apps herausfiltern
vulnerable = {name: result for name, result in results.items()
if result.is_vulnerable}
print(f"{len(vulnerable)} betroffene Apps gefunden")
from unity_vulnerability_checker import UnityVulnerabilityChecker
class AppReviewSystem:
def __init__(self):
self.checker = UnityVulnerabilityChecker(verbose=False)
def review_upload(self, apk_path: str) -> str:
result = self.checker.check_apk(apk_path)
if result.is_vulnerable:
return "REJECT" # Veröffentlichung ablehnen
elif result.is_safe:
return "APPROVE" # Genehmigen
else:
return "MANUAL_REVIEW" # Manuelle Überprüfung
reviewer = AppReviewSystem()
decision = reviewer.review_upload("new_game.apk")
from flask import Flask, request, jsonify
from unity_vulnerability_checker import check_unity_vulnerability
app = Flask(__name__)
@app.route('/api/scan', methods=['POST'])
def scan_apk():
file = request.files['file']
temp_path = f"/tmp/{file.filename}"
file.save(temp_path)
result = check_unity_vulnerability(temp_path)
# to_dict()-Methode verwenden, um direkt in JSON zu konvertieren
response = result.to_dict()
response["filename"] = file.filename
response["vulnerable"] = result.is_vulnerable
return jsonify(response)
┌─────────────────┐
│ APK-Datei lesen │
└────────┬─────────┘
│
▼
┌─────────────────┐
│ Unity-App? │──NO──> negative
└────────┬─────────┘
│ YES
▼
┌─────────────────────┐
│ Patcher-Patch erkannt? │──YES──> negative
└────────┬─────────────┘
│ NO
▼
┌─────────────────┐
│ Unity-Version extrahieren │──Fehler──> inconclusive
└────────┬─────────┘
│ Erfolg
▼
┌─────────────────┐
│ Version < 2017.1 ? │──YES──> negative
└────────┬─────────┘
│ NO
▼
┌─────────────────┐
│ Version behoben? │──YES──> negative
└────────┬─────────┘
│ NO
▼
positive
Prüft, ob die folgenden Merkmale in der APK vorhanden sind:
lib/*/libunity.so - Unity-Laufzeitbibliothekassets/bin/Data/* - Unity-RessourcendateienExtrahiert die Unity-Versionsnummer aus den folgenden Quellen:
Unterstützte Versionsnummernformate:
2019.4.40f1, 2022.3.15f16000.0.23f1, 6000.2.6f22019.4.40, 6000.0.23Basierend auf den Regeln der offiziellen Unity-Sicherheitsankündigung:
Automatischer Scan vor der Veröffentlichung von Apps, Ablehnung betroffener Apps
from unity_vulnerability_checker import check_unity_vulnerability
def pre_publish_check(apk_path):
result = check_unity_vulnerability(apk_path)
if result.is_vulnerable:
return {
"approved": False,
"reason": f"CVE-2025-59489 vulnerability detected ({result.version})",
"recommendation": result.recommendation
}
return {"approved": True, "message": result.message}
Stapelweises Scannen des vorhandenen App-Bestands, Identifizierung von Apps, die aktualisiert werden müssen
python unity_vulnerability_checker.py --batch /data/published_apps > scan_report.txt
Täglicher geplanter Scan neu hochgeladener Apps mit automatischer Benachrichtigung der Entwickler
import schedule
from unity_vulnerability_checker import batch_check
def daily_scan():
results = batch_check("/data/new_uploads")
vulnerable = [(name, result) for name, result in results.items() if result.is_vulnerable]
if vulnerable:
# Benachrichtigung mit detaillierten Informationen senden
for name, result in vulnerable:
send_notification(name, result.version, result.message)
schedule.every().day.at("02:00").do(daily_scan)
Erstellung von Plattform-Sicherheitsberichten mit Statistiken zur Schwachstellenverteilung
from unity_vulnerability_checker import batch_check
import json
results = batch_check("/data/all_apps")
report = {
"total": len(results),
"vulnerable": sum(1 for r in results.values() if r.is_vulnerable),
"safe": sum(1 for r in results.values() if r.is_safe),
"unclear": sum(1 for r in results.values() if r.is_uncertain),
# Detaillierte Liste
"vulnerable_apps": [
{"name": name, "version": r.version, "message": r.message}
for name, r in results.items() if r.is_vulnerable
]
}
with open("security_report.json", "w") as f:
json.dump(report, f, indent=2)
Integration in kontinuierliche Integrationsprozesse für automatisierte Sicherheitsprüfungen
#!/bin/bash
# In der CI-Pipeline verwenden
python unity_vulnerability_checker.py build/output.apk
result=$(python unity_vulnerability_checker.py build/output.apk | grep "Erkennungsergebnis")
if echo "$result" | grep -q "positive"; then
echo "Security check failed: CVE-2025-59489 detected"
exit 1
fi
echo "Security check passed"
Mögliche Fehlbewertung als sicher:
Mögliche Fehlbewertung als betroffen:
inconclusive-Ergebnisse wird eine manuelle Überprüfung empfohlenMögliche Gründe:
Empfehlung: Manuelle Überprüfung solcher Apps durchführen
Unity hat für die Versionen 2017.1-2018.4 keine Sicherheitspatches bereitgestellt. Diese Versionen sind tatsächlich anfällig, aber da:
Wird "inconclusive" statt "positive" zurückgegeben. Empfehlungen:
Basierend auf den Regeln der offiziellen Unity-Ankündigung liegt die Genauigkeit für standardmäßig erstellte APKs bei > 95 %. Verschleierte oder gepackte APKs können zusätzliche Verarbeitung erfordern.
Die Prüfung einer einzelnen APK dauert in der Regel 0,5-2 Sekunden und unterstützt parallele Stapelverarbeitung für höhere Effizienz. Detaillierte Leistungskennzahlen finden Sie im Abschnitt "Leistungskennzahlen" dieses Dokuments.
Die aktuelle Version konzentriert sich auf Android-APKs. Die Prüfung von iOS-.ipa-Dateien erfordert zusätzliche Anpassungen.
Ändern Sie das PATCHED_VERSIONS-Wörterbuch in unity_vulnerability_checker.py und verfolgen Sie die offiziellen Unity-Ankündigungen für die neuesten Informationen.
Sofort handeln
Kontinuierliche Überwachung
Nutzerbenachrichtigung
Unity-Version aktualisieren
Temporäre Lösung (wenn kein Upgrade möglich)
Behebung verifizieren
positive gemeldet wirdProbleme aufgetreten?
test_demo.py ausführen, um die ordnungsgemäße Funktion des Tools zu verifizierenusage_examples.py für ähnliche Szenarien ansehenDas Projekt ist mit vollständigen Codequalitätsprüfungswerkzeugen konfiguriert:
# Abhängigkeiten installieren
pip install ruff pre-commit
# Pre-commit-Hooks installieren
pre-commit install
# Alle Prüfungen manuell ausführen
pre-commit run --all-files
Vor jedem Commit werden automatisch die folgenden Prüfungen ausgeführt:
Ruff Linter - Statische Analyse von Python-Code
Ruff Formatter - Python-Codeformatierung
Allgemeine Dateiprüfungen
Markdown-Formatprüfung
ruff.toml - Ruff-Konfiguration.pre-commit-config.yaml - Pre-commit-Hooks-KonfigurationDer gesamte Code muss vor dem Commit die Ruff-Prüfung bestehen. Wenn die Prüfung fehlschlägt, wird der Commit blockiert.
# Wenn pre-commit fehlschlägt, werden einige Probleme automatisch behoben
# Nach der Behebung erneut git add und commit ausführen
git add .
git commit -m "your message"
# Nur Python-Dateien prüfen
ruff check *.py
# Probleme automatisch beheben
ruff check --fix *.py
# Code formatieren
ruff format *.py
major >= 2019 or major >= 6000)Dieses Tool dient ausschließlich der Sicherheitsprüfung und Compliance-Kontrolle.
| Wenn das Spiel diese Berechtigung hat | Kann der Angreifer |
|---|
| 📸 Kamera | Dich heimlich filmen |
| 🎤 Mikrofon | Dich belauschen |
| 📍 Standort | Dich verfolgen |
| 📱 Kontakte | Dein Adressbuch stehlen |
| 💾 Speicher | Deine Dateien lesen/löschen |
| 💰 Zahlungen | In-App-Zahlungen missbrauchen |
| 🔐 Konto | Das Spielkonto stehlen |
| Unity-Version | Mindestversion mit Fix | Status |
|---|
| 6000.3 | 6000.3.0b4 | ✅ Patch verfügbar |
| 6000.2 | 6000.2.6f2 | ✅ Patch verfügbar |
| 6000.0 LTS | 6000.0.58f2 | ✅ Patch verfügbar |
| 2022.3 | 2022.3.62f2 | ✅ Patch verfügbar |
| 2021.3 | 2021.3.45f2 | ✅ Patch verfügbar |
| 2020.x | 2020.1.18f1+ | ✅ Patch verfügbar |
| 2019.x | 2019.1.15f1+ | ✅ Patch verfügbar |
| 2017-2018 | N/A | ⚠️ Kein offizieller Patch, Versionsupgrade empfohlen |