From 9084889c323eee596e608920975fc903f8894911 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 4 Sep 2025 09:32:02 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/smali-changes. --- .../malware-analysis.md | 81 +++++++++--------- .../reversing-native-libraries.md | 82 +++++++++---------- .../android-app-pentesting/smali-changes.md | 82 +++++++++---------- 3 files changed, 123 insertions(+), 122 deletions(-) diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md index dd16b6558..609e41661 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md @@ -14,7 +14,7 @@ - [Intezer](https://analyze.intezer.com) - [Any.Run](https://any.run/) -## Offline — antywirusy i narzędzia wykrywania +## Narzędzia antywirusowe i detekcyjne (offline) ### Yara @@ -24,8 +24,8 @@ sudo apt-get install -y yara ``` #### Przygotuj reguły -Użyj tego skryptu, aby pobrać i scalić wszystkie reguły yara dotyczące malware z github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ -Utwórz katalog _**rules**_ i uruchom skrypt. Spowoduje to utworzenie pliku o nazwie _**malware_rules.yar**_, który zawiera wszystkie reguły yara dla malware. +Użyj tego skryptu, aby pobrać i scalić wszystkie yara malware rules z github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ +Utwórz katalog _**rules**_ i uruchom skrypt. Spowoduje to utworzenie pliku o nazwie _**malware_rules.yar**_, który zawiera wszystkie yara rules dla malware. ```bash wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py mkdir rules @@ -36,9 +36,9 @@ python malware_yara_rules.py yara -w malware_rules.yar image #Scan 1 file yara -w malware_rules.yar folder #Scan the whole folder ``` -#### YaraGen: Sprawdzanie malware i tworzenie reguł +#### YaraGen: Sprawdź malware i utwórz reguły -Możesz użyć narzędzia [**YaraGen**](https://github.com/Neo23x0/yarGen) aby wygenerować yara rules z pliku binarnego. Zobacz te poradniki: [**Część 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Część 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Część 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) +Możesz użyć narzędzia [**YaraGen**](https://github.com/Neo23x0/yarGen), aby wygenerować yara rules z pliku binarnego. Zobacz te poradniki: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) ```bash python3 yarGen.py --update python3.exe yarGen.py --excludegood -m ../../mals/ @@ -57,25 +57,26 @@ clamscan folderpath #Scan the whole folder ``` ### [Capa](https://github.com/mandiant/capa) -**Capa** wykrywa potencjalnie złośliwe **capabilities** w plikach wykonywalnych: PE, ELF, .NET. Dzięki temu znajdzie takie elementy jak Att\&ck tactics, albo podejrzane możliwości, takie jak: +**Capa** wykrywa potencjalnie złośliwe **możliwości** w plikach wykonywalnych: PE, ELF, .NET. Wykryje więc rzeczy takie jak Att\&ck tactics, lub podejrzane możliwości takie jak: -- sprawdzanie błędu OutputDebugString -- uruchamianie jako usługa -- tworzenie procesu +- check for OutputDebugString error +- run as a service +- create process Pobierz go z [**Github repo**](https://github.com/mandiant/capa). ### IOCs -IOC oznacza Indicator Of Compromise. IOC to zestaw **warunków, które identyfikują** potencjalnie niechciane oprogramowanie lub potwierdzone **malware**. Blue Teams używają tego rodzaju definicji do **wyszukiwania tego typu złośliwych plików** w swoich **systemach** i **sieciach**.\ -Dzielenie się tymi definicjami jest bardzo przydatne — gdy malware zostanie zidentyfikowane na komputerze i zostanie utworzony IOC dla tego malware, inne Blue Teams mogą go użyć, aby szybciej wykryć to malware. +IOC oznacza Indicator Of Compromise. IOC to zbiór **warunków, które identyfikują** potencjalnie niechciane oprogramowanie lub potwierdzone **malware**.\ +Blue Teams używają tego rodzaju definicji do **wyszukiwania tego typu złośliwych plików** w swoich **systemach** i **sieciach**.\ +Udostępnianie tych definicji jest bardzo przydatne — gdy malware zostanie zidentyfikowane na komputerze i zostanie utworzony dla niego IOC, inne Blue Teams mogą go wykorzystać do szybszej identyfikacji. -Narzędzie do tworzenia lub modyfikowania IOCs jest [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ -Możesz użyć narzędzi takich jak [**Redline**](https://www.fireeye.com/services/freeware/redline.html) do **wyszukiwania zdefiniowanych IOCs na urządzeniu**. +Narzędziem do tworzenia lub modyfikowania IOC jest [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ +Możesz użyć narzędzi takich jak [**Redline**](https://www.fireeye.com/services/freeware/redline.html) do **wyszukiwania zdefiniowanych IOC na urządzeniu**. ### Loki -[**Loki**](https://github.com/Neo23x0/Loki) to skaner dla Simple Indicators of Compromise.\ +[**Loki**](https://github.com/Neo23x0/Loki) to skaner prostych wskaźników kompromitacji.\ Wykrywanie opiera się na czterech metodach detekcji: ``` 1. File Name IOC @@ -92,7 +93,7 @@ Compares process connection endpoints with C2 IOCs (new since version v.10) ``` ### Linux Malware Detect -[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) jest skanerem malware dla Linux wydanym na licencji GNU GPLv2, zaprojektowanym z myślą o zagrożeniach występujących w środowiskach współdzielonego hostingu. Wykorzystuje dane o zagrożeniach z systemów wykrywania włamań na krawędzi sieci do wyodrębniania malware, które jest aktywnie używane w atakach, oraz generuje sygnatury do wykrywania. Dodatkowo dane o zagrożeniach pochodzą także z zgłoszeń użytkowników za pomocą funkcji LMD checkout oraz z zasobów społeczności zajmującej się malware. +[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) to skaner malware dla Linux wydany na licencji GNU GPLv2, zaprojektowany z myślą o zagrożeniach występujących w środowiskach współdzielonego hostingu. Wykorzystuje dane o zagrożeniach z network edge intrusion detection systems do wydobywania malware, które są aktywnie używane w atakach, i generuje sygnatury do wykrywania. Dodatkowo dane o zagrożeniach pochodzą również z user submissions za pomocą LMD checkout feature oraz z zasobów społeczności malware. ### rkhunter @@ -102,31 +103,31 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk ``` ### FLOSS -[**FLOSS**](https://github.com/mandiant/flare-floss) to narzędzie, które próbuje znaleźć obfuscated strings w plikach executable, używając różnych technik. +[**FLOSS**](https://github.com/mandiant/flare-floss) to narzędzie, które spróbuje znaleźć obfuscated strings w executables, używając różnych techniques. ### PEpper -[PEpper ](https://github.com/Th3Hurrican3/PEpper) sprawdza podstawowe rzeczy wewnątrz pliku executable (binary data, entropy, URLs and IPs, some yara rules). +[PEpper ](https://github.com/Th3Hurrican3/PEpper) sprawdza podstawowe rzeczy w executable (binary data, entropy, URLs and IPs, some yara rules). ### PEstudio -[PEstudio](https://www.winitor.com/download) to narzędzie, które pozwala uzyskać informacje o Windows executables, takich jak imports, exports, headers, ale także sprawdzi virus total i znajdzie potencjalne Att\&ck techniques. +[PEstudio](https://www.winitor.com/download) to narzędzie pozwalające uzyskać informacje o Windows executables, takich jak imports, exports, headers, ale także sprawdzi virus total i znajdzie potencjalne Att\&ck techniques. ### Detect It Easy(DiE) -[**DiE**](https://github.com/horsicq/Detect-It-Easy/) to narzędzie do wykrywania, czy plik jest **encrypted**, oraz do znajdowania **packers**. +[**DiE**](https://github.com/horsicq/Detect-It-Easy/) to narzędzie do wykrywania, czy plik jest **encrypted** i także znajdowania **packers**. ### NeoPI -[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) to skrypt w Pythonie, który wykorzystuje różnorodne **statistical methods** do wykrywania **obfuscated** i **encrypted** content w plikach tekstowych/skryptowych. Celem NeoPI jest pomoc w **detection of hidden web shell code**. +[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) to skrypt Python, który używa różnych **statistical methods** do wykrywania **obfuscated** i **encrypted** content w plikach tekstowych/skryptach. Celem NeoPI jest pomoc w **detection of hidden web shell code**. ### **php-malware-finder** -[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) robi wszystko, by wykryć **obfuscated**/**dodgy code** oraz pliki używające funkcji **PHP** często stosowanych w **malwares**/webshells. +[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) robi co może, aby wykryć **obfuscated**/**dodgy code** oraz pliki wykorzystujące funkcje **PHP** często używane w **malwares**/webshells. ### Apple Binary Signatures -Podczas sprawdzania jakiegoś **malware sample** zawsze powinieneś **check the signature** binarki, ponieważ **developer** który ją podpisał, może być już **related** z **malware**. +Sprawdzając próbkę **malware sample** powinieneś zawsze **check the signature** binarki, ponieważ **developer**, który ją podpisał, może być już **related** z **malware.** ```bash #Get signer codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" @@ -141,21 +142,21 @@ spctl --assess --verbose /Applications/Safari.app ### File Stacking -Jeśli wiesz, że jakiś folder zawierający **pliki** serwera WWW był **ostatnio zaktualizowany w określonym dniu**, **sprawdź** **datę**, kiedy wszystkie **pliki** na **serwerze WWW** zostały utworzone i zmodyfikowane, a jeśli któraś data jest **podejrzana**, sprawdź ten plik. +Jeżeli wiesz, że jakiś folder zawierający **pliki** web servera był **ostatnio zaktualizowany w pewnym dniu**. **Sprawdź** **datę**, kiedy wszystkie **pliki** w **web serverze** zostały utworzone i zmodyfikowane — jeśli któraś data wygląda **podejrzanie**, sprawdź ten plik. ### Baselines -Jeśli pliki w katalogu **nie powinny być zmieniane**, możesz obliczyć **hash** **oryginalnych plików** katalogu i **porównać** je z **aktualnymi**. Wszystko, co zostało zmodyfikowane, będzie **podejrzane**. +Jeżeli pliki w folderze **nie powinny być modyfikowane**, możesz obliczyć **hash** **oryginalnych plików** folderu i **porównać** je z **aktualnymi**. Wszystko zmodyfikowane będzie **podejrzane**. ### Statistical Analysis -Gdy informacje są zapisywane w logach, możesz **sprawdzić statystyki, np. ile razy każdy plik serwera WWW był dostępny — web shell może być jednym z najczęściej wywoływanych**. +Kiedy informacje są zapisywane w logach, możesz **sprawdzić statystyki**, np. ile razy każdy plik web servera był dostępny — web shell może być jednym z najczęściej. --- -### Android natywna telemetryka w aplikacji (no root) +### Android in-app native telemetry (no root) -Na Androidzie możesz instrumentować natywny kod wewnątrz procesu docelowej aplikacji, preloadując małą bibliotekę loggera zanim zainicjują się inne biblioteki JNI. To daje wczesną widoczność zachowania natywnego bez systemowych hooków ani root. Popularnym podejściem jest SoTap: wrzuć libsotap.so dla odpowiedniego ABI do APK i wstrzyknięcie wywołania System.loadLibrary("sotap") wcześnie (np. static initializer lub Application.onCreate), a następnie zbieraj logi z wewnętrznych/zewnętrznych ścieżek lub z fallbacku Logcat. +Na Androidzie możesz instrumentować natywny kod wewnątrz procesu docelowej aplikacji przez wstępne załadowanie małej biblioteki loggera zanim inne JNI libs się zainicjalizują. To daje wczesną widoczność natywnego zachowania bez system-wide hooks ani roota. Popularne podejście to SoTap: wrzuć libsotap.so dla odpowiedniego ABI do APK i wstrzyknij wywołanie System.loadLibrary("sotap") wcześnie (np. static initializer lub Application.onCreate), następnie zbieraj logi z internal/external ścieżek lub użyj Logcat jako fallback. See the Android native reversing page for setup details and log paths: @@ -167,11 +168,11 @@ See the Android native reversing page for setup details and log paths: ## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers) -Nowoczesne rodziny malware nadużywają obfuskacji Control-Flow Graph (CFG): zamiast bezpośredniego skoku/wywołania obliczają cel w czasie wykonywania i wykonują `jmp rax` lub `call rax`. Mały *dispatcher* (zwykle dziewięć instrukcji) ustawia końcowy cel w zależności od flag CPU `ZF`/`CF`, całkowicie łamiąc odzyskiwanie statycznego CFG. +Współczesne rodziny malware intensywnie nadużywają Control-Flow Graph (CFG) obfuskacji: zamiast bezpośredniego skoku/wywołania obliczają cel w czasie wykonania i wykonują `jmp rax` lub `call rax`. Mały *dispatcher* (zazwyczaj dziewięć instrukcji) ustawia docelowy adres zależnie od flag CPU `ZF`/`CF`, całkowicie łamiąc statyczne odzyskiwanie CFG. -Technika – prezentowana przez loader SLOW#TEMPEST – może zostać sforsowana trzystopniowym workflowem opartym wyłącznie na IDAPython i Unicorn CPU emulator. +Technika – zaprezentowana przez loader SLOW#TEMPEST – może być pokonana trzema krokami wykorzystując wyłącznie IDAPython i emulator CPU Unicorn. -### 1. Zlokalizuj każdy skok/wywołanie pośrednie +### 1. Zlokalizuj wszystkie pośrednie skoki / wywołania ```python import idautils, idc @@ -180,7 +181,7 @@ mnem = idc.print_insn_mnem(ea) if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax": print(f"[+] Dispatcher found @ {ea:X}") ``` -### 2. Wyodrębnij dispatcher byte-code +### 2. Wyodrębnij kod bajtowy dispatchera ```python import idc @@ -195,7 +196,7 @@ size = jmp_ea + idc.get_item_size(jmp_ea) - start code = idc.get_bytes(start, size) open(f"{start:X}.bin", "wb").write(code) ``` -### 3. Emuluj to dwukrotnie przy użyciu Unicorn +### 3. Emuluj to dwukrotnie za pomocą Unicorn ```python from unicorn import * from unicorn.x86_const import * @@ -211,9 +212,9 @@ mu.reg_write(UC_X86_REG_RAX, 0) mu.emu_start(BASE, BASE+len(code)) return mu.reg_read(UC_X86_REG_RAX) ``` -Uruchom `run(code,0,0)` i `run(code,1,1)`, aby uzyskać docelowe adresy gałęzi *false* i *true*. +Uruchom `run(code,0,0)` i `run(code,1,1)`, aby uzyskać *false* i *true* cele gałęzi. -### 4. Przywróć bezpośredni jump / call +### 4. Przywróć bezpośredni skok / wywołanie ```python import struct, ida_bytes @@ -222,26 +223,26 @@ op = 0xE8 if is_call else 0xE9 # CALL rel32 or JMP rel32 disp = target - (ea + 5) & 0xFFFFFFFF ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack(' ' + count + ' met }); }); ``` -Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks. +Frida będzie działać od razu na urządzeniach z PAC/BTI (Pixel 8/Android 14+), o ile użyjesz frida-server 16.2 lub nowszej – wcześniejsze wersje nie potrafiły zlokalizować paddingu dla inline hooks. -### Lokalne telemetry JNI w procesie poprzez preloaded .so (SoTap) +### Process-local JNI telemetry via preloaded .so (SoTap) -Gdy pełna instrumentacja jest przesadą lub zablokowana, nadal możesz uzyskać widoczność na poziomie natywnym przez preloading małego loggera wewnątrz procesu docelowego. SoTap to lekka biblioteka natywna Android (.so), która loguje zachowanie w czasie wykonywania innych bibliotek JNI (.so) w tym samym procesie aplikacji (nie wymaga roota). +Gdy pełna instrumentacja jest przesadą lub zablokowana, nadal możesz uzyskać widoczność na poziomie native, preładowując mały logger wewnątrz docelowego procesu. SoTap to lekka natywna biblioteka Android (.so), która loguje zachowanie w czasie wykonywania innych bibliotek JNI (.so) w tym samym procesie aplikacji (nie wymaga root). -Główne cechy: -- Inicjalizuje się wcześnie i obserwuje interakcje JNI/natywne wewnątrz procesu, który ją ładuje. -- Przechowuje logi, używając wielu zapisywalnych ścieżek z płynnym fallbackiem do Logcat, gdy dostęp do pamięci jest ograniczony. -- Możliwość modyfikacji źródła: edytuj sotap.c, aby rozszerzyć/dostosować, co jest logowane, i przebuduj dla każdego ABI. +Key properties: +- Inicjalizuje się wcześnie i obserwuje JNI/native interactions wewnątrz procesu, który ją ładuje. +- Przechowuje logi, używając wielu zapisywalnych ścieżek z awaryjnym przełączeniem na Logcat, gdy dostęp do pamięci jest ograniczony. +- Source-customizable: edytuj sotap.c, aby rozszerzyć/dostosować co jest logowane i przebuduj per ABI. -Konfiguracja (repack the APK): -1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so: -- lib/arm64-v8a/libsotap.so (for arm64) -- lib/armeabi-v7a/libsotap.so (for arm32) -2) Ensure SoTap loads before other JNI libs. Inject a call early (e.g., Application subclass static initializer or onCreate) so the logger is initialized first. Smali snippet example: +Setup (repack the APK): +1) Umieść właściwy build ABI w APK, aby loader mógł rozwiązać libsotap.so: +- lib/arm64-v8a/libsotap.so (dla arm64) +- lib/armeabi-v7a/libsotap.so (dla arm32) +2) Upewnij się, że SoTap ładuje się przed innymi bibliotekami JNI. Wstrzyknij wywołanie wcześnie (np. statyczny initializer podklasy Application lub onCreate), aby logger był zainicjalizowany jako pierwszy. Przykład fragmentu Smali: ```smali const-string v0, "sotap" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V ``` -3) Rebuild/sign/install, run the app, then collect logs. +3) Przebuduj/podpisz/zainstaluj, uruchom aplikację, a następnie zbierz logi. Log paths (checked in order): ``` @@ -92,44 +92,44 @@ Log paths (checked in order): # If all fail: fallback to Logcat only ``` Notes and troubleshooting: -- Wyrównanie ABI jest obowiązkowe. Niezgodność spowoduje wyrzucenie UnsatisfiedLinkError i logger nie załaduje się. -- Ograniczenia przestrzeni dyskowej są powszechne w nowoczesnym Androidzie; jeśli zapisy plików nie powiodą się, SoTap nadal wyśle dane przez Logcat. -- Zachowanie/poziom szczegółowości ma być dostosowany; po edycji sotap.c przebuduj z źródeł. +- Wyrównanie ABI jest obowiązkowe. Brak dopasowania spowoduje UnsatisfiedLinkError i logger nie załaduje się. +- Ograniczenia przestrzeni dyskowej są powszechne w nowoczesnym Androidzie; jeśli zapisy plików zawiodą, SoTap będzie nadal wysyłać przez Logcat. +- Zachowanie/poziom szczegółowości jest przeznaczony do dostosowania; po edycji pliku sotap.c odbuduj z źródeł. This approach is useful for malware triage and JNI debugging where observing native call flows from process start is critical but root/system-wide hooks aren’t available. --- -### Ostatnie podatności warte poszukiwania w APK +### Najnowsze podatności, które warto wyszukiwać w APK | Rok | CVE | Biblioteka | Uwagi | |------|-----|------------------|-------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Przepełnienie bufora na stercie osiągalne z kodu natywnego, który dekoduje obrazy WebP. Wiele aplikacji Android pakuje podatne wersje. Gdy zobaczysz `libwebp.so` w APK, sprawdź jej wersję i rozważ eksploatację lub załatanie.| | -|2024|Multiple|OpenSSL 3.x series|Kilka problemów związanych z bezpieczeństwem pamięci i padding-oracle. Wiele bundli Flutter & ReactNative dostarcza własne `libcrypto.so`.| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Przepełnienie bufora sterty dostępne z poziomu natywnego kodu dekodującego obrazy WebP. Wiele aplikacji Android dołącza podatne wersje. Gdy zobaczysz `libwebp.so` w APK, sprawdź jej wersję i spróbuj exploitowania lub załatania.| | +|2024|Multiple|OpenSSL 3.x series|Kilka problemów związanych z bezpieczeństwem pamięci oraz padding-oracle. Wiele bundli Flutter & ReactNative dostarcza własne `libcrypto.so`.| -When you spot *third-party* `.so` files inside an APK, always cross-check their hash against upstream advisories. SCA (Software Composition Analysis) is uncommon on mobile, so outdated vulnerable builds are rampant. +Gdy zauważysz *third-party* `.so` pliki w APK, zawsze porównaj ich hash z upstream advisories. SCA (Software Composition Analysis) jest rzadko stosowane na urządzeniach mobilnych, więc przestarzałe, podatne buildy są powszechne. --- -### Anti-Reversing & Hardening trends (Android 13-15) +### Trendy Anti-Reversing i Hardening (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 włącza PAC/BTI w bibliotekach systemowych na obsługiwanych układach ARMv8.3+. Decompilery teraz pokazują pseudo-instrukcje związane z PAC; do analizy dynamicznej Frida wstrzykuje trampoliny *po* usunięciu PAC, ale twoje własne trampoliny powinny wywoływać `pacda`/`autibsp` tam, gdzie to konieczne. -* **MTE & Scudo hardened allocator:** memory-tagging jest opcjonalne, ale wiele aplikacji świadomych Play-Integrity kompiluje się z `-fsanitize=memtag`; użyj `setprop arm64.memtag.dump 1` oraz `adb shell am start ...` aby przechwycić błędy tagów. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercyjne packery (np. Bangcle, SecNeo) coraz częściej chronią kod *native*, nie tylko Java; spodziewaj się fałszywego control-flow i zaszyfrowanych blobów stringów w `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 włącza PAC/BTI w bibliotekach systemowych na obsługiwanym sprzęcie ARMv8.3+. Dekompilery teraz pokazują pseudo-instrukcje związane z PAC; dla analizy dynamicznej Frida wstrzykuje trampoliny *po* usunięciu PAC, ale twoje niestandardowe trampoliny powinny wywoływać `pacda`/`autibsp` tam, gdzie to konieczne. +* **MTE & Scudo hardened allocator:** memory-tagging jest opcjonalne, ale wiele aplikacji świadomych Play-Integrity buduje się z `-fsanitize=memtag`; użyj `setprop arm64.memtag.dump 1` oraz `adb shell am start ...` aby przechwycić błędy tagów. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** komercyjne packery (np. Bangcle, SecNeo) coraz częściej chronią kod natywny, nie tylko Java; spodziewaj się fałszywych ścieżek sterowania i zaszyfrowanych blobów stringów w `.rodata`. --- ### Zasoby -- **Nauka ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) -- **Dokumentacja JNI & NDK:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) -- **Debugowanie bibliotek natywnych:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) +- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) +- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) +- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) ### Referencje -- Change-log Frida 16.x (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) -- Advisory NVD dotyczące przepełnienia `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) -- SoTap: Lekki in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- Frida 16.x lista zmian (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) +- Porada NVD dotycząca przepełnienia `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) +- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) - How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) diff --git a/src/mobile-pentesting/android-app-pentesting/smali-changes.md b/src/mobile-pentesting/android-app-pentesting/smali-changes.md index 4fdd5c3e8..b0a51037d 100644 --- a/src/mobile-pentesting/android-app-pentesting/smali-changes.md +++ b/src/mobile-pentesting/android-app-pentesting/smali-changes.md @@ -3,84 +3,84 @@ {{#include ../../banners/hacktricks-training.md}} -Czasami warto zmodyfikować kod aplikacji, aby uzyskać dostęp do ukrytych informacji (np. dobrze obfuskowanych haseł lub flag). W takim przypadku warto zdekompilować APK, zmodyfikować kod i ponownie go skompilować. +Czasami warto zmodyfikować application code, aby uzyskać dostęp do ukrytych informacji (np. mocno obfuskowanych haseł lub flags). W takim przypadku może być przydatne zdekompilować apk, zmodyfikować code i ponownie go skompilować. -**Opcodes reference:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) +**Referencja opcode'ów:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) ## Szybki sposób -Używając **Visual Studio Code** i rozszerzenia [APKLab](https://github.com/APKLab/APKLab), możesz **automatycznie zdekompilować**, zmodyfikować, **ponownie skompilować**, podpisać i zainstalować aplikację bez uruchamiania poleceń. +Używając **Visual Studio Code** oraz rozszerzenia [APKLab](https://github.com/APKLab/APKLab), możesz **automatycznie zdekompilować**, zmodyfikować, **ponownie skompilować**, podpisać i zainstalować aplikację bez wykonywania żadnego polecenia. Inny **skrypt**, który znacznie ułatwia to zadanie, to [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh) ## Dekompilacja APK -Używając APKTool, możesz uzyskać dostęp do **kodu smali i zasobów**: +Używając APKTool możesz uzyskać dostęp do **smali code and resources**: ```bash apktool d APP.apk ``` -If **apktool** gives you any error, try[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) +Jeśli **apktool** zgłasza jakikolwiek błąd, spróbuj [zainstalować **najnowszą wersję**](https://ibotpeaches.github.io/Apktool/install/) -Niektóre **interesujące pliki, które warto sprawdzić**: +Niektóre **interesujące pliki, które powinieneś sprawdzić to**: -- _res/values/strings.xml_ (and all xmls inside res/values/*) +- _res/values/strings.xml_ (i wszystkie pliki .xml w res/values/*) - _AndroidManifest.xml_ -- Any file with extension _.sqlite_ or _.db_ +- Każdy plik z rozszerzeniem _.sqlite_ lub _.db_ -If `apktool` has **problems decoding the application** take a look to [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) or try using the argument **`-r`** (Nie dekoduj zasobów). Wówczas, jeśli problem był w zasobie, a nie w kodzie źródłowym, nie będziesz miał tego problemu (nie zdekompilujesz też zasobów). +Jeśli `apktool` ma **problemy z dekodowaniem aplikacji**, zajrzyj na [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) lub spróbuj użyć argumentu **`-r`** (Nie dekoduj zasobów). Wtedy, jeśli problem był w zasobie, a nie w kodzie źródłowym, ten problem nie wystąpi (nie zdekompilujesz też zasobów). -## Change smali code +## Zmiana kodu smali -Możesz **zmieniać** **instrukcje**, zmieniać **wartość** niektórych zmiennych lub **dodawać** nowe instrukcje. Ja edytuję kod Smali używając [**VS Code**](https://code.visualstudio.com), następnie instaluję **smalise extension** i edytor powiadomi cię, jeśli jakaś **instrukcja jest niepoprawna**.\ -Some **examples** can be found here: +Możesz **zmieniać** **instrukcje**, zmieniać **wartość** niektórych zmiennych lub **dodawać** nowe instrukcje. Ja zmieniam kod Smali używając [**VS Code**](https://code.visualstudio.com), następnie instalujesz rozszerzenie **smalise** i edytor powie ci, jeśli jakaś **instrukcja jest niepoprawna**.\ +Kilka **przykładów** znajdziesz tutaj: -- [Smali changes examples](smali-changes.md) +- [Przykłady zmian Smali](smali-changes.md) - [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md) -Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali). +Albo możesz [**sprawdzić poniżej wyjaśnienia kilku zmian Smali**](smali-changes.md#modifying-smali). -## Recompile the APK +## Rekompilacja APK -Po zmodyfikowaniu kodu możesz **zrekompilować** kod używając: +Po zmodyfikowaniu kodu możesz **rekompilować** go używając: ```bash apktool b . #In the folder generated when you decompiled the application ``` -Spowoduje to, że nowe APK zostanie **compile** **inside** folderu _**dist**_. +To **skompiluje** nowy APK **wewnątrz** folderu _**dist**_. -Jeśli **apktool** zgłosi **error**, spróbuj[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) +Jeśli **apktool** zgłosi **błąd**, spróbuj[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) -### **Podpisz nowe APK** +### **Podpisz nowy APK** Następnie musisz **wygenerować klucz** (zostaniesz poproszony o hasło oraz o kilka informacji, które możesz wypełnić losowo): ```bash keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias ``` -Na koniec, **podpisz** nowy APK: +Na koniec **podpisz** nowy APK: ```bash jarsigner -keystore key.jks path/to/dist/* ``` -### Optymalizacja nowej aplikacji +### Optymalizuj nową aplikację -**zipalign** jest narzędziem do wyrównywania archiwów, które zapewnia istotną optymalizację plików aplikacji Android (APK). [More information here](https://developer.android.com/studio/command-line/zipalign). +**zipalign** to narzędzie do wyrównywania archiwów, które zapewnia istotne optymalizacje plików aplikacji Android (APK). [Więcej informacji tutaj](https://developer.android.com/studio/command-line/zipalign). ```bash zipalign [-f] [-v] infile.apk outfile.apk zipalign -v 4 infile.apk ``` -### **Podpisz nowy APK (znowu?)** +### **Podpisz nowy APK (jeszcze raz?)** -Jeśli **wolisz** użyć [**apksigner**](https://developer.android.com/studio/command-line/) zamiast jarsigner, **powinieneś podpisać APK** po zastosowaniu **optymalizacji za pomocą** zipaling. ALE ZWRÓĆ UWAGĘ, ŻE MUSISZ **PODPISAĆ APLIKACJĘ TYLKO RAZ** PRZY UŻYCIU jarsigner (przed zipalign) LUB PRZY UŻYCIU aspsigner (po zipaling). +Jeśli **wolisz** użyć [**apksigner**](https://developer.android.com/studio/command-line/) zamiast jarsigner, **powinieneś podpisać APK** po zastosowaniu **optymalizacji przy użyciu** zipaling. ALE ZWRÓĆ UWAGĘ, ŻE MUSISZ **PODPISAĆ APLIKACJĘ TYLKO RAZ** za pomocą jarsigner (przed zipalign) LUB za pomocą aspsigner (po zipaling). ```bash apksigner sign --ks key.jks ./dist/mycompiled.apk ``` ## Modyfikowanie Smali -Dla następującego kodu Java Hello World: +Dla następującego kodu Hello World w Javie: ```java public static void printHelloWorld() { System.out.println("Hello World") } ``` -Kod Smali wyglądałby tak: +Kod Smali wyglądałby następująco: ```java .method public static printHelloWorld()V .registers 2 @@ -90,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V return-void .end method ``` -Zestaw instrukcji Smali jest dostępny [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). +Zestaw instrukcji Smali jest dostępny [tutaj](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). ### Drobne zmiany -### Modyfikacja wartości początkowych zmiennej w funkcji +### Modyfikacja początkowych wartości zmiennej w funkcji -Niektóre zmienne są zdefiniowane na początku funkcji przy użyciu opcode _const_, możesz zmodyfikować ich wartości lub zdefiniować nowe: +Niektóre zmienne są zdefiniowane na początku funkcji przy użyciu opcode _const_; możesz zmodyfikować ich wartości lub zdefiniować nowe: ```bash #Number const v9, 0xf4240 @@ -140,17 +140,17 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin ``` Zalecenia: -- Jeśli zamierzasz użyć zadeklarowanych zmiennych wewnątrz funkcji (zadeklarowane v0,v1,v2...) umieść te linie pomiędzy _.local _ i deklaracjami zmiennych (_const v0, 0x1_) -- Jeśli chcesz wstawić kod logowania w środku ciała funkcji: -- Dodaj 2 do liczby zadeklarowanych zmiennych: Ex: from _.locals 10_ to _.locals 12_ -- Nowe zmienne powinny mieć kolejne numery względem już zadeklarowanych zmiennych (w tym przykładzie powinny to być _v10_ i _v11_, pamiętaj że numeracja zaczyna się od v0). -- Zmień kod funkcji logującej i użyj _v10_ i _v11_ zamiast _v5_ i _v1_. +- Jeśli zamierzasz użyć zadeklarowanych zmiennych wewnątrz funkcji (zadeklarowanych v0,v1,v2...) umieść te linie pomiędzy _.local _ i deklaracjami zmiennych (_const v0, 0x1_) +- Jeśli chcesz umieścić kod logowania w środku kodu funkcji: + - Dodaj 2 do liczby zadeklarowanych zmiennych: np. od _.locals 10_ do _.locals 12_ + - Nowe zmienne powinny mieć kolejne numery po już zadeklarowanych zmiennych (w tym przykładzie powinny to być _v10_ i _v11_, pamiętaj, że numeracja zaczyna się od v0). + - Zmień kod funkcji logującej i użyj _v10_ i _v11_ zamiast _v5_ i _v1_. ### Wyświetlanie toastów Pamiętaj, aby dodać 3 do liczby _.locals_ na początku funkcji. -Ten kod jest przygotowany do wstawienia w **środek funkcji** (**zmień** liczbę **zmiennych** w razie potrzeby). Pobierze **wartość this.o**, **zamieni** ją na **String**, a następnie **wyświetli** **toast** z jej wartością. +Ten kod jest przygotowany do wstawienia w **środek funkcji** (**zmień** liczbę **zmiennych** w razie potrzeby). Pobierze **wartość this.o**, **przekształci** ją do **String** i następnie **wyświetli** **toast** z jej wartością. ```bash const/4 v10, 0x1 const/4 v11, 0x1 @@ -162,9 +162,9 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/ move-result-object v12 invoke-virtual {v12}, Landroid/widget/Toast;->show()V ``` -### Ładowanie biblioteki natywnej przy uruchamianiu (System.loadLibrary) +### Ładowanie biblioteki natywnej przy starcie (System.loadLibrary) -Czasami trzeba wstępnie załadować bibliotekę natywną, aby została zainicjalizowana przed innymi bibliotekami JNI (np. aby włączyć process-local telemetry/logging). Możesz wstrzyknąć wywołanie System.loadLibrary() w statycznym inicjalizatorze lub wcześnie w Application.onCreate(). Przykładowy smali dla statycznego inicjalizatora klasy (): +Czasami trzeba wstępnie załadować bibliotekę natywną, aby zainicjowała się przed innymi bibliotekami JNI (np. aby umożliwić telemetrię/logowanie lokalne dla procesu). Możesz wstrzyknąć wywołanie System.loadLibrary() w static initializer lub wcześnie w Application.onCreate(). Przykład smali dla static class initializer (): ```smali .class public Lcom/example/App; .super Landroid/app/Application; @@ -176,7 +176,7 @@ invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V return-void .end method ``` -Alternatywnie, umieść te same dwie instrukcje na początku Application.onCreate(), aby zapewnić, że biblioteka załaduje się jak najwcześniej: +Alternatywnie umieść te same dwie instrukcje na początku metody Application.onCreate(), aby upewnić się, że biblioteka zostanie załadowana jak najwcześniej: ```smali .method public onCreate()V .locals 1 @@ -189,11 +189,11 @@ return-void .end method ``` Uwagi: -- Upewnij się, że właściwy wariant ABI biblioteki znajduje się w lib// (np. arm64-v8a/armeabi-v7a), aby uniknąć UnsatisfiedLinkError. -- Wczesne załadowanie (class static initializer) gwarantuje, że native logger będzie mógł obserwować późniejszą aktywność JNI. +- Upewnij się, że odpowiedni wariant ABI biblioteki znajduje się w lib// (np. arm64-v8a/armeabi-v7a), aby uniknąć UnsatisfiedLinkError. +- Wczesne załadowanie (class static initializer) gwarantuje, że native logger będzie mógł obserwować późniejsze aktywności JNI. ## Źródła -- SoTap: Lekki logger zachowania JNI (.so) w aplikacji – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- SoTap: Lekki wbudowany logger zachowań JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) {{#include ../../banners/hacktricks-training.md}}