taptap/cve-2025-59489Scanner automatizzato che rileva la vulnerabilità di injection nel runtime Unity CVE-2025-59489 negli APK Android estraendo la versione di Unity e verificandola rispetto alle versioni corrette, con elaborazione batch e integrazione CI/CD.
Strumento di rilevamento automatizzato della vulnerabilità di iniezione nel runtime Unity, specifico per piattaforme di giochi Android.
In sintesi: un attaccante può ottenere il controllo completo del gioco/app Unity interessato, acquisendo tutti i permessi di quell'app.
Punto chiave: su Android, un'app dannosa può dirottare i permessi già ottenuti dall'app Unity
Punto chiave: su Windows, se il gioco ha registrato un custom URI handler, basta fare clic su un link appositamente creato per attivare la vulnerabilità
Buone notizie: l'attaccante non può superare i limiti dei permessi dell'app stessa
Cattive notizie: molti giochi richiedono numerosi permessi (fotocamera, microfono, archiviazione, posizione, ecc.), e l'attaccante può sfruttarli completamente
Come operatore di una piattaforma di giochi Android, le conseguenze peggiori:
[Fonte: annuncio di sicurezza ufficiale Unity, analisi tecnica GMO Flatt Security]
# Richiede solo la libreria standard di Python 3.7+, nessuna dipendenza aggiuntiva
python3 --version # Verifica la versione di Python
# Passaggio 1: esegui i test
python test_demo.py
# Passaggio 2: rileva un singolo APK
python unity_vulnerability_checker.py your_game.apk
# Passaggio 3: rilevamento batch
python unity_vulnerability_checker.py --batch /path/to/apks
# Passaggio 4: consulta gli esempi di utilizzo
python usage_examples.py
from unity_vulnerability_checker import check_unity_vulnerability
# Rileva un singolo file APK
result = check_unity_vulnerability("your_game.apk")
# Metodo 1: usa le proprietà di comodo
if result.is_vulnerable:
print(f"⚠️ L'app è vulnerabile! ({result.version})")
print(f"Suggerimento: {result.recommendation}")
elif result.is_safe:
print(f"✅ L'app è sicura")
print(f"Motivo: {result.message}")
else:
print(f"❓ Richiede revisione manuale")
print(f"Motivo: {result.message}")
# Metodo 2: usa il campo status
if result.status == "positive":
print(f"Vulnerabile: {result.version}")
from unity_vulnerability_checker import batch_check
# Scansione batch di una directory
results = batch_check("/path/to/apk/folder")
# Filtra le app vulnerabili
vulnerable_apps = [
(name, result)
for name, result in results.items()
if result.is_vulnerable
]
print(f"Trovate {len(vulnerable_apps)} app vulnerabili")
for name, result in vulnerable_apps:
print(f" - {name}: {result.version}")
from unity_vulnerability_checker import UnityVulnerabilityChecker
class MyPlatform:
"""Il tuo sistema di piattaforma di giochi"""
def __init__(self):
self.checker = UnityVulnerabilityChecker()
def check_new_upload(self, apk_path: str) -> bool:
"""Controlla un APK appena caricato, restituisce se può essere pubblicato"""
result = self.checker.check_apk(apk_path)
if result.is_vulnerable:
# Vulnerabile - rifiuta la pubblicazione
self.notify_developer(
f"La tua app è vulnerabile alla vulnerabilità Unity\n"
f"Versione: {result.version}\n"
f"Suggerimento: {result.recommendation}"
)
return False
elif result.is_safe:
# Sicura - approva la pubblicazione
return True
else:
# Non determinabile - revisione manuale
self.queue_manual_review(apk_path, result.message)
return False
def notify_developer(self, message: str):
"""Notifica lo sviluppatore (implementa la tua logica di notifica)"""
pass
def queue_manual_review(self, apk_path: str):
"""Aggiungi alla coda di revisione manuale (implementa la tua logica)"""
pass
Lo strumento restituisce tre tipi di risultati:
Esempio di output (formato compatto su una riga):
# App vulnerabile
⚠️ L'app è vulnerabile a CVE-2025-59489 (Unity 2019.2.6f1)
# App sicura (3 casi)
✅ L'app è sicura - non è un'app Unity
✅ L'app è sicura - già corretta con lo strumento Unity patcher
✅ L'app è sicura - versione corretta (2019.4.41f1)
# Non determinabile
❓ Non determinabile - app Unity ma impossibile estrarre la versione, potrebbe essere protetta o offuscata, si consiglia revisione manuale
⚠️ File troppo grande per l'elaborazione (1500.0MB, limite 1024MB) - modifica MAX_APK_SIZE_MB alla riga 15 del codice con un valore maggiore
.
├── unity_vulnerability_checker.py # Modulo principale
│ ├─ Classe UnityVulnerabilityChecker - motore principale di rilevamento vulnerabilità
│ ├─ check_unity_vulnerability() - funzione di rilevamento semplificata
│ ├─ batch_check() - funzionalità di rilevamento batch
│ └─ logica completa di parsing e valutazione delle versioni
│
├── usage_examples.py # Esempi di utilizzo
│ ├─ Esempi di utilizzo di base
│ ├─ Esempi di rilevamento batch
│ ├─ Esempi di integrazione piattaforma
│ ├─ Esempi di risposta automatizzata
│ └─ Esempi di integrazione API Flask
│
├── test_demo.py # Demo di test
│ ├─ Test di parsing dei numeri di versione
│ ├─ Test di estrazione della versione
│ ├─ Test di valutazione delle correzioni
│ ├─ Simulazione di scenari di scansione APK
│ └─ Test di benchmark delle prestazioni
│
├── test_version_detection.py # Test unitari (33 casi di test)
│
├── README.md # Documentazione completa (include guida rapida)
│
└── CLAUDE.md # Specifiche di sviluppo
# Rilevamento di un singolo file
python unity_vulnerability_checker.py game.apk
# Modalità log dettagliati
python unity_vulnerability_checker.py game.apk -v
# Rilevamento batch di una directory
python unity_vulnerability_checker.py --batch /path/to/apk/folder
# Rilevamento batch (modalità dettagliata)
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)
# Filtra le app vulnerabili
vulnerable = {name: result for name, result in results.items()
if result.is_vulnerable}
print(f"Trovate {len(vulnerable)} app vulnerabili")
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" # Rifiuta la pubblicazione
elif result.is_safe:
return "APPROVE" # Approva
else:
return "MANUAL_REVIEW" # Revisione manuale
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)
# Usa il metodo to_dict() per convertire direttamente in JSON
response = result.to_dict()
response["filename"] = file.filename
response["vulnerable"] = result.is_vulnerable
return jsonify(response)
┌─────────────────┐
│ Leggi file APK │
└────────┬─────────┘
│
▼
┌─────────────────┐
│ È un'app Unity? │──NO──> negative
└────────┬─────────┘
│ SÌ
▼
┌─────────────────────┐
│ Rilevata patch patcher? │──SÌ──> negative
└────────┬─────────────┘
│ NO
▼
┌─────────────────┐
│ Estrai versione Unity │──Fallito──> inconclusive
└────────┬─────────┘
│ Successo
▼
┌─────────────────┐
│ Versione < 2017.1 ? │──SÌ──> negative
└────────┬─────────┘
│ NO
▼
┌─────────────────┐
│ Versione corretta? │──SÌ──> negative
└────────┬─────────┘
│ NO
▼
positive
Rileva la presenza delle seguenti caratteristiche nell'APK:
lib/*/libunity.so - libreria runtime Unityassets/bin/Data/* - file di risorse UnityEstrae il numero di versione Unity dalle seguenti posizioni:
Formati di versione supportati:
2019.4.40f1, 2022.3.15f16000.0.23f1, 6000.2.6f22019.4.40, 6000.0.23Basata sulle regole dell'annuncio di sicurezza ufficiale Unity:
Scansione automatica prima della pubblicazione dell'app, rifiuto delle app vulnerabili
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"Rilevata vulnerabilità CVE-2025-59489 ({result.version})",
"recommendation": result.recommendation
}
return {"approved": True, "message": result.message}
Scansione batch della libreria di app esistente, identificazione delle app che richiedono aggiornamento
python unity_vulnerability_checker.py --batch /data/published_apps > scan_report.txt
Scansione programmata giornaliera delle nuove app caricate, notifica automatica agli sviluppatori
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:
# Invia notifica con informazioni dettagliate
for name, result in vulnerable:
send_notification(name, result.version, result.message)
schedule.every().day.at("02:00").do(daily_scan)
Generazione di report di sicurezza della piattaforma, statistiche sulla distribuzione delle vulnerabilità
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),
# Elenco dettagliato
"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)
Integrazione nel flusso di integrazione continua, controllo di sicurezza automatizzato
#!/bin/bash
# Utilizzo nella pipeline CI
python unity_vulnerability_checker.py build/output.apk
result=$(python unity_vulnerability_checker.py build/output.apk | grep "Risultato rilevamento")
if echo "$result" | grep -q "positive"; then
echo "Controllo di sicurezza non superato: rilevata CVE-2025-59489"
exit 1
fi
echo "Controllo di sicurezza superato"
Possibili casi di valutazione errata come sicuri:
Possibili casi di valutazione errata come vulnerabili:
inconclusive, si consiglia una revisione manualePossibili motivi:
Suggerimento: eseguire una revisione manuale per queste app
Unity non ha fornito patch di sicurezza per le versioni 2017.1-2018.4. Queste versioni presentano effettivamente la vulnerabilità, ma poiché:
Viene restituito "inconclusive" invece di "positive", con i seguenti suggerimenti:
Basandosi sulle regole dell'annuncio ufficiale Unity, l'accuratezza per gli APK costruiti in modo standard è > 95%. Gli APK offuscati o protetti potrebbero richiedere un'elaborazione aggiuntiva.
Il rilevamento di un singolo APK viene solitamente completato in 0,5-2 secondi, con supporto per l'elaborazione batch parallela per migliorare l'efficienza. Per gli indicatori di prestazione dettagliati, consultare la sezione "Indicatori di prestazione" di questo documento.
La versione attuale si concentra sugli APK Android. Il rilevamento dei file .ipa iOS richiede un adattamento aggiuntivo.
Modificare il dizionario PATCHED_VERSIONS in unity_vulnerability_checker.py, monitorando gli annunci ufficiali Unity per le informazioni più recenti.
Azione immediata
Monitoraggio continuo
Notifica agli utenti
Aggiornare la versione Unity
Soluzione temporanea (quando non è possibile aggiornare)
Verifica della correzione
positiveHai riscontrato un problema?
test_demo.py per verificare che lo strumento funzioni correttamenteusage_examples.py per scenari similiIl progetto è configurato con strumenti completi di controllo qualità del codice:
# Installa le dipendenze
pip install ruff pre-commit
# Installa gli hook pre-commit
pre-commit install
# Esegui manualmente tutti i controlli
pre-commit run --all-files
Prima di ogni commit vengono eseguiti automaticamente i seguenti controlli:
Ruff Linter - analisi statica del codice Python
Ruff Formatter - formattazione del codice Python
Controlli generali sui file
Controllo del formato Markdown
ruff.toml - configurazione Ruff.pre-commit-config.yaml - configurazione degli hook Pre-commitTutto il codice deve superare il controllo ruff prima del commit. Se il controllo fallisce, il commit viene bloccato.
# Se pre-commit fallisce, alcuni problemi vengono corretti automaticamente
# Dopo la correzione, è necessario eseguire nuovamente git add e il commit
git add .
git commit -m "il tuo messaggio"
# Controlla solo i file Python
ruff check *.py
# Correzione automatica dei problemi
ruff check --fix *.py
# Formatta il codice
ruff format *.py
major >= 2019 or major >= 6000)Questo strumento è destinato esclusivamente ad audit di sicurezza e controlli di conformità.
| Se il gioco ha questo permesso | L'attaccante può |
|---|
| 📸 Fotocamera | Fotografarti di nascosto |
| 🎤 Microfono | Origliarti |
| 📍 Posizione | Tracciarti |
| 📱 Contatti | Rubare la tua rubrica |
| 💾 Archiviazione | Leggere/eliminare i tuoi file |
| 💰 Pagamenti | Effettuare pagamenti in-app fraudolenti |
| 🔐 Account | Rubare l'account di gioco |
| Versione Unity | Versione minima corretta | Stato |
|---|
| 6000.3 | 6000.3.0b4 | ✅ Patch disponibile |
| 6000.2 | 6000.2.6f2 | ✅ Patch disponibile |
| 6000.0 LTS | 6000.0.58f2 | ✅ Patch disponibile |
| 2022.3 | 2022.3.62f2 | ✅ Patch disponibile |
| 2021.3 | 2021.3.45f2 | ✅ Patch disponibile |
| 2020.x | 2020.1.18f1+ | ✅ Patch disponibile |
| 2019.x | 2019.1.15f1+ | ✅ Patch disponibile |
| 2017-2018 | N/A | ⚠️ Nessuna patch ufficiale, si consiglia di aggiornare la versione |