diff --git a/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md b/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md index 521364dad..64d35ef54 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md +++ b/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md @@ -2,52 +2,102 @@ {{#include ../../banners/hacktricks-training.md}} -## Zadania, Stos Wsteczny i Aktywności w Pierwszym Planie +## Task, Back Stack and Foreground Activities -W Androidzie, **zadanie** to zasadniczo zestaw aktywności, z którymi użytkownicy wchodzą w interakcję, aby wykonać określone zadanie, zorganizowane w **stos wsteczny**. Stos ten porządkuje aktywności na podstawie momentu ich otwarcia, z najnowszą aktywnością wyświetlaną na górze jako **aktywność w pierwszym planie**. W każdej chwili tylko ta aktywność jest widoczna na ekranie, co czyni ją częścią **zadania w pierwszym planie**. +W Androidzie, **task** to zasadniczo zestaw aktywności, z którymi użytkownicy wchodzą w interakcję, aby wykonać określone zadanie, zorganizowane w **back stack**. Ten stos porządkuje aktywności na podstawie momentu ich otwarcia, z najnowszą aktywnością wyświetlaną na górze jako **foreground activity**. W każdej chwili tylko ta aktywność jest widoczna na ekranie, co czyni ją częścią **foreground task**. Oto szybkie podsumowanie przejść między aktywnościami: -- **Aktywność 1** zaczyna jako jedyna aktywność w pierwszym planie. -- Uruchomienie **Aktywności 2** przesuwa **Aktywność 1** do stosu wstecznego, przynosząc **Aktywność 2** na pierwszy plan. -- Rozpoczęcie **Aktywności 3** przesuwa **Aktywność 1** i **Aktywność 2** dalej w stosie, z **Aktywnością 3** teraz na przodzie. -- Zamknięcie **Aktywności 3** przywraca **Aktywność 2** na pierwszy plan, pokazując uproszczony mechanizm nawigacji zadań w Androidzie. +- **Activity 1** zaczyna jako jedyna aktywność w foreground. +- Uruchomienie **Activity 2** przesuwa **Activity 1** do back stack, przynosząc **Activity 2** na foreground. +- Rozpoczęcie **Activity 3** przesuwa **Activity 1** i **Activity 2** dalej w stosie, z **Activity 3** teraz na przodzie. +- Zamknięcie **Activity 3** przywraca **Activity 2** na foreground, pokazując uproszczony mechanizm nawigacji zadań w Androidzie. ![https://developer.android.com/images/fundamentals/diagram_backstack.png](<../../images/image (698).png>) -## Atak na afinity zadania +--- -### Przegląd afinity zadania i trybów uruchamiania +## Task affinity attacks -W aplikacjach Android, **afinity zadania** określa preferowane zadanie aktywności, zazwyczaj zgodne z nazwą pakietu aplikacji. Ta konfiguracja jest kluczowa w tworzeniu aplikacji proof-of-concept (PoC) do demonstrowania ataku. +`taskAffinity` informuje Android, do którego tasku `Activity` *preferuje* należeć. Gdy dwie aktywności dzielą tę samą afinitet, **Android ma prawo połączyć je w tym samym back-stack, nawet jeśli pochodzą z różnych APK**. -### Tryby uruchamiania +Jeśli atakujący może umieścić złośliwą aktywność na **root** tego stosu, za każdym razem, gdy ofiara otworzy legalną aplikację, złośliwy interfejs użytkownika będzie pierwszą rzeczą, którą zobaczy użytkownik – idealne do phishingu lub nadużywania uprawnień. -Atrybut `launchMode` kieruje obsługą instancji aktywności w zadaniach. Tryb **singleTask** jest kluczowy dla tego ataku, dyktując trzy scenariusze w oparciu o istniejące instancje aktywności i dopasowania afinity zadania. Wykorzystanie polega na zdolności aplikacji atakującego do naśladowania afinity zadania aplikacji docelowej, wprowadzając system Android w błąd, aby uruchomił aplikację atakującego zamiast zamierzonej ofiary. +Powierzchnia ataku jest szersza, niż wielu deweloperów myśli, ponieważ **każda aktywność automatycznie dziedziczy afinitet równy nazwie pakietu aplikacji** (chyba że deweloper ustawi `android:taskAffinity=""`). Dlatego *nic nie robiąc* aplikacja już jest narażona na przejęcie zadań w wersjach Androida przed 11. -### Szczegółowe kroki ataku +### Klasyczny scenariusz "singleTask / StrandHogg" -1. **Instalacja złośliwej aplikacji**: Ofiara instaluje aplikację atakującego na swoim urządzeniu. -2. **Początkowa aktywacja**: Ofiara najpierw otwiera złośliwą aplikację, przygotowując urządzenie do ataku. -3. **Próba uruchomienia aplikacji docelowej**: Ofiara próbuje otworzyć aplikację docelową. -4. **Wykonanie przejęcia**: W pewnym momencie aplikacja próbuje otworzyć widok **singleTask**. Z powodu dopasowania afinity zadania, złośliwa aplikacja jest uruchamiana zamiast aplikacji docelowej. -5. **Oszustwo**: Złośliwa aplikacja wyświetla fałszywy ekran logowania przypominający aplikację docelową, oszukując użytkownika, aby wprowadził wrażliwe informacje. +1. Atakujący deklaruje aktywność z: +```xml + + + + + + +``` +2. Złośliwa aplikacja jest uruchamiana raz, aby task (z fałszywą afinitetą) istniał w ostatnich zadaniach. +3. Gdy użytkownik później otworzy prawdziwą aplikację, Android stwierdza, że już istnieje task, którego **root affinity pasuje do pakietu** i po prostu przynosi ten task na foreground. +4. Interfejs użytkownika atakującego jest wyświetlany jako pierwszy. -> [!TIP] -> Zauważ, że aby ten atak zadziałał, wrażliwy widok **nie musi mieć eksportu ustawionego na true** ani nie musi być główną aktywnością. +### Wariant Default–Affinity (bez `singleTask`) – Studium przypadku Caller ID -Aby uzyskać praktyczną implementację tego ataku, zapoznaj się z repozytorium Task Hijacking Strandhogg na GitHubie: [Task Hijacking Strandhogg](https://github.com/az0mb13/Task_Hijacking_Strandhogg). +Wrażliwość zgłoszona w aplikacji **Caller ID (caller.id.phone.number.block)** pokazuje, że atak *również* działa przeciwko domyślnemu trybowi uruchamiania `standard`: -### Środki zapobiegawcze +1. Aplikacja atakującego tworzy fałszywą aktywność root i natychmiast się ukrywa: +```kotlin +class HackActivity : AppCompatActivity() { +override fun onCreate(savedInstanceState: Bundle?) { +super.onCreate(savedInstanceState) +moveTaskToBack(true) // utrzymuje task w ostatnich, ale poza zasięgiem wzroku +} +} +``` +2. Manifest musi tylko skopiować pakiet ofiary do `taskAffinity`: +```xml + + + + + + +``` +3. Gdy użytkownik zainstaluje i otworzy złośliwą aplikację **raz**, istnieje task, którego afinitet równa się pakietowi ofiary (ale siedzi w tle). +4. Gdy uruchamiana jest prawdziwa aplikacja Caller ID, Android ponownie wykorzystuje ten task i przynosi `HackActivity` na foreground → okno phishingowe/nadużycie uprawnień. -Aby zapobiec takim atakom, deweloperzy mogą: -- Ustawić **`taskAffinity`** widoku **singleTask** na pusty ciąg (`android:taskAffinity=""`) -- Wybrać tryb uruchamiania **`singleInstance`**, zapewniając izolację ich aplikacji od innych. -- Dostosować funkcję **`onBackPressed()`**, co oferuje dodatkową ochronę przed przejęciem zadań. +> UWAGA: Począwszy od **Android 11 (API 30)** system *nie* umieszcza dwóch pakietów, które nie są częścią tego samego UID, w tym samym tasku domyślnie, co łagodzi ten konkretny wariant. Starsze wersje pozostają narażone. -## **Referencje** +--- -- [**https://blog.dixitaditya.com/android-task-hijacking/**](https://blog.dixitaditya.com/android-task-hijacking/) -- [**https://blog.takemyhand.xyz/2021/02/android-task-hijacking-with.html**](https://blog.takemyhand.xyz/2021/02/android-task-hijacking-with.html) +## Detection & Exploitation checklist + +1. Pobierz `AndroidManifest.xml` z docelowego APK i sprawdź, czy każda `` (lub globalny element ``) zawiera `android:taskAffinity=""` (pusty) **lub** dostosowaną wartość. +2. Jeśli nie, stwórz złośliwą aplikację: +- `android:taskAffinity` = nazwa pakietu ofiary. +- Zapewnij intencję `MAIN/LAUNCHER`, aby użytkownik mógł ją otworzyć raz. +- Opcjonalnie wywołaj `moveTaskToBack(true)`, aby natychmiast się ukryć. +3. Pozwól ofierze otworzyć swoją legalną aplikację → przejęcie. + +## Mitigation + +Deweloperzy powinni: + +* Wyraźnie ustawić `android:taskAffinity=""` na poziomie `` (zalecane) **lub** nadać każdej aktywności unikalną, prywatną afinitet. +* Dla wysoce wrażliwych ekranów, połączyć powyższe z `android:launchMode="singleInstance"` lub nowoczesnymi [`setLaunchMode`](https://developer.android.com/reference/android/content/pm/ActivityInfo#launchMode) zabezpieczeniami. +* Zaktualizować `targetSdkVersion` aplikacji i egzekwować **zmiany w zachowaniu Androida 11**, gdzie taski nie są domyślnie dzielone między pakietami. + +--- + +## References + +- [https://blog.dixitaditya.com/android-task-hijacking/](https://blog.dixitaditya.com/android-task-hijacking/) +- [https://blog.takemyhand.xyz/2021/02/android-task-hijacking-with.html](https://blog.takemyhand.xyz/2021/02/android-task-hijacking-with.html) +- [Android Manifest Misconfiguration Leading to Task Hijacking in Caller ID app](https://github.com/KMov-g/androidapps/blob/main/caller.id.phone.number.block.md) +- [https://medium.com/mobile-app-development-publication/the-risk-of-android-strandhogg-security-issue-and-how-it-can-be-mitigated-80d2ddb4af06](https://medium.com/mobile-app-development-publication/the-risk-of-android-strandhogg-security-issue-and-how-it-can-be-mitigated-80d2ddb4af06) {{#include ../../banners/hacktricks-training.md}}