CVE-Forschung und PoC-Labor – Android-Sicherheitsanalyse

👨‍🏫 Betreuerinformationen

👤 Studenteninformationen

📚 Kursinformationen

🚀 Projektzusammenfassung und Umfang

Dieses Projekt wurde als Abschlussarbeit für den Kurs Penetrationstest (BGT006) des Studiengangs Informationstechnologie der İstinye Universität entwickelt. Im Rahmen des Projekts wurden drei aktuelle Schwachstellen (CVE-2024-0044, CVE-2024-43093, CVE-2024-23706), die das Android-Ökosystem betreffen, eingehend untersucht, eine isolierte Laborumgebung aufgebaut und mit einer Cyber-Detektiv-Methodik analysiert.

🎯 Gelöstes Problem und Projektziel

Herkömmliche Android-Sicherheitsanalysen bestehen oft nur aus theoretischer Dokumentation oder statischen Bildern. Dieses Projekt löst die grundlegenden Probleme, indem es den Angriffs- und Verteidigungszyklus mit lauffähigem Code kombiniert:

• Live-Analyse von Schwachstellen: Erfasst die Fußabdrücke kritischer Privilegieneskalationslücken (LPE) wie CVE-2024-0044 live in der Android-Logebene (logcat).
• Red Team & Blue Team Korrelation: Bietet einen vollständigen Angriffs-Verteidigungs-PoC (Proof of Concept), indem das Red-Team-Exploit-Tool (exploit_sim.py) und der Blue-Team-Log-Überwachungsdetektor (detector.py) Ende-zu-Ende verbunden werden.
• Produktisierte Sicherheitsergebnisse: Wandelt erkannte Alarme in Echtzeit in JSON/CSV-Berichte gemäß SIEM-Standards um und speist sie in ein zentrales Dashboard.

⚡ PoC mit einem Befehl (Angriffs-Erkennungs-Simulation)

Für Benutzer, die das Projekt klonen, wurden PoC-Starter mit einem Befehl (run_poc.bat / run_poc.sh) hinzugefügt, damit sie es innerhalb von Sekunden ausführen und die Ausgabe sehen können. Diese Skripte simulieren die Exploit-Schritte des Red Teams und veranlassen den Blue-Team-Detektor, Alarme zu erzeugen und in die Datei reports/detection_results.json zu schreiben. Detaillierte Ausführungsschritte finden Sie im Abschnitt Installation und Ausführung.

📊 Übersichtstabelle der analysierten Schwachstellen

🔌 Integration des Zwischenmoduls (NetVanguard)

Der im Rahmen des Projekts entwickelte Endpunkt-Log-Analyse-Agent src/detector.py wurde in das zentrale Anomalieüberwachungs- und Alarm-Dashboard NetVanguard integriert, das als Zwischenprojekt realisiert wurde. Kritische Schwachstellensignaturen, die auf dem Emulator auftreten, werden über das Netzwerk an die NetVanguard-Backend-Engine übertragen, um eine zentrale Überwachungsarchitektur (SIEM) zu simulieren.

🕵️ Architektur des Log-Analyse-Agenten (src/detector.py)

Der Schwachstellenerkennungsagent (src/detector.py) ist eine leichte Endpunkt-Log-Überwachungs-Engine, die entwickelt wurde, um Exploit-Aktivitäten auf Android-Geräten zu erkennen.

Grundlegende Funktionen und Betriebsmodi:

1. Flexibler Log-Eingang (3 Modi):
   • Live-ADB-Logcat-Stream: Stellt eine direkte Verbindung zum Emulator über den Befehl adb connect her und überwacht die Gerätelogs live.
   • Pipeline/Stdin-Modus: Kann über die Architektur adb logcat | python src/detector.py mit anderen CLI-Tools verbunden werden.
   • Dateiverfolgung (Tail -f): Überwacht dynamisch zeilenweise zuvor aufgezeichnete Logdateien (.log).
   • Fallback (manuelle Eingabe): Falls auf dem System weder ADB noch eine Logdatei installiert ist, filtert es manuell eingegebene Logzeilen zu Testzwecken (Live-Simulationsmodul).
2. Regelbasierte Signaturerkennung:
   • Wird aus der Variablen DETECTION_KEYWORDS in der .env-Datei gespeist.
   • Wenn kritische Exploit-Signaturen wie Android Runtime-Abstürze (SIGSEGV), Paketinstallationsfehler (SIGABRT) und abgestürzte Sicherheits-Apps (Process has died) erkannt werden, erzeugt es sofort [TEHLIKE - ALARM] im Terminal und in den Logs.

🛠️ Verwendete Technologien

📂 Projektverzeichnisstruktur

