diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 432bf44fc..e7e49e187 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -326,6 +326,7 @@ - [Android APK Checklist](mobile-pentesting/android-checklist.md) - [Android Applications Pentesting](mobile-pentesting/android-app-pentesting/README.md) - [Accessibility Services Abuse](mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md) + - [Android Anti Instrumentation And Ssl Pinning Bypass](mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md) - [Android Applications Basics](mobile-pentesting/android-app-pentesting/android-applications-basics.md) - [Android Task Hijacking](mobile-pentesting/android-app-pentesting/android-task-hijacking.md) - [ADB Commands](mobile-pentesting/android-app-pentesting/adb-commands.md) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index ada01380b..43ee29ed0 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -13,14 +13,14 @@ android-applications-basics.md ## ADB (Android Debug Bridge) To główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem z Androidem (emulowanym lub fizycznym).\ -**ADB** umożliwia kontrolowanie urządzeń zarówno przez **USB**, jak i **sieć** z komputera. To narzędzie pozwala na **kopiowanie** plików w obu kierunkach, **instalację** i **odinstalację** aplikacji, **wykonywanie** poleceń powłoki, **tworzenie kopii zapasowych** danych, **odczytywanie** logów, wśród innych funkcji. +**ADB** umożliwia kontrolowanie urządzeń zarówno przez **USB**, jak i **sieć** z komputera. To narzędzie pozwala na **kopiowanie** plików w obie strony, **instalację** i **odinstalowanie** aplikacji, **wykonywanie** poleceń powłoki, **tworzenie kopii zapasowych** danych, **odczytywanie** logów, wśród innych funkcji. Zobacz poniższą listę [**komend ADB**](adb-commands.md), aby dowiedzieć się, jak używać adb. ## Smali Czasami interesujące jest **modyfikowanie kodu aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (może dobrze obfuskowanych haseł lub flag). Wtedy może być interesujące dekompilowanie apk, modyfikowanie kodu i ponowne kompilowanie go.\ -[**W tym samouczku** możesz **dowiedzieć się, jak dekompilować APK, modyfikować kod Smali i ponownie kompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które będą przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**. +[**W tym samouczku** możesz **nauczyć się, jak dekompilować APK, modyfikować kod Smali i ponownie kompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które będą przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**. ## Inne interesujące triki @@ -48,7 +48,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Studium przypadków i luki +## Case Studies & Vulnerabilities {{#ref}} ../ios-pentesting/air-keyboard-remote-input-injection.md @@ -58,31 +58,31 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Analiza statyczna +## Static Analysis Przede wszystkim, aby przeanalizować APK, powinieneś **rzucić okiem na kod Java** za pomocą dekompilatora.\ Proszę, [**przeczytaj tutaj, aby znaleźć informacje o różnych dostępnych dekompilatorach**](apk-decompilers.md). -### Szukanie interesujących informacji +### Looking for interesting Info Rzucając okiem na **ciągi** APK, możesz szukać **haseł**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **kluczy** **api**, **szyfrowania**, **uuid bluetooth**, **tokenów** i wszystkiego, co interesujące... szukaj nawet **tylnych drzwi** do wykonania kodu lub tylnych drzwi uwierzytelniających (twardo zakodowane dane logowania administratora do aplikacji). **Firebase** -Zwróć szczególną uwagę na **adresy URL Firebase** i sprawdź, czy są źle skonfigurowane. [Więcej informacji o tym, czym jest Firebase i jak go wykorzystać, znajdziesz tutaj.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Zwróć szczególną uwagę na **adresy URL Firebase** i sprawdź, czy są źle skonfigurowane. [Więcej informacji na temat tego, czym jest Firebase i jak go wykorzystać, znajdziesz tutaj.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Podstawowe zrozumienie aplikacji - Manifest.xml, strings.xml +### Basic understanding of the application - Manifest.xml, strings.xml -**Badanie plików _Manifest.xml_ i _strings.xml_ aplikacji może ujawnić potencjalne luki w zabezpieczeniach**. Pliki te można uzyskać za pomocą dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip, a następnie rozpakowując go. +**Badanie plików _Manifest.xml_ i **_strings.xml_** aplikacji może ujawnić potencjalne luki w zabezpieczeniach**. Pliki te można uzyskać za pomocą dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip, a następnie go rozpakowując. **Luki** zidentyfikowane w **Manifest.xml** obejmują: -- **Aplikacje debugowalne**: Aplikacje ustawione jako debugowalne (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ pozwalają na połączenia, które mogą prowadzić do wykorzystania. Aby uzyskać dalsze zrozumienie, jak wykorzystać aplikacje debugowalne, zapoznaj się z samouczkiem na temat znajdowania i wykorzystywania aplikacji debugowalnych na urządzeniu. +- **Debugowalne aplikacje**: Aplikacje ustawione jako debugowalne (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ pozwalają na połączenia, które mogą prowadzić do wykorzystania. Aby lepiej zrozumieć, jak wykorzystać debugowalne aplikacje, zapoznaj się z samouczkiem na temat znajdowania i wykorzystywania debugowalnych aplikacji na urządzeniu. - **Ustawienia kopii zapasowej**: Atrybut `android:allowBackup="false"` powinien być wyraźnie ustawiony dla aplikacji zajmujących się wrażliwymi informacjami, aby zapobiec nieautoryzowanym kopiom zapasowym danych za pomocą adb, szczególnie gdy włączone jest debugowanie USB. - **Bezpieczeństwo sieci**: Niestandardowe konfiguracje bezpieczeństwa sieci (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak przypinanie certyfikatów i ustawienia ruchu HTTP. Przykładem jest zezwolenie na ruch HTTP dla określonych domen. - **Eksportowane aktywności i usługi**: Identyfikacja eksportowanych aktywności i usług w manifeście może uwydatnić komponenty, które mogą być nadużywane. Dalsza analiza podczas testów dynamicznych może ujawnić, jak wykorzystać te komponenty. - **Dostawcy treści i FileProviders**: Odkryte dostawcy treści mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders powinna być również dokładnie sprawdzona. -- **Odbiorniki rozgłoszeniowe i schematy URL**: Te komponenty mogą być wykorzystywane do eksploatacji, z szczególną uwagą na to, jak zarządzane są schematy URL w kontekście luk wejściowych. +- **Odbiorniki rozgłoszeniowe i schematy URL**: Te komponenty mogą być wykorzystywane do eksploatacji, z szczególnym uwzględnieniem sposobu zarządzania schematami URL w kontekście luk wejściowych. - **Wersje SDK**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują obsługiwane wersje Androida, podkreślając znaczenie nieobsługiwania przestarzałych, podatnych wersji Androida z powodów bezpieczeństwa. Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak klucze API, niestandardowe schematy i inne notatki dewelopera, co podkreśla potrzebę starannego przeglądu tych zasobów. @@ -92,15 +92,15 @@ Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak klucze AP **Tapjacking** to atak, w którym **złośliwa** **aplikacja** jest uruchamiana i **pozycjonuje się na wierzchu aplikacji ofiary**. Gdy widocznie zasłania aplikację ofiary, jej interfejs użytkownika jest zaprojektowany w taki sposób, aby oszukać użytkownika, aby z nią interagował, podczas gdy przekazuje interakcję do aplikacji ofiary.\ W efekcie **oślepia użytkownika, nie pozwalając mu wiedzieć, że faktycznie wykonuje akcje w aplikacji ofiary**. -Więcej informacji znajdziesz w: +Znajdź więcej informacji w: {{#ref}} tapjacking.md {{#endref}} -### Przechwytywanie zadań +### Task Hijacking -**Aktywność** z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na przechwytywanie zadań. Oznacza to, że **aplikacja** może być zainstalowana i jeśli zostanie uruchomiona przed prawdziwą aplikacją, może **przechwycić zadanie prawdziwej aplikacji** (więc użytkownik będzie interagował z **złośliwą aplikacją, myśląc, że używa prawdziwej**). +**Aktywność** z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na przejęcie zadania. Oznacza to, że **aplikacja** może być zainstalowana i jeśli zostanie uruchomiona przed prawdziwą aplikacją, może **przejąć zadanie prawdziwej aplikacji** (więc użytkownik będzie interagował z **złośliwą aplikacją, myśląc, że używa prawdziwej**). Więcej informacji w: @@ -108,44 +108,44 @@ Więcej informacji w: android-task-hijacking.md {{#endref}} -### Niebezpieczne przechowywanie danych +### Insecure data storage -**Przechowywanie wewnętrzne** +**Internal Storage** -W Androidzie pliki **przechowywane** w **przechowywaniu wewnętrznym** są **zaplanowane** do **dostępu** wyłącznie przez **aplikację**, która je **utworzyła**. Ten środek bezpieczeństwa jest **egzekwowany** przez system operacyjny Android i jest zazwyczaj wystarczający dla potrzeb bezpieczeństwa większości aplikacji. Jednak deweloperzy czasami wykorzystują tryby takie jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **zezwolić** na **dzielenie się** plikami między różnymi aplikacjami. Jednak te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe. +W Androidzie pliki **przechowywane** w **wewnętrznej** pamięci są **zaplanowane** do **dostępu** wyłącznie przez **aplikację**, która je **utworzyła**. Ten środek bezpieczeństwa jest **egzekwowany** przez system operacyjny Android i jest zazwyczaj wystarczający dla potrzeb bezpieczeństwa większości aplikacji. Jednak deweloperzy czasami wykorzystują tryby takie jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **zezwolić** na **dzielenie się** plikami między różnymi aplikacjami. Niemniej jednak, te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe. 1. **Analiza statyczna:** -- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **starannie analizowane**. Te tryby **mogą potencjalnie ujawniać** pliki **niezamierzonym lub nieautoryzowanym dostępem**. +- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie sprawdzane**. Te tryby **mogą potencjalnie ujawniać** pliki **niezamierzonym lub nieautoryzowanym dostępem**. 2. **Analiza dynamiczna:** - **Zweryfikuj** **uprawnienia** ustawione na plikach utworzonych przez aplikację. W szczególności **sprawdź**, czy jakiekolwiek pliki są **ustawione na bycie czytelnymi lub zapisywalnymi na całym świecie**. Może to stanowić istotne ryzyko bezpieczeństwa, ponieważ pozwoli **jakiejkolwiek aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia lub zamiaru, na **odczyt lub modyfikację** tych plików. -**Przechowywanie zewnętrzne** +**External Storage** -Podczas pracy z plikami na **przechowywaniu zewnętrznym**, takim jak karty SD, należy podjąć pewne środki ostrożności: +Podczas pracy z plikami na **zewnętrznej pamięci**, takiej jak karty SD, należy podjąć pewne środki ostrożności: 1. **Dostępność**: -- Pliki na zewnętrznym przechowywaniu są **globalnie czytelne i zapisywalne**. Oznacza to, że każda aplikacja lub użytkownik może uzyskać dostęp do tych plików. +- Pliki na zewnętrznej pamięci są **globalnie czytelne i zapisywalne**. Oznacza to, że każda aplikacja lub użytkownik może uzyskać dostęp do tych plików. 2. **Problemy z bezpieczeństwem**: -- Biorąc pod uwagę łatwość dostępu, zaleca się **nieprzechowywanie wrażliwych informacji** na zewnętrznym przechowywaniu. -- Zewnętrzne przechowywanie może być usunięte lub dostępne przez każdą aplikację, co czyni je mniej bezpiecznym. -3. **Obsługa danych z zewnętrznego przechowywania**: -- Zawsze **przeprowadzaj walidację wejścia** na danych pobranych z zewnętrznego przechowywania. Jest to kluczowe, ponieważ dane pochodzą z nieznanego źródła. -- Przechowywanie plików wykonywalnych lub klas na zewnętrznym przechowywaniu do dynamicznego ładowania jest zdecydowanie odradzane. -- Jeśli Twoja aplikacja musi pobrać pliki wykonywalne z zewnętrznego przechowywania, upewnij się, że te pliki są **podpisane i kryptograficznie weryfikowane** przed ich dynamicznym załadowaniem. Ten krok jest kluczowy dla utrzymania integralności bezpieczeństwa Twojej aplikacji. +- Biorąc pod uwagę łatwość dostępu, zaleca się **nieprzechowywanie wrażliwych informacji** na zewnętrznej pamięci. +- Zewnętrzna pamięć może być usunięta lub dostępna przez każdą aplikację, co czyni ją mniej bezpieczną. +3. **Obsługa danych z zewnętrznej pamięci**: +- Zawsze **przeprowadzaj walidację wejścia** na danych pobranych z zewnętrznej pamięci. Jest to kluczowe, ponieważ dane pochodzą z nieznanego źródła. +- Przechowywanie plików wykonywalnych lub plików klas na zewnętrznej pamięci do dynamicznego ładowania jest zdecydowanie odradzane. +- Jeśli Twoja aplikacja musi pobierać pliki wykonywalne z zewnętrznej pamięci, upewnij się, że te pliki są **podpisane i weryfikowane kryptograficznie** przed ich dynamicznym załadowaniem. Ten krok jest kluczowy dla utrzymania integralności bezpieczeństwa Twojej aplikacji. -Zewnętrzne przechowywanie można **uzyskać** w `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` +Zewnętrzna pamięć może być **dostępna** w `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` > [!TIP] > Począwszy od Androida 4.4 (**API 17**), karta SD ma strukturę katalogów, która **ogranicza dostęp aplikacji do katalogu, który jest specjalnie przeznaczony dla tej aplikacji**. To zapobiega złośliwej aplikacji w uzyskaniu dostępu do plików innej aplikacji. **Wrażliwe dane przechowywane w postaci niezaszyfrowanej** -- **Preferencje współdzielone**: Android pozwala każdej aplikacji łatwo zapisywać pliki xml w ścieżce `/data/data//shared_prefs/` i czasami możliwe jest znalezienie wrażliwych informacji w postaci niezaszyfrowanej w tym folderze. -- **Bazy danych**: Android pozwala każdej aplikacji łatwo zapisywać bazy danych sqlite w ścieżce `/data/data//databases/` i czasami możliwe jest znalezienie wrażliwych informacji w postaci niezaszyfrowanej w tym folderze. +- **Preferencje współdzielone**: Android pozwala każdej aplikacji na łatwe zapisywanie plików xml w ścieżce `/data/data//shared_prefs/` i czasami możliwe jest znalezienie wrażliwych informacji w postaci niezaszyfrowanej w tym folderze. +- **Bazy danych**: Android pozwala każdej aplikacji na łatwe zapisywanie baz danych sqlite w ścieżce `/data/data//databases/` i czasami możliwe jest znalezienie wrażliwych informacji w postaci niezaszyfrowanej w tym folderze. -### Uszkodzony TLS +### Broken TLS -**Akceptuj wszystkie certyfikaty** +**Accept All Certificates** Z jakiegoś powodu czasami deweloperzy akceptują wszystkie certyfikaty, nawet jeśli na przykład nazwa hosta nie pasuje do linii kodu, jak w poniższym przykładzie: ```java @@ -194,9 +194,9 @@ Zgodnie z tym [**postem na blogu**](https://clearbluejar.github.io/posts/desuper ### Zautomatyzowana analiza statycznego kodu -Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **luki** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera szereg **znanych źródeł** (które wskazują narzędziu **miejsca**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sankcji** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą spowodować szkody) i **reguł**. Te reguły wskazują na **kombinację** **źródeł-sankcji**, która wskazuje na lukę. +Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **luki** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera szereg **znanych źródeł** (które wskazują narzędziu **miejsca**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinki** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą spowodować szkody) oraz **reguły**. Te reguły wskazują na **kombinację** **źródeł-sinków**, które wskazują na lukę. -Dzięki tej wiedzy, **mariana-trench przeanalizuje kod i znajdzie możliwe luki w nim**. +Dzięki tej wiedzy, **mariana-trench przejrzy kod i znajdzie możliwe luki w nim**. ### Wycieki sekretów @@ -273,7 +273,7 @@ Musisz aktywować opcje **debugowania**, a byłoby dobrze, gdybyś mógł je **z 5. Wróć i znajdziesz **Opcje dewelopera**. > Po zainstalowaniu aplikacji, pierwszą rzeczą, którą powinieneś zrobić, jest jej przetestowanie i zbadanie, co robi, jak działa i zapoznanie się z nią.\ -> Sugeruję **przeprowadzenie tej wstępnej analizy dynamicznej za pomocą analizy dynamicznej MobSF + pidcat**, abyśmy mogli **nauczyć się, jak działa aplikacja**, podczas gdy MobSF **zbiera** wiele **interesujących** **danych**, które możesz później przeglądać. +> Sugeruję **przeprowadzenie tej początkowej analizy dynamicznej za pomocą analizy dynamicznej MobSF + pidcat**, abyśmy mogli **nauczyć się, jak działa aplikacja**, podczas gdy MobSF **zbiera** wiele **interesujących** **danych**, które możesz później przeglądać. ### Niezamierzony wyciek danych @@ -282,12 +282,12 @@ Musisz aktywować opcje **debugowania**, a byłoby dobrze, gdybyś mógł je **z Deweloperzy powinni być ostrożni w ujawnianiu **informacji debugowania** publicznie, ponieważ może to prowadzić do wycieków wrażliwych danych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony wrażliwych informacji. **Pidcat** jest preferowane ze względu na łatwość użycia i czytelność. > [!WARNING] -> Zauważ, że od **nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Aplikacje nie mogą uzyskiwać dostępu do logów innych aplikacji.\ +> Zauważ, że od **nowszych wersji niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Więc aplikacje nie mogą uzyskiwać dostępu do logów innych aplikacji.\ > Tak czy inaczej, nadal zaleca się **nie logować wrażliwych informacji**. **Bufor kopiowania/wklejania** -Oparty na **schowku** framework Androida umożliwia funkcjonalność kopiowania i wklejania w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskiwać dostęp** do schowka, potencjalnie ujawniając wrażliwe dane. Ważne jest, aby **wyłączyć funkcje kopiowania/wklejania** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec wyciekom danych. +Androidowy framework oparty na **schowku** umożliwia funkcjonalność kopiowania i wklejania w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskiwać dostęp** do schowka, potencjalnie ujawniając wrażliwe dane. Ważne jest, aby **wyłączyć funkcje kopiowania/wklejania** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec wyciekom danych. **Logi awarii** @@ -310,8 +310,8 @@ Wylicz tabele używając `.tables` i wylicz kolumny tabel używając `.schema 5**, automatycznie uruchomi **Frida** i ustawi globalne ustawienia **proxy** do **przechwytywania** ruchu. Będzie przechwytywać ruch tylko z testowanej aplikacji. +Od wersji Android **> 5**, automatycznie **uruchomi Frida** i ustawi globalne ustawienia **proxy** do **przechwytywania** ruchu. Będzie przechwytywać ruch tylko z testowanej aplikacji. **Frida** @@ -557,7 +563,7 @@ Domyślnie użyje również niektórych skryptów Frida do **obejścia SSL pinni MobSF może również **wywoływać eksportowane aktywności**, robić **zrzuty ekranu** z nich i **zapisywać** je do raportu. Aby **rozpocząć** testowanie dynamiczne, naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida i "**Live API Monitor**", aby zobaczyć wszystkie wywołania do podłączonych metod, przekazywane argumenty i zwracane wartości (to pojawi się po naciśnięciu "Start Instrumentation").\ -MobSF pozwala również na załadowanie własnych **skryptów Frida** (aby wysłać wyniki swoich skryptów Frida do MobSF, użyj funkcji `send()`). Ma również **kilka wstępnie napisanych skryptów**, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), wystarczy **je wybrać**, nacisnąć "**Load**" i nacisnąć "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**"). +MobSF pozwala również na załadowanie własnych **skryptów Frida** (aby wysłać wyniki swoich skryptów Frida do MobSF, użyj funkcji `send()`). Ma również **kilka wcześniej napisanych skryptów**, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), wystarczy **je wybrać**, nacisnąć "**Load**" i nacisnąć "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**"). ![](<../../images/image (419).png>) @@ -570,11 +576,11 @@ Ponadto masz kilka dodatkowych funkcji Frida: - **Search Class Pattern**: Wyszukaj klasy według wzoru - **Trace Class Methods**: **Śledź** **całą klasę** (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF śledzi kilka interesujących metod API Androida. -Gdy wybierzesz dodatkowy moduł, który chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie wyniki w "**Frida Live Logs**". +Gdy wybierzesz moduł pomocniczy, który chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie wyniki w "**Frida Live Logs**". **Shell** -Mobsf oferuje również powłokę z niektórymi poleceniami **adb**, **komendami MobSF** i ogólnymi **poleceniami powłoki** na dole strony analizy dynamicznej. Niektóre interesujące polecenia: +Mobsf oferuje również powłokę z niektórymi poleceniami **adb**, **poleceniami MobSF** i powszechnymi **poleceniami** **powłoki** na dole strony analizy dynamicznej. Niektóre interesujące polecenia: ```bash help shell ls @@ -632,7 +638,7 @@ reverse-apk relative/path/to/APP.apk SUPER to aplikacja działająca w wierszu poleceń, która może być używana w systemach Windows, MacOS X i Linux, analizująca pliki _.apk_ w poszukiwaniu luk. Robi to, dekompresując APK i stosując szereg reguł w celu wykrycia tych luk. -Wszystkie reguły są zawarte 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ą zdefiniowane w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły, aby analizować to, czego potrzebują. Pobierz najnowsze pliki binarne z [strony pobierania](https://superanalyzer.rocks/download.html) ``` @@ -652,7 +658,7 @@ Pobierz [najnowszą wersję](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework to system analizy podatności Android, który pomaga deweloperom lub hakerom znaleźć potencjalne luki w zabezpieczeniach aplikacji na Androida.\ +AndroBugs Framework to system analizy podatności Android, który pomaga deweloperom lub hakerom znaleźć potencjalne luki w zabezpieczeniach aplikacji Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -662,7 +668,7 @@ androbugs.exe -f [APK file] **Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnych złośliwych zachowaniach rozwijanych przez aplikację na Androida. -Wykrywanie odbywa się za pomocą **analizy statycznej** bajtkodu Dalvik aplikacji, reprezentowanego jako **Smali**, z wykorzystaniem biblioteki [`androguard`](https://github.com/androguard/androguard). +Wykrywanie odbywa się za pomocą **analizy statycznej** bajtowego kodu Dalvik aplikacji, reprezentowanego jako **Smali**, z wykorzystaniem biblioteki [`androguard`](https://github.com/androguard/androguard). To narzędzie szuka **typowych zachowań "złych" aplikacji**, takich jak: eksfiltracja identyfikatorów telekomunikacyjnych, przechwytywanie strumieni audio/wideo, modyfikacja danych PIM, wykonanie dowolnego kodu... ``` @@ -672,7 +678,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** to **M**obilna **A**plikacja **R**everse engineering i **A**naliza Framework. Jest to narzędzie, które łączy powszechnie używane narzędzia do reverse engineering i analizy aplikacji mobilnych, aby wspierać testowanie aplikacji mobilnych w kontekście zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania i uczynienie go bardziej przyjaznym dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa. +**MARA** to **M**obile **A**pplication **R**everse engineering i **A**nalysis Framework. Jest to narzędzie, które łączy powszechnie używane narzędzia do inżynierii wstecznej i analizy aplikacji mobilnych, aby wspierać testowanie aplikacji mobilnych w kontekście zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania i uczynienie go bardziej przyjaznym dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa. Może: @@ -695,37 +701,37 @@ Zauważ, że w zależności od usługi i konfiguracji, której używasz do obfus Z [Wikipedia](): **ProGuard** to narzędzie wiersza poleceń typu open source, które zmniejsza, optymalizuje i obfuskowało kod Java. Potrafi optymalizować bajty kodu oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest oprogramowaniem darmowym i jest dystrybuowane na licencji GNU General Public License, wersja 2. -ProGuard jest dystrybuowane jako część Android SDK i działa podczas budowania aplikacji w trybie release. +ProGuard jest dystrybuowane jako część Android SDK i działa podczas budowania aplikacji w trybie wydania. ### [DexGuard](https://www.guardsquare.com/dexguard) Znajdź przewodnik krok po kroku, jak deobfuskować apk w [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Z tego przewodnika) Ostatni raz, gdy sprawdzaliśmy, tryb działania Dexguard był: +(Z tego przewodnika) Ostatnim razem, gdy sprawdzaliśmy, tryb działania Dexguard był: - załaduj zasób jako InputStream; - przekaż wynik do klasy dziedziczącej z FilterInputStream, aby go odszyfrować; - wykonaj kilka bezużytecznych obfuskacji, aby zmarnować kilka minut czasu odwracającego; - przekaż odszyfrowany wynik do ZipInputStream, aby uzyskać plik DEX; -- w końcu załaduj wynikowy DEX jako zasób za pomocą metody `loadDex`. +- w końcu załaduj wynikowy DEX jako zasób, używając metody `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia obfuskacyjne Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym inspekcję kodu i przewidywanie bibliotek.** +**DeGuard odwraca proces obfuskacji wykonywanej przez narzędzia obfuskacyjne Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym inspekcję kodu i przewidywanie bibliotek.** 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 w zabezpieczeniach w aplikacjach android i deobfuskacji kodu aplikacji android. Używa publicznego API Gemini od Google. +To narzędzie LLM do znajdowania potencjalnych luk w zabezpieczeniach w aplikacjach androidowych i deobfuskacji kodu aplikacji androidowych. Używa publicznego API Gemini firmy Google. ### [Simplify](https://github.com/CalebFenton/simplify) -To **ogólny deobfuskator androida.** Simplify **wirtualnie wykonuje aplikację**, aby zrozumieć jej zachowanie, a następnie **stara się zoptymalizować kod**, aby działał identycznie, ale był łatwiejszy do zrozumienia dla człowieka. Każdy typ optymalizacji jest prosty i ogólny, więc nie ma znaczenia, jaki konkretny typ obfuskacji jest używany. +To **ogólny deobfuskator androidowy.** Simplify **wirtualnie wykonuje aplikację**, aby zrozumieć jej zachowanie, a następnie **stara się zoptymalizować kod**, aby działał identycznie, ale był łatwiejszy do zrozumienia dla człowieka. Każdy typ optymalizacji jest prosty i ogólny, więc nie ma znaczenia, jaki konkretny typ obfuskacji jest używany. ### [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 dostarcza informacji o **tym, jak stworzono APK**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida. ### Manual @@ -735,7 +741,7 @@ APKiD dostarcza informacji o **tym, jak APK zostało stworzone**. Identyfikuje w ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b to wirtualna maszyna bezpieczeństwa Androida oparta na ubuntu-mate, która zawiera zbiór najnowszych frameworków, tutoriali i laboratoriów od różnych geeków i badaczy bezpieczeństwa do reverse engineering i analizy złośliwego oprogramowania. +AndroL4b to wirtualna maszyna bezpieczeństwa Androida oparta na ubuntu-mate, która zawiera zbiór najnowszych frameworków, poradników i laboratoriów od różnych geeków i badaczy bezpieczeństwa do inżynierii wstecznej i analizy złośliwego oprogramowania. ## References diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md new file mode 100644 index 000000000..2b57b9a06 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -0,0 +1,203 @@ +# Android Anti-Instrumentation & SSL Pinning Bypass (Frida/Objection) + +{{#include ../../banners/hacktricks-training.md}} + +Ta strona przedstawia praktyczny workflow do odzyskania analizy dynamicznej aplikacji Android, które wykrywają/blokują instrumentację lub wymuszają pinning TLS. Skupia się na szybkim triage, powszechnych wykryciach oraz skryptach/taktykach do kopiowania, aby je obejść bez ponownego pakowania, gdy to możliwe. + +## Detection Surface (co sprawdzają aplikacje) + +- Kontrole root: su binary, ścieżki Magisk, wartości getprop, powszechne pakiety root +- Kontrole Frida/debuggera (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), skanowanie /proc, classpath, załadowane biblioteki +- Native anti‑debug: ptrace(), syscalls, anti‑attach, punkty przerwania, inline hooks +- Kontrole wczesnej inicjalizacji: Application.onCreate() lub haki startowe procesu, które powodują awarię, jeśli instrumentacja jest obecna +- TLS pinning: niestandardowy TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins + +## Step 1 — Szybkie zwycięstwo: ukryj root za pomocą Magisk DenyList + +- Włącz Zygisk w Magisk +- Włącz DenyList, dodaj docelowy pakiet +- Uruchom ponownie i przetestuj ponownie + +Wiele aplikacji szuka tylko oczywistych wskaźników (su/ścieżki Magisk/getprop). DenyList często neutralizuje naiwne kontrole. + +References: +- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk + +## Step 2 — Testy Frida Codeshare w 30 sekund + +Wypróbuj powszechne skrypty drop-in przed głębszym zanurzeniem: + +- anti-root-bypass.js +- anti-frida-detection.js +- hide_frida_gum.js + +Example: +```bash +frida -U -f com.example.app -l anti-frida-detection.js +``` +Te zazwyczaj stają się stubami dla kontroli Java root/debug, skanów procesów/usług oraz natywnego ptrace(). Przydatne w słabo chronionych aplikacjach; wzmocnione cele mogą wymagać dostosowanych haków. + +- Codeshare: https://codeshare.frida.re/ + +## Krok 3 — Obejście detektorów w czasie inicjalizacji przez późniejsze podłączenie + +Wiele detekcji działa tylko podczas uruchamiania procesu/onCreate(). Wstrzykiwanie w czasie uruchamiania (-f) lub gadżety są wykrywane; podłączenie po załadowaniu UI może przejść niezauważone. +```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 działa, utrzymaj sesję stabilną i przejdź do mapowania oraz sprawdzania stubów. + +## Krok 4 — Mapowanie logiki detekcji za pomocą Jadx i poszukiwania ciągów + +Słowa kluczowe do triage statycznego w Jadx: +- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" + +Typowe wzorce Java: +```java +public boolean isFridaDetected() { +return getRunningServices().contains("frida"); +} +``` +Common APIs do przeglądu/hookowania: +- android.os.Debug.isDebuggerConnected +- android.app.ActivityManager.getRunningAppProcesses / getRunningServices +- java.lang.System.loadLibrary / System.load (native bridge) +- java.lang.Runtime.exec / ProcessBuilder (probing commands) +- android.os.SystemProperties.get (root/emulator heuristics) + +## Krok 5 — Stubbing w czasie rzeczywistym z Frida (Java) + +Nadpisz niestandardowe zabezpieczenia, aby zwrócić bezpieczne wartości bez ponownego pakowania: +```js +Java.perform(() => { +const Checks = Java.use('com.example.security.Checks'); +Checks.isFridaDetected.implementation = function () { return false; }; + +// Neutralize debugger checks +const Debug = Java.use('android.os.Debug'); +Debug.isDebuggerConnected.implementation = function () { return false; }; + +// Example: kill ActivityManager scans +const AM = Java.use('android.app.ActivityManager'); +AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; +}); +``` +Triaging wczesnych awarii? Zrzucaj klasy tuż przed tym, jak umiera, aby zidentyfikować prawdopodobne przestrzenie nazw detekcji: +```js +Java.perform(() => { +Java.enumerateLoadedClasses({ +onMatch: n => console.log(n), +onComplete: () => console.log('Done') +}); +}); +``` +Zaloguj i zneutralizuj podejrzane metody, aby potwierdzić przepływ wykonania: +```js +Java.perform(() => { +const Det = Java.use('com.example.security.DetectionManager'); +Det.checkFrida.implementation = function () { +console.log('checkFrida() called'); +return false; +}; +}); +``` +## Krok 6 — Podążaj za ścieżką JNI/natywną, gdy haki Java zawodzą + +Śledź punkty wejścia JNI, aby zlokalizować natywne ładowarki i inicjalizację detekcji: +```bash +frida-trace -n com.example.app -i "JNI_OnLoad" +``` +Szybka natywna triage pakietowanych 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/natywne odwracanie: +- Ghidra: https://ghidra-sre.org/ +- r2frida: https://github.com/nowsecure/r2frida + +Przykład: neuter ptrace, aby pokonać prostą anty‑debug w libc: +```js +const ptrace = Module.findExportByName(null, 'ptrace'); +if (ptrace) { +Interceptor.replace(ptrace, new NativeCallback(function () { +return -1; // pretend failure +}, 'int', ['int', 'int', 'pointer', 'pointer'])); +} +``` +Zobacz także: {{#ref}} +reversing-native-libraries.md +{{#endref}} + +## Krok 7 — Patching Objection (wbudowanie gadżetu / podstawy stripowania) + +Kiedy wolisz repakowanie od haków czasu wykonywania, spróbuj: +```bash +objection patchapk --source app.apk +``` +Notatki: +- Wymaga apktool; upewnij się, że masz aktualną wersję z oficjalnego przewodnika, aby uniknąć problemów z budowaniem: https://apktool.org/docs/install +- Wstrzykiwanie gadgetów umożliwia instrumentację bez roota, ale nadal może być wykryte przez silniejsze kontrole w czasie inicjalizacji. + +Odniesienia: +- Objection: https://github.com/sensepost/objection + +## Krok 8 — Alternatywa: Łatka TLS pinning dla widoczności sieci + +Jeśli instrumentacja jest zablokowana, nadal możesz analizować 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 +- Aby uzyskać informacje o sztuczkach zaufania CA w konfiguracji sieci (i zaufaniu CA użytkownika w Androidzie 7+), zobacz: +{{#ref}} +make-apk-accept-ca-certificate.md +{{#endref}} +{{#ref}} +install-burp-certificate.md +{{#endref}} + +## Przydatna ściągawka z poleceniami +```bash +# List processes and attach +frida-ps -Uai +frida -U -n com.example.app + +# Spawn with a script (may trigger detectors) +frida -U -f com.example.app -l anti-frida-detection.js + +# Trace native init +frida-trace -n com.example.app -i "JNI_OnLoad" + +# Objection runtime +objection --gadget com.example.app explore + +# Static TLS pinning removal +apk-mitm app.apk +``` +## Wskazówki i uwagi + +- Preferuj dołączanie później niż uruchamianie, gdy aplikacje zawieszają się przy uruchamianiu +- Niektóre detekcje są ponownie uruchamiane w krytycznych procesach (np. płatności, autoryzacja) — trzymaj haki aktywne podczas nawigacji +- Mieszaj statyczne i dynamiczne: przeszukaj ciągi w Jadx, aby skrócić listę klas; następnie podłącz metody, aby zweryfikować w czasie rzeczywistym +- Wzmocnione aplikacje mogą używać pakietów i natywnego TLS pinning — spodziewaj się odwrotnego inżynierii kodu natywnego + +## Odniesienia + +- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/) +- [Frida Codeshare](https://codeshare.frida.re/) +- [Objection](https://github.com/sensepost/objection) +- [apk-mitm](https://github.com/shroudedcode/apk-mitm) +- [Jadx](https://github.com/skylot/jadx) +- [Ghidra](https://ghidra-sre.org/) +- [r2frida](https://github.com/nowsecure/r2frida) +- [Apktool install guide](https://apktool.org/docs/install) +- [Magisk](https://github.com/topjohnwu/Magisk) + +{{#include ../../banners/hacktricks-training.md}}