MobSF

Lernziel

Nach dieser Seite kannst du MobSF über Docker starten, eine APK-Datei hochladen und die Analyseergebnisse auswerten. Du verstehst, welche Befunde MobSF automatisch findet (hardkodierte Schlüssel, unsichere Berechtigungen, exported Components) und wo du manuell nacharbeiten musst.

Was ist MobSF?

MobSF (Mobile Security Framework) ist ein Open-Source-Framework für automatisierte Sicherheitsanalysen von Android- und iOS-Apps. Es kombiniert statische Analyse (Code, Manifest, Ressourcen ohne App-Ausführung) und optionale dynamische Analyse (App läuft im Emulator) in einem web-basierten Dashboard.

MobSF erkennt automatisch bekannte Schwachstellenmuster: hardkodierte API-Keys und Passwörter, unsichere Cryptographic-API-Verwendung, zu weit gefasste Berechtigungen, exportierte Activities ohne Zugriffskontrolle und viele weitere. Als Ausgangspunkt für Phase 1 spart es erheblich Zeit — du weißt nach wenigen Minuten, wo es interessant wird.

Installation

Docker (empfohlen)

Die einfachste Installationsmethode ist Docker — kein Python-Setup, keine Abhängigkeitskonflikte:

# MobSF-Image herunterladen und starten (Port 8000)
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest

Nach dem Start ist MobSF unter http://localhost:8000 erreichbar. Die Web-Oberfläche benötigt keinen Login. Den API-Key für die REST-API findest du auf der Startseite.

Lokale Installation (ohne Docker)

# Python 3.10–3.12 erforderlich
git clone https://github.com/MobSF/Mobile-Security-Framework-MobSF.git
cd Mobile-Security-Framework-MobSF

# Setup-Script installiert Abhängigkeiten und initialisiert die Datenbank
./setup.sh

# Server starten
./run.sh 0.0.0.0:8000

Installation prüfen

# Docker-Container läuft?
docker ps | grep mobsf
# Ausgabe: ... opensecurity/mobile-security-framework-mobsf:latest ...

# Web-UI erreichbar?
curl -s http://localhost:8000 | grep -o "MobSF"
# Ausgabe: MobSF

BLE-Beispiel: LED-Strip APK analysieren

Die LED-Strip-App enthält mehrere Schwachstellen, die MobSF automatisch aufdeckt. So läuft eine typische Analyse ab.

Schritt 1: APK hochladen

1. Browser öffnen: http://localhost:8000
2. APK-Datei per Drag & Drop auf das Upload-Feld ziehen (oder "Upload & Analyze" klicken)
3. MobSF startet die Analyse automatisch — dauert 30–120 Sekunden je nach APK-Größe

Alternativ per cURL (API-Key steht auf der MobSF-Startseite unter "API Key"):

curl -F "file=@ledstrip.apk" http://localhost:8000/api/v1/upload \
  -H "X-Mobsf-Api-Key: DEIN_API_KEY"

Schritt 2: Analysebefunde auswerten

Nach Abschluss der Analyse zeigt das Dashboard folgende Sektionen:

Hardkodierte Schlüssel und Secrets:

MobSF sucht nach Regex-Mustern für API-Keys, kryptographische Schlüssel, Passwörter und Tokens direkt im dekompilierten Code. Für die LED-Strip-App findet es:

HIGH  Hardcoded Encryption Key detected
      File: wl/smartled/EncryptUtil.java
      Match: byte[] key = {89, 76, 90, 75, 53, 41, 33, 41, ...}

Dieselben XOR-Schlüsselbytes, die du auch in JADX findest. MobSF sagt dir wo der Schlüssel steht, JADX zeigt dir, wie er verwendet wird und warum das iterative XOR zu einem einzigen effektiven Byte kollabiert.

Unsichere Berechtigungen:

MEDIUM  ACCESS_FINE_LOCATION declared but not justified
HIGH    BLUETOOTH_ADMIN without user consent flow

Android benötigt ACCESS_FINE_LOCATION für BLE-Scans bis Android 11. Viele Apps deklarieren es, ohne den Nutzer zu erklären, warum.

Exported Components:

HIGH  Activity exported without permission: wl.smartled.ControlActivity
      Intent filter: action=android.intent.action.VIEW

Eine exportierte Activity ohne android:permission-Attribut kann von anderen Apps ohne Berechtigung gestartet werden — unbeabsichtigte Angriffsfläche.

Features im Überblick

Fortgeschrittene Anwendungen

REST-API für CI/CD-Integration

MobSF hat eine vollständige REST-API, mit der du Scans automatisiert aus CI/CD-Pipelines starten kannst:

# API-Key von der MobSF-Startseite oder aus ~/.MobSF/secret
API_KEY="DEIN_API_KEY"

# 1. APK hochladen
HASH=$(curl -s -F "file=@app.apk" http://localhost:8000/api/v1/upload \
  -H "X-Mobsf-Api-Key: $API_KEY" | python3 -c \
  'import sys,json; print(json.load(sys.stdin)["hash"])')

# 2. Analyse starten
curl -s -X POST http://localhost:8000/api/v1/scan \
  -H "X-Mobsf-Api-Key: $API_KEY" \
  -d "scan_type=apk&file_name=app.apk&hash=$HASH"

# 3. Ergebnisse als JSON abrufen
curl -s -X POST http://localhost:8000/api/v1/report_json \
  -H "X-Mobsf-Api-Key: $API_KEY" \
  -d "hash=$HASH" > results.json

Das JSON-Ergebnis enthält alle Befunde maschinenlesbar — ideal für automatisierte Bewertungen mehrerer APKs.

Mehrere APKs in Batch scannen

Wenn du mehrere Apps einer Geräteserie analysieren willst (z. B. verschiedene Firmware-Versionen derselben App):

import requests
from pathlib import Path

BASE_URL = "http://localhost:8000/api/v1"
AUTH_HEADER = {"X-Mobsf-Api-Key": "DEIN_API_KEY"}  # Von der MobSF-Startseite

def scan_apk(apk_path: str) -> dict:
    """APK hochladen, analysieren und Ergebnisse zurückgeben."""
    with open(apk_path, "rb") as f:
        upload_resp = requests.post(
            f"{BASE_URL}/upload",
            files={"file": (Path(apk_path).name, f, "application/octet-stream")},
            headers=AUTH_HEADER,
        )
    file_hash = upload_resp.json()["hash"]

    requests.post(
        f"{BASE_URL}/scan",
        data={"scan_type": "apk", "file_name": Path(apk_path).name, "hash": file_hash},
        headers=AUTH_HEADER,
    )

    report = requests.get(
        f"{BASE_URL}/report_json?hash={file_hash}",
        headers=AUTH_HEADER,
    )
    return report.json()

# Alle APKs im aktuellen Verzeichnis scannen
for apk_file in Path(".").glob("*.apk"):
    print(f"Scanne: {apk_file.name}")
    result = scan_apk(str(apk_file))
    high_count = len([f for f in result.get("findings", []) if f.get("severity") == "high"])
    print(f"  HIGH-Befunde: {high_count}")

Dynamische Analyse mit Emulator

MobSF unterstützt auch dynamische Analyse — die App läuft in einem Android-Emulator und MobSF überwacht alle System-Calls, Netzwerkzugriffe und Datei-Operationen in Echtzeit.

Voraussetzung: Android-x86-Emulator (Genymotion oder Android Studio AVD) läuft auf Port 5554.

# Emulator starten und mit ADB verbinden
adb connect 127.0.0.1:5555

# In MobSF: Dynamic Analyzer → Start Dynamic Analysis
# App wird automatisch installiert und gestartet

Häufige Probleme

Zusammenfassung

• MobSF über Docker starten: docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
• APK hochladen → Dashboard zeigt HIGH/MEDIUM/INFO-Befunde nach Schweregrad sortiert
• Typische Befunde bei BLE-IoT-Apps: hardkodierte Krypto-Schlüssel, zu breite Berechtigungen, exportierte Components ohne Permission
• REST-API ermöglicht automatisierte Batch-Scans und CI/CD-Integration
• Dynamische Analyse funktioniert für App-Verhalten, nicht für BLE-Kommunikation (kein BLE im Emulator)
• MobSF ist Einstiegspunkt, kein Ersatz für manuelle JADX-Analyse