mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/mobile-pentesting/android-app-pentesting/frida-tuto
This commit is contained in:
Translator
parent
a8498c01d9
commit
ffc2678fa4
@ -1,10 +1,10 @@
|
||||
# Aplikacje Android Pentesting
|
||||
# Pentesting aplikacji Androidowych
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Podstawy aplikacji Android
|
||||
## Podstawy aplikacji Androidowych
|
||||
|
||||
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**:
|
||||
Zaleca się rozpoczęcie od przeczytania tej strony, aby poznać **najważniejsze elementy związane z bezpieczeństwem Androida oraz najniebezpieczniejsze komponenty aplikacji Androidowych**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -13,24 +13,24 @@ android-applications-basics.md
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
To jest główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem android (emulowanym lub fizycznym).\
|
||||
**ADB** pozwala kontrolować urządzenia zarówno przez **USB** jak i **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obu kierunkach, **instalację** i **deinstalację** aplikacji, **wykonywanie** poleceń shell, **backup** danych, **odczyt** logów, oraz inne funkcje.
|
||||
To główne narzędzie potrzebne do połączenia z urządzeniem z Androidem (emulowanym lub fizycznym).\
|
||||
**ADB** pozwala kontrolować urządzenia zarówno przez **USB**, jak i **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obu kierunkach, **instalację** i **odinstalację** aplikacji, **wykonywanie** poleceń shell, **tworzenie kopii zapasowych** danych, **odczytywanie** logów oraz inne funkcje.
|
||||
|
||||
Rzuć okiem na następującą listę [**ADB Commands**](adb-commands.md), aby nauczyć się jak 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 obfuskowane hasła lub flagi). W takim wypadku może być przydatne zdekompilowanie apk, modyfikacja kodu i ponowna kompilacja.\
|
||||
[**W tym samouczku** możesz **nauczyć się jak zdekompilować APK, zmodyfikować kod Smali i ponownie skompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo użyteczne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**.
|
||||
Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. mocno zamaskowanych haseł lub flag). W takim przypadku może być interesujące zdekompilować APK, zmodyfikować kod i skompilować go ponownie.\
|
||||
[**W tym tutorialu** możesz **nauczyć się, jak zdekompilować APK, zmodyfikować kod Smali i ponownie skompilować APK** z nową funkcjonalnością](smali-changes.md). To może być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**.
|
||||
|
||||
## Inne interesujące triki
|
||||
## Inne ciekawe triki
|
||||
|
||||
- [Fałszowanie lokalizacji w Play Store](spoofing-your-location-in-play-store.md)
|
||||
- [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)
|
||||
- [Wykorzystywanie niebezpiecznych mechanizmów In-App Update](insecure-in-app-update-rce.md)
|
||||
- [Wykorzystywanie Accessibility Services (Android RAT)](accessibility-services-abuse.md)
|
||||
- **Pobieranie APKów**: [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:
|
||||
- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
|
||||
- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
|
||||
- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- Wyodrębnianie APK z urządzenia:
|
||||
```bash
|
||||
adb shell pm list packages
|
||||
com.android.insecurebankv2
|
||||
@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
|
||||
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
```
|
||||
- Połącz wszystkie splits i base apks za pomocą [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Scal wszystkie splits i base apks za pomocą [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
```bash
|
||||
mkdir splits
|
||||
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
|
||||
@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
## Analiza statyczna
|
||||
|
||||
Po pierwsze, aby analizować APK powinieneś **przejrzeć kod Java** używając dekompilatora.\
|
||||
Proszę, [**read here to find information about different available decompilers**](apk-decompilers.md).
|
||||
Przede wszystkim, analizując APK powinieneś **przejrzeć kod Java** przy użyciu dekompilera.\
|
||||
Proszę, [**przeczytaj tutaj, aby znaleźć informacje o dostępnych dekompilatorach**](apk-decompilers.md).
|
||||
|
||||
### Poszukiwanie ciekawych informacji
|
||||
### Szukanie interesujących informacji
|
||||
|
||||
Już samo przejrzenie **strings** w APK pozwala szukać **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i wszystkiego interesującego... sprawdź nawet obecność wykonania kodu **backdoors** lub uwierzytelniających backdoorów (hardcoded admin credentials to the app).
|
||||
Już samo spojrzenie na **strings** w APK pozwala wyszukać **hasła**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i wszystko interesujące... szukaj nawet kodu wykonawczego — **backdoors** lub backdoorów uwierzytelniania (twardo zakodowane poświadczenia administratora w aplikacji).
|
||||
|
||||
**Firebase**
|
||||
|
||||
Zwróć szczególną uwagę na **firebase URLs** i sprawdź, czy jest źle skonfigurowany. [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 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)
|
||||
|
||||
### Podstawowe zrozumienie aplikacji - Manifest.xml, strings.xml
|
||||
|
||||
**Przegląd plików _Manifest.xml_ i **_strings.xml_** aplikacji może ujawnić potencjalne luki bezpieczeństwa**. Do tych plików można uzyskać dostęp używając dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip i rozpakowując go.
|
||||
Badanie plików aplikacji _Manifest.xml_ oraz **_strings.xml_** może ujawnić potencjalne podatności bezpieczeństwa. Pliki te można uzyskać za pomocą dekompilatorów lub przez zmianę rozszerzenia pliku APK na .zip i rozpakowanie go.
|
||||
|
||||
**Podatności** wykrywane z **Manifest.xml** obejmują:
|
||||
**Podatności** zidentyfikowane na podstawie **Manifest.xml** obejmują:
|
||||
|
||||
- **Debuggable Applications**: Aplikacje ustawione jako debuggable (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ umożliwiają połączenia, które mogą prowadzić do eksploatacji. Aby lepiej zrozumieć, jak eksploatować aplikacje oznaczone jako debuggable, odnieś się do samouczka o wyszukiwaniu i eksploatowaniu debuggable aplikacji na urządzeniu.
|
||||
- **Backup Settings**: Atrybut `android:allowBackup="false"` powinien być ustawiony wyraźnie dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, szczególnie gdy włączone jest usb debugging.
|
||||
- **Network Security**: Niestandardowe konfiguracje bezpieczeństwa sieci (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak pinowanie certyfikatów i ustawienia ruchu HTTP. Przykładem może być zezwolenie na ruch HTTP dla określonych domen.
|
||||
- **Exported Activities and Services**: Identyfikacja eksportowanych aktywności i serwisów w manifeście może ujawnić komponenty, które mogą być nadużyte. Dalsza analiza podczas testów dynamicznych może pokazać sposoby ich wykorzystania.
|
||||
- **Content Providers and FileProviders**: Udostępnione content providery mogą pozwolić na nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders również powinna zostać dokładnie przeanalizowana.
|
||||
- **Broadcast Receivers and URL Schemes**: Te komponenty mogą zostać wykorzystane do eksploatacji, ze szczególną uwagą na to, jak zarządzane są URL schemes pod kątem podatności wejścia.
|
||||
- **SDK Versions**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują obsługiwane wersje Androida, podkreślając znaczenie niewspierania przestarzałych, podatnych wersji Androida ze względów bezpieczeństwa.
|
||||
- **Aplikacje z włączonym debugowaniem**: Aplikacje ustawione jako `debuggable="true"` w _Manifest.xml_ stwarzają ryzyko, ponieważ pozwalają na połączenia, które mogą doprowadzić do eksploatacji. Aby lepiej zrozumieć jak wykorzystywać aplikacje z włączonym debugowaniem, odwołaj się do tutoriala dotyczącego wyszukiwania i wykorzystywania takich aplikacji na urządzeniu.
|
||||
- **Ustawienia kopii zapasowej**: Atrybut `android:allowBackup="false"` powinien być jawnie ustawiony dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, zwłaszcza gdy włączone jest usb debugging.
|
||||
- **Bezpieczeństwo sieci**: 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 ruchu HTTP. Przykładem może być zezwolenie na ruch HTTP dla określonych domen.
|
||||
- **Exported Activities and Services**: Identyfikacja eksportowanych activities i services w manifeście może ujawnić komponenty, które mogą być nadużyte. Dalsza analiza podczas testów dynamicznych może pokazać, jak je zaatakować.
|
||||
- **Content Providers i FileProviders**: Eksponowane content providers mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders również powinna być dokładnie sprawdzona.
|
||||
- **Broadcast Receivers i schematy URL**: Te komponenty mogą być wykorzystane do ataku, ze szczególnym uwzględnieniem sposobu obsługi schematów URL pod kątem podatności na wprowadzenie danych.
|
||||
- **Wersje SDK**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują wspierane wersje Androida, podkreślając znaczenie niewspierania przestarzałych, podatnych wersji Androida ze względów bezpieczeństwa.
|
||||
|
||||
Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak API keys, custom schemas i inne notatki deweloperskie, co podkreśla potrzebę dokładnego przeglądu tych zasobów.
|
||||
Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak klucze API, custom schemas i inne uwagi deweloperskie, co podkreśla potrzebę dokładnego przeglądu tych zasobów.
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** to atak, w którym **malicious** **application** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłania ona widocznie aplikację ofiary, jej interfejs użytkownika jest zaprojektowany tak, aby oszukać użytkownika, by wchodził w interakcję z nim, podczas gdy interakcja jest przekazywana do aplikacji ofiary.\
|
||||
W efekcie, **użytkownik jest oślepiony i nie wie, że faktycznie wykonuje działania w aplikacji ofiary**.
|
||||
**Tapjacking** to atak, w którym **złośliwa aplikacja** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłoni widocznie aplikację ofiary, jej interfejs użytkownika jest zaprojektowany tak, aby oszukać użytkownika i zmusić go do interakcji, podczas gdy faktyczna interakcja jest przekazywana do aplikacji ofiary.\
|
||||
W efekcie **oszukuje się użytkownika, ukrywając fakt, że w rzeczywistości wykonuje działania w aplikacji ofiary**.
|
||||
|
||||
Find more information in:
|
||||
Znajdź więcej informacji w:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -104,82 +104,82 @@ tapjacking.md
|
||||
|
||||
### Task Hijacking
|
||||
|
||||
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** (w rezultacie użytkownik będzie wchodził w interakcję z **malicious application** myśląc, że używa prawdziwej).
|
||||
Activity z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na Task Hijacking. Oznacza to, że jeśli zainstalowana zostanie złośliwa aplikacja i uruchomiona przed prawdziwą aplikacją, może **przejąć task prawdziwej aplikacji** (użytkownik będzie wchodził w interakcję ze **złośliwą aplikacją, myśląc, że używa oryginalnej**).
|
||||
|
||||
More info in:
|
||||
Więcej informacji w:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
android-task-hijacking.md
|
||||
{{#endref}}
|
||||
|
||||
### Niezabezpieczone przechowywanie danych
|
||||
### Niepewne przechowywanie danych
|
||||
|
||||
**Pamięć wewnętrzna**
|
||||
**Internal Storage**
|
||||
|
||||
W Androidzie pliki **przechowywane** w **internal** storage są **zaprojektowane** tak, aby były **dostępne** wyłącznie dla **aplikacji**, która je **utworzyła**. Ten mechanizm bezpieczeństwa jest **wymuszony** przez system Android i zazwyczaj wystarcza do zabezpieczenia większości aplikacji. Jednak deweloperzy czasem używają trybów takich jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **pozwolić** na **udostępnianie** plików między różnymi aplikacjami. Te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe.
|
||||
W Androidzie pliki **przechowywane** w **internal** storage są **zaprojektowane** tak, aby były dostępne wyłącznie dla aplikacji, która je utworzyła. Ten mechanizm bezpieczeństwa jest **egzekwowany** przez system Android i zazwyczaj wystarcza dla potrzeb większości aplikacji. Jednak deweloperzy czasem 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ą dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe.
|
||||
|
||||
1. **Static Analysis:**
|
||||
- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie ocenione**. Te tryby **mogą potencjalnie ujawnić** pliki **niezamierzonemu lub nieautoryzowanemu dostępowi**.
|
||||
- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie sprawdzone**. Te tryby **mogą potencjalnie ujawnić** pliki niezamierzonemu lub nieautoryzowanemu dostępowi.
|
||||
2. **Dynamic Analysis:**
|
||||
- **Zweryfikuj** uprawnienia ustawione na plikach tworzonych przez aplikację. W szczególności **sprawdź**, czy jakiekolwiek pliki nie są **ustawione jako czytelne lub zapisywalne dla wszystkich**. Może to stanowić istotne ryzyko bezpieczeństwa, ponieważ pozwoliłoby **każdej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy intencji, **odczytywać lub modyfikować** te pliki.
|
||||
- **Zweryfikuj** **uprawnienia** ustawione na plikach tworzonych przez aplikację. W szczególności **sprawdź**, czy któreś pliki są **ustawione jako czytelne lub zapisywalne dla wszystkich**. To może stanowić poważne ryzyko bezpieczeństwa, ponieważ pozwoli **dowolnej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy zamiaru, **odczytać lub zmodyfikować** te pliki.
|
||||
|
||||
**Pamięć zewnętrzna**
|
||||
**External Storage**
|
||||
|
||||
W przypadku plików na **external storage**, takich jak karty SD, należy zachować ostrożność:
|
||||
W przypadku plików na **external storage**, takich jak SD Card, należy zachować ostrożność:
|
||||
|
||||
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 dotyczące bezpieczeństwa**:
|
||||
- Ze względu na łatwość dostępu, zaleca się **nie przechowywać wrażliwych informacji** na external storage.
|
||||
- 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 **przeprowadzaj walidację wejścia** dla danych pobranych z external storage. To kluczowe, ponieważ dane pochodzą z nieufnego źródła.
|
||||
- Zdecydowanie odradza się przechowywanie plików wykonywalnych lub klas na external storage w celu dynamicznego ładowania.
|
||||
- Jeżeli aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że te pliki są **podpisane i kryptograficznie weryfikowane** przed dynamicznym załadowaniem. Ten krok jest kluczowy dla zachowania integralności bezpieczeństwa aplikacji.
|
||||
- Pliki na external storage są **globalnie czytelne i zapisywalne**. Oznacza to, że dowolna aplikacja lub użytkownik może mieć do nich dostęp.
|
||||
2. **Obawy bezpieczeństwa**:
|
||||
- Ze względu na łatwość dostępu, zaleca się **nie przechowywać informacji wrażliwych** na external storage.
|
||||
- External storage można usunąć lub uzyskać do niego dostęp przez dowolną aplikację, co czyni go mniej bezpiecznym.
|
||||
3. **Obsługa danych z External Storage**:
|
||||
- Zawsze **przeprowadzaj walidację wejścia** na danych pobieranych z external storage. Jest to kluczowe, ponieważ dane pochodzą ze źródła nieznanego/zewnętrznego.
|
||||
- Przechowywanie plików wykonywalnych lub klas na external storage do dynamicznego ładowania jest zdecydowanie odradzane.
|
||||
- Jeśli aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że są one **signed i cryptographically verified** przed ich dynamicznym załadowaniem. Ten krok jest niezbędny do utrzymania integralności bezpieczeństwa aplikacji.
|
||||
|
||||
External storage można **uzyskać** w /storage/emulated/0 , /sdcard , /mnt/sdcard
|
||||
External storage można **dostępować** 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**), struktura katalogów na karcie SD **ogranicza dostęp aplikacji do katalogu przeznaczonego specjalnie dla tej aplikacji**. Zapobiega to uzyskaniu przez złośliwą aplikację dostępu do odczytu lub zapisu plików innej aplikacji.
|
||||
|
||||
**Wrażliwe dane przechowywane jawnie**
|
||||
**Wrażliwe dane przechowywane w postaci jawnej**
|
||||
|
||||
- **Shared preferences**: Android pozwala każdej aplikacji na łatwe zapisywanie plików xml w ścieżce `/data/data/<packagename>/shared_prefs/` i czasem można znaleźć wrażliwe informacje w postaci jawnej w tym folderze.
|
||||
- **Databases**: Android pozwala każdej aplikacji na łatwe zapisywanie baz sqlite w ścieżce `/data/data/<packagename>/databases/` i czasem można znaleźć wrażliwe informacje w postaci jawnej w tym folderze.
|
||||
- **Shared preferences**: Android pozwala każdej aplikacji na łatwe zapisywanie plików xml w ścieżce `/data/data/<packagename>/shared_prefs/` i czasami można znaleźć w tym folderze wrażliwe informacje w postaci jawnej.
|
||||
- **Databases**: Android pozwala każdej aplikacji na łatwe zapisywanie baz sqlite w ścieżce `/data/data/<packagename>/databases/` i czasami można znaleźć w tym folderze wrażliwe informacje w postaci jawnej.
|
||||
|
||||
### Błędna konfiguracja TLS
|
||||
### Broken TLS
|
||||
|
||||
**Accept All Certificates**
|
||||
|
||||
Z jakiegoś powodu deweloperzy czasem akceptują wszystkie certyfikaty, nawet jeśli na przykład hostname nie pasuje, używając linii kodu podobnych do następującej:
|
||||
Z jakiegoś powodu deweloperzy czasami akceptują wszystkie certyfikaty nawet jeśli, na przykład, hostname nie pasuje — z użyciem fragmentów kodu takich jak poniższy:
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
Dobrym sposobem przetestowania tego jest próba przechwycenia ruchu za pomocą proxy, takiego jak Burp, bez autoryzowania Burp CA na urządzeniu. Możesz też wygenerować w Burp certyfikat dla innej nazwy hosta i go użyć.
|
||||
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.
|
||||
|
||||
### Błędna kryptografia
|
||||
|
||||
**Słabe procesy zarządzania kluczami**
|
||||
|
||||
Niektórzy deweloperzy zapisują dane wrażliwe w lokalnej pamięci i szyfrują je kluczem zakodowanym na stałe/przewidywalnym w kodzie. Nie powinno się tego robić, ponieważ analiza odwrotna może umożliwić atakującym wyodrębnienie poufnych informacji.
|
||||
Niektórzy deweloperzy zapisują dane wrażliwe w lokalnym magazynie i szyfrują je kluczem zakodowanym na stałe / przewidywalnym w kodzie. Nie powinno się tego robić, ponieważ reversing może pozwolić atakującym na wyodrębnienie informacji poufnych.
|
||||
|
||||
**Użycie niebezpiecznych i/lub przestarzałych algorytmów**
|
||||
|
||||
Deweloperzy nie powinni używać **deprecated algorithms** do przeprowadzania autoryzacyjnych **checks**, **store** lub **send** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli do przechowywania haseł używane są **hashes**, powinno się stosować odporne na brute-force algorytmy z salt.
|
||||
Deweloperzy nie powinni używać **deprecated algorithms** do wykonywania kontroli 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ł, powinny to być hashe odporne na brute-force z zastosowaniem salt.
|
||||
|
||||
### Inne kontrole
|
||||
|
||||
- Zaleca się **obfuskować APK**, aby utrudnić pracę reverse engineerów atakującym.
|
||||
- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna wykonać swoje własne **sprawdzenia, czy urządzenie jest rooted** i działać odpowiednio.
|
||||
- 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 upewnić się, czy 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
|
||||
- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers.
|
||||
- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna przeprowadzać własne sprawdzenia, aby ustalić, czy urządzenie jest rooted i odpowiednio reagować.
|
||||
- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna sprawdzać, czy używany jest **emulator**.
|
||||
- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby ustalić, czy została zmodyfikowana.
|
||||
- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK
|
||||
|
||||
### Aplikacja React Native
|
||||
|
||||
Read the following page to learn how to easily access javascript code of React applications:
|
||||
Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu javascript aplikacji React:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -188,7 +188,7 @@ react-native-application.md
|
||||
|
||||
### Aplikacje Xamarin
|
||||
|
||||
Read the following page to learn how to easily access C# code of a xamarin applications:
|
||||
Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu C# aplikacji xamarin:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -199,15 +199,15 @@ Read the following page to learn how to easily access C# code of a xamarin appli
|
||||
|
||||
According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
|
||||
|
||||
### Automatyczna analiza statyczna kodu
|
||||
### Zautomatyzowana statyczna analiza kodu
|
||||
|
||||
Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **vulnerabilities** przez **scanning** **code** aplikacji. To narzędzie zawiera zbiór **known sources** (które wskazują narzędziu **places** gdzie **input** jest **controlled by the user**), **sinks** (które wskazują narzędziu **dangerous** **places** gdzie złośliwy input użytkownika może spowodować szkody) oraz **rules**. Te rules wskazują **combination** **sources-sinks**, które oznaczają podatność.
|
||||
Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) potrafi znaleźć **vulnerabilities** poprzez **scanning** **code** aplikacji. To narzędzie zawiera zbiór **known sources** (które wskazują narzędziu **places** gdzie **input** jest **controlled by the user**), **sinks** (które wskazują narzędziu **dangerous** **places** gdzie złośliwy input użytkownika może wyrządzić szkody) oraz **rules**. Zasady te wskazują **combination** **sources-sinks** które sygnalizują podatność.
|
||||
|
||||
Z tą wiedzą, **mariana-trench will review the code and find possible vulnerabilities on it**.
|
||||
Dzięki temu **mariana-trench przeanalizuje kod i znajdzie możliwe podatności**.
|
||||
|
||||
### Secrets leaked
|
||||
|
||||
Aplikacja może zawierać sekrety (API keys, passwords, hidden urls, subdomains...) wewnątrz, które możesz odkryć. Możesz użyć narzędzia takiego jak [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
|
||||
### Bypass Biometric Authentication
|
||||
|
||||
@ -216,7 +216,7 @@ Aplikacja może zawierać sekrety (API keys, passwords, hidden urls, subdomains.
|
||||
bypass-biometric-authentication-android.md
|
||||
{{#endref}}
|
||||
|
||||
### Inne ciekawe funkcje
|
||||
### Inne interesujące funkcje
|
||||
|
||||
- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
|
||||
@ -236,13 +236,13 @@ content-protocol.md
|
||||
|
||||
## Analiza dynamiczna
|
||||
|
||||
> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe środowisko (Burp CA cert, Drozer i Frida głównie). Dlatego zdecydowanie zalecane jest użycie urządzenia rooted (emuowane lub nie).
|
||||
> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe środowisko (Burp CA cert, Drozer i Frida głównie). Dlatego urządzenie z rootem (emulowane lub nie) jest zdecydowanie zalecane.
|
||||
|
||||
### Online dynamic analysis
|
||||
### Analiza dynamiczna online
|
||||
|
||||
Możesz utworzyć darmowe konto na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala na przesyłanie i uruchamianie APK, więc jest przydatna do obserwowania, jak APK się zachowuje.
|
||||
Możesz założyć **darmowe konto** na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala **upload** i **execute** APK, więc jest przydatna do sprawdzenia, jak apk się zachowuje.
|
||||
|
||||
Możesz nawet **zobaczyć logi swojej aplikacji** w sieci i połączyć się przez **adb**.
|
||||
Możesz nawet **zobaczyć logi swojej aplikacji** w przeglądarce i połączyć się przez **adb**.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -250,72 +250,79 @@ Dzięki połączeniu ADB możesz używać **Drozer** i **Frida** wewnątrz emula
|
||||
|
||||
### Lokalna analiza dynamiczna
|
||||
|
||||
#### Użycie emulatora
|
||||
#### Korzystanie z emulatora
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Możesz stworzyć urządzenia **x86** i **arm**, a zgodnie z [**this**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **latest x86** versions **support ARM libraries** bez konieczności używania wolnego emulatora arm).
|
||||
- Naucz się jak to skonfigurować na tej stronie:
|
||||
- [**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 wersje x86** obsługują **ARM libraries** bez potrzeby używania wolnego emulatora arm).
|
||||
- Naucz się, jak to skonfigurować na tej stronie:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) (Bezpłatna wersja: Personal Edition, trzeba utworzyć konto. Zaleca się pobranie wersji Z **VirtualBox**, aby uniknąć potencjalnych błędów.)
|
||||
- [**Nox**](https://es.bignox.com) (Darmowy, ale nie obsługuje Frida ani Drozer).
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) (wersja darmowa: Personal Edition, wymagane założenie konta. Zaleca się pobranie wersji z **VirtualBox**, aby uniknąć potencjalnych błędów.)
|
||||
- [**Nox**](https://es.bignox.com) (darmowy, ale nie obsługuje Frida ani Drozer).
|
||||
|
||||
> [!TIP]
|
||||
> Tworząc nowy emulator na dowolnej platformie pamiętaj, że im większy ekran, tym wolniej będzie działać emulator. Wybieraj więc, jeśli to możliwe, mniejsze ekrany.
|
||||
> Przy tworzeniu nowego emulatora na dowolnej platformie pamiętaj, że im większy ekran, tym wolniej będzie działał emulator. Dlatego wybieraj małe ekrany, jeśli to możliwe.
|
||||
|
||||
Aby **zainstalować google services** (np. AppStore) w Genymotion, musisz kliknąć przycisk oznaczony na czerwono na poniższym obrazku:
|
||||
Aby **zainstalować google services** (np. AppStore) w Genymotion musisz kliknąć przycisk zaznaczony na czerwono na poniższym obrazku:
|
||||
|
||||
.png>)
|
||||
|
||||
Zwróć też uwagę, że w **konfiguracji Android VM w Genymotion** możesz wybrać **Bridge Network mode** (przydatne, jeśli będziesz łączyć się z Android VM z innej VM z narzędziami).
|
||||
Zwróć też uwagę, że w **konfiguracji Android VM 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).
|
||||
|
||||
#### Użycie urządzenia fizycznego
|
||||
|
||||
Musisz aktywować opcje **debugowania**, a dobrze byłoby, gdybyś mógł je **root**:
|
||||
Musisz aktywować opcje **debugowania**, a dobrze byłoby, jeśli możesz je **root**:
|
||||
|
||||
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**.
|
||||
2. (Od Androida 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ą, którą powinieneś zrobić, jest wypróbować ją, zbadać, co robi, jak działa i oswoić się z nią. Zalecam **wykonanie tej początkowej analizy dynamicznej przy użyciu MobSF dynamic analysis + pidcat**, dzięki czemu będziemy mogli **dowiedzieć się, jak działa aplikacja**, podczas gdy MobSF **zbiera** mnóstwo **interesujących** **danych**, które możesz później przejrzeć.
|
||||
> Po zainstalowaniu aplikacji pierwszą rzeczą, którą powinieneś zrobić, jest jej wypróbowanie, sprawdzenie, co robi, jak działa i oswojenie się z nią.\
|
||||
> Sugeruję **wykonać tę początkową analizę dynamiczną używając MobSF dynamic analysis + pidcat**, dzięki czemu będziemy mogli **dowiedzieć się, jak aplikacja działa**, podczas gdy MobSF **przechwyci** dużo **interesujących** **danych**, które możesz przejrzeć później.
|
||||
|
||||
Magisk/Zygisk szybkie notatki (zalecane na urządzeniach Pixel)
|
||||
- Patchuj boot.img za pomocą aplikacji Magisk i flashuj przez fastboot, aby uzyskać systemless root
|
||||
- Włącz Zygisk + DenyList do ukrywania roota; rozważ LSPosed/Shamiko, gdy wymagane jest silniejsze ukrywanie
|
||||
- Zachowaj oryginalny boot.img, aby móc odzyskać po aktualizacjach OTA; ponownie patcheuj po każdej OTA
|
||||
- Do mirrorowania ekranu użyj scrcpy na hoście
|
||||
|
||||
### Unintended Data Leakage
|
||||
|
||||
**Logging**
|
||||
|
||||
Deweloperzy powinni zachować ostrożność przy ujawnianiu **debugging information** publicznie, ponieważ może to prowadzić do sensitive data leaks. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) oraz `adb logcat` są zalecane 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 być ostrożni z ujawnianiem **debugging information** publicznie, ponieważ może to prowadzić do wrażliwych danych leaks. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony poufnych informacji. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność.
|
||||
|
||||
> [!WARNING]
|
||||
> Zauważ, że od **wersji nowszej niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Więc aplikacje nie mogą uzyskać dostępu do 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ć dostępu do logów innych aplikacji.\
|
||||
> Niemniej jednak nadal zaleca się **nie logować wrażliwych informacji**.
|
||||
|
||||
**Copy/Paste Buffer Caching**
|
||||
|
||||
Androidowy framework oparty na **clipboard-based** umożliwia funkcję kopiuj-wklej w aplikacjach, jednak stwarza ryzyko, ponieważ **inne aplikacje** mogą **access** schowka, potencjalnie ujawniając wrażliwe dane. Kluczowe jest **wyłączenie funkcji copy/paste** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec data leaks.
|
||||
Androidowy framework oparty na **clipboard** umożliwia funkcję kopiuj-wklej w aplikacjach, jednak stwarza ryzyko, ponieważ **inne aplikacje** mogą **dostępować** do schowka, potencjalnie ujawniając sensitive data. Kluczowe jest **wyłączenie funkcji kopiuj/wklej** w wrażliwych sekcjach aplikacji, takich jak dane karty kredytowej, aby zapobiec data leaks.
|
||||
|
||||
**Crash Logs**
|
||||
|
||||
Jeśli aplikacja **crashes** i **saves logs**, te logi mogą pomóc atakującym, szczególnie gdy aplikacja nie może być reverse-engineerowana. Aby złagodzić to ryzyko, unikaj logowania przy crashach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL dla bezpieczeństwa.
|
||||
Jeżeli aplikacja **crashes** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacja nie może być reverse-engineered. Aby zminimalizować to ryzyko, unikaj logowania przy awariach, a jeśli logi muszą być przesłane przez sieć, upewnij się, że są wysyłane przez kanał SSL.
|
||||
|
||||
Jako pentester, **spróbuj rzucić okiem na te logi**.
|
||||
|
||||
**Analytics Data Sent To 3rd Parties**
|
||||
|
||||
Aplikacje często integrują usługi takie jak Google Adsense, które mogą niezamiernie **leak sensitive data** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne data leaks, zaleca się **intercept the application's traffic** i sprawdzić, czy jakiekolwiek wrażliwe informacje są wysyłane do usług stron trzecich.
|
||||
Aplikacje często integrują usługi takie jak Google Adsense, które mogą niezamierzenie **leak sensitive data** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne data leaks, zaleca się **przechwycić ruch aplikacji** i sprawdzić, czy jakiekolwiek wrażliwe informacje są wysyłane do usług third-party.
|
||||
|
||||
### SQLite DBs
|
||||
|
||||
Większość aplikacji będzie używać **internal SQLite databases** do zapisywania informacji. Podczas pentest zwróć uwagę na **databases** utworzone, nazwy **tables** i **columns** oraz wszystkie zapisane **data**, ponieważ możesz znaleźć **sensitive information** (co byłoby podatnością).\
|
||||
Bazy danych powinny być zlokalizowane w `/data/data/the.package.name/databases` na przykład `/data/data/com.mwr.example.sieve/databases`
|
||||
Większość aplikacji używa **internal SQLite databases** do zapisywania informacji. Podczas pentest przejrzyj **databases** utworzone, nazwy **tables** i **columns** oraz wszystkie zapisane **data**, ponieważ możesz znaleźć **sensitive information** (co byłoby podatnością).\
|
||||
Bazy danych powinny znajdować się w `/data/data/the.package.name/databases` jak `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
Jeśli baza danych przechowuje poufne informacje i jest **encrypted** ale możesz **find** **password** wewnątrz aplikacji, to nadal jest **vulnerability**.
|
||||
Jeśli baza danych zapisuje poufne informacje i jest **encrypted** ale możesz **find** **password** wewnątrz aplikacji, to wciąż jest to **vulnerability**.
|
||||
|
||||
Wyenumeruj tabele używając `.tables` i wyświetl kolumny tabel poleceniem `.schema <table_name>`
|
||||
Wylistuj tabele używając `.tables` i wypisz kolumny tabel wykonując `.schema <table_name>`
|
||||
|
||||
### Drozer (Exploit Activities, Content Providers and Services)
|
||||
|
||||
@ -325,7 +332,7 @@ Drozer is s useful tool to **exploit exported activities, exported services and
|
||||
### Exploiting exported Activities
|
||||
|
||||
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
Also remember that the code of an activity starts in the **`onCreate`** method.
|
||||
Pamiętaj też, że kod aktywności zaczyna się w metodzie **`onCreate`**.
|
||||
|
||||
**Authorisation bypass**
|
||||
|
||||
@ -340,50 +347,50 @@ You can also start an exported activity from adb:
|
||||
```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 aktywności, 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 będzie traktować jako złośliwe użycie _**singleTask/singleInstance**_ jako `android:launchMode` w activity, ale zgodnie z [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), najwyraźniej jest to niebezpieczne tylko w starych wersjach (API versions < 21).
|
||||
|
||||
> [!TIP]
|
||||
> Należy pamiętać, że obejście autoryzacji nie zawsze jest podatnością — zależy to od sposobu działania bypassu i jakie informacje są ujawniane.
|
||||
> Należy pamiętać, że an authorisation bypass nie zawsze jest podatnością — zależy to od sposobu działania bypassu i jakie informacje są ujawniane.
|
||||
|
||||
**Ujawnianie wrażliwych informacji**
|
||||
**Sensitive information leakage**
|
||||
|
||||
**Aktywności mogą również zwracać wyniki**. Jeśli uda Ci się znaleźć eksportowaną i niechronioną aktywność wywołującą metodę **`setResult`** i **zwracającą wrażliwe informacje**, dochodzi do ujawnienia wrażliwych informacji.
|
||||
**Aktywności mogą też zwracać wyniki.** Jeśli uda Ci się znaleźć eksportowaną i niezabezpieczoną activity, która wywołuje metodę **`setResult`** i **zwraca poufne informacje**, dochodzi do sensitive information leakage.
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
Jeśli Tapjacking nie jest zapobiegany, możesz wykorzystać eksportowaną aktywność, aby spowodować, że **użytkownik wykona nieoczekiwane akcje**. Więcej informacji o [**czym jest Tapjacking — zobacz link**](#tapjacking).
|
||||
Jeśli Tapjacking nie jest zatrzymany, możesz wykorzystać eksportowaną activity, aby zmusić **użytkownika do wykonania nieoczekiwanych działań**. Po więcej informacji o [**czym jest Tapjacking, zobacz link**](#tapjacking).
|
||||
|
||||
### Exploiting Content Providers - Accessing and manipulating sensitive information
|
||||
### Exploiting Content Providers - Uzyskiwanie i manipulowanie poufnymi informacjami
|
||||
|
||||
[**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
Content providers służą zasadniczo do **udostępniania danych**. Jeśli aplikacja udostępnia content providers, możesz być w stanie **wyodrębnić wrażliwe** dane z nich. Warto także przetestować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne.
|
||||
Content providers służą zasadniczo do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wyodrębnić poufne** dane z nich. Warto też testować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne.
|
||||
|
||||
[**Dowiedz się, jak wykorzystać Content Providers przy użyciu Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
[**Dowiedz się, jak exploit Content Providers przy użyciu 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 rozpoczynają się w metodzie `onStartCommand`.
|
||||
Pamiętaj, że działania Service zaczynają się w metodzie `onStartCommand`.
|
||||
|
||||
Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Zatem jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **przetestować** go **dynamicznie** w celu wyciągnięcia informacji poufnych, obejścia mechanizmów uwierzytelniania itp.\
|
||||
[**Dowiedz się, jak wykorzystać Services przy użyciu Drozer.**](drozer-tutorial/index.html#services)
|
||||
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 **testować** go **dynamicznie** w celu wydobycia informacji poufnych, obejścia mechanizmów uwierzytelniania itp.\
|
||||
[**Dowiedz się, jak exploit Services przy użyciu 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 rozpoczynają się w metodzie `onReceive`.
|
||||
Pamiętaj, że działania Broadcast Receiver zaczynają się w metodzie `onReceive`.
|
||||
|
||||
Broadcast Receiver będzie oczekiwał na określony typ komunikatu. W zależności od tego, jak odbiornik obsługuje komunikat, może być podatny.\
|
||||
[**Dowiedz się, jak wykorzystać Broadcast Receivers przy użyciu Drozer.**](#exploiting-broadcast-receivers)
|
||||
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.\
|
||||
[**Dowiedz się, jak exploit Broadcast Receivers przy użyciu 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ć** zadeklarowany **scheme** za pomocą **adb** lub **przeglądarki**:
|
||||
Możesz wyszukać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów typu [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._
|
||||
_Zauważ, że możesz **pominąć nazwę pakietu** i urządzenie mobilne automatycznie wywoła aplikację, która powinna otworzyć ten link._
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
@ -396,52 +403,52 @@ Aby znaleźć **kod, który zostanie wykonany w aplikacji**, przejdź do activit
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
**Wrażliwe informacje**
|
||||
**Wrażliwe dane**
|
||||
|
||||
Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie przyjmuje wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod ten deep link i ukraść te dane!**
|
||||
Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie otrzymuje 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 też sprawdzić, czy któryś deep link nie używa parametru w samej ścieżce URL, np.: `https://api.example.com/v1/users/{username}` — w takim przypadku możesz wymusić path traversal, uzyskując dostęp do czegoś takiego: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
|
||||
Zauważ, że jeśli znajdziesz poprawne endpointy w aplikacji, możesz spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **przejęcie konta** (jeśli możesz modyfikować dane użytkowników bez tokenu CSRF i podatny endpoint używał odpowiedniej metody) oraz inne podatności. 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ś takiego: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
|
||||
Zauważ, że jeśli znajdziesz odpowiednie endpointy w aplikacji, możesz być w stanie wywołać **Open Redirect** (jeśli część ścieżki jest użyta jako nazwa domeny), **account takeover** (jeśli możesz zmodyfikować dane użytkowników bez tokena CSRF i podatny endpoint używał odpowiedniej metody) i inne podatności. Więcej informacji [tutaj](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Więcej przykładów**
|
||||
|
||||
Interesujący [raport bug bounty](https://hackerone.com/reports/855618) dotyczący linków (_/.well-known/assetlinks.json_).
|
||||
Interesujący raport bug bounty dotyczący linków (_/.well-known/assetlinks.json_): [Interesujący raport bug bounty](https://hackerone.com/reports/855618).
|
||||
|
||||
### Inspekcja warstwy transportowej i błędy weryfikacji
|
||||
### Transport Layer Inspection and Verification Failures
|
||||
|
||||
- **Certyfikaty nie zawsze są właściwie sprawdzane** przez aplikacje Android. Często aplikacje te ignorują ostrzeżenia i akceptują certyfikaty self-signed lub, w niektórych przypadkach, przechodzą na połączenia HTTP.
|
||||
- **Negocjacje podczas handshake SSL/TLS bywają słabe**, używając niebezpiecznych zestawów szyfrów. Ta podatność naraża połączenie na ataki man-in-the-middle (MITM), pozwalając atakującym odszyfrować dane.
|
||||
- **Wycieki informacji prywatnych** stanowią ryzyko, gdy aplikacje uwierzytelniają się przez bezpieczne kanały, a następnie komunikują się przez niezaszyfrowane kanały w innych operacjach. Takie podejście nie chroni wrażliwych danych, takich jak ciasteczka sesyjne czy dane użytkownika, przed przechwyceniem przez złośliwe podmioty.
|
||||
- **Certificates are not always inspected properly** przez aplikacje Android. Często aplikacje pomijają ostrzeżenia i akceptują certyfikaty self-signed lub w niektórych przypadkach wracają do używania połączeń HTTP.
|
||||
- **Negotiations during the SSL/TLS handshake are sometimes weak**, wykorzystując niebezpieczne zestawy szyfrów. Ta podatność naraża połączenie na ataki man-in-the-middle (MITM), umożliwiając atakującym odszyfrowanie danych.
|
||||
- **Leakage of private information** stanowi ryzyko, gdy aplikacje uwierzytelniają się przy użyciu bezpiecznych kanałów, a następnie komunikują się przez niezabezpieczone kanały dla innych transakcji. Takie podejście nie chroni wrażliwych danych, takich jak session cookies czy dane użytkownika, przed przechwyceniem przez podmioty złośliwe.
|
||||
|
||||
#### Weryfikacja certyfikatu
|
||||
#### Certificate Verification
|
||||
|
||||
Skupimy się na **weryfikacji certyfikatu**. Należy weryfikować integralność certyfikatu serwera, aby zwiększyć bezpieczeństwo. To kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez niezaszyfrowane kanały niosą znaczące ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i łatania podatności, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) zawiera obszerne wskazówki.
|
||||
Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS oraz przesyłanie wrażliwych danych przez niezabezpieczone kanały mogą stanowić poważne ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i usuwania podatności, [**to źródło**](https://manifestsecurity.com/android-application-security-part-10/) zawiera obszerny przewodnik.
|
||||
|
||||
#### SSL Pinning
|
||||
|
||||
SSL Pinning to mechanizm bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej wewnątrz aplikacji. Metoda ta jest istotna w zapobieganiu atakom MITM. Zdecydowanie zaleca się wdrożenie SSL Pinning w aplikacjach przetwarzających wrażliwe informacje.
|
||||
SSL Pinning to mechanizm bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej w samej aplikacji. Ta metoda jest istotna dla zapobiegania atakom man-in-the-middle (MITM). Implementacja SSL Pinning jest gorąco zalecana dla aplikacji przetwarzających dane wrażliwe.
|
||||
|
||||
#### Inspekcja ruchu
|
||||
#### Traffic Inspection
|
||||
|
||||
Aby inspekcjonować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu zaszyfrowany ruch może być niewidoczny przez proxy. Po instrukcję instalacji własnego certyfikatu CA, [**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 szyfrowany ruch może nie być widoczny przez proxy. Instrukcję instalacji niestandardowego certyfikatu CA znajdziesz [**tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
|
||||
|
||||
Aplikacje celujące w **API Level 24 i wyżej** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest krytyczny dla inspekcji zaszyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**this tutorial**](make-apk-accept-ca-certificate.md).
|
||||
Aplikacje celujące w **API Level 24 and above** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest kluczowy dla inspekcji szyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**tym tutorialu**](make-apk-accept-ca-certificate.md).
|
||||
|
||||
Jeśli używane jest **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Dzieje się tak dlatego, że samo dodanie certyfikatu do magazynu nie zadziała — Flutter ma własną listę zaufanych CA.
|
||||
Jeśli użyto **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Wynika to z faktu, że samo dodanie certyfikatu do magazynu nie wystarczy, ponieważ 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 miejsca, w których pinning jest egzekwowany w APK. Wykrywanie statyczne pomaga zaplanować hooki/łatki i skupić się na właściwych ścieżkach kodu.
|
||||
|
||||
Narzędzie: SSLPinDetect
|
||||
- Open-sourceowe narzędzie do analizy statycznej, które dekompiluje APK do Smali (przez apktool) i skanuje pod kątem wyselekcjonowanych wzorców regex implementacji SSL/TLS pinning.
|
||||
- Raportuje 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 wstępne: Python >= 3.8, Java w PATH, apktool
|
||||
- Wymagania wstępne: Python >= 3.8, Java on PATH, apktool
|
||||
```bash
|
||||
git clone https://github.com/aancw/SSLPinDetect
|
||||
cd SSLPinDetect
|
||||
@ -456,7 +463,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 rozszerz sygnatury, aby wykrywać zastrzeżone/własne style pinning. Możesz załadować własny plik JSON i skanować na dużą skalę.
|
||||
Użyj lub rozszerz sygnatur, aby wykrywać proprietarne/niestandardowe style pinning. Możesz załadować własny plik JSON i skanować na dużą skalę.
|
||||
```json
|
||||
{
|
||||
"OkHttp Certificate Pinning": [
|
||||
@ -470,43 +477,43 @@ Użyj lub rozszerz sygnatury, aby wykrywać zastrzeżone/własne style pinning.
|
||||
]
|
||||
}
|
||||
```
|
||||
Notes and tips
|
||||
- Szybkie skanowanie dużych aplikacji przy użyciu wielowątkowości i memory-mapped I/O; prekompilowane regexy zmniejszają narzut/fałszywe pozytywy.
|
||||
Notatki i wskazówki
|
||||
- Szybkie skanowanie dużych aplikacji przez multi-threading i memory-mapped I/O; pre-kompilowane regexy zmniejszają narzut / false positives.
|
||||
- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
|
||||
- Typowe cele do dalszej analizy:
|
||||
- OkHttp: użycie CertificatePinner, setCertificatePinner, odwołania do pakietu okhttp3/okhttp
|
||||
- Własne TrustManagery: javax.net.ssl.X509TrustManager, nadpisania checkServerTrusted
|
||||
- Niestandardowe konteksty SSL: SSLContext.getInstance + SSLContext.init z niestandardowymi managerami
|
||||
- Deklaratywne piny w res/xml network security config oraz odwołania w manifest
|
||||
- Użyj znalezionych lokalizacji do zaplanowania Frida hooks, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi.
|
||||
- Typowe cele detekcji do dalszej triage:
|
||||
- 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, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi.
|
||||
|
||||
|
||||
|
||||
#### Bypassing SSL Pinning
|
||||
#### Omijanie SSL Pinning
|
||||
|
||||
Gdy SSL Pinning jest zaimplementowany, konieczne staje się jego ominięcie, aby przeanalizować ruch HTTPS. Istnieje kilka metod do tego celu:
|
||||
Gdy SSL Pinning jest zaimplementowany, konieczne bywa jego obejście, aby inspekcjonować ruch HTTPS. Dostępne są różne metody:
|
||||
|
||||
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować roota, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową — i nie zawsze to zadziała.
|
||||
- Możesz użyć **Frida** (opisane poniżej) do obejścia tej ochrony. Oto przewodnik dotyczący 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 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 także spróbować **automatycznie ominąć SSL Pinning** używając **MobSF dynamic analysis** (opisane poniżej)
|
||||
- Jeśli nadal uważasz, że nie przechwytujesz części ruchu, możesz spróbować **przekierować ruch do Burp przy użyciu 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)
|
||||
- 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ć roota, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową wersję, i nie zawsze to zadziała.
|
||||
- Możesz użyć **Frida** (omówionej poniżej) aby obejść tę ochronę. Tutaj masz 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 także spróbować **automatycznie obejść 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 obejść SSL Pinning** używając **MobSF dynamic analysis** (opisane poniżej)
|
||||
- Jeśli nadal uważasz, że istnieje ruch, którego nie przechwytujesz, możesz spróbować **przekierować ruch do burpa 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)
|
||||
|
||||
#### Looking for Common Web Vulnerabilities
|
||||
#### Szukanie typowych podatności webowych
|
||||
|
||||
Ważne jest również poszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje o identyfikacji i łagodzeniu tych podatności wykraczają poza zakres tego podsumowania, ale są szeroko omówione w innych materiałach.
|
||||
Ważne jest także 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.
|
||||
|
||||
### Frida
|
||||
|
||||
[Frida](https://www.frida.re) to dynamiczny zestaw narzędzi 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 wykonywania, aby zmieniać zachowanie, wartości, wydobywać wartości, uruchamiać inny kod...**\
|
||||
Jeśli chcesz pentestować aplikacje Android, musisz umieć używać Frida.
|
||||
[Frida](https://www.frida.re) to zestaw narzędzi do dynamicznej instrumentacji dla programistów, reverse-engineerów i badaczy bezpieczeństwa.\
|
||||
**Możesz uzyskać dostęp do działającej aplikacji i hookować metody w czasie działania, aby zmieniać zachowanie, modyfikować wartości, wydobywać dane, uruchamiać inny kod...**\
|
||||
Jeśli chcesz pentestować aplikacje Android, musisz umieć korzystać z Frida.
|
||||
|
||||
- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html)
|
||||
- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- 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))
|
||||
- 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
|
||||
|
||||
@ -514,9 +521,9 @@ Jeśli chcesz pentestować aplikacje Android, musisz umieć używać Frida.
|
||||
android-anti-instrumentation-and-ssl-pinning-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### **Dump Memory - Fridump**
|
||||
### **Zrzut pamięci - Fridump**
|
||||
|
||||
Sprawdź, czy aplikacja przechowuje w pamięci wrażliwe informacje, których nie powinna przechowywać, takie jak hasła czy mnemoniki.
|
||||
Sprawdź, czy aplikacja nie przechowuje w pamięci informacji wrażliwych, których nie powinna przechowywać, takich jak hasła czy mnemoniki.
|
||||
|
||||
Używając [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji poleceniem:
|
||||
```bash
|
||||
@ -527,70 +534,68 @@ python3 fridump3.py -u <PID>
|
||||
frida-ps -Uai
|
||||
python3 fridump3.py -u "<Name>"
|
||||
```
|
||||
To zrzuci pamięć do folderu ./dump, a tam możesz użyć grep, na przykład:
|
||||
To zrzuci pamięć do katalogu ./dump, a tam możesz użyć grep z czymś takim:
|
||||
```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]+$"
|
||||
```
|
||||
### **Poufne dane w Keystore**
|
||||
### **Wrażliwe dane w Keystore**
|
||||
|
||||
W Androidzie Keystore jest najlepszym miejscem do przechowywania poufnych danych, jednak przy odpowiednich uprawnieniach wciąż **możliwe jest uzyskanie do niego dostępu**.
|
||||
W Androidzie Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy wystarczających uprawnieniach nadal jest **możliwe uzyskanie do niego dostępu**. Ponieważ aplikacje często przechowują tutaj **wrażliwe dane w postaci jawnej**, pentests powinny to sprawdzać jako root user — osoba z fizycznym dostępem do urządzenia mogłaby je przejąć.
|
||||
|
||||
Ponieważ aplikacje mają tendencję do przechowywania tutaj **poufnych danych w clear text**, pentests powinny to zweryfikować, gdyż root user lub ktoś z fizycznym dostępem do urządzenia mógłby te dane ukraść.
|
||||
Nawet jeśli aplikacja przechowuje data w Keystore, dane powinny być zaszyfrowane.
|
||||
|
||||
Nawet jeśli aplikacja przechowała dane w keystore, dane powinny być zaszyfrowane.
|
||||
|
||||
Aby uzyskać dostęp do danych wewnątrz keystore możesz użyć tego Frida script: [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 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)
|
||||
```bash
|
||||
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **Fingerprint/Biometrics Bypass**
|
||||
|
||||
Użycie poniższego Frida scriptu może umożliwić **bypass fingerprint authentication** stosowany przez aplikacje Android w celu **ochrony pewnych wrażliwych obszarów:**
|
||||
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 <app.package>
|
||||
```
|
||||
### **Obrazy w tle**
|
||||
|
||||
Gdy przeniesiesz aplikację do tła, Android zapisuje **snapshot aplikacji**, dzięki czemu po przywróceniu do pierwszego planu zaczyna najpierw ładować obraz, aby wydawało się, że aplikacja uruchomiła się szybciej.
|
||||
Gdy umieścisz aplikację w tle, Android zapisuje **zrzut aplikacji**, dzięki czemu po przywróceniu jej na pierwszy plan najpierw ładuje obraz, co sprawia, że aplikacja wydaje się uruchamiać szybciej.
|
||||
|
||||
Jednak jeśli ten snapshot zawiera **poufne informacje**, ktoś mający dostęp do snapshotu może **ukraść te informacje** (uwaga: wymagany jest root, aby uzyskać do niego dostęp).
|
||||
Jednak jeśli ten zrzut zawiera **poufne informacje**, osoba mająca dostęp do zrzutu może **ukraść te dane** (uwaga: dostęp wymaga root).
|
||||
|
||||
Snapshoty są zwykle przechowywane pod ścieżką: **`/data/system_ce/0/snapshots`**
|
||||
Zrzuty są zwykle przechowywane pod ścieżką: **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android oferuje sposób na **zapobieganie przechwytywaniu zrzutów ekranu przez ustawienie parametru layout FLAG_SECURE**. Użycie tej flagi powoduje, że zawartość okna jest traktowana jako bezpieczna, uniemożliwiając pojawienie się na zrzutach ekranu lub wyświetlanie na niezabezpieczonych ekranach.
|
||||
Android udostępnia sposób na **zablokowanie wykonywania zrzutów ekranu przez ustawienie parametru layoutu FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się na zrzutach ekranu oraz wyświetlaniu na niezaufanych ekranach.
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
### **Android Application Analyzer**
|
||||
|
||||
To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas analizy dynamicznej: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas dynamicznej analizy: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
|
||||
### Intent Injection
|
||||
|
||||
Deweloperzy często tworzą komponenty proxy 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 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.
|
||||
|
||||
Niebezpieczeństwo polega na pozwoleniu atakującym na wywoływanie nie-exportowanych komponentów aplikacji lub dostęp do wrażliwych content providers poprzez przekierowanie tych Intents. Przykładem jest komponent `WebView` konwertujący URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)`, a następnie je wykonujący, co może prowadzić do złośliwych Intent injections.
|
||||
Niebezpieczeństwo polega na umożliwieniu atakującym wywołania nieeksportowanych komponentów aplikacji lub uzyskania dostępu do wrażliwych content providers przez przekierowanie tych Intents. Dobrym przykładem jest komponent `WebView`, który konwertuje URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)`, a następnie je wykonuje, co może prowadzić do złośliwych Intent injections.
|
||||
|
||||
### Kluczowe wnioski
|
||||
### Essential Takeaways
|
||||
|
||||
- **Intent Injection** jest podobny do webowego problemu Open Redirect.
|
||||
- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonania niebezpiecznych operacji.
|
||||
- Może to wystawić atakującym nie-exportowane komponenty i content providers.
|
||||
- Konwersja URL-i na `Intent` przez `WebView` może ułatwić niezamierzone działania.
|
||||
- **Intent Injection** jest podobny do webowej podatności Open Redirect.
|
||||
- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonywania niebezpiecznych operacji.
|
||||
- Może ujawnić nieeksportowane komponenty i content providers atakującym.
|
||||
- Konwersja URL do `Intent` przez `WebView` może ułatwić niezamierzone działania.
|
||||
|
||||
### Android Client Side Injections and others
|
||||
|
||||
Prawdopodobnie znasz tego rodzaju podatności z Weba. W aplikacji Android należy zachować szczególną ostrożność w związku z tymi podatnościami:
|
||||
Prawdopodobnie znasz tego typu podatności z Weba. Musisz być szczególnie ostrożny z tymi podatnościami w aplikacji Android:
|
||||
|
||||
- **SQL Injection:** Jeśli używasz dynamicznych zapytań lub Content-Providers, upewnij się, że stosujesz zapytania parametryzowane.
|
||||
- **JavaScript Injection (XSS):** Sprawdź, czy obsługa JavaScript i Pluginów jest wyłączona dla wszelkich WebViews (domyślnie wyłączona). [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** Dostęp WebView do systemu plików powinien być wyłączony (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: W kilku przypadkach po zakończeniu sesji przez aplikację Android cookie nie jest unieważniane lub może być nawet zapisane na dysku
|
||||
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
- **SQL Injection:** W przypadku dynamicznych zapytań lub Content-Providers upewnij się, że używasz zapytań parametryzowanych.
|
||||
- **JavaScript Injection (XSS):** Upewnij się, że wsparcie dla JavaScript i Pluginów jest wyłączone dla wszystkich WebViews (domyślnie wyłączone). [Więcej informacji](webview-attacks.md#javascript-enabled).
|
||||
- **Local File Inclusion:** WebViews powinny mieć wyłączony dostęp do systemu plików (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [Więcej informacji](webview-attacks.md#javascript-enabled).
|
||||
- **Eternal cookies**: W wielu przypadkach, gdy aplikacja Android kończy sesję, cookie nie jest unieważniane lub może być nawet zapisane na dysku.
|
||||
- [**Secure Flag** w cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
---
|
||||
|
||||
## Automatyczna analiza
|
||||
## Analiza automatyczna
|
||||
|
||||
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
|
||||
|
||||
@ -598,51 +603,51 @@ Prawdopodobnie znasz tego rodzaju podatności z Weba. W aplikacji Android należ
|
||||
|
||||
.png>)
|
||||
|
||||
**Ocena podatności aplikacji** z użyciem ładnego interfejsu webowego. Możesz również przeprowadzić analizę dynamiczną (ale musisz przygotować środowisko).
|
||||
**Ocena podatności aplikacji** przy użyciu ładnego webowego frontendu. Możesz także przeprowadzić dynamiczną analizę (ale musisz przygotować środowisko).
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf
|
||||
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
|
||||
```
|
||||
Zwróć uwagę, że MobSF potrafi analizować **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Również, jeśli utworzysz plik **ZIP** z kodem źródłowym aplikacji **Android** lub **IOS** (przejdź do katalogu głównego aplikacji, zaznacz wszystko i utwórz plik ZIP), będzie on również możliwy do analizy.
|
||||
Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\
|
||||
Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also.
|
||||
|
||||
MobSF pozwala także na **diff/Compare** analizę oraz integrację z **VirusTotal** (musisz ustawić swój klucz API w _MobSF/settings.py_ i włączyć to: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Możesz także ustawić `VT_UPLOAD` na `False`, wtedy zamiast pliku zostanie przesłany **hash**.
|
||||
MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
|
||||
|
||||
### Asystowana analiza dynamiczna z MobSF
|
||||
### Assisted Dynamic analysis with MobSF
|
||||
|
||||
**MobSF** może być również bardzo pomocne przy analizie dynamicznej na **Android**, ale w takim przypadku musisz zainstalować **MobSF** i **genymotion** na hoście (VM lub Docker nie zadziałają). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
Analizator dynamiczny MobSF może:
|
||||
**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
|
||||
The **MobSF dynamic analyser** can:
|
||||
|
||||
- **Dump application data** (URL-e, logi, schowek, zrzuty ekranu robione przez Ciebie, zrzuty ekranu robione przez "**Exported Activity Tester**", e-maile, bazy SQLite, pliki XML i inne utworzone pliki). Wszystko to jest wykonywane automatycznie z wyjątkiem zrzutów ekranu — musisz nacisnąć, gdy chcesz zrzut ekranu lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty wszystkich eksportowanych aktywności.
|
||||
- Przechwytywać **HTTPS traffic**
|
||||
- Wykorzystać **Frida** do uzyskania informacji w czasie wykonania (runtime)
|
||||
- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
|
||||
- Capture **HTTPS traffic**
|
||||
- Use **Frida** to obtain **runtime** **information**
|
||||
|
||||
Od wersji Android > 5, automatycznie uruchomi Frida i ustawi globalne ustawienia proxy, aby przechwycić ruch. Będzie przechwytywać tylko ruch z testowanej aplikacji.
|
||||
From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application.
|
||||
|
||||
**Frida**
|
||||
|
||||
Domyślnie będzie też używać niektórych **Frida Scripts** do **bypass SSL pinning**, **root detection** i **debugger detection** oraz do monitorowania interesujących API.\
|
||||
MobSF może także **invoke exported activities**, pobierać ich **screenshots** i **save** je do raportu.
|
||||
By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\
|
||||
MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
|
||||
|
||||
Aby **start** testów dynamicznych naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez Frida scripts i "**Live API Monitor**", aby zobaczyć wszystkie wywołania do zahaczonych metod, przekazane argumenty i zwracane wartości (pojawi się to po naciśnięciu "Start Instrumentation").\
|
||||
MobSF pozwala także na załadowanie własnych **Frida scripts** (aby wysłać wyniki swoich Frida scripts do MobSF użyj funkcji `send()`). Ma też kilka predefiniowanych skryptów, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu wybierz je, naciśnij "**Load**" i "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**").
|
||||
To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\
|
||||
MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
|
||||
Ponadto masz kilka pomocniczych funkcjonalności Frida:
|
||||
Moreover, you have some Auxiliary Frida functionalities:
|
||||
|
||||
- **Enumerate Loaded Classes**: Wypisze wszystkie załadowane klasy
|
||||
- **Capture Strings**: Wypisze wszystkie przechwycone stringi podczas korzystania z aplikacji (bardzo hałaśliwe)
|
||||
- **Capture String Comparisons**: Może być bardzo przydatne. Pokaże dwa porównywane stringi oraz czy wynik był True czy False.
|
||||
- **Enumerate Class Methods**: Wprowadź nazwę klasy (np. "java.io.File"), a wypisze wszystkie metody tej klasy.
|
||||
- **Search Class Pattern**: Wyszukuje klasy według wzorca
|
||||
- **Trace Class Methods**: **Trace** całej klasy (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF śledzi kilka interesujących metod Android Api.
|
||||
- **Enumerate Loaded Classes**: It will print all the loaded classes
|
||||
- **Capture Strings**: It will print all the capture strings while using the application (super noisy)
|
||||
- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False.
|
||||
- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class.
|
||||
- **Search Class Pattern**: Search classes by pattern
|
||||
- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting 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**".
|
||||
Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**".
|
||||
|
||||
**Shell**
|
||||
|
||||
MobSF dostarcza również shell z kilkoma poleceniami **adb**, **MobSF commands** oraz typowymi poleceniami **shell** na dole strony analizy dynamicznej. Kilka ciekawych poleceń:
|
||||
Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands:
|
||||
```bash
|
||||
help
|
||||
shell ls
|
||||
@ -653,32 +658,32 @@ receivers
|
||||
```
|
||||
**Narzędzia HTTP**
|
||||
|
||||
Gdy ruch HTTP zostanie przechwycony, możesz zobaczyć toporny widok przechwyconego ruchu na przycisku "**HTTP(S) Traffic**" u dołu albo ładniejszy widok po naciśnięciu zielonego przycisku "**Start HTTPTools**". Z drugiej opcji możesz **wysyłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\
|
||||
Aby to zrobić, _włącz 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)).
|
||||
When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\
|
||||
To do so, _power on Burp -->_ _turn off Intercept --> in MobSF HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Po zakończeniu dynamicznej analizy z MobSF możesz nacisnąć "**Start Web API Fuzzer**", aby **fuzzować http requests** i szukać podatności.
|
||||
Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities.
|
||||
|
||||
> [!TIP]
|
||||
> Po wykonaniu dynamicznej analizy z MobSF ustawienia proxy mogą zostać źle skonfigurowane i nie będzie można ich naprawić z poziomu GUI. Możesz naprawić ustawienia proxy wykonując:
|
||||
> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing:
|
||||
>
|
||||
> ```
|
||||
> adb shell settings put global http_proxy :0
|
||||
> ```
|
||||
|
||||
### Wspomagana analiza dynamiczna z 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ć, **co dzieje się w aplikacji**, podczas gdy wykonujesz **dynamic analysis**.
|
||||
You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
|
||||
This tool with use some **Hooks** to let you know **what is happening in the application** while you perform a **dynamic analysis**.
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
To **świetne narzędzie do przeprowadzania static analysis z GUI**
|
||||
This is a **great tool to perform static analysis with a GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
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 również **zdolne do tworzenia "Proof-of-Concept" deployable APK** oraz generowania **ADB commands**, aby wykorzystać niektóre ze znalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego.
|
||||
This tool is designed to look for several **security related Android application vulnerabilities**, either in **source code** or **packaged APKs**. The tool is also **capable of creating a "Proof-of-Concept" deployable APK** and **ADB commands**, to exploit some of the found vulnerabilities (Exposed activities, intents, tapjacking...). As with Drozer, there is no need to root the test device.
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -687,10 +692,10 @@ qark --java path/to/specific/java/file.java
|
||||
```
|
||||
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
|
||||
|
||||
- Wyświetla wszystkie wyodrębnione pliki do szybkiego przeglądu
|
||||
- Wyświetla wszystkie wyodrębnione pliki do szybkiego wglądu
|
||||
- Automatycznie dekompiluje pliki APK do formatu Java i Smali
|
||||
- Analizuje AndroidManifest.xml pod kątem typowych podatności i zachowania
|
||||
- Statyczna analiza kodu źródłowego pod kątem typowych podatności i zachowań
|
||||
- Analizuje AndroidManifest.xml pod kątem common vulnerabilities and behavior
|
||||
- Statyczna analiza kodu źródłowego pod kątem common vulnerabilities and behavior
|
||||
- Informacje o urządzeniu
|
||||
- i więcej
|
||||
```bash
|
||||
@ -698,11 +703,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ć na Windows, MacOS X i Linux, analizująca pliki _.apk_ w poszukiwaniu podatności. Robi to poprzez rozpakowywanie APK i stosowanie zestawu reguł w celu wykrycia tych podatności.
|
||||
SUPER jest aplikacją uruchamianą z wiersza poleceń, którą można używać w Windows, MacOS X i Linux, analizującą pliki _.apk_ w poszukiwaniu podatności. Robi to poprzez dekompresję APK i zastosowanie zestawu reguł do wykrywania tych podatności.
|
||||
|
||||
Wszystkie reguły są umieszczone w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły, aby analizować to, czego potrzebują.
|
||||
Wszystkie reguły są zgromadzone w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły do analizy tego, czego potrzebują.
|
||||
|
||||
Pobierz najnowsze binaria ze [download page](https://superanalyzer.rocks/download.html)
|
||||
Pobierz najnowsze binaria ze strony [download page](https://superanalyzer.rocks/download.html)
|
||||
```
|
||||
super-analyzer {apk_file}
|
||||
```
|
||||
@ -710,9 +715,9 @@ super-analyzer {apk_file}
|
||||
|
||||
.png>)
|
||||
|
||||
StaCoAn to **crossplatform** narzędzie, które wspomaga programistów, bugbounty hunters i ethical hackers w przeprowadzaniu [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych.
|
||||
StaCoAn to **wieloplatformowe** narzędzie, które wspomaga programistów, bugbounty hunters and 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 swojej aplikacji mobilnej (an .apk or .ipa file) 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 tym, że przeciągasz i upuszczasz plik swojej 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.
|
||||
|
||||
Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
@ -720,7 +725,7 @@ Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
|
||||
|
||||
AndroBugs Framework to system analizy podatności dla Androida, który pomaga deweloperom lub hackers znaleźć potencjalne luki w zabezpieczeniach aplikacji Android.\
|
||||
AndroBugs Framework jest systemem analizy podatności Androida, który pomaga deweloperom lub hakerom znaleźć potencjalne luki bezpieczeństwa w aplikacjach Android.\
|
||||
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
|
||||
```
|
||||
python androbugs.py -f [APK file]
|
||||
@ -728,11 +733,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 potencjalnie złośliwych zachowaniach wykonywanych przez aplikację na Androida.
|
||||
**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.
|
||||
|
||||
Wykrywanie odbywa się za pomocą static analysis Dalvik bytecode aplikacji, reprezentowanego jako Smali, z użyciem biblioteki androguard.
|
||||
Wykrywanie odbywa się poprzez **static analysis** kodu bajtowego Dalvik aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard).
|
||||
|
||||
To narzędzie poszukuje typowych zachowań "złych" aplikacji, takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
|
||||
Narzędzie poszukuje **common behavior of "bad" applications** takich 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
|
||||
```
|
||||
@ -740,82 +745,83 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
|
||||
.png>)
|
||||
|
||||
**MARA** to framework do reverse engineeringu i analizy aplikacji mobilnych. 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 mobile. Jego celem jest ułatwienie tej pracy deweloperom aplikacji mobilnych oraz specjalistom ds. bezpieczeństwa.
|
||||
**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Jest to narzędzie łączące powszechnie używane mobile application reverse engineering and analysis tools, aby wspomóc testowanie aplikacji mobilnych przeciwko OWASP mobile security threats. Jego celem jest ułatwienie tej pracy i uczynienie jej bardziej przyjazną dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa.
|
||||
|
||||
Potrafi:
|
||||
It is able to:
|
||||
|
||||
- Wyodrębniać kod Java i Smali przy użyciu różnych narzędzi
|
||||
- Analizować APKi za pomocą: [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)
|
||||
- Wydobywać informacje prywatne z APK za pomocą regexów.
|
||||
- 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 przez [apk-deguard.com](http://www.apk-deguard.com)
|
||||
- Wyodrębnia kod Java i Smali za pomocą różnych narzędzi
|
||||
- Analizuje 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)
|
||||
- Wydobywa private information z APK za pomocą regexps.
|
||||
- Analizuje Manifest.
|
||||
- Analizuje znalezione domeny przy użyciu: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- Deobfuskacja APK poprzez [apk-deguard.com](http://www.apk-deguard.com)
|
||||
|
||||
### Koodous
|
||||
|
||||
Przydatne do wykrywania malware: [https://koodous.com/](https://koodous.com)
|
||||
|
||||
## Obfuskacja/Deobfuskacja kodu
|
||||
## Obfuscating/Deobfuscating code
|
||||
|
||||
Zwróć uwagę, że w zależności od usługi i konfiguracji użytej do obfuskacji kodu, sekrety mogą, ale nie muszą być obfuskowane.
|
||||
Zauważ, że w zależności od serwisu i konfiguracji użytej do obfuskacji kodu, sekrety mogą, ale nie muszą pozostać obfuskowane.
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
Z [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** jest open source'owym narzędziem konsolowym, które zmniejsza, optymalizuje i obfuskje kod Java. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem rozpowszechnianym na licencji GNU General Public License, wersja 2.
|
||||
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest rozpowszechniany na licencji GNU General Public License, wersja 2.
|
||||
|
||||
ProGuard jest dostarczany jako część Android SDK i uruchamia się podczas budowania aplikacji w trybie release.
|
||||
ProGuard jest dystrybuowany jako część Android SDK i działa podczas budowania aplikacji w trybie release.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Znajdź krok po kroku przewodnik jak deobfuskować apk w [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Znajdź przewodnik krok po kroku jak zdeobfuskować apk: [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(Z tego przewodnika) Ostatnio, gdy sprawdzaliśmy, tryb działania Dexguard wyglądał następująco:
|
||||
(Z tego przewodnika) Ostatnio, kiedy sprawdzaliśmy, tryb działania Dexguard był:
|
||||
|
||||
- załaduj zasób jako InputStream;
|
||||
- przekaż wynik do klasy dziedziczącej po FilterInputStream, aby go odszyfrować;
|
||||
- wykonaj pewną bezużyteczną obfuskację, żeby zmarnować kilka minut czasu reversera;
|
||||
- przekaż odszyfrowany wynik do ZipInputStream, aby uzyskać plik DEX;
|
||||
- w końcu załaduj powstały DEX jako zasób używając metody `loadDex`.
|
||||
- load a resource as an InputStream;
|
||||
- feed the result to a class inheriting from FilterInputStream to decrypt it;
|
||||
- do some useless obfuscation to waste a few minutes of time from a reverser;
|
||||
- feed the decrypted result to a ZipInputStream to get a DEX file;
|
||||
- finally load the resulting DEX as a Resource using the `loadDex` method.
|
||||
|
||||
### [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 identyfikację bibliotek.**
|
||||
**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia do obfuskacji Android. To umożliwia liczne analizy bezpieczeństwa, w tym inspekcję kodu i identyfikację bibliotek.**
|
||||
|
||||
Możesz przesłać obfuskowany APK na ich platformę.
|
||||
Możesz przesłać obfuskowane APK na ich platformę.
|
||||
|
||||
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
|
||||
|
||||
To narzędzie LLM do znajdowania potencjalnych luk bezpieczeństwa w aplikacjach android oraz deobfuskacji kodu aplikacji android. Wykorzystuje publiczne API Google Gemini.
|
||||
To narzędzie LLM do znajdowania potencjalnych luk bezpieczeństwa w aplikacjach Android i deobfuskacji kodu aplikacji Android. Używa publicznego API Google Gemini.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
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.
|
||||
To **generic android deobfuscator.** Simplify **virtually executes an app** aby zrozumieć jej zachowanie, a następnie **tries to optimize the code** tak, by 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 rodzaj obfuskacji został użyty.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD dostarcza informacji o **tym, jak APK zostało stworzone**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida.
|
||||
APKiD daje informacje o tym **how an APK was made**. Identyfikuje wiele **compilers**, **packers**, **obfuscators** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Android.
|
||||
|
||||
### Manual
|
||||
|
||||
[Przeczytaj ten poradnik, aby poznać kilka trików dotyczących **odwracania niestandardowej obfuskacji**](manual-deobfuscation.md)
|
||||
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
|
||||
|
||||
## Laboratoria
|
||||
## Labs
|
||||
|
||||
### [Androl4b](https://github.com/sh4hin/Androl4b)
|
||||
|
||||
AndroL4b to wirtualna maszyna bezpieczeństwa Android oparta na ubuntu-mate, zawierająca kolekcję najnowszych frameworków, tutoriali i laboratoriów od różnych entuzjastów i badaczy bezpieczeństwa 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, tutoriali i laboratoriów od różnych entuzjastów bezpieczeństwa i badaczy do reverse engineering i analizy malware.
|
||||
|
||||
## Referencje
|
||||
|
||||
- [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/) Android quick course
|
||||
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Szybki kurs Android
|
||||
- [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)
|
||||
- [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)
|
||||
|
||||
## Do wypróbowania
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Ta strona przedstawia praktyczny workflow do odzyskania analizy dynamicznej przeciw aplikacjom Android, które wykrywają/blokują instrumentację z powodu roota lub wymuszają TLS pinning. Skupia się na szybkiej triage, typowych detekcjach oraz gotowych do wklejenia hookach/taktykach umożliwiających obejście ich bez repackowania, gdy to możliwe.
|
||||
Ta strona dostarcza praktyczny workflow pozwalający odzyskać dynamiczną analizę aplikacji Android, które wykrywają/root‑blokują instrumentation lub wymuszają TLS pinning. Koncentruje się na szybkim triage, typowych detekcjach oraz copy‑pasteable hooks/tactics do ich ominięcia bez repacking, kiedy to możliwe.
|
||||
|
||||
## Detection Surface (what apps check)
|
||||
|
||||
@ -18,7 +18,7 @@ Ta strona przedstawia praktyczny workflow do odzyskania analizy dynamicznej prze
|
||||
- Enable DenyList, add the target package
|
||||
- Reboot and retest
|
||||
|
||||
Wiele aplikacji szuka tylko oczywistych wskaźników (su/Magisk paths/getprop). DenyList często neutralizuje naiwne sprawdzenia.
|
||||
Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks.
|
||||
|
||||
References:
|
||||
- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
|
||||
@ -35,24 +35,41 @@ Example:
|
||||
```bash
|
||||
frida -U -f com.example.app -l anti-frida-detection.js
|
||||
```
|
||||
Zwykle to zastępuje sprawdzenia Java root/debug, process/service scans oraz natywne ptrace(). Przydatne w słabiej chronionych aplikacjach; w przypadku mocniej zabezpieczonych celów mogą być potrzebne dopasowane hooks.
|
||||
Zazwyczaj stubują sprawdzenia root/debug w Java, skanowania procesów i usług oraz natywne ptrace(). Przydatne w słabo zabezpieczonych aplikacjach; w przypadku wzmocnionych celów mogą być potrzebne dostosowane hooks.
|
||||
|
||||
- Codeshare: https://codeshare.frida.re/
|
||||
|
||||
## Krok 3 — Ominięcie detektorów inicjalizacji przez późne dołączanie
|
||||
## Automatyzacja z Medusa (Frida framework)
|
||||
|
||||
Wiele detekcji działa tylko podczas tworzenia procesu/onCreate(). Spawn‑time injection (-f) lub gadgets zostają wykryte; dołączenie po załadowaniu UI może to ominąć.
|
||||
Medusa udostępnia 90+ gotowych modułów do SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception i innych.
|
||||
```bash
|
||||
git clone https://github.com/Ch0pin/medusa
|
||||
cd medusa
|
||||
pip install -r requirements.txt
|
||||
python medusa.py
|
||||
|
||||
# Example interactive workflow
|
||||
show categories
|
||||
use http_communications/multiple_unpinner
|
||||
use root_detection/universal_root_detection_bypass
|
||||
run com.target.app
|
||||
```
|
||||
Wskazówka: Medusa świetnie nadaje się do szybkich zwycięstw przed napisaniem custom hooks. Możesz też cherry-pick modules i połączyć je z własnymi scripts.
|
||||
|
||||
## Krok 3 — Omijanie detektorów uruchamianych przy inicjalizacji przez późne dołączanie
|
||||
|
||||
Wiele wykryć uruchamia się tylko podczas process spawn/onCreate(). Spawn‑time injection (-f) lub gadgets zostają wykryte; podłączenie się po załadowaniu UI może je ominąć.
|
||||
```bash
|
||||
# Launch the app normally (launcher/adb), wait for UI, then attach
|
||||
frida -U -n com.example.app
|
||||
# Or with Objection to attach to running process
|
||||
aobjection --gadget com.example.app explore # if using gadget
|
||||
```
|
||||
Jeśli to zadziała, utrzymaj sesję stabilną i przejdź do mapowania oraz stub checks.
|
||||
Jeśli to zadziała, utrzymaj sesję stabilną i przejdź do mapowania oraz wykonywania stub checks.
|
||||
|
||||
## Krok 4 — Mapowanie logiki wykrywania za pomocą Jadx i przeszukiwania łańcuchów znaków
|
||||
## Krok 4 — Mapuj logikę wykrywania za pomocą Jadx i przeszukiwania stringów
|
||||
|
||||
Statyczne słowa kluczowe do wstępnej analizy w Jadx:
|
||||
Słowa kluczowe do statycznego triage w Jadx:
|
||||
- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
|
||||
|
||||
Typowe wzorce Java:
|
||||
@ -68,9 +85,9 @@ Typowe API do przeglądu/hook:
|
||||
- java.lang.Runtime.exec / ProcessBuilder (probing commands)
|
||||
- android.os.SystemProperties.get (root/emulator heuristics)
|
||||
|
||||
## Krok 5 — Stubowanie w czasie wykonania z Frida (Java)
|
||||
## Krok 5 — Runtime stubbing with Frida (Java)
|
||||
|
||||
Nadpisz niestandardowe mechanizmy ochronne, aby zwracały bezpieczne wartości bez repackowania:
|
||||
Zastąp niestandardowe mechanizmy kontrolne, aby zwracały bezpieczne wartości bez przepakowywania:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
const Checks = Java.use('com.example.security.Checks');
|
||||
@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
|
||||
AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
|
||||
});
|
||||
```
|
||||
Triaging early crashes? Dump classes tuż przed zakończeniem, aby zidentyfikować prawdopodobne detection namespaces:
|
||||
Analizujesz wczesne awarie? Zrzucaj klasy tuż przed zakończeniem działania, aby wyłapać prawdopodobne przestrzenie nazw detekcji:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
Java.enumerateLoadedClasses({
|
||||
@ -94,7 +111,17 @@ onComplete: () => console.log('Done')
|
||||
});
|
||||
});
|
||||
```
|
||||
Zaloguj i unieszkodliw podejrzane metody, aby potwierdzić przebieg wykonania:
|
||||
```
|
||||
// Quick root detection stub example (adapt to target package/class names)
|
||||
Java.perform(() => {
|
||||
try {
|
||||
const RootChecker = Java.use('com.target.security.RootCheck');
|
||||
RootChecker.isDeviceRooted.implementation = function () { return false; };
|
||||
} catch (e) {}
|
||||
});
|
||||
```
|
||||
|
||||
Zaloguj i zneutralizuj podejrzane metody, aby potwierdzić przebieg wykonania:
|
||||
```js
|
||||
Java.perform(() => {
|
||||
const Det = Java.use('com.example.security.DetectionManager');
|
||||
@ -104,24 +131,64 @@ return false;
|
||||
};
|
||||
});
|
||||
```
|
||||
## Krok 6 — Śledź ścieżkę JNI/native, gdy Java hooks zawodzą
|
||||
## Bypass emulator/VM detection (Java stubs)
|
||||
|
||||
Prześledź JNI entry points, aby zlokalizować native loaders i detection init:
|
||||
Typowe heurystyki: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE zawierające generic/goldfish/ranchu/sdk; artefakty QEMU takie jak /dev/qemu_pipe, /dev/socket/qemud; domyślny MAC 02:00:00:00:00:00; NAT 10.0.2.x; brak telephony/sensors.
|
||||
|
||||
Szybkie sfałszowanie pól Build:
|
||||
```js
|
||||
Java.perform(function(){
|
||||
var Build = Java.use('android.os.Build');
|
||||
Build.MODEL.value = 'Pixel 7 Pro';
|
||||
Build.MANUFACTURER.value = 'Google';
|
||||
Build.BRAND.value = 'google';
|
||||
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
|
||||
});
|
||||
```
|
||||
Uzupełnij o stuby dla sprawdzeń istnienia plików oraz identyfikatorów (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList), aby zwracały realistyczne wartości.
|
||||
|
||||
## SSL pinning bypass quick hook (Java)
|
||||
|
||||
Zneutralizuj niestandardowe TrustManagers i wymuś permisywne konteksty SSL:
|
||||
```js
|
||||
Java.perform(function(){
|
||||
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
|
||||
var SSLContext = Java.use('javax.net.ssl.SSLContext');
|
||||
|
||||
// No-op validations
|
||||
X509TrustManager.checkClientTrusted.implementation = function(){ };
|
||||
X509TrustManager.checkServerTrusted.implementation = function(){ };
|
||||
|
||||
// Force permissive TrustManagers
|
||||
var TrustManagers = [ X509TrustManager.$new() ];
|
||||
var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom');
|
||||
SSLContextInit.implementation = function(km, tm, sr){
|
||||
return SSLContextInit.call(this, km, TrustManagers, sr);
|
||||
};
|
||||
});
|
||||
```
|
||||
Notatki
|
||||
- Rozszerz dla OkHttp: hook okhttp3.CertificatePinner and HostnameVerifier as needed, or use a universal unpinning script from CodeShare.
|
||||
- Przykład uruchomienia: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
|
||||
|
||||
## Krok 6 — Podążaj śladem JNI/native, gdy Java hooks zawodzą
|
||||
|
||||
Śledź JNI entry points, aby zlokalizować native loaders i detection init:
|
||||
```bash
|
||||
frida-trace -n com.example.app -i "JNI_OnLoad"
|
||||
```
|
||||
Szybka natywna ocena dołączonych plików .so:
|
||||
Szybkie natywne triage dołączonych plików .so:
|
||||
```bash
|
||||
# List exported symbols & JNI
|
||||
nm -D libfoo.so | head
|
||||
objdump -T libfoo.so | grep Java_
|
||||
strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root'
|
||||
```
|
||||
Interaktywne/native reversing:
|
||||
Interactive/native reversing:
|
||||
- Ghidra: https://ghidra-sre.org/
|
||||
- r2frida: https://github.com/nowsecure/r2frida
|
||||
|
||||
Przykład: unieszkodliwić ptrace, aby pokonać prosty anti‑debug w libc:
|
||||
Przykład: unieszkodliwienie ptrace, aby obejść prosty anti‑debug w libc:
|
||||
```js
|
||||
const ptrace = Module.findExportByName(null, 'ptrace');
|
||||
if (ptrace) {
|
||||
@ -130,7 +197,7 @@ return -1; // pretend failure
|
||||
}, 'int', ['int', 'int', 'pointer', 'pointer']));
|
||||
}
|
||||
```
|
||||
Zobacz też:
|
||||
Zobacz także:
|
||||
{{#ref}}
|
||||
reversing-native-libraries.md
|
||||
{{#endref}}
|
||||
@ -141,22 +208,24 @@ Jeśli wolisz repacking zamiast runtime hooks, spróbuj:
|
||||
```bash
|
||||
objection patchapk --source app.apk
|
||||
```
|
||||
Notatki:
|
||||
Uwagi:
|
||||
- Wymaga apktool; upewnij się, że masz aktualną wersję zgodnie z oficjalnym przewodnikiem, aby uniknąć problemów z budowaniem: https://apktool.org/docs/install
|
||||
- Gadget injection umożliwia instrumentation bez root, ale nadal może zostać wykryte przez silniejsze init‑time checks.
|
||||
|
||||
Odnośniki:
|
||||
Opcjonalnie dodaj moduły LSPosed i Shamiko dla lepszego ukrywania root w środowiskach Zygisk oraz zadbaj o DenyList, aby objąć procesy potomne.
|
||||
|
||||
Referencje:
|
||||
- Objection: https://github.com/sensepost/objection
|
||||
|
||||
## Krok 8 — Plan awaryjny: Modyfikacja TLS pinning dla widoczności ruchu sieciowego
|
||||
## Krok 8 — Plan awaryjny: Patch TLS pinning dla widoczności sieci
|
||||
|
||||
Jeżeli instrumentation jest zablokowane, nadal możesz analizować ruch, usuwając pinning statycznie:
|
||||
Jeśli instrumentation jest zablokowane, nadal możesz przeanalizować ruch, usuwając pinning statycznie:
|
||||
```bash
|
||||
apk-mitm app.apk
|
||||
# Then install the patched APK and proxy via Burp/mitmproxy
|
||||
```
|
||||
- Narzędzie: https://github.com/shroudedcode/apk-mitm
|
||||
- W kwestii network config CA‑trust tricks (and Android 7+ user CA trust), zobacz:
|
||||
- Dla sztuczek związanych z konfiguracją sieci i CA‑trust (oraz Android 7+ user CA trust), zobacz:
|
||||
|
||||
{{#ref}}
|
||||
make-apk-accept-ca-certificate.md
|
||||
@ -166,7 +235,7 @@ make-apk-accept-ca-certificate.md
|
||||
install-burp-certificate.md
|
||||
{{#endref}}
|
||||
|
||||
## Przydatne polecenia (cheat‑sheet)
|
||||
## Przydatna ściągawka poleceń
|
||||
```bash
|
||||
# List processes and attach
|
||||
frida-ps -Uai
|
||||
@ -186,12 +255,12 @@ apk-mitm app.apk
|
||||
```
|
||||
## Wskazówki i uwagi
|
||||
|
||||
- Preferuj attaching late zamiast spawning, gdy aplikacje crashują przy uruchomieniu
|
||||
- Niektóre detekcje uruchamiają się ponownie w krytycznych przepływach (np. payment, auth) — utrzymuj hooks aktywne podczas nawigacji
|
||||
- Łącz analizę statyczną i dynamiczną: string hunt w Jadx, aby zawęzić listę klas; następnie hookuj metody, by zweryfikować je w czasie wykonania
|
||||
- Wzmocnione aplikacje mogą używać packers i native TLS pinning — spodziewaj się reverse native code
|
||||
- Preferuj dołączanie (attach) później zamiast spawnowania, gdy aplikacje crashują przy uruchomieniu
|
||||
- Niektóre wykrycia uruchamiają się ponownie w krytycznych przepływach (np. payment, auth) — utrzymuj hooks aktywne podczas nawigacji
|
||||
- Łącz analizę statyczną i dynamiczną: wyszukaj stringi w Jadx, aby zawęzić listę klas; następnie hookuj metody, by zweryfikować je w runtime
|
||||
- Zabezpieczone aplikacje mogą używać packers i native TLS pinning — spodziewaj się reverse engineeringu natywnego kodu
|
||||
|
||||
## References
|
||||
## Źródła
|
||||
|
||||
- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
|
||||
- [Frida Codeshare](https://codeshare.frida.re/)
|
||||
@ -202,5 +271,7 @@ apk-mitm app.apk
|
||||
- [r2frida](https://github.com/nowsecure/r2frida)
|
||||
- [Apktool install guide](https://apktool.org/docs/install)
|
||||
- [Magisk](https://github.com/topjohnwu/Magisk)
|
||||
- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,34 +1,34 @@
|
||||
# AVD - Android Virtual Device
|
||||
# AVD - Wirtualne urządzenie Androida
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Dziękuję bardzo [**@offsecjay**](https://twitter.com/offsecjay) za pomoc w tworzeniu tej treści.
|
||||
Bardzo dziękuję [**@offsecjay**](https://twitter.com/offsecjay) za pomoc przy tworzeniu tej treści.
|
||||
|
||||
## Co to jest
|
||||
## Czym jest
|
||||
|
||||
Android Studio pozwala na **uruchamianie maszyn wirtualnych Android, które możesz wykorzystać do testowania APK**. Aby z nich skorzystać, będziesz potrzebować:
|
||||
Android Studio pozwala **uruchamiać wirtualne maszyny Androida, których możesz użyć do testowania plików APK**. Aby z nich korzystać, będziesz potrzebować:
|
||||
|
||||
- **Narzędzi SDK Android** - [Pobierz tutaj](https://developer.android.com/studio/releases/sdk-tools).
|
||||
- Lub **Android Studio** (z narzędziami SDK Android) - [Pobierz tutaj](https://developer.android.com/studio).
|
||||
- Pakiet **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
|
||||
- Lub **Android Studio** (z Android SDK tools) - [Download here](https://developer.android.com/studio).
|
||||
|
||||
Na Windows (w moim przypadku) **po zainstalowaniu Android Studio** miałem **zainstalowane narzędzia SDK w**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
|
||||
Na Windows (w moim przypadku) **po zainstalowaniu Android Studio** miałem **SDK Tools zainstalowane w**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
|
||||
|
||||
Na Macu możesz **pobrać narzędzia SDK** i mieć je w PATH, uruchamiając:
|
||||
Na macu możesz **pobrać SDK tools** i mieć je w PATH uruchamiając:
|
||||
```bash
|
||||
brew tap homebrew/cask
|
||||
brew install --cask android-sdk
|
||||
```
|
||||
Lub z **Android Studio GUI**, jak wskazano w [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a), co zainstaluje je w `~/Library/Android/sdk/cmdline-tools/latest/bin/` oraz `~/Library/Android/sdk/platform-tools/` i `~/Library/Android/sdk/emulator/`
|
||||
Albo z poziomu **Android Studio GUI**, jak wskazano w [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a), co zainstaluje je w `~/Library/Android/sdk/cmdline-tools/latest/bin/` i `~/Library/Android/sdk/platform-tools/` oraz `~/Library/Android/sdk/emulator/`
|
||||
|
||||
W przypadku problemów z Javą:
|
||||
W przypadku problemów z Java:
|
||||
```java
|
||||
export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
|
||||
```
|
||||
## GUI
|
||||
|
||||
### Przygotuj Maszynę Wirtualną
|
||||
### Przygotowanie maszyny wirtualnej
|
||||
|
||||
Jeśli zainstalowałeś Android Studio, możesz po prostu otworzyć główny widok projektu i uzyskać dostęp do: _**Narzędzia**_ --> _**Menadżer AVD.**_
|
||||
Jeśli zainstalowałeś Android Studio, otwórz widok główny projektu i przejdź: _**Tools**_ --> _**AVD Manager.**_
|
||||
|
||||
<div align="center" data-full-width="false">
|
||||
|
||||
@ -36,38 +36,38 @@ Jeśli zainstalowałeś Android Studio, możesz po prostu otworzyć główny wid
|
||||
|
||||
</div>
|
||||
|
||||
Następnie kliknij na _**Utwórz Wirtualne Urządzenie**_
|
||||
Następnie kliknij _**Create Virtual Device**_
|
||||
|
||||
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
|
||||
|
||||
_**wybierz** telefon, którego chcesz użyć_ i kliknij na _**Dalej.**_
|
||||
_**select** telefon, którego chcesz użyć_ i kliknij _**Next.**_
|
||||
|
||||
> [!WARNING]
|
||||
> Jeśli potrzebujesz telefonu z zainstalowanym Sklepem Play, wybierz taki z ikoną Sklepu Play!
|
||||
> Jeśli potrzebujesz telefonu z zainstalowanym Play Store wybierz taki, który ma ikonę Play Store!
|
||||
>
|
||||
> <img src="../../images/image (1144).png" alt="" data-size="original">
|
||||
|
||||
W bieżącym widoku będziesz mógł **wybrać i pobrać obraz Androida**, który telefon będzie uruchamiał:
|
||||
W tym widoku będziesz mógł **wybrać i pobrać obraz Androida**, na którym telefon będzie działał:
|
||||
|
||||
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
Więc, wybierz go, a jeśli nie jest pobrany, kliknij na symbol _**Pobierz**_ obok nazwy (**teraz poczekaj, aż obraz zostanie pobrany).**\
|
||||
Gdy obraz zostanie pobrany, po prostu wybierz **`Dalej`** i **`Zakończ`**.
|
||||
Więc wybierz go, a jeśli nie jest pobrany kliknij na symbol _**Download**_ obok nazwy (**now wait until the image is downloaded).**\
|
||||
Po pobraniu obrazu po prostu wybierz **`Next`** i **`Finish`**.
|
||||
|
||||
Maszyna wirtualna zostanie utworzona. Teraz **za każdym razem, gdy uzyskasz dostęp do menedżera AVD, będzie ona obecna**.
|
||||
Maszyna wirtualna zostanie utworzona. Teraz **za każdym razem, gdy wejdziesz do AVD Manager, będzie ona dostępna**.
|
||||
|
||||
### Uruchom Maszynę Wirtualną
|
||||
### Uruchamianie maszyny wirtualnej
|
||||
|
||||
Aby **uruchomić** ją, po prostu naciśnij _**Przycisk Start**_.
|
||||
Aby ją **uruchomić**, naciśnij _**Start button**_.
|
||||
|
||||
.png>)
|
||||
|
||||
## Narzędzie Wiersza Poleceń
|
||||
## Narzędzie wiersza poleceń
|
||||
|
||||
> [!WARNING]
|
||||
> Dla macOS możesz znaleźć narzędzie `avdmanager` w `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` oraz `emulator` w `/Users/<username>/Library/Android/sdk/emulator/emulator`, jeśli je zainstalowałeś.
|
||||
> Dla macOS narzędzie `avdmanager` znajdziesz w `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` a `emulator` w `/Users/<username>/Library/Android/sdk/emulator/emulator` jeśli są zainstalowane.
|
||||
|
||||
Przede wszystkim musisz **zdecydować, którego telefonu chcesz użyć**, aby zobaczyć listę możliwych telefonów, wykonaj:
|
||||
Przede wszystkim musisz **zdecydować, którego telefonu chcesz użyć**, aby zobaczyć listę dostępnych telefonów wykonaj:
|
||||
```
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
|
||||
|
||||
@ -95,8 +95,8 @@ Name: Nexus 10
|
||||
OEM : Google
|
||||
[...]
|
||||
```
|
||||
Gdy zdecydujesz o nazwie urządzenia, które chcesz użyć, musisz **zdecydować, który obraz Androida chcesz uruchomić na tym urządzeniu.**\
|
||||
Możesz wylistować wszystkie opcje używając `sdkmanager`:
|
||||
Po wybraniu nazwy urządzenia, którego chcesz użyć, musisz **zdecydować, który obraz Androida chcesz uruchomić na tym urządzeniu.**\
|
||||
Możesz wyświetlić wszystkie opcje za pomocą `sdkmanager`:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
|
||||
```
|
||||
@ -104,7 +104,7 @@ I **pobierz** ten (lub wszystkie), które chcesz użyć za pomocą:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
|
||||
```
|
||||
Po pobraniu obrazu Android, którego chcesz użyć, możesz **wyświetlić wszystkie pobrane obrazy Android** za pomocą:
|
||||
Po pobraniu obrazu Android, którego chcesz użyć, możesz **wypisać wszystkie pobrane obrazy Androida** za pomocą:
|
||||
```
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
|
||||
----------
|
||||
@ -120,12 +120,11 @@ Type: Platform
|
||||
API level: 29
|
||||
Revision: 4
|
||||
```
|
||||
W tym momencie zdecydowałeś, jakiego urządzenia chcesz użyć i pobrałeś obraz Androida, więc **możesz utworzyć maszynę wirtualną za pomocą**:
|
||||
W tym momencie wybrałeś urządzenie, którego chcesz użyć i pobrałeś obraz Androida, więc **możesz utworzyć maszynę wirtualną przy użyciu**:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
|
||||
```
|
||||
W ostatniej komendzie **stworzyłem VM o nazwie** "_AVD9_" używając **urządzenia** "_Nexus 5X_" oraz **obrazu Android** "_system-images;android-28;google_apis;x86_64_".\
|
||||
Teraz możesz **wyświetlić listę maszyn wirtualnych**, które stworzyłeś za pomocą:
|
||||
W ostatnim poleceniu **utworzyłem maszynę wirtualną nazwaną** "_AVD9_" używając **urządzenia** "_Nexus 5X_" i **obrazu Androida** "_system-images;android-28;google_apis;x86_64_".\ Teraz możesz **wypisać maszyny wirtualne** które utworzyłeś poleceniem:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
|
||||
|
||||
@ -140,60 +139,109 @@ Name: Pixel_2_API_27
|
||||
Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
|
||||
Error: Google pixel_2 no longer exists as a device
|
||||
```
|
||||
### Uruchom Maszynę Wirtualną
|
||||
### Uruchamianie maszyny wirtualnej
|
||||
|
||||
> [!WARNING]
|
||||
> Dla macOS możesz znaleźć narzędzie `avdmanager` w `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` oraz `emulator` w `/Users/<username>/Library/Android/sdk/emulator/emulator`, jeśli je zainstalowałeś.
|
||||
> Dla macOS możesz znaleźć narzędzie `avdmanager` w `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` i `emulator` w `/Users/<username>/Library/Android/sdk/emulator/emulator`, jeśli masz je zainstalowane.
|
||||
|
||||
Już widzieliśmy, jak możesz wylistować utworzone maszyny wirtualne, ale **możesz je również wylistować używając**:
|
||||
Widzieliśmy już, jak wyświetlić utworzone maszyny wirtualne, ale **można je także wylistować za pomocą**:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
|
||||
AVD9
|
||||
Pixel_2_API_27
|
||||
```
|
||||
Możesz po prostu **uruchomić dowolną maszynę wirtualną utworzoną** za pomocą:
|
||||
Możesz po prostu **uruchomić dowolną utworzoną maszynę wirtualną** używając:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
|
||||
```
|
||||
Lub korzystając z bardziej zaawansowanych opcji, możesz uruchomić maszynę wirtualną, taką jak:
|
||||
Lub używając bardziej zaawansowanych opcji możesz uruchomić maszynę wirtualną taką jak:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
|
||||
```
|
||||
### Opcje wiersza poleceń
|
||||
|
||||
Jednak istnieje **wiele różnych przydatnych opcji wiersza poleceń**, które możesz wykorzystać do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, ale możesz [**znaleźć pełną listę tutaj**](https://developer.android.com/studio/run/emulator-commandline)
|
||||
Jednak istnieje **wiele różnych przydatnych opcji wiersza poleceń**, których możesz użyć do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, a pełną listę możesz [**znaleźć tutaj**](https://developer.android.com/studio/run/emulator-commandline)
|
||||
|
||||
**Uruchamianie**
|
||||
**Rozruch**
|
||||
|
||||
- `-snapshot name` : Uruchom snapshot VM
|
||||
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Wyświetl wszystkie zarejestrowane snapshoty
|
||||
|
||||
**Sieć**
|
||||
|
||||
- `-dns-server 192.0.2.0, 192.0.2.255` : Pozwól wskazać oddzielone przecinkami serwery DNS dla VM.
|
||||
- **`-http-proxy 192.168.1.12:8080`** : Pozwól wskazać proxy HTTP do użycia (bardzo przydatne do przechwytywania ruchu za pomocą Burp)
|
||||
- Jeśli ustawienia proxy nie działają z jakiegoś powodu, spróbuj skonfigurować je wewnętrznie lub używając aplikacji takiej jak "Super Proxy" lub "ProxyDroid".
|
||||
- `-netdelay 200` : Ustaw emulację opóźnienia sieci w milisekundach.
|
||||
- `-port 5556` : Ustaw numer portu TCP używanego dla konsoli i adb.
|
||||
- `-dns-server 192.0.2.0, 192.0.2.255` : Pozwala wskazać serwery DNS oddzielone przecinkami dla VM.
|
||||
- **`-http-proxy 192.168.1.12:8080`** : Pozwala wskazać HTTP proxy do użycia (bardzo przydatne do przechwytywania ruchu przy użyciu Burp)
|
||||
- Jeśli ustawienia proxy nie działają z jakiegoś powodu, spróbuj skonfigurować je wewnętrznie lub użyć aplikacji takiej jak "Super Proxy" lub "ProxyDroid".
|
||||
- `-netdelay 200` : Ustaw emulowaną latencję sieciową w milisekundach.
|
||||
- `-port 5556` : Ustaw numer portu TCP używany dla konsoli i adb.
|
||||
- `-ports 5556,5559` : Ustaw porty TCP używane dla konsoli i adb.
|
||||
- **`-tcpdump /path/dumpfile.cap`** : Przechwyć cały ruch do pliku
|
||||
- **`-tcpdump /path/dumpfile.cap`** : Zapisz cały ruch do pliku
|
||||
|
||||
**System**
|
||||
|
||||
- `-selinux {disabled|permissive}` : Ustaw moduł zabezpieczeń Security-Enhanced Linux na tryb wyłączony lub permissive w systemie operacyjnym Linux.
|
||||
- `-selinux {disabled|permissive}` : Ustaw moduł Security-Enhanced Linux (SELinux) w tryb disabled lub permissive.
|
||||
- `-timezone Europe/Paris` : Ustaw strefę czasową dla urządzenia wirtualnego
|
||||
- `-screen {touch(default)|multi-touch|o-touch}` : Ustaw emulowany tryb ekranu dotykowego.
|
||||
- **`-writable-system`** : Użyj tej opcji, aby mieć zapisywalny obraz systemu podczas sesji emulacji. Będziesz musiał również uruchomić `adb root; adb remount`. To jest bardzo przydatne do zainstalowania nowego certyfikatu w systemie.
|
||||
- `-screen {touch(default)|multi-touch|o-touch}` : Ustaw tryb emulowanego ekranu dotykowego.
|
||||
- **`-writable-system`** : Użyj tej opcji, aby mieć zapisywalny obraz systemu podczas sesji emulacji. Będziesz musiał także uruchomić `adb root; adb remount`. To bardzo przydatne do instalacji nowego certyfikatu w systemie.
|
||||
|
||||
## Konfiguracja CLI na Linuxie (SDK/AVD quickstart)
|
||||
|
||||
Oficjalne narzędzia CLI ułatwiają tworzenie szybkich, debugowalnych emulatorów bez Android Studio.
|
||||
```bash
|
||||
# Directory layout
|
||||
mkdir -p ~/Android/cmdline-tools/latest
|
||||
|
||||
# Download commandline tools (Linux)
|
||||
wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
|
||||
unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
|
||||
rm /tmp/cmdline-tools.zip
|
||||
|
||||
# Env vars (add to ~/.bashrc or ~/.zshrc)
|
||||
export ANDROID_HOME=$HOME/Android
|
||||
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH
|
||||
|
||||
# Install core SDK components
|
||||
sdkmanager --install "platform-tools" "emulator"
|
||||
|
||||
# Install a debuggable x86_64 system image (Android 11 / API 30)
|
||||
sdkmanager --install "system-images;android-30;google_apis;x86_64"
|
||||
|
||||
# Create an AVD and run it with a writable /system & snapshot name
|
||||
avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
|
||||
emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap
|
||||
|
||||
# Verify root (debuggable images allow `adb root`)
|
||||
adb root
|
||||
adb shell whoami # expect: root
|
||||
```
|
||||
Notatki
|
||||
- Warianty obrazów systemu: google_apis (z możliwością debugowania, pozwala na `adb root`), google_apis_playstore (nie da się uzyskać roota), aosp/default (lekki).
|
||||
- Typy buildów: userdebug często pozwala na `adb root` na obrazach z możliwością debugowania. Obrazy Play Store to buildy produkcyjne i blokują roota.
|
||||
- Na hostach x86_64 pełna emulacja systemu ARM64 nie jest obsługiwana od API 28+. Dla Androida 11+ użyj obrazów Google APIs/Play, które zawierają per-app ARM-to-x86 translation, aby szybko uruchamiać wiele aplikacji przeznaczonych tylko dla ARM.
|
||||
|
||||
### Migawki z CLI
|
||||
```bash
|
||||
# Save a clean snapshot from the running emulator
|
||||
adb -s emulator-5554 emu avd snapshot save my_clean_setup
|
||||
|
||||
# Boot from a named snapshot (if it exists)
|
||||
emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
|
||||
```
|
||||
## ARM→x86 tłumaczenie binarne (Android 11+)
|
||||
|
||||
Obrazy Google APIs i Play Store na Android 11+ potrafią tłumaczyć binaria aplikacji ARM dla każdego procesu, zachowując resztę systemu natywną (x86/x86_64). Zwykle jest to wystarczająco szybkie, by testować wiele aplikacji przeznaczonych wyłącznie dla ARM na desktopie.
|
||||
|
||||
> Porada: Preferuj obrazy Google APIs x86/x86_64 podczas pentests. Obrazy Play są wygodne, ale blokują `adb root`; używaj ich tylko, gdy konkretnie potrzebujesz Play services i zaakceptujesz brak root.
|
||||
|
||||
## Rootowanie urządzenia z Play Store
|
||||
|
||||
Jeśli pobrałeś urządzenie z Play Store, nie będziesz mógł uzyskać dostępu do roota bezpośrednio i otrzymasz ten komunikat o błędzie
|
||||
Jeśli pobrałeś urządzenie z Play Store, nie będziesz w stanie bezpośrednio uzyskać root i otrzymasz ten komunikat o błędzie
|
||||
```
|
||||
$ adb root
|
||||
adbd cannot run as root in production builds
|
||||
```
|
||||
Używając [rootAVD](https://github.com/newbit1/rootAVD) z [Magisk](https://github.com/topjohnwu/Magisk) udało mi się go zrootować (zobacz na przykład [**ten film**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **lub** [**ten**](https://www.youtube.com/watch?v=qQicUW0svB8)).
|
||||
Używając [rootAVD](https://github.com/newbit1/rootAVD) z [Magisk](https://github.com/topjohnwu/Magisk) udało mi się uzyskać root (na przykład obejrzyj [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **or** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)).
|
||||
|
||||
## Zainstaluj certyfikat Burp
|
||||
|
||||
@ -204,12 +252,18 @@ Sprawdź następującą stronę, aby dowiedzieć się, jak zainstalować niestan
|
||||
install-burp-certificate.md
|
||||
{{#endref}}
|
||||
|
||||
## Fajne opcje AVD
|
||||
## Przydatne opcje AVD
|
||||
|
||||
### Zrób zrzut ekranu
|
||||
### Wykonaj snapshot
|
||||
|
||||
Możesz **użyć GUI**, aby w dowolnym momencie zrobić zrzut ekranu VM:
|
||||
Możesz **użyć GUI**, aby wykonać snapshot VM w dowolnym momencie:
|
||||
|
||||
.png>)
|
||||
|
||||
## Źródła
|
||||
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
|
||||
- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Frida Tutorial
|
||||
# Poradnik Frida
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,41 +10,93 @@ Zainstaluj **frida tools**:
|
||||
pip install frida-tools
|
||||
pip install frida
|
||||
```
|
||||
**Pobierz i zainstaluj** na Androidzie **serwer frida** ([Pobierz najnowszą wersję](https://github.com/frida/frida/releases)).\
|
||||
Jedna linia do ponownego uruchomienia adb w trybie root, połączenia z nim, przesłania serwera frida, nadania uprawnień do wykonywania i uruchomienia go w tle:
|
||||
**Pobierz i zainstaluj** na urządzeniu z Androidem **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ Jednolinijkowe polecenie, aby zrestartować adb w trybie root, połączyć się z urządzeniem, przesłać frida-server, nadać prawa wykonywania i uruchomić go w tle:
|
||||
```bash
|
||||
adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
|
||||
```
|
||||
**Sprawdź**, czy to **działa**:
|
||||
**Sprawdź** czy to **działa**:
|
||||
```bash
|
||||
frida-ps -U #List packages and processes
|
||||
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
|
||||
```
|
||||
## Frida server vs. Gadget (root vs. no-root)
|
||||
|
||||
Dwa powszechne sposoby instrumentowania aplikacji Android przy użyciu Frida:
|
||||
|
||||
- Frida server (rooted devices): Wgraj i uruchom natywny daemon, który pozwala dołączyć do dowolnego procesu.
|
||||
- Frida Gadget (no root): Dołącz Frida jako bibliotekę współdzieloną wewnątrz APK i automatycznie załaduj ją w docelowym procesie.
|
||||
|
||||
Frida server (rooted)
|
||||
```bash
|
||||
# Download the matching frida-server binary for your device's arch
|
||||
# https://github.com/frida/frida/releases
|
||||
adb root
|
||||
adb push frida-server-<ver>-android-<arch> /data/local/tmp/frida-server
|
||||
adb shell chmod 755 /data/local/tmp/frida-server
|
||||
adb shell /data/local/tmp/frida-server & # run at boot via init/magisk if desired
|
||||
|
||||
# From host, list processes and attach
|
||||
frida-ps -Uai
|
||||
frida -U -n com.example.app
|
||||
```
|
||||
Frida Gadget (no-root)
|
||||
|
||||
1) Rozpakuj APK, dodaj gadget .so i konfigurację:
|
||||
- Umieść libfrida-gadget.so w lib/<abi>/ (np. lib/arm64-v8a/)
|
||||
- Utwórz assets/frida-gadget.config z ustawieniami ładowania skryptów
|
||||
|
||||
Przykład frida-gadget.config
|
||||
```json
|
||||
{
|
||||
"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
|
||||
"runtime": { "logFile": "/sdcard/frida-gadget.log" }
|
||||
}
|
||||
```
|
||||
2) Referencuj/załaduj gadget tak, aby był zainicjalizowany wcześnie:
|
||||
- Najprościej: Dodaj mały Java stub wywołujący System.loadLibrary("frida-gadget") w Application.onCreate(), lub użyj istniejącego mechanizmu ładowania bibliotek natywnych.
|
||||
|
||||
3) Przepakuj i podpisz APK, a następnie zainstaluj:
|
||||
```bash
|
||||
apktool d app.apk -o app_m
|
||||
# ... add gadget .so and config ...
|
||||
apktool b app_m -o app_gadget.apk
|
||||
uber-apk-signer -a app_gadget.apk -o out_signed
|
||||
adb install -r out_signed/app_gadget-aligned-debugSigned.apk
|
||||
```
|
||||
4) Podłącz się z hosta do procesu gadget:
|
||||
```bash
|
||||
frida-ps -Uai
|
||||
frida -U -n com.example.app
|
||||
```
|
||||
Notatki
|
||||
- Gadget jest wykrywany przez niektóre mechanizmy ochronne; utrzymuj nazwy/ścieżki dyskretne i ładuj późno/lub warunkowo, jeśli to konieczne.
|
||||
- W przypadku aplikacji wzmocnionych, preferuj rooted testing z server + late attach, lub połącz to z ukrywaniem Magisk/Zygisk.
|
||||
|
||||
## Samouczki
|
||||
|
||||
### [Samouczek 1](frida-tutorial-1.md)
|
||||
|
||||
**Z**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
|
||||
**Źródło**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
|
||||
**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
|
||||
**Kod źródłowy**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
|
||||
|
||||
**Śledź [link, aby to przeczytać](frida-tutorial-1.md).**
|
||||
**Przejdź do [linku, aby przeczytać](frida-tutorial-1.md).**
|
||||
|
||||
### [Samouczek 2](frida-tutorial-2.md)
|
||||
|
||||
**Z**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Części 2, 3 i 4)\
|
||||
**APKi i kod źródłowy**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
|
||||
**Źródło**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Części 2, 3 & 4)\
|
||||
**APKs i kod źródłowy**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
|
||||
|
||||
**Śledź [link, aby to przeczytać.](frida-tutorial-2.md)**
|
||||
**Przejdź do [linku, aby przeczytać.](frida-tutorial-2.md)**
|
||||
|
||||
### [Samouczek 3](owaspuncrackable-1.md)
|
||||
|
||||
**Z**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
**Źródło**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk)
|
||||
|
||||
**Śledź [link, aby to przeczytać](owaspuncrackable-1.md).**
|
||||
**Przejdź do [linku, aby przeczytać](owaspuncrackable-1.md).**
|
||||
|
||||
**Możesz znaleźć więcej niesamowitych skryptów Frida tutaj:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
**Tu znajdziesz więcej świetnych skryptów Frida:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
|
||||
## Szybkie przykłady
|
||||
|
||||
@ -61,7 +113,7 @@ frida -U --no-pause -l disableRoot.js -f owasp.mstg.uncrackable1
|
||||
#frozen so that the instrumentation can occur, and the automatically
|
||||
#continue execution with our modified code.
|
||||
```
|
||||
### Podstawowy skrypt Pythona
|
||||
### Podstawowy skrypt w Pythonie
|
||||
```python
|
||||
import frida, sys
|
||||
|
||||
@ -72,9 +124,9 @@ print('[ * ] Running Frida Demo application')
|
||||
script.load()
|
||||
sys.stdin.read()
|
||||
```
|
||||
### Hookowanie funkcji bez parametrów
|
||||
### Hooking funkcji bez parametrów
|
||||
|
||||
Hookuj funkcję `a()` klasy `sg.vantagepoint.a.c`
|
||||
Hook funkcję `a()` klasy `sg.vantagepoint.a.c`
|
||||
```javascript
|
||||
Java.perform(function () {
|
||||
; rootcheck1.a.overload().implementation = function() {
|
||||
@ -91,7 +143,7 @@ sysexit.exit.overload("int").implementation = function (var_0) {
|
||||
send("java.lang.System.exit(I)V // We avoid exiting the application :)")
|
||||
}
|
||||
```
|
||||
Hook MainActivity `.onStart()` i `.onCreate()`
|
||||
Hook MainActivity `.onStart()` & `.onCreate()`
|
||||
```javascript
|
||||
var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity")
|
||||
mainactivity.onStart.overload().implementation = function () {
|
||||
@ -115,9 +167,9 @@ send("Activity HIT!!!")
|
||||
var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
|
||||
}
|
||||
```
|
||||
### Hooking functions with parameters and retrieving the value
|
||||
### Hooking funkcji z parametrami i pobierania wartości
|
||||
|
||||
Hookowanie funkcji deszyfrującej. Wydrukuj dane wejściowe, wywołaj oryginalną funkcję, aby deszyfrować dane wejściowe, a na koniec wydrukuj dane w postaci jawnej:
|
||||
Hooking funkcji deszyfrującej. Wydrukuj dane wejściowe, wywołaj oryginalną funkcję, aby odszyfrować wejście i na końcu wydrukuj odszyfrowane dane:
|
||||
```javascript
|
||||
function getString(data) {
|
||||
var ret = ""
|
||||
@ -142,9 +194,9 @@ send("Decrypted flag: " + flag)
|
||||
return ret //[B
|
||||
}
|
||||
```
|
||||
### Hookowanie funkcji i wywoływanie ich z naszym wejściem
|
||||
### Hooking functions i wywoływanie ich z naszym inputem
|
||||
|
||||
Hookuj funkcję, która przyjmuje ciąg znaków i wywołaj ją z innym ciągiem (z [tutaj](https://11x256.github.io/Frida-hooking-android-part-2/))
|
||||
Hook funkcję, która przyjmuje string i wywołaj ją z innym stringiem (z [here](https://11x256.github.io/Frida-hooking-android-part-2/))
|
||||
```javascript
|
||||
var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class
|
||||
|
||||
@ -157,11 +209,11 @@ console.log("Return value: " + ret)
|
||||
return ret
|
||||
}
|
||||
```
|
||||
### Uzyskiwanie już utworzonego obiektu klasy
|
||||
### Pobieranie już utworzonego obiektu klasy
|
||||
|
||||
Jeśli chcesz wyodrębnić jakiś atrybut utworzonego obiektu, możesz to zrobić.
|
||||
Jeśli chcesz wyciągnąć jakiś atrybut z utworzonego obiektu, możesz użyć tego.
|
||||
|
||||
W tym przykładzie zobaczysz, jak uzyskać obiekt klasy my_activity i jak wywołać funkcję .secret(), która wydrukuje prywatny atrybut obiektu:
|
||||
W tym przykładzie zobaczysz, jak pobrać obiekt klasy my_activity i jak wywołać funkcję .secret(), która wydrukuje prywatny atrybut obiektu:
|
||||
```javascript
|
||||
Java.choose("com.example.a11x256.frida_test.my_activity", {
|
||||
onMatch: function (instance) {
|
||||
@ -175,7 +227,13 @@ onComplete: function () {},
|
||||
## Inne samouczki Frida
|
||||
|
||||
- [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
|
||||
- [Część 1 serii blogów o zaawansowanym użyciu Frida: Biblioteki szyfrowania IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
|
||||
- [Część 1 serii blogowej Advanced Frida Usage: Biblioteki szyfrowania iOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
|
||||
|
||||
|
||||
## Źródła
|
||||
|
||||
- [Zbuduj powtarzalne laboratorium Android Bug Bounty: Emulator vs Magisk, Burp, Frida i Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
- [Dokumentacja Frida Gadget](https://frida.re/docs/gadget/)
|
||||
- [Wydania Frida (server binaries)](https://github.com/frida/frida/releases)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,20 +1,32 @@
|
||||
# Zainstaluj certyfikat Burp
|
||||
# Install Burp Certificate
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## System-wide proxy via ADB
|
||||
|
||||
Skonfiguruj globalne proxy HTTP, aby wszystkie aplikacje kierowały ruch przez twój interceptor (Burp/mitmproxy):
|
||||
```bash
|
||||
# Set proxy (device/emulator must reach your host IP)
|
||||
adb shell settings put global http_proxy 192.168.1.2:8080
|
||||
|
||||
# Clear proxy
|
||||
adb shell settings put global http_proxy :0
|
||||
```
|
||||
Tip: In Burp, bind your listener to 0.0.0.0 so devices on the LAN can connect (Proxy -> Options -> Proxy Listeners).
|
||||
|
||||
## Na maszynie wirtualnej
|
||||
|
||||
Przede wszystkim musisz pobrać certyfikat Der z Burp. Możesz to zrobić w _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
|
||||
Najpierw musisz pobrać certyfikat Der z Burp. Możesz to zrobić w _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
|
||||
|
||||
.png>)
|
||||
|
||||
**Eksportuj certyfikat w formacie Der** i przekształć go do formy, którą **Android** będzie w stanie **zrozumieć.** Zauważ, że **aby skonfigurować certyfikat burp na maszynie Android w AVD** musisz **uruchomić** tę maszynę **z** opcją **`-writable-system`**.\
|
||||
**Eksportuj certyfikat w formacie Der** i zamień go na formę, którą **Android** będzie w stanie **obsłużyć.** Zwróć uwagę, że **aby skonfigurować certyfikat Burp na maszynie Android w AVD** musisz **uruchomić** tę maszynę **z** opcją **`-writable-system`**.\
|
||||
Na przykład możesz uruchomić ją tak:
|
||||
```bash
|
||||
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
|
||||
```
|
||||
Aby **skonfigurować certyfikat burp**:
|
||||
Następnie, aby **skonfigurować certyfikat burps, wykonaj:**
|
||||
```bash
|
||||
openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
|
||||
CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
|
||||
@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
|
||||
adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
|
||||
adb reboot #Now, reboot the machine
|
||||
```
|
||||
Gdy **maszyna zakończy ponowne uruchamianie**, certyfikat burp będzie używany!
|
||||
Gdy **machine finish rebooting** burp certificate będzie przez nią używany!
|
||||
|
||||
## Używanie Magisc
|
||||
## Korzystanie z Magisc
|
||||
|
||||
Jeśli **zrootowałeś swoje urządzenie za pomocą Magisc** (może emulator), a **nie możesz wykonać** poprzednich **kroków** w celu zainstalowania certyfikatu Burp, ponieważ **system plików jest tylko do odczytu** i nie możesz go zamontować jako zapisywalny, istnieje inny sposób.
|
||||
Jeśli **rootowałeś urządzenie z Magisc** (może emulator) i **nie możesz wykonać** poprzednich **kroków** aby zainstalować Burp cert, ponieważ **filesystem jest tylko do odczytu** i nie możesz go zamontować jako zapisywalny, istnieje inne rozwiązanie.
|
||||
|
||||
Wyjaśnione w [**tym filmie**](https://www.youtube.com/watch?v=qQicUW0svB8) musisz:
|
||||
Wyjaśnione w [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) musisz:
|
||||
|
||||
1. **Zainstalować certyfikat CA**: Po prostu **przeciągnij i upuść** certyfikat DER Burp **zmieniając rozszerzenie** na `.crt` w telefonie, aby był przechowywany w folderze Pobrane, a następnie przejdź do `Zainstaluj certyfikat` -> `Certyfikat CA`
|
||||
1. **Install a CA certificate**: Po prostu **drag&drop** DER Burp certificate **zmieniając rozszerzenie** na `.crt` na mobile aby został zapisany w Downloads folder i przejdź do `Install a certificate` -> `CA certificate`
|
||||
|
||||
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
|
||||
|
||||
- Sprawdź, czy certyfikat został poprawnie zapisany, przechodząc do `Zaufane poświadczenia` -> `UŻYTKOWNIK`
|
||||
- Sprawdź, że certyfikat został poprawnie zapisany przechodząc do `Trusted credentials` -> `USER`
|
||||
|
||||
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
|
||||
|
||||
2. **Uczynić go zaufanym przez system**: Pobierz moduł Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (plik .zip), **przeciągnij i upuść go** w telefonie, przejdź do aplikacji **Magics** w telefonie do sekcji **`Moduły`**, kliknij **`Zainstaluj z pamięci`**, wybierz moduł `.zip`, a po zainstalowaniu **zrestartuj** telefon:
|
||||
2. **Make it System trusted**: Pobierz Magisc moduł [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (plik .zip), **drag&drop go** na telefon, otwórz **Magics app** na telefonie w sekcji **`Modules`**, kliknij **`Install from storage`**, wybierz `.zip` moduł i po instalacji **reboot** telefonu:
|
||||
|
||||
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
|
||||
|
||||
- Po ponownym uruchomieniu przejdź do `Zaufane poświadczenia` -> `SYSTEM` i sprawdź, czy certyfikat Postswigger jest tam
|
||||
- Po reboot, przejdź do `Trusted credentials` -> `SYSTEM` i sprawdź, że Postswigger cert tam jest
|
||||
|
||||
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
|
||||
|
||||
## Po Androidzie 14
|
||||
### Learn how to create a Magisc module
|
||||
|
||||
W najnowszej wersji Androida 14 zaobserwowano znaczną zmianę w obsłudze certyfikatów urzędów certyfikacji (CA) zaufanych przez system. Wcześniej certyfikaty te znajdowały się w **`/system/etc/security/cacerts/`**, dostępne i modyfikowalne przez użytkowników z uprawnieniami roota, co pozwalało na natychmiastowe zastosowanie w całym systemie. Jednak w Androidzie 14 lokalizacja przechowywania została przeniesiona do **`/apex/com.android.conscrypt/cacerts`**, katalogu w ścieżce **`/apex`**, który jest z natury niemodyfikowalny.
|
||||
Sprawdź [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
|
||||
|
||||
Próby ponownego zamontowania **ścieżki APEX cacerts** jako zapisywalnej kończą się niepowodzeniem, ponieważ system nie pozwala na takie operacje. Nawet próby odmontowania lub nałożenia na katalog tymczasowego systemu plików (tmpfs) nie omijają niemodyfikowalności; aplikacje nadal uzyskują dostęp do oryginalnych danych certyfikatu, niezależnie od zmian na poziomie systemu plików. Ta odporność wynika z faktu, że montaż **`/apex`** jest skonfigurowany z propagacją PRIVATE, co zapewnia, że wszelkie modyfikacje w katalogu **`/apex`** nie wpływają na inne procesy.
|
||||
## Po Android 14
|
||||
|
||||
Inicjalizacja Androida obejmuje proces `init`, który, uruchamiając system operacyjny, również inicjuje proces Zygote. Proces ten jest odpowiedzialny za uruchamianie procesów aplikacji z nową przestrzenią montowania, która obejmuje prywatny montaż **`/apex`**, izolując tym samym zmiany w tym katalogu od innych procesów.
|
||||
W najnowszym wydaniu Android 14 zaobserwowano istotną zmianę w obsłudze system-trusted Certificate Authority (CA) certificates. Wcześniej te certyfikaty były przechowywane w **`/system/etc/security/cacerts/`**, dostępne i modyfikowalne przez użytkowników z uprawnieniami root, co pozwalało na ich natychmiastowe zastosowanie w całym systemie. Jednak w Android 14 lokalizacja przechowywania została przeniesiona do **`/apex/com.android.conscrypt/cacerts`**, katalogu w ścieżce **`/apex`**, który z natury jest niemutowalny.
|
||||
|
||||
Niemniej jednak istnieje obejście dla tych, którzy potrzebują zmodyfikować certyfikaty CA zaufane przez system w katalogu **`/apex`**. Polega to na ręcznym ponownym zamontowaniu **`/apex`**, aby usunąć propagację PRIVATE, co czyni go zapisywalnym. Proces obejmuje skopiowanie zawartości **`/apex/com.android.conscrypt`** do innej lokalizacji, odmontowanie katalogu **`/apex/com.android.conscrypt`**, aby wyeliminować ograniczenie tylko do odczytu, a następnie przywrócenie zawartości do ich pierwotnej lokalizacji w **`/apex`**. To podejście wymaga szybkiego działania, aby uniknąć awarii systemu. Aby zapewnić systemowe zastosowanie tych zmian, zaleca się ponowne uruchomienie `system_server`, co skutecznie restartuje wszystkie aplikacje i przywraca system do spójnego stanu.
|
||||
Próby ponownego zamontowania **APEX cacerts path** jako zapisywalnego kończą się niepowodzeniem, ponieważ system nie pozwala na takie operacje. Nawet próby odmontowania lub nadpisania katalogu tymczasowym systemem plików (tmpfs) nie obchodzą niemutowalności; aplikacje nadal odczytują oryginalne dane certyfikatów niezależnie od zmian na poziomie systemu plików. Ta odporność wynika z faktu, że montowanie **`/apex`** jest skonfigurowane z PRIVATE propagation, co zapewnia, że jakiekolwiek modyfikacje wewnątrz katalogu **`/apex`** nie wpływają na inne procesy.
|
||||
|
||||
Inicjalizacja Androida obejmuje proces `init`, który przy uruchamianiu systemu operacyjnego także inicjuje proces Zygote. Ten proces jest odpowiedzialny za uruchamianie procesów aplikacji z nową przestrzenią nazw montowania, która zawiera prywatny mount **`/apex`**, izolując w ten sposób zmiany w tym katalogu od innych procesów.
|
||||
|
||||
Niemniej jednak istnieje obejście dla tych, którzy potrzebują modyfikować system-trusted CA certificates w katalogu **`/apex`**. Polega ono na ręcznym ponownym zamontowaniu **`/apex`** aby usunąć PRIVATE propagation, czyniąc go zapisywalnym. Proces obejmuje skopiowanie zawartości **`/apex/com.android.conscrypt`** do innej lokalizacji, odmontowanie katalogu **`/apex/com.android.conscrypt`** aby wyeliminować ograniczenie tylko do odczytu, a następnie przywrócenie zawartości na oryginalne miejsce w **`/apex`**. Podejście to wymaga szybkiego działania, aby uniknąć awarii systemu. Aby zapewnić zastosowanie tych zmian w całym systemie, zaleca się zrestartowanie `system_server`, co efektywnie restartuje wszystkie aplikacje i przywraca system do spójnego stanu.
|
||||
```bash
|
||||
# Create a separate temp directory, to hold the current certificates
|
||||
# Otherwise, when we add the mount we can't read the current certs anymore.
|
||||
@ -117,26 +133,26 @@ echo "System certificate injected"
|
||||
```
|
||||
### Bind-mounting through NSEnter
|
||||
|
||||
1. **Ustawienie zapisywalnego katalogu**: Początkowo tworzony jest zapisywalny katalog poprzez zamontowanie `tmpfs` nad istniejącym katalogiem certyfikatów systemowych, który nie jest APEX. Osiąga się to za pomocą następującego polecenia:
|
||||
1. **Konfigurowanie katalogu zapisywalnego**: Najpierw tworzy się katalog umożliwiający zapis, montując `tmpfs` nad istniejącym katalogiem certyfikatów systemowych non-APEX. Robi się to za pomocą następującego polecenia:
|
||||
```bash
|
||||
mount -t tmpfs tmpfs /system/etc/security/cacerts
|
||||
```
|
||||
2. **Przygotowanie certyfikatów CA**: Po skonfigurowaniu zapisywalnego katalogu, certyfikaty CA, które zamierza się użyć, powinny zostać skopiowane do tego katalogu. Może to obejmować skopiowanie domyślnych certyfikatów z `/apex/com.android.conscrypt/cacerts/`. Ważne jest, aby odpowiednio dostosować uprawnienia i etykiety SELinux tych certyfikatów.
|
||||
3. **Zamontowanie dla Zygote**: Wykorzystując `nsenter`, wchodzi się do przestrzeni nazw montowania Zygote. Zygote, będący procesem odpowiedzialnym za uruchamianie aplikacji Android, wymaga tego kroku, aby zapewnić, że wszystkie aplikacje uruchamiane odtąd korzystają z nowo skonfigurowanych certyfikatów CA. Używana komenda to:
|
||||
2. **Preparing CA Certificates**: Po skonfigurowaniu zapisywalnego katalogu, CA certificates, które zamierzasz użyć, należy skopiować do tego katalogu. Może to wymagać skopiowania domyślnych certyfikatów z `/apex/com.android.conscrypt/cacerts/`. Należy odpowiednio ustawić uprawnienia i etykiety SELinux tych certyfikatów.
|
||||
3. **Bind Mounting for Zygote**: Używając `nsenter`, wchodzi się do mount namespace procesu Zygote. Zygote, będący procesem odpowiedzialnym za uruchamianie aplikacji Android, wymaga tego kroku, aby wszystkie później uruchamiane aplikacje korzystały z nowo skonfigurowanych CA certificates. Użyta komenda to:
|
||||
```bash
|
||||
nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
|
||||
```
|
||||
To zapewnia, że każda nowa aplikacja uruchomiona będzie przestrzegać zaktualizowanego ustawienia certyfikatów CA.
|
||||
To zapewnia, że każda nowo uruchomiona aplikacja będzie stosować zaktualizowaną konfigurację certyfikatów CA.
|
||||
|
||||
4. **Zastosowanie zmian w działających aplikacjach**: Aby zastosować zmiany w już działających aplikacjach, ponownie używa się `nsenter`, aby wejść do przestrzeni nazw każdej aplikacji indywidualnie i wykonać podobne powiązanie montażu. Niezbędne polecenie to:
|
||||
4. **Zastosowanie zmian w działających aplikacjach**: Aby zastosować zmiany w już działających aplikacjach, ponownie używa się `nsenter`, aby wejść do namespace każdej aplikacji indywidualnie i wykonać podobny bind mount. Niezbędne polecenie to:
|
||||
```bash
|
||||
nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
|
||||
```
|
||||
5. **Alternatywne podejście - Miękki restart**: Alternatywna metoda polega na wykonaniu bind mount na procesie `init` (PID 1), a następnie na miękkim restarcie systemu operacyjnego za pomocą poleceń `stop && start`. To podejście propagowałoby zmiany we wszystkich przestrzeniach nazw, unikając potrzeby indywidualnego adresowania każdej działającej aplikacji. Jednak ta metoda jest zazwyczaj mniej preferowana z powodu niedogodności związanych z restartem.
|
||||
5. **Alternatywne podejście - Soft Reboot**: Alternatywna metoda polega na wykonaniu bind mount na procesie `init` (PID 1), a następnie przeprowadzeniu soft reboot systemu operacyjnego za pomocą poleceń `stop && start`. To podejście spowoduje propagację zmian we wszystkich namespaces, eliminując potrzebę indywidualnego adresowania każdej uruchomionej aplikacji. Jednak ta metoda jest zazwyczaj mniej preferowana ze względu na niedogodność związaną z ponownym uruchomieniem.
|
||||
|
||||
## References
|
||||
|
||||
- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
|
||||
## Źródła
|
||||
|
||||
- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
|
||||
- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user