Android-rce-analizi/
├── .github/
│   └── workflows/
│       └── detector_test.yml  # GitHub Actions (CI/CD) Automatische Testkonfiguration
├── .gitattributes             # GitHub-Sprachstatistiken und Dateiattributkonfiguration
├── README.md                  # Hauptdokument des Projekts
├── ROADMAP.md                 # Projektfahrplan (Phase 0-5)
├── start_dashboard.bat        # Web-Dashboard-Starter für Windows
├── start_dashboard.sh         # Web-Dashboard-Starter für macOS/Linux
├── run_poc.bat                # PoC-Simulator mit einem Klick für Windows
├── run_poc.sh                 # PoC-Simulator mit einem Klick für macOS/Linux
├── .gitignore                 # Von Git ausgeschlossene Dateien
├── .env.example               # Umgebungsvariablenvorlage
├── Dockerfile                 # Docker-Konfiguration
├── docker-compose.yml         # Multi-Container-Konfiguration
├── LICENSE                    # Lizenzdatei
├── mitigation/                # Schwachstellenminderungs- und Patches
│   ├── cve_2024_0044_patch.diff
│   ├── cve_2024_23706_mitigation.md
│   └── cve_2024_43093_mitigation.md
├── src/                       # Quellcode
│   ├── detector.py            # Endpunkt-Log-Analyse-Agent (Echtzeit-Erkennungsmotor)
│   ├── exploit_sim.py         # Red Team Schwachstellen-Exploit-Simulator
│   └── test_detector.py       # Automatisierte Unit-Tests für den Agenten
├── reports/                   # Simulierte Scan- und Erkennungsberichte
│   ├── nessus_scan.csv        # Simulierte Nessus-Schwachstellenscanner-Ausgabe
│   └── detection_results.json # Vom Erkennungsmotor in Echtzeit aufgezeichnete Logausgaben
├── web/                       # Web-Dashboard-Oberfläche
│   ├── index.html             # Haupt-Dashboard-HTML-Datei
│   ├── css/style.css          # Oberflächenstile
│   └── js/main.js             # Oberflächendynamik und Terminal-Simulator
├── docs/                      # Dokumentation
│   ├── assets/                # Bilder und Mediendateien (inkl. Demo-GIF)
│   ├── modules/               # Moduldokumente
│   ├── references/            # Referenzquellen
│   └── research/              # Tiefgehende Forschungsdokumente
│       ├── 01_zafiyet_analizi.md
│       ├── 02_teknik_mekanizma.md
│       ├── 03_saldirgan_perspektifi.md
│       ├── cve_2024_23706.md
│       ├── cve_2024_43093.md
│       ├── detector_test_output.md  # Testberichtausgabe
│       └── final_rapor.md           # Abschlussbericht für die Kursabgabe
└── honeypot/                  # Honeypot-Umgebungsdateien (Emulator-Einrichtungsleitfaden)

🔬 Analyse- und Simulationsmethodik

Im Rahmen des Projekts wurde die Schwachstellenanalyse und Verteidigungssimulation in einem 4-stufigen Cybersicherheitszyklus behandelt:

graph TD
    A["1. Zafiyet Analizi & Statik İnceleme"] --> B["2. İzole Lab Ortamı Kurulumu"]
    B --> C["3. İstismar Simülasyonu & Dinamik Loglama"]
    C --> D["4. Korelasyon & Görsel Dashboard"]

1. Statische und theoretische Analyse: Durch die Untersuchung der AOSP-Quellcodes (Android Open Source Project) wurden logische Fehler in UID-Zuordnungen, SQLite-Datenbankzugriffsbeschränkungen und Paketinstallationsmechanismen identifiziert.
2. Isolierte Laborumgebung: Der Android-Emulator (API 33-34) und die Honeypot-Konfiguration wurden mit Docker-Containern in ein isoliertes Penetrationstestnetzwerk eingebunden.
3. Dynamisches Logging und Erkennung: Die bei Auslösung der Schwachstellen auftretenden Absturz- und Bypass-Spuren (z. B. SIGSEGV) wurden vom Schwachstellenerkennungsagenten src/detector.py gefiltert und erfasst.
4. Dashboard-Visualisierung: Die gesammelten Daten wurden mit Risikomatrizen, Angriffskettendiagrammen und Live-Terminalsimulationen angereichert, die für Administratoren und Analysten verständlich sind, und in die web/-Oberfläche übertragen.

Installation und Ausführung

Voraussetzungen

• Python 3.8+
• Android SDK (API Level 33-34)
• Docker & Docker Compose
• ADB (Android Debug Bridge)

Schritt 1: Vorbereitung

# 1. Repoyu klonlayın ve dizine gidin
git clone https://github.com/bfurkanyildiz/Android-rce-analizi.git
cd Android-rce-analizi

# 2. Ortam değişkenlerini hazırlayın (.env olmadan varsayılan ayarlar kullanılır)
cp .env.example .env

Schritt 2: Ausführungsoptionen

🚀 Option A: PoC-Simulation mit einem Klick (schnellste Methode)

Ohne Installation oder Emulator-Konfiguration den Angriffs- und Erkennungsmechanismus Ende-zu-Ende testen:

• Windows (Doppelklick oder CMD):
  root@kitploit:~

  run_poc.bat
  

• macOS / Linux (Terminal):
  root@kitploit:~

  bash run_poc.sh
  

🕵️ Option B: Manueller Live-ADB-Modus

Bei laufendem Android-Emulator Echtzeit-Logcat erfassen:

# Ajanı başlatın (ADB üzerinden canlı logları dinlemeye başlar)
python src/detector.py

# Ayrı bir terminalden saldırı simülatörünü tetikleyin
python src/exploit_sim.py

🐳 Option C: Container-Modus mit Docker

Alle Abhängigkeiten in einem isolierten Docker-Container starten:

docker-compose up -d

Schritt 3: Automatische Tests ausführen

Um die Softwarequalität und CI/CD-Standards zu testen:

python -m unittest src/test_detector.py

🖥️ Web-Dashboard-Benutzeroberfläche

Jeder Benutzer, der das Projekt klont (git clone), kann die umfangreiche Weboberfläche mit Analyseberichten und Terminalsimulation problemlos lokal ausführen.

Dashboard-Vorschau (Demo)

Zur Anzeige der Oberfläche können Sie eine der folgenden Methoden verwenden:

1. Automatische Startskripte (empfohlen)

Führen Sie den für Ihr Betriebssystem passenden Befehl aus, um den lokalen HTTP-Server im Hintergrund zu starten und die Oberfläche automatisch in Ihrem Standardbrowser zu öffnen:

• Windows (PowerShell / CMD): Doppelklicken Sie auf die Datei start_dashboard.bat im Hauptverzeichnis des Projekts, oder führen Sie folgenden Befehl im Terminal aus:
  root@kitploit:~

  start_dashboard.bat
  

• macOS / Linux (Bash): Direkter Start über das Terminal (ohne Ausführungsberechtigung):
  root@kitploit:~

  bash start_dashboard.sh
  

  oder mit Ausführungsberechtigung:
  root@kitploit:~

  chmod +x start_dashboard.sh
  ./start_dashboard.sh
  

2. Offline-Ausführung (ohne Server)

Zur direkten Ausführung ohne lokalen Server:

1. Gehen Sie zum Verzeichnis web/.
2. Doppelklicken Sie auf die Datei index.html, um sie direkt im Browser zu öffnen.

3. Manueller Start mit Server

Wenn Sie den Python-Server manuell starten möchten:

python -m http.server 8080

Öffnen Sie anschließend im Browser http://localhost:8080/web/index.html.

🔄 CI/CD und automatische Sicherheits-/Qualitätsscans

Unser Projekt wird nach den Prinzipien der Softwareentwicklung (DevSecOps) gemäß Cybersicherheitsstandards verwaltet. Bei jedem Push oder Pull-Request in das Repository führt GitHub Actions den folgenden Workflow (Pipeline) aus:

1. Unterstützung mehrerer Betriebssysteme (Matrix-Build): Der Code des Agenten wird sowohl auf ubuntu-latest als auch auf windows-latest getestet, um die plattformübergreifende Kompatibilität zu überprüfen.
2. Statische Code-Analyse (Linter): Mit dem Tool flake8 werden die Python-Schreibstandards (PEP 8) überprüft.
3. Statische Sicherheitsanalyse (Bandit-Scan): Mit dem Tool bandit werden kritische Schwachstellenmuster im Code automatisch gescannt (alle False-Positives wurden gemäß Cybersicherheitsstandards mit # nosec markiert).
4. Pipeline-Integrationstest: Die Pipeline exploit_sim.py | detector.py wird ausgeführt, um den End-to-End-Exploit-Erkennungszyklus zu simulieren.
5. Berichtsausgabe (Artefakte): Die nach erfolgreichem PoC erzeugte detection_results.json wird automatisch als Zip-Datei in die Actions-Ausgabe hochgeladen.

PoC-Terminalausgabe-Vorschau:

⚠️ Rechtlicher Hinweis

Dieses Projekt dient ausschließlich akademischen und Bildungszwecken. Alle Tests werden in einer kontrollierten Laborumgebung auf isolierten virtuellen Maschinen durchgeführt. Jeglicher Angriffsversuch auf echte Geräte oder Systeme Dritter ist rechtswidrig und liegt außerhalb des Anwendungsbereichs dieses Projekts.

📄 Lizenz

Dieses Projekt ist unter der GNU General Public License v3.0 lizenziert.