maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/mobile-pentesting/android-app-pentesting/avd-androi

Browse Source
This commit is contained in:
Translator 2025-09-08 01:48:24 +00:00
parent 107a468026
commit fbccfae8b8
5 changed files with 578 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

479
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -1,10 +1,10 @@
# Pentesting von Android-Anwendungen
# Android-Anwendungen Pentesting
{{#include ../../banners/hacktricks-training.md}}
## Grundlagen zu Android-Anwendungen
Es wird dringend empfohlen, zuerst diese Seite zu lesen, um die **wichtigsten Teile im Zusammenhang mit Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** zu kennen:
Es wird dringend empfohlen, diese Seite zuerst zu lesen, um die **wichtigsten Teile in Bezug auf Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** kennenzulernen:
{{#ref}}
@ -13,24 +13,24 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
Dies ist das Haupttool, das du benötigst, um ein Android-Gerät (emuliert oder physisch) zu verbinden.\
**ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Network** von einem Computer aus. Dieses Utility 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.
Dies ist das Hauptwerkzeug, das Sie benötigen, um eine Verbindung zu einem Android-Gerät (emuliert oder physisch) herzustellen.\
**ADB** ermöglicht es, Geräte entweder über **USB** oder **Netzwerk** von einem Computer aus zu steuern. 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, unter anderen Funktionen.
Sieh dir die folgende Liste der [**ADB Commands**](adb-commands.md) an, um zu lernen, wie man adb verwendet.
Sieh dir die folgende Liste der [**ADB Commands**](adb-commands.md) an, um zu lernen, wie man adb benutzt.
## Smali
Manchmal ist es interessant, den Anwendungscode zu **modifizieren**, um auf **versteckte Informationen** zuzugreifen (z. B. stark obfuskierte Passwörter oder flags). Dann kann es sinnvoll sein, die APK zu dekompilieren, den Code zu ändern und die APK wieder 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). Das kann sehr nützlich sein als **Alternative für mehrere Tests während der dynamischen Analyse**, die weiter unten vorgestellt werden. Behalte diese Möglichkeit also immer im Hinterkopf.
Manchmal ist es interessant, den **Anwendungscode zu modifizieren**, um auf **versteckte Informationen** zuzugreifen (z. B. stark obfuskierte Passwörter oder Flags). In solchen Fällen kann es hilfreich sein, die APK zu dekompilieren, den Code zu ändern und sie wieder 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 noch vorgestellt werden. Behalte daher **immer diese Möglichkeit** im Hinterkopf.
## Other interesting tricks
## Weitere interessante Tricks
- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md)
- [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md)
- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
- APK aus Gerät extrahieren:
- **APKs herunterladen**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
- APK vom Gerät extrahieren:
```bash
adb shell pm list packages
com.android.insecurebankv2
@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
## Statische Analyse
Zuerst solltest du beim Analysieren einer APK **den Java-Code ansehen** mit einem decompiler.\
Bitte, [**lies hier, um Informationen über verschiedene verfügbare decompiler zu finden**](apk-decompilers.md).
Zuerst sollte man zur Analyse einer APK **den Java-Code ansehen** und dazu einen Decompiler verwenden.\
Bitte, [**lies hier, um Informationen zu verschiedenen verfügbaren Decompilern zu finden**](apk-decompilers.md).
### Suche nach interessanten Informationen
Schon ein Blick in die **strings** der APK kann Hinweise auf **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** und andere interessante Dinge liefern... suche auch nach code execution **backdoors** oder authentication backdoors (hardcodierte Admin-Credentials in der App).
Schon ein Blick auf die **strings** der APK kann Hinweise auf **Passwörter**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api**-Schlüssel, **Verschlüsselung**, **bluetooth uuids**, **Tokens** und alles andere Interessante liefern... suche auch nach Codeausführungs-**Backdoors** oder Authentifizierungs-Backdoors (hardcodierte Admin-Credentials in der App).
**Firebase**
Achte besonders auf **Firebase URLs** und prüfe, ob es falsch konfiguriert ist. [Mehr Informationen darüber, was Firebase ist und wie man es ausnutzt, hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
Achte besonders auf **Firebase-URLs** und überprüfe, ob diese falsch konfiguriert sind. [Mehr Informationen darüber, was Firebase ist und wie man es ausnutzen kann, hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Grundlegendes Verständnis der Anwendung - Manifest.xml, strings.xml
Die **Untersuchung der Anwendungs-_Manifest.xml_ und der **_strings.xml_** Dateien kann potenzielle Sicherheitslücken offenbaren**. Diese Dateien sind mittels decompilers zugänglich oder indem man die APK-Endung 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-Erweiterung in .zip umbenennt und die Datei entpackt.
**Schwachstellen**, die aus der **Manifest.xml** hervorgehen können, umfassen:
Aus der **Manifest.xml** identifizierbare **Schwachstellen** umfassen:
- **Debuggable Applications**: Anwendungen, die als debuggable (`debuggable="true"`) in der _Manifest.xml_ gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben, die zu einer Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Anwendungen ausnutzt, siehe Tutorials 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 arbeiten, um unautorisierte Daten-Backups via 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 pins und HTTP-Traffic-Einstellungen angeben. Ein Beispiel ist das Erlauben von HTTP-Traffic für bestimmte Domains.
- **Exported Activities and Services**: Das Identifizieren exportierter Activities und Services im Manifest kann Komponenten aufzeigen, die missbraucht werden könnten. Eine weitere Analyse während dynamischer Tests kann offenbaren, wie diese Komponenten ausgenutzt werden können.
- **Content Providers and FileProviders**: Offen exponierte Content Providers könnten unautorisierten Zugriff oder die Manipulation von Daten erlauben. Die Konfiguration von FileProviders sollte ebenfalls genau geprüft werden.
- **Broadcast Receivers and URL Schemes**: Diese Komponenten könnten für Exploits genutzt werden, mit besonderem Augenmerk darauf, wie URL-Schemes für Input-Schwachstellen gehandhabt werden.
- **SDK Versions**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und heben hervor, warum es wichtig ist, keine veralteten, verwundbaren Android-Versionen zu unterstützen.
- **Debuggable Applications**: Anwendungen, die in der _Manifest.xml_ als debuggable (`debuggable="true"`) gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben können, die zur Ausnutzung führen. Für ein besseres Verständnis, wie debuggable Applications ausgenutzt werden können, siehe ein Tutorial zum Finden und Ausnutzen von debuggable Applications 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 Datenbackups über adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist.
- **Network Security**: Benutzerdefinierte Netzwerk-Sicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Certificate Pins und Einstellungen für HTTP-Traffic spezifizieren. Ein Beispiel wäre das Zulassen von HTTP-Traffic für bestimmte Domains.
- **Exported Activities und Services**: Das Identifizieren exportierter Activities und Services im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Weitere Analysen während dynamischer Tests können aufdecken, wie diese Komponenten ausgenutzt werden können.
- **Content Providers und FileProviders**: Exponierte Content Providers könnten unautorisierten Zugriff oder Modifikationen von Daten ermöglichen. Die Konfiguration von FileProviders sollte ebenfalls sorgfältig geprüft werden.
- **Broadcast Receivers und URL-Schemata**: Diese Komponenten könnten für Exploits genutzt werden, mit besonderem Augenmerk darauf, wie URL-Schemata für Eingaben gehandhabt werden.
- **SDK-Versionen**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und machen deutlich, dass es wichtig ist, keine veralteten, verwundbaren Android-Versionen zu unterstützen.
Aus der **strings.xml** Datei können sensible Informationen wie API keys, custom schemas und andere Entwicklerhinweise entdeckt werden, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht.
Aus der **strings.xml** können sensible Informationen wie API-Schlüssel, Custom Schemes und andere Entwicklerhinweise entdeckt werden, was die Notwendigkeit unterstreicht, diese Ressourcen sorgfältig zu prüfen.
### Tapjacking
Tapjacking ist ein Angriff, bei dem eine **malicious** **application** gestartet wird und sich **über eine victim application legt**. Sobald sie die victim app sichtbar überdeckt, ist ihre Benutzeroberfläche so gestaltet, dass der Benutzer zur Interaktion verleitet wird, während die Interaktion an die victim app weitergereicht wird.\
Effektiv wird der Benutzer **gebilndet und weiß nicht, dass er tatsächlich Aktionen in der victim app durchführt**.
Tapjacking ist ein Angriff, bei dem eine **malicious** **application** gestartet wird und **sich über einer Opfer-Anwendung positioniert**. Sobald sie die Opfer-App sichtbar überlagert, ist ihre Benutzeroberfläche so gestaltet, dass sie den Benutzer zur Interaktion verleitet, während sie die Interaktion an die Opfer-App weiterreicht.\
Im Effekt **blendet sie den Benutzer aus, sodass er nicht erkennt, dass er tatsächlich Aktionen in der Opfer-App durchführt**.
Mehr Informationen findest du in:
Mehr Informationen dazu findest du in:
{{#ref}}
@ -104,9 +104,9 @@ tapjacking.md
### Task Hijacking
Eine **activity** mit dem **`launchMode`** auf **`singleTask`** gesetzt und ohne definierte `taskAffinity` ist für Task Hijacking anfällig. Das bedeutet, dass eine **application** installiert werden kann, die, wenn sie vor der echten Anwendung gestartet wird, **die Task der echten Anwendung hijacken** könnte (sodass der Benutzer mit der **malicious application interagiert und denkt, er benutze die echte**).
Eine **activity** mit dem **`launchMode`** auf **`singleTask` ohne definiertes `taskAffinity`** ist anfällig für Task Hijacking. Das bedeutet, dass eine **application** installiert werden kann und wenn sie vor der echten Anwendung gestartet wird, die **Task der echten Anwendung hijacken** könnte (so dass der Benutzer mit der **malicious application interagiert und glaubt, die echte Anwendung zu benutzen**).
Mehr Info in:
Mehr Infos in:
{{#ref}}
@ -117,65 +117,65 @@ android-task-hijacking.md
**Internal Storage**
In Android sind Dateien, die im **internal** storage **gespeichert** werden, so **konzipiert**, dass sie **ausschließlich von der App zugänglich** sind, die sie erstellt hat. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem durchgesetzt und ist in der Regel ausreichend für die Sicherheitsanforderungen der meisten Anwendungen. Entwickler verwenden jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um Dateien zwischen verschiedenen Anwendungen zu **teilen**. Diese Modi **beschränken den Zugriff nicht** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
In Android sind Dateien, die im **internal** Storage **gespeichert** werden, **dafür 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 **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
1. **Statische Analyse:**
- **Überprüfe**, ob `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` verwendet werden. Diese Modi **können Dateien unbeabsichtigt oder unautorisiert zugänglich machen**.
- **Stelle sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **gründlich geprüft** wird. Diese Modi **können Dateien unbeabsichtigt oder unautorisiert zugänglich machen**.
2. **Dynamische Analyse:**
- **Verifiziere** die **Berechtigungen** von Dateien, die von der App erstellt wurden. Prüfe speziell, ob Dateien **weltweit lesbar oder beschreibbar** gesetzt sind. Das stellt ein erhebliches Sicherheitsrisiko dar, da **jede installierte Anwendung**, unabhängig von Herkunft oder Absicht, diese Dateien **lesen oder ändern** könnte.
- **Überprüfe** die **Berechtigungen** der von der App erstellten Dateien. Insbesondere **prüfe**, ob Dateien so gesetzt sind, dass sie weltweit lesbar oder schreibbar sind. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder auf dem Gerät installierten Anwendung**, unabhängig von Herkunft oder Absicht, erlauben würde, diese Dateien zu **lesen oder zu verändern**.
**External Storage**
Beim Umgang mit Dateien auf **external storage**, wie SD-Karten, sind bestimmte Vorsichtsmaßnahmen zu treffen:
Beim Umgang mit Dateien auf **external storage**, wie SD-Karten, sollten bestimmte Vorsichtsmaßnahmen getroffen werden:
1. **Zugänglichkeit**:
- Dateien auf external storage sind **global lesbar und beschreibbar**. Das bedeutet, jede Anwendung oder jeder Benutzer kann auf diese Dateien zugreifen.
2. **Sicherheitsbedenken**:
- Aufgrund der leichten Zugänglichkeit sollte man **keine sensiblen Informationen** auf external storage speichern.
- External storage kann entfernt oder von beliebigen Anwendungen ausgelesen werden, wodurch es weniger sicher ist.
3. **Umgang mit Daten von External Storage**:
- Führe immer **Input-Validierung** auf Daten durch, die von external storage geladen werden. Das ist wichtig, da die Daten aus einer untrusted Quelle stammen.
- Das Speichern von Executables oder class files auf external storage zum dynamischen Laden ist stark zu vermeiden.
- Wenn deine Anwendung ausführbare Dateien aus external storage laden muss, stelle sicher, dass diese Dateien **signiert und kryptografisch verifiziert** sind, bevor sie dynamisch geladen werden. Dieser Schritt ist entscheidend für die Integrität und Sicherheit deiner Anwendung.
- Aufgrund des einfachen Zugriffs wird **davon abgeraten, sensible Informationen** auf external storage zu speichern.
- External storage kann entfernt werden oder von jeder Anwendung eingesehen werden, was es weniger sicher macht.
3. **Umgang mit Daten aus external storage**:
- Führe immer **Eingabevalidierung** an Daten durch, die aus external storage abgerufen werden. Das ist entscheidend, da diese Daten aus einer nicht vertrauenswürdigen Quelle stammen.
- Das Speichern von ausführbaren Dateien oder class-Dateien auf external storage zur dynamischen Nachladung wird dringend abgeraten.
- Falls deine App ausführbare Dateien aus external storage laden muss, stelle sicher, dass diese Dateien **signiert und kryptografisch verifiziert** sind, bevor sie dynamisch geladen werden. Dieser Schritt ist wichtig, um die Sicherheitsintegrität deiner Anwendung zu wahren.
External storage kann unter /storage/emulated/0 , /sdcard , /mnt/sdcard zugegriffen werden.
External storage kann unter /storage/emulated/0 , /sdcard , /mnt/sdcard zugegriffen werden
> [!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. Das verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erlangen.
> Beginnend mit Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die den Zugriff einer App auf das Verzeichnis beschränkt, das speziell für diese App vorgesehen ist. Dies verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erlangen.
**Sensitive data stored in clear-text**
- **Shared preferences**: Android erlaubt jeder Anwendung, XML-Dateien unter dem Pfad `/data/data/<packagename>/shared_prefs/` abzulegen, und manchmal findet man dort sensitive Informationen im Klartext.
- **Databases**: Android erlaubt jeder Anwendung, sqlite-Datenbanken unter dem Pfad `/data/data/<packagename>/databases/` zu speichern, und manchmal findet man dort sensitive Informationen im Klartext.
- **Shared preferences**: Android erlaubt jeder App, 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 App, 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 beispielsweise 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.
### Broken Cryptography
### Fehlerhafte Kryptographie
**Poor Key Management Processes**
**Schlechte Key-Management-Prozesse**
Einige Entwickler speichern sensitive Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren key. Das sollte nicht gemacht werden, da ein reversing Angreifern erlauben könnte, die vertraulichen Informationen zu extrahieren.
Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hartkodierten/vorhersehbaren Key. Das sollte nicht gemacht werden, da Reverse-Engineering es Angreifern ermöglichen könnte, die vertraulichen Informationen zu extrahieren.
**Use of Insecure and/or Deprecated Algorithms**
**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 beispielsweise **hashes** verwendet werden, um Passwörter zu speichern, sollten brute-force-resistant **hashes** mit salt verwendet werden.
Entwickler sollten keine **veralteten Algorithmen** verwenden, um Autorisierungs**prüfungen** durchzuführen, Daten zu **speichern** oder zu **senden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** z. B. zum Speichern von Passwörtern verwendet werden, sollten hashes verwendet werden, die bruteforce-**resistent** sind und Salt enthalten.
### Other checks
### Weitere Prüfungen
- Es wird empfohlen, die **obfuscate the APK** zu verwenden, um die Arbeit des reverse engineer für Angreifer zu erschweren.
- Wenn die App sensibel ist (wie bank apps), sollte sie ihre **own checks to see if the mobile is rooted** durchführen und entsprechend handeln.
- Wenn die App sensibel ist (wie bank apps), sollte sie prüfen, ob ein **emulator** verwendet wird.
- Wenn die App sensibel ist (wie bank apps), sollte sie **check it's own integrity before executing** um zu prüfen, ob sie modifiziert wurde.
- Use [**APKiD**](https://github.com/rednaga/APKiD) um zu prüfen, welcher compiler/packer/obfuscator verwendet wurde, um die APK zu bauen
- Es wird empfohlen, das **APK zu obfuskieren**, um die Reverse-Engineering-Arbeit für Angreifer zu erschweren.
- Wenn die App sensibel ist (z. B. Bank-Apps), sollte sie **eigene Prüfungen durchführen, um zu erkennen, 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.
- Verwende [**APKiD**](https://github.com/rednaga/APKiD), um zu prüfen, welcher Compiler/Packager/Obfuscator zum Erstellen des APK verwendet wurde
### React Native Application
@ -199,15 +199,15 @@ 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.**
### Automated Static Code Analysis
### Automatisierte statische Code-Analyse
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.
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 die **Stellen** angeben, an denen die **Eingabe** vom Benutzer **kontrolliert** wird), **sinks** (die dem Tool **gefährliche** **Stellen** anzeigen, an denen bösartige Benutzereingaben Schaden anrichten könnten) und **rules**. Diese Regeln geben die **Kombination** von **sources-sinks** an, die auf eine Vulnerability hinweist.
With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**.
Mit diesem Wissen **wird mariana-trench den Code überprüfen und mögliche Vulnerabilities darin finden**.
### Secrets leaked
An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
Eine Anwendung kann Secrets (API-Keys, Passwörter, versteckte URLs, Subdomains...) enthalten, die Sie möglicherweise entdecken können. Du könntest ein Tool wie [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) verwenden
### Bypass Biometric Authentication
@ -216,14 +216,14 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains
bypass-biometric-authentication-android.md
{{#endref}}
### Other interesting functions
### Andere interessante Funktionen
- **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)
### **Other tricks**
### **Weitere Tricks**
{{#ref}}
@ -248,20 +248,20 @@ You can even **see the logs of your application** in the web and connect through
Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
### Local Dynamic Analysis
### Lokale dynamische Analyse
#### Using an emulator
#### Verwendung eines emulators
- [**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:
- [**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)**neueren x86** Versionen **unterstützen ARM-Bibliotheken** ohne einen langsamen arm-emulator zu benötigen).
- Lerne, wie man es auf dieser Seite einrichtet:
{{#ref}}
avd-android-virtual-device.md
{{#endref}}
- [**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).
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, du musst ein Konto erstellen. _Es wird empfohlen, die Version **WITH**_ _**VirtualBox** herunterzuladen, um potenzielle Fehler zu vermeiden._)
- [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt aber Frida oder Drozer nicht).
> [!TIP]
> When creating a new emulator on any platform remember that the bigger the screen is, the slower the emulator will run. So select small screens if possible.
@ -272,9 +272,9 @@ To **install google services** (like AppStore) in Genymotion you need to click o
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).
#### Use a physical device
#### Verwende ein physisches Gerät
You need to activate the **debugging** options and it will be cool if you can **root** it:
Du musst die **Debugging**-Optionen aktivieren und es ist vorteilhaft, wenn du es **rooten** kannst:
1. **Settings**.
2. (FromAndroid 8.0) Select **System**.
@ -285,11 +285,19 @@ You need to activate the **debugging** options and it will be cool if you can **
> 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 (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
### Unintended Data Leakage
**Logging**
Entwickler sollten vorsichtig sein, **debugging information** öffentlich preiszugeben, da dies zu sensiblen data leaks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungslogs zu überwachen und sensible Informationen zu identifizieren bzw. zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
Entwickler sollten vorsichtig sein, debug-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 Anwendungslogs zu überwachen, damit sensible Informationen identifiziert und geschützt werden können. **Pidcat** wird aufgrund seiner einfachen Nutzung und Lesbarkeit bevorzugt.
> [!WARNING]
> 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.\
@ -297,26 +305,26 @@ Entwickler sollten vorsichtig sein, **debugging information** öffentlich preisz
**Copy/Paste Buffer Caching**
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.
Androids **clipboard-basiertes** Framework ermöglicht Copy-Paste-Funktionen in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können und dadurch möglicherweise sensible Daten exponiert werden. Es ist wichtig, Copy/Paste-Funktionen für sensible Bereiche einer Anwendung, wie Kreditkartendaten, zu **deaktivieren**, um leaks zu verhindern.
**Crash Logs**
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.
Wenn eine Anwendung **abstürzt** und **Logs speichert**, können diese Logs Angreifern helfen, insbesondere wenn die Anwendung nicht reverse-engineered werden kann. Um dieses Risiko zu mindern, sollte man vermeiden, bei Abstürzen zu loggen, und falls Logs über das Netzwerk gesendet werden müssen, sicherstellen, dass sie über einen SSL-Kanal übertragen werden.
As pentester, **try to take a look to these logs**.
Als pentester, **versuche dir diese Logs anzusehen**.
**Analytics Data Sent To 3rd Parties**
**Analytics-Daten an Dritte gesendet**
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.
Anwendungen integrieren oft Dienste wie Google Adsense, die unbeabsichtigt sensible Daten leak durch fehlerhafte Implementierung durch Entwickler auslösen können. Um potenzielle Daten leaks zu identifizieren, ist es ratsam, den Traffic der Anwendung abzufangen und zu prüfen, ob sensible Informationen an Drittanbieter gesendet werden.
### SQLite DBs
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`
Die meisten Anwendungen verwenden **interne SQLite-Datenbanken**, um Informationen zu speichern. Während des Pentests solltest du einen **Blick** auf die erstellten **Datenbanken**, die Namen der **Tabellen** und **Spalten** und alle gespeicherten **Daten** werfen, da du sensible Informationen finden könntest (was eine Vulnerability wäre).\
Datenbanken sollten sich in `/data/data/the.package.name/databases` befinden, z. B. `/data/data/com.mwr.example.sieve/databases`
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**.
Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt ist**, du aber das **Passwort** in der Anwendung **finden** kannst, ist das immer noch eine **Vulnerability**.
Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema <table_name>`
Zähle die Tabellen mit `.tables` auf und liste die Spalten der Tabellen mit `.schema <table_name>` auf
### Drozer (Exploit Activities, Content Providers and Services)
@ -341,107 +349,108 @@ You can also start an exported activity from adb:
```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 [diesem](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) ist das offenbar nur auf alten Versionen (API versions < 21) gefährlich.
**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
> [!TIP]
> Beachte, dass ein authorisation bypass nicht immer eine vulnerability ist — es kommt darauf an, wie der bypass funktioniert und welche Informationen exponiert werden.
> Beachte, dass ein authorisation bypass nicht immer eine vulnerability ist; es hängt davon ab, wie der Bypass funktioniert und welche Informationen exponiert werden.
**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 ein Leck sensibler Informationen vor.
**Activities can also return results**. Wenn es dir gelingt, eine exportierte und ungeschützte Activity zu finden, die die Methode **`setResult`** aufruft und **vertrauliche 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 unerwartete Aktionen ausführen zu lassen**. Für mehr Infos über [**was Tapjacking ist, folge dem Link**](#tapjacking).
Wenn Tapjacking nicht verhindert wird, könntest du die exportierte Activity missbrauchen, um den **user unerwartete Aktionen ausführen zu lassen**. Für mehr Infos darüber, [**was Tapjacking ist, folge dem Link**](#tapjacking).
### 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 im Grunde verwendet, um **Daten zu teilen**. Wenn eine App Content providers bereitstellt, kannst du möglicherweise **sensible Daten aus ihnen extrahieren**. Es ist außerdem sinnvoll, mögliche **SQL injections** und **Path Traversals** zu testen, da diese verwundbar sein könnten.
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
Content providers werden grundsätzlich verwendet, um **Daten zu teilen**. Wenn eine App Content providers bereitstellt, könntest du in der Lage sein, **sensible Daten** aus ihnen zu extrahieren. Es ist auch interessant, 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)
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
### **Exploiting Services**
[**Lies dies, wenn du auffrischen möchtest, was ein Service ist.**](android-applications-basics.md#services)\
[**Read this if you want to refresh what is a Service.**](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**, diese **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, Authentifizierungsmaßnahmen zu umgehen usw.\
[**Lerne, wie man Services mit Drozer ausnutzt.**](drozer-tutorial/index.html#services)
Ein Service ist im Grunde etwas, das **Daten empfangen**, **verarbeiten** und (möglicherweise) eine Antwort **zurückgeben** kann. Wenn eine Anwendung also Services exportiert, solltest du den **Code** prüfen, um zu verstehen, was er macht, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...
[**Learn how to exploit Services with Drozer.**](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)\
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Denke daran, dass die Aktionen eines Broadcast Receiver in der Methode `onReceive` beginnen.
Ein Broadcast Receiver wartet auf einen bestimmten Nachrichtentyp. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\
[**Lerne, wie man Broadcast Receivers mit Drozer ausnutzt.**](#exploiting-broadcast-receivers)
Ein Broadcast Receiver wartet auf einen Nachrichtentyp. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
### **Exploiting Schemes / Deep links**
Du kannst nach deep links manuell suchen, indem du Tools wie MobSF oder Skripte wie [dieses](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwendest.\
Du kannst ein deklariertes **scheme** mit **adb** oder einem **browser** **öffnen**:
Du kannst manuell nach deep links suchen, z. B. mit Tools wie MobSF oder Skripten wie [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
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 den Link öffnen soll._
```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>
```
**Ausgeführter Code**
**Auszuführender 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`**.
Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Activity, die durch den deep link aufgerufen wird, und suche die Funktion **`onNewIntent`**.
![](<../../images/image (436) (1) (1) (1).png>)
**Sensitive info**
**Sensible Informationen**
Jedes Mal, wenn du einen deep link findest, überprüfe, dass **er keine sensitiven Daten (wie Passwörter) über URL parameters erhält**, denn jede andere Anwendung könnte **den deep link vortäuschen und diese Daten stehlen!**
Jedes Mal, wenn du einen deep link findest, überprüfe, dass er **nicht sensitive Daten (wie Passwörter) über URL-Parameter empfängt**, denn jede andere Anwendung könnte den deep link **vortäuschen und diese Daten stehlen!**
**Parameters in path**
**Parameter im Pfad**
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 ein path traversal erzwingen, indem du auf etwas wie `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\
Note that if you find the correct endpoints inside the application you may be able to cause a **Open Redirect** (if part of the path is used as domain name), **account takeover** (if you can modify users details without CSRF token and the vuln endpoint used the correct method) and any other vuln. More [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 auf etwas wie zugreifst: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
Beachte, dass du, wenn du die korrekten Endpunkte in der Anwendung findest, möglicherweise einen **Open Redirect** (wenn ein Teil des Pfads als Domainname verwendet wird), eine **account takeover** (wenn du Benutzerdetails ohne CSRF-Token ändern kannst und der vuln Endpoint die richtige Methode verwendet) und andere vuln verursachen kannst. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
**More examples**
**Weitere Beispiele**
An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
Ein [interessanter bug bounty report](https://hackerone.com/reports/855618) über Links (_/.well-known/assetlinks.json_).
### Transport Layer-Inspektion und Verifikationsfehler
### Transport Layer-Inspektion und Verifizierungsfehler
- **Zertifikate werden nicht immer korrekt geprüft** von Android-Anwendungen. Es ist üblich, dass diese Anwendungen Warnungen ignorieren und selbstsignierte Zertifikate akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückfallen.
- **Aushandlungen während des SSL/TLS-Handshake sind manchmal schwach**, es werden insecure cipher suites eingesetzt. Diese Schwachstelle macht die Verbindung anfällig für man-in-the-middle (MITM) Angriffe und erlaubt Angreifern, die Daten zu entschlüsseln.
- **Offenlegung privater Informationen** ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, dann aber für andere Transaktionen über unsichere Kanäle kommunizieren. Dieser Ansatz schützt sensible Daten wie Session-Cookies oder Benutzerdetails nicht vor dem Abfangen durch böswillige Akteure.
- **Certificates are not always inspected properly** von Android-Anwendungen. Es ist üblich, dass diese Anwendungen Warnungen übersehen und selbstsignierte Zertifikate akzeptieren oder in manchen Fällen auf HTTP-Verbindungen zurückfallen.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, es werden unsichere Cipher Suites verwendet. Diese Schwachstelle macht die Verbindung anfällig für man-in-the-middle (MITM)-Angriffe und ermöglicht es Angreifern, die Daten zu entschlüsseln.
- **Leakage of private information** ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, aber anschließend für andere Transaktionen über nicht sichere Kanäle kommunizieren. Dieser Ansatz schützt sensitive Daten wie Session-Cookies oder Benutzerdetails nicht vor dem Abfangen durch bösartige Akteure.
#### Certificate Verification
#### Zertifikatsprüfung
Wir konzentrieren uns auf die **Zertifikatsverifikation**. Die Integrität des Serverzertifikats muss verifiziert werden, um die Sicherheit zu erhöhen. Das ist entscheidend, da unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle erhebliche Risiken darstellen können. Für detaillierte Schritte zur Überprüfung von Serverzertifikaten und zur Behebung von Schwachstellen bietet [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitungen.
Wir konzentrieren uns auf **certificate verification**. Die Integrität des Serverzertifikats muss verifiziert werden, um die Sicherheit zu erhöhen. Das ist entscheidend, da unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle erhebliche Risiken darstellen können. Für detaillierte Schritte zur Verifikation von Serverzertifikaten und zur Behebung von Schwachstellen bietet [**diese Ressource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitung.
#### SSL Pinning
SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat gegen eine bekannte Kopie verifiziert, die innerhalb der Anwendung gespeichert ist. Diese Methode ist essenziell, um MITM-Angriffe zu verhindern. Die Implementierung von SSL Pinning wird dringend empfohlen für Anwendungen, die mit sensitiven Informationen umgehen.
SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat gegen eine bekannte Kopie prüft, die innerhalb der Anwendung selbst gespeichert ist. Diese Methode ist essentiell, um MITM-Angriffe zu verhindern. Die Implementierung von SSL Pinning wird dringend für Anwendungen empfohlen, die sensitive Informationen verarbeiten.
#### Traffic Inspection
#### Traffic-Inspektion
Um HTTP-Traffic zu inspizieren, ist es notwendig, **das Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist verschlüsselter Traffic möglicherweise nicht über den Proxy sichtbar. For a guide on installing a custom CA certificate, [**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 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, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Applications targeting **API Level 24 and above** require modifications to the Network Security Config to accept the proxy's CA certificate. This step is critical for inspecting encrypted traffic. For instructions on modifying the Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
Anwendungen, die **API Level 24 and above** anvisieren, 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. Für Anweisungen zur Änderung der Network Security Config, [**siehe dieses Tutorial**](make-apk-accept-ca-certificate.md).
If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is becasue, just adding the certificate into the store won't work as Flutter has its own list of valid CAs.
Wenn **Flutter** verwendet wird, musst du die Anweisungen auf [**dieser Seite**](flutter.md) befolgen. Das liegt daran, dass das einfache Hinzufügen des Zertifikats in den Store nicht ausreicht, da Flutter seine eigene Liste gültiger CAs hat.
#### Static detection of SSL/TLS pinning
#### Statische Erkennung von 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 Code-Pfade zu konzentrieren.
Bevor du Runtime-Bypasses versuchst, solltest du schnell kartieren, wo Pinning im APK durchgesetzt wird. Statische Erkennung hilft dir, Hooks/Patches zu planen und dich auf die richtigen Codepfade zu konzentrieren.
Tool: SSLPinDetect
- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations.
- Reports exact file path, line number, and a code snippet for each match.
- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
- Open-source static-analysis utility, das das APK zu Smali (via apktool) dekompiliert und nach kuratierten Regex-Mustern für SSL/TLS-Pinning-Implementierungen scannt.
- Gibt für jeden Treffer den exakten Dateipfad, die Zeilennummer und einen Codeausschnitt aus.
- Deckt gängige Frameworks und benutzerdefinierte Codepfade ab: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
Installation
Install
- Voraussetzungen: Python >= 3.8, Java on PATH, apktool
```bash
git clone https://github.com/aancw/SSLPinDetect
@ -457,8 +466,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-Musterregeln (JSON)
Verwenden oder erweitern Sie signatures, um proprietäre/custom pinning styles zu erkennen. Sie können Ihr eigenes JSON laden und scan at scale.
Verwenden oder erweitern Sie signatures, um proprietäre/benutzerdefinierte pinning-Stile zu erkennen. Sie können Ihr eigenes JSON laden und in großem Maßstab scannen.
```json
{
"OkHttp Certificate Pinning": [
@ -473,42 +481,42 @@ Verwenden oder erweitern Sie signatures, um proprietäre/custom pinning styles z
}
```
Notes and tips
- Schnelles Scannen großer Apps per Multithreading und memory-mapped I/O; vorkompilierte regex reduziert Overhead/Falschpositive.
- Schnellscans bei großen Apps mittels Multithreading und speichergemapter I/O; vorkompilierte Regex reduzieren Overhead/Falschmeldungen.
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
- Typische Erkennungsziele zur weiteren Triage:
- OkHttp: CertificatePinner-Nutzung, setCertificatePinner, okhttp3/okhttp Paketreferenzen
- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted-Overrides
- 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 Config-Reviews vor dynamischem Testing zu planen.
- 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 Konfigurationsreviews vor dynamischen Tests zu planen.
#### Umgehung von SSL Pinning
#### Bypassing SSL Pinning
Wenn SSL Pinning implementiert ist, wird seine Umgehung notwendig, um HTTPS-Traffic zu untersuchen. Dafür stehen verschiedene Methoden zur Verfügung:
When SSL Pinning is implemented, it becomes necessary to inspect HTTPS traffic by bypassing it. Verschiedene Methoden stehen dafür zur Verfügung:
- Automatisch die **apk** mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) **modifizieren**, um SSLPinning zu **bypassen**. Der größte Vorteil dieser Option ist, dass du kein root brauchst, um das SSL Pinning zu umgehen, aber du musst die Anwendung löschen und die neue installieren — das funktioniert nicht immer.
- Du kannst **Frida** (unten besprochen) verwenden, um diesen Schutz zu umgehen. Hier ein Guide 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 mit [**objection**](frida-tutorial/objection-tutorial.md) zu umgehen: `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Du kannst auch versuchen, SSL Pinning automatisch mit **MobSF dynamic analysis** zu umgehen (unten erklärt)
- Wenn du denkst, dass Traffic nicht erfasst wird, kannst du versuchen, den Traffic per 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)
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Der größte Vorteil dieser Option ist, dass du kein root benötigst, um SSL Pinning zu bypassen, aber du musst die Anwendung löschen und die neue installieren, und das funktioniert nicht immer.
- Du könntest **Frida** (discussed below) verwenden, um diesen Schutz zu bypassen. Hier ein Guide zur Nutzung von Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
- Wenn du immer noch denkst, dass es Traffic gibt, den du nicht aufzeichnest, kannst du versuchen, den Traffic mit iptables an burp weiterzuleiten. Lies diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Suche nach gängigen Web-Vulnerabilities
#### Looking for Common Web Vulnerabilities
Es ist wichtig, auch nach gängigen Web-Vulnerabilities innerhalb der Anwendung zu suchen. Detaillierte Informationen zur Identifikation und Behebung dieser Schwachstellen liegen außerhalb dieser Zusammenfassung, werden aber an anderer Stelle ausführlich behandelt.
Es ist wichtig, auch nach typischen Web-Schwachstellen innerhalb der Anwendung zu suchen. Detaillierte Informationen zur Identifikation und Behebung dieser Schwachstellen gehen über diese Zusammenfassung hinaus, sind aber an anderer Stelle umfassend dokumentiert.
### Frida
[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungs-Toolkit für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
Du kannst auf laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um Verhalten zu ändern, Werte zu verändern, Werte zu extrahieren oder anderen Code auszuführen...\
Wenn du Android-Anwendungen pentesten willst, musst du wissen, wie man Frida benutzt.
**Du kannst laufende Anwendungen erreichen und Methoden zur Laufzeit hooken, um Verhalten zu ändern, Werte zu verändern, Werte zu extrahieren, anderen Code auszuführen...**\
Wenn du Android-Anwendungen pentest willst, musst du wissen, wie man Frida benutzt.
- Lerne, wie man Frida benutzt: [**Frida tutorial**](frida-tutorial/index.html)
- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html)
- Einige "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection ist gut, 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) gezeigt lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
- 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 scripts hier: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Versuche, Anti-Debugging / Anti-Frida-Mechanismen zu bypassen, 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) gezeigt lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
#### Anti-instrumentation & SSL pinning bypass workflow
@ -516,11 +524,11 @@ Wenn du Android-Anwendungen pentesten willst, musst du wissen, wie man Frida ben
android-anti-instrumentation-and-ssl-pinning-bypass.md
{{#endref}}
### **Speicher dumpen - Fridump**
### **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 sie nicht ablegen sollte, wie Passwörter oder Mnemonics.
Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App dumpen mit:
Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App mit:
```bash
# With PID
python3 fridump3.py -u <PID>
@ -529,63 +537,63 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Dadurch wird der Speicher im Ordner ./dump gedumpt, und dort könntest du mit etwas wie folgendem grep suchen:
Das wird den Speicher im Ordner ./dump dumpen, und dort könntest du mit etwas wie grep suchen:
```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 im Keystore**
In Android ist der Keystore der beste Ort, um sensible Daten zu speichern, jedoch ist es mit ausreichenden Privilegien weiterhin **möglich, darauf zuzugreifen**. Da Anwendungen hier dazu neigen, **sensible Daten im Klartext** 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.
In Android ist der Keystore der beste Ort, um sensible Daten zu speichern, jedoch ist es bei ausreichenden Privilegien immer noch **möglich, darauf zuzugreifen**. Da Anwendungen hier dazu neigen, **sensible Daten im Klartext** zu speichern, sollten pentests dies prüfen, da ein root user oder jemand mit physischem Zugriff auf das Gerät diese Daten stehlen könnte.
Selbst wenn eine App Daten im Keystore speichert, sollten die Daten verschlüsselt sein.
Selbst wenn eine App Daten im Keystore speichert, sollten diese verschlüsselt sein.
Um auf die Daten im Keystore zuzugreifen, kannst du 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, kann man dieses Frida script 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)
```bash
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
```
### **Fingerprint/Biometrics Bypass**
Mit dem folgenden Frida-Skript kann es möglich sein, eine von Android-Anwendungen eingesetzte **bypass fingerprint authentication** zu umgehen, die zum Schutz bestimmter sensibler Bereiche verwendet wird:
Mit dem folgenden Frida-Skript könnte es möglich sein, die von Android-Anwendungen möglicherweise 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>
```
### **Hintergrundbilder**
### **Background Images**
Wenn Sie eine Anwendung in den Hintergrund legen, speichert Android eine **snapshot of the application**, sodass beim Wiederherstellen in den Vordergrund das Bild vor der App geladen wird und es so aussieht, als wäre die App schneller gestartet.
Wenn du eine Anwendung in den Hintergrund verschiebst, speichert Android einen **Snapshot der Anwendung**, sodass beim Wiederherstellen in den Vordergrund zuerst das Bild geladen wird, bevor die App startet, wodurch es so wirkt, als wäre die App schneller geladen.
Wenn dieser snapshot jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den snapshot **diese Informationen stehlen** (Hinweis: Zum Zugriff wird Root benötigt).
Wenn dieser Snapshot jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Snapshot diese Informationen **stehlen** (beachte, dass du root benötigst, um darauf zuzugreifen).
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, **das Erfassen von screenshots zu verhindern, indem der Layout-Parameter FLAG_SECURE gesetzt wird**. Wenn dieses Flag verwendet wird, werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden.
Android bietet eine Möglichkeit, die **Aufnahme von Screenshots durch Setzen des FLAG_SECURE** Layout-Parameters zu verhindern. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in Screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
### **Android Application Analyzer**
Dieses Tool kann Ihnen beim Verwalten verschiedener Tools während der dynamic analysis helfen: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
Dieses Tool kann dir helfen, verschiedene Tools während der dynamic analysis 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(...)` weitergeben, was riskant sein kann.
Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky.
Die Gefahr liegt darin, Angreifern zu erlauben, nicht-exportierte App-Komponenten auszulösen oder sensible content providers zu erreichen, 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.
Die Gefahr besteht darin, dass Angreifer diese Intents fehlleiten und so nicht-exportierte App-Komponenten auslösen oder auf sensible content providers zugreifen können. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs über `Intent.parseUri(...)` in `Intent`-Objekte umwandelt und diese dann ausführt, was potenziell zu bösartigen Intent injections führen kann.
### Wesentliche Erkenntnisse
### Essential Takeaways
- **Intent Injection** ist ähnlich wie das Open Redirect-Problem im Web.
- Exploits beinhalten das Übergeben von `Intent`-Objekten als extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
- Dadurch können nicht-exportierte Komponenten und content providers für Angreifer zugänglich werden.
- Die URL-zu-`Intent`-Konvertierung von `WebView` kann unbeabsichtigte Aktionen ermöglichen.
- Exploits beinhalten das Weitergeben von `Intent`-Objekten als Extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
- Dadurch können non-exported components und content providers für Angreifer zugänglich gemacht werden.
- Die Konvertierung von URLs zu `Intent`-Objekten durch `WebView` kann unbeabsichtigte Aktionen ermöglichen.
### Android Client Side Injections and others
Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Bei einer Android-Anwendung müssen Sie besonders auf diese Schwachstellen achten:
Wahrscheinlich kennst du diese Art von Schwachstellen aus dem Web. Bei Android-Anwendungen musst du bei diesen Schwachstellen besonders vorsichtig sein:
- **SQL Injection:** Beim Umgang mit dynamischen Abfragen oder Content-Providers stellen Sie sicher, dass parametrisierte Abfragen verwendet werden.
- **JavaScript Injection (XSS):** Vergewissern Sie sich, 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 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 die Session-Cookie nicht widerrufen oder das Cookie kann sogar auf der Festplatte gespeichert werden
- **SQL Injection:** Wenn du mit dynamischen Queries oder Content-Providers arbeitest, stelle sicher, dass parameterisierte Abfragen verwendet werden.
- **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** Bei WebViews sollte der Zugriff auf das Dateisystem deaktiviert sein (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: In vielen Fällen wird beim Beenden der Android-Anwendung die Session-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)
---
@ -598,51 +606,51 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Bei einer An
![](<../../images/image (866).png>)
**Vulnerability assessment der Anwendung** mittels eines ansprechenden web-basierten Frontends. Sie können auch dynamic analysis durchführen (aber Sie müssen die Umgebung vorbereiten).
**Sicherheitsbewertung der Anwendung** mithilfe einer ansprechenden webbasierten Oberfläche. Du kannst auch dynamic analysis durchführen (du musst aber die Umgebung vorbereiten).
```bash
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Beachte, dass MobSF **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren kann (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
Außerdem, wenn du eine **ZIP** Datei mit dem Source-Code einer **Android** oder **IOS** App erstellst (gehe in den Root-Ordner der Anwendung, wähle alles aus und erstelle eine ZIPfile), kann es diese ebenfalls analysieren.
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.
MobSF erlaubt dir auch, **diff/Compare** Analysen durchzuführen und **VirusTotal** zu integrieren (du musst deinen API Key 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 der **hash** statt der Datei **upload**.
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 **upload** instead of the file.
### Unterstützte Dynamic analysis mit MobSF
### Unterstützte dynamische Analyse mit MobSF
**MobSF** kann auch bei der **dynamic analysis** von **Android** sehr hilfreich sein, in diesem Fall musst du jedoch MobSF und **genymotion** auf deinem Host installieren (eine VM oder Docker funktioniert nicht). _Hinweis: Du musst **zuerst eine VM in genymotion starten** und **dann MobSF.**_\
**MobSF** kann auch sehr nützlich für **dynamic analysis** unter **Android** sein, aber in diesem Fall müssen Sie MobSF und **genymotion** auf Ihrem Host installieren (a **VM** or **Docker** won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
Der **MobSF dynamic analyser** kann:
- **Dump Anwendungsdaten** (URLs, logs, clipboard, screenshots, die du gemacht hast, screenshots die vom "**Exported Activity Tester**" gemacht wurden, emails, SQLite Datenbanken, XML Dateien und andere erstellte Dateien). All dies geschieht automatisch außer bei den Screenshots — diese musst du manuell auslösen, oder du musst "**Exported Activity Tester**" drücken, um Screenshots aller exportierten Activities zu erhalten.
- **Capture HTTPS traffic**
- **Use Frida** um **Laufzeitinformationen** zu erhalten
- **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.
- Erfassen von **HTTPS traffic**
- Verwenden von **Frida**, um **Laufzeitinformationen** zu erhalten
Ab android **versions > 5** wird es **automatisch Frida starten** und globale **proxy** Einstellungen setzen, um den Traffic zu **capture**. Es wird nur den Traffic der getesteten Anwendung erfassen.
Ab **Android versions > 5** wird es **automatically start Frida** und globale **proxy**-Einstellungen setzen, um den Traffic zu **capture**. Es wird nur den Traffic der getesteten Anwendung erfassen.
**Frida**
Standardmäßig verwendet es auch einige Frida Scripts, um **SSL pinning** zu **bypassen**, **root detection** und **debugger detection** zu umgehen und um interessante **APIs** zu **monitoren**.\
MobSF kann auch **invoke exported activities**, **Screenshots** davon machen und sie für den Report **save**.
Standardmäßig werden auch einige Frida Scripts verwendet, 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**.
Um das dynamic testing zu **starten** drücke den grünen Button: "**Start Instrumentation**". Drücke "**Frida Live Logs**" um die von den Frida scripts erzeugten Logs zu sehen und "**Live API Monitor**" um alle Aufrufe der gehookten Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies erscheint nach dem Drücken von "Start Instrumentation").\
MobSF erlaubt dir außerdem, eigene **Frida scripts** zu laden (um die Ergebnisse deiner Frida scripts an MobSF zu senden benutze die Funktion `send()`). Es gibt auch **mehrere vorgeschriebene scripts**, die du laden kannst (du kannst weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), einfach **auswählen**, "**Load**" drücken und "**Start Instrumentation**" drücken (die Logs dieser scripts wirst du im "**Frida Live Logs**" sehen).
Um das dynamische Testing zu **start**en, drücken Sie den grünen Button: "**Start Instrumentation**". Drücken Sie "**Frida Live Logs**", um die von den Frida-Scripts erzeugten Logs zu sehen, und "**Live API Monitor**", um alle Aufrufe zu gehookten Methoden, übergebene Argumente und Rückgabewerte zu sehen (dies erscheint nach dem Drücken von "Start Instrumentation").\
MobSF erlaubt Ihnen auch, eigene **Frida scripts** zu laden (um die Ergebnisse Ihrer Friday scripts an MobSF zu senden, benutzen Sie die Funktion `send()`). Es gibt auch **several pre-written scripts**, die Sie laden können (Sie können weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), einfach **select them**, drücken Sie "**Load**" und dann "**Start Instrumentation**" (Sie können die Logs dieser Scripts in "**Frida Live Logs**" sehen).
![](<../../images/image (419).png>)
Außerdem hast du einige zusätzliche Frida-Funktionalitäten:
Zudem haben Sie einige zusätzliche Frida-Funktionalitäten:
- **Enumerate Loaded Classes**: Es gibt alle geladenen Klassen aus
- **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 2 verglichenen Strings und ob das Ergebnis True oder False war.
- **Enumerate Class Methods**: Gib den Klassennamen ein (z.B. "java.io.File") und es listet alle Methoden der Klasse auf.
- **Search Class Pattern**: Sucht Klassen nach einem Pattern
- **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.
- **Enumerate Loaded Classes**: Druckt alle geladenen Klassen
- **Capture Strings**: Gibt alle erfassten Strings während der Nutzung der Anwendung aus (sehr noisy)
- **Capture String Comparisons**: Kann sehr nützlich sein. Es wird **die 2 Strings zeigen, die verglichen wurden** und ob das Ergebnis True oder False war.
- **Enumerate Class Methods**: Geben Sie den Klassennamen ein (z. B. "java.io.File") und es werden alle Methoden der Klasse ausgegeben.
- **Search Class Pattern**: Sucht Klassen nach Pattern
- **Trace Class Methods**: **Trace** einer **ganzen Klasse** (zeigt Eingaben und Ausgaben aller Methoden der Klasse). Denken Sie daran, dass MobSF standardmäßig mehrere interessante Android API-Methoden traces.
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.
Sobald Sie das Auxiliary-Modul ausgewählt haben, das Sie verwenden möchten, müssen Sie "**Start Intrumentation**" drücken und Sie werden alle Ausgaben in "**Frida Live Logs**" sehen.
**Shell**
Mobsf bietet dir außerdem eine Shell mit einigen **adb** Befehlen, **MobSF** Befehlen und gängigen **shell** **commands** am unteren Rand der dynamic analysis Seite. Einige interessante Befehle:
MobSF stellt Ihnen außerdem eine Shell mit einigen **adb** commands, **MobSF commands**, und gängigen **shell** **commands** unten auf der Seite für dynamische Analyse zur Verfügung. Einige interessante commands:
```bash
help
shell ls
@ -651,34 +659,34 @@ exported_activities
services
receivers
```
**HTTP-Tools**
**HTTP tools**
Wenn HTTP-Traffic erfasst wird, kannst du eine rohe Ansicht des aufgezeichneten Traffics über den "**HTTP(S) Traffic**"-Button sehen oder eine schönere Ansicht über den grünen "**Start HTTPTools**"-Button. Über die zweite Option kannst du die **aufgezeichneten 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)).
Wenn HTTP-Traffic erfasst wird, kannst du eine unansehnliche Ansicht des erfassten Traffics unten unter "**HTTP(S) Traffic**" sehen oder eine schönere Ansicht über die grüne Schaltfläche "**Start HTTPTools**". Bei der zweiten Option kannst du **send** die **captured requests** an **proxies** wie Burp oder Owasp ZAP.\
Um das zu tun: _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> drücke "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Sobald du die dynamische Analyse mit MobSF abgeschlossen hast, kannst du auf "**Start Web API Fuzzer**" drücken, um **http requests zu fuzz-en** und nach Schwachstellen zu suchen.
Sobald du die dynamic analysis mit MobSF abgeschlossen hast, kannst du auf "**Start Web API Fuzzer**" drücken, um **fuzz http requests** und nach Schwachstellen zu suchen.
> [!TIP]
> Nach einer dynamischen Analyse mit MobSF können die Proxy-Einstellungen falsch konfiguriert sein und du kannst sie nicht über die GUI reparieren. Du kannst die Proxy-Einstellungen folgendermaßen zurücksetzen:
> Nach Durchführung einer dynamic analysis mit MobSF können die Proxy-Einstellungen falsch konfiguriert sein und du wirst sie nicht über die GUI beheben können. Du kannst die Proxy-Einstellungen wie folgt reparieren:
>
> ```
> adb shell settings put global http_proxy :0
> ```
### Assisted Dynamic Analysis with Inspeckage
### Assisted Dynamic Analysis mit Inspeckage
Du kannst das Tool von [**Inspeckage**](https://github.com/ac-pm/Inspeckage) beziehen.\
Dieses Tool verwendet einige **Hooks**, um dir während einer **dynamic analysis** zu zeigen, **was in der Anwendung passiert**, während du sie ausführst.
Du kannst das Tool von [**Inspeckage**](https://github.com/ac-pm/Inspeckage) bekommen.\
Dieses Tool verwendet einige **Hooks**, um dir zu zeigen, **what is happening in the application**, während du eine **dynamic analysis** durchführst.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
Dies ist ein **tolles Tool, um statische Analyse mit einer GUI durchzuführen**
Dies ist ein **tolles Tool, um static analysis mit einer GUI durchzuführen**
![](<../../images/image (741).png>)
### [Qark](https://github.com/linkedin/qark)
Dieses Tool wurde entwickelt, um nach verschiedenen **security related Android application vulnerabilities** zu suchen, sowohl im **source code** als auch in **packaged APKs**. Das Tool ist außerdem **in der Lage, eine \"Proof-of-Concept\" deployable APK** und **ADB commands** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exposed activities, intents, tapjacking...). Wie bei Drozer ist es nicht nötig, das Testgerät zu rooten.
Dieses Tool ist dafür konzipiert, nach verschiedenen **security related Android application vulnerabilities** zu suchen, 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
@ -687,10 +695,10 @@ qark --java path/to/specific/java/file.java
```
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
- Zeigt alle extrahierten Dateien zur einfachen Referenz an
- Dekompiliert automatisch APK-Dateien in Java- und Smali-Format
- Analysiert AndroidManifest.xml auf häufige Schwachstellen und Verhaltensweisen
- Statische Quellcode-Analyse auf häufige Schwachstellen und Verhaltensweisen
- Zeigt alle extrahierten Dateien zur einfachen Übersicht an
- Dekompliliert 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
@ -698,11 +706,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 genutzt werden kann und _.apk_-Dateien nach Schwachstellen analysiert. Dazu dekomprimiert sie 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 nach Schwachstellen analysiert. Dazu werden APKs dekomprimiert und eine Reihe von Regeln angewendet, um diese Schwachstellen zu erkennen.
Alle Regeln sind in einer `rules.json`-Datei zentralisiert, und jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen.
Alle Regeln sind in einer Datei `rules.json` zentralisiert, und jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um gezielt 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}
```
@ -710,9 +718,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 **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.
Das Konzept ist, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) per Drag & Drop auf die StaCoAn-Anwendung ziehen; anschließend erstellt sie einen visuellen und portablen Bericht für Sie. Sie können die Einstellungen und wordlists anpassen, um eine maßgeschneiderte Erfahrung zu erhalten.
Das Konzept besteht darin, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) per Drag & Drop auf die StaCoAn-Anwendung ziehen; sie erzeugt dann einen visuellen und portablen Bericht für Sie. Sie können die Einstellungen und wordlists anpassen, um ein individuelles Erlebnis zu erhalten.
Herunterladen[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
@ -720,7 +728,7 @@ Herunterladen[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
AndroBugs Framework ist ein Android vulnerability analysis system, das Entwicklern oder hackers hilft, potenzielle security vulnerabilities in Android-Anwendungen zu finden.\
AndroBugs Framework ist ein System zur Analyse von Schwachstellen in Android-Anwendungen, das Entwicklern oder hackers dabei hilft, potenzielle Sicherheitslücken zu finden.\
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
```
python androbugs.py -f [APK file]
@ -728,11 +736,11 @@ androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** ist ein Tool, dessen Hauptziel darin besteht, den Benutzer vor potenziell bösartigen Verhaltensweisen einer Android-Anwendung zu erkennen und zu warnen.
**Androwarn** ist ein Tool, dessen Hauptzweck darin besteht, potenziell bösartiges Verhalten einer Android-Anwendung zu erkennen und den Benutzer davor zu warnen.
Die Erkennung erfolgt durch **static analysis** des Dalvik bytecode der Anwendung, dargestellt als **Smali**, mithilfe der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
Die Erkennung erfolgt durch die **static analysis** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mithilfe der [`androguard`](https://github.com/androguard/androguard)-Bibliothek.
Dieses Tool sucht nach **häufigen Verhaltensmustern von "bad" applications** wie: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
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...
```
python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
```
@ -740,36 +748,36 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das häufig verwendete Mobile Application Reverse Engineering- und Analysis-Tools zusammenführt, um bei der Prüfung von mobilen Anwendungen gegen die OWASP mobile security threats zu unterstützen. Ziel ist es, diese Aufgabe für Mobile-Application-Entwickler und Sicherheitsfachleute einfacher und benutzerfreundlicher zu machen.
**MARA** is a **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 Anwendungsentwickler und Sicherheitsexperten einfacher und benutzerfreundlicher zu gestalten.
Es kann:
It is able to:
- Java- und Smali-Code mit verschiedenen Tools extrahieren
- Extract Java and Smali code using different tools
- APKs analysieren mit: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- Private Informationen aus der APK mit Regexps extrahieren.
- Private Informationen aus dem APK mittels regexps extrahieren.
- Das Manifest analysieren.
- Gefundene Domains analysieren mit: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) und [whatweb](https://github.com/urbanadventurer/WhatWeb)
- APK via [apk-deguard.com](http://www.apk-deguard.com) deobfuskieren
- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
### 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
Beachte, dass abhängig vom Service und der Konfiguration, die du zum Obfuskieren des Codes verwendest, Secrets eventuell obfuskiert sind oder nicht.
Beachte, dass abhängig vom Service und der Konfiguration, die du zum Obfuskieren des Codes verwendest, Secrets möglicherweise obfuskiert sind oder nicht.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
From [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 ungenutzte Instruktionen erkennen und entfernen. ProGuard ist freie Software und wird unter der GNU General Public License, Version 2 vertrieben.
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Es kann Bytecode optimieren sowie ungenutzte Instruktionen erkennen und entfernen. ProGuard ist freie Software und wird unter der GNU General Public License, version 2 vertrieben.
ProGuard wird als Teil des Android SDK ausgeliefert und läuft beim Erstellen der Anwendung im Release-Modus.
ProGuard wird als Teil des Android SDK verteilt und läuft beim Erstellen der Anwendung im Release-Modus.
### [DexGuard](https://www.guardsquare.com/dexguard)
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)
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
(Aus diesem Leitfaden) Beim letzten Mal, als wir es überprüft haben, war der DexGuard Betriebsmodus wie folgt:
(From that guide) Last time we checked, the Dexguard mode of operation was:
- load a resource as an InputStream;
- feed the result to a class inheriting from FilterInputStream to decrypt it;
@ -779,36 +787,36 @@ Eine Schritt-für-Schritt-Anleitung zum Deobfuskieren der APK findest du unter [
### [DeGuard](http://apk-deguard.com)
**DeGuard kehrt den von Android-Obfuskationstools durchgeführten Obfuskationsprozess um. Dies ermöglicht zahlreiche Sicherheitsanalysen, einschließlich Code-Inspektion und Erkennung von Bibliotheken.**
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
Du kannst eine obfuskierte APK auf ihre Plattform hochladen.
Du kannst eine obfuskierte APK auf deren Plattform hochladen.
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
Dies ist ein LLM-Tool, um mögliche Sicherheitslücken in Android-Apps zu finden und Android-App-Code zu deobfuskieren. Verwendet Google's Gemini public API.
This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
### [Simplify](https://github.com/CalebFenton/simplify)
Es ist ein **generischer android deobfuscator.** Simplify **führt eine App praktisch aus**, um ihr Verhalten zu verstehen, und versucht dann, den Code so zu optimieren, dass er sich identisch verhält, aber für einen Menschen leichter zu verstehen ist. Jeder Optimierungstyp ist einfach und generisch, sodass es egal ist, welche konkrete Art der Obfuskation verwendet wurde.
Es ist ein **generic android deobfuscator.** Simplify **virtually executes an app** um ihr Verhalten zu verstehen und versucht dann, **tries to optimize the code** damit es sich identisch verhält, aber für einen Menschen leichter zu verstehen ist. Jede Optimierungsart ist einfach und generisch, daher spielt es keine Rolle, welche spezifische Art der Obfuskation verwendet wurde.
### [APKiD](https://github.com/rednaga/APKiD)
APKiD liefert Informationen darüber, **wie eine APK erstellt wurde**. Es identifiziert viele **Compilers**, **Packers**, **Obfuscators** und andere merkwürdige Dinge. Es ist [_PEiD_](https://www.aldeid.com/wiki/PEiD) für Android.
APKiD gives you information about **how an APK was made**. Es identifiziert viele **compilers**, **packers**, **obfuscators**, und andere seltsame Dinge. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
### Manual
[Lesen Sie dieses Tutorial, um einige Tricks zu lernen, **wie man benutzerdefinierte Obfuskation reverse-engineert**](manual-deobfuscation.md)
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
## Labs
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b ist eine Android-Sicherheits-virtuelle Maschine basierend auf ubuntu-mate und enthält eine Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Security-Geeks und Forschern für Reverse Engineering und Malware-Analyse.
AndroL4b ist eine Android security virtual machine basierend auf ubuntu-mate und enthält eine Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Security-Geeks und Forschern für reverse engineering und malware analysis.
## References
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es ist eine großartige Liste von Ressourcen
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources
- [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)
@ -816,8 +824,9 @@ AndroL4b ist eine Android-Sicherheits-virtuelle Maschine basierend auf ubuntu-ma
- [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
## Noch auszuprobieren
- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

147
src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
View File

@ -2,46 +2,63 @@
{{#include ../../banners/hacktricks-training.md}}
Diese Seite bietet einen praxisorientierten Workflow, um dynamische Analyse gegen Android-Apps wiederherzustellen, die Instrumentation erkennen/Root‑Blockierungen durchführen oder TLS‑Pinning erzwingen. Sie konzentriert sich auf schnelle Triage, häufige Erkennungen und kopierbare Hooks/Taktiken, um diese nach Möglichkeit ohne Repacking zu umgehen.
Diese Seite bietet einen praktischen Workflow, um dynamic analysis gegen Android-Apps wiederherzustellen, die Instrumentation erkennen/root‑blocken oder TLS pinning erzwingen. Sie konzentriert sich auf schnelle Triage, häufige Erkennungen und copy‑pasteable hooks/tactics, um diese nach Möglichkeit ohne repacking zu umgehen.
## Detection Surface (was Apps prüfen)
## Detection Surface (what apps check)
- Root-Prüfungen: su binary, Magisk-Pfade, getprop-Werte, gängige root-Pakete
- Frida/debugger-Prüfungen (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), Scannen von /proc, classpath, geladene libs
- Root checks: su binary, Magisk paths, getprop values, common root packages
- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
- Frühe Init‑Prüfungen: Application.onCreate() oder Prozess-Start-Hooks, die abstürzen, wenn Instrumentation vorhanden ist
- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present
- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins
## Schritt 1 — Quick win: Root verbergen mit Magisk DenyList
## Schritt 1 — Schneller Erfolg: Root mit Magisk DenyList verbergen
- Zygisk in Magisk aktivieren
- DenyList aktivieren, das Zielpaket hinzufügen
- Neustarten und erneut testen
- Aktiviere Zygisk in Magisk
- Aktiviere DenyList, füge das Zielpaket hinzu
- Neustart und erneut testen
Viele Apps suchen nur nach offensichtlichen Indikatoren (su/Magisk‑Pfade/getprop). DenyList neutralisiert oft naive Prüfungen.
Viele Apps suchen nur nach offensichtlichen Indikatoren (su/Magisk-Pfade/getprop). DenyList neutralisiert oft naive Checks.
Referenzen:
References:
- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
## Schritt 2 — 30‑Sekunden Frida Codeshare‑Tests
## Schritt 2 — 30‑Sekunden Frida Codeshare tests
Versuche gängige Drop‑in‑Skripte, bevor du tiefer gehst:
Probiere gängige drop‑in scripts, bevor du tiefer einsteigst:
- anti-root-bypass.js
- anti-frida-detection.js
- hide_frida_gum.js
Beispiel:
Example:
```bash
frida -U -f com.example.app -l anti-frida-detection.js
```
Diese setzen typischerweise Java root/debug-Prüfungen, process/service-Scans und native ptrace() außer Kraft. Nützlich bei leicht geschützten Apps; gehärtete Ziele benötigen möglicherweise maßgeschneiderte hooks.
Diese setzen typischerweise Java root/debug checks, process/service scans und native ptrace() außer Kraft. Nützlich bei leicht geschützten apps; gehärtete targets benötigen möglicherweise maßgeschneiderte hooks.
- Codeshare: https://codeshare.frida.re/
## Schritt 3 — Init-time-Detektoren umgehen, indem man sich später anhängt
## Automatisieren mit Medusa (Frida-Framework)
Viele Detektionen laufen nur während des process spawn/onCreate(). Spawn‑time injection (-f) oder gadgets werden erwischt; ein späteres Anhängen, nachdem die UI geladen ist, kann unbemerkt vorbeischlüpfen.
Medusa bietet über 90 fertige Module für SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception und mehr.
```bash
git clone https://github.com/Ch0pin/medusa
cd medusa
pip install -r requirements.txt
python medusa.py
# Example interactive workflow
show categories
use http_communications/multiple_unpinner
use root_detection/universal_root_detection_bypass
run com.target.app
```
Tipp: Medusa ist ideal für schnelle Erfolge, bevor du eigene hooks schreibst. Du kannst auch Module gezielt auswählen und mit deinen eigenen Skripten kombinieren.
## Schritt 3 — Bypass init-time detectors by attaching late
Viele Detections laufen nur während des process spawn/onCreate(). Spawn‑time injection (-f) oder gadgets werden erkannt; attaching nach dem Laden der UI kann unbemerkt durchrutschen.
```bash
# Launch the app normally (launcher/adb), wait for UI, then attach
frida -U -n com.example.app
@ -50,9 +67,9 @@ aobjection --gadget com.example.app explore # if using gadget
```
Wenn das funktioniert, halte die Sitzung stabil und fahre mit Map- und Stub-Checks fort.
## Schritt 4 — Erkennungslogik mit Jadx kartieren und nach Strings durchsuchen
## Schritt 4 — Erkennungslogik mit Jadx und String-Suche kartieren
Statische Triage-Stichwörter in Jadx:
Statische Triage-Schlüsselwörter in Jadx:
- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
Typische Java-Muster:
@ -61,16 +78,16 @@ public boolean isFridaDetected() {
return getRunningServices().contains("frida");
}
```
Gängige APIs to review/hook:
Gängige APIs zum review/hook:
- android.os.Debug.isDebuggerConnected
- android.app.ActivityManager.getRunningAppProcesses / getRunningServices
- java.lang.System.loadLibrary / System.load (native bridge)
- java.lang.Runtime.exec / ProcessBuilder (probing commands)
- android.os.SystemProperties.get (root/emulator heuristics)
## Schritt 5 — Runtime-Stubbing mit Frida (Java)
## Schritt 5 — Runtime stubbing mit Frida (Java)
Überschreibe benutzerdefinierte Guards, damit sie sichere Werte zurückgeben, ohne die App neu zu packen:
Benutzerdefinierte Guards überschreiben, damit sie sichere Werte zurückgeben, ohne repacking:
```js
Java.perform(() => {
const Checks = Java.use('com.example.security.Checks');
@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
});
```
Frühe Abstürze triagieren? Dump classes kurz bevor die App abstürzt, um wahrscheinliche Detection-Namespaces zu identifizieren:
Frühe Abstürze triagieren? Dump classes kurz bevor es abstürzt, um wahrscheinliche Detection-Namespaces zu erkennen:
```js
Java.perform(() => {
Java.enumerateLoadedClasses({
@ -94,7 +111,15 @@ onComplete: () => console.log('Done')
});
});
```
Protokolliere und neutralisiere verdächtige Methoden, um den Ausführungsfluss zu bestätigen:
// Quick root detection stub example (adapt to target package/class names)
Java.perform(() => {
try {
const RootChecker = Java.use('com.target.security.RootCheck');
RootChecker.isDeviceRooted.implementation = function () { return false; };
} catch (e) {}
});
Verdächtige Methoden protokollieren und neutralisieren, um den Ausführungsfluss zu bestätigen:
```js
Java.perform(() => {
const Det = Java.use('com.example.security.DetectionManager');
@ -104,13 +129,53 @@ return false;
};
});
```
## Schritt 6 — Folge der JNI/native-Spur, wenn Java hooks fehlschlagen
## Bypass emulator/VM detection (Java stubs)
Verfolge JNI-Einstiegspunkte, um native Loader und die Erkennungs-Initialisierung zu lokalisieren:
Gängige Heuristiken: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE, die generic/goldfish/ranchu/sdk enthalten; QEMU-Artefakte wie /dev/qemu_pipe, /dev/socket/qemud; Standard-MAC 02:00:00:00:00:00; 10.0.2.x NAT; fehlende telephony/sensors.
Schnelles Spoofing der Build-Felder:
```js
Java.perform(function(){
var Build = Java.use('android.os.Build');
Build.MODEL.value = 'Pixel 7 Pro';
Build.MANUFACTURER.value = 'Google';
Build.BRAND.value = 'google';
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
});
```
Ergänze Stubs für Dateiexistenzprüfungen und Identifikatoren (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList), um realistische Werte zurückzugeben.
## SSL pinning bypass quick hook (Java)
Neutralisiere benutzerdefinierte TrustManagers und erzwinge permissive SSL-Kontexte:
```js
Java.perform(function(){
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
var SSLContext = Java.use('javax.net.ssl.SSLContext');
// No-op validations
X509TrustManager.checkClientTrusted.implementation = function(){ };
X509TrustManager.checkServerTrusted.implementation = function(){ };
// Force permissive TrustManagers
var TrustManagers = [ X509TrustManager.$new() ];
var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom');
SSLContextInit.implementation = function(km, tm, sr){
return SSLContextInit.call(this, km, TrustManagers, sr);
};
});
```
Hinweise
- Für OkHttp erweitern: hook okhttp3.CertificatePinner und HostnameVerifier bei Bedarf, oder verwende ein universelles unpinning-Skript von CodeShare.
- Beispiel ausführen: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
## Schritt 6 — JNI/native-Spur folgen, wenn Java-Hooks fehlschlagen
Verfolge JNI-Einstiegspunkte, um native Loader und die Detection-Initialisierung zu lokalisieren:
```bash
frida-trace -n com.example.app -i "JNI_OnLoad"
```
Schnelle native triage gebündelter .so-Dateien:
Schnelle native Triage von gebündelten .so-Dateien:
```bash
# List exported symbols & JNI
nm -D libfoo.so | head
@ -121,7 +186,7 @@ Interaktives/native reversing:
- Ghidra: https://ghidra-sre.org/
- r2frida: https://github.com/nowsecure/r2frida
Beispiel: ptrace neutralisieren, um einfachen anti‑debug in libc zu umgehen:
Beispiel: ptrace neutralisieren, um einfache anti‑debug in libc zu umgehen:
```js
const ptrace = Module.findExportByName(null, 'ptrace');
if (ptrace) {
@ -137,26 +202,28 @@ reversing-native-libraries.md
## Schritt 7 — Objection patching (embed gadget / strip basics)
Wenn Sie repacking dem Einsatz von runtime hooks vorziehen, versuchen Sie:
Wenn Sie repacking runtime hooks vorziehen, versuchen Sie:
```bash
objection patchapk --source app.apk
```
Hinweise:
- Benötigt apktool; stellen Sie sicher, dass Sie eine aktuelle Version gemäß der offiziellen Anleitung verwenden, um Build-Probleme zu vermeiden: https://apktool.org/docs/install
- Gadget injection ermöglicht Instrumentierung ohne root, kann aber durch strengere init‑time checks erkannt werden.
- Benötigt apktool; stelle eine aktuelle Version gemäß der offiziellen Anleitung sicher, um Build-Probleme zu vermeiden: https://apktool.org/docs/install
- Gadget injection ermöglicht instrumentation ohne Root, kann aber trotzdem von stärkeren init‑time checks erkannt werden.
Optional, füge LSPosed-Module und Shamiko für stärkeres root hiding in Zygisk-Umgebungen hinzu, und kuratiere die DenyList, um child processes abzudecken.
Referenzen:
- Objection: https://github.com/sensepost/objection
## Schritt 8 — Fallback: TLS pinning patchen für Netzwerk-Sichtbarkeit
## Schritt 8 — Fallback: Patch TLS pinning für Netzwerk‑Sichtbarkeit
Wenn Instrumentierung blockiert ist, können Sie den Traffic weiterhin untersuchen, indem Sie das Pinning statisch entfernen:
Wenn instrumentation blockiert ist, kannst du den Traffic trotzdem untersuchen, indem du pinning statisch entfernst:
```bash
apk-mitm app.apk
# Then install the patched APK and proxy via Burp/mitmproxy
```
- Tool: https://github.com/shroudedcode/apk-mitm
- Für Netzwerk-Konfigurations-CA‑trust-Tricks (und Android 7+ Nutzer-CA-Trust), siehe:
- Für Tricks zur Netzwerk-Konfiguration bezüglich CA‑trust (und Android 7+ user CA trust), siehe:
{{#ref}}
make-apk-accept-ca-certificate.md
@ -186,12 +253,12 @@ apk-mitm app.apk
```
## Tipps & Hinweise
- Bevorzuge spätes Attaching gegenüber Spawning, wenn Apps beim Start abstürzen
- Einige Detections laufen in kritischen Flows (z. B. payment, auth) erneut — halte Hooks während der Navigation aktiv
- Kombiniere statische und dynamische Analyse: string hunt in Jadx, um Klassen vorzuselektieren; dann hook methods, um zur Laufzeit zu verifizieren
- Gehärtete Apps können packers und native TLS pinning verwenden — rechne damit, nativen Code zu reverse-engineeren
- Bevorzuge ein spätes attach gegenüber spawn, wenn Apps beim Start abstürzen
- Einige detections werden in kritischen Flows (z. B. payment, auth) erneut ausgeführt — halte hooks während der Navigation aktiv
- Kombiniere static und dynamic: string hunt in Jadx, um Klassen zu shortlisten; hook methods, um zur Laufzeit zu verifizieren
- Gehärtete Apps können packers und native TLS pinning verwenden — erwarte, nativen Code reverse-engineeren
## Referenzen
## References
- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
- [Frida Codeshare](https://codeshare.frida.re/)
@ -202,5 +269,7 @@ apk-mitm app.apk
- [r2frida](https://github.com/nowsecure/r2frida)
- [Apktool install guide](https://apktool.org/docs/install)
- [Magisk](https://github.com/topjohnwu/Magisk)
- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa)
- [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)
{{#include ../../banners/hacktricks-training.md}}

154
src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
View File

@ -6,19 +6,19 @@ Vielen Dank an [**@offsecjay**](https://twitter.com/offsecjay) für seine Hilfe
## Was ist
Android Studio ermöglicht es, **virtuelle Maschinen von Android auszuführen, die Sie zum Testen von APKs verwenden können**. Um sie zu nutzen, benötigen Sie:
Android Studio ermöglicht es, **virtuelle Android-Maschinen auszuführen, die du zum Testen von APKs verwenden kannst**. Um sie zu benutzen, benötigst du:
- Die **Android SDK-Tools** - [Hier herunterladen](https://developer.android.com/studio/releases/sdk-tools).
- Oder **Android Studio** (mit Android SDK-Tools) - [Hier herunterladen](https://developer.android.com/studio).
- Die **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
- Oder **Android Studio** (mit Android SDK tools) - [Download here](https://developer.android.com/studio).
In Windows (in meinem Fall) **nach der Installation von Android Studio** hatte ich die **SDK-Tools installiert in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
Unter Windows (in meinem Fall) hatte ich **nach der Installation von Android Studio** die **SDK Tools installiert in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
In mac können Sie **die SDK-Tools herunterladen** und sie im PATH haben, indem Sie Folgendes ausführen:
Auf macOS kannst du die **SDK tools herunterladen** und sie dem PATH hinzufügen, indem du folgendes ausführst:
```bash
brew tap homebrew/cask
brew install --cask android-sdk
```
Oder über die **Android Studio GUI**, wie in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) angegeben, die sie in `~/Library/Android/sdk/cmdline-tools/latest/bin/` und `~/Library/Android/sdk/platform-tools/` und `~/Library/Android/sdk/emulator/` installieren wird.
Oder über die **Android Studio GUI**, wie in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) angegeben, welche sie in `~/Library/Android/sdk/cmdline-tools/latest/bin/` und `~/Library/Android/sdk/platform-tools/` und `~/Library/Android/sdk/emulator/` installiert.
Für die Java-Probleme:
```java
@ -28,7 +28,7 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
### Virtuelle Maschine vorbereiten
Wenn Sie Android Studio installiert haben, können Sie einfach die Hauptprojektansicht öffnen und auf: _**Tools**_ --> _**AVD Manager.**_
If you installed Android Studio, you can just open the main project view and access: _**Tools**_ --> _**AVD Manager.**_
<div align="center" data-full-width="false">
@ -36,38 +36,38 @@ Wenn Sie Android Studio installiert haben, können Sie einfach die Hauptprojekta
</div>
Klicken Sie dann auf _**Create Virtual Device**_
Then, click on _**Create Virtual Device**_
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
_**Wählen Sie** das Telefon aus, das Sie verwenden möchten_ und klicken Sie auf _**Next.**_
_**select** the phone you want to use_ and click on _**Next.**_
> [!WARNING]
> Wenn Sie ein Telefon mit installiertem Play Store benötigen, wählen Sie eines mit dem Play Store-Symbol aus!
> Wenn du ein Telefon mit installiertem Play Store benötigst, wähle eines mit dem Play Store-Symbol darauf!
>
> <img src="../../images/image (1144).png" alt="" data-size="original">
In der aktuellen Ansicht können Sie **das Android-Image auswählen und herunterladen**, das das Telefon ausführen wird:
In dieser Ansicht kannst du das **Android-Image auswählen und herunterladen**, das das Telefon ausführen wird:
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
Wählen Sie es aus, und wenn es nicht heruntergeladen ist, klicken Sie auf das _**Download**_-Symbol neben dem Namen (**warten Sie jetzt, bis das Image heruntergeladen ist).**\
Sobald das Image heruntergeladen ist, wählen Sie einfach **`Next`** und **`Finish`**.
Wähle es aus und falls es noch nicht heruntergeladen ist, klicke auf das _**Download**_-Symbol neben dem Namen (**warte nun, bis das Image heruntergeladen ist**).\
Sobald das Image heruntergeladen ist, wähle einfach **`Next`** und **`Finish`**.
Die virtuelle Maschine wird erstellt. Jetzt **wird sie jedes Mal vorhanden sein, wenn Sie auf den AVD-Manager zugreifen**.
Die virtuelle Maschine wird erstellt. Nun wird sie **jedes Mal vorhanden sein, wenn du den AVD manager aufrufst**.
### Virtuelle Maschine ausführen
### Virtuelle Maschine starten
Um sie **auszuführen**, drücken Sie einfach die _**Start-Taste**_.
Um sie **zu starten**, drücke einfach den _**Start button**_.
![](<../../images/image (518).png>)
## Befehlszeilenwerkzeug
## Kommandozeilen-Tool
> [!WARNING]
> Für macOS finden Sie das `avdmanager`-Tool unter `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` und den `emulator` unter `/Users/<username>/Library/Android/sdk/emulator/emulator`, wenn Sie sie installiert haben.
> Unter macOS findest du das `avdmanager`-Tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` und den `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator`, falls du sie installiert hast.
Zunächst müssen Sie **entscheiden, welches Telefon Sie verwenden möchten**. Um die Liste der möglichen Telefone anzuzeigen, führen Sie aus:
Zuerst musst du **entscheiden, welches Telefon du verwenden möchtest**, um die Liste der möglichen Telefone zu sehen, führe aus:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
@ -95,16 +95,16 @@ Name: Nexus 10
OEM : Google
[...]
```
Sobald Sie den Namen des Geräts, das Sie verwenden möchten, festgelegt haben, müssen Sie **entscheiden, welches Android-Image Sie auf diesem Gerät ausführen möchten.**\
Sobald Sie den Namen des Geräts festgelegt haben, das Sie verwenden möchten, müssen Sie **entscheiden, welches Android-Image Sie auf diesem Gerät ausführen möchten.**\
Sie können alle Optionen mit `sdkmanager` auflisten:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
```
Und **lade** die eine (oder alle), die du verwenden möchtest, mit:
Und **lade** die eine (oder alle) herunter, die du verwenden möchtest:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
```
Sobald Sie das Android-Image heruntergeladen haben, das Sie verwenden möchten, können Sie **alle heruntergeladenen Android-Images auflisten** mit:
Sobald Sie das Android-Image heruntergeladen haben, das Sie verwenden möchten, können Sie mit folgendem Befehl **alle heruntergeladenen Android-Images auflisten**:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
----------
@ -120,12 +120,11 @@ Type: Platform
API level: 29
Revision: 4
```
In diesem Moment haben Sie das Gerät ausgewählt, das Sie verwenden möchten, und das Android-Image heruntergeladen, sodass **Sie die virtuelle Maschine mit**: erstellen können.
Zu diesem Zeitpunkt haben Sie das Gerät, das Sie verwenden möchten, ausgewählt und das Android-Image heruntergeladen. Sie können daher **die virtuelle Maschine wie folgt erstellen**:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
```
Im letzten Befehl **habe ich eine VM mit dem Namen** "_AVD9_" unter Verwendung des **Geräts** "_Nexus 5X_" und des **Android-Images** "_system-images;android-28;google_apis;x86_64_" **erstellt**.\
Jetzt können Sie **die virtuellen Maschinen**, die Sie erstellt haben, mit folgendem Befehl auflisten:
Im letzten Befehl **habe ich eine VM namens** "_AVD9_" unter Verwendung des **Geräts** "_Nexus 5X_" und des **Android-Images** "_system-images;android-28;google_apis;x86_64_".\ Jetzt kannst du **die von dir erstellten virtuellen Maschinen auflisten** mit:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
@ -140,76 +139,131 @@ Name: Pixel_2_API_27
Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
Error: Google pixel_2 no longer exists as a device
```
### Virtuelle Maschine ausführen
### Virtuelle Maschine starten
> [!WARNING]
> Für macOS finden Sie das `avdmanager`-Tool unter `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` und den `emulator` unter `/Users/<username>/Library/Android/sdk/emulator/emulator`, wenn Sie diese installiert haben.
> Für macOS findest du das `avdmanager`-Tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` und den `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator`, falls du sie installiert hast.
Wir haben bereits gesehen, wie Sie die erstellten virtuellen Maschinen auflisten können, aber **Sie können sie auch auflisten mit**:
Wir haben bereits gesehen, wie du die erstellten virtuellen Maschinen auflisten kannst, aber **du kannst sie auch mit folgendem Befehl auflisten**:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
AVD9
Pixel_2_API_27
```
Sie können einfach **jede erstellte virtuelle Maschine ausführen** mit:
Du kannst einfach **jede erstellte virtuelle Maschine** mit folgendem Befehl starten:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
```
Oder indem Sie fortgeschrittenere Optionen verwenden, können Sie eine virtuelle Maschine wie:
Oder mit fortgeschritteneren Optionen können Sie eine virtuelle Maschine wie folgt ausführen:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
### Befehlszeilenoptionen
Es gibt jedoch **eine Menge nützlicher Befehlszeilenoptionen**, die Sie verwenden können, um eine virtuelle Maschine zu starten. Unten finden Sie einige interessante Optionen, aber Sie können [**eine vollständige Liste hier finden**](https://developer.android.com/studio/run/emulator-commandline)
Es gibt jedoch **viele verschiedene nützliche Befehlszeilenoptionen**, die du verwenden kannst, um eine virtuelle Maschine zu starten. Nachfolgend findest du einige interessante Optionen, eine vollständige Liste kannst du [**hier finden**](https://developer.android.com/studio/run/emulator-commandline)
**Boot**
- `-snapshot name` : VM-Snapshot starten
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Alle aufgezeichneten Snapshots auflisten
- `-snapshot name` : Start VM snapshot
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : List all the snapshots recorded
**Netzwerk**
- `-dns-server 192.0.2.0, 192.0.2.255` : Ermöglicht die Angabe von durch Kommas getrennten DNS-Servern für die VM.
- **`-http-proxy 192.168.1.12:8080`** : Ermöglicht die Angabe eines HTTP-Proxys (sehr nützlich, um den Verkehr mit Burp zu erfassen)
- Wenn die Proxy-Einstellungen aus irgendeinem Grund nicht funktionieren, versuchen Sie, sie intern oder mit einer Anwendung wie "Super Proxy" oder "ProxyDroid" zu konfigurieren.
- `-netdelay 200` : Setzt die Netzwerkverzögerungsemulation in Millisekunden.
- `-port 5556` : Setzt die TCP-Portnummer, die für die Konsole und adb verwendet wird.
- `-ports 5556,5559` : Setzt die TCP-Ports, die für die Konsole und adb verwendet werden.
- **`-tcpdump /path/dumpfile.cap`** : Erfasst den gesamten Verkehr in einer Datei
- `-dns-server 192.0.2.0, 192.0.2.255` : Ermöglicht das Komma-getrennte Angeben der DNS-Server für die VM.
- **`-http-proxy 192.168.1.12:8080`** : Ermöglicht das Angeben eines HTTP-Proxys zur Nutzung (sehr nützlich, um den Traffic mit Burp zu erfassen)
- Wenn die Proxy-Einstellungen aus irgendeinem Grund nicht funktionieren, versuche sie intern zu konfigurieren oder eine Anwendung wie "Super Proxy" oder "ProxyDroid" zu verwenden.
- `-netdelay 200` : Setzt die Netzwerklatenz-Emulation in Millisekunden.
- `-port 5556` : Legt die TCP-Portnummer fest, die für die Konsole und adb verwendet wird.
- `-ports 5556,5559` : Legt die TCP-Ports fest, die für die Konsole und adb verwendet werden.
- **`-tcpdump /path/dumpfile.cap`** : Erfasst den gesamten Datenverkehr in einer Datei
**System**
- `-selinux {disabled|permissive}` : Setzt das Security-Enhanced Linux-Sicherheitsmodul entweder auf deaktiviert oder permissiv auf einem Linux-Betriebssystem.
- `-timezone Europe/Paris` : Setzt die Zeitzone für das virtuelle Gerät
- `-screen {touch(default)|multi-touch|o-touch}` : Setzt den emulierten Touchscreen-Modus.
- **`-writable-system`** : Verwenden Sie diese Option, um während Ihrer Emulationssitzung ein beschreibbares Systemabbild zu haben. Sie müssen auch `adb root; adb remount` ausführen. Dies ist sehr nützlich, um ein neues Zertifikat im System zu installieren.
- `-selinux {disabled|permissive}` : Setzt das Security-Enhanced Linux Security-Modul entweder auf disabled oder permissive Modus unter einem Linux-Betriebssystem.
- `-timezone Europe/Paris` : Legt die Zeitzone für das virtuelle Gerät fest
- `-screen {touch(default)|multi-touch|o-touch}` : Legt den emulierten Touchscreen-Modus fest.
- **`-writable-system`** : Verwende diese Option, um während deiner Emulationssitzung ein beschreibbares System-Image zu haben. Du musst außerdem `adb root; adb remount` ausführen. Das ist sehr nützlich, um ein neues Zertifikat im System zu installieren.
## Rooten eines Play Store-Geräts
## Linux-CLI-Einrichtung (SDK/AVD quickstart)
Wenn Sie ein Gerät mit Play Store heruntergeladen haben, können Sie nicht direkt Root erhalten, und Sie erhalten diese Fehlermeldung
Die offiziellen CLI-Tools machen es einfach, schnelle, debugbare Emulatoren zu erstellen, ohne Android Studio.
```bash
# Directory layout
mkdir -p ~/Android/cmdline-tools/latest
# Download commandline tools (Linux)
wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
rm /tmp/cmdline-tools.zip
# Env vars (add to ~/.bashrc or ~/.zshrc)
export ANDROID_HOME=$HOME/Android
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH
# Install core SDK components
sdkmanager --install "platform-tools" "emulator"
# Install a debuggable x86_64 system image (Android 11 / API 30)
sdkmanager --install "system-images;android-30;google_apis;x86_64"
# Create an AVD and run it with a writable /system & snapshot name
avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap
# Verify root (debuggable images allow `adb root`)
adb root
adb shell whoami # expect: root
```
Hinweise
- System-Image-Varianten: google_apis (debugfähig, ermöglicht `adb root`), google_apis_playstore (nicht rootbar), aosp/default (leichtgewichtig).
- Build-Typen: userdebug erlaubt oft `adb root` auf debug-fähigen Images. Play Store-Images sind Produktions-Builds und verhindern Root.
- Auf x86_64-Hosts wird die Full-System-ARM64-Emulation ab API 28+ nicht unterstützt. Für Android 11+ verwende Google APIs/Play-Images, die pro-App ARM-to-x86-Translation enthalten, um viele ARM-only-Apps schnell auszuführen.
### Snapshots von der CLI
```bash
# Save a clean snapshot from the running emulator
adb -s emulator-5554 emu avd snapshot save my_clean_setup
# Boot from a named snapshot (if it exists)
emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
```
## ARM→x86 Binärübersetzung (Android 11+)
Google APIs und Play Store-Images unter Android 11+ können ARM-App-Binaries pro Prozess übersetzen, während der Rest des Systems nativ x86/x86_64 bleibt. Das ist oft schnell genug, um viele ARM-only Apps auf dem Desktop zu testen.
> Tipp: Bevorzuge Google APIs x86/x86_64-Images während pentests. Play-Images sind praktisch, blockieren aber `adb root`; verwende sie nur, wenn du speziell Play services benötigst und das Fehlen von root akzeptierst.
## Rooting eines Play Store-Geräts
Wenn du ein Gerät mit Play Store heruntergeladen hast, wirst du nicht direkt root erhalten können, und du bekommst diese Fehlermeldung
```
$ adb root
adbd cannot run as root in production builds
```
Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) konnte ich es rooten (folgen Sie zum Beispiel [**diesem Video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **oder** [**diesem hier**](https://www.youtube.com/watch?v=qQicUW0svB8)).
Mit [rootAVD](https://github.com/newbit1/rootAVD) und [Magisk](https://github.com/topjohnwu/Magisk) konnte ich es rooten (siehe zum Beispiel [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **oder** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)).
## Burp-Zertifikat installieren
Überprüfen Sie die folgende Seite, um zu lernen, wie man ein benutzerdefiniertes CA-Zertifikat installiert:
Siehe die folgende Seite, um zu erfahren, wie man ein benutzerdefiniertes CA-Zertifikat installiert:
{{#ref}}
install-burp-certificate.md
{{#endref}}
## Nette AVD-Optionen
## Nützliche AVD-Optionen
### Snapshot erstellen
Sie können **die GUI** verwenden, um jederzeit einen Snapshot der VM zu erstellen:
Du kannst die **GUI** verwenden, um jederzeit einen Snapshot der VM zu erstellen:
![](<../../images/image (234).png>)
## Referenzen
- [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)
- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)
{{#include ../../banners/hacktricks-training.md}}

95
src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
View File

@ -10,16 +10,69 @@ Installiere **frida tools**:
pip install frida-tools
pip install frida
```
**Laden Sie den **frida server** auf Android herunter und installieren Sie ihn** ([Laden Sie die neueste Version herunter](https://github.com/frida/frida/releases)).\
Einzeiler, um adb im Root-Modus neu zu starten, sich damit zu verbinden, frida-server hochzuladen, Ausführungsberechtigungen zu erteilen und es im Hintergrund auszuführen:
**Download und installiere** auf dem Android-Gerät den **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
Einzeiler, um adb im Root-Modus neu zu starten, eine Verbindung zu ihm herzustellen, frida-server hochzuladen, Ausführungsrechte zu vergeben und ihn im Hintergrund auszuführen:
```bash
adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
```
**Überprüfen** Sie, ob es **funktioniert**:
**Überprüfe** ob es **funktioniert**:
```bash
frida-ps -U #List packages and processes
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
```
## Frida server vs. Gadget (root vs. no-root)
Zwei gängige Wege, Android-Apps mit Frida zu instrumentieren:
- Frida server (rooted devices): Einen nativen Daemon aufspielen und ausführen, der es ermöglicht, sich an jeden Prozess anzuhängen.
- Frida Gadget (no root): Frida als Shared Library in die APK einbinden und sie automatisch im Zielprozess laden.
Frida server (rooted)
```bash
# Download the matching frida-server binary for your device's arch
# https://github.com/frida/frida/releases
adb root
adb push frida-server-<ver>-android-<arch> /data/local/tmp/frida-server
adb shell chmod 755 /data/local/tmp/frida-server
adb shell /data/local/tmp/frida-server & # run at boot via init/magisk if desired
# From host, list processes and attach
frida-ps -Uai
frida -U -n com.example.app
```
Frida Gadget (no-root)
1) APK entpacken, das Gadget .so und die Config hinzufügen:
- Lege libfrida-gadget.so in lib/<abi>/ ab (z. B. lib/arm64-v8a/)
- Erstelle assets/frida-gadget.config mit deinen Einstellungen zum Laden von Scripts
Beispiel frida-gadget.config
```json
{
"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
"runtime": { "logFile": "/sdcard/frida-gadget.log" }
}
```
2) Referenziere/lade das Gadget, sodass es frühzeitig initialisiert wird:
- Am einfachsten: Füge einen kleinen Java-Stub hinzu, der System.loadLibrary("frida-gadget") in Application.onCreate() aufruft, oder verwende das bereits vorhandene native Laden von Bibliotheken.
3) APK neu packen, signieren und installieren:
```bash
apktool d app.apk -o app_m
# ... add gadget .so and config ...
apktool b app_m -o app_gadget.apk
uber-apk-signer -a app_gadget.apk -o out_signed
adb install -r out_signed/app_gadget-aligned-debugSigned.apk
```
4) Vom Host an den Gadget-Prozess anhängen:
```bash
frida-ps -Uai
frida -U -n com.example.app
```
Hinweise
- Gadget wird von einigen Schutzmechanismen erkannt; halte Namen/Pfade unauffällig und lade ihn spät/bedingt, falls nötig.
- Bei gehärteten Apps bevorzuge Tests auf gerootetem Gerät mit server + late attach, oder kombiniere das mit Magisk/Zygisk hiding.
## Tutorials
### [Tutorial 1](frida-tutorial-1.md)
@ -28,25 +81,25 @@ frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
**Quellcode**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
**Folgen Sie dem [Link, um es zu lesen](frida-tutorial-1.md).**
**Folge dem [Link, um es zu lesen](frida-tutorial-1.md).**
### [Tutorial 2](frida-tutorial-2.md)
**Von**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Teile 2, 3 & 4)\
**APKs und Quellcode**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**Von**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\
**APKs and Source code**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**Folgen Sie dem [Link, um es zu lesen.](frida-tutorial-2.md)**
**Folge dem [Link, um es zu lesen.](frida-tutorial-2.md)**
### [Tutorial 3](owaspuncrackable-1.md)
**Von**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk)
**Folgen Sie dem [Link, um es zu lesen](owaspuncrackable-1.md).**
**Folge dem [Link, um es zu lesen](owaspuncrackable-1.md).**
**Sie finden hier weitere großartige Frida-Skripte:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
**Du findest weitere Awesome Frida scripts hier:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
## Quick Examples
## Schnelle Beispiele
### Frida von der Kommandozeile aufrufen
```bash
@ -72,7 +125,7 @@ print('[ * ] Running Frida Demo application')
script.load()
sys.stdin.read()
```
### Funktionen ohne Parameter hooken
### Hooking von Funktionen ohne Parameter
Hook die Funktion `a()` der Klasse `sg.vantagepoint.a.c`
```javascript
@ -115,9 +168,9 @@ send("Activity HIT!!!")
var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
}
```
### Funktionen mit Parametern hooken und den Wert abrufen
### Hooking von Funktionen mit Parametern und Auslesen des Werts
Eine Entschlüsselungsfunktion hooken. Den Input ausgeben, die ursprüngliche Funktion aufrufen, um den Input zu entschlüsseln, und schließlich die unverschlüsselten Daten ausgeben:
Hooking einer decryption-Funktion. Gib die Eingabe aus, rufe die originale Funktion auf, decrypt die Eingabe und gib schließlich die Klartextdaten aus:
```javascript
function getString(data) {
var ret = ""
@ -142,9 +195,9 @@ send("Decrypted flag: " + flag)
return ret //[B
}
```
### Funktionen hooken und sie mit unserem Input aufrufen
### Hooking von Funktionen und Aufruf mit unserem Input
Hooken Sie eine Funktion, die einen String empfängt, und rufen Sie sie mit einem anderen String auf (von [hier](https://11x256.github.io/Frida-hooking-android-part-2/))
Hook eine Funktion, die einen string entgegennimmt, und rufe sie mit einem anderen string auf (aus [here](https://11x256.github.io/Frida-hooking-android-part-2/))
```javascript
var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class
@ -159,9 +212,9 @@ return ret
```
### Zugriff auf ein bereits erstelltes Objekt einer Klasse
Wenn Sie ein Attribut eines erstellten Objekts extrahieren möchten, können Sie dies verwenden.
Wenn du ein Attribut eines bereits erstellten Objekts extrahieren möchtest, kannst du Folgendes verwenden.
In diesem Beispiel sehen Sie, wie Sie das Objekt der Klasse my_activity erhalten und wie Sie die Funktion .secret() aufrufen, die ein privates Attribut des Objekts ausgibt:
In diesem Beispiel siehst du, wie man das Objekt der Klasse my_activity bekommt und die Funktion .secret() aufruft, die ein privates Attribut des Objekts ausgibt:
```javascript
Java.choose("com.example.a11x256.frida_test.my_activity", {
onMatch: function (instance) {
@ -175,7 +228,13 @@ onComplete: function () {},
## Weitere Frida-Tutorials
- [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
- [Teil 1 der Blogreihe zu fortgeschrittenem Frida-Gebrauch: IOS-Verschlüsselungsbibliotheken](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
## Referenzen
- [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)
- [Frida Gadget documentation](https://frida.re/docs/gadget/)
- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
{{#include ../../../banners/hacktricks-training.md}}

74
src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
View File

@ -1,20 +1,32 @@
# Installiere Burp-Zertifikat
# Burp-Zertifikat installieren
{{#include ../../banners/hacktricks-training.md}}
## Auf einer virtuellen Maschine
## Systemweiter Proxy über ADB
Zuerst musst du das Der-Zertifikat von Burp herunterladen. Du kannst dies in _**Proxy**_ --> _**Optionen**_ --> _**CA-Zertifikat importieren/exportieren**_
Konfiguriere einen globalen HTTP-Proxy, sodass alle Apps ihren Traffic über deinen Interceptor (Burp/mitmproxy) leiten:
```bash
# Set proxy (device/emulator must reach your host IP)
adb shell settings put global http_proxy 192.168.1.2:8080
# Clear proxy
adb shell settings put global http_proxy :0
```
Tipp: Binde in Burp deinen Listener an 0.0.0.0, damit Geräte im LAN sich verbinden können (Proxy -> Options -> Proxy Listeners).
## In einer virtuellen Maschine
Zuerst musst du das DER-Zertifikat aus Burp herunterladen. Das geht unter _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
![](<../../images/image (367).png>)
**Exportiere das Zertifikat im Der-Format** und lass uns **es** in eine Form **transformieren**, die **Android** **verstehen** kann. Beachte, dass du **um das Burp-Zertifikat auf der Android-Maschine in AVD zu konfigurieren**, diese Maschine **mit** der **`-writable-system`** Option **ausführen** musst.\
Zum Beispiel kannst du es so ausführen:
**Exportiere das Zertifikat im DER-Format** und konvertiere es in ein Format, das **Android** verstehen kann. Beachte, dass du **um das Burp-Zertifikat auf der Android-Maschine im AVD zu konfigurieren**, diese Maschine **mit** der Option **`-writable-system`** **starten** musst.\
Zum Beispiel kannst du sie so starten:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
Dann, um **das Zertifikat von Burp zu konfigurieren, tun Sie**:
Dann, um **das Burp-Zertifikat zu konfigurieren**, führe Folgendes aus:
```bash
openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
adb reboot #Now, reboot the machine
```
Sobald die **Maschine mit dem Neustart fertig ist**, wird das Burp-Zertifikat verwendet!
Sobald die **machine finish rebooting** das System neu gestartet hat, wird das Burp-Zertifikat von ihm verwendet!
## Verwendung von Magisc
## Using Magisc
Wenn Sie Ihr **Gerät mit Magisc gerootet haben** (vielleicht ein Emulator) und Sie die vorherigen **Schritte** zur Installation des Burp-Zertifikats nicht **befolgen können**, weil das **Dateisystem schreibgeschützt** ist und Sie es nicht beschreibbar remounten können, gibt es einen anderen Weg.
Wenn du dein Gerät **mit Magisc gerootet** hast (vielleicht ein Emulator) und du die vorherigen **Schritte** zum Installieren des Burp-Zertifikats **nicht ausführen kannst**, weil das **Filesystem read-only** ist und du es nicht als schreibbar remounten kannst, gibt es eine andere Möglichkeit.
In [**diesem Video**](https://www.youtube.com/watch?v=qQicUW0svB8) müssen Sie:
Erklärt in [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) musst du:
1. **Ein CA-Zertifikat installieren**: Ziehen Sie einfach das DER Burp-Zertifikat **und ändern Sie die Erweiterung** in `.crt` auf dem Mobilgerät, sodass es im Downloads-Ordner gespeichert wird, und gehen Sie zu `Zertifikat installieren` -> `CA-Zertifikat`
1. **Install a CA certificate**: Ziehe per **drag&drop** das DER Burp-Zertifikat und **ändere die Erweiterung** zu `.crt`, sodass es im mobilen Gerät im Downloads-Ordner gespeichert wird, und gehe zu `Install a certificate` -> `CA certificate`
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
- Überprüfen Sie, ob das Zertifikat korrekt gespeichert wurde, indem Sie zu `Vertrauenswürdige Anmeldeinformationen` -> `BENUTZER` gehen
- Prüfe, dass das Zertifikat korrekt gespeichert wurde, indem du zu `Trusted credentials` -> `USER` gehst
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
2. **Es systemvertrauenswürdig machen**: Laden Sie das Magisc-Modul [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (eine .zip-Datei) herunter, **ziehen Sie es** auf das Telefon, gehen Sie zur **Magics-App** auf dem Telefon in den **`Module`**-Bereich, klicken Sie auf **`Von Speicher installieren`**, wählen Sie das `.zip`-Modul aus und starten Sie das Telefon nach der Installation **neu**:
2. **Make it System trusted**: Lade das Magisc-Modul [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (eine .zip-Datei) herunter, **drag&drop** es auf das Telefon, öffne die Magics-App auf dem Telefon im Bereich `Modules`, klicke auf `Install from storage`, wähle das `.zip`-Modul aus und starte das Telefon nach der Installation **neu**:
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
- Nach dem Neustart gehen Sie zu `Vertrauenswürdige Anmeldeinformationen` -> `SYSTEM` und überprüfen Sie, ob das Postswigger-Zertifikat vorhanden ist
- Nach dem Neustart gehe zu `Trusted credentials` -> `SYSTEM` und überprüfe, ob das Postswigger-Zertifikat vorhanden ist
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
## Nach Android 14
### Learn how to create a Magisc module
In der neuesten Android 14-Version wurde ein signifikanter Wandel im Umgang mit systemvertrauenswürdigen Zertifizierungsstellen (CA)-Zertifikaten beobachtet. Zuvor waren diese Zertifikate in **`/system/etc/security/cacerts/`** untergebracht, die von Benutzern mit Root-Rechten zugänglich und modifizierbar waren, was eine sofortige Anwendung im gesamten System ermöglichte. Mit Android 14 wurde der Speicherort jedoch in **`/apex/com.android.conscrypt/cacerts`** verschoben, ein Verzeichnis innerhalb des **`/apex`**-Pfades, das von Natur aus unveränderlich ist.
Sieh dir an: [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
Versuche, den **APEX cacerts-Pfad** als beschreibbar zu remounten, scheitern, da das System solche Operationen nicht zulässt. Selbst Versuche, das Verzeichnis mit einem temporären Dateisystem (tmpfs) zu unmounten oder zu überlagern, umgehen nicht die Unveränderlichkeit; Anwendungen greifen weiterhin auf die ursprünglichen Zertifikatsdaten zu, unabhängig von Änderungen auf Dateisystemebene. Diese Widerstandsfähigkeit ist darauf zurückzuführen, dass die **`/apex`**-Einbindung mit PRIVATE-Propagation konfiguriert ist, was sicherstellt, dass Änderungen innerhalb des **`/apex`**-Verzeichnisses andere Prozesse nicht beeinflussen.
## Post Android 14
Die Initialisierung von Android umfasst den `init`-Prozess, der beim Start des Betriebssystems auch den Zygote-Prozess initiiert. Dieser Prozess ist verantwortlich für das Starten von Anwendungsprozessen mit einem neuen Einhänge-Namensraum, der eine private **`/apex`**-Einbindung umfasst, wodurch Änderungen an diesem Verzeichnis von anderen Prozessen isoliert werden.
In der neuesten Android-14-Version wurde ein signifikanter Wandel in der Handhabung system-trusteter Certificate Authority (CA)-Zertifikate beobachtet. Früher wurden diese Zertifikate in **`/system/etc/security/cacerts/`** abgelegt, was für Benutzer mit Root-Rechten zugänglich und änderbar war und eine sofortige Anwendung im gesamten System ermöglichte. Mit Android 14 wurde der Speicherort jedoch nach **`/apex/com.android.conscrypt/cacerts`** verschoben, einem Verzeichnis innerhalb des **`/apex`**-Pfads, das von Natur aus immutable ist.
Dennoch gibt es einen Workaround für diejenigen, die die systemvertrauenswürdigen CA-Zertifikate im **`/apex`**-Verzeichnis ändern müssen. Dies beinhaltet das manuelle Remounten von **`/apex`**, um die PRIVATE-Propagation zu entfernen und es beschreibbar zu machen. Der Prozess umfasst das Kopieren des Inhalts von **`/apex/com.android.conscrypt`** an einen anderen Ort, das Unmounten des **`/apex/com.android.conscrypt`**-Verzeichnisses, um die schreibgeschützte Einschränkung zu beseitigen, und dann das Wiederherstellen des Inhalts an seinen ursprünglichen Ort innerhalb von **`/apex`**. Dieser Ansatz erfordert schnelles Handeln, um Systemabstürze zu vermeiden. Um eine systemweite Anwendung dieser Änderungen sicherzustellen, wird empfohlen, den `system_server` neu zu starten, was effektiv alle Anwendungen neu startet und das System in einen konsistenten Zustand bringt.
Versuche, den **APEX cacerts path** als schreibbar zu remounten, schlagen fehl, da das System solche Operationen nicht zulässt. Selbst Versuche, das Verzeichnis zu unmounten oder mit einem temporären Dateisystem (tmpfs) zu überlagern, umgehen die Unveränderlichkeit nicht; Anwendungen greifen weiterhin auf die ursprünglichen Zertifikatdaten zu, unabhängig von Änderungen auf Dateisystemebene. Diese Belastbarkeit liegt daran, dass der **`/apex`**-Mount mit PRIVATE propagation konfiguriert ist, wodurch Änderungen innerhalb des **`/apex`**-Verzeichnisses andere Prozesse nicht beeinflussen.
Die Initialisierung von Android beinhaltet den `init`-Prozess, der beim Start des Betriebssystems auch den Zygote-Prozess startet. Dieser Prozess ist dafür verantwortlich, Anwendungsprozesse mit einem neuen Mount-Namespace zu starten, der einen privaten **`/apex`**-Mount enthält und somit Änderungen an diesem Verzeichnis von anderen Prozessen isoliert.
Dennoch existiert ein Workaround für diejenigen, die die system-trusteten CA-Zertifikate im **`/apex`**-Verzeichnis ändern müssen. Dieser besteht darin, **`/apex`** manuell so zu remounten, dass die PRIVATE propagation entfernt wird, und es damit schreibbar zu machen. Der Prozess umfasst das Kopieren des Inhalts von **`/apex/com.android.conscrypt`** an einen anderen Ort, das Unmounten des Verzeichnisses **`/apex/com.android.conscrypt`**, um die Read-only-Einschränkung zu beseitigen, und anschließend das Wiederherstellen des Inhalts an seinem ursprünglichen Ort innerhalb von **`/apex`**. Dieser Ansatz erfordert schnelles Handeln, um Systemabstürze zu vermeiden. Um eine systemweite Anwendung dieser Änderungen sicherzustellen, wird empfohlen, den `system_server` neu zu starten, was effektiv alle Anwendungen neu startet und das System in einen konsistenten Zustand bringt.
```bash
# Create a separate temp directory, to hold the current certificates
# Otherwise, when we add the mount we can't read the current certs anymore.
@ -115,28 +131,28 @@ wait # Launched in parallel - wait for completion here
echo "System certificate injected"
```
### Bind-Mounting durch NSEnter
### Bind-mounting through NSEnter
1. **Einrichtungs eines beschreibbaren Verzeichnisses**: Zunächst wird ein beschreibbares Verzeichnis eingerichtet, indem ein `tmpfs` über das vorhandene nicht-APEX-Systemzertifikatsverzeichnis gemountet wird. Dies wird mit dem folgenden Befehl erreicht:
1. **Einrichten eines beschreibbaren Verzeichnisses**: Zunächst wird ein beschreibbares Verzeichnis eingerichtet, indem ein `tmpfs` über das bestehende non-APEX System-Zertifikatsverzeichnis gemountet wird. Dies wird mit dem folgenden Befehl erreicht:
```bash
mount -t tmpfs tmpfs /system/etc/security/cacerts
```
2. **Vorbereiten der CA-Zertifikate**: Nach der Einrichtung des beschreibbaren Verzeichnisses sollten die CA-Zertifikate, die man verwenden möchte, in dieses Verzeichnis kopiert werden. Dies kann das Kopieren der Standardzertifikate aus `/apex/com.android.conscrypt/cacerts/` beinhalten. Es ist wichtig, die Berechtigungen und SELinux-Labels dieser Zertifikate entsprechend anzupassen.
3. **Bind-Mounting für Zygote**: Mit `nsenter` betritt man den Mount-Namespace von Zygote. Zygote, der Prozess, der für das Starten von Android-Anwendungen verantwortlich ist, benötigt diesen Schritt, um sicherzustellen, dass alle fortan gestarteten Anwendungen die neu konfigurierten CA-Zertifikate verwenden. Der verwendete Befehl ist:
2. **Vorbereiten der CA-Zertifikate**: Nachdem das beschreibbare Verzeichnis eingerichtet wurde, sollten die CA-Zertifikate, die verwendet werden sollen, in dieses Verzeichnis kopiert werden. Dies kann das Kopieren der Standardzertifikate aus `/apex/com.android.conscrypt/cacerts/` beinhalten. Es ist wichtig, die Berechtigungen und SELinux-Labels dieser Zertifikate entsprechend anzupassen.
3. **Bind-Mounting für Zygote**: Mit `nsenter` tritt man in das Mount-Namespace von Zygote ein. Zygote, der Prozess, der für das Starten von Android-Anwendungen verantwortlich ist, erfordert diesen Schritt, um sicherzustellen, dass alle künftig gestarteten Anwendungen die neu konfigurierten CA-Zertifikate verwenden. Der verwendete Befehl lautet:
```bash
nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
Dies stellt sicher, dass jede neu gestartete App den aktualisierten CA-Zertifikats-Setup entspricht.
Dies stellt sicher, dass jede neu gestartete App die aktualisierte CA certificates-Einrichtung verwendet.
4. **Änderungen auf laufende Apps anwenden**: Um die Änderungen auf bereits laufende Anwendungen anzuwenden, wird `nsenter` erneut verwendet, um in den Namespace jeder App einzutreten und eine ähnliche Bind-Mount durchzuführen. Der notwendige Befehl ist:
4. **Änderungen auf bereits laufende Apps anwenden**: Um die Änderungen auf bereits laufende Anwendungen anzuwenden, wird erneut `nsenter` verwendet, um in den Namespace jeder App einzeln zu wechseln und einen ähnlichen bind mount durchzuführen. Der notwendige Befehl lautet:
```bash
nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
5. **Alternative Ansatz - Soft Reboot**: Ein alternativer Ansatz besteht darin, das Bind-Mount auf dem `init`-Prozess (PID 1) durchzuführen, gefolgt von einem Soft-Reboot des Betriebssystems mit den `stop && start`-Befehlen. Dieser Ansatz würde die Änderungen über alle Namespaces propagieren und die Notwendigkeit vermeiden, jede laufende App einzeln anzusprechen. Dieser Ansatz wird jedoch im Allgemeinen weniger bevorzugt, da das Neustarten unpraktisch ist.
5. **Alternative Vorgehensweise - Soft Reboot**: Eine alternative Methode besteht darin, den bind mount am `init`-Prozess (PID 1) durchzuführen, gefolgt von einem Soft Reboot des Betriebssystems mit den Befehlen `stop && start`. Dieser Ansatz würde die Änderungen auf alle Namespaces übertragen und die Notwendigkeit vermeiden, jede laufende App einzeln zu adressieren. Diese Methode wird jedoch allgemein weniger bevorzugt, da der Neustart unpraktisch ist.
## References
- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
## Referenzen
- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
- [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)
{{#include ../../banners/hacktricks-training.md}}