taptap/cve-2025-59489Analyseur automatisé qui détecte la vulnérabilité d'injection au runtime Unity CVE-2025-59489 dans les APK Android en extrayant la version d'Unity et en la vérifiant par rapport aux versions corrigées, avec traitement par lots et intégration CI/CD.
Outil de détection automatisée de la vulnérabilité d'injection du runtime Unity, spécialement conçu pour les plateformes de jeux Android.
En résumé : Un attaquant peut prendre le contrôle total du jeu/application Unity affecté et obtenir toutes les autorisations de cette application.
Point clé : Sur Android, une application malveillante peut détourner les autorisations déjà obtenues par l'application Unity
Point clé : Sur Windows, si le jeu a enregistré un gestionnaire d'URI personnalisé, cliquer sur un lien spécialement conçu peut déclencher la vulnérabilité
Bonne nouvelle : L'attaquant ne peut pas dépasser les limites d'autorisations de l'application elle-même
Mauvaise nouvelle : De nombreux jeux exigent de nombreuses autorisations (caméra, microphone, stockage, localisation, etc.), que l'attaquant peut exploiter pleinement
En tant qu'exploitant d'une plateforme de jeux Android, les pires conséquences :
[Source : avis de sécurité officiel d'Unity, analyse technique de GMO Flatt Security]
# Nécessite uniquement la bibliothèque standard Python 3.7+, aucune dépendance supplémentaire
python3 --version # Vérifier la version de Python
# Étape 1 : Exécuter les tests
python test_demo.py
# Étape 2 : Détecter un seul APK
python unity_vulnerability_checker.py your_game.apk
# Étape 3 : Détection par lots
python unity_vulnerability_checker.py --batch /path/to/apks
# Étape 4 : Consulter les exemples d'utilisation
python usage_examples.py
from unity_vulnerability_checker import check_unity_vulnerability
# Détecter un seul fichier APK
result = check_unity_vulnerability("your_game.apk")
# Méthode 1 : Utiliser les propriétés pratiques
if result.is_vulnerable:
print(f"⚠️ Application affectée ! ({result.version})")
print(f"Recommandation : {result.recommendation}")
elif result.is_safe:
print(f"✅ Application sécurisée")
print(f"Raison : {result.message}")
else:
print(f"❓ Nécessite une vérification manuelle")
print(f"Raison : {result.message}")
# Méthode 2 : Utiliser le champ status
if result.status == "positive":
print(f"Affectée : {result.version}")
from unity_vulnerability_checker import batch_check
# Analyser un répertoire par lots
results = batch_check("/path/to/apk/folder")
# Filtrer les applications affectées
vulnerable_apps = [
(name, result)
for name, result in results.items()
if result.is_vulnerable
]
print(f"{len(vulnerable_apps)} application(s) affectée(s) trouvée(s)")
for name, result in vulnerable_apps:
print(f" - {name} : {result.version}")
from unity_vulnerability_checker import UnityVulnerabilityChecker
class MyPlatform:
"""Votre système de plateforme de jeux"""
def __init__(self):
self.checker = UnityVulnerabilityChecker()
def check_new_upload(self, apk_path: str) -> bool:
"""Vérifier un APK nouvellement téléchargé, retourner s'il peut être publié"""
result = self.checker.check_apk(apk_path)
if result.is_vulnerable:
# Affecté - refuser la publication
self.notify_developer(
f"Votre application est affectée par la vulnérabilité Unity\n"
f"Version : {result.version}\n"
f"Recommandation : {result.recommendation}"
)
return False
elif result.is_safe:
# Sécurisé - approuver la publication
return True
else:
# Impossible de déterminer - vérification manuelle
self.queue_manual_review(apk_path, result.message)
return False
def notify_developer(self, message: str):
"""Notifier le développeur (implémenter votre logique de notification)"""
pass
def queue_manual_review(self, apk_path: str):
"""Ajouter à la file de vérification manuelle (implémenter votre logique)"""
pass
L'outil retourne trois types de résultats :
Exemple de sortie (format concis sur une ligne) :
# Application affectée
⚠️ Cette application est affectée par CVE-2025-59489 (Unity 2019.2.6f1)
# Application sécurisée (3 cas)
✅ Cette application est sécurisée - Application non Unity
✅ Cette application est sécurisée - Déjà corrigée avec l'outil Unity patcher
✅ Cette application est sécurisée - Version corrigée (2019.4.41f1)
# Impossible de déterminer
❓ Impossible de déterminer - Application Unity mais version impossible à extraire, peut être protégée ou obfusquée, vérification manuelle recommandée
⚠️ Fichier trop volumineux pour être traité (1500.0MB, limite 1024MB) - Modifier MAX_APK_SIZE_MB à la ligne 15 du code pour une valeur plus grande
.
├── unity_vulnerability_checker.py # Module principal
│ ├─ Classe UnityVulnerabilityChecker - moteur principal de détection de vulnérabilités
│ ├─ check_unity_vulnerability() - fonction de détection simplifiée
│ ├─ batch_check() - fonction de détection par lots
│ └─ logique complète d'analyse et de détermination des versions
│
├── usage_examples.py # Exemples d'utilisation
│ ├─ Exemples d'utilisation de base
│ ├─ Exemples de détection par lots
│ ├─ Exemples d'intégration de plateforme
│ ├─ Exemples de réponse automatisée
│ └─ Exemples d'intégration d'API Flask
│
├── test_demo.py # Démonstration de test
│ ├─ Tests d'analyse des numéros de version
│ ├─ Tests d'extraction de version
│ ├─ Tests de détermination de correction
│ ├─ Simulation de scénarios d'analyse APK
│ └─ Tests de référence de performance
│
├── test_version_detection.py # Tests unitaires (33 cas de test)
│
├── README.md # Documentation complète (inclut le guide de démarrage rapide)
│
└── CLAUDE.md # Normes de développement
# Détection d'un seul fichier
python unity_vulnerability_checker.py game.apk
# Mode journal détaillé
python unity_vulnerability_checker.py game.apk -v
# Détection par lots d'un répertoire
python unity_vulnerability_checker.py --batch /path/to/apk/folder
# Détection par lots (mode détaillé)
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)
# Filtrer les applications affectées
vulnerable = {name: result for name, result in results.items()
if result.is_vulnerable}
print(f"{len(vulnerable)} application(s) affectée(s) trouvée(s)")
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" # Refuser la publication
elif result.is_safe:
return "APPROVE" # Approuver
else:
return "MANUAL_REVIEW" # Vérification manuelle
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)
# Utiliser la méthode to_dict() pour convertir directement en JSON
response = result.to_dict()
response["filename"] = file.filename
response["vulnerable"] = result.is_vulnerable
return jsonify(response)
┌─────────────────┐
│ Lire le fichier APK │
└────────┬─────────┘
│
▼
┌─────────────────┐
│ Application Unity ? │──NON──> negative
└────────┬─────────┘
│ OUI
▼
┌─────────────────────┐
│ Correctif patcher détecté ? │──OUI──> negative
└────────┬─────────────┘
│ NON
▼
┌─────────────────┐
│ Extraire la version Unity │──Échec──> inconclusive
└────────┬─────────┘
│ Succès
▼
┌─────────────────┐
│ Version < 2017.1 ? │──OUI──> negative
└────────┬─────────┘
│ NON
▼
┌─────────────────┐
│ Version corrigée ? │──OUI──> negative
└────────┬─────────┘
│ NON
▼
positive
Détecte la présence des caractéristiques suivantes dans l'APK :
lib/*/libunity.so - bibliothèque d'exécution Unityassets/bin/Data/* - fichiers de ressources UnityExtrait le numéro de version Unity à partir des emplacements suivants :
Formats de numéro de version pris en charge :
2019.4.40f1, 2022.3.15f16000.0.23f1, 6000.2.6f22019.4.40, 6000.0.23Basée sur les règles de l'avis de sécurité officiel d'Unity :
Analyse automatique avant la publication d'une application, refus des applications affectées
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}
Analyse par lots de la bibliothèque d'applications existante, identification des applications nécessitant une mise à jour
python unity_vulnerability_checker.py --batch /data/published_apps > scan_report.txt
Analyse planifiée quotidienne des applications nouvellement téléchargées, notification automatique aux développeurs
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:
# Envoyer une notification avec les informations détaillées
for name, result in vulnerable:
send_notification(name, result.version, result.message)
schedule.every().day.at("02:00").do(daily_scan)
Génération de rapports de sécurité de la plateforme, statistiques sur la répartition des vulnérabilités
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),
# Liste détaillée
"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)
Intégration dans le processus d'intégration continue pour une vérification de sécurité automatisée
#!/bin/bash
# Utilisation dans le pipeline CI
python unity_vulnerability_checker.py build/output.apk
result=$(python unity_vulnerability_checker.py build/output.apk | grep "Résultat de détection")
if echo "$result" | grep -q "positive"; then
echo "Security check failed: CVE-2025-59489 detected"
exit 1
fi
echo "Security check passed"
Cas pouvant être faussement considérés comme sécurisés :
Cas pouvant être faussement considérés comme affectés :
inconclusive, une vérification manuelle est recommandéeRaisons possibles :
Recommandation : effectuer une vérification manuelle pour ces applications
Unity n'a pas fourni de correctifs de sécurité pour les versions 2017.1-2018.4. Ces versions présentent effectivement la vulnérabilité, mais comme :
Par conséquent, "inconclusive" est retourné au lieu de "positive". Recommandations :
Basée sur les règles de l'avis officiel d'Unity, la précision pour les APK construits de manière standard est > 95 %. Les APK obfusqués ou protégés peuvent nécessiter un traitement supplémentaire.
La détection d'un seul APK est généralement terminée en 0,5 à 2 secondes, avec prise en charge du traitement par lots parallèle pour améliorer l'efficacité. Les indicateurs de performance détaillés sont présentés dans la section « Indicateurs de performance » de ce document.
La version actuelle se concentre sur les APK Android. La détection des fichiers .ipa iOS nécessite une adaptation supplémentaire.
Modifier le dictionnaire PATCHED_VERSIONS dans unity_vulnerability_checker.py, et surveiller les avis officiels d'Unity pour obtenir les dernières informations.
Agir immédiatement
Surveillance continue
Notification des utilisateurs
Mettre à niveau la version Unity
Solution temporaire (si la mise à niveau est impossible)
Vérifier la correction
positiveUn problème ?
test_demo.py pour vérifier que l'outil fonctionne correctementusage_examples.py pour trouver des scénarios similairesLe projet est configuré avec des outils complets de contrôle qualité du code :
# Installer les dépendances
pip install ruff pre-commit
# Installer les hooks pre-commit
pre-commit install
# Exécuter manuellement toutes les vérifications
pre-commit run --all-files
Les vérifications suivantes sont exécutées automatiquement avant chaque commit :
Ruff Linter - Analyse statique du code Python
Ruff Formatter - Formatage du code Python
Vérification des fichiers généraux
Vérification du format Markdown
ruff.toml - Configuration Ruff.pre-commit-config.yaml - Configuration des hooks Pre-commitTout le code doit passer la vérification ruff avant le commit. Si la vérification échoue, le commit est bloqué.
# Si pre-commit échoue, certains problèmes sont automatiquement corrigés
# Après correction, il faut refaire git add et committer
git add .
git commit -m "votre message"
# Vérifier uniquement les fichiers Python
ruff check *.py
# Corriger automatiquement les problèmes
ruff check --fix *.py
# Formater le code
ruff format *.py
major >= 2019 or major >= 6000)Cet outil est destiné uniquement à l'audit de sécurité et aux contrôles de conformité.
| Si le jeu a cette autorisation | L'attaquant peut |
|---|
| 📸 Caméra | Vous filmer en secret |
| 🎤 Microphone | Vous écouter |
| 📍 Localisation | Vous suivre à la trace |
| 📱 Contacts | Voler votre répertoire |
| 💾 Stockage | Lire/supprimer vos fichiers |
| 💰 Paiement | Effectuer des paiements frauduleux dans le jeu |
| 🔐 Compte | Voler le compte du jeu |
| Version Unity | Version de correction minimale | Statut |
|---|
| 6000.3 | 6000.3.0b4 | ✅ Correctif disponible |
| 6000.2 | 6000.2.6f2 | ✅ Correctif disponible |
| 6000.0 LTS | 6000.0.58f2 | ✅ Correctif disponible |
| 2022.3 | 2022.3.62f2 | ✅ Correctif disponible |
| 2021.3 | 2021.3.45f2 | ✅ Correctif disponible |
| 2020.x | 2020.1.18f1+ | ✅ Correctif disponible |
| 2019.x | 2019.1.15f1+ | ✅ Correctif disponible |
| 2017-2018 | N/A | ⚠️ Aucun correctif officiel, mise à niveau recommandée